From 6071fc3a47b514f8da50e92be4f0d2307faa8313 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Wed, 26 Jun 2024 15:38:52 +0200 Subject: [PATCH 01/78] naive conformal prediction --- darts/models/__init__.py | 3 + darts/models/cp/conformal_model.py | 436 +++++++++++++++++++++++++++++ 2 files changed, 439 insertions(+) create mode 100644 darts/models/cp/conformal_model.py diff --git a/darts/models/__init__.py b/darts/models/__init__.py index 17640b195d..361c4018e1 100644 --- a/darts/models/__init__.py +++ b/darts/models/__init__.py @@ -108,6 +108,8 @@ except ImportError: XGBModel = NotImportedModule(module_name="XGBoost") +# Conformal Prediction +from darts.models.cp.conformal_model import ConformalModel from darts.models.filtering.gaussian_process_filter import GaussianProcessFilter from darts.models.filtering.kalman_filter import KalmanFilter @@ -165,4 +167,5 @@ "MovingAverageFilter", "NaiveEnsembleModel", "EnsembleModel", + "ConformalModel", ] diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py new file mode 100644 index 0000000000..7e9ce13013 --- /dev/null +++ b/darts/models/cp/conformal_model.py @@ -0,0 +1,436 @@ +import re +from typing import Any, List, Optional, Sequence, Tuple, Union + +import numpy as np +import pandas as pd + +from darts import TimeSeries +from darts.logging import get_logger, raise_log +from darts.models.forecasting.forecasting_model import GlobalForecastingModel +from darts.utils.ts_utils import SeriesType, get_series_seq_type, series2seq + +logger = get_logger(__name__) + + +def cqr_score_sym(row, quantile_lo_col, quantile_hi_col): + return ( + [None, None] + if row[quantile_lo_col] is None or row[quantile_hi_col] is None + else [ + max(row[quantile_lo_col] - row["y"], row["y"] - row[quantile_hi_col]), + 0 + if row[quantile_lo_col] - row["y"] > row["y"] - row[quantile_hi_col] + else 1, + ] + ) + + +def cqr_score_asym(row, quantile_lo_col, quantile_hi_col): + return ( + [None, None] + if row[quantile_lo_col] is None or row[quantile_hi_col] is None + else [ + row[quantile_lo_col] - row["y"], + row["y"] - row[quantile_hi_col], + 0 + if row[quantile_lo_col] - row["y"] > row["y"] - row[quantile_hi_col] + else 1, + ] + ) + + +class ConformalModel(GlobalForecastingModel): + def __init__( + self, + model, + alpha: Union[float, Tuple[float, float]], + method: str, + quantiles: Optional[List[float]] = None, + ): + """Conformal prediction dataclass + + Parameters + ---------- + model + The forecasting model. + alpha + Significance level of the prediction interval, float if coverage error spread arbitrarily over left and + right tails, tuple of two floats for different coverage error over left and right tails respectively + method + The conformal prediction technique to use: + + - `"naive"` for the Naive or Absolute Residual method + - `"cqr"` for Conformalized Quantile Regression + quantiles + Optionally, a list of quantiles from the quantile regression `model` to use. + """ + if not isinstance(model, GlobalForecastingModel) or not model._fit_called: + raise_log( + ValueError("`model` must be a pre-trained `GlobalForecastingModel`."), + logger=logger, + ) + if method == "naive" and not isinstance(alpha, float): + raise_log( + ValueError(f"`alpha` must be a `float` when `method={method}`."), + logger=logger, + ) + super().__init__(add_encoders=None) + + if isinstance(alpha, float): + self.symmetrical = True + self.q_hats = pd.DataFrame(columns=["q_hat_sym"]) + else: + self.symmetrical = False + self.alpha_lo, self.alpha_hi = alpha + self.q_hats = pd.DataFrame(columns=["q_hat_lo", "q_hat_hi"]) + + self.model = model + self.noncon_scores = dict() + self.alpha = alpha + self.method = method + self.quantiles = quantiles + self._fit_called = True + + @property + def output_chunk_length(self) -> Optional[int]: + return self.model.output_chunk_length + + def fit( + self, + series: Union[TimeSeries, Sequence[TimeSeries]], + past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + ) -> "ConformalModel": + # does not have to be trained + return self + + def predict( + self, + n: int, + series: Union[TimeSeries, Sequence[TimeSeries]] = None, + past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + num_samples: int = 1, + verbose: bool = False, + predict_likelihood_parameters: bool = False, + show_warnings: bool = True, + ) -> Union[TimeSeries, Sequence[TimeSeries]]: + called_with_single_series = get_series_seq_type(series) == SeriesType.SINGLE + series = series2seq(series) + past_covariates = series2seq(past_covariates) + future_covariates = series2seq(future_covariates) + + preds = self.model.predict( + n=n, + series=series, + past_covariates=past_covariates, + future_covariates=future_covariates, + num_samples=num_samples, + verbose=verbose, + predict_likelihood_parameters=predict_likelihood_parameters, + show_warnings=show_warnings, + ) + preds = series2seq(preds) + + residuals = self.model.residuals( + series=series, + past_covariates=past_covariates, + future_covariates=future_covariates, + forecast_horizon=n, + last_points_only=False, + retrain=False, + stride=1, + verbose=verbose, + show_warnings=show_warnings, + values_only=True, + ) + if self.method != "naive": + raise_log(NotImplementedError("non-naive not yet implemented")) + + # first: NAIVE only + cp_preds = [] + for res, pred in zip(residuals, preds): + # convert to (horizon, n comps, hist fcs) + res = np.concatenate(res, axis=2) + q_hat = np.quantile(res, q=self.alpha, axis=2) + pred_vals = pred.values(copy=False) + cp_pred = np.concatenate( + [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 + ) + # TODO: use `_build_forecast_series` as in `pl_forecasting_module.py` + cp_pred = TimeSeries.from_times_and_values( + times=pred._time_index, + values=cp_pred, + ) + cp_preds.append(cp_pred) + + return cp_preds[0] if called_with_single_series else cp_preds + # for step_number in range(1, self.n_forecasts + 1): + # # conformalize + # noncon_scores = self._get_nonconformity_scores(df_cal, step_number) + # q_hat = self._get_q_hat(df_cal, noncon_scores) + # y_hat_col = f"yhat{step_number}" + # y_hat_lo_col = f"{y_hat_col} {min(self.quantiles) * 100}%" + # y_hat_hi_col = f"{y_hat_col} {max(self.quantiles) * 100}%" + # if self.method == "naive" and self.symmetrical: + # q_hat_sym = q_hat["q_hat_sym"] + # df[y_hat_lo_col] = df[y_hat_col] - q_hat_sym + # df[y_hat_hi_col] = df[y_hat_col] + q_hat_sym + # elif self.method == "cqr" and self.symmetrical: + # q_hat_sym = q_hat["q_hat_sym"] + # df[y_hat_lo_col] = df[y_hat_lo_col] - q_hat_sym + # df[y_hat_hi_col] = df[y_hat_hi_col] + q_hat_sym + # elif self.method == "cqr" and not self.symmetrical: + # q_hat_lo = q_hat["q_hat_lo"] + # q_hat_hi = q_hat["q_hat_hi"] + # df[y_hat_lo_col] = df[y_hat_lo_col] - q_hat_lo + # df[y_hat_hi_col] = df[y_hat_hi_col] + q_hat_hi + # else: + # raise ValueError( + # f"Unknown conformal prediction method '{self.method}'. Please input either 'naive' or 'cqr'." + # ) + # if step_number == 1: + # # save nonconformity scores of the first timestep + # self.noncon_scores = noncon_scores + # + # # append the dictionary of q_hats to the dataframe based on the keys of the dictionary + # q_hat_df = pd.DataFrame([q_hat]) + # self.q_hats = pd.concat([self.q_hats, q_hat_df], ignore_index=True) + # + # # if show_all_PI is True, add the quantile regression prediction intervals + # if show_all_PI: + # df_quantiles = [col for col in df_qr.columns if "%" in col and f"yhat{step_number}" in col] + # df_add = df_qr[df_quantiles] + # + # if self.method == "naive": + # cp_lo_col = f"yhat{step_number} - qhat{step_number}" # e.g. yhat1 - qhat1 + # cp_hi_col = f"yhat{step_number} + qhat{step_number}" # e.g. yhat1 + qhat1 + # df.rename(columns={y_hat_lo_col: cp_lo_col, y_hat_hi_col: cp_hi_col}, inplace=True) + # elif self.method == "cqr": + # qr_lo_col = ( + # f"yhat{step_number} {max(self.quantiles) * 100}% - qhat{step_number}" #e.g. yhat1 95% - qhat1 + # ) + # qr_hi_col = ( + # f"yhat{step_number} {min(self.quantiles) * 100}% + qhat{step_number}" #e.g. yhat1 5% + qhat1 + # ) + # df.rename(columns={y_hat_lo_col: qr_lo_col, y_hat_hi_col: qr_hi_col}, inplace=True) + # + # df = pd.concat([df, df_add], axis=1, ignore_index=False) + # + # return df + + def _get_nonconformity_scores(self, df_cal: pd.DataFrame, step_number: int) -> dict: + """Get the nonconformity scores using the given conformal prediction technique. + + Parameters + ---------- + df_cal : pd.DataFrame + calibration dataframe + step_number : int + i-th step ahead forecast + + Returns + ------- + Dict[str, np.ndarray] + dictionary with one entry (symmetrical) or two entries (asymmetrical) of nonconformity scores + + """ + y_hat_col = f"yhat{step_number}" + if self.method == "cqr": + # CQR nonconformity scoring function + quantile_lo = str(min(self.quantiles) * 100) + quantile_hi = str(max(self.quantiles) * 100) + quantile_lo_col = f"{y_hat_col} {quantile_lo}%" + quantile_hi_col = f"{y_hat_col} {quantile_hi}%" + if self.symmetrical: + scores_df = df_cal.apply( + cqr_score_sym, + axis=1, + result_type="expand", + quantile_lo_col=quantile_lo_col, + quantile_hi_col=quantile_hi_col, + ) + scores_df.columns = ["scores", "arg"] + noncon_scores = scores_df["scores"].values + else: # asymmetrical intervals + scores_df = df_cal.apply( + cqr_score_asym, + axis=1, + result_type="expand", + quantile_lo_col=quantile_lo_col, + quantile_hi_col=quantile_hi_col, + ) + scores_df.columns = ["scores_lo", "scores_hi", "arg"] + noncon_scores_lo = scores_df["scores_lo"].values + noncon_scores_hi = scores_df["scores_hi"].values + # Remove NaN values + noncon_scores_lo: Any = noncon_scores_lo[~pd.isnull(noncon_scores_lo)] + noncon_scores_hi: Any = noncon_scores_hi[~pd.isnull(noncon_scores_hi)] + # Sort + noncon_scores_lo.sort() + noncon_scores_hi.sort() + # return dict of nonconformity scores + return { + "noncon_scores_hi": noncon_scores_lo, + "noncon_scores_lo": noncon_scores_hi, + } + else: # self.method == "naive" + # Naive nonconformity scoring function + noncon_scores = abs(df_cal["y"] - df_cal[y_hat_col]).values + # Remove NaN values + noncon_scores: Any = noncon_scores[~pd.isnull(noncon_scores)] + # Sort + noncon_scores.sort() + + return {"noncon_scores": noncon_scores} + + def _get_q_hat(self, noncon_scores: dict) -> dict: + """Get the q_hat that is derived from the nonconformity scores. + + Parameters + ---------- + noncon_scores : dict + dictionary with one entry (symmetrical) or two entries (asymmetrical) of nonconformity scores + + Returns + ------- + Dict[str, float] + upper and lower q_hat value, or the one-sided prediction interval width + + """ + # Get the q-hat index and value + if self.method == "cqr" and self.symmetrical is False: + noncon_scores_lo = noncon_scores["noncon_scores_lo"] + noncon_scores_hi = noncon_scores["noncon_scores_hi"] + q_hat_idx_lo = int(len(noncon_scores_lo) * self.alpha_lo) + q_hat_idx_hi = int(len(noncon_scores_hi) * self.alpha_hi) + q_hat_lo = noncon_scores_lo[-q_hat_idx_lo] + q_hat_hi = noncon_scores_hi[-q_hat_idx_hi] + return {"q_hat_lo": q_hat_lo, "q_hat_hi": q_hat_hi} + else: + noncon_scores = noncon_scores["noncon_scores"] + q_hat_idx = int(len(noncon_scores) * self.alpha) + q_hat = noncon_scores[-q_hat_idx] + return {"q_hat_sym": q_hat} + + @property + def _model_encoder_settings( + self, + ) -> Tuple[ + Optional[int], + Optional[int], + bool, + bool, + Optional[List[int]], + Optional[List[int]], + ]: + return None, None, False, False, None, None + + def extreme_lags( + self, + ) -> Tuple[ + Optional[int], + Optional[int], + Optional[int], + Optional[int], + Optional[int], + Optional[int], + int, + Optional[int], + ]: + return self.model.extreme_lags + + def supports_multivariate(self) -> bool: + return self.model.supports_multivariate + + +def uncertainty_evaluate(df_forecast: pd.DataFrame) -> pd.DataFrame: + """Evaluate conformal prediction on test dataframe. + + Parameters + ---------- + df_forecast : pd.DataFrame + forecast dataframe with the conformal prediction intervals + + Returns + ------- + pd.DataFrame + table containing evaluation metrics such as interval_width and miscoverage_rate + """ + # Remove beginning rows used as lagged regressors (if any), or future dataframes without y-values + # therefore, this ensures that all forecast rows for evaluation contains both y and y-hat + df_forecast_eval = df_forecast.dropna(subset=["y", "yhat1"]).reset_index(drop=True) + + # Get evaluation params + df_eval = pd.DataFrame() + cols = df_forecast_eval.columns + yhat_cols = [col for col in cols if "%" in col] + n_forecasts = int(re.search("yhat(\\d+)", yhat_cols[-1]).group(1)) + + # get the highest and lowest quantile percentages + quantiles = [] + for col in yhat_cols: + match = re.search(r"\d+\.\d+", col) + if match: + quantiles.append(float(match.group())) + quantiles = sorted(set(quantiles)) + + # Begin conformal evaluation steps + for step_number in range(1, n_forecasts + 1): + y = df_forecast_eval["y"].values + # only relevant if show_all_PI is true + if len([col for col in cols if "qhat" in col]) > 0: + qhat_cols = [col for col in cols if f"qhat{step_number}" in col] + yhat_lo = df_forecast_eval[qhat_cols[0]].values + yhat_hi = df_forecast_eval[qhat_cols[-1]].values + else: + yhat_lo = df_forecast_eval[f"yhat{step_number} {quantiles[0]}%"].values + yhat_hi = df_forecast_eval[f"yhat{step_number} {quantiles[-1]}%"].values + interval_width, miscoverage_rate = _get_evaluate_metrics_from_dataset( + y, yhat_lo, yhat_hi + ) + + # Construct row dataframe with current timestep using its q-hat, interval width, and miscoverage rate + col_names = ["interval_width", "miscoverage_rate"] + row = [interval_width, miscoverage_rate] + df_row = pd.DataFrame( + [row], + columns=pd.MultiIndex.from_product([[f"yhat{step_number}"], col_names]), + ) + + # Add row dataframe to overall evaluation dataframe with all forecasted timesteps + df_eval = pd.concat([df_eval, df_row], axis=1) + + return df_eval + + +def _get_evaluate_metrics_from_dataset( + y: np.ndarray, yhat_lo: np.ndarray, yhat_hi: np.ndarray +) -> Tuple[float, float]: + # df_forecast_eval: pd.DataFrame, + # quantile_lo_col: str, + # quantile_hi_col: str, + # ) -> Tuple[float, float]: + """Infers evaluation parameters based on the evaluation dataframe columns. + + Parameters + ---------- + df_forecast_eval : pd.DataFrame + forecast dataframe with the conformal prediction intervals + + Returns + ------- + float, float + conformal prediction evaluation metrics + """ + # Interval width (efficiency metric) + quantile_lo_mean = np.mean(yhat_lo) + quantile_hi_mean = np.mean(yhat_hi) + interval_width = quantile_hi_mean - quantile_lo_mean + + # Miscoverage rate (validity metric) + n_covered = np.sum((y >= yhat_lo) & (y <= yhat_hi)) + coverage_rate = n_covered / len(y) + miscoverage_rate = 1 - coverage_rate + + return interval_width, miscoverage_rate From 2dbf28b922e818ffd5f5cd4ea9355b110c48161b Mon Sep 17 00:00:00 2001 From: dennisbader Date: Mon, 1 Jul 2024 11:16:32 +0200 Subject: [PATCH 02/78] first hist fc version works --- darts/models/cp/conformal_model.py | 136 ++++++++++++++++++++++++++++- 1 file changed, 133 insertions(+), 3 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 7e9ce13013..376b1922a7 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -1,5 +1,10 @@ import re -from typing import Any, List, Optional, Sequence, Tuple, Union +from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union + +try: + from typing import Literal +except ImportError: + from typing_extensions import Literal import numpy as np import pandas as pd @@ -7,7 +12,9 @@ from darts import TimeSeries from darts.logging import get_logger, raise_log from darts.models.forecasting.forecasting_model import GlobalForecastingModel +from darts.utils import _with_sanity_checks from darts.utils.ts_utils import SeriesType, get_series_seq_type, series2seq +from darts.utils.utils import n_steps_between logger = get_logger(__name__) @@ -130,8 +137,6 @@ def predict( predict_likelihood_parameters=predict_likelihood_parameters, show_warnings=show_warnings, ) - preds = series2seq(preds) - residuals = self.model.residuals( series=series, past_covariates=past_covariates, @@ -219,6 +224,130 @@ def predict( # # return df + @_with_sanity_checks("_historical_forecasts_sanity_checks") + def historical_forecasts( + self, + series: Union[TimeSeries, Sequence[TimeSeries]], + past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + num_samples: int = 1, + train_length: Optional[int] = None, + start: Optional[Union[pd.Timestamp, float, int]] = None, + start_format: Literal["position", "value"] = "value", + forecast_horizon: int = 1, + stride: int = 1, + retrain: Union[bool, int, Callable[..., bool]] = True, + overlap_end: bool = False, + last_points_only: bool = True, + verbose: bool = False, + show_warnings: bool = True, + predict_likelihood_parameters: bool = False, + enable_optimization: bool = True, + fit_kwargs: Optional[Dict[str, Any]] = None, + predict_kwargs: Optional[Dict[str, Any]] = None, + sample_weight: Optional[Union[TimeSeries, Sequence[TimeSeries], str]] = None, + ) -> Union[TimeSeries, List[TimeSeries], List[List[TimeSeries]]]: + called_with_single_series = get_series_seq_type(series) == SeriesType.SINGLE + series = series2seq(series) + past_covariates = series2seq(past_covariates) + future_covariates = series2seq(future_covariates) + + hfcs = self.model.historical_forecasts( + series=series, + past_covariates=past_covariates, + future_covariates=future_covariates, + num_samples=num_samples, + forecast_horizon=forecast_horizon, + retrain=False, + overlap_end=overlap_end, + last_points_only=False, + verbose=verbose, + show_warnings=show_warnings, + predict_likelihood_parameters=predict_likelihood_parameters, + enable_optimization=enable_optimization, + fit_kwargs=fit_kwargs, + predict_kwargs=predict_kwargs, + ) + # TODO: add support for: + # - overlap_end = True + # - last_points_only = True + # - add correct output components + # - use only `train_length` previous residuals + # - num_samples + # - predict_likelihood_parameters + # - tqdm iterator over series + # - support for different CP algorithms + # - compute all possible residuals (including the partial forecast horizons up until the end) + + residuals = self.model.residuals( + series=series, + historical_forecasts=hfcs, + last_points_only=False, + verbose=verbose, + show_warnings=show_warnings, + values_only=True, + ) + + # TODO: Generate Conformalized predictions per forecast + cp_hfcs = [] + for s_hfcs, res in zip(hfcs, residuals): + cp_preds = [] + + # no historical forecasts were generated + if not s_hfcs: + cp_hfcs.append(cp_preds) + continue + + # determine the first forecast index for which to compute conformal prediction; + # all forecasts before that are used for calibration + # skip based on `train_length` + skip_n_train_length = 0 + if train_length is not None: + if train_length > len(s_hfcs): + # ignore series where we don't have enough forecasts available + cp_hfcs.append(cp_preds) + continue + skip_n_train_length = train_length + + # skip based on `start` + skip_n_start = 0 + if start is not None: + if isinstance(start, pd.Timestamp) or start_format == "value": + skip_n_start = n_steps_between( + s_hfcs[0], start, freq=series[0].freq + ) + else: + # start is `int` and `start_format="position"` + skip_n_start = start if start >= 0 else start + len(series) + + # TODO: what should be the smallest number for calibration residuals - 0 or 1? + min_skip_n = 0 + skip_n = max([skip_n_train_length, skip_n_start, min_skip_n]) + + for idx, pred in enumerate(s_hfcs[skip_n::stride]): + # convert to (horizon, n comps, hist fcs) + pred_vals = pred.values(copy=False) + if not skip_n and not idx: + cp_pred = np.concatenate([pred_vals] * 3, axis=1) + else: + # TODO: should we consider all previous historical forecasts, or only the stridden ones? + # get the last residual index for calibration + cal_idx = skip_n + idx * stride + cal_res = np.concatenate(res[:cal_idx], axis=2) + q_hat = np.quantile(cal_res, q=self.alpha, axis=2) + cp_pred = np.concatenate( + [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 + ) + + # TODO: use `_build_forecast_series` as in `pl_forecasting_module.py` + cp_pred = TimeSeries.from_times_and_values( + times=pred._time_index, + values=cp_pred, + ) + cp_preds.append(cp_pred) + cp_hfcs.append(cp_preds) + return cp_hfcs[0] if called_with_single_series else cp_hfcs + def _get_nonconformity_scores(self, df_cal: pd.DataFrame, step_number: int) -> dict: """Get the nonconformity scores using the given conformal prediction technique. @@ -326,6 +455,7 @@ def _model_encoder_settings( ]: return None, None, False, False, None, None + @property def extreme_lags( self, ) -> Tuple[ From 6c18c7eace63cac82e25cf8143116f14bcbf646b Mon Sep 17 00:00:00 2001 From: dennisbader Date: Mon, 1 Jul 2024 11:42:43 +0200 Subject: [PATCH 03/78] add component names --- darts/models/cp/conformal_model.py | 44 +++++++++++++++++++--------- darts/utils/timeseries_generation.py | 23 ++++++++------- 2 files changed, 42 insertions(+), 25 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 376b1922a7..6f718f2a9a 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -13,6 +13,7 @@ from darts.logging import get_logger, raise_log from darts.models.forecasting.forecasting_model import GlobalForecastingModel from darts.utils import _with_sanity_checks +from darts.utils.timeseries_generation import _build_forecast_series from darts.utils.ts_utils import SeriesType, get_series_seq_type, series2seq from darts.utils.utils import n_steps_between @@ -154,7 +155,7 @@ def predict( # first: NAIVE only cp_preds = [] - for res, pred in zip(residuals, preds): + for series_, pred, res in zip(series, preds, residuals): # convert to (horizon, n comps, hist fcs) res = np.concatenate(res, axis=2) q_hat = np.quantile(res, q=self.alpha, axis=2) @@ -162,13 +163,15 @@ def predict( cp_pred = np.concatenate( [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 ) - # TODO: use `_build_forecast_series` as in `pl_forecasting_module.py` - cp_pred = TimeSeries.from_times_and_values( - times=pred._time_index, - values=cp_pred, + cp_pred = _build_forecast_series( + points_preds=cp_pred, + input_series=series_, + custom_columns=self._cp_component_names(series_), + time_index=pred._time_index, + with_static_covs=False, + with_hierarchy=False, ) cp_preds.append(cp_pred) - return cp_preds[0] if called_with_single_series else cp_preds # for step_number in range(1, self.n_forecasts + 1): # # conformalize @@ -271,7 +274,6 @@ def historical_forecasts( # TODO: add support for: # - overlap_end = True # - last_points_only = True - # - add correct output components # - use only `train_length` previous residuals # - num_samples # - predict_likelihood_parameters @@ -279,6 +281,8 @@ def historical_forecasts( # - support for different CP algorithms # - compute all possible residuals (including the partial forecast horizons up until the end) + # DONE: + # - add correct output components residuals = self.model.residuals( series=series, historical_forecasts=hfcs, @@ -290,7 +294,7 @@ def historical_forecasts( # TODO: Generate Conformalized predictions per forecast cp_hfcs = [] - for s_hfcs, res in zip(hfcs, residuals): + for series_, s_hfcs, res in zip(series, hfcs, residuals): cp_preds = [] # no historical forecasts were generated @@ -324,7 +328,10 @@ def historical_forecasts( min_skip_n = 0 skip_n = max([skip_n_train_length, skip_n_start, min_skip_n]) - for idx, pred in enumerate(s_hfcs[skip_n::stride]): + for ( + idx, + pred, + ) in enumerate(s_hfcs[skip_n::stride]): # convert to (horizon, n comps, hist fcs) pred_vals = pred.values(copy=False) if not skip_n and not idx: @@ -338,11 +345,13 @@ def historical_forecasts( cp_pred = np.concatenate( [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 ) - - # TODO: use `_build_forecast_series` as in `pl_forecasting_module.py` - cp_pred = TimeSeries.from_times_and_values( - times=pred._time_index, - values=cp_pred, + cp_pred = _build_forecast_series( + points_preds=cp_pred, + input_series=series_, + custom_columns=self._cp_component_names(series_), + time_index=pred._time_index, + with_static_covs=False, + with_hierarchy=False, ) cp_preds.append(cp_pred) cp_hfcs.append(cp_preds) @@ -442,6 +451,13 @@ def _get_q_hat(self, noncon_scores: dict) -> dict: q_hat = noncon_scores[-q_hat_idx] return {"q_hat_sym": q_hat} + def _cp_component_names(self, input_series) -> List[str]: + return [ + f"{tgt_name}_{param_n}" + for tgt_name in input_series.components + for param_n in ["q_lo", "q_md", "q_hi"] + ] + @property def _model_encoder_settings( self, diff --git a/darts/utils/timeseries_generation.py b/darts/utils/timeseries_generation.py index fded623916..833cb144f8 100644 --- a/darts/utils/timeseries_generation.py +++ b/darts/utils/timeseries_generation.py @@ -737,6 +737,7 @@ def _build_forecast_series( with_static_covs: bool = True, with_hierarchy: bool = True, pred_start: Optional[Union[pd.Timestamp, int]] = None, + time_index: Union[pd.DatetimeIndex, pd.RangeIndex] = None, ) -> TimeSeries: """ Builds a forecast time series starting after the end of an input time series, with the @@ -762,17 +763,17 @@ def _build_forecast_series( TimeSeries New TimeSeries instance starting after the input series """ - time_index_length = ( - len(points_preds) - if isinstance(points_preds, np.ndarray) - else len(points_preds[0]) - ) - - time_index = _generate_new_dates( - time_index_length, - input_series=input_series, - start=pred_start, - ) + if time_index is None: + time_index_length = ( + len(points_preds) + if isinstance(points_preds, np.ndarray) + else len(points_preds[0]) + ) + time_index = _generate_new_dates( + time_index_length, + input_series=input_series, + start=pred_start, + ) values = ( points_preds if isinstance(points_preds, np.ndarray) From 48d562a7e2aa55b0a83e042e306a4b3b4fd5598a Mon Sep 17 00:00:00 2001 From: dennisbader Date: Mon, 1 Jul 2024 12:59:44 +0200 Subject: [PATCH 04/78] add support for train length --- darts/models/cp/conformal_model.py | 29 ++++++++++++----------------- 1 file changed, 12 insertions(+), 17 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 6f718f2a9a..3a0dd64f1e 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -272,9 +272,8 @@ def historical_forecasts( predict_kwargs=predict_kwargs, ) # TODO: add support for: - # - overlap_end = True # - last_points_only = True - # - use only `train_length` previous residuals + # - overlap_end = True # - num_samples # - predict_likelihood_parameters # - tqdm iterator over series @@ -283,6 +282,7 @@ def historical_forecasts( # DONE: # - add correct output components + # - use only `train_length` previous residuals residuals = self.model.residuals( series=series, historical_forecasts=hfcs, @@ -298,31 +298,25 @@ def historical_forecasts( cp_preds = [] # no historical forecasts were generated - if not s_hfcs: + if not s_hfcs or train_length is not None and train_length > len(s_hfcs): cp_hfcs.append(cp_preds) continue # determine the first forecast index for which to compute conformal prediction; # all forecasts before that are used for calibration # skip based on `train_length` - skip_n_train_length = 0 - if train_length is not None: - if train_length > len(s_hfcs): - # ignore series where we don't have enough forecasts available - cp_hfcs.append(cp_preds) - continue - skip_n_train_length = train_length + skip_n_train_length = train_length if train_length is not None else 0 # skip based on `start` skip_n_start = 0 if start is not None: if isinstance(start, pd.Timestamp) or start_format == "value": - skip_n_start = n_steps_between( - s_hfcs[0], start, freq=series[0].freq - ) + start_ = start else: - # start is `int` and `start_format="position"` - skip_n_start = start if start >= 0 else start + len(series) + start_ = series_._time_index[start] + skip_n_start = n_steps_between( + start_, s_hfcs[0].start_time(), freq=series_.freq + ) # TODO: what should be the smallest number for calibration residuals - 0 or 1? min_skip_n = 0 @@ -339,8 +333,9 @@ def historical_forecasts( else: # TODO: should we consider all previous historical forecasts, or only the stridden ones? # get the last residual index for calibration - cal_idx = skip_n + idx * stride - cal_res = np.concatenate(res[:cal_idx], axis=2) + cal_end = skip_n + idx * stride + cal_start = None if train_length is None else cal_end - train_length + cal_res = np.concatenate(res[cal_start:cal_end], axis=2) q_hat = np.quantile(cal_res, q=self.alpha, axis=2) cp_pred = np.concatenate( [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 From 2c192adb450d9205834800048efb67bdc63f8777 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Mon, 1 Jul 2024 14:49:57 +0200 Subject: [PATCH 05/78] support for last points only --- darts/models/cp/conformal_model.py | 101 ++++++++++++++++++++--------- 1 file changed, 72 insertions(+), 29 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 3a0dd64f1e..6a7b75f573 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -14,8 +14,13 @@ from darts.models.forecasting.forecasting_model import GlobalForecastingModel from darts.utils import _with_sanity_checks from darts.utils.timeseries_generation import _build_forecast_series -from darts.utils.ts_utils import SeriesType, get_series_seq_type, series2seq -from darts.utils.utils import n_steps_between +from darts.utils.ts_utils import ( + SeriesType, + get_series_seq_type, + get_single_series, + series2seq, +) +from darts.utils.utils import generate_index, n_steps_between logger = get_logger(__name__) @@ -263,7 +268,7 @@ def historical_forecasts( forecast_horizon=forecast_horizon, retrain=False, overlap_end=overlap_end, - last_points_only=False, + last_points_only=last_points_only, verbose=verbose, show_warnings=show_warnings, predict_likelihood_parameters=predict_likelihood_parameters, @@ -272,7 +277,6 @@ def historical_forecasts( predict_kwargs=predict_kwargs, ) # TODO: add support for: - # - last_points_only = True # - overlap_end = True # - num_samples # - predict_likelihood_parameters @@ -281,12 +285,13 @@ def historical_forecasts( # - compute all possible residuals (including the partial forecast horizons up until the end) # DONE: + # - last_points_only = True # - add correct output components # - use only `train_length` previous residuals residuals = self.model.residuals( series=series, historical_forecasts=hfcs, - last_points_only=False, + last_points_only=last_points_only, verbose=verbose, show_warnings=show_warnings, values_only=True, @@ -315,41 +320,79 @@ def historical_forecasts( else: start_ = series_._time_index[start] skip_n_start = n_steps_between( - start_, s_hfcs[0].start_time(), freq=series_.freq + end=start_, + start=get_single_series(s_hfcs).start_time(), + freq=series_.freq, ) + # hfcs only contain last predicted points; skip until end of first forecast + if last_points_only: + skip_n_start += forecast_horizon - 1 # TODO: what should be the smallest number for calibration residuals - 0 or 1? min_skip_n = 0 skip_n = max([skip_n_train_length, skip_n_start, min_skip_n]) - for ( - idx, - pred, - ) in enumerate(s_hfcs[skip_n::stride]): - # convert to (horizon, n comps, hist fcs) - pred_vals = pred.values(copy=False) - if not skip_n and not idx: - cp_pred = np.concatenate([pred_vals] * 3, axis=1) - else: - # TODO: should we consider all previous historical forecasts, or only the stridden ones? - # get the last residual index for calibration - cal_end = skip_n + idx * stride - cal_start = None if train_length is None else cal_end - train_length - cal_res = np.concatenate(res[cal_start:cal_end], axis=2) - q_hat = np.quantile(cal_res, q=self.alpha, axis=2) - cp_pred = np.concatenate( - [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 - ) - cp_pred = _build_forecast_series( - points_preds=cp_pred, + if last_points_only: + for idx, pred_vals in enumerate( + s_hfcs.values(copy=False)[skip_n::stride] + ): + pred_vals = np.expand_dims(pred_vals, 0) + if not skip_n and not idx: + cp_pred = np.concatenate([pred_vals] * 3, axis=1) + else: + # get the last residual index for calibration + cal_end = skip_n + idx * stride + cal_start = ( + None if train_length is None else cal_end - train_length + ) + # TODO: should we consider all previous historical forecasts, or only the stridden ones? + cal_res = res[cal_start:cal_end] + q_hat = np.quantile(cal_res, q=self.alpha, axis=0) + cp_pred = np.concatenate( + [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 + ) + cp_preds.append(cp_pred) + cp_preds = _build_forecast_series( + points_preds=np.concatenate(cp_preds, axis=0), input_series=series_, custom_columns=self._cp_component_names(series_), - time_index=pred._time_index, + time_index=generate_index( + start=s_hfcs._time_index[skip_n], + length=len(cp_preds), + freq=series_.freq * stride, + ), with_static_covs=False, with_hierarchy=False, ) - cp_preds.append(cp_pred) - cp_hfcs.append(cp_preds) + cp_hfcs.append(cp_preds) + else: + for idx, pred in enumerate(s_hfcs[skip_n::stride]): + # convert to (horizon, n comps, hist fcs) + pred_vals = pred.values(copy=False) + if not skip_n and not idx: + cp_pred = np.concatenate([pred_vals] * 3, axis=1) + else: + # get the last residual index for calibration + cal_end = skip_n + idx * stride + cal_start = ( + None if train_length is None else cal_end - train_length + ) + # TODO: should we consider all previous historical forecasts, or only the stridden ones? + cal_res = np.concatenate(res[cal_start:cal_end], axis=2) + q_hat = np.quantile(cal_res, q=self.alpha, axis=2) + cp_pred = np.concatenate( + [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 + ) + cp_pred = _build_forecast_series( + points_preds=cp_pred, + input_series=series_, + custom_columns=self._cp_component_names(series_), + time_index=pred._time_index, + with_static_covs=False, + with_hierarchy=False, + ) + cp_preds.append(cp_pred) + cp_hfcs.append(cp_preds) return cp_hfcs[0] if called_with_single_series else cp_hfcs def _get_nonconformity_scores(self, df_cal: pd.DataFrame, step_number: int) -> dict: From cdbc6ce2f761a1589fa4fa0b8771adc3ab45de51 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Tue, 2 Jul 2024 09:40:47 +0200 Subject: [PATCH 06/78] add hist fc unit tests --- .../forecasting/test_historical_forecasts.py | 165 +++++++++++++++++- 1 file changed, 159 insertions(+), 6 deletions(-) diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index 5281261ad2..968736539a 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -13,6 +13,7 @@ ARIMA, AutoARIMA, CatBoostModel, + ConformalModel, LightGBMModel, LinearRegressionModel, NaiveDrift, @@ -1360,13 +1361,13 @@ def f_encoder(idx): assert ohfc[0].start_time() == first_ts_expected # check hist fc end assert ohfc[-1].end_time() == last_ts_expected - for hfc, ohfc in zip(hfc, ohfc): - assert hfc.columns.equals(series.columns) - assert ohfc.columns.equals(series.columns) - assert len(ohfc) == n_pred_points_expected - assert (hfc.time_index == ohfc.time_index).all() + for hfc_, ohfc_ in zip(hfc, ohfc): + assert hfc_.columns.equals(series.columns) + assert ohfc_.columns.equals(series.columns) + assert len(ohfc_) == n_pred_points_expected + assert (hfc_.time_index == ohfc_.time_index).all() np.testing.assert_array_almost_equal( - hfc.all_values(), ohfc.all_values() + hfc_.all_values(), ohfc_.all_values() ) def test_hist_fc_end_exact_with_covs(self): @@ -2512,3 +2513,155 @@ def test_sample_weight(self, config): == f"`sample_weight` at series index {invalid_idx} must contain " f"at least all times of the corresponding target `series`." ) + + @pytest.mark.slow + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") + @pytest.mark.parametrize( + "config", + list( + itertools.product( + [False, True], # use covariates + [True, False], # last points only + [True, False], # overlap end + [1, 3], # stride + [ + 3, # horizon < ocl + 5, # horizon == ocl + 7, # horizon > ocl -> autoregression + ], + [False, True], # use integer indexed series + [False, True], # use multi-series + ) + ), + ) + def test_conformal_historical_forecasts(self, config): + """Tests naive conformal model.""" + ( + use_covs, + last_points_only, + overlap_end, + stride, + horizon, + use_int_idx, + use_multi_series, + ) = config + icl = 3 + ocl = 5 + len_val_series = 10 + series_train, series_val = ( + self.ts_pass_train[:10], + self.ts_pass_val[:len_val_series], + ) + if use_int_idx: + series_train = TimeSeries.from_values( + series_train.all_values(), columns=series_train.columns + ) + series_val = TimeSeries.from_times_and_values( + values=series_val.all_values(), + times=pd.RangeIndex( + start=series_train.end_time() + series_train.freq, + stop=series_train.end_time() + + (len(series_val) + 1) * series_train.freq, + step=series_train.freq, + ), + columns=series_train.columns, + ) + + model_kwargs = ( + {} + if not use_covs + else {"lags_past_covariates": icl, "lags_future_covariates": (icl, ocl)} + ) + forecasting_model = LinearRegressionModel( + lags=icl, output_chunk_length=ocl, **model_kwargs + ) + if use_covs: + pc = tg.gaussian_timeseries( + start=series_train.start_time(), + end=series_val.end_time() + max(0, horizon - ocl) * series_train.freq, + freq=series_train.freq, + ) + fc = tg.gaussian_timeseries( + start=series_train.start_time(), + end=series_val.end_time() + max(ocl, horizon) * series_train.freq, + freq=series_train.freq, + ) + else: + pc, fc = None, None + + forecasting_model.fit(series_train, past_covariates=pc, future_covariates=fc) + + model = ConformalModel(forecasting_model, alpha=0.8, method="naive") + + if use_multi_series: + series_val = [ + series_val, + (series_val + 10) + .shift(1) + .with_columns_renamed(series_val.columns, "test_col"), + ] + pc = [pc, pc.shift(1)] if pc is not None else None + fc = [fc, fc.shift(1)] if fc is not None else None + + hist_fct = model.historical_forecasts( + series=series_val, + past_covariates=pc, + future_covariates=fc, + retrain=False, + last_points_only=last_points_only, + overlap_end=overlap_end, + stride=stride, + forecast_horizon=horizon, + ) + + if not isinstance(series_val, list): + series_val = [series_val] + hist_fct = [hist_fct] + + for ( + series, + hfc, + ) in zip(series_val, hist_fct): + if not isinstance(hfc, list): + hfc = [hfc] + + if not last_points_only and overlap_end: + n_pred_series_expected = 8 + n_pred_points_expected = horizon + first_ts_expected = series.time_index[icl] + last_ts_expected = series.end_time() + series.freq * horizon + elif not last_points_only: # overlap_end = False + n_pred_series_expected = len(series) - icl - horizon + 1 + n_pred_points_expected = horizon + first_ts_expected = series.time_index[icl] + last_ts_expected = series.end_time() + elif overlap_end: # last_points_only = True + n_pred_series_expected = 1 + n_pred_points_expected = 8 + first_ts_expected = series.time_index[icl] + (horizon - 1) * series.freq + last_ts_expected = series.end_time() + series.freq * horizon + else: # last_points_only = True, overlap_end = False + n_pred_series_expected = 1 + n_pred_points_expected = len(series) - icl - horizon + 1 + first_ts_expected = series.time_index[icl] + (horizon - 1) * series.freq + last_ts_expected = series.end_time() + + # to make it simple in case of stride, we assume that non-optimized hist fc returns correct results + if stride > 1: + n_pred_series_expected = len(hfc) + n_pred_points_expected = len(hfc[0]) + first_ts_expected = hfc[0].start_time() + last_ts_expected = hfc[-1].end_time() + + cols_excpected = [] + for col in series.columns: + cols_excpected += [f"{col}_q_lo", f"{col}_q_md", f"{col}_q_hi"] + # check length match between optimized and default hist fc + assert len(hfc) == n_pred_series_expected + # check hist fc start + assert hfc[0].start_time() == first_ts_expected + # check hist fc end + assert hfc[-1].end_time() == last_ts_expected + for hfc_ in hfc: + assert hfc_.columns.tolist() == cols_excpected + assert len(hfc_) == n_pred_points_expected From 8c54a7d90749370177bc4e3e7fb041e8f7fc89db Mon Sep 17 00:00:00 2001 From: dennisbader Date: Tue, 2 Jul 2024 09:55:46 +0200 Subject: [PATCH 07/78] add first conformal unit tests --- .../forecasting/test_conformal_model.py | 368 ++++++++++++++++++ .../forecasting/test_regression_models.py | 10 +- 2 files changed, 372 insertions(+), 6 deletions(-) create mode 100644 darts/tests/models/forecasting/test_conformal_model.py diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py new file mode 100644 index 0000000000..30c875831e --- /dev/null +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -0,0 +1,368 @@ +import functools +import itertools + +import numpy as np +import pandas as pd +import pytest + +from darts import TimeSeries +from darts.logging import get_logger +from darts.models import ( + ConformalModel, + LinearRegressionModel, + NaiveSeasonal, +) +from darts.utils import timeseries_generation as tg + +logger = get_logger(__name__) + + +def train_test_split(series, split_ts): + """ + Splits all provided TimeSeries instances into train and test sets according to the provided timestamp. + + Parameters + ---------- + features : TimeSeries + Feature TimeSeries instances to be split. + target : TimeSeries + Target TimeSeries instance to be split. + split_ts : TimeStamp + Time stamp indicating split point. + + Returns + ------- + TYPE + 4-tuple of the form (train_features, train_target, test_features, test_target) + """ + if isinstance(series, TimeSeries): + return series.split_after(split_ts) + else: + return list(zip(*[ts.split_after(split_ts) for ts in series])) + + +def dummy_timeseries( + length, + n_series=1, + comps_target=1, + comps_pcov=1, + comps_fcov=1, + multiseries_offset=0, + pcov_offset=0, + fcov_offset=0, + comps_stride=100, + type_stride=10000, + series_stride=1000000, + target_start_value=1, + first_target_start_date=pd.Timestamp("2000-01-01"), + freq="D", + integer_index=False, +): + targets, pcovs, fcovs = [], [], [] + for series_idx in range(n_series): + target_start_date = ( + series_idx * multiseries_offset + if integer_index + else first_target_start_date + + pd.Timedelta(series_idx * multiseries_offset, unit=freq) + ) + pcov_start_date = ( + target_start_date + pcov_offset + if integer_index + else target_start_date + pd.Timedelta(pcov_offset, unit=freq) + ) + fcov_start_date = ( + target_start_date + fcov_offset + if integer_index + else target_start_date + pd.Timedelta(fcov_offset, unit=freq) + ) + + target_start_val = target_start_value + series_stride * series_idx + pcov_start_val = target_start_val + type_stride + fcov_start_val = target_start_val + 2 * type_stride + + target_ts = None + pcov_ts = None + fcov_ts = None + + for idx in range(comps_target): + start = target_start_val + idx * comps_stride + curr_ts = tg.linear_timeseries( + start_value=start, + end_value=start + length - 1, + start=target_start_date, + length=length, + freq=freq, + column_name=f"{series_idx}-trgt-{idx}", + ) + target_ts = target_ts.stack(curr_ts) if target_ts else curr_ts + for idx in range(comps_pcov): + start = pcov_start_val + idx * comps_stride + curr_ts = tg.linear_timeseries( + start_value=start, + end_value=start + length - 1, + start=pcov_start_date, + length=length, + freq=freq, + column_name=f"{series_idx}-pcov-{idx}", + ) + pcov_ts = pcov_ts.stack(curr_ts) if pcov_ts else curr_ts + for idx in range(comps_fcov): + start = fcov_start_val + idx * comps_stride + curr_ts = tg.linear_timeseries( + start_value=start, + end_value=start + length - 1, + start=fcov_start_date, + length=length, + freq=freq, + column_name=f"{series_idx}-fcov-{idx}", + ) + fcov_ts = fcov_ts.stack(curr_ts) if fcov_ts else curr_ts + + targets.append(target_ts) + pcovs.append(pcov_ts) + fcovs.append(fcov_ts) + + return targets, pcovs, fcovs + + +# helper function used to register LightGBMModel/LinearRegressionModel with likelihood +def partialclass(cls, *args, **kwargs): + class NewCls(cls): + __init__ = functools.partialmethod(cls.__init__, *args, **kwargs) + + return NewCls + + +class TestRegressionModels: + np.random.seed(42) + # default regression models + models = [LinearRegressionModel] + + # register likelihood regression models + QuantileLinearRegressionModel = partialclass( + LinearRegressionModel, + likelihood="quantile", + quantiles=[0.05, 0.5, 0.95], + random_state=42, + ) + # targets for poisson regression must be positive, so we exclude them for some tests + models.extend([ + QuantileLinearRegressionModel, + ]) + + univariate_accuracies = [ + 1e-13, # LinearRegressionModel + 0.8, # QuantileLinearRegressionModel + ] + multivariate_accuracies = [ + 1e-13, # LinearRegressionModel + 0.8, # QuantileLinearRegressionModel + ] + multivariate_multiseries_accuracies = [ + 1e-13, # LinearRegressionModel + 0.8, # QuantileLinearRegressionModel + ] + + # dummy feature and target TimeSeries instances + target_series, past_covariates, future_covariates = dummy_timeseries( + length=100, + n_series=3, + comps_target=3, + comps_pcov=2, + comps_fcov=1, + multiseries_offset=10, + pcov_offset=0, + fcov_offset=0, + ) + # shift sines to positive values for poisson regressors + sine_univariate1 = tg.sine_timeseries(length=100) + 1.5 + sine_univariate2 = tg.sine_timeseries(length=100, value_phase=1.5705) + 1.5 + sine_univariate3 = tg.sine_timeseries(length=100, value_phase=0.78525) + 1.5 + sine_univariate4 = tg.sine_timeseries(length=100, value_phase=0.392625) + 1.5 + sine_univariate5 = tg.sine_timeseries(length=100, value_phase=0.1963125) + 1.5 + sine_univariate6 = tg.sine_timeseries(length=100, value_phase=0.09815625) + 1.5 + sine_multivariate1 = sine_univariate1.stack(sine_univariate2) + sine_multivariate2 = sine_univariate2.stack(sine_univariate3) + sine_multiseries1 = [sine_univariate1, sine_univariate2, sine_univariate3] + sine_multiseries2 = [sine_univariate4, sine_univariate5, sine_univariate6] + + lags_1 = {"target": [-3, -2, -1], "past": [-4, -2], "future": [-5, 2]} + + def test_model_construction(self): + local_model = NaiveSeasonal(K=5) + global_model = LinearRegressionModel(lags=5, output_chunk_length=1) + series = self.target_series[0][:10] + + method = "naive" + model_err_msg = "`model` must be a pre-trained `GlobalForecastingModel`." + # un-trained local model + with pytest.raises(ValueError) as exc: + ConformalModel(model=local_model, alpha=0.8, method=method) + assert str(exc.value) == model_err_msg + + # pre-trained local model + local_model.fit(series) + with pytest.raises(ValueError) as exc: + ConformalModel(model=local_model, alpha=0.8, method=method) + assert str(exc.value) == model_err_msg + + # un-trained global model + with pytest.raises(ValueError) as exc: + ConformalModel(model=global_model, alpha=0.8, method=method) + assert str(exc.value) == model_err_msg + + # pre-trained local model should work + global_model.fit(series) + _ = ConformalModel(model=global_model, alpha=0.8, method=method) + + @pytest.mark.parametrize("model_cls", models) + def test_predict_runnability(self, model_cls): + # testing lags_past_covariates None but past_covariates during prediction + model_instance = model_cls(lags=4, lags_past_covariates=None) + model_instance.fit(self.sine_univariate1) + model = ConformalModel(model_instance, alpha=0.8, method="naive") + # cannot pass past covariates + with pytest.raises(ValueError): + model.predict( + n=1, + series=self.sine_univariate1, + past_covariates=self.sine_multivariate1, + ) + # works without covariates + model.predict(n=1, series=self.sine_univariate1) + + # testing lags_past_covariates but no past_covariates during prediction + model_instance = model_cls(lags=4, lags_past_covariates=3) + # make multi series fit so no training set is stored + model_instance.fit( + [self.sine_univariate1] * 2, past_covariates=[self.sine_univariate1] * 2 + ) + model = ConformalModel(model_instance, alpha=0.8, method="naive") + with pytest.raises(ValueError) as exc: + model.predict(n=1, series=self.sine_univariate1) + assert ( + str(exc.value) == "The model has been trained with past covariates. " + "Some matching past_covariates have to be provided to `predict()`." + ) + # works with covariates + model.predict( + n=1, series=self.sine_univariate1, past_covariates=self.sine_univariate1 + ) + # too short covariates + with pytest.raises(ValueError) as exc: + model.predict( + n=1, + series=self.sine_univariate1, + past_covariates=self.sine_univariate1[:-1], + ) + assert str(exc.value).startswith( + "The `past_covariates` at list/sequence index 0 are not long enough." + ) + + # testing lags_future_covariates but no future_covariates during prediction + model_instance = model_cls(lags=4, lags_future_covariates=(3, 0)) + # make multi series fit so no training set is stored + model_instance.fit( + [self.sine_univariate1] * 2, future_covariates=[self.sine_univariate1] * 2 + ) + model = ConformalModel(model_instance, alpha=0.8, method="naive") + with pytest.raises(ValueError) as exc: + model.predict(n=1, series=self.sine_univariate1) + assert ( + str(exc.value) == "The model has been trained with future covariates. " + "Some matching future_covariates have to be provided to `predict()`." + ) + # works with covariates + model.predict( + n=1, series=self.sine_univariate1, future_covariates=self.sine_univariate1 + ) + with pytest.raises(ValueError) as exc: + model.predict( + n=1, + series=self.sine_univariate1, + future_covariates=self.sine_univariate1[:-1], + ) + assert str(exc.value).startswith( + "The `future_covariates` at list/sequence index 0 are not long enough." + ) + + # test input dim + model_instance = model_cls(lags=4) + model_instance.fit(self.sine_univariate1) + model = ConformalModel(model_instance, alpha=0.8, method="naive") + with pytest.raises(ValueError) as exc: + model.predict( + n=1, series=self.sine_univariate1.stack(self.sine_univariate1) + ) + assert str(exc.value).startswith( + "The number of components of the target series" + ) + + @pytest.mark.parametrize( + "config", + itertools.product( + [True, False], # univariate series + [True, False], # single series + [True, False], # use covariates + [True, False], # datetime index + [3, 5, 7], # different horizons + ), + ) + def test_predict(self, config): + (is_univar, is_single, use_covs, is_datetime, horizon) = config + + icl = 3 + ocl = 5 + series = self.sine_univariate1[:10] + if not is_univar: + series = series.stack(series) + if not is_datetime: + series = TimeSeries.from_values(series.all_values(), columns=series.columns) + if use_covs: + pc, fc = series, series + fc = fc.append_values(fc.values()[: max(horizon, ocl)]) + if horizon > ocl: + pc = pc.append_values(pc.values()[: horizon - ocl]) + model_kwargs = { + "lags_past_covariates": icl, + "lags_future_covariates": (icl, ocl), + } + else: + pc, fc = None, None + model_kwargs = {} + if not is_single: + series = [ + series, + series.with_columns_renamed( + col_names=series.columns.tolist(), + col_names_new=(series.columns + "_s2").tolist(), + ), + ] + if use_covs: + pc = [pc] * 2 + fc = [fc] * 2 + + # testing lags_past_covariates None but past_covariates during prediction + model_instance = LinearRegressionModel( + lags=icl, output_chunk_length=ocl, **model_kwargs + ) + model_instance.fit(series=series, past_covariates=pc, future_covariates=fc) + model = ConformalModel(model_instance, alpha=0.8, method="naive") + + preds = model.predict( + n=horizon, series=series, past_covariates=pc, future_covariates=fc + ) + + if is_single: + series = [series] + preds = [preds] + + for s_, preds_ in zip(series, preds): + cols_expected = [] + for col in s_.columns: + cols_expected += [f"{col}_q_{q}" for q in ["lo", "md", "hi"]] + assert preds_.columns.tolist() == cols_expected + assert len(preds_) == horizon + assert preds_.start_time() == s_.end_time() + s_.freq + assert preds_.freq == s_.freq diff --git a/darts/tests/models/forecasting/test_regression_models.py b/darts/tests/models/forecasting/test_regression_models.py index 4266af7b1a..ebbece5fdd 100644 --- a/darts/tests/models/forecasting/test_regression_models.py +++ b/darts/tests/models/forecasting/test_regression_models.py @@ -1000,33 +1000,31 @@ def test_models_runnability(self, config): model, mode = config train_y, test_y = self.sine_univariate1.split_before(0.7) # testing past covariates + model_instance = model(lags=4, lags_past_covariates=None, multi_models=mode) with pytest.raises(ValueError): # testing lags_past_covariates None but past_covariates during training - model_instance = model(lags=4, lags_past_covariates=None, multi_models=mode) model_instance.fit( series=self.sine_univariate1, past_covariates=self.sine_multivariate1, ) + model_instance = model(lags=4, lags_past_covariates=3, multi_models=mode) with pytest.raises(ValueError): # testing lags_past_covariates but no past_covariates during fit - model_instance = model(lags=4, lags_past_covariates=3, multi_models=mode) model_instance.fit(series=self.sine_univariate1) # testing future_covariates + model_instance = model(lags=4, lags_future_covariates=None, multi_models=mode) with pytest.raises(ValueError): # testing lags_future_covariates None but future_covariates during training - model_instance = model( - lags=4, lags_future_covariates=None, multi_models=mode - ) model_instance.fit( series=self.sine_univariate1, future_covariates=self.sine_multivariate1, ) + model_instance = model(lags=4, lags_future_covariates=3, multi_models=mode) with pytest.raises(ValueError): # testing lags_covariate but no covariate during fit - model_instance = model(lags=4, lags_future_covariates=3, multi_models=mode) model_instance.fit(series=self.sine_univariate1) # testing input_dim From 80dece916974291ef7bf7eae0a3c90e0b2cf26a9 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Wed, 3 Jul 2024 14:39:19 +0200 Subject: [PATCH 08/78] overlap end checkpoint --- darts/models/cp/conformal_model.py | 33 +++++++++++++---- darts/models/forecasting/forecasting_model.py | 35 ++++++++++++++++--- 2 files changed, 56 insertions(+), 12 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 6a7b75f573..0b77a156ae 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -13,6 +13,8 @@ from darts.logging import get_logger, raise_log from darts.models.forecasting.forecasting_model import GlobalForecastingModel from darts.utils import _with_sanity_checks + +# from darts.utils.data.tabularization import _extract_lagged_vals_from_windows from darts.utils.timeseries_generation import _build_forecast_series from darts.utils.ts_utils import ( SeriesType, @@ -52,6 +54,10 @@ def cqr_score_asym(row, quantile_lo_col, quantile_hi_col): ) +# TODO: fit conformal model (maybe for the future) +# - + + class ConformalModel(GlobalForecastingModel): def __init__( self, @@ -260,6 +266,7 @@ def historical_forecasts( past_covariates = series2seq(past_covariates) future_covariates = series2seq(future_covariates) + # generate all possible forecasts (overlap_end=True) hfcs = self.model.historical_forecasts( series=series, past_covariates=past_covariates, @@ -267,7 +274,7 @@ def historical_forecasts( num_samples=num_samples, forecast_horizon=forecast_horizon, retrain=False, - overlap_end=overlap_end, + overlap_end=True, last_points_only=last_points_only, verbose=verbose, show_warnings=show_warnings, @@ -291,6 +298,7 @@ def historical_forecasts( residuals = self.model.residuals( series=series, historical_forecasts=hfcs, + overlap_end=True, last_points_only=last_points_only, verbose=verbose, show_warnings=show_warnings, @@ -303,14 +311,18 @@ def historical_forecasts( cp_preds = [] # no historical forecasts were generated - if not s_hfcs or train_length is not None and train_length > len(s_hfcs): + if not s_hfcs or (train_length is not None and train_length > len(s_hfcs)): cp_hfcs.append(cp_preds) continue # determine the first forecast index for which to compute conformal prediction; # all forecasts before that are used for calibration - # skip based on `train_length` - skip_n_train_length = train_length if train_length is not None else 0 + + # skip based on `train_length`; for `horizon > 1` we need additional calibration points + # to avoid look-ahead bias and ensure all steps in horizon have `train_length` points + skip_n_train_length = ( + train_length + forecast_horizon - 1 if train_length is not None else 0 + ) # skip based on `start` skip_n_start = 0 @@ -340,14 +352,21 @@ def historical_forecasts( if not skip_n and not idx: cp_pred = np.concatenate([pred_vals] * 3, axis=1) else: - # get the last residual index for calibration + # get the last residual index for calibration, `cal_end` is exclusive cal_end = skip_n + idx * stride + # first residual index is shifted back by the horizon to also get `train_length` points for + # the last point in the horizon cal_start = ( - None if train_length is None else cal_end - train_length + None + if train_length is None + else cal_end - (train_length + forecast_horizon - 1) ) + # cal_start = ( + # None if train_length is None else cal_end - train_length - (forecast_horizon - 1) + # ) # TODO: should we consider all previous historical forecasts, or only the stridden ones? cal_res = res[cal_start:cal_end] - q_hat = np.quantile(cal_res, q=self.alpha, axis=0) + q_hat = np.nanquantile(cal_res, q=self.alpha, axis=0) cp_pred = np.concatenate( [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 ) diff --git a/darts/models/forecasting/forecasting_model.py b/darts/models/forecasting/forecasting_model.py index 5a5dc7a738..de370eb6ff 100644 --- a/darts/models/forecasting/forecasting_model.py +++ b/darts/models/forecasting/forecasting_model.py @@ -57,7 +57,7 @@ get_single_series, series2seq, ) -from darts.utils.utils import generate_index +from darts.utils.utils import generate_index, n_steps_between logger = get_logger(__name__) @@ -1827,6 +1827,7 @@ def residuals( forecast_horizon: int = 1, stride: int = 1, retrain: Union[bool, int, Callable[..., bool]] = True, + overlap_end: bool = False, last_points_only: bool = True, metric: METRIC_TYPE = metrics.err, verbose: bool = False, @@ -1937,6 +1938,8 @@ def residuals( to the corresponding retrain function argument. Note: some models do require being retrained every time and do not support anything other than `retrain=True`. + overlap_end + Whether the returned forecasts can go beyond the series' end or not. last_points_only Whether to use the whole historical forecasts or only the last point of each forecast to compute the error. metric @@ -2006,9 +2009,34 @@ def residuals( show_warnings=show_warnings, fit_kwargs=fit_kwargs, predict_kwargs=predict_kwargs, - overlap_end=False, + overlap_end=overlap_end, sample_weight=sample_weight, ) + # remember input series type + series_seq_type = get_series_seq_type(series) + + # add nans to end of series to get residuals of same shape for each forecast + if overlap_end: + # infer the forecast horizon based on the last forecast; allows user not to care about `forecast_horizon` + if series_seq_type == SeriesType.SINGLE: + hfc_last = ( + historical_forecasts + if last_points_only + else historical_forecasts[-1] + ) + series = [series] + else: + hfc_last = ( + historical_forecasts[0] + if last_points_only + else historical_forecasts[0][-1] + ) + horizon_ = n_steps_between( + hfc_last.end_time(), series[0].end_time(), freq=series[0].freq + ) + series = [s_.append_values(np.array([np.nan] * horizon_)) for s_ in series] + if series_seq_type == SeriesType.SINGLE: + series = series[0] residuals = self.backtest( series=series, @@ -2019,9 +2047,6 @@ def residuals( metric_kwargs=metric_kwargs, ) - # remember input series type - series_seq_type = get_series_seq_type(series) - # convert forecasts and residuals to list of lists of series/arrays forecast_seq_type = get_series_seq_type(historical_forecasts) historical_forecasts = series2seq( From 24bc75fc67a97737fabfa3008b4082828efcd27f Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 4 Jul 2024 09:47:38 +0200 Subject: [PATCH 09/78] overlap end checkpoint 2 --- darts/models/cp/conformal_model.py | 121 ++++++++++++++++++++++------- 1 file changed, 91 insertions(+), 30 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 0b77a156ae..2c89cb7fce 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -9,12 +9,11 @@ import numpy as np import pandas as pd +import darts.metrics from darts import TimeSeries from darts.logging import get_logger, raise_log from darts.models.forecasting.forecasting_model import GlobalForecastingModel from darts.utils import _with_sanity_checks - -# from darts.utils.data.tabularization import _extract_lagged_vals_from_windows from darts.utils.timeseries_generation import _build_forecast_series from darts.utils.ts_utils import ( SeriesType, @@ -27,6 +26,18 @@ logger = get_logger(__name__) +def _triul_indices(forecast_horizon, n_comps): + idx_horizon, idx_hfc = np.tril_indices(n=forecast_horizon, k=-1) + idx_comp = [i for _ in range(len(idx_horizon)) for i in range(n_comps)] + + # reverse to get lower left triangle + idx_horizon = forecast_horizon - 1 - idx_horizon + idx_horizon = idx_horizon.repeat(n_comps) + + idx_hfc = idx_hfc.repeat(n_comps) + return idx_horizon, idx_comp, idx_hfc + + def cqr_score_sym(row, quantile_lo_col, quantile_hi_col): return ( [None, None] @@ -109,6 +120,7 @@ def __init__( self.method = method self.quantiles = quantiles self._fit_called = True + self.score_fn = darts.metrics.ae @property def output_chunk_length(self) -> Optional[int]: @@ -160,6 +172,7 @@ def predict( verbose=verbose, show_warnings=show_warnings, values_only=True, + metric=self.score_fn, ) if self.method != "naive": raise_log(NotImplementedError("non-naive not yet implemented")) @@ -284,14 +297,15 @@ def historical_forecasts( predict_kwargs=predict_kwargs, ) # TODO: add support for: - # - overlap_end = True # - num_samples # - predict_likelihood_parameters # - tqdm iterator over series # - support for different CP algorithms - # - compute all possible residuals (including the partial forecast horizons up until the end) # DONE: + # - properly define minimum residuals to start (different for `last_points_only=True/False` + # - compute all possible residuals (including the partial forecast horizons up until the end) + # - overlap_end = True # - last_points_only = True # - add correct output components # - use only `train_length` previous residuals @@ -303,11 +317,19 @@ def historical_forecasts( verbose=verbose, show_warnings=show_warnings, values_only=True, + metric=self.score_fn, + ) + + # mask later used to avoid look-ahead bias in case of `last_points_only=False` + idx_horizon, idx_comp, idx_hfc = _triul_indices( + forecast_horizon, series[0].width ) # TODO: Generate Conformalized predictions per forecast cp_hfcs = [] - for series_, s_hfcs, res in zip(series, hfcs, residuals): + for series_idx, (series_, s_hfcs, res) in enumerate( + zip(series, hfcs, residuals) + ): cp_preds = [] # no historical forecasts were generated @@ -318,11 +340,11 @@ def historical_forecasts( # determine the first forecast index for which to compute conformal prediction; # all forecasts before that are used for calibration - # skip based on `train_length`; for `horizon > 1` we need additional calibration points + # skip based on `train_length` + skip_n_train = train_length or 0 + # for `horizon > 1` we need additional calibration points # to avoid look-ahead bias and ensure all steps in horizon have `train_length` points - skip_n_train_length = ( - train_length + forecast_horizon - 1 if train_length is not None else 0 - ) + skip_n_train += forecast_horizon - 1 # skip based on `start` skip_n_start = 0 @@ -340,31 +362,54 @@ def historical_forecasts( if last_points_only: skip_n_start += forecast_horizon - 1 - # TODO: what should be the smallest number for calibration residuals - 0 or 1? - min_skip_n = 0 - skip_n = max([skip_n_train_length, skip_n_start, min_skip_n]) + # we need at least 1 residual per point in the horizon + min_skip_n = 1 if last_points_only else forecast_horizon + first_fc_idx = max([skip_n_train, skip_n_start, min_skip_n]) + + if first_fc_idx >= len(s_hfcs): + ( + raise_log( + ValueError( + "Cannot build a single input for prediction with the provided model, " + f"`series` and `*_covariates` at series index: {series_idx}. The minimum " + "prediction input time index requirements were not met. " + "Please check the time index of `series` and `*_covariates`." + ), + logger=logger, + ), + ) + # determine the last forecast index respecting `overlap_end` + last_fc_idx = len(s_hfcs) + if not overlap_end: + last_hfc = s_hfcs if last_points_only else s_hfcs[-1] + delta_end = n_steps_between( + end=last_hfc.end_time(), + start=series_.end_time(), + freq=series_.freq, + ) + if last_fc_idx: + last_fc_idx -= delta_end + + # historical conformal prediction if last_points_only: for idx, pred_vals in enumerate( - s_hfcs.values(copy=False)[skip_n::stride] + s_hfcs.values(copy=False)[first_fc_idx:last_fc_idx:stride] ): pred_vals = np.expand_dims(pred_vals, 0) - if not skip_n and not idx: + if not first_fc_idx and not idx: cp_pred = np.concatenate([pred_vals] * 3, axis=1) else: # get the last residual index for calibration, `cal_end` is exclusive - cal_end = skip_n + idx * stride - # first residual index is shifted back by the horizon to also get `train_length` points for + # to avoid look-ahead bias, use only residuals from before the historical forecast start point; + # since we look at `last_points only=True`, the last residual historically available at + # the forecasting point is `forecast_horizon - 1` steps before + cal_end = first_fc_idx + idx * stride - (forecast_horizon - 1) + # first residual index is shifted back by the horizon to get `train_length` points for # the last point in the horizon cal_start = ( - None - if train_length is None - else cal_end - (train_length + forecast_horizon - 1) + cal_end - train_length if train_length is not None else None ) - # cal_start = ( - # None if train_length is None else cal_end - train_length - (forecast_horizon - 1) - # ) - # TODO: should we consider all previous historical forecasts, or only the stridden ones? cal_res = res[cal_start:cal_end] q_hat = np.nanquantile(cal_res, q=self.alpha, axis=0) cp_pred = np.concatenate( @@ -376,7 +421,7 @@ def historical_forecasts( input_series=series_, custom_columns=self._cp_component_names(series_), time_index=generate_index( - start=s_hfcs._time_index[skip_n], + start=s_hfcs._time_index[first_fc_idx], length=len(cp_preds), freq=series_.freq * stride, ), @@ -385,20 +430,36 @@ def historical_forecasts( ) cp_hfcs.append(cp_preds) else: - for idx, pred in enumerate(s_hfcs[skip_n::stride]): + for idx, pred in enumerate(s_hfcs[first_fc_idx:last_fc_idx:stride]): # convert to (horizon, n comps, hist fcs) pred_vals = pred.values(copy=False) - if not skip_n and not idx: + if not first_fc_idx and not idx: cp_pred = np.concatenate([pred_vals] * 3, axis=1) else: - # get the last residual index for calibration - cal_end = skip_n + idx * stride + # get the last residual index for calibration, `cal_end` is exclusive + # to avoid look-ahead bias, use only residuals from before the historical forecast start point; + # since we look at `last_points only=False`, the last residual historically available at + # the forecasting point is from the first predicted step of the previous forecast + cal_end = first_fc_idx + idx * stride + # stepping back further gives access to more residuals and also residuals from longer horizons. + # to get `train_length` residuals for the last step in the horizon, we need to step back + # additional `forecast_horizon - 1` points cal_start = ( - None if train_length is None else cal_end - train_length + cal_end - train_length - (forecast_horizon - 1) + if train_length is not None + else None ) # TODO: should we consider all previous historical forecasts, or only the stridden ones? cal_res = np.concatenate(res[cal_start:cal_end], axis=2) - q_hat = np.quantile(cal_res, q=self.alpha, axis=2) + # ignore upper left residuals to have same number of residuals per horizon + cal_res[idx_horizon, idx_comp, idx_hfc] = np.nan + # ignore lower right residuals to avoid look-ahead bias + cal_res[ + forecast_horizon - 1 - idx_horizon, + idx_comp, + cal_res.shape[2] - 1 - idx_hfc, + ] = np.nan + q_hat = np.nanquantile(cal_res, q=self.alpha, axis=2) cp_pred = np.concatenate( [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 ) From b19b708aa07a31d247502f3e0b122c9c27a86fb6 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 4 Jul 2024 16:37:06 +0200 Subject: [PATCH 10/78] ignore start --- darts/models/cp/conformal_model.py | 98 ++++++++++++------- .../forecasting/test_historical_forecasts.py | 8 +- 2 files changed, 66 insertions(+), 40 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 2c89cb7fce..55316a9ac4 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -14,6 +14,7 @@ from darts.logging import get_logger, raise_log from darts.models.forecasting.forecasting_model import GlobalForecastingModel from darts.utils import _with_sanity_checks +from darts.utils.historical_forecasts.utils import _historical_forecasts_start_warnings from darts.utils.timeseries_generation import _build_forecast_series from darts.utils.ts_utils import ( SeriesType, @@ -320,12 +321,11 @@ def historical_forecasts( metric=self.score_fn, ) - # mask later used to avoid look-ahead bias in case of `last_points_only=False` + # this mask is later used to avoid look-ahead bias in case of `last_points_only=False` idx_horizon, idx_comp, idx_hfc = _triul_indices( forecast_horizon, series[0].width ) - # TODO: Generate Conformalized predictions per forecast cp_hfcs = [] for series_idx, (series_, s_hfcs, res) in enumerate( zip(series, hfcs, residuals) @@ -337,36 +337,29 @@ def historical_forecasts( cp_hfcs.append(cp_preds) continue - # determine the first forecast index for which to compute conformal prediction; - # all forecasts before that are used for calibration - - # skip based on `train_length` - skip_n_train = train_length or 0 - # for `horizon > 1` we need additional calibration points - # to avoid look-ahead bias and ensure all steps in horizon have `train_length` points - skip_n_train += forecast_horizon - 1 - - # skip based on `start` - skip_n_start = 0 - if start is not None: - if isinstance(start, pd.Timestamp) or start_format == "value": - start_ = start - else: - start_ = series_._time_index[start] - skip_n_start = n_steps_between( - end=start_, - start=get_single_series(s_hfcs).start_time(), + # determine the last forecast index for conformal prediction + first_hfc = get_single_series(s_hfcs) + last_hfc = s_hfcs if last_points_only else s_hfcs[-1] + last_fc_idx = len(s_hfcs) + # adjust based on `overlap_end` + if not overlap_end: + delta_end = n_steps_between( + end=last_hfc.end_time(), + start=series_.end_time(), freq=series_.freq, ) - # hfcs only contain last predicted points; skip until end of first forecast - if last_points_only: - skip_n_start += forecast_horizon - 1 + if last_fc_idx: + last_fc_idx -= delta_end + # determine the first forecast index for conformal prediction; all forecasts before that are + # used for calibration # we need at least 1 residual per point in the horizon - min_skip_n = 1 if last_points_only else forecast_horizon - first_fc_idx = max([skip_n_train, skip_n_start, min_skip_n]) + skip_n_train = forecast_horizon - if first_fc_idx >= len(s_hfcs): + # plus some additional steps based on `train_length` + if train_length is not None: + skip_n_train += train_length - 1 + if skip_n_train >= len(s_hfcs): ( raise_log( ValueError( @@ -379,17 +372,50 @@ def historical_forecasts( ), ) - # determine the last forecast index respecting `overlap_end` - last_fc_idx = len(s_hfcs) - if not overlap_end: - last_hfc = s_hfcs if last_points_only else s_hfcs[-1] - delta_end = n_steps_between( - end=last_hfc.end_time(), - start=series_.end_time(), + # skip solely based on `start` + skip_n_start = 0 + if start is not None: + if isinstance(start, pd.Timestamp) or start_format == "value": + start_time = start + else: + start_time = series_._time_index[start] + + skip_n_start = n_steps_between( + end=start_time, + start=first_hfc.start_time(), freq=series_.freq, ) - if last_fc_idx: - last_fc_idx -= delta_end + # hfcs only contain last predicted points; skip until end of first forecast + if last_points_only: + skip_n_start += forecast_horizon - 1 + + # if start is out of bounds, we ignore it + if ( + skip_n_start < 0 + or skip_n_start >= last_fc_idx + or skip_n_start < skip_n_train + ): + skip_n_start = 0 + if show_warnings: + # adjust to actual start point in case of `last_points_only` + adjust_idx = ( + int(last_points_only) + * (forecast_horizon - 1) + * series_.freq + ) + hfc_predict_index = ( + s_hfcs[skip_n_train].start_time() - adjust_idx, + s_hfcs[last_fc_idx].start_time() - adjust_idx, + ) + _historical_forecasts_start_warnings( + idx=series_idx, + start=start, + start_time_=start_time, + historical_forecasts_time_index=hfc_predict_index, + ) + + # get final first index + first_fc_idx = max([skip_n_train, skip_n_start]) # historical conformal prediction if last_points_only: diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index 968736539a..84abdfa938 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -2532,7 +2532,7 @@ def test_sample_weight(self, config): [False, True], # use integer indexed series [False, True], # use multi-series ) - ), + )[0:1], ) def test_conformal_historical_forecasts(self, config): """Tests naive conformal model.""" @@ -2626,12 +2626,12 @@ def test_conformal_historical_forecasts(self, config): hfc = [hfc] if not last_points_only and overlap_end: - n_pred_series_expected = 8 + n_pred_series_expected = len(series) - icl + 1 - horizon n_pred_points_expected = horizon - first_ts_expected = series.time_index[icl] + first_ts_expected = series.time_index[icl + horizon] last_ts_expected = series.end_time() + series.freq * horizon elif not last_points_only: # overlap_end = False - n_pred_series_expected = len(series) - icl - horizon + 1 + n_pred_series_expected = len(series) - icl + 1 - horizon n_pred_points_expected = horizon first_ts_expected = series.time_index[icl] last_ts_expected = series.end_time() From 7f023789a110a73d5a3f51ca01b53e2b3fb09b56 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 5 Jul 2024 14:07:08 +0200 Subject: [PATCH 11/78] finalize hist fc test --- darts/models/cp/conformal_model.py | 24 +++++----- .../forecasting/test_historical_forecasts.py | 44 ++++++++++++++----- 2 files changed, 44 insertions(+), 24 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 55316a9ac4..ba3e3bb0ee 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -359,18 +359,6 @@ def historical_forecasts( # plus some additional steps based on `train_length` if train_length is not None: skip_n_train += train_length - 1 - if skip_n_train >= len(s_hfcs): - ( - raise_log( - ValueError( - "Cannot build a single input for prediction with the provided model, " - f"`series` and `*_covariates` at series index: {series_idx}. The minimum " - "prediction input time index requirements were not met. " - "Please check the time index of `series` and `*_covariates`." - ), - logger=logger, - ), - ) # skip solely based on `start` skip_n_start = 0 @@ -416,6 +404,18 @@ def historical_forecasts( # get final first index first_fc_idx = max([skip_n_train, skip_n_start]) + if first_fc_idx >= last_fc_idx: + ( + raise_log( + ValueError( + "Cannot build a single input for prediction with the provided model, " + f"`series` and `*_covariates` at series index: {series_idx}. The minimum " + "prediction input time index requirements were not met. " + "Please check the time index of `series` and `*_covariates`." + ), + logger=logger, + ), + ) # historical conformal prediction if last_points_only: diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index 84abdfa938..9cf51107d1 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -2532,7 +2532,7 @@ def test_sample_weight(self, config): [False, True], # use integer indexed series [False, True], # use multi-series ) - )[0:1], + ), ) def test_conformal_historical_forecasts(self, config): """Tests naive conformal model.""" @@ -2547,10 +2547,12 @@ def test_conformal_historical_forecasts(self, config): ) = config icl = 3 ocl = 5 - len_val_series = 10 + min_len_val_series = icl + horizon + int(not overlap_end) * horizon + # generate n forecasts + n_forecasts = 3 series_train, series_val = ( self.ts_pass_train[:10], - self.ts_pass_val[:len_val_series], + self.ts_pass_val[: min_len_val_series + n_forecasts - 1], ) if use_int_idx: series_train = TimeSeries.from_values( @@ -2566,7 +2568,8 @@ def test_conformal_historical_forecasts(self, config): ), columns=series_train.columns, ) - + series_val_too_short = series_val[:-n_forecasts] + # with pytest.raises(ValueError): model_kwargs = ( {} if not use_covs @@ -2613,6 +2616,18 @@ def test_conformal_historical_forecasts(self, config): stride=stride, forecast_horizon=horizon, ) + with pytest.raises(ValueError) as exc: + _ = model.historical_forecasts( + series=series_val_too_short, + past_covariates=pc, + future_covariates=fc, + retrain=False, + last_points_only=last_points_only, + overlap_end=overlap_end, + stride=stride, + forecast_horizon=horizon, + ) + assert str(exc.value).startswith("Cannot build a single input for prediction") if not isinstance(series_val, list): series_val = [series_val] @@ -2625,25 +2640,30 @@ def test_conformal_historical_forecasts(self, config): if not isinstance(hfc, list): hfc = [hfc] + n_preds_with_overlap = len(series) - icl + 1 - horizon if not last_points_only and overlap_end: - n_pred_series_expected = len(series) - icl + 1 - horizon + n_pred_series_expected = n_preds_with_overlap n_pred_points_expected = horizon - first_ts_expected = series.time_index[icl + horizon] + first_ts_expected = series.time_index[icl] + series.freq * horizon last_ts_expected = series.end_time() + series.freq * horizon elif not last_points_only: # overlap_end = False - n_pred_series_expected = len(series) - icl + 1 - horizon + n_pred_series_expected = n_preds_with_overlap - horizon n_pred_points_expected = horizon - first_ts_expected = series.time_index[icl] + first_ts_expected = series.time_index[icl] + series.freq * horizon last_ts_expected = series.end_time() elif overlap_end: # last_points_only = True n_pred_series_expected = 1 - n_pred_points_expected = 8 - first_ts_expected = series.time_index[icl] + (horizon - 1) * series.freq + n_pred_points_expected = n_preds_with_overlap + first_ts_expected = ( + series.time_index[icl] + (2 * horizon - 1) * series.freq + ) last_ts_expected = series.end_time() + series.freq * horizon else: # last_points_only = True, overlap_end = False n_pred_series_expected = 1 - n_pred_points_expected = len(series) - icl - horizon + 1 - first_ts_expected = series.time_index[icl] + (horizon - 1) * series.freq + n_pred_points_expected = n_preds_with_overlap - horizon + first_ts_expected = ( + series.time_index[icl] + (2 * horizon - 1) * series.freq + ) last_ts_expected = series.end_time() # to make it simple in case of stride, we assume that non-optimized hist fc returns correct results From 94acb963ab29db7924e890b5db868b1ddcf1a9ec Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 5 Jul 2024 14:16:56 +0200 Subject: [PATCH 12/78] start, train length tests --- .../forecasting/test_historical_forecasts.py | 108 +++++++++++++++++- 1 file changed, 106 insertions(+), 2 deletions(-) diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index 9cf51107d1..e24ee638a8 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -2514,8 +2514,6 @@ def test_sample_weight(self, config): f"at least all times of the corresponding target `series`." ) - @pytest.mark.slow - @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") @pytest.mark.parametrize( "config", list( @@ -2685,3 +2683,109 @@ def test_conformal_historical_forecasts(self, config): for hfc_ in hfc: assert hfc_.columns.tolist() == cols_excpected assert len(hfc_) == n_pred_points_expected + + @pytest.mark.parametrize( + "config", + list( + itertools.product( + [False, True], # last points only + [None, 1, 2], # train length + ["value", "position"], # start format + [False, True], # use integer indexed series + [False, True], # use multi-series + ) + ), + ) + def test_conformal_historical_start_trian_length(self, config): + """Tests naive conformal model.""" + ( + last_points_only, + train_length, + start_format, + use_int_idx, + use_multi_series, + ) = config + icl = 3 + ocl = 5 + horizon = 7 + min_len_val_series = icl + 2 * horizon + # generate n forecasts + n_forecasts = 3 + series_train, series_val = ( + self.ts_pass_train[:10], + self.ts_pass_val[: min_len_val_series + n_forecasts - 1], + ) + if use_int_idx: + series_train = TimeSeries.from_values( + series_train.all_values(), columns=series_train.columns + ) + series_val = TimeSeries.from_times_and_values( + values=series_val.all_values(), + times=pd.RangeIndex( + start=series_train.end_time() + series_train.freq, + stop=series_train.end_time() + + (len(series_val) + 1) * series_train.freq, + step=series_train.freq, + ), + columns=series_train.columns, + ) + forecasting_model = LinearRegressionModel(lags=icl, output_chunk_length=ocl) + forecasting_model.fit(series_train) + + model = ConformalModel(forecasting_model, alpha=0.8, method="naive") + + if use_multi_series: + series_val = [ + series_val, + (series_val + 10) + .shift(1) + .with_columns_renamed(series_val.columns, "test_col"), + ] + + hist_fct = model.historical_forecasts( + series=series_val, + retrain=False, + train_length=train_length, + start=0, + start_format=start_format, + last_points_only=last_points_only, + forecast_horizon=horizon, + ) + + if not isinstance(series_val, list): + series_val = [series_val] + hist_fct = [hist_fct] + + for ( + series, + hfc, + ) in zip(series_val, hist_fct): + if not isinstance(hfc, list): + hfc = [hfc] + + n_preds_with_overlap = len(series) - icl + 1 - horizon + if not last_points_only: + n_pred_series_expected = n_preds_with_overlap - horizon + n_pred_points_expected = horizon + first_ts_expected = series.time_index[icl] + series.freq * horizon + last_ts_expected = series.end_time() + else: + n_pred_series_expected = 1 + n_pred_points_expected = n_preds_with_overlap - horizon + first_ts_expected = ( + series.time_index[icl] + (2 * horizon - 1) * series.freq + ) + last_ts_expected = series.end_time() + + cols_excpected = [] + for col in series.columns: + cols_excpected += [f"{col}_q_lo", f"{col}_q_md", f"{col}_q_hi"] + # check length match between optimized and default hist fc + assert len(hfc) == n_pred_series_expected + # check hist fc start + assert hfc[0].start_time() == first_ts_expected + # check hist fc end + assert hfc[-1].end_time() == last_ts_expected + for hfc_ in hfc: + assert hfc_.columns.tolist() == cols_excpected + assert len(hfc_) == n_pred_points_expected From c6f27ae528a8a4555b18547a7d4d4557d2555343 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 5 Jul 2024 16:11:55 +0200 Subject: [PATCH 13/78] finalize start train length tests --- darts/models/cp/conformal_model.py | 22 ++++++-- darts/models/forecasting/forecasting_model.py | 2 +- .../forecasting/test_historical_forecasts.py | 52 ++++++++++++++----- darts/utils/timeseries_generation.py | 4 +- 4 files changed, 61 insertions(+), 19 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index ba3e3bb0ee..66ed389866 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -28,13 +28,25 @@ def _triul_indices(forecast_horizon, n_comps): + """Computes the indices of upper for a 3D Matrix of shape (horizon, components, n forecasts) + left triangle. The upper left triangle is first computed for the (horizon, n forecasts) + dimension, and then repeated along the `components` dimension. + + These indices can be used to: + - mask out residuals from "newer" forecasts to avoid look-ahead bias (for horizons > 1) + - mask out residuals from "older" forecasts, so that each conformal forecast has the same number + of residual examples per point in the forecast horizon. + """ + # get lower right triangle idx_horizon, idx_hfc = np.tril_indices(n=forecast_horizon, k=-1) - idx_comp = [i for _ in range(len(idx_horizon)) for i in range(n_comps)] - # reverse to get lower left triangle idx_horizon = forecast_horizon - 1 - idx_horizon - idx_horizon = idx_horizon.repeat(n_comps) + # get component indices (already repeated) + idx_comp = [i for _ in range(len(idx_horizon)) for i in range(n_comps)] + + # repeat along the component dimension + idx_horizon = idx_horizon.repeat(n_comps) idx_hfc = idx_hfc.repeat(n_comps) return idx_horizon, idx_comp, idx_hfc @@ -321,7 +333,8 @@ def historical_forecasts( metric=self.score_fn, ) - # this mask is later used to avoid look-ahead bias in case of `last_points_only=False` + # this mask is later used to avoid look-ahead bias and guarantee identical number of calibration + # points per step in the forecast horizon. Only used in case of `last_points_only=False` idx_horizon, idx_comp, idx_hfc = _triul_indices( forecast_horizon, series[0].width ) @@ -475,7 +488,6 @@ def historical_forecasts( if train_length is not None else None ) - # TODO: should we consider all previous historical forecasts, or only the stridden ones? cal_res = np.concatenate(res[cal_start:cal_end], axis=2) # ignore upper left residuals to have same number of residuals per horizon cal_res[idx_horizon, idx_comp, idx_hfc] = np.nan diff --git a/darts/models/forecasting/forecasting_model.py b/darts/models/forecasting/forecasting_model.py index de370eb6ff..f87c36036f 100644 --- a/darts/models/forecasting/forecasting_model.py +++ b/darts/models/forecasting/forecasting_model.py @@ -2015,7 +2015,7 @@ def residuals( # remember input series type series_seq_type = get_series_seq_type(series) - # add nans to end of series to get residuals of same shape for each forecast + # optionally, add nans to end of series to get residuals of same shape for each forecast if overlap_end: # infer the forecast horizon based on the last forecast; allows user not to care about `forecast_horizon` if series_seq_type == SeriesType.SINGLE: diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index e24ee638a8..65227c4711 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -2533,7 +2533,8 @@ def test_sample_weight(self, config): ), ) def test_conformal_historical_forecasts(self, config): - """Tests naive conformal model.""" + """Tests naive conformal model with last points only, covariates, stride, + different horizons and overlap end.""" ( use_covs, last_points_only, @@ -2690,17 +2691,19 @@ def test_conformal_historical_forecasts(self, config): itertools.product( [False, True], # last points only [None, 1, 2], # train length + [False, True], # use start ["value", "position"], # start format [False, True], # use integer indexed series [False, True], # use multi-series ) ), ) - def test_conformal_historical_start_trian_length(self, config): - """Tests naive conformal model.""" + def test_conformal_historical_start_train_length(self, config): + """Tests naive conformal model with start and train length.""" ( last_points_only, train_length, + use_start, start_format, use_int_idx, use_multi_series, @@ -2708,7 +2711,9 @@ def test_conformal_historical_start_trian_length(self, config): icl = 3 ocl = 5 horizon = 7 - min_len_val_series = icl + 2 * horizon + add_train_length = train_length - 1 if train_length is not None else 0 + add_start = 2 * int(use_start) + min_len_val_series = icl + 2 * horizon + add_train_length + add_start # generate n forecasts n_forecasts = 3 series_train, series_val = ( @@ -2732,6 +2737,13 @@ def test_conformal_historical_start_trian_length(self, config): forecasting_model = LinearRegressionModel(lags=icl, output_chunk_length=ocl) forecasting_model.fit(series_train) + start_position = icl + horizon + add_train_length + add_start + start = None + if use_start: + if start_format == "value": + start = series_val.time_index[start_position] + else: + start = start_position model = ConformalModel(forecasting_model, alpha=0.8, method="naive") if use_multi_series: @@ -2746,7 +2758,7 @@ def test_conformal_historical_start_trian_length(self, config): series=series_val, retrain=False, train_length=train_length, - start=0, + start=start, start_format=start_format, last_points_only=last_points_only, forecast_horizon=horizon, @@ -2756,24 +2768,40 @@ def test_conformal_historical_start_trian_length(self, config): series_val = [series_val] hist_fct = [hist_fct] - for ( + for idx, ( series, hfc, - ) in zip(series_val, hist_fct): + ) in enumerate(zip(series_val, hist_fct)): if not isinstance(hfc, list): hfc = [hfc] - n_preds_with_overlap = len(series) - icl + 1 - horizon + # multi series: second series is shifted by one time step (+/- idx); + # start_format = "value" requires a shift + add_start_series_2 = idx * int(use_start) * int(start_format == "value") + n_preds_without_overlap = ( + len(series) + - icl + + 1 + - 2 * horizon + - add_train_length + - add_start + + add_start_series_2 + ) if not last_points_only: - n_pred_series_expected = n_preds_with_overlap - horizon + n_pred_series_expected = n_preds_without_overlap n_pred_points_expected = horizon - first_ts_expected = series.time_index[icl] + series.freq * horizon + # seconds series is shifted by one time step (- idx) + first_ts_expected = series.time_index[ + start_position - add_start_series_2 + ] last_ts_expected = series.end_time() else: n_pred_series_expected = 1 - n_pred_points_expected = n_preds_with_overlap - horizon + n_pred_points_expected = n_preds_without_overlap + # seconds series is shifted by one time step (- idx) first_ts_expected = ( - series.time_index[icl] + (2 * horizon - 1) * series.freq + series.time_index[start_position - add_start_series_2] + + (horizon - 1) * series.freq ) last_ts_expected = series.end_time() diff --git a/darts/utils/timeseries_generation.py b/darts/utils/timeseries_generation.py index 833cb144f8..51be383029 100644 --- a/darts/utils/timeseries_generation.py +++ b/darts/utils/timeseries_generation.py @@ -756,7 +756,9 @@ def _build_forecast_series( with_hierarchy If set to `False`, do not copy the input_series `hierarchy` attribute pred_start - Optionally, give a custom prediction start point. + Optionally, give a custom prediction start point. Only effective if `time_index` is `None`. + time_index + Optionally, the index to use for the forecast time series. Returns ------- From ba79d9af414641d7693c0baeb77168c671aadd3e Mon Sep 17 00:00:00 2001 From: dennisbader Date: Mon, 8 Jul 2024 16:51:56 +0200 Subject: [PATCH 14/78] fix residuals with overlap end --- darts/models/cp/conformal_model.py | 61 +++++++++-- darts/models/forecasting/forecasting_model.py | 101 ++++-------------- darts/utils/historical_forecasts/utils.py | 94 +++++++++++++++- 3 files changed, 165 insertions(+), 91 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 66ed389866..10e4ff0102 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -158,12 +158,14 @@ def predict( verbose: bool = False, predict_likelihood_parameters: bool = False, show_warnings: bool = True, + cal_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + cal_past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + cal_future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, ) -> Union[TimeSeries, Sequence[TimeSeries]]: called_with_single_series = get_series_seq_type(series) == SeriesType.SINGLE series = series2seq(series) past_covariates = series2seq(past_covariates) future_covariates = series2seq(future_covariates) - preds = self.model.predict( n=n, series=series, @@ -174,14 +176,43 @@ def predict( predict_likelihood_parameters=predict_likelihood_parameters, show_warnings=show_warnings, ) + + if cal_series is None: + series_ = series + past_covariates_ = past_covariates + future_covariates_ = future_covariates + else: + series_ = series2seq(cal_series) + if len(series_) != len(series): + raise_log( + ValueError( + f"Mismatch between number of `cal_series` ({len(series_)}) " + f"and number of `series` ({len(series)})." + ), + logger=logger, + ) + past_covariates_ = series2seq(cal_past_covariates) + future_covariates_ = series2seq(cal_future_covariates) + + hfcs = self.model.historical_forecasts( + series=series_, + past_covariates=past_covariates_, + future_covariates=future_covariates_, + num_samples=num_samples, + forecast_horizon=n, + retrain=False, + overlap_end=True, + last_points_only=False, + verbose=verbose, + show_warnings=show_warnings, + predict_likelihood_parameters=predict_likelihood_parameters, + ) + residuals = self.model.residuals( series=series, - past_covariates=past_covariates, - future_covariates=future_covariates, - forecast_horizon=n, + historical_forecasts=hfcs, last_points_only=False, - retrain=False, - stride=1, + overlap_end=True, verbose=verbose, show_warnings=show_warnings, values_only=True, @@ -513,6 +544,24 @@ def historical_forecasts( cp_hfcs.append(cp_preds) return cp_hfcs[0] if called_with_single_series else cp_hfcs + def _calibrate_forecasts( + self, + series: Union[TimeSeries, Sequence[TimeSeries]], + forecasts: Union[TimeSeries, Sequence[TimeSeries]], + cal_series: Union[TimeSeries, Sequence[TimeSeries]], + cal_forecasts: Union[TimeSeries, Sequence[TimeSeries]], + train_length: Optional[int] = None, + start: Optional[Union[pd.Timestamp, float, int]] = None, + start_format: Literal["position", "value"] = "value", + forecast_horizon: int = 1, + stride: int = 1, + overlap_end: bool = False, + last_points_only: bool = True, + verbose: bool = False, + show_warnings: bool = True, + ): + pass + def _get_nonconformity_scores(self, df_cal: pd.DataFrame, step_number: int) -> dict: """Get the nonconformity scores using the given conformal prediction technique. diff --git a/darts/models/forecasting/forecasting_model.py b/darts/models/forecasting/forecasting_model.py index f87c36036f..26a365a192 100644 --- a/darts/models/forecasting/forecasting_model.py +++ b/darts/models/forecasting/forecasting_model.py @@ -41,10 +41,12 @@ from darts.utils import _build_tqdm_iterator, _parallel_apply, _with_sanity_checks from darts.utils.historical_forecasts.utils import ( _adjust_historical_forecasts_time_index, + _extend_series_for_overlap_end, _get_historical_forecast_predict_index, _get_historical_forecast_train_index, _historical_forecasts_general_checks, _historical_forecasts_sanitize_kwargs, + _process_historical_forecast_for_backtest, _reconciliate_historical_time_indices, ) from darts.utils.timeseries_generation import ( @@ -57,7 +59,7 @@ get_single_series, series2seq, ) -from darts.utils.utils import generate_index, n_steps_between +from darts.utils.utils import generate_index logger = get_logger(__name__) @@ -1398,58 +1400,13 @@ def backtest( # remember input series type series_seq_type = get_series_seq_type(series) - series = series2seq(series) - - # check that `historical_forecasts` have correct type - expected_seq_type = None - forecast_seq_type = get_series_seq_type(historical_forecasts) - if last_points_only and not series_seq_type == forecast_seq_type: - # lpo=True -> fc sequence type must be the same - expected_seq_type = series_seq_type - elif not last_points_only and forecast_seq_type != series_seq_type + 1: - # lpo=False -> fc sequence type must be one order higher - expected_seq_type = series_seq_type + 1 - - if expected_seq_type is not None: - raise_log( - ValueError( - f"Expected `historical_forecasts` of type {expected_seq_type} " - f"with `last_points_only={last_points_only}` and `series` of type " - f"{series_seq_type}. However, received `historical_forecasts` of type " - f"{forecast_seq_type}. Make sure to pass the same `last_points_only` " - f"value that was used to generate the historical forecasts." - ), - logger=logger, - ) - - # we must wrap each fc in a list if `last_points_only=True` - nested = last_points_only and forecast_seq_type == SeriesType.SEQ - historical_forecasts = series2seq( - historical_forecasts, seq_type_out=SeriesType.SEQ_SEQ, nested=nested + # validate historical forecasts and covert to multiple series with multiple forecasts case + series, historical_forecasts = _process_historical_forecast_for_backtest( + series=series, + historical_forecasts=historical_forecasts, + last_points_only=last_points_only, ) - # check that the number of series-specific forecasts corresponds to the - # number of series in `series` - if len(series) != len(historical_forecasts): - error_msg = ( - f"Mismatch between the number of series-specific `historical_forecasts` " - f"(n={len(historical_forecasts)}) and the number of `TimeSeries` in `series` " - f"(n={len(series)}). For `last_points_only={last_points_only}`, expected " - ) - expected_seq_type = ( - series_seq_type if last_points_only else series_seq_type + 1 - ) - if expected_seq_type == SeriesType.SINGLE: - error_msg += ( - f"a single `historical_forecasts` of type {expected_seq_type}." - ) - else: - error_msg += f"`historical_forecasts` of type {expected_seq_type} with length n={len(series)}." - raise_log( - ValueError(error_msg), - logger=logger, - ) - # we have multiple forecasts per series: rearrange forecasts to call each metric only once; # flatten historical forecasts, get matching target series index, remember cumulative target lengths # for later reshaping back to original @@ -2012,53 +1969,31 @@ def residuals( overlap_end=overlap_end, sample_weight=sample_weight, ) + # remember input series type series_seq_type = get_series_seq_type(series) + # validate historical forecasts and covert to multiple series with multiple forecasts case + series, historical_forecasts = _process_historical_forecast_for_backtest( + series=series, + historical_forecasts=historical_forecasts, + last_points_only=last_points_only, + ) # optionally, add nans to end of series to get residuals of same shape for each forecast if overlap_end: - # infer the forecast horizon based on the last forecast; allows user not to care about `forecast_horizon` - if series_seq_type == SeriesType.SINGLE: - hfc_last = ( - historical_forecasts - if last_points_only - else historical_forecasts[-1] - ) - series = [series] - else: - hfc_last = ( - historical_forecasts[0] - if last_points_only - else historical_forecasts[0][-1] - ) - horizon_ = n_steps_between( - hfc_last.end_time(), series[0].end_time(), freq=series[0].freq + series = _extend_series_for_overlap_end( + series=series, historical_forecasts=historical_forecasts ) - series = [s_.append_values(np.array([np.nan] * horizon_)) for s_ in series] - if series_seq_type == SeriesType.SINGLE: - series = series[0] residuals = self.backtest( series=series, historical_forecasts=historical_forecasts, - last_points_only=last_points_only, + last_points_only=False, metric=metric, reduction=None, metric_kwargs=metric_kwargs, ) - # convert forecasts and residuals to list of lists of series/arrays - forecast_seq_type = get_series_seq_type(historical_forecasts) - historical_forecasts = series2seq( - historical_forecasts, - seq_type_out=SeriesType.SEQ_SEQ, - nested=last_points_only and forecast_seq_type == SeriesType.SEQ, - ) - if series_seq_type == SeriesType.SINGLE: - residuals = [residuals] - if last_points_only: - residuals = [[res] for res in residuals] - # sanity check residual output try: res, fc = residuals[0][0], historical_forecasts[0][0] diff --git a/darts/utils/historical_forecasts/utils.py b/darts/utils/historical_forecasts/utils.py index 9099f9a44d..01bda9999d 100644 --- a/darts/utils/historical_forecasts/utils.py +++ b/darts/utils/historical_forecasts/utils.py @@ -14,8 +14,8 @@ from darts.logging import get_logger, raise_if_not, raise_log from darts.timeseries import TimeSeries -from darts.utils.ts_utils import get_series_seq_type, series2seq -from darts.utils.utils import generate_index +from darts.utils.ts_utils import SeriesType, get_series_seq_type, series2seq +from darts.utils.utils import generate_index, n_steps_between logger = get_logger(__name__) @@ -927,3 +927,93 @@ def _process_predict_start_points_bounds( bounds[:, 1] -= steps_too_long cum_lengths = np.cumsum(np.diff(bounds) // stride + 1) return bounds, cum_lengths + + +def _process_historical_forecast_for_backtest( + series: Union[TimeSeries, Sequence[TimeSeries]], + historical_forecasts: Union[ + TimeSeries, Sequence[TimeSeries], Sequence[Sequence[TimeSeries]] + ], + last_points_only: bool, +): + """Checks that the `historical_forecasts` have the correct format based on the input `series` and + `last_points_only`. If all checks have passed, it converts `series` and `historical_forecasts` format into a + multiple series case with `last_points_only=False`. + """ + # remember input series type + series_seq_type = get_series_seq_type(series) + series = series2seq(series) + + # check that `historical_forecasts` have correct type + expected_seq_type = None + forecast_seq_type = get_series_seq_type(historical_forecasts) + if last_points_only and not series_seq_type == forecast_seq_type: + # lpo=True -> fc sequence type must be the same + expected_seq_type = series_seq_type + elif not last_points_only and forecast_seq_type != series_seq_type + 1: + # lpo=False -> fc sequence type must be one order higher + expected_seq_type = series_seq_type + 1 + + if expected_seq_type is not None: + raise_log( + ValueError( + f"Expected `historical_forecasts` of type {expected_seq_type} " + f"with `last_points_only={last_points_only}` and `series` of type " + f"{series_seq_type}. However, received `historical_forecasts` of type " + f"{forecast_seq_type}. Make sure to pass the same `last_points_only` " + f"value that was used to generate the historical forecasts." + ), + logger=logger, + ) + + # we must wrap each fc in a list if `last_points_only=True` + nested = last_points_only and forecast_seq_type == SeriesType.SEQ + historical_forecasts = series2seq( + historical_forecasts, seq_type_out=SeriesType.SEQ_SEQ, nested=nested + ) + + # check that the number of series-specific forecasts corresponds to the + # number of series in `series` + if len(series) != len(historical_forecasts): + error_msg = ( + f"Mismatch between the number of series-specific `historical_forecasts` " + f"(n={len(historical_forecasts)}) and the number of `TimeSeries` in `series` " + f"(n={len(series)}). For `last_points_only={last_points_only}`, expected " + ) + expected_seq_type = series_seq_type if last_points_only else series_seq_type + 1 + if expected_seq_type == SeriesType.SINGLE: + error_msg += f"a single `historical_forecasts` of type {expected_seq_type}." + else: + error_msg += f"`historical_forecasts` of type {expected_seq_type} with length n={len(series)}." + raise_log( + ValueError(error_msg), + logger=logger, + ) + return series, historical_forecasts + + +def _extend_series_for_overlap_end( + series: Sequence[TimeSeries], + historical_forecasts: Sequence[Sequence[TimeSeries]], +): + """Extends each target `series` to the end of the last historical forecast for that series. + Fills the values all missing dates with `np.nan`. + + Assumes the input meets the multiple `series` case with `last_points_only=False` (e.g. the output of + `darts.utils.historical_forecasts.utils_process_historical_forecast_for_backtest()`). + """ + series_extended = [] + append_vals = [np.nan] * series[0].n_components + for series_, hfcs_ in zip(series, historical_forecasts): + # find number of missing target time steps based on the last forecast + missing_steps = n_steps_between( + hfcs_[-1].end_time(), series[0].end_time(), freq=series[0].freq + ) + # extend the target if it is too short + if missing_steps > 0: + series_extended.append( + series_.append_values(np.array([append_vals] * missing_steps)) + ) + else: + series_extended.append(series_) + return series_extended From c03eb17de7e86d5623fb25c38a58c435078afda4 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Tue, 9 Jul 2024 11:23:15 +0200 Subject: [PATCH 15/78] refactor calibration for predict and hist fc --- darts/models/cp/conformal_model.py | 315 +++++++++++++++++++---------- 1 file changed, 205 insertions(+), 110 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 10e4ff0102..9fce54ebde 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -43,7 +43,7 @@ def _triul_indices(forecast_horizon, n_comps): idx_horizon = forecast_horizon - 1 - idx_horizon # get component indices (already repeated) - idx_comp = [i for _ in range(len(idx_horizon)) for i in range(n_comps)] + idx_comp = np.array([i for _ in range(len(idx_horizon)) for i in range(n_comps)]) # repeat along the component dimension idx_horizon = idx_horizon.repeat(n_comps) @@ -78,8 +78,36 @@ def cqr_score_asym(row, quantile_lo_col, quantile_hi_col): ) -# TODO: fit conformal model (maybe for the future) -# - +def _calibration_residuals( + residuals, + start: Optional[int], + end: Optional[int], + last_points_only: bool, + forecast_horizon: Optional[int] = None, + cal_mask: Optional[Tuple[np.ndarray, np.ndarray, np.ndarray]] = None, +): + """Extract residuals used to calibrate the predictions of a forecasting model. + It guarantees: + - no look-ahead bias + """ + if last_points_only: + return residuals[start:end] + + cal_res = np.concatenate(residuals[start:end], axis=2) + # no masking required for horizon == 1 + if forecast_horizon == 1: + return cal_res + + # ignore upper left residuals to have same number of residuals per horizon + idx_horizon, idx_comp, idx_hfc = cal_mask + cal_res[idx_horizon, idx_comp, idx_hfc] = np.nan + # ignore lower right residuals to avoid look-ahead bias + cal_res[ + forecast_horizon - 1 - idx_horizon, + idx_comp, + cal_res.shape[2] - 1 - idx_hfc, + ] = np.nan + return cal_res class ConformalModel(GlobalForecastingModel): @@ -166,6 +194,26 @@ def predict( series = series2seq(series) past_covariates = series2seq(past_covariates) future_covariates = series2seq(future_covariates) + + # if a calibration set is given, use it. Otherwise, use past of input as calibration + if cal_series is None: + cal_series = series + cal_past_covariates = past_covariates + cal_future_covariates = future_covariates + + cal_series = series2seq(cal_series) + if len(cal_series) != len(series): + raise_log( + ValueError( + f"Mismatch between number of `cal_series` ({len(cal_series)}) " + f"and number of `series` ({len(series)})." + ), + logger=logger, + ) + cal_past_covariates = series2seq(cal_past_covariates) + cal_future_covariates = series2seq(cal_future_covariates) + + # generate model forecast to calibrate preds = self.model.predict( n=n, series=series, @@ -176,28 +224,14 @@ def predict( predict_likelihood_parameters=predict_likelihood_parameters, show_warnings=show_warnings, ) - - if cal_series is None: - series_ = series - past_covariates_ = past_covariates - future_covariates_ = future_covariates - else: - series_ = series2seq(cal_series) - if len(series_) != len(series): - raise_log( - ValueError( - f"Mismatch between number of `cal_series` ({len(series_)}) " - f"and number of `series` ({len(series)})." - ), - logger=logger, - ) - past_covariates_ = series2seq(cal_past_covariates) - future_covariates_ = series2seq(cal_future_covariates) - - hfcs = self.model.historical_forecasts( - series=series_, - past_covariates=past_covariates_, - future_covariates=future_covariates_, + # convert to multi series case with `last_points_only=False` + preds = [[pred] for pred in preds] + + # generate all possible forecasts for calibration + cal_hfcs = self.model.historical_forecasts( + series=cal_series, + past_covariates=cal_past_covariates, + future_covariates=cal_future_covariates, num_samples=num_samples, forecast_horizon=n, retrain=False, @@ -207,40 +241,22 @@ def predict( show_warnings=show_warnings, predict_likelihood_parameters=predict_likelihood_parameters, ) - - residuals = self.model.residuals( + cal_preds = self._calibrate_forecasts( series=series, - historical_forecasts=hfcs, - last_points_only=False, + forecasts=preds, + cal_series=cal_series, + cal_forecasts=cal_hfcs, + forecast_horizon=n, overlap_end=True, + last_points_only=False, verbose=verbose, show_warnings=show_warnings, - values_only=True, - metric=self.score_fn, ) - if self.method != "naive": - raise_log(NotImplementedError("non-naive not yet implemented")) - - # first: NAIVE only - cp_preds = [] - for series_, pred, res in zip(series, preds, residuals): - # convert to (horizon, n comps, hist fcs) - res = np.concatenate(res, axis=2) - q_hat = np.quantile(res, q=self.alpha, axis=2) - pred_vals = pred.values(copy=False) - cp_pred = np.concatenate( - [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 - ) - cp_pred = _build_forecast_series( - points_preds=cp_pred, - input_series=series_, - custom_columns=self._cp_component_names(series_), - time_index=pred._time_index, - with_static_covs=False, - with_hierarchy=False, - ) - cp_preds.append(cp_pred) - return cp_preds[0] if called_with_single_series else cp_preds + # convert historical forecasts output to simple forecast / prediction + if called_with_single_series: + return cal_preds[0][0] + else: + return [cp[0] for cp in cal_preds] # for step_number in range(1, self.n_forecasts + 1): # # conformalize # noncon_scores = self._get_nonconformity_scores(df_cal, step_number) @@ -317,13 +333,29 @@ def historical_forecasts( fit_kwargs: Optional[Dict[str, Any]] = None, predict_kwargs: Optional[Dict[str, Any]] = None, sample_weight: Optional[Union[TimeSeries, Sequence[TimeSeries], str]] = None, + cal_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + cal_past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + cal_future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, ) -> Union[TimeSeries, List[TimeSeries], List[List[TimeSeries]]]: called_with_single_series = get_series_seq_type(series) == SeriesType.SINGLE series = series2seq(series) past_covariates = series2seq(past_covariates) future_covariates = series2seq(future_covariates) - # generate all possible forecasts (overlap_end=True) + if cal_series is not None: + cal_series = series2seq(cal_series) + if len(cal_series) != len(series): + raise_log( + ValueError( + f"Mismatch between number of `cal_series` ({len(cal_series)}) " + f"and number of `series` ({len(series)})." + ), + logger=logger, + ) + cal_past_covariates = series2seq(cal_past_covariates) + cal_future_covariates = series2seq(cal_future_covariates) + + # generate all possible forecasts (overlap_end=True) to have enough residuals hfcs = self.model.historical_forecasts( series=series, past_covariates=past_covariates, @@ -340,6 +372,63 @@ def historical_forecasts( fit_kwargs=fit_kwargs, predict_kwargs=predict_kwargs, ) + # optionally, generate calibration forecasts + if cal_series is None: + cal_hfcs = None + else: + cal_hfcs = self.model.historical_forecasts( + series=cal_series, + past_covariates=cal_past_covariates, + future_covariates=cal_future_covariates, + num_samples=num_samples, + forecast_horizon=forecast_horizon, + retrain=False, + overlap_end=True, + last_points_only=last_points_only, + verbose=verbose, + show_warnings=show_warnings, + predict_likelihood_parameters=predict_likelihood_parameters, + enable_optimization=enable_optimization, + fit_kwargs=fit_kwargs, + predict_kwargs=predict_kwargs, + ) + calibrated_forecasts = self._calibrate_forecasts( + series=series, + forecasts=hfcs, + cal_series=cal_series, + cal_forecasts=cal_hfcs, + train_length=train_length, + start=start, + start_format=start_format, + forecast_horizon=forecast_horizon, + stride=stride, + overlap_end=overlap_end, + last_points_only=last_points_only, + verbose=verbose, + show_warnings=show_warnings, + ) + return ( + calibrated_forecasts[0] + if called_with_single_series + else calibrated_forecasts + ) + + def _calibrate_forecasts( + self, + series: Sequence[TimeSeries], + forecasts: Sequence[Sequence[TimeSeries]], + cal_series: Optional[Sequence[TimeSeries]] = None, + cal_forecasts: Optional[Sequence[Sequence[TimeSeries]]] = None, + train_length: Optional[int] = None, + start: Optional[Union[pd.Timestamp, float, int]] = None, + start_format: Literal["position", "value"] = "value", + forecast_horizon: int = 1, + stride: int = 1, + overlap_end: bool = False, + last_points_only: bool = True, + verbose: bool = False, + show_warnings: bool = True, + ) -> Union[TimeSeries, List[TimeSeries], List[List[TimeSeries]]]: # TODO: add support for: # - num_samples # - predict_likelihood_parameters @@ -353,9 +442,10 @@ def historical_forecasts( # - last_points_only = True # - add correct output components # - use only `train_length` previous residuals + residuals = self.model.residuals( - series=series, - historical_forecasts=hfcs, + series=series if cal_series is None else cal_series, + historical_forecasts=forecasts if cal_series is None else cal_forecasts, overlap_end=True, last_points_only=last_points_only, verbose=verbose, @@ -366,13 +456,11 @@ def historical_forecasts( # this mask is later used to avoid look-ahead bias and guarantee identical number of calibration # points per step in the forecast horizon. Only used in case of `last_points_only=False` - idx_horizon, idx_comp, idx_hfc = _triul_indices( - forecast_horizon, series[0].width - ) + cal_mask = _triul_indices(forecast_horizon, series[0].width) cp_hfcs = [] for series_idx, (series_, s_hfcs, res) in enumerate( - zip(series, hfcs, residuals) + zip(series, forecasts, residuals) ): cp_preds = [] @@ -395,14 +483,28 @@ def historical_forecasts( if last_fc_idx: last_fc_idx -= delta_end - # determine the first forecast index for conformal prediction; all forecasts before that are - # used for calibration - # we need at least 1 residual per point in the horizon - skip_n_train = forecast_horizon - - # plus some additional steps based on `train_length` - if train_length is not None: - skip_n_train += train_length - 1 + # determine the first forecast index for conformal prediction + if cal_series is None: + # all forecasts before that are used for calibration + # we need at least 1 residual per point in the horizon + skip_n_train = forecast_horizon + # plus some additional steps based on `train_length` + if train_length is not None: + skip_n_train += train_length - 1 + else: + # with a long enough calibration set, we can start from the first forecast + min_n_cal = max(train_length or 0, 1) + if len(residuals) < min_n_cal: + raise_log( + ValueError( + "Could not build a single calibration input with the provided " + f"`cal_series` and `cal_*_covariates` at series index: {series_idx}. " + f"Expected to generate at least `max(train_length, 1) = {min_n_cal}` " + f"calibration forecasts, but could only generate `{len(residuals)}`." + ), + logger=logger, + ) + skip_n_train = 0 # skip solely based on `start` skip_n_start = 0 @@ -461,15 +563,27 @@ def historical_forecasts( ), ) + # use fixed `q_hat` if calibration set is provided + q_hat = None + if cal_series is not None: + cal_res = _calibration_residuals( + res, + -train_length if train_length is not None else None, + None, + last_points_only=last_points_only, + forecast_horizon=forecast_horizon, + cal_mask=cal_mask, + ) + axis = 0 if last_points_only else 2 + q_hat = np.nanquantile(cal_res, q=self.alpha, axis=axis) + # historical conformal prediction if last_points_only: for idx, pred_vals in enumerate( s_hfcs.values(copy=False)[first_fc_idx:last_fc_idx:stride] ): pred_vals = np.expand_dims(pred_vals, 0) - if not first_fc_idx and not idx: - cp_pred = np.concatenate([pred_vals] * 3, axis=1) - else: + if cal_series is None: # get the last residual index for calibration, `cal_end` is exclusive # to avoid look-ahead bias, use only residuals from before the historical forecast start point; # since we look at `last_points only=True`, the last residual historically available at @@ -480,11 +594,13 @@ def historical_forecasts( cal_start = ( cal_end - train_length if train_length is not None else None ) - cal_res = res[cal_start:cal_end] - q_hat = np.nanquantile(cal_res, q=self.alpha, axis=0) - cp_pred = np.concatenate( - [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 + cal_res = _calibration_residuals( + res, cal_start, cal_end, last_points_only=last_points_only ) + q_hat = np.nanquantile(cal_res, q=self.alpha, axis=0) + cp_pred = np.concatenate( + [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 + ) cp_preds.append(cp_pred) cp_preds = _build_forecast_series( points_preds=np.concatenate(cp_preds, axis=0), @@ -503,9 +619,7 @@ def historical_forecasts( for idx, pred in enumerate(s_hfcs[first_fc_idx:last_fc_idx:stride]): # convert to (horizon, n comps, hist fcs) pred_vals = pred.values(copy=False) - if not first_fc_idx and not idx: - cp_pred = np.concatenate([pred_vals] * 3, axis=1) - else: + if cal_series is None: # get the last residual index for calibration, `cal_end` is exclusive # to avoid look-ahead bias, use only residuals from before the historical forecast start point; # since we look at `last_points only=False`, the last residual historically available at @@ -519,19 +633,18 @@ def historical_forecasts( if train_length is not None else None ) - cal_res = np.concatenate(res[cal_start:cal_end], axis=2) - # ignore upper left residuals to have same number of residuals per horizon - cal_res[idx_horizon, idx_comp, idx_hfc] = np.nan - # ignore lower right residuals to avoid look-ahead bias - cal_res[ - forecast_horizon - 1 - idx_horizon, - idx_comp, - cal_res.shape[2] - 1 - idx_hfc, - ] = np.nan - q_hat = np.nanquantile(cal_res, q=self.alpha, axis=2) - cp_pred = np.concatenate( - [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 + cal_res = _calibration_residuals( + res, + cal_start, + cal_end, + last_points_only=last_points_only, + forecast_horizon=forecast_horizon, + cal_mask=cal_mask, ) + q_hat = np.nanquantile(cal_res, q=self.alpha, axis=2) + cp_pred = np.concatenate( + [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 + ) cp_pred = _build_forecast_series( points_preds=cp_pred, input_series=series_, @@ -542,25 +655,7 @@ def historical_forecasts( ) cp_preds.append(cp_pred) cp_hfcs.append(cp_preds) - return cp_hfcs[0] if called_with_single_series else cp_hfcs - - def _calibrate_forecasts( - self, - series: Union[TimeSeries, Sequence[TimeSeries]], - forecasts: Union[TimeSeries, Sequence[TimeSeries]], - cal_series: Union[TimeSeries, Sequence[TimeSeries]], - cal_forecasts: Union[TimeSeries, Sequence[TimeSeries]], - train_length: Optional[int] = None, - start: Optional[Union[pd.Timestamp, float, int]] = None, - start_format: Literal["position", "value"] = "value", - forecast_horizon: int = 1, - stride: int = 1, - overlap_end: bool = False, - last_points_only: bool = True, - verbose: bool = False, - show_warnings: bool = True, - ): - pass + return cp_hfcs def _get_nonconformity_scores(self, df_cal: pd.DataFrame, step_number: int) -> dict: """Get the nonconformity scores using the given conformal prediction technique. From d31f459904481456241062ea808449b474e4bd80 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Tue, 9 Jul 2024 13:09:43 +0200 Subject: [PATCH 16/78] base and child conformal --- darts/models/__init__.py | 10 ++-- darts/models/cp/conformal_model.py | 54 +++++++++++++++---- .../forecasting/test_conformal_model.py | 20 +++---- .../forecasting/test_historical_forecasts.py | 6 +-- 4 files changed, 61 insertions(+), 29 deletions(-) diff --git a/darts/models/__init__.py b/darts/models/__init__.py index 361c4018e1..68e75fc7a2 100644 --- a/darts/models/__init__.py +++ b/darts/models/__init__.py @@ -109,15 +109,15 @@ XGBModel = NotImportedModule(module_name="XGBoost") # Conformal Prediction -from darts.models.cp.conformal_model import ConformalModel -from darts.models.filtering.gaussian_process_filter import GaussianProcessFilter -from darts.models.filtering.kalman_filter import KalmanFilter +from darts.models.cp.conformal_model import NaiveConformalModel # Filtering +from darts.models.filtering.gaussian_process_filter import GaussianProcessFilter +from darts.models.filtering.kalman_filter import KalmanFilter from darts.models.filtering.moving_average_filter import MovingAverageFilter -from darts.models.forecasting.baselines import NaiveEnsembleModel # Ensembling +from darts.models.forecasting.baselines import NaiveEnsembleModel from darts.models.forecasting.ensemble_model import EnsembleModel __all__ = [ @@ -167,5 +167,5 @@ "MovingAverageFilter", "NaiveEnsembleModel", "EnsembleModel", - "ConformalModel", + "NaiveConformalModel", ] diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 9fce54ebde..fa84c975ef 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -1,4 +1,5 @@ import re +from abc import ABC, abstractmethod from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union try: @@ -110,7 +111,7 @@ def _calibration_residuals( return cal_res -class ConformalModel(GlobalForecastingModel): +class ConformalModel(GlobalForecastingModel, ABC): def __init__( self, model, @@ -161,7 +162,6 @@ def __init__( self.method = method self.quantiles = quantiles self._fit_called = True - self.score_fn = darts.metrics.ae @property def output_chunk_length(self) -> Optional[int]: @@ -416,9 +416,11 @@ def historical_forecasts( def _calibrate_forecasts( self, series: Sequence[TimeSeries], - forecasts: Sequence[Sequence[TimeSeries]], + forecasts: Union[Sequence[Sequence[TimeSeries]], Sequence[TimeSeries]], cal_series: Optional[Sequence[TimeSeries]] = None, - cal_forecasts: Optional[Sequence[Sequence[TimeSeries]]] = None, + cal_forecasts: Optional[ + Union[Sequence[Sequence[TimeSeries]], Sequence[TimeSeries]] + ] = None, train_length: Optional[int] = None, start: Optional[Union[pd.Timestamp, float, int]] = None, start_format: Literal["position", "value"] = "value", @@ -451,7 +453,7 @@ def _calibrate_forecasts( verbose=verbose, show_warnings=show_warnings, values_only=True, - metric=self.score_fn, + metric=self._residuals_metric, ) # this mask is later used to avoid look-ahead bias and guarantee identical number of calibration @@ -574,8 +576,9 @@ def _calibrate_forecasts( forecast_horizon=forecast_horizon, cal_mask=cal_mask, ) - axis = 0 if last_points_only else 2 - q_hat = np.nanquantile(cal_res, q=self.alpha, axis=axis) + q_hat = self._calibrate_interval( + cal_res, last_points_only=last_points_only + ) # historical conformal prediction if last_points_only: @@ -597,9 +600,11 @@ def _calibrate_forecasts( cal_res = _calibration_residuals( res, cal_start, cal_end, last_points_only=last_points_only ) - q_hat = np.nanquantile(cal_res, q=self.alpha, axis=0) + q_hat = self._calibrate_interval( + cal_res, last_points_only=last_points_only + ) cp_pred = np.concatenate( - [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 + [pred_vals + q_hat[0], pred_vals, pred_vals + q_hat[1]], axis=1 ) cp_preds.append(cp_pred) cp_preds = _build_forecast_series( @@ -641,9 +646,11 @@ def _calibrate_forecasts( forecast_horizon=forecast_horizon, cal_mask=cal_mask, ) - q_hat = np.nanquantile(cal_res, q=self.alpha, axis=2) + q_hat = self._calibrate_interval( + cal_res, last_points_only=last_points_only + ) cp_pred = np.concatenate( - [pred_vals - q_hat, pred_vals, pred_vals + q_hat], axis=1 + [pred_vals + q_hat[0], pred_vals, pred_vals + q_hat[1]], axis=1 ) cp_pred = _build_forecast_series( points_preds=cp_pred, @@ -657,6 +664,17 @@ def _calibrate_forecasts( cp_hfcs.append(cp_preds) return cp_hfcs + @abstractmethod + def _calibrate_interval( + self, residuals: np.ndarray, last_points_only: bool + ) -> Tuple[np.ndarray, np.ndarray]: + """Computes the upper and lower calibrated forecast intervals based on residuals.""" + + @property + @abstractmethod + def _residuals_metric(self): + """Gives the "per time step" metric used to compute residuals.""" + def _get_nonconformity_scores(self, df_cal: pd.DataFrame, step_number: int) -> dict: """Get the nonconformity scores using the given conformal prediction technique. @@ -880,3 +898,17 @@ def _get_evaluate_metrics_from_dataset( miscoverage_rate = 1 - coverage_rate return interval_width, miscoverage_rate + + +class NaiveConformalModel(ConformalModel): + def _calibrate_interval( + self, residuals: np.ndarray, last_points_only: bool + ) -> Tuple[np.ndarray, np.ndarray]: + """Computes the lower and upper calibrated forecast intervals based on residuals.""" + axis = 0 if last_points_only else 2 + q_hat = np.nanquantile(residuals, q=self.alpha, axis=axis) + return -q_hat, q_hat + + @property + def _residuals_metric(self): + return darts.metrics.ae diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 30c875831e..760ddd8ade 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -8,8 +8,8 @@ from darts import TimeSeries from darts.logging import get_logger from darts.models import ( - ConformalModel, LinearRegressionModel, + NaiveConformalModel, NaiveSeasonal, ) from darts.utils import timeseries_generation as tg @@ -198,30 +198,30 @@ def test_model_construction(self): model_err_msg = "`model` must be a pre-trained `GlobalForecastingModel`." # un-trained local model with pytest.raises(ValueError) as exc: - ConformalModel(model=local_model, alpha=0.8, method=method) + NaiveConformalModel(model=local_model, alpha=0.8, method=method) assert str(exc.value) == model_err_msg # pre-trained local model local_model.fit(series) with pytest.raises(ValueError) as exc: - ConformalModel(model=local_model, alpha=0.8, method=method) + NaiveConformalModel(model=local_model, alpha=0.8, method=method) assert str(exc.value) == model_err_msg # un-trained global model with pytest.raises(ValueError) as exc: - ConformalModel(model=global_model, alpha=0.8, method=method) + NaiveConformalModel(model=global_model, alpha=0.8, method=method) assert str(exc.value) == model_err_msg # pre-trained local model should work global_model.fit(series) - _ = ConformalModel(model=global_model, alpha=0.8, method=method) + _ = NaiveConformalModel(model=global_model, alpha=0.8, method=method) @pytest.mark.parametrize("model_cls", models) def test_predict_runnability(self, model_cls): # testing lags_past_covariates None but past_covariates during prediction model_instance = model_cls(lags=4, lags_past_covariates=None) model_instance.fit(self.sine_univariate1) - model = ConformalModel(model_instance, alpha=0.8, method="naive") + model = NaiveConformalModel(model_instance, alpha=0.8, method="naive") # cannot pass past covariates with pytest.raises(ValueError): model.predict( @@ -238,7 +238,7 @@ def test_predict_runnability(self, model_cls): model_instance.fit( [self.sine_univariate1] * 2, past_covariates=[self.sine_univariate1] * 2 ) - model = ConformalModel(model_instance, alpha=0.8, method="naive") + model = NaiveConformalModel(model_instance, alpha=0.8, method="naive") with pytest.raises(ValueError) as exc: model.predict(n=1, series=self.sine_univariate1) assert ( @@ -266,7 +266,7 @@ def test_predict_runnability(self, model_cls): model_instance.fit( [self.sine_univariate1] * 2, future_covariates=[self.sine_univariate1] * 2 ) - model = ConformalModel(model_instance, alpha=0.8, method="naive") + model = NaiveConformalModel(model_instance, alpha=0.8, method="naive") with pytest.raises(ValueError) as exc: model.predict(n=1, series=self.sine_univariate1) assert ( @@ -290,7 +290,7 @@ def test_predict_runnability(self, model_cls): # test input dim model_instance = model_cls(lags=4) model_instance.fit(self.sine_univariate1) - model = ConformalModel(model_instance, alpha=0.8, method="naive") + model = NaiveConformalModel(model_instance, alpha=0.8, method="naive") with pytest.raises(ValueError) as exc: model.predict( n=1, series=self.sine_univariate1.stack(self.sine_univariate1) @@ -348,7 +348,7 @@ def test_predict(self, config): lags=icl, output_chunk_length=ocl, **model_kwargs ) model_instance.fit(series=series, past_covariates=pc, future_covariates=fc) - model = ConformalModel(model_instance, alpha=0.8, method="naive") + model = NaiveConformalModel(model_instance, alpha=0.8, method="naive") preds = model.predict( n=horizon, series=series, past_covariates=pc, future_covariates=fc diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index 65227c4711..bc867f8872 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -13,9 +13,9 @@ ARIMA, AutoARIMA, CatBoostModel, - ConformalModel, LightGBMModel, LinearRegressionModel, + NaiveConformalModel, NaiveDrift, NaiveSeasonal, NotImportedModule, @@ -2593,7 +2593,7 @@ def test_conformal_historical_forecasts(self, config): forecasting_model.fit(series_train, past_covariates=pc, future_covariates=fc) - model = ConformalModel(forecasting_model, alpha=0.8, method="naive") + model = NaiveConformalModel(forecasting_model, alpha=0.8, method="naive") if use_multi_series: series_val = [ @@ -2744,7 +2744,7 @@ def test_conformal_historical_start_train_length(self, config): start = series_val.time_index[start_position] else: start = start_position - model = ConformalModel(forecasting_model, alpha=0.8, method="naive") + model = NaiveConformalModel(forecasting_model, alpha=0.8, method="naive") if use_multi_series: series_val = [ From ff2beabed816cbd049785a5666e1a90e29d292e6 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Wed, 10 Jul 2024 10:12:29 +0200 Subject: [PATCH 17/78] checks for calibration set --- darts/models/cp/conformal_model.py | 35 ++++++----- .../forecasting/test_conformal_model.py | 19 +++--- .../forecasting/test_historical_forecasts.py | 62 +++++++++++++++++-- 3 files changed, 84 insertions(+), 32 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index fa84c975ef..24f82d4825 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -116,10 +116,9 @@ def __init__( self, model, alpha: Union[float, Tuple[float, float]], - method: str, quantiles: Optional[List[float]] = None, ): - """Conformal prediction dataclass + """Base Conformal Prediction Model Parameters ---------- @@ -128,11 +127,6 @@ def __init__( alpha Significance level of the prediction interval, float if coverage error spread arbitrarily over left and right tails, tuple of two floats for different coverage error over left and right tails respectively - method - The conformal prediction technique to use: - - - `"naive"` for the Naive or Absolute Residual method - - `"cqr"` for Conformalized Quantile Regression quantiles Optionally, a list of quantiles from the quantile regression `model` to use. """ @@ -141,11 +135,6 @@ def __init__( ValueError("`model` must be a pre-trained `GlobalForecastingModel`."), logger=logger, ) - if method == "naive" and not isinstance(alpha, float): - raise_log( - ValueError(f"`alpha` must be a `float` when `method={method}`."), - logger=logger, - ) super().__init__(add_encoders=None) if isinstance(alpha, float): @@ -159,7 +148,6 @@ def __init__( self.model = model self.noncon_scores = dict() self.alpha = alpha - self.method = method self.quantiles = quantiles self._fit_called = True @@ -496,13 +484,15 @@ def _calibrate_forecasts( else: # with a long enough calibration set, we can start from the first forecast min_n_cal = max(train_length or 0, 1) - if len(residuals) < min_n_cal: + if not last_points_only: + min_n_cal += forecast_horizon - 1 + if len(res) < min_n_cal: raise_log( ValueError( "Could not build a single calibration input with the provided " f"`cal_series` and `cal_*_covariates` at series index: {series_idx}. " - f"Expected to generate at least `max(train_length, 1) = {min_n_cal}` " - f"calibration forecasts, but could only generate `{len(residuals)}`." + f"Expected to generate at least `{min_n_cal}` calibration forecasts, " + f"but could only generate `{len(res)}`." ), logger=logger, ) @@ -568,9 +558,12 @@ def _calibrate_forecasts( # use fixed `q_hat` if calibration set is provided q_hat = None if cal_series is not None: + cal_start = -train_length if train_length else 0 + if not last_points_only: + cal_start -= forecast_horizon - 1 cal_res = _calibration_residuals( res, - -train_length if train_length is not None else None, + cal_start, None, last_points_only=last_points_only, forecast_horizon=forecast_horizon, @@ -901,6 +894,14 @@ def _get_evaluate_metrics_from_dataset( class NaiveConformalModel(ConformalModel): + def __init__(self, model, alpha: Union[float, Tuple[float, float]]): + if not isinstance(alpha, float): + raise_log( + ValueError("`alpha` must be a `float`."), + logger=logger, + ) + super().__init__(model=model, alpha=alpha) + def _calibrate_interval( self, residuals: np.ndarray, last_points_only: bool ) -> Tuple[np.ndarray, np.ndarray]: diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 760ddd8ade..7226e147ec 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -194,34 +194,33 @@ def test_model_construction(self): global_model = LinearRegressionModel(lags=5, output_chunk_length=1) series = self.target_series[0][:10] - method = "naive" model_err_msg = "`model` must be a pre-trained `GlobalForecastingModel`." # un-trained local model with pytest.raises(ValueError) as exc: - NaiveConformalModel(model=local_model, alpha=0.8, method=method) + NaiveConformalModel(model=local_model, alpha=0.8) assert str(exc.value) == model_err_msg # pre-trained local model local_model.fit(series) with pytest.raises(ValueError) as exc: - NaiveConformalModel(model=local_model, alpha=0.8, method=method) + NaiveConformalModel(model=local_model, alpha=0.8) assert str(exc.value) == model_err_msg # un-trained global model with pytest.raises(ValueError) as exc: - NaiveConformalModel(model=global_model, alpha=0.8, method=method) + NaiveConformalModel(model=global_model, alpha=0.0) assert str(exc.value) == model_err_msg # pre-trained local model should work global_model.fit(series) - _ = NaiveConformalModel(model=global_model, alpha=0.8, method=method) + _ = NaiveConformalModel(model=global_model, alpha=0.8) @pytest.mark.parametrize("model_cls", models) def test_predict_runnability(self, model_cls): # testing lags_past_covariates None but past_covariates during prediction model_instance = model_cls(lags=4, lags_past_covariates=None) model_instance.fit(self.sine_univariate1) - model = NaiveConformalModel(model_instance, alpha=0.8, method="naive") + model = NaiveConformalModel(model_instance, alpha=0.8) # cannot pass past covariates with pytest.raises(ValueError): model.predict( @@ -238,7 +237,7 @@ def test_predict_runnability(self, model_cls): model_instance.fit( [self.sine_univariate1] * 2, past_covariates=[self.sine_univariate1] * 2 ) - model = NaiveConformalModel(model_instance, alpha=0.8, method="naive") + model = NaiveConformalModel(model_instance, alpha=0.8) with pytest.raises(ValueError) as exc: model.predict(n=1, series=self.sine_univariate1) assert ( @@ -266,7 +265,7 @@ def test_predict_runnability(self, model_cls): model_instance.fit( [self.sine_univariate1] * 2, future_covariates=[self.sine_univariate1] * 2 ) - model = NaiveConformalModel(model_instance, alpha=0.8, method="naive") + model = NaiveConformalModel(model_instance, alpha=0.8) with pytest.raises(ValueError) as exc: model.predict(n=1, series=self.sine_univariate1) assert ( @@ -290,7 +289,7 @@ def test_predict_runnability(self, model_cls): # test input dim model_instance = model_cls(lags=4) model_instance.fit(self.sine_univariate1) - model = NaiveConformalModel(model_instance, alpha=0.8, method="naive") + model = NaiveConformalModel(model_instance, alpha=0.8) with pytest.raises(ValueError) as exc: model.predict( n=1, series=self.sine_univariate1.stack(self.sine_univariate1) @@ -348,7 +347,7 @@ def test_predict(self, config): lags=icl, output_chunk_length=ocl, **model_kwargs ) model_instance.fit(series=series, past_covariates=pc, future_covariates=fc) - model = NaiveConformalModel(model_instance, alpha=0.8, method="naive") + model = NaiveConformalModel(model_instance, alpha=0.8) preds = model.predict( n=horizon, series=series, past_covariates=pc, future_covariates=fc diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index bc867f8872..a9a7444cb9 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -2593,7 +2593,7 @@ def test_conformal_historical_forecasts(self, config): forecasting_model.fit(series_train, past_covariates=pc, future_covariates=fc) - model = NaiveConformalModel(forecasting_model, alpha=0.8, method="naive") + model = NaiveConformalModel(forecasting_model, alpha=0.8) if use_multi_series: series_val = [ @@ -2699,7 +2699,8 @@ def test_conformal_historical_forecasts(self, config): ), ) def test_conformal_historical_start_train_length(self, config): - """Tests naive conformal model with start and train length.""" + """Tests naive conformal model with start, train length, calibration set, and center forecasts against + the forecasting model's forecast.""" ( last_points_only, train_length, @@ -2744,7 +2745,7 @@ def test_conformal_historical_start_train_length(self, config): start = series_val.time_index[start_position] else: start = start_position - model = NaiveConformalModel(forecasting_model, alpha=0.8, method="naive") + model = NaiveConformalModel(forecasting_model, alpha=0.8) if use_multi_series: series_val = [ @@ -2763,21 +2764,48 @@ def test_conformal_historical_start_train_length(self, config): last_points_only=last_points_only, forecast_horizon=horizon, ) + # using a calibration series should be able to calibrate all historical forecasts + # from the base forecasting model + hist_fct_all = forecasting_model.historical_forecasts( + series=series_val, + retrain=False, + start=start, + start_format=start_format, + last_points_only=last_points_only, + forecast_horizon=horizon, + ) + hist_fct_cal = model.historical_forecasts( + series=series_val, + cal_series=series_val, + retrain=False, + train_length=train_length, + start=start, + start_format=start_format, + last_points_only=last_points_only, + forecast_horizon=horizon, + ) if not isinstance(series_val, list): series_val = [series_val] hist_fct = [hist_fct] + hist_fct_all = [hist_fct_all] + hist_fct_cal = [hist_fct_cal] for idx, ( series, hfc, - ) in enumerate(zip(series_val, hist_fct)): + hfc_all, + hfc_cal, + ) in enumerate(zip(series_val, hist_fct, hist_fct_all, hist_fct_cal)): if not isinstance(hfc, list): hfc = [hfc] + hfc_all = [hfc_all] + hfc_cal = [hfc_cal] # multi series: second series is shifted by one time step (+/- idx); # start_format = "value" requires a shift add_start_series_2 = idx * int(use_start) * int(start_format == "value") + n_preds_without_overlap = ( len(series) - icl @@ -2808,7 +2836,7 @@ def test_conformal_historical_start_train_length(self, config): cols_excpected = [] for col in series.columns: cols_excpected += [f"{col}_q_lo", f"{col}_q_md", f"{col}_q_hi"] - # check length match between optimized and default hist fc + # check historical forecasts dimensions assert len(hfc) == n_pred_series_expected # check hist fc start assert hfc[0].start_time() == first_ts_expected @@ -2817,3 +2845,27 @@ def test_conformal_historical_start_train_length(self, config): for hfc_ in hfc: assert hfc_.columns.tolist() == cols_excpected assert len(hfc_) == n_pred_points_expected + + # with a calibration set, we can calibrate all possible historical forecasts from base forecasting model + assert len(hfc_cal) == len(hfc_all) + for hfc_all_, hfc_cal_ in zip(hfc_all, hfc_cal): + assert hfc_all_.start_time() == hfc_cal_.start_time() + assert len(hfc_all_) == len(hfc_cal_) + assert hfc_all_.freq == hfc_cal_.freq + + # the center forecast must be equal to the forecasting model's forecast + np.testing.assert_array_almost_equal( + hfc_all_.all_values(), hfc_cal_.all_values()[:, 1:2] + ) + + # check that with a calibration set, all prediction intervals have the same width + vals_cal_0 = hfc_cal[0].values() + vals_cal_i = hfc_cal_.values() + np.testing.assert_array_almost_equal( + vals_cal_0[:, 0] - vals_cal_0[:, 1], + vals_cal_i[:, 0] - vals_cal_i[:, 1], + ) + np.testing.assert_array_almost_equal( + vals_cal_0[:, 1] - vals_cal_0[:, 2], + vals_cal_i[:, 1] - vals_cal_i[:, 2], + ) From 522ee9d305aef1521d2c25c21c9707bfa78a1e56 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Wed, 10 Jul 2024 10:16:31 +0200 Subject: [PATCH 18/78] rename conformal naive model --- darts/models/__init__.py | 6 +++--- darts/models/cp/conformal_model.py | 2 +- .../forecasting/test_conformal_model.py | 20 +++++++++---------- .../forecasting/test_historical_forecasts.py | 6 +++--- 4 files changed, 17 insertions(+), 17 deletions(-) diff --git a/darts/models/__init__.py b/darts/models/__init__.py index 68e75fc7a2..41554e98b2 100644 --- a/darts/models/__init__.py +++ b/darts/models/__init__.py @@ -109,7 +109,7 @@ XGBModel = NotImportedModule(module_name="XGBoost") # Conformal Prediction -from darts.models.cp.conformal_model import NaiveConformalModel +from darts.models.cp.conformal_model import ConformalNaiveModel # Filtering from darts.models.filtering.gaussian_process_filter import GaussianProcessFilter @@ -142,7 +142,7 @@ "VARIMA", "BlockRNNModel", "DLinearModel", - "GlobalNaiveDrift", + "GlobalNaiveAggregate", "GlobalNaiveDrift", "GlobalNaiveSeasonal", "NBEATSModel", @@ -167,5 +167,5 @@ "MovingAverageFilter", "NaiveEnsembleModel", "EnsembleModel", - "NaiveConformalModel", + "ConformalNaiveModel", ] diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 24f82d4825..d8d2af0b75 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -893,7 +893,7 @@ def _get_evaluate_metrics_from_dataset( return interval_width, miscoverage_rate -class NaiveConformalModel(ConformalModel): +class ConformalNaiveModel(ConformalModel): def __init__(self, model, alpha: Union[float, Tuple[float, float]]): if not isinstance(alpha, float): raise_log( diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 7226e147ec..b3728de3b5 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -8,8 +8,8 @@ from darts import TimeSeries from darts.logging import get_logger from darts.models import ( + ConformalNaiveModel, LinearRegressionModel, - NaiveConformalModel, NaiveSeasonal, ) from darts.utils import timeseries_generation as tg @@ -197,30 +197,30 @@ def test_model_construction(self): model_err_msg = "`model` must be a pre-trained `GlobalForecastingModel`." # un-trained local model with pytest.raises(ValueError) as exc: - NaiveConformalModel(model=local_model, alpha=0.8) + ConformalNaiveModel(model=local_model, alpha=0.8) assert str(exc.value) == model_err_msg # pre-trained local model local_model.fit(series) with pytest.raises(ValueError) as exc: - NaiveConformalModel(model=local_model, alpha=0.8) + ConformalNaiveModel(model=local_model, alpha=0.8) assert str(exc.value) == model_err_msg # un-trained global model with pytest.raises(ValueError) as exc: - NaiveConformalModel(model=global_model, alpha=0.0) + ConformalNaiveModel(model=global_model, alpha=0.0) assert str(exc.value) == model_err_msg # pre-trained local model should work global_model.fit(series) - _ = NaiveConformalModel(model=global_model, alpha=0.8) + _ = ConformalNaiveModel(model=global_model, alpha=0.8) @pytest.mark.parametrize("model_cls", models) def test_predict_runnability(self, model_cls): # testing lags_past_covariates None but past_covariates during prediction model_instance = model_cls(lags=4, lags_past_covariates=None) model_instance.fit(self.sine_univariate1) - model = NaiveConformalModel(model_instance, alpha=0.8) + model = ConformalNaiveModel(model_instance, alpha=0.8) # cannot pass past covariates with pytest.raises(ValueError): model.predict( @@ -237,7 +237,7 @@ def test_predict_runnability(self, model_cls): model_instance.fit( [self.sine_univariate1] * 2, past_covariates=[self.sine_univariate1] * 2 ) - model = NaiveConformalModel(model_instance, alpha=0.8) + model = ConformalNaiveModel(model_instance, alpha=0.8) with pytest.raises(ValueError) as exc: model.predict(n=1, series=self.sine_univariate1) assert ( @@ -265,7 +265,7 @@ def test_predict_runnability(self, model_cls): model_instance.fit( [self.sine_univariate1] * 2, future_covariates=[self.sine_univariate1] * 2 ) - model = NaiveConformalModel(model_instance, alpha=0.8) + model = ConformalNaiveModel(model_instance, alpha=0.8) with pytest.raises(ValueError) as exc: model.predict(n=1, series=self.sine_univariate1) assert ( @@ -289,7 +289,7 @@ def test_predict_runnability(self, model_cls): # test input dim model_instance = model_cls(lags=4) model_instance.fit(self.sine_univariate1) - model = NaiveConformalModel(model_instance, alpha=0.8) + model = ConformalNaiveModel(model_instance, alpha=0.8) with pytest.raises(ValueError) as exc: model.predict( n=1, series=self.sine_univariate1.stack(self.sine_univariate1) @@ -347,7 +347,7 @@ def test_predict(self, config): lags=icl, output_chunk_length=ocl, **model_kwargs ) model_instance.fit(series=series, past_covariates=pc, future_covariates=fc) - model = NaiveConformalModel(model_instance, alpha=0.8) + model = ConformalNaiveModel(model_instance, alpha=0.8) preds = model.predict( n=horizon, series=series, past_covariates=pc, future_covariates=fc diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index a9a7444cb9..1c4d946e9e 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -13,9 +13,9 @@ ARIMA, AutoARIMA, CatBoostModel, + ConformalNaiveModel, LightGBMModel, LinearRegressionModel, - NaiveConformalModel, NaiveDrift, NaiveSeasonal, NotImportedModule, @@ -2593,7 +2593,7 @@ def test_conformal_historical_forecasts(self, config): forecasting_model.fit(series_train, past_covariates=pc, future_covariates=fc) - model = NaiveConformalModel(forecasting_model, alpha=0.8) + model = ConformalNaiveModel(forecasting_model, alpha=0.8) if use_multi_series: series_val = [ @@ -2745,7 +2745,7 @@ def test_conformal_historical_start_train_length(self, config): start = series_val.time_index[start_position] else: start = start_position - model = NaiveConformalModel(forecasting_model, alpha=0.8) + model = ConformalNaiveModel(forecasting_model, alpha=0.8) if use_multi_series: series_val = [ From 1b40a409a35f93b4d4bb1980a6d1bbccbee0167b Mon Sep 17 00:00:00 2001 From: dennisbader Date: Wed, 10 Jul 2024 13:44:04 +0200 Subject: [PATCH 19/78] add additional forecasting model logic --- darts/models/cp/conformal_model.py | 120 +++++++++-- darts/models/forecasting/ensemble_model.py | 3 +- .../test_global_forecasting_models.py | 189 ++++++++++-------- 3 files changed, 207 insertions(+), 105 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index d8d2af0b75..152d7865b0 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -151,10 +151,6 @@ def __init__( self.quantiles = quantiles self._fit_called = True - @property - def output_chunk_length(self) -> Optional[int]: - return self.model.output_chunk_length - def fit( self, series: Union[TimeSeries, Sequence[TimeSeries]], @@ -178,11 +174,40 @@ def predict( cal_past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, cal_future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, ) -> Union[TimeSeries, Sequence[TimeSeries]]: + if series is None: + # then there must be a single TS, and that was saved in super().fit as self.training_series + if self.training_series is None: + raise_log( + ValueError( + "Input `series` must be provided. This is the result either from fitting on multiple series, " + "or from not having fit the model yet." + ), + logger, + ) + series = self.training_series + called_with_single_series = get_series_seq_type(series) == SeriesType.SINGLE + + # guarantee that all inputs are either list of TimeSeries or None series = series2seq(series) + if past_covariates is None and self.past_covariate_series is not None: + past_covariates = [self.past_covariate_series] * len(series) + if future_covariates is None and self.future_covariate_series is not None: + future_covariates = [self.future_covariate_series] * len(series) past_covariates = series2seq(past_covariates) future_covariates = series2seq(future_covariates) + super().predict( + n, + series, + past_covariates, + future_covariates, + num_samples, + verbose, + predict_likelihood_parameters, + show_warnings, + ) + # if a calibration set is given, use it. Otherwise, use past of input as calibration if cal_series is None: cal_series = series @@ -770,17 +795,16 @@ def _cp_component_names(self, input_series) -> List[str]: ] @property - def _model_encoder_settings( - self, - ) -> Tuple[ - Optional[int], - Optional[int], - bool, - bool, - Optional[List[int]], - Optional[List[int]], - ]: - return None, None, False, False, None, None + def output_chunk_length(self) -> Optional[int]: + return self.model.output_chunk_length + + @property + def output_chunk_shift(self) -> int: + return self.model.output_chunk_shift + + @property + def _model_encoder_settings(self): + raise NotImplementedError(f"not supported by `{self.__class__.__name__}`.") @property def extreme_lags( @@ -795,11 +819,75 @@ def extreme_lags( int, Optional[int], ]: - return self.model.extreme_lags + raise NotImplementedError(f"not supported by `{self.__class__.__name__}`.") + + @property + def min_train_series_length(self) -> int: + raise NotImplementedError(f"not supported by `{self.__class__.__name__}`.") + + @property + def min_train_samples(self) -> int: + raise NotImplementedError(f"not supported by `{self.__class__.__name__}`.") def supports_multivariate(self) -> bool: return self.model.supports_multivariate + @property + def supports_past_covariates(self) -> bool: + return self.model.supports_past_covariates + + @property + def supports_future_covariates(self) -> bool: + return self.model.supports_future_covariates + + @property + def supports_static_covariates(self) -> bool: + return self.model.supports_static_covariates + + @property + def supports_sample_weight(self) -> bool: + """Whether the model supports a validation set during training.""" + return False + + @property + def supports_likelihood_parameter_prediction(self) -> bool: + """EnsembleModel can predict likelihood parameters if all its forecasting models were fitted with the + same likelihood. + """ + return True + + @property + def supports_probabilistic_prediction(self) -> bool: + return True + + @property + def uses_past_covariates(self) -> bool: + """ + Whether the model uses past covariates, once fitted. + """ + return self.model.uses_past_covariates + + @property + def uses_future_covariates(self) -> bool: + """ + Whether the model uses future covariates, once fitted. + """ + return self.model.uses_future_covariates + + @property + def uses_static_covariates(self) -> bool: + """ + Whether the model uses static covariates, once fitted. + """ + return self.model.uses_static_covariates + + @property + def considers_static_covariates(self) -> bool: + """ + Whether the model considers static covariates, if there are any. + """ + return self.model.considers_static_covariates + def uncertainty_evaluate(df_forecast: pd.DataFrame) -> pd.DataFrame: """Evaluate conformal prediction on test dataframe. diff --git a/darts/models/forecasting/ensemble_model.py b/darts/models/forecasting/ensemble_model.py index ef36802e60..b8255f1ada 100644 --- a/darts/models/forecasting/ensemble_model.py +++ b/darts/models/forecasting/ensemble_model.py @@ -231,9 +231,10 @@ def _stack_ts_multiseq(self, predictions_list): # stacks multiple sequences of timeseries elementwise return [self._stack_ts_seq(ts_list) for ts_list in zip(*predictions_list)] + @property def _model_encoder_settings(self): raise NotImplementedError( - "Encoders are not supported by EnsembleModels. Instead add encoder to the underlying `forecasting_models`." + "Encoders are not supported by EnsembleModels. Instead add encoders to the underlying `forecasting_models`." ) def _make_multiple_predictions( diff --git a/darts/tests/models/forecasting/test_global_forecasting_models.py b/darts/tests/models/forecasting/test_global_forecasting_models.py index 94b3098e34..8041998aca 100644 --- a/darts/tests/models/forecasting/test_global_forecasting_models.py +++ b/darts/tests/models/forecasting/test_global_forecasting_models.py @@ -10,6 +10,7 @@ from darts.dataprocessing.transformers import Scaler from darts.datasets import AirPassengersDataset from darts.metrics import mape +from darts.models.forecasting.forecasting_model import ForecastingModel from darts.tests.conftest import TORCH_AVAILABLE, tfm_kwargs from darts.utils import timeseries_generation as tg from darts.utils.timeseries_generation import linear_timeseries @@ -23,10 +24,12 @@ from darts.models import ( BlockRNNModel, + ConformalNaiveModel, DLinearModel, GlobalNaiveAggregate, GlobalNaiveDrift, GlobalNaiveSeasonal, + LinearRegressionModel, NBEATSModel, NLinearModel, RNNModel, @@ -45,139 +48,150 @@ IN_LEN = 24 OUT_LEN = 12 +torch_kwargs = { + "input_chunk_length": IN_LEN, + "output_chunk_length": OUT_LEN, + "random_state": 0, + "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], +} +# pre-trained global model for conformal models +model_fc = LinearRegressionModel(lags=IN_LEN, output_chunk_length=OUT_LEN).fit( + AirPassengersDataset().load() +) models_cls_kwargs_errs = [ ( BlockRNNModel, - { - "model": "RNN", - "hidden_dim": 10, - "n_rnn_layers": 1, - "batch_size": 32, - "n_epochs": 10, - "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], - }, + dict( + { + "model": "RNN", + "hidden_dim": 10, + "n_rnn_layers": 1, + "batch_size": 32, + "n_epochs": 10, + }, + **torch_kwargs, + ), 110.0, ), ( RNNModel, - { - "model": "RNN", - "training_length": IN_LEN + OUT_LEN, - "hidden_dim": 10, - "batch_size": 32, - "n_epochs": 10, - "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], - }, + dict( + { + "model": "RNN", + "training_length": IN_LEN + OUT_LEN, + "hidden_dim": 10, + "batch_size": 32, + "n_epochs": 10, + }, + **torch_kwargs, + ), 150.0, ), ( RNNModel, - { - "training_length": IN_LEN + OUT_LEN, - "n_epochs": 10, - "likelihood": GaussianLikelihood(), - "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], - }, + dict( + { + "training_length": IN_LEN + OUT_LEN, + "n_epochs": 10, + "likelihood": GaussianLikelihood(), + }, + **torch_kwargs, + ), 80.0, ), ( TCNModel, - { - "n_epochs": 10, - "batch_size": 32, - "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], - }, + dict( + { + "n_epochs": 10, + "batch_size": 32, + }, + **torch_kwargs, + ), 60.0, ), ( TransformerModel, - { - "d_model": 16, - "nhead": 2, - "num_encoder_layers": 2, - "num_decoder_layers": 2, - "dim_feedforward": 16, - "batch_size": 32, - "n_epochs": 10, - "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], - }, + dict( + { + "d_model": 16, + "nhead": 2, + "num_encoder_layers": 2, + "num_decoder_layers": 2, + "dim_feedforward": 16, + "batch_size": 32, + "n_epochs": 10, + }, + **torch_kwargs, + ), 60.0, ), ( NBEATSModel, - { - "num_stacks": 4, - "num_blocks": 1, - "num_layers": 2, - "layer_widths": 12, - "n_epochs": 10, - "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], - }, + dict( + { + "num_stacks": 4, + "num_blocks": 1, + "num_layers": 2, + "layer_widths": 12, + "n_epochs": 10, + }, + **torch_kwargs, + ), 140.0, ), ( TFTModel, - { - "hidden_size": 16, - "lstm_layers": 1, - "num_attention_heads": 4, - "add_relative_index": True, - "n_epochs": 10, - "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], - }, + dict( + { + "hidden_size": 16, + "lstm_layers": 1, + "num_attention_heads": 4, + "add_relative_index": True, + "n_epochs": 10, + }, + **torch_kwargs, + ), 70.0, ), ( NLinearModel, - { - "n_epochs": 10, - "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], - }, + dict({"n_epochs": 10}, **torch_kwargs), 50.0, ), ( DLinearModel, - { - "n_epochs": 10, - "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], - }, + dict({"n_epochs": 10}, **torch_kwargs), 55.0, ), ( TiDEModel, - { - "n_epochs": 10, - "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], - }, + dict({"n_epochs": 10}, **torch_kwargs), 40.0, ), ( TSMixerModel, - { - "n_epochs": 10, - "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], - }, + dict({"n_epochs": 10}, **torch_kwargs), 60.0, ), ( GlobalNaiveAggregate, - { - "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], - }, + torch_kwargs, 22, ), ( GlobalNaiveDrift, - { - "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], - }, + torch_kwargs, 17, ), ( GlobalNaiveSeasonal, - { - "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], - }, + torch_kwargs, + 39, + ), + ( + ConformalNaiveModel, + {"model": model_fc, "alpha": 0.8}, 39, ), ] @@ -247,10 +261,14 @@ class TestGlobalForecastingModels: def test_save_model_parameters(self, config): # model creation parameters were saved before. check if re-created model has same params as original model_cls, kwargs, err = config - model = model_cls( - input_chunk_length=IN_LEN, output_chunk_length=OUT_LEN, **kwargs - ) - assert model._model_params, model.untrained_model()._model_params + model = model_cls(**kwargs) + model_fresh = model.untrained_model() + assert model._model_params.keys() == model_fresh._model_params.keys() + for param, val in model._model_params.items(): + if isinstance(val, ForecastingModel): + # Conformal Models require a forecasting model as input, which has no equality + continue + assert val == model_fresh._model_params[param] @pytest.mark.parametrize( "model", @@ -310,12 +328,7 @@ def test_save_load_model(self, tmpdir_module, model): @pytest.mark.parametrize("config", models_cls_kwargs_errs) def test_single_ts(self, config): model_cls, kwargs, err = config - model = model_cls( - input_chunk_length=IN_LEN, - output_chunk_length=OUT_LEN, - random_state=0, - **kwargs, - ) + model = model_cls(**kwargs) model.fit(self.ts_pass_train) pred = model.predict(n=36) mape_err = mape(self.ts_pass_val, pred) From 7ee148806e1c4d46d73e13345bc55f3882984578 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 11 Jul 2024 11:29:23 +0200 Subject: [PATCH 20/78] add more unit tests --- darts/models/cp/conformal_model.py | 176 ++-- .../forecasting/test_conformal_model.py | 889 +++++++++++++----- .../test_global_forecasting_models.py | 189 ++-- .../forecasting/test_historical_forecasts.py | 4 +- 4 files changed, 856 insertions(+), 402 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 152d7865b0..7d9454bc69 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -1,6 +1,7 @@ +import os import re from abc import ABC, abstractmethod -from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union +from typing import Any, BinaryIO, Callable, Dict, List, Optional, Sequence, Tuple, Union try: from typing import Literal @@ -28,30 +29,6 @@ logger = get_logger(__name__) -def _triul_indices(forecast_horizon, n_comps): - """Computes the indices of upper for a 3D Matrix of shape (horizon, components, n forecasts) - left triangle. The upper left triangle is first computed for the (horizon, n forecasts) - dimension, and then repeated along the `components` dimension. - - These indices can be used to: - - mask out residuals from "newer" forecasts to avoid look-ahead bias (for horizons > 1) - - mask out residuals from "older" forecasts, so that each conformal forecast has the same number - of residual examples per point in the forecast horizon. - """ - # get lower right triangle - idx_horizon, idx_hfc = np.tril_indices(n=forecast_horizon, k=-1) - # reverse to get lower left triangle - idx_horizon = forecast_horizon - 1 - idx_horizon - - # get component indices (already repeated) - idx_comp = np.array([i for _ in range(len(idx_horizon)) for i in range(n_comps)]) - - # repeat along the component dimension - idx_horizon = idx_horizon.repeat(n_comps) - idx_hfc = idx_hfc.repeat(n_comps) - return idx_horizon, idx_comp, idx_hfc - - def cqr_score_sym(row, quantile_lo_col, quantile_hi_col): return ( [None, None] @@ -88,12 +65,36 @@ def _calibration_residuals( cal_mask: Optional[Tuple[np.ndarray, np.ndarray, np.ndarray]] = None, ): """Extract residuals used to calibrate the predictions of a forecasting model. - It guarantees: - - no look-ahead bias + + Parameters + ---------- + residuals + A (sequence) of residuals. + start + The first index from the residuals to extract for the current historical forecasts. + end + The last index from the residuals to extract for the current historical forecasts. + last_points_only + Whether to return only the last predicted points. + forecast_horizon + The forecast horizon. + cal_mask + Optionally, in case of `last_points_only=False` a mask to prevent look-ahead bias and provide the same number + of calibration residuals per point in the horizon. + + Returns + ------- + np.ndarray + An array of residuals used for calibration. The non-np.nan values have shape (n forecasting points, + n components, n cal forecasts * n samples). For `last_points_only=True`, n forecasting points is `1`. + Otherwise, it's equal to `forecast_horizon`. """ if last_points_only: - return residuals[start:end] + # (n hist forecasts, n components, n samples) -> (1, n components, n cal forecasts * n samples) + return np.swapaxes(residuals[start:end], 0, 2) + # n hist forecasts * (horizon, n components, n samples) -> (horizon, n components, n cal forecasts * n samples) + # n cal forecasts is longer, as we'll set all non-relevant values in the cal_mask to np.nan cal_res = np.concatenate(residuals[start:end], axis=2) # no masking required for horizon == 1 if forecast_horizon == 1: @@ -111,6 +112,30 @@ def _calibration_residuals( return cal_res +def _triul_indices(forecast_horizon, n_comps): + """Computes the indices of the upper left triangle from a 3D Matrix of shape (horizon, components, n forecasts). + The upper left triangle is first computed for the (horizon, n forecasts) dimension, and then repeated along the + `components` dimension. + + These indices can be used to: + - mask out residuals from "newer" forecasts to avoid look-ahead bias (for horizons > 1) + - mask out residuals from "older" forecasts, so that each conformal forecast has the same number + of residual examples per point in the forecast horizon. + """ + # get lower right triangle + idx_horizon, idx_hfc = np.tril_indices(n=forecast_horizon, k=-1) + # reverse to get lower left triangle + idx_horizon = forecast_horizon - 1 - idx_horizon + + # get component indices (already repeated) + idx_comp = np.array([i for _ in range(len(idx_horizon)) for i in range(n_comps)]) + + # repeat along the component dimension + idx_horizon = idx_horizon.repeat(n_comps) + idx_hfc = idx_hfc.repeat(n_comps) + return idx_horizon, idx_comp, idx_hfc + + class ConformalModel(GlobalForecastingModel, ABC): def __init__( self, @@ -176,7 +201,7 @@ def predict( ) -> Union[TimeSeries, Sequence[TimeSeries]]: if series is None: # then there must be a single TS, and that was saved in super().fit as self.training_series - if self.training_series is None: + if self.model.training_series is None: raise_log( ValueError( "Input `series` must be provided. This is the result either from fitting on multiple series, " @@ -184,16 +209,16 @@ def predict( ), logger, ) - series = self.training_series + series = self.model.training_series called_with_single_series = get_series_seq_type(series) == SeriesType.SINGLE # guarantee that all inputs are either list of TimeSeries or None series = series2seq(series) - if past_covariates is None and self.past_covariate_series is not None: - past_covariates = [self.past_covariate_series] * len(series) - if future_covariates is None and self.future_covariate_series is not None: - future_covariates = [self.future_covariate_series] * len(series) + if past_covariates is None and self.model.past_covariate_series is not None: + past_covariates = [self.model.past_covariate_series] * len(series) + if future_covariates is None and self.model.future_covariate_series is not None: + future_covariates = [self.model.future_covariate_series] * len(series) past_covariates = series2seq(past_covariates) future_covariates = series2seq(future_covariates) @@ -583,9 +608,14 @@ def _calibrate_forecasts( # use fixed `q_hat` if calibration set is provided q_hat = None if cal_series is not None: - cal_start = -train_length if train_length else 0 - if not last_points_only: - cal_start -= forecast_horizon - 1 + if train_length is None: + cal_start = 0 + else: + cal_start = -train_length + # with last points only we need additional points; + # the mask will handle correct residual extraction + if not last_points_only: + cal_start -= forecast_horizon - 1 cal_res = _calibration_residuals( res, cal_start, @@ -594,9 +624,7 @@ def _calibrate_forecasts( forecast_horizon=forecast_horizon, cal_mask=cal_mask, ) - q_hat = self._calibrate_interval( - cal_res, last_points_only=last_points_only - ) + q_hat = self._calibrate_interval(cal_res) # historical conformal prediction if last_points_only: @@ -618,12 +646,8 @@ def _calibrate_forecasts( cal_res = _calibration_residuals( res, cal_start, cal_end, last_points_only=last_points_only ) - q_hat = self._calibrate_interval( - cal_res, last_points_only=last_points_only - ) - cp_pred = np.concatenate( - [pred_vals + q_hat[0], pred_vals, pred_vals + q_hat[1]], axis=1 - ) + q_hat = self._calibrate_interval(cal_res) + cp_pred = self._apply_interval(pred_vals, q_hat) cp_preds.append(cp_pred) cp_preds = _build_forecast_series( points_preds=np.concatenate(cp_preds, axis=0), @@ -633,6 +657,7 @@ def _calibrate_forecasts( start=s_hfcs._time_index[first_fc_idx], length=len(cp_preds), freq=series_.freq * stride, + name=series_.time_index.name, ), with_static_covs=False, with_hierarchy=False, @@ -664,12 +689,8 @@ def _calibrate_forecasts( forecast_horizon=forecast_horizon, cal_mask=cal_mask, ) - q_hat = self._calibrate_interval( - cal_res, last_points_only=last_points_only - ) - cp_pred = np.concatenate( - [pred_vals + q_hat[0], pred_vals, pred_vals + q_hat[1]], axis=1 - ) + q_hat = self._calibrate_interval(cal_res) + cp_pred = self._apply_interval(pred_vals, q_hat) cp_pred = _build_forecast_series( points_preds=cp_pred, input_series=series_, @@ -682,12 +703,44 @@ def _calibrate_forecasts( cp_hfcs.append(cp_preds) return cp_hfcs + def save( + self, path: Optional[Union[str, os.PathLike, BinaryIO]] = None, **pkl_kwargs + ) -> None: + model_name = self.__class__.__name__ + raise_log( + NotImplementedError( + f"`{model_name}` does not support saving / loading. Instead, " + f"save the underlying forecasting model `{self.model.__class__.__name__}` using its dedicated " + f"save / load functionality, and create a new `{model_name}` with it.", + ), + logger=logger, + ) + @abstractmethod def _calibrate_interval( - self, residuals: np.ndarray, last_points_only: bool + self, residuals: np.ndarray ) -> Tuple[np.ndarray, np.ndarray]: """Computes the upper and lower calibrated forecast intervals based on residuals.""" + def _apply_interval(self, pred, q_hat): + """Applies the calibrated interval to the predicted values. Returns an array with 3 predicted columns + (lower bound, model forecast, upper bound) per component. + + E.g. output is `(target1_cq_low, target1_pred, target1_cq_high, target2_cq_low, ...)` + """ + n_comps = pred.shape[1] + pred = np.concatenate([pred + q_hat[0], pred, pred + q_hat[1]], axis=1) + if n_comps == 1: + return pred + + n_cal_comps = 3 + # pre-compute axes swap (source and destination) for applying calibration intervals + axes_src = [i for i in range(n_comps * n_cal_comps)] + axes_dst = [] + for i in range(n_comps): + axes_dst += axes_src[i::n_comps] + return pred[:, axes_dst] + @property @abstractmethod def _residuals_metric(self): @@ -789,9 +842,9 @@ def _get_q_hat(self, noncon_scores: dict) -> dict: def _cp_component_names(self, input_series) -> List[str]: return [ - f"{tgt_name}_{param_n}" + f"{tgt_name}{param_n}" for tgt_name in input_series.components - for param_n in ["q_lo", "q_md", "q_hi"] + for param_n in ["_cq_lo", "", "_cq_hi"] ] @property @@ -991,11 +1044,16 @@ def __init__(self, model, alpha: Union[float, Tuple[float, float]]): super().__init__(model=model, alpha=alpha) def _calibrate_interval( - self, residuals: np.ndarray, last_points_only: bool + self, residuals: np.ndarray ) -> Tuple[np.ndarray, np.ndarray]: - """Computes the lower and upper calibrated forecast intervals based on residuals.""" - axis = 0 if last_points_only else 2 - q_hat = np.nanquantile(residuals, q=self.alpha, axis=axis) + """Computes the lower and upper calibrated forecast intervals based on residuals. + + Parameters + ---------- + residuals + The residuals are expected to have shape (horizon, n components, n historical forecasts * n samples) + """ + q_hat = np.nanquantile(residuals, q=self.alpha, axis=2) return -q_hat, q_hat @property diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index b3728de3b5..2c6108ee6c 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -1,198 +1,107 @@ -import functools +import copy import itertools +import os import numpy as np import pandas as pd import pytest -from darts import TimeSeries -from darts.logging import get_logger +from darts import TimeSeries, concatenate +from darts.datasets import AirPassengersDataset +from darts.metrics import ae from darts.models import ( ConformalNaiveModel, LinearRegressionModel, NaiveSeasonal, + NLinearModel, ) +from darts.models.forecasting.forecasting_model import ForecastingModel +from darts.tests.conftest import TORCH_AVAILABLE, tfm_kwargs from darts.utils import timeseries_generation as tg -logger = get_logger(__name__) - - -def train_test_split(series, split_ts): - """ - Splits all provided TimeSeries instances into train and test sets according to the provided timestamp. - - Parameters - ---------- - features : TimeSeries - Feature TimeSeries instances to be split. - target : TimeSeries - Target TimeSeries instance to be split. - split_ts : TimeStamp - Time stamp indicating split point. - - Returns - ------- - TYPE - 4-tuple of the form (train_features, train_target, test_features, test_target) - """ - if isinstance(series, TimeSeries): - return series.split_after(split_ts) +IN_LEN = 3 +OUT_LEN = 5 +regr_kwargs = {"lags": IN_LEN, "output_chunk_length": OUT_LEN} +tfm_kwargs = copy.deepcopy(tfm_kwargs) +tfm_kwargs["pl_trainer_kwargs"]["fast_dev_run"] = True +torch_kwargs = dict( + {"input_chunk_length": IN_LEN, "output_chunk_length": OUT_LEN, "random_state": 0}, + **tfm_kwargs, +) + + +def train_model(*args, model_type="regression", model_params=None, **kwargs): + model_params = model_params or {} + if model_type == "regression": + return LinearRegressionModel(**regr_kwargs, **model_params).fit(*args, **kwargs) else: - return list(zip(*[ts.split_after(split_ts) for ts in series])) - - -def dummy_timeseries( - length, - n_series=1, - comps_target=1, - comps_pcov=1, - comps_fcov=1, - multiseries_offset=0, - pcov_offset=0, - fcov_offset=0, - comps_stride=100, - type_stride=10000, - series_stride=1000000, - target_start_value=1, - first_target_start_date=pd.Timestamp("2000-01-01"), - freq="D", - integer_index=False, -): - targets, pcovs, fcovs = [], [], [] - for series_idx in range(n_series): - target_start_date = ( - series_idx * multiseries_offset - if integer_index - else first_target_start_date - + pd.Timedelta(series_idx * multiseries_offset, unit=freq) - ) - pcov_start_date = ( - target_start_date + pcov_offset - if integer_index - else target_start_date + pd.Timedelta(pcov_offset, unit=freq) - ) - fcov_start_date = ( - target_start_date + fcov_offset - if integer_index - else target_start_date + pd.Timedelta(fcov_offset, unit=freq) - ) + return NLinearModel(**torch_kwargs, **model_params).fit(*args, **kwargs) - target_start_val = target_start_value + series_stride * series_idx - pcov_start_val = target_start_val + type_stride - fcov_start_val = target_start_val + 2 * type_stride - - target_ts = None - pcov_ts = None - fcov_ts = None - - for idx in range(comps_target): - start = target_start_val + idx * comps_stride - curr_ts = tg.linear_timeseries( - start_value=start, - end_value=start + length - 1, - start=target_start_date, - length=length, - freq=freq, - column_name=f"{series_idx}-trgt-{idx}", - ) - target_ts = target_ts.stack(curr_ts) if target_ts else curr_ts - for idx in range(comps_pcov): - start = pcov_start_val + idx * comps_stride - curr_ts = tg.linear_timeseries( - start_value=start, - end_value=start + length - 1, - start=pcov_start_date, - length=length, - freq=freq, - column_name=f"{series_idx}-pcov-{idx}", - ) - pcov_ts = pcov_ts.stack(curr_ts) if pcov_ts else curr_ts - for idx in range(comps_fcov): - start = fcov_start_val + idx * comps_stride - curr_ts = tg.linear_timeseries( - start_value=start, - end_value=start + length - 1, - start=fcov_start_date, - length=length, - freq=freq, - column_name=f"{series_idx}-fcov-{idx}", - ) - fcov_ts = fcov_ts.stack(curr_ts) if fcov_ts else curr_ts - targets.append(target_ts) - pcovs.append(pcov_ts) - fcovs.append(fcov_ts) +# pre-trained global model for conformal models +models_cls_kwargs_errs = [ + ( + ConformalNaiveModel, + {"alpha": 0.8}, + "regression", + ), +] - return targets, pcovs, fcovs +if TORCH_AVAILABLE: + models_cls_kwargs_errs.append(( + ConformalNaiveModel, + {"alpha": 0.8}, + "torch", + )) -# helper function used to register LightGBMModel/LinearRegressionModel with likelihood -def partialclass(cls, *args, **kwargs): - class NewCls(cls): - __init__ = functools.partialmethod(cls.__init__, *args, **kwargs) +class TestConformalModel: + np.random.seed(42) - return NewCls + # forecasting horizon used in runnability tests + horizon = OUT_LEN + 1 + # some arbitrary static covariates + static_covariates = pd.DataFrame([[0.0, 1.0]], columns=["st1", "st2"]) -class TestRegressionModels: - np.random.seed(42) - # default regression models - models = [LinearRegressionModel] - - # register likelihood regression models - QuantileLinearRegressionModel = partialclass( - LinearRegressionModel, - likelihood="quantile", - quantiles=[0.05, 0.5, 0.95], - random_state=42, + # real timeseries for functionality tests + ts_length = 10 + horizon + ts_passengers = ( + AirPassengersDataset() + .load()[:ts_length] + .with_static_covariates(static_covariates) + ) + ts_pass_train, ts_pass_val = ( + ts_passengers[:-horizon], + ts_passengers[-horizon:], + ) + + # an additional noisy series + ts_pass_train_1 = ts_pass_train + 0.01 * tg.gaussian_timeseries( + length=len(ts_pass_train), + freq=ts_pass_train.freq_str, + start=ts_pass_train.start_time(), + ) + + # an additional time series serving as covariates + year_series = tg.datetime_attribute_timeseries(ts_passengers, attribute="year") + month_series = tg.datetime_attribute_timeseries(ts_passengers, attribute="month") + time_covariates = year_series.stack(month_series) + time_covariates_train = time_covariates[:-horizon] + + # various ts with different static covariates representations + ts_w_static_cov = tg.linear_timeseries(length=ts_length).with_static_covariates( + pd.Series([1, 2]) ) - # targets for poisson regression must be positive, so we exclude them for some tests - models.extend([ - QuantileLinearRegressionModel, - ]) - - univariate_accuracies = [ - 1e-13, # LinearRegressionModel - 0.8, # QuantileLinearRegressionModel - ] - multivariate_accuracies = [ - 1e-13, # LinearRegressionModel - 0.8, # QuantileLinearRegressionModel - ] - multivariate_multiseries_accuracies = [ - 1e-13, # LinearRegressionModel - 0.8, # QuantileLinearRegressionModel - ] - - # dummy feature and target TimeSeries instances - target_series, past_covariates, future_covariates = dummy_timeseries( - length=100, - n_series=3, - comps_target=3, - comps_pcov=2, - comps_fcov=1, - multiseries_offset=10, - pcov_offset=0, - fcov_offset=0, + ts_shared_static_cov = ts_w_static_cov.stack(tg.sine_timeseries(length=ts_length)) + ts_comps_static_cov = ts_shared_static_cov.with_static_covariates( + pd.DataFrame([[0, 1], [2, 3]], columns=["st1", "st2"]) ) - # shift sines to positive values for poisson regressors - sine_univariate1 = tg.sine_timeseries(length=100) + 1.5 - sine_univariate2 = tg.sine_timeseries(length=100, value_phase=1.5705) + 1.5 - sine_univariate3 = tg.sine_timeseries(length=100, value_phase=0.78525) + 1.5 - sine_univariate4 = tg.sine_timeseries(length=100, value_phase=0.392625) + 1.5 - sine_univariate5 = tg.sine_timeseries(length=100, value_phase=0.1963125) + 1.5 - sine_univariate6 = tg.sine_timeseries(length=100, value_phase=0.09815625) + 1.5 - sine_multivariate1 = sine_univariate1.stack(sine_univariate2) - sine_multivariate2 = sine_univariate2.stack(sine_univariate3) - sine_multiseries1 = [sine_univariate1, sine_univariate2, sine_univariate3] - sine_multiseries2 = [sine_univariate4, sine_univariate5, sine_univariate6] - - lags_1 = {"target": [-3, -2, -1], "past": [-4, -2], "future": [-5, 2]} def test_model_construction(self): local_model = NaiveSeasonal(K=5) - global_model = LinearRegressionModel(lags=5, output_chunk_length=1) - series = self.target_series[0][:10] + global_model = LinearRegressionModel(**regr_kwargs) + series = self.ts_pass_train model_err_msg = "`model` must be a pre-trained `GlobalForecastingModel`." # un-trained local model @@ -215,89 +124,366 @@ def test_model_construction(self): global_model.fit(series) _ = ConformalNaiveModel(model=global_model, alpha=0.8) - @pytest.mark.parametrize("model_cls", models) - def test_predict_runnability(self, model_cls): - # testing lags_past_covariates None but past_covariates during prediction - model_instance = model_cls(lags=4, lags_past_covariates=None) - model_instance.fit(self.sine_univariate1) - model = ConformalNaiveModel(model_instance, alpha=0.8) - # cannot pass past covariates + @pytest.mark.parametrize("config", models_cls_kwargs_errs) + def test_save_model_parameters(self, config): + # model creation parameters were saved before. check if re-created model has same params as original + model_cls, kwargs, model_type = config + model = model_cls( + model=train_model(self.ts_pass_train, model_type=model_type), **kwargs + ) + model_fresh = model.untrained_model() + assert model._model_params.keys() == model_fresh._model_params.keys() + for param, val in model._model_params.items(): + if isinstance(val, ForecastingModel): + # Conformal Models require a forecasting model as input, which has no equality + continue + assert val == model_fresh._model_params[param] + + @pytest.mark.parametrize("config", models_cls_kwargs_errs) + def test_save_load_model(self, tmpdir_fn, config): + # check if save and load methods work and if loaded model creates same forecasts as original model + model_cls, kwargs, model_type = config + model = model_cls( + train_model(self.ts_pass_train, model_type=model_type), **kwargs + ) + + model_path = os.path.join(tmpdir_fn, "model_test.pkl") + with pytest.raises(NotImplementedError) as exc: + model.save(model_path) + assert "does not support saving / loading" in str(exc.value) + + @pytest.mark.parametrize("config", models_cls_kwargs_errs) + def test_single_ts(self, config): + model_cls, kwargs, model_type = config + model = model_cls( + train_model(self.ts_pass_train, model_type=model_type), **kwargs + ) + pred = model.predict(n=self.horizon) + assert pred.n_components == self.ts_pass_train.n_components * 3 + assert not np.isnan(pred.all_values()).any().any() + + pred_fc = model.model.predict(n=self.horizon) + assert pred_fc.time_index.equals(pred.time_index) + # the center forecasts must be equal to the forecasting model forecast + np.testing.assert_array_almost_equal( + pred[self.ts_pass_val.columns.tolist()].all_values(), pred_fc.all_values() + ) + assert pred.static_covariates is None + + # using a different `n`, gives different results, since we can generate more residuals for the horizon + pred1 = model.predict(n=1) + assert not pred1 == pred + + # giving the same series as calibration set must give the same results + pred_cal = model.predict(n=self.horizon, cal_series=self.ts_pass_train) + np.testing.assert_array_almost_equal(pred.all_values(), pred_cal.all_values()) + + # wrong dimension with pytest.raises(ValueError): model.predict( - n=1, - series=self.sine_univariate1, - past_covariates=self.sine_multivariate1, + n=self.horizon, series=self.ts_pass_train.stack(self.ts_pass_train) ) - # works without covariates - model.predict(n=1, series=self.sine_univariate1) - - # testing lags_past_covariates but no past_covariates during prediction - model_instance = model_cls(lags=4, lags_past_covariates=3) - # make multi series fit so no training set is stored - model_instance.fit( - [self.sine_univariate1] * 2, past_covariates=[self.sine_univariate1] * 2 + + @pytest.mark.parametrize("config", models_cls_kwargs_errs) + def test_multi_ts(self, config): + model_cls, kwargs, model_type = config + model = model_cls( + train_model( + [self.ts_pass_train, self.ts_pass_train_1], model_type=model_type + ), + **kwargs, ) - model = ConformalNaiveModel(model_instance, alpha=0.8) - with pytest.raises(ValueError) as exc: - model.predict(n=1, series=self.sine_univariate1) - assert ( - str(exc.value) == "The model has been trained with past covariates. " - "Some matching past_covariates have to be provided to `predict()`." + with pytest.raises(ValueError): + # when model is fit from >1 series, one must provide a series in argument + model.predict(n=1) + + pred = model.predict(n=self.horizon, series=self.ts_pass_train) + assert pred.n_components == self.ts_pass_train.n_components * 3 + assert not np.isnan(pred.all_values()).any().any() + + # the center forecasts must be equal to the forecasting model forecast + pred_fc = model.model.predict(n=self.horizon, series=self.ts_pass_train) + assert pred_fc.time_index.equals(pred.time_index) + np.testing.assert_array_almost_equal( + pred[self.ts_pass_val.columns.tolist()].all_values(), pred_fc.all_values() + ) + + # using a calibration series also requires an input series + with pytest.raises(ValueError): + # when model is fit from >1 series, one must provide a series in argument + model.predict(n=1, cal_series=self.ts_pass_train) + # giving the same series as calibration set must give the same results + pred_cal = model.predict( + n=self.horizon, + series=self.ts_pass_train, + cal_series=self.ts_pass_train, + ) + np.testing.assert_array_almost_equal(pred.all_values(), pred_cal.all_values()) + + # check prediction for several time series + pred_list = model.predict( + n=self.horizon, + series=[self.ts_pass_train, self.ts_pass_train_1], ) - # works with covariates - model.predict( - n=1, series=self.sine_univariate1, past_covariates=self.sine_univariate1 + pred_fc_list = model.model.predict( + n=self.horizon, + series=[self.ts_pass_train, self.ts_pass_train_1], ) - # too short covariates + assert ( + len(pred_list) == 2 + ), f"Model {model_cls} did not return a list of prediction" + for pred, pred_fc in zip(pred_list, pred_fc_list): + assert pred.n_components == self.ts_pass_train.n_components * 3 + assert pred_fc.time_index.equals(pred.time_index) + assert not np.isnan(pred.all_values()).any().any() + np.testing.assert_array_almost_equal( + pred_fc.all_values(), + pred[self.ts_pass_val.columns.tolist()].all_values(), + ) + + # using a calibration series requires to have same number of series as target with pytest.raises(ValueError) as exc: + # when model is fit from >1 series, one must provide a series in argument model.predict( n=1, - series=self.sine_univariate1, - past_covariates=self.sine_univariate1[:-1], + series=[self.ts_pass_train, self.ts_pass_val], + cal_series=self.ts_pass_train, ) - assert str(exc.value).startswith( - "The `past_covariates` at list/sequence index 0 are not long enough." - ) - - # testing lags_future_covariates but no future_covariates during prediction - model_instance = model_cls(lags=4, lags_future_covariates=(3, 0)) - # make multi series fit so no training set is stored - model_instance.fit( - [self.sine_univariate1] * 2, future_covariates=[self.sine_univariate1] * 2 - ) - model = ConformalNaiveModel(model_instance, alpha=0.8) - with pytest.raises(ValueError) as exc: - model.predict(n=1, series=self.sine_univariate1) assert ( - str(exc.value) == "The model has been trained with future covariates. " - "Some matching future_covariates have to be provided to `predict()`." - ) - # works with covariates - model.predict( - n=1, series=self.sine_univariate1, future_covariates=self.sine_univariate1 + str(exc.value) + == "Mismatch between number of `cal_series` (1) and number of `series` (2)." ) + # using a calibration series requires to have same number of series as target with pytest.raises(ValueError) as exc: + # when model is fit from >1 series, one must provide a series in argument model.predict( n=1, - series=self.sine_univariate1, - future_covariates=self.sine_univariate1[:-1], + series=[self.ts_pass_train, self.ts_pass_val], + cal_series=[self.ts_pass_train] * 3, ) - assert str(exc.value).startswith( - "The `future_covariates` at list/sequence index 0 are not long enough." + assert ( + str(exc.value) + == "Mismatch between number of `cal_series` (3) and number of `series` (2)." ) - # test input dim - model_instance = model_cls(lags=4) - model_instance.fit(self.sine_univariate1) - model = ConformalNaiveModel(model_instance, alpha=0.8) - with pytest.raises(ValueError) as exc: + # giving the same series as calibration set must give the same results + pred_cal_list = model.predict( + n=self.horizon, + series=[self.ts_pass_train, self.ts_pass_train_1], + cal_series=[self.ts_pass_train, self.ts_pass_train_1], + ) + for pred, pred_cal in zip(pred_list, pred_cal_list): + np.testing.assert_array_almost_equal( + pred.all_values(), pred_cal.all_values() + ) + + # using copies of the same series as calibration set must give the same interval widths for + # each target series + pred_cal_list = model.predict( + n=self.horizon, + series=[self.ts_pass_train, self.ts_pass_train_1], + cal_series=[self.ts_pass_train, self.ts_pass_train], + ) + + pred_0_vals = pred_cal_list[0].all_values() + pred_1_vals = pred_cal_list[1].all_values() + + # lower range + np.testing.assert_array_almost_equal( + pred_0_vals[:, 1] - pred_0_vals[:, 0], pred_1_vals[:, 1] - pred_1_vals[:, 0] + ) + # upper range + np.testing.assert_array_almost_equal( + pred_0_vals[:, 2] - pred_0_vals[:, 1], pred_1_vals[:, 2] - pred_1_vals[:, 1] + ) + + # wrong dimension + with pytest.raises(ValueError): model.predict( - n=1, series=self.sine_univariate1.stack(self.sine_univariate1) + n=self.horizon, + series=[ + self.ts_pass_train, + self.ts_pass_train.stack(self.ts_pass_train), + ], ) - assert str(exc.value).startswith( - "The number of components of the target series" + + @pytest.mark.parametrize( + "config", + itertools.product( + [(ConformalNaiveModel, {"alpha": 0.8}, "regression")], + [ + {"lags_past_covariates": IN_LEN}, + {"lags_future_covariates": (IN_LEN, OUT_LEN)}, + {}, + ], + ), + ) + def test_covariates(self, config): + (model_cls, kwargs, model_type), covs_kwargs = config + model_fc = LinearRegressionModel(**regr_kwargs, **covs_kwargs) + # Here we rely on the fact that all non-Dual models currently are Past models + if model_fc.supports_future_covariates: + cov_name = "future_covariates" + is_past = False + elif model_fc.supports_past_covariates: + cov_name = "past_covariates" + is_past = True + else: + cov_name = None + is_past = None + + covariates = [self.time_covariates_train, self.time_covariates_train] + if cov_name is not None: + cov_kwargs = {cov_name: covariates} + cov_kwargs_train = {cov_name: self.time_covariates_train} + cov_kwargs_notrain = {cov_name: self.time_covariates} + else: + cov_kwargs = {} + cov_kwargs_train = {} + cov_kwargs_notrain = {} + + model_fc.fit(series=[self.ts_pass_train, self.ts_pass_train_1], **cov_kwargs) + + model = model_cls(model=model_fc, **kwargs) + if cov_name == "future_covariates": + assert model.supports_future_covariates + assert not model.supports_past_covariates + assert model.uses_future_covariates + assert not model.uses_past_covariates + elif cov_name == "past_covariates": + assert not model.supports_future_covariates + assert model.supports_past_covariates + assert not model.uses_future_covariates + assert model.uses_past_covariates + else: + assert not model.supports_future_covariates + assert not model.supports_past_covariates + assert not model.uses_future_covariates + assert not model.uses_past_covariates + + with pytest.raises(ValueError): + # when model is fit from >1 series, one must provide a series in argument + model.predict(n=1) + + if cov_name is not None: + with pytest.raises(ValueError): + # when model is fit using multiple covariates, covariates are required at prediction time + model.predict(n=1, series=self.ts_pass_train) + + with pytest.raises(ValueError): + # when model is fit using covariates, n cannot be greater than output_chunk_length... + # (for short covariates) + # past covariates model can predict up until output_chunk_length + # with train future covariates we cannot predict at all after end of series + model.predict( + n=OUT_LEN + 1 if is_past else 1, + series=self.ts_pass_train, + **cov_kwargs_train, + ) + else: + # model does not support covariates + with pytest.raises(ValueError): + model.predict( + n=1, + series=self.ts_pass_train, + past_covariates=self.time_covariates, + ) + with pytest.raises(ValueError): + model.predict( + n=1, + series=self.ts_pass_train, + future_covariates=self.time_covariates, + ) + + # ... unless future covariates are provided + _ = model.predict( + n=self.horizon, series=self.ts_pass_train, **cov_kwargs_notrain + ) + + pred = model.predict( + n=self.horizon, series=self.ts_pass_train, **cov_kwargs_notrain + ) + pred_fc = model_fc.predict( + n=self.horizon, + series=self.ts_pass_train, + **cov_kwargs_notrain, + ) + np.testing.assert_array_almost_equal( + pred[self.ts_pass_val.columns.tolist()].all_values(), + pred_fc.all_values(), ) + if cov_name is None: + return + + # when model is fit using 1 training and 1 covariate series, time series args are optional + model_fc = LinearRegressionModel(**regr_kwargs, **covs_kwargs) + model_fc.fit(series=self.ts_pass_train, **cov_kwargs_train) + model = model_cls(model_fc, **kwargs) + + if is_past: + # can only predict up until ocl + with pytest.raises(ValueError): + _ = model.predict(n=OUT_LEN + 1) + # wrong covariates dimension + with pytest.raises(ValueError): + covs = cov_kwargs_train[cov_name] + covs = {cov_name: covs.stack(covs)} + _ = model.predict(n=OUT_LEN + 1, **covs) + # with past covariates from train we can predict up until output_chunk_length + pred1 = model.predict(n=OUT_LEN) + pred2 = model.predict(n=OUT_LEN, series=self.ts_pass_train) + pred3 = model.predict(n=OUT_LEN, **cov_kwargs_train) + pred4 = model.predict( + n=OUT_LEN, **cov_kwargs_train, series=self.ts_pass_train + ) + else: + # with future covariates we need additional time steps to predict + with pytest.raises(ValueError): + _ = model.predict(n=1) + with pytest.raises(ValueError): + _ = model.predict(n=1, series=self.ts_pass_train) + with pytest.raises(ValueError): + _ = model.predict(n=1, **cov_kwargs_train) + with pytest.raises(ValueError): + _ = model.predict(n=1, **cov_kwargs_train, series=self.ts_pass_train) + # wrong covariates dimension + with pytest.raises(ValueError): + covs = cov_kwargs_notrain[cov_name] + covs = {cov_name: covs.stack(covs)} + _ = model.predict(n=OUT_LEN + 1, **covs) + pred1 = model.predict(n=OUT_LEN, **cov_kwargs_notrain) + pred2 = model.predict( + n=OUT_LEN, series=self.ts_pass_train, **cov_kwargs_notrain + ) + pred3 = model.predict(n=OUT_LEN, **cov_kwargs_notrain) + pred4 = model.predict( + n=OUT_LEN, **cov_kwargs_notrain, series=self.ts_pass_train + ) + + assert pred1 == pred2 + assert pred1 == pred3 + assert pred1 == pred4 + + @pytest.mark.parametrize( + "config,ts", + itertools.product( + models_cls_kwargs_errs, + [ts_w_static_cov, ts_shared_static_cov, ts_comps_static_cov], + ), + ) + def test_use_static_covariates(self, config, ts): + """ + Check that both static covariates representations are supported (component-specific and shared) + for both uni- and multivariate series when fitting the model. + Also check that the static covariates are present in the forecasted series + """ + model_cls, kwargs, model_type = config + model = model_cls(train_model(ts, model_type=model_type), **kwargs) + assert model.uses_static_covariates + pred = model.predict(OUT_LEN) + assert pred.static_covariates is None + @pytest.mark.parametrize( "config", itertools.product( @@ -310,22 +496,19 @@ def test_predict_runnability(self, model_cls): ) def test_predict(self, config): (is_univar, is_single, use_covs, is_datetime, horizon) = config - - icl = 3 - ocl = 5 - series = self.sine_univariate1[:10] + series = self.ts_pass_train if not is_univar: series = series.stack(series) if not is_datetime: series = TimeSeries.from_values(series.all_values(), columns=series.columns) if use_covs: pc, fc = series, series - fc = fc.append_values(fc.values()[: max(horizon, ocl)]) - if horizon > ocl: - pc = pc.append_values(pc.values()[: horizon - ocl]) + fc = fc.append_values(fc.values()[: max(horizon, OUT_LEN)]) + if horizon > OUT_LEN: + pc = pc.append_values(pc.values()[: horizon - OUT_LEN]) model_kwargs = { - "lags_past_covariates": icl, - "lags_future_covariates": (icl, ocl), + "lags_past_covariates": IN_LEN, + "lags_future_covariates": (IN_LEN, OUT_LEN), } else: pc, fc = None, None @@ -344,7 +527,7 @@ def test_predict(self, config): # testing lags_past_covariates None but past_covariates during prediction model_instance = LinearRegressionModel( - lags=icl, output_chunk_length=ocl, **model_kwargs + lags=IN_LEN, output_chunk_length=OUT_LEN, **model_kwargs ) model_instance.fit(series=series, past_covariates=pc, future_covariates=fc) model = ConformalNaiveModel(model_instance, alpha=0.8) @@ -360,8 +543,234 @@ def test_predict(self, config): for s_, preds_ in zip(series, preds): cols_expected = [] for col in s_.columns: - cols_expected += [f"{col}_q_{q}" for q in ["lo", "md", "hi"]] + cols_expected += [f"{col}{q}" for q in ["_cq_lo", "", "_cq_hi"]] assert preds_.columns.tolist() == cols_expected assert len(preds_) == horizon assert preds_.start_time() == s_.end_time() + s_.freq assert preds_.freq == s_.freq + + def test_output_chunk_shift(self): + model_params = {"output_chunk_shift": 1} + model = ConformalNaiveModel( + train_model(self.ts_pass_train, model_params=model_params), alpha=0.8 + ) + pred = model.predict(n=1) + pred_fc = model.model.predict(n=1) + + assert pred_fc.time_index.equals(pred.time_index) + # the center forecasts must be equal to the forecasting model forecast + np.testing.assert_array_almost_equal( + pred[self.ts_pass_train.columns.tolist()].all_values(), pred_fc.all_values() + ) + + pred_cal = model.predict(n=1, cal_series=self.ts_pass_train) + assert pred_fc.time_index.equals(pred_cal.time_index) + # the center forecasts must be equal to the forecasting model forecast + np.testing.assert_array_almost_equal(pred_cal.all_values(), pred.all_values()) + + @pytest.mark.parametrize( + "config", + itertools.product( + [1, 3, 5], + [True, False], + [True, False], + ), + ) + def test_naive_conformal_model_predict(self, config): + """Verifies that naive conformal model computes the correct intervals + The naive approach computes it as follows: + + - pred_upper = pred + q_alpha(absolute error, past) + - pred_middle = pred + - pred_lower = pred - q_alpha(absolute error, past) + + Where q_alpha(absolute error) is the `alpha` quantile of all historic absolute errors between + `pred`, and the target series. + """ + n, is_univar, is_single = config + alpha = 0.8 + series = self.helper_prepare_series(is_univar, is_single) + model_fc = train_model(series) + pred_fc_list = model_fc.predict(n, series=series) + model = ConformalNaiveModel(model=model_fc, alpha=alpha) + pred_cal_list = model.predict(n, series=series) + pred_cal_list_with_cal = model.predict(n, series=series, cal_series=series) + + # compute the expected intervals + residuals_list = model_fc.residuals( + series, + retrain=False, + forecast_horizon=n, + overlap_end=True, + last_points_only=False, + stride=1, + values_only=True, + metric=ae, # absolute error + ) + if is_single: + pred_fc_list = [pred_fc_list] + pred_cal_list = [pred_cal_list] + residuals_list = [residuals_list] + pred_cal_list_with_cal = [pred_cal_list_with_cal] + + for pred_fc, pred_cal, residuals in zip( + pred_fc_list, pred_cal_list, residuals_list + ): + residuals = np.concatenate(residuals[:-1], axis=2) + + pred_vals = pred_fc.all_values() + pred_vals_expected = self.helper_compute_naive_pred_cal( + residuals, pred_vals, n, alpha + ) + np.testing.assert_array_almost_equal( + pred_cal.all_values(), pred_vals_expected + ) + assert pred_cal_list_with_cal == pred_cal_list + + @pytest.mark.parametrize( + "config", + list( + itertools.product( + [1, 3, 5], # horizon + [True, False], # univariate series + [True, False], # single series, + ) + ), + ) + def test_naive_conformal_model_historical_forecasts(self, config): + """Verifies naive conformal model historical forecasts.""" + n, is_univar, is_single = config + alpha = 0.8 + series = self.helper_prepare_series(is_univar, is_single) + model_fc = train_model(series) + hfc_fc_list = model_fc.historical_forecasts( + series, + retrain=False, + forecast_horizon=n, + overlap_end=True, + last_points_only=False, + stride=1, + ) + # compute the expected intervals + residuals_list = model_fc.residuals( + series, + historical_forecasts=hfc_fc_list, + overlap_end=True, + last_points_only=False, + values_only=True, + metric=ae, # absolute error + ) + model = ConformalNaiveModel(model=model_fc, alpha=alpha) + hfc_cal_list = model.historical_forecasts( + series=series, + forecast_horizon=n, + overlap_end=True, + last_points_only=False, + stride=1, + ) + hfc_cal_list_with_cal = model.historical_forecasts( + series=series, + forecast_horizon=n, + overlap_end=True, + last_points_only=False, + stride=1, + cal_series=series, + ) + + if is_single: + hfc_cal_list = [hfc_cal_list] + residuals_list = [residuals_list] + hfc_cal_list_with_cal = [hfc_cal_list_with_cal] + hfc_fc_list = [hfc_fc_list] + # conformal models start later since they need past residuals as input + first_fc_idx = len(hfc_fc_list[0]) - len(hfc_cal_list[0]) + + for hfc_fc, hfc_cal, hfc_residuals in zip( + hfc_fc_list, hfc_cal_list, residuals_list + ): + for idx, (pred_fc, pred_cal) in enumerate( + zip(hfc_fc[first_fc_idx:], hfc_cal) + ): + residuals = np.concatenate(hfc_residuals[: first_fc_idx + idx], axis=2) + + pred_vals = pred_fc.all_values() + pred_vals_expected = self.helper_compute_naive_pred_cal( + residuals, pred_vals, n, alpha + ) + np.testing.assert_array_almost_equal( + pred_cal.all_values(), pred_vals_expected + ) + for hfc_cal_with_cal, hfc_cal in zip(hfc_cal_list_with_cal, hfc_cal_list): + # last forecast with calibration set must be equal to the last without calibration set + # (since calibration set is the same series) + assert hfc_cal_with_cal[-1] == hfc_cal[-1] + hfc_0_vals = hfc_cal_with_cal[0].all_values() + for hfc_i in hfc_cal_with_cal[1:]: + hfc_i_vals = hfc_i.all_values() + np.testing.assert_array_almost_equal( + hfc_0_vals[:, 1::3] - hfc_0_vals[:, 0::3], + hfc_i_vals[:, 1::3] - hfc_i_vals[:, 0::3], + ) + np.testing.assert_array_almost_equal( + hfc_0_vals[:, 2::3] - hfc_0_vals[:, 1::3], + hfc_i_vals[:, 2::3] - hfc_i_vals[:, 1::3], + ) + + # checking that last points only is equal to the last forecasted point + hfc_lpo_list = model.historical_forecasts( + series=series, + forecast_horizon=n, + overlap_end=True, + last_points_only=True, + stride=1, + ) + hfc_lpo_list_with_cal = model.historical_forecasts( + series=series, + forecast_horizon=n, + overlap_end=True, + last_points_only=True, + stride=1, + cal_series=series, + ) + if is_single: + hfc_lpo_list = [hfc_lpo_list] + hfc_lpo_list_with_cal = [hfc_lpo_list_with_cal] + + for hfc_lpo, hfc_cal in zip(hfc_lpo_list, hfc_cal_list): + hfc_cal_lpo = concatenate([hfc[-1:] for hfc in hfc_cal], axis=0) + assert hfc_lpo == hfc_cal_lpo + + for hfc_lpo, hfc_cal in zip(hfc_lpo_list_with_cal, hfc_cal_list_with_cal): + hfc_cal_lpo = concatenate([hfc[-1:] for hfc in hfc_cal], axis=0) + assert hfc_lpo == hfc_cal_lpo + + def helper_prepare_series(self, is_univar, is_single): + series = self.ts_pass_train + if not is_univar: + series = series.stack(series + 3.0) + if not is_single: + series = [series, series + 5] + return series + + def helper_compute_naive_pred_cal(self, residuals, pred_vals, n, alpha): + q_hats = [] + # compute the quantile `alpha` of all past residuals (absolute "per time step" errors between historical + # forecasts and the target series) + for idx in range(n): + res_n = residuals[idx][:, n - (idx + 1) : residuals.shape[2] - idx] + q_hat_n = np.quantile(res_n, q=alpha, axis=1) + q_hats.append(q_hat_n) + q_hats = np.expand_dims(np.array(q_hats), -1) + # the prediciton interval is given by pred +/- q_hat + n_comps = pred_vals.shape[1] + pred_vals_expected = [] + for col_idx in range(n_comps): + q_col = q_hats[:, col_idx] + pred_col = pred_vals[:, col_idx] + pred_col_expected = np.concatenate( + [pred_col - q_col, pred_col, pred_col + q_col], axis=1 + ) + pred_col_expected = np.expand_dims(pred_col_expected, -1) + pred_vals_expected.append(pred_col_expected) + pred_vals_expected = np.concatenate(pred_vals_expected, axis=1) + return pred_vals_expected diff --git a/darts/tests/models/forecasting/test_global_forecasting_models.py b/darts/tests/models/forecasting/test_global_forecasting_models.py index 8041998aca..94b3098e34 100644 --- a/darts/tests/models/forecasting/test_global_forecasting_models.py +++ b/darts/tests/models/forecasting/test_global_forecasting_models.py @@ -10,7 +10,6 @@ from darts.dataprocessing.transformers import Scaler from darts.datasets import AirPassengersDataset from darts.metrics import mape -from darts.models.forecasting.forecasting_model import ForecastingModel from darts.tests.conftest import TORCH_AVAILABLE, tfm_kwargs from darts.utils import timeseries_generation as tg from darts.utils.timeseries_generation import linear_timeseries @@ -24,12 +23,10 @@ from darts.models import ( BlockRNNModel, - ConformalNaiveModel, DLinearModel, GlobalNaiveAggregate, GlobalNaiveDrift, GlobalNaiveSeasonal, - LinearRegressionModel, NBEATSModel, NLinearModel, RNNModel, @@ -48,150 +45,139 @@ IN_LEN = 24 OUT_LEN = 12 -torch_kwargs = { - "input_chunk_length": IN_LEN, - "output_chunk_length": OUT_LEN, - "random_state": 0, - "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], -} -# pre-trained global model for conformal models -model_fc = LinearRegressionModel(lags=IN_LEN, output_chunk_length=OUT_LEN).fit( - AirPassengersDataset().load() -) models_cls_kwargs_errs = [ ( BlockRNNModel, - dict( - { - "model": "RNN", - "hidden_dim": 10, - "n_rnn_layers": 1, - "batch_size": 32, - "n_epochs": 10, - }, - **torch_kwargs, - ), + { + "model": "RNN", + "hidden_dim": 10, + "n_rnn_layers": 1, + "batch_size": 32, + "n_epochs": 10, + "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], + }, 110.0, ), ( RNNModel, - dict( - { - "model": "RNN", - "training_length": IN_LEN + OUT_LEN, - "hidden_dim": 10, - "batch_size": 32, - "n_epochs": 10, - }, - **torch_kwargs, - ), + { + "model": "RNN", + "training_length": IN_LEN + OUT_LEN, + "hidden_dim": 10, + "batch_size": 32, + "n_epochs": 10, + "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], + }, 150.0, ), ( RNNModel, - dict( - { - "training_length": IN_LEN + OUT_LEN, - "n_epochs": 10, - "likelihood": GaussianLikelihood(), - }, - **torch_kwargs, - ), + { + "training_length": IN_LEN + OUT_LEN, + "n_epochs": 10, + "likelihood": GaussianLikelihood(), + "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], + }, 80.0, ), ( TCNModel, - dict( - { - "n_epochs": 10, - "batch_size": 32, - }, - **torch_kwargs, - ), + { + "n_epochs": 10, + "batch_size": 32, + "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], + }, 60.0, ), ( TransformerModel, - dict( - { - "d_model": 16, - "nhead": 2, - "num_encoder_layers": 2, - "num_decoder_layers": 2, - "dim_feedforward": 16, - "batch_size": 32, - "n_epochs": 10, - }, - **torch_kwargs, - ), + { + "d_model": 16, + "nhead": 2, + "num_encoder_layers": 2, + "num_decoder_layers": 2, + "dim_feedforward": 16, + "batch_size": 32, + "n_epochs": 10, + "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], + }, 60.0, ), ( NBEATSModel, - dict( - { - "num_stacks": 4, - "num_blocks": 1, - "num_layers": 2, - "layer_widths": 12, - "n_epochs": 10, - }, - **torch_kwargs, - ), + { + "num_stacks": 4, + "num_blocks": 1, + "num_layers": 2, + "layer_widths": 12, + "n_epochs": 10, + "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], + }, 140.0, ), ( TFTModel, - dict( - { - "hidden_size": 16, - "lstm_layers": 1, - "num_attention_heads": 4, - "add_relative_index": True, - "n_epochs": 10, - }, - **torch_kwargs, - ), + { + "hidden_size": 16, + "lstm_layers": 1, + "num_attention_heads": 4, + "add_relative_index": True, + "n_epochs": 10, + "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], + }, 70.0, ), ( NLinearModel, - dict({"n_epochs": 10}, **torch_kwargs), + { + "n_epochs": 10, + "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], + }, 50.0, ), ( DLinearModel, - dict({"n_epochs": 10}, **torch_kwargs), + { + "n_epochs": 10, + "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], + }, 55.0, ), ( TiDEModel, - dict({"n_epochs": 10}, **torch_kwargs), + { + "n_epochs": 10, + "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], + }, 40.0, ), ( TSMixerModel, - dict({"n_epochs": 10}, **torch_kwargs), + { + "n_epochs": 10, + "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], + }, 60.0, ), ( GlobalNaiveAggregate, - torch_kwargs, + { + "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], + }, 22, ), ( GlobalNaiveDrift, - torch_kwargs, + { + "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], + }, 17, ), ( GlobalNaiveSeasonal, - torch_kwargs, - 39, - ), - ( - ConformalNaiveModel, - {"model": model_fc, "alpha": 0.8}, + { + "pl_trainer_kwargs": tfm_kwargs["pl_trainer_kwargs"], + }, 39, ), ] @@ -261,14 +247,10 @@ class TestGlobalForecastingModels: def test_save_model_parameters(self, config): # model creation parameters were saved before. check if re-created model has same params as original model_cls, kwargs, err = config - model = model_cls(**kwargs) - model_fresh = model.untrained_model() - assert model._model_params.keys() == model_fresh._model_params.keys() - for param, val in model._model_params.items(): - if isinstance(val, ForecastingModel): - # Conformal Models require a forecasting model as input, which has no equality - continue - assert val == model_fresh._model_params[param] + model = model_cls( + input_chunk_length=IN_LEN, output_chunk_length=OUT_LEN, **kwargs + ) + assert model._model_params, model.untrained_model()._model_params @pytest.mark.parametrize( "model", @@ -328,7 +310,12 @@ def test_save_load_model(self, tmpdir_module, model): @pytest.mark.parametrize("config", models_cls_kwargs_errs) def test_single_ts(self, config): model_cls, kwargs, err = config - model = model_cls(**kwargs) + model = model_cls( + input_chunk_length=IN_LEN, + output_chunk_length=OUT_LEN, + random_state=0, + **kwargs, + ) model.fit(self.ts_pass_train) pred = model.predict(n=36) mape_err = mape(self.ts_pass_val, pred) diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index 1c4d946e9e..92c74b2d13 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -2674,7 +2674,7 @@ def test_conformal_historical_forecasts(self, config): cols_excpected = [] for col in series.columns: - cols_excpected += [f"{col}_q_lo", f"{col}_q_md", f"{col}_q_hi"] + cols_excpected += [f"{col}_cq_lo", f"{col}", f"{col}_cq_hi"] # check length match between optimized and default hist fc assert len(hfc) == n_pred_series_expected # check hist fc start @@ -2835,7 +2835,7 @@ def test_conformal_historical_start_train_length(self, config): cols_excpected = [] for col in series.columns: - cols_excpected += [f"{col}_q_lo", f"{col}_q_md", f"{col}_q_hi"] + cols_excpected += [f"{col}_cq_lo", f"{col}", f"{col}_cq_hi"] # check historical forecasts dimensions assert len(hfc) == n_pred_series_expected # check hist fc start From 6870580db3bfb460f481112e6d0271a4cb7e9d6d Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 12 Jul 2024 15:29:57 +0200 Subject: [PATCH 21/78] add output chunk shift support --- darts/models/cp/conformal_model.py | 33 ++++--- .../forecasting/test_conformal_model.py | 15 ++-- .../forecasting/test_historical_forecasts.py | 87 ++++++++++++++----- 3 files changed, 95 insertions(+), 40 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 7d9454bc69..027be83eaa 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -520,18 +520,19 @@ def _calibrate_forecasts( start=series_.end_time(), freq=series_.freq, ) - if last_fc_idx: + if delta_end > 0: last_fc_idx -= delta_end # determine the first forecast index for conformal prediction if cal_series is None: # all forecasts before that are used for calibration # we need at least 1 residual per point in the horizon - skip_n_train = forecast_horizon + skip_n_train = forecast_horizon + self.output_chunk_shift # plus some additional steps based on `train_length` if train_length is not None: skip_n_train += train_length - 1 else: + # TODO: check cal set with ocs # with a long enough calibration set, we can start from the first forecast min_n_cal = max(train_length or 0, 1) if not last_points_only: @@ -561,6 +562,8 @@ def _calibrate_forecasts( start=first_hfc.start_time(), freq=series_.freq, ) + # hfcs have shifted output; skip until end of shift + skip_n_start += self.output_chunk_shift # hfcs only contain last predicted points; skip until end of first forecast if last_points_only: skip_n_start += forecast_horizon - 1 @@ -573,12 +576,11 @@ def _calibrate_forecasts( ): skip_n_start = 0 if show_warnings: - # adjust to actual start point in case of `last_points_only` + # adjust to actual start point in case of output shift or `last_points_only=True` adjust_idx = ( - int(last_points_only) - * (forecast_horizon - 1) - * series_.freq - ) + self.output_chunk_shift + + int(last_points_only) * (forecast_horizon - 1) + ) * series_.freq hfc_predict_index = ( s_hfcs[skip_n_train].start_time() - adjust_idx, s_hfcs[last_fc_idx].start_time() - adjust_idx, @@ -610,6 +612,7 @@ def _calibrate_forecasts( if cal_series is not None: if train_length is None: cal_start = 0 + # TODO check whether we actually get correct train length points without overlap NaNs at the end else: cal_start = -train_length # with last points only we need additional points; @@ -637,7 +640,11 @@ def _calibrate_forecasts( # to avoid look-ahead bias, use only residuals from before the historical forecast start point; # since we look at `last_points only=True`, the last residual historically available at # the forecasting point is `forecast_horizon - 1` steps before - cal_end = first_fc_idx + idx * stride - (forecast_horizon - 1) + cal_end = ( + first_fc_idx + + idx * stride + - (forecast_horizon + self.output_chunk_shift - 1) + ) # first residual index is shifted back by the horizon to get `train_length` points for # the last point in the horizon cal_start = ( @@ -668,11 +675,12 @@ def _calibrate_forecasts( # convert to (horizon, n comps, hist fcs) pred_vals = pred.values(copy=False) if cal_series is None: - # get the last residual index for calibration, `cal_end` is exclusive + # get the last residual index for calibration, `cal_end` is exclusive. # to avoid look-ahead bias, use only residuals from before the historical forecast start point; # since we look at `last_points only=False`, the last residual historically available at - # the forecasting point is from the first predicted step of the previous forecast - cal_end = first_fc_idx + idx * stride + # the forecasting point is from the first predicted step of the previous forecast (without + # output shift, otherwise the `output_chunk_shift`th point before that) + cal_end = first_fc_idx + idx * stride - self.output_chunk_shift # stepping back further gives access to more residuals and also residuals from longer horizons. # to get `train_length` residuals for the last step in the horizon, we need to step back # additional `forecast_horizon - 1` points @@ -722,7 +730,8 @@ def _calibrate_interval( ) -> Tuple[np.ndarray, np.ndarray]: """Computes the upper and lower calibrated forecast intervals based on residuals.""" - def _apply_interval(self, pred, q_hat): + @staticmethod + def _apply_interval(pred, q_hat): """Applies the calibrated interval to the predicted values. Returns an array with 3 predicted columns (lower bound, model forecast, upper bound) per component. diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 2c6108ee6c..5137239738 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -634,15 +634,16 @@ def test_naive_conformal_model_predict(self, config): [1, 3, 5], # horizon [True, False], # univariate series [True, False], # single series, + [0, 1], # output chunk shift ) ), ) def test_naive_conformal_model_historical_forecasts(self, config): """Verifies naive conformal model historical forecasts.""" - n, is_univar, is_single = config + n, is_univar, is_single, ocs = config alpha = 0.8 series = self.helper_prepare_series(is_univar, is_single) - model_fc = train_model(series) + model_fc = train_model(series, model_params={"output_chunk_shift": ocs}) hfc_fc_list = model_fc.historical_forecasts( series, retrain=False, @@ -691,15 +692,19 @@ def test_naive_conformal_model_historical_forecasts(self, config): for idx, (pred_fc, pred_cal) in enumerate( zip(hfc_fc[first_fc_idx:], hfc_cal) ): - residuals = np.concatenate(hfc_residuals[: first_fc_idx + idx], axis=2) + # need to ignore additional `ocs` (output shift) residuals + residuals = np.concatenate( + hfc_residuals[: first_fc_idx - ocs + idx], axis=2 + ) pred_vals = pred_fc.all_values() pred_vals_expected = self.helper_compute_naive_pred_cal( - residuals, pred_vals, n, alpha + residuals, pred_vals, n, alpha, ocs=ocs ) np.testing.assert_array_almost_equal( pred_cal.all_values(), pred_vals_expected ) + for hfc_cal_with_cal, hfc_cal in zip(hfc_cal_list_with_cal, hfc_cal_list): # last forecast with calibration set must be equal to the last without calibration set # (since calibration set is the same series) @@ -752,7 +757,7 @@ def helper_prepare_series(self, is_univar, is_single): series = [series, series + 5] return series - def helper_compute_naive_pred_cal(self, residuals, pred_vals, n, alpha): + def helper_compute_naive_pred_cal(self, residuals, pred_vals, n, alpha, ocs=0): q_hats = [] # compute the quantile `alpha` of all past residuals (absolute "per time step" errors between historical # forecasts and the target series) diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index 92c74b2d13..e385a27596 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -2529,6 +2529,7 @@ def test_sample_weight(self, config): ], [False, True], # use integer indexed series [False, True], # use multi-series + [0, 1], # output chunk shift ) ), ) @@ -2543,10 +2544,12 @@ def test_conformal_historical_forecasts(self, config): horizon, use_int_idx, use_multi_series, + ocs, ) = config icl = 3 ocl = 5 - min_len_val_series = icl + horizon + int(not overlap_end) * horizon + horizon_ocs = horizon + ocs + min_len_val_series = icl + horizon_ocs + int(not overlap_end) * horizon_ocs # generate n forecasts n_forecasts = 3 series_train, series_val = ( @@ -2575,7 +2578,7 @@ def test_conformal_historical_forecasts(self, config): else {"lags_past_covariates": icl, "lags_future_covariates": (icl, ocl)} ) forecasting_model = LinearRegressionModel( - lags=icl, output_chunk_length=ocl, **model_kwargs + lags=icl, output_chunk_length=ocl, output_chunk_shift=ocs, **model_kwargs ) if use_covs: pc = tg.gaussian_timeseries( @@ -2585,7 +2588,8 @@ def test_conformal_historical_forecasts(self, config): ) fc = tg.gaussian_timeseries( start=series_train.start_time(), - end=series_val.end_time() + max(ocl, horizon) * series_train.freq, + end=series_val.end_time() + + (max(ocl, horizon) + ocs) * series_train.freq, freq=series_train.freq, ) else: @@ -2605,6 +2609,22 @@ def test_conformal_historical_forecasts(self, config): pc = [pc, pc.shift(1)] if pc is not None else None fc = [fc, fc.shift(1)] if fc is not None else None + # cannot perform auto regression with output chunk shift + if ocs and horizon > ocl: + with pytest.raises(ValueError) as exc: + _ = model.historical_forecasts( + series=series_val_too_short, + past_covariates=pc, + future_covariates=fc, + retrain=False, + last_points_only=last_points_only, + overlap_end=overlap_end, + stride=stride, + forecast_horizon=horizon, + ) + assert str(exc.value).startswith("Cannot perform auto-regression") + return + hist_fct = model.historical_forecasts( series=series_val, past_covariates=pc, @@ -2639,36 +2659,50 @@ def test_conformal_historical_forecasts(self, config): if not isinstance(hfc, list): hfc = [hfc] - n_preds_with_overlap = len(series) - icl + 1 - horizon + n_preds_with_overlap = len(series) - icl + 1 - horizon_ocs if not last_points_only and overlap_end: n_pred_series_expected = n_preds_with_overlap n_pred_points_expected = horizon - first_ts_expected = series.time_index[icl] + series.freq * horizon - last_ts_expected = series.end_time() + series.freq * horizon + first_ts_expected = series.time_index[icl] + series.freq * ( + horizon_ocs + ocs + ) + last_ts_expected = series.end_time() + series.freq * horizon_ocs elif not last_points_only: # overlap_end = False - n_pred_series_expected = n_preds_with_overlap - horizon + n_pred_series_expected = n_preds_with_overlap - horizon_ocs n_pred_points_expected = horizon - first_ts_expected = series.time_index[icl] + series.freq * horizon + first_ts_expected = series.time_index[icl] + series.freq * ( + horizon_ocs + ocs + ) last_ts_expected = series.end_time() elif overlap_end: # last_points_only = True n_pred_series_expected = 1 n_pred_points_expected = n_preds_with_overlap - first_ts_expected = ( - series.time_index[icl] + (2 * horizon - 1) * series.freq + first_ts_expected = series.time_index[icl] + series.freq * ( + horizon_ocs + ocs + horizon - 1 ) - last_ts_expected = series.end_time() + series.freq * horizon + last_ts_expected = series.end_time() + series.freq * horizon_ocs else: # last_points_only = True, overlap_end = False n_pred_series_expected = 1 - n_pred_points_expected = n_preds_with_overlap - horizon - first_ts_expected = ( - series.time_index[icl] + (2 * horizon - 1) * series.freq + n_pred_points_expected = n_preds_with_overlap - horizon_ocs + first_ts_expected = series.time_index[icl] + series.freq * ( + horizon_ocs + ocs + horizon - 1 ) last_ts_expected = series.end_time() # to make it simple in case of stride, we assume that non-optimized hist fc returns correct results if stride > 1: - n_pred_series_expected = len(hfc) - n_pred_points_expected = len(hfc[0]) + n_pred_series_expected = ( + n_pred_series_expected + if last_points_only + else n_pred_series_expected // stride + + int(n_pred_series_expected % stride) + ) + n_pred_points_expected = ( + n_pred_points_expected + if not last_points_only + else n_pred_points_expected // stride + + int(n_pred_points_expected % stride) + ) first_ts_expected = hfc[0].start_time() last_ts_expected = hfc[-1].end_time() @@ -2695,6 +2729,7 @@ def test_conformal_historical_forecasts(self, config): ["value", "position"], # start format [False, True], # use integer indexed series [False, True], # use multi-series + [0, 1], # output chunk shift ) ), ) @@ -2708,13 +2743,15 @@ def test_conformal_historical_start_train_length(self, config): start_format, use_int_idx, use_multi_series, + ocs, ) = config icl = 3 ocl = 5 - horizon = 7 + horizon = 5 + horizon_ocs = horizon + ocs add_train_length = train_length - 1 if train_length is not None else 0 add_start = 2 * int(use_start) - min_len_val_series = icl + 2 * horizon + add_train_length + add_start + min_len_val_series = icl + 2 * horizon_ocs + add_train_length + add_start # generate n forecasts n_forecasts = 3 series_train, series_val = ( @@ -2735,10 +2772,14 @@ def test_conformal_historical_start_train_length(self, config): ), columns=series_train.columns, ) - forecasting_model = LinearRegressionModel(lags=icl, output_chunk_length=ocl) + forecasting_model = LinearRegressionModel( + lags=icl, + output_chunk_length=ocl, + output_chunk_shift=ocs, + ) forecasting_model.fit(series_train) - start_position = icl + horizon + add_train_length + add_start + start_position = icl + horizon_ocs + add_train_length + add_start start = None if use_start: if start_format == "value": @@ -2810,7 +2851,7 @@ def test_conformal_historical_start_train_length(self, config): len(series) - icl + 1 - - 2 * horizon + - 2 * horizon_ocs - add_train_length - add_start + add_start_series_2 @@ -2820,7 +2861,7 @@ def test_conformal_historical_start_train_length(self, config): n_pred_points_expected = horizon # seconds series is shifted by one time step (- idx) first_ts_expected = series.time_index[ - start_position - add_start_series_2 + start_position - add_start_series_2 + ocs ] last_ts_expected = series.end_time() else: @@ -2829,7 +2870,7 @@ def test_conformal_historical_start_train_length(self, config): # seconds series is shifted by one time step (- idx) first_ts_expected = ( series.time_index[start_position - add_start_series_2] - + (horizon - 1) * series.freq + + (horizon_ocs - 1) * series.freq ) last_ts_expected = series.end_time() From 01aaf0efaca0fbfb03f0b74a8357249e10e6ddfe Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 19 Jul 2024 09:31:01 +0200 Subject: [PATCH 22/78] support train length with cal input --- .../forecasting/test_conformal_model.py | 23 +++++++++++++++---- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 5137239738..f7c9943ea4 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -635,12 +635,13 @@ def test_naive_conformal_model_predict(self, config): [True, False], # univariate series [True, False], # single series, [0, 1], # output chunk shift + [None, 1], # train length ) ), ) def test_naive_conformal_model_historical_forecasts(self, config): """Verifies naive conformal model historical forecasts.""" - n, is_univar, is_single, ocs = config + n, is_univar, is_single, ocs, train_length = config alpha = 0.8 series = self.helper_prepare_series(is_univar, is_single) model_fc = train_model(series, model_params={"output_chunk_shift": ocs}) @@ -668,6 +669,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): overlap_end=True, last_points_only=False, stride=1, + train_length=train_length, ) hfc_cal_list_with_cal = model.historical_forecasts( series=series, @@ -676,6 +678,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): last_points_only=False, stride=1, cal_series=series, + train_length=train_length, ) if is_single: @@ -683,9 +686,9 @@ def test_naive_conformal_model_historical_forecasts(self, config): residuals_list = [residuals_list] hfc_cal_list_with_cal = [hfc_cal_list_with_cal] hfc_fc_list = [hfc_fc_list] + # conformal models start later since they need past residuals as input first_fc_idx = len(hfc_fc_list[0]) - len(hfc_cal_list[0]) - for hfc_fc, hfc_cal, hfc_residuals in zip( hfc_fc_list, hfc_cal_list, residuals_list ): @@ -699,7 +702,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): pred_vals = pred_fc.all_values() pred_vals_expected = self.helper_compute_naive_pred_cal( - residuals, pred_vals, n, alpha, ocs=ocs + residuals, pred_vals, n, alpha, train_length=train_length ) np.testing.assert_array_almost_equal( pred_cal.all_values(), pred_vals_expected @@ -757,12 +760,22 @@ def helper_prepare_series(self, is_univar, is_single): series = [series, series + 5] return series - def helper_compute_naive_pred_cal(self, residuals, pred_vals, n, alpha, ocs=0): + def helper_compute_naive_pred_cal( + self, residuals, pred_vals, n, alpha, train_length=None + ): + train_length = train_length or 0 + # if train_length: + # d = 1 q_hats = [] # compute the quantile `alpha` of all past residuals (absolute "per time step" errors between historical # forecasts and the target series) for idx in range(n): - res_n = residuals[idx][:, n - (idx + 1) : residuals.shape[2] - idx] + res_end = residuals.shape[2] - idx + if train_length: + res_start = res_end - train_length + else: + res_start = n - (idx + 1) + res_n = residuals[idx][:, res_start:res_end] q_hat_n = np.quantile(res_n, q=alpha, axis=1) q_hats.append(q_hat_n) q_hats = np.expand_dims(np.array(q_hats), -1) From c5dbf77f5095380c4f71b0f9265fcec17cbdd364 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 26 Jul 2024 09:39:47 +0200 Subject: [PATCH 23/78] support train lenght part 2 --- darts/models/cp/conformal_model.py | 18 ++++++++++++++++-- .../models/forecasting/test_conformal_model.py | 2 ++ 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 027be83eaa..5cf8a0f033 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -610,11 +610,25 @@ def _calibrate_forecasts( # use fixed `q_hat` if calibration set is provided q_hat = None if cal_series is not None: + cal_series_, cal_hfcs = ( + cal_series[series_idx], + cal_forecasts[series_idx], + ) + cal_last_hfc = cal_hfcs if last_points_only else cal_hfcs[-1] + cal_last_fc_idx = len(cal_hfcs) + cal_delta_end = n_steps_between( + end=cal_last_hfc.end_time(), + start=cal_series_.end_time(), + freq=cal_series_.freq, + ) + if cal_delta_end > 0: + cal_last_fc_idx -= cal_delta_end + if train_length is None: cal_start = 0 # TODO check whether we actually get correct train length points without overlap NaNs at the end else: - cal_start = -train_length + cal_start = cal_last_fc_idx - train_length # with last points only we need additional points; # the mask will handle correct residual extraction if not last_points_only: @@ -622,7 +636,7 @@ def _calibrate_forecasts( cal_res = _calibration_residuals( res, cal_start, - None, + cal_last_fc_idx, last_points_only=last_points_only, forecast_horizon=forecast_horizon, cal_mask=cal_mask, diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index f7c9943ea4..5e516009b4 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -642,6 +642,8 @@ def test_naive_conformal_model_predict(self, config): def test_naive_conformal_model_historical_forecasts(self, config): """Verifies naive conformal model historical forecasts.""" n, is_univar, is_single, ocs, train_length = config + # if train_length: + # d = 1 alpha = 0.8 series = self.helper_prepare_series(is_univar, is_single) model_fc = train_model(series, model_params={"output_chunk_shift": ocs}) From 684775252a977d4fcc01f023ebf3b3b8796b8db3 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sat, 27 Jul 2024 17:29:41 +0200 Subject: [PATCH 24/78] restructure hist fc logic --- darts/models/cp/conformal_model.py | 230 +++++------------- .../forecasting/test_conformal_model.py | 6 +- 2 files changed, 63 insertions(+), 173 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 5cf8a0f033..12e6df23c6 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -56,86 +56,6 @@ def cqr_score_asym(row, quantile_lo_col, quantile_hi_col): ) -def _calibration_residuals( - residuals, - start: Optional[int], - end: Optional[int], - last_points_only: bool, - forecast_horizon: Optional[int] = None, - cal_mask: Optional[Tuple[np.ndarray, np.ndarray, np.ndarray]] = None, -): - """Extract residuals used to calibrate the predictions of a forecasting model. - - Parameters - ---------- - residuals - A (sequence) of residuals. - start - The first index from the residuals to extract for the current historical forecasts. - end - The last index from the residuals to extract for the current historical forecasts. - last_points_only - Whether to return only the last predicted points. - forecast_horizon - The forecast horizon. - cal_mask - Optionally, in case of `last_points_only=False` a mask to prevent look-ahead bias and provide the same number - of calibration residuals per point in the horizon. - - Returns - ------- - np.ndarray - An array of residuals used for calibration. The non-np.nan values have shape (n forecasting points, - n components, n cal forecasts * n samples). For `last_points_only=True`, n forecasting points is `1`. - Otherwise, it's equal to `forecast_horizon`. - """ - if last_points_only: - # (n hist forecasts, n components, n samples) -> (1, n components, n cal forecasts * n samples) - return np.swapaxes(residuals[start:end], 0, 2) - - # n hist forecasts * (horizon, n components, n samples) -> (horizon, n components, n cal forecasts * n samples) - # n cal forecasts is longer, as we'll set all non-relevant values in the cal_mask to np.nan - cal_res = np.concatenate(residuals[start:end], axis=2) - # no masking required for horizon == 1 - if forecast_horizon == 1: - return cal_res - - # ignore upper left residuals to have same number of residuals per horizon - idx_horizon, idx_comp, idx_hfc = cal_mask - cal_res[idx_horizon, idx_comp, idx_hfc] = np.nan - # ignore lower right residuals to avoid look-ahead bias - cal_res[ - forecast_horizon - 1 - idx_horizon, - idx_comp, - cal_res.shape[2] - 1 - idx_hfc, - ] = np.nan - return cal_res - - -def _triul_indices(forecast_horizon, n_comps): - """Computes the indices of the upper left triangle from a 3D Matrix of shape (horizon, components, n forecasts). - The upper left triangle is first computed for the (horizon, n forecasts) dimension, and then repeated along the - `components` dimension. - - These indices can be used to: - - mask out residuals from "newer" forecasts to avoid look-ahead bias (for horizons > 1) - - mask out residuals from "older" forecasts, so that each conformal forecast has the same number - of residual examples per point in the forecast horizon. - """ - # get lower right triangle - idx_horizon, idx_hfc = np.tril_indices(n=forecast_horizon, k=-1) - # reverse to get lower left triangle - idx_horizon = forecast_horizon - 1 - idx_horizon - - # get component indices (already repeated) - idx_comp = np.array([i for _ in range(len(idx_horizon)) for i in range(n_comps)]) - - # repeat along the component dimension - idx_horizon = idx_horizon.repeat(n_comps) - idx_hfc = idx_hfc.repeat(n_comps) - return idx_horizon, idx_comp, idx_hfc - - class ConformalModel(GlobalForecastingModel, ABC): def __init__( self, @@ -474,15 +394,6 @@ def _calibrate_forecasts( # - predict_likelihood_parameters # - tqdm iterator over series # - support for different CP algorithms - - # DONE: - # - properly define minimum residuals to start (different for `last_points_only=True/False` - # - compute all possible residuals (including the partial forecast horizons up until the end) - # - overlap_end = True - # - last_points_only = True - # - add correct output components - # - use only `train_length` previous residuals - residuals = self.model.residuals( series=series if cal_series is None else cal_series, historical_forecasts=forecasts if cal_series is None else cal_forecasts, @@ -494,10 +405,6 @@ def _calibrate_forecasts( metric=self._residuals_metric, ) - # this mask is later used to avoid look-ahead bias and guarantee identical number of calibration - # points per step in the forecast horizon. Only used in case of `last_points_only=False` - cal_mask = _triul_indices(forecast_horizon, series[0].width) - cp_hfcs = [] for series_idx, (series_, s_hfcs, res) in enumerate( zip(series, forecasts, residuals) @@ -607,41 +514,68 @@ def _calibrate_forecasts( ), ) - # use fixed `q_hat` if calibration set is provided + # TODO: only works if all points with overlap end can be generated + n_examples = ( + len(s_hfcs) if cal_series is None else len(cal_forecasts[series_idx]) + ) - forecast_horizon + # assert len(s_hfcs) - forecast_horizon == last_fc_idx - first_fc_idx + # bring into shape (forecasting steps, n components, n samples * n examples) + if last_points_only: + # -> (1, n components, n samples * n examples) + res = res[:n_examples].T + else: + res = np.array(res) + # -> (forecast horizon, n components, n samples * n examples) + # rearrange the residuals to avoid look-ahead bias and to have the same number of examples per + # point in the horizon; + # e.g. for a horizon = 2, and some forecasting point at time t3, we would have residuals: + # R1: t1_h1, R2: t1_h2 (e.g. t1_h1 is the first forecasted point from time t1 -> t2) + # R3: t2_h1, R4: t2_h2 + # - R4 would be unknown at time t3 -> we exclude it + # - R1 is ignored to have the same number of examples per point in the horizon (1 in this case) + res = np.concatenate( + [ + res[-(i + 1) - n_examples : -(i + 1), i] + for i in range(forecast_horizon) + ], + axis=2, + ).T + q_hat = None if cal_series is not None: - cal_series_, cal_hfcs = ( - cal_series[series_idx], - cal_forecasts[series_idx], - ) - cal_last_hfc = cal_hfcs if last_points_only else cal_hfcs[-1] - cal_last_fc_idx = len(cal_hfcs) - cal_delta_end = n_steps_between( - end=cal_last_hfc.end_time(), - start=cal_series_.end_time(), - freq=cal_series_.freq, - ) - if cal_delta_end > 0: - cal_last_fc_idx -= cal_delta_end + # with a calibration set, we use the same calibration for all forecasts + if self.output_chunk_shift: + res = res[:, :, : -self.output_chunk_shift] + if train_length is not None: + res = res[:, :, -train_length:] + else: + res = res + q_hat = self._calibrate_interval(res) + + def conformal_predict(idx_, pred_vals_): + if cal_series is None: + # get the last residual index for calibration, `cal_end` is exclusive + # to avoid look-ahead bias, use only residuals from before the historical forecast start point; + # for `last_points_only=True`, the last residual historically available at the forecasting + # point is `forecast_horizon + self.output_chunk_shift - 1` steps before. The same applies to + # `last_points_only=False` thanks to the residual rearrangement + cal_end = ( + first_fc_idx + + idx_ * stride + - (forecast_horizon + self.output_chunk_shift - 1) + ) + # first residual index is shifted back by the horizon to get `train_length` points for + # the last point in the horizon + cal_start = ( + cal_end - train_length if train_length is not None else None + ) - if train_length is None: - cal_start = 0 - # TODO check whether we actually get correct train length points without overlap NaNs at the end + cal_res = res[:, :, cal_start:cal_end] + q_hat_ = self._calibrate_interval(cal_res) else: - cal_start = cal_last_fc_idx - train_length - # with last points only we need additional points; - # the mask will handle correct residual extraction - if not last_points_only: - cal_start -= forecast_horizon - 1 - cal_res = _calibration_residuals( - res, - cal_start, - cal_last_fc_idx, - last_points_only=last_points_only, - forecast_horizon=forecast_horizon, - cal_mask=cal_mask, - ) - q_hat = self._calibrate_interval(cal_res) + # with a calibration set, use a constant q_hat + q_hat_ = q_hat + return self._apply_interval(pred_vals_, q_hat_) # historical conformal prediction if last_points_only: @@ -649,26 +583,7 @@ def _calibrate_forecasts( s_hfcs.values(copy=False)[first_fc_idx:last_fc_idx:stride] ): pred_vals = np.expand_dims(pred_vals, 0) - if cal_series is None: - # get the last residual index for calibration, `cal_end` is exclusive - # to avoid look-ahead bias, use only residuals from before the historical forecast start point; - # since we look at `last_points only=True`, the last residual historically available at - # the forecasting point is `forecast_horizon - 1` steps before - cal_end = ( - first_fc_idx - + idx * stride - - (forecast_horizon + self.output_chunk_shift - 1) - ) - # first residual index is shifted back by the horizon to get `train_length` points for - # the last point in the horizon - cal_start = ( - cal_end - train_length if train_length is not None else None - ) - cal_res = _calibration_residuals( - res, cal_start, cal_end, last_points_only=last_points_only - ) - q_hat = self._calibrate_interval(cal_res) - cp_pred = self._apply_interval(pred_vals, q_hat) + cp_pred = conformal_predict(idx, pred_vals) cp_preds.append(cp_pred) cp_preds = _build_forecast_series( points_preds=np.concatenate(cp_preds, axis=0), @@ -686,33 +601,8 @@ def _calibrate_forecasts( cp_hfcs.append(cp_preds) else: for idx, pred in enumerate(s_hfcs[first_fc_idx:last_fc_idx:stride]): - # convert to (horizon, n comps, hist fcs) pred_vals = pred.values(copy=False) - if cal_series is None: - # get the last residual index for calibration, `cal_end` is exclusive. - # to avoid look-ahead bias, use only residuals from before the historical forecast start point; - # since we look at `last_points only=False`, the last residual historically available at - # the forecasting point is from the first predicted step of the previous forecast (without - # output shift, otherwise the `output_chunk_shift`th point before that) - cal_end = first_fc_idx + idx * stride - self.output_chunk_shift - # stepping back further gives access to more residuals and also residuals from longer horizons. - # to get `train_length` residuals for the last step in the horizon, we need to step back - # additional `forecast_horizon - 1` points - cal_start = ( - cal_end - train_length - (forecast_horizon - 1) - if train_length is not None - else None - ) - cal_res = _calibration_residuals( - res, - cal_start, - cal_end, - last_points_only=last_points_only, - forecast_horizon=forecast_horizon, - cal_mask=cal_mask, - ) - q_hat = self._calibrate_interval(cal_res) - cp_pred = self._apply_interval(pred_vals, q_hat) + cp_pred = conformal_predict(idx, pred_vals) cp_pred = _build_forecast_series( points_preds=cp_pred, input_series=series_, diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 5e516009b4..ee50cc07ed 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -642,8 +642,6 @@ def test_naive_conformal_model_predict(self, config): def test_naive_conformal_model_historical_forecasts(self, config): """Verifies naive conformal model historical forecasts.""" n, is_univar, is_single, ocs, train_length = config - # if train_length: - # d = 1 alpha = 0.8 series = self.helper_prepare_series(is_univar, is_single) model_fc = train_model(series, model_params={"output_chunk_shift": ocs}) @@ -679,8 +677,8 @@ def test_naive_conformal_model_historical_forecasts(self, config): overlap_end=True, last_points_only=False, stride=1, - cal_series=series, train_length=train_length, + cal_series=series, ) if is_single: @@ -733,6 +731,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): overlap_end=True, last_points_only=True, stride=1, + train_length=train_length, ) hfc_lpo_list_with_cal = model.historical_forecasts( series=series, @@ -740,6 +739,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): overlap_end=True, last_points_only=True, stride=1, + train_length=train_length, cal_series=series, ) if is_single: From 13461c51e7d75b1361c9a6543b46a5150b330178 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sun, 28 Jul 2024 14:30:15 +0200 Subject: [PATCH 25/78] test with shorter covariates --- .../forecasting/test_conformal_model.py | 24 ++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index ee50cc07ed..10a0e67378 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -65,7 +65,7 @@ class TestConformalModel: static_covariates = pd.DataFrame([[0.0, 1.0]], columns=["st1", "st2"]) # real timeseries for functionality tests - ts_length = 10 + horizon + ts_length = 13 + horizon ts_passengers = ( AirPassengersDataset() .load()[:ts_length] @@ -636,15 +636,25 @@ def test_naive_conformal_model_predict(self, config): [True, False], # single series, [0, 1], # output chunk shift [None, 1], # train length + [True, False], # use too short covariates ) ), ) def test_naive_conformal_model_historical_forecasts(self, config): """Verifies naive conformal model historical forecasts.""" - n, is_univar, is_single, ocs, train_length = config + n, is_univar, is_single, ocs, train_length, use_covs = config alpha = 0.8 series = self.helper_prepare_series(is_univar, is_single) - model_fc = train_model(series, model_params={"output_chunk_shift": ocs}) + model_params = {"output_chunk_shift": ocs} + covs_kwargs = {} + cal_covs_kwargs = {} + if use_covs: + model_params["lags_past_covariates"] = regr_kwargs["lags"] + # use shorter covariates, to test whether residuals are still properly extracted + past_covs = series[:-3] if is_single else [s[:-3] for s in series] + covs_kwargs["past_covariates"] = past_covs + cal_covs_kwargs["cal_past_covariates"] = past_covs + model_fc = train_model(series, model_params=model_params, **covs_kwargs) hfc_fc_list = model_fc.historical_forecasts( series, retrain=False, @@ -652,6 +662,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): overlap_end=True, last_points_only=False, stride=1, + **covs_kwargs, ) # compute the expected intervals residuals_list = model_fc.residuals( @@ -661,6 +672,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): last_points_only=False, values_only=True, metric=ae, # absolute error + **covs_kwargs, ) model = ConformalNaiveModel(model=model_fc, alpha=alpha) hfc_cal_list = model.historical_forecasts( @@ -670,6 +682,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): last_points_only=False, stride=1, train_length=train_length, + **covs_kwargs, ) hfc_cal_list_with_cal = model.historical_forecasts( series=series, @@ -679,6 +692,8 @@ def test_naive_conformal_model_historical_forecasts(self, config): stride=1, train_length=train_length, cal_series=series, + **covs_kwargs, + **cal_covs_kwargs, ) if is_single: @@ -732,6 +747,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): last_points_only=True, stride=1, train_length=train_length, + **covs_kwargs, ) hfc_lpo_list_with_cal = model.historical_forecasts( series=series, @@ -741,6 +757,8 @@ def test_naive_conformal_model_historical_forecasts(self, config): stride=1, train_length=train_length, cal_series=series, + **covs_kwargs, + **cal_covs_kwargs, ) if is_single: hfc_lpo_list = [hfc_lpo_list] From 4143c20b896de8ac0211aa1365a0389664780043 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Tue, 30 Jul 2024 13:59:22 +0200 Subject: [PATCH 26/78] add checks for min lengths --- darts/models/cp/conformal_model.py | 53 +++++++++------ .../forecasting/test_conformal_model.py | 65 +++++++++++++++++-- 2 files changed, 95 insertions(+), 23 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 12e6df23c6..53540e4246 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -420,15 +420,15 @@ def _calibrate_forecasts( first_hfc = get_single_series(s_hfcs) last_hfc = s_hfcs if last_points_only else s_hfcs[-1] last_fc_idx = len(s_hfcs) + # adjust based on `overlap_end` - if not overlap_end: - delta_end = n_steps_between( - end=last_hfc.end_time(), - start=series_.end_time(), - freq=series_.freq, - ) - if delta_end > 0: - last_fc_idx -= delta_end + delta_end = n_steps_between( + end=last_hfc.end_time(), + start=series_.end_time(), + freq=series_.freq, + ) + if not overlap_end and delta_end > 0: + last_fc_idx -= delta_end # determine the first forecast index for conformal prediction if cal_series is None: @@ -438,24 +438,39 @@ def _calibrate_forecasts( # plus some additional steps based on `train_length` if train_length is not None: skip_n_train += train_length - 1 + min_n_cal = skip_n_train + + if delta_end == forecast_horizon + self.output_chunk_shift: + min_n_cal += 1 else: - # TODO: check cal set with ocs # with a long enough calibration set, we can start from the first forecast min_n_cal = max(train_length or 0, 1) if not last_points_only: min_n_cal += forecast_horizon - 1 - if len(res) < min_n_cal: - raise_log( - ValueError( - "Could not build a single calibration input with the provided " - f"`cal_series` and `cal_*_covariates` at series index: {series_idx}. " - f"Expected to generate at least `{min_n_cal}` calibration forecasts, " - f"but could only generate `{len(res)}`." - ), - logger=logger, - ) + + cal_series_ = cal_series[series_idx] + cal_last_hfc = cal_forecasts[series_idx][-1] + cal_delta_end = n_steps_between( + end=cal_last_hfc.end_time(), + start=cal_series_.end_time(), + freq=cal_series_.freq, + ) + if cal_delta_end == forecast_horizon + self.output_chunk_shift: + min_n_cal += 1 skip_n_train = 0 + if len(res) < min_n_cal: + set_name = "" if cal_series is None else "cal_" + raise_log( + ValueError( + "Could not build a single calibration input with the provided " + f"`{set_name}series` and `{set_name}*_covariates` at series index: {series_idx}. " + f"Expected to generate at least `{min_n_cal}` calibration forecasts, " + f"but could only generate `{len(res)}`." + ), + logger=logger, + ) + # skip solely based on `start` skip_n_start = 0 if start is not None: diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 10a0e67378..63bc28774f 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -20,7 +20,7 @@ from darts.utils import timeseries_generation as tg IN_LEN = 3 -OUT_LEN = 5 +OUT_LEN = 3 regr_kwargs = {"lags": IN_LEN, "output_chunk_length": OUT_LEN} tfm_kwargs = copy.deepcopy(tfm_kwargs) tfm_kwargs["pl_trainer_kwargs"]["fast_dev_run"] = True @@ -491,7 +491,7 @@ def test_use_static_covariates(self, config, ts): [True, False], # single series [True, False], # use covariates [True, False], # datetime index - [3, 5, 7], # different horizons + [1, 3, 5], # different horizons ), ) def test_predict(self, config): @@ -643,6 +643,9 @@ def test_naive_conformal_model_predict(self, config): def test_naive_conformal_model_historical_forecasts(self, config): """Verifies naive conformal model historical forecasts.""" n, is_univar, is_single, ocs, train_length, use_covs = config + if ocs and n > OUT_LEN: + # auto-regression not allowed with ocs + return alpha = 0.8 series = self.helper_prepare_series(is_univar, is_single) model_params = {"output_chunk_shift": ocs} @@ -784,8 +787,6 @@ def helper_compute_naive_pred_cal( self, residuals, pred_vals, n, alpha, train_length=None ): train_length = train_length or 0 - # if train_length: - # d = 1 q_hats = [] # compute the quantile `alpha` of all past residuals (absolute "per time step" errors between historical # forecasts and the target series) @@ -812,3 +813,59 @@ def helper_compute_naive_pred_cal( pred_vals_expected.append(pred_col_expected) pred_vals_expected = np.concatenate(pred_vals_expected, axis=1) return pred_vals_expected + + @pytest.mark.parametrize( + "config", + list( + itertools.product( + [1, 3, 5, 7], # horizon + [0, 1], # output chunk shift + [None, 1], # train length + [False, True], # use covariates + ) + ), + ) + def test_too_short_input(self, config): + """Verifies naive conformal model historical forecasts.""" + n, ocs, train_length, use_covs = config + if ocs and n > OUT_LEN: + return + icl = IN_LEN + min_len = icl + n + series = tg.linear_timeseries(length=min_len) + + model_params = {"output_chunk_shift": ocs} + covs_kwargs = {} + cal_covs_kwargs = {} + covs_kwargs_too_short = {} + cal_covs_kwargs_short = {} + if use_covs: + model_params["lags_past_covariates"] = regr_kwargs["lags"] + # use shorter covariates, to test whether residuals are still properly extracted + covs_kwargs["past_covariates"] = series + cal_covs_kwargs["cal_past_covariates"] = series + covs_kwargs_too_short["past_covariates"] = series[:-1] + cal_covs_kwargs_short["past_covariates"] = series[:-1] + # model_fc = train_model(series, model_params=model_params, **covs_kwargs) + + model = ConformalNaiveModel( + train_model( + self.ts_pass_train.with_static_covariates(None), + model_params=model_params, + ), + alpha=0.8, + ) + # prediction works with long enough series + _ = model.predict(n=n, series=series) + _ = model.predict(n=n, series=series, cal_series=series) + # series too short + with pytest.raises(ValueError) as exc: + _ = model.predict(n=n, series=series[:-1]) + assert str(exc.value).startswith( + "Could not build a single calibration input with the provided `cal_series`" + ) + with pytest.raises(ValueError) as exc: + _ = model.predict(n=n, series=series, cal_series=series[:-1]) + assert str(exc.value).startswith( + "Could not build a single calibration input with the provided `cal_series`" + ) From 5e2115c650f34158c44f273c85506198b80d883d Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 30 Aug 2024 08:39:39 +0200 Subject: [PATCH 27/78] corrections for minimum input --- darts/models/cp/conformal_model.py | 146 ++++---- .../forecasting/test_conformal_model.py | 346 +++++++++++++++--- .../forecasting/test_historical_forecasts.py | 4 +- 3 files changed, 369 insertions(+), 127 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 53540e4246..44992e42fe 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -321,7 +321,7 @@ def historical_forecasts( num_samples=num_samples, forecast_horizon=forecast_horizon, retrain=False, - overlap_end=True, + overlap_end=overlap_end, last_points_only=last_points_only, verbose=verbose, show_warnings=show_warnings, @@ -397,7 +397,7 @@ def _calibrate_forecasts( residuals = self.model.residuals( series=series if cal_series is None else cal_series, historical_forecasts=forecasts if cal_series is None else cal_forecasts, - overlap_end=True, + overlap_end=overlap_end if cal_series is None else True, last_points_only=last_points_only, verbose=verbose, show_warnings=show_warnings, @@ -416,54 +416,62 @@ def _calibrate_forecasts( cp_hfcs.append(cp_preds) continue - # determine the last forecast index for conformal prediction first_hfc = get_single_series(s_hfcs) last_hfc = s_hfcs if last_points_only else s_hfcs[-1] - last_fc_idx = len(s_hfcs) - # adjust based on `overlap_end` - delta_end = n_steps_between( - end=last_hfc.end_time(), - start=series_.end_time(), - freq=series_.freq, - ) - if not overlap_end and delta_end > 0: - last_fc_idx -= delta_end - - # determine the first forecast index for conformal prediction + # determine first forecast index for conformal prediction and minimum number of + # calibration examples if cal_series is None: - # all forecasts before that are used for calibration - # we need at least 1 residual per point in the horizon - skip_n_train = forecast_horizon + self.output_chunk_shift - # plus some additional steps based on `train_length` + # we need at least one residual per point in the horizon prior to the first conformal forecast + first_idx_train = forecast_horizon + self.output_chunk_shift + # plus some additional examples based on `train_length` if train_length is not None: - skip_n_train += train_length - 1 - min_n_cal = skip_n_train - - if delta_end == forecast_horizon + self.output_chunk_shift: - min_n_cal += 1 + first_idx_train += train_length - 1 + + # the minimum number of calibration examples includes the first forecast (+1) + min_n_cal = first_idx_train + 1 + + # check if later we need to drop some residuals without useful information + if overlap_end: + # compute number of steps between `series` end and last forecast end + delta_end = n_steps_between( + end=last_hfc.end_time(), + start=series_.end_time(), + freq=series_.freq, + ) + else: + delta_end = 0 else: - # with a long enough calibration set, we can start from the first forecast + # calibration set is decoupled from `series` forecasts -> we can start with the first forecast + first_idx_train = 0 + + # at least one or `train_length` examples min_n_cal = max(train_length or 0, 1) + # `last_points_only=False` requires additional examples to use most recent information + # from all steps in the horizon if not last_points_only: min_n_cal += forecast_horizon - 1 + # check if we need to drop some residuals without useful information cal_series_ = cal_series[series_idx] cal_last_hfc = cal_forecasts[series_idx][-1] - cal_delta_end = n_steps_between( + delta_end = n_steps_between( end=cal_last_hfc.end_time(), start=cal_series_.end_time(), freq=cal_series_.freq, ) - if cal_delta_end == forecast_horizon + self.output_chunk_shift: - min_n_cal += 1 - skip_n_train = 0 + # if calibration set gives residuals with unuseful information, increase the required size + if delta_end > 0: + if last_points_only: + min_n_cal += delta_end + elif delta_end >= forecast_horizon: + min_n_cal += delta_end - forecast_horizon + 1 if len(res) < min_n_cal: set_name = "" if cal_series is None else "cal_" raise_log( ValueError( - "Could not build a single calibration input with the provided " + "Could not build the minimum required calibration input with the provided " f"`{set_name}series` and `{set_name}*_covariates` at series index: {series_idx}. " f"Expected to generate at least `{min_n_cal}` calibration forecasts, " f"but could only generate `{len(res)}`." @@ -471,32 +479,46 @@ def _calibrate_forecasts( logger=logger, ) + # drop residuals without useful information + last_res_idx = None + if last_points_only and delta_end > 0: + # useful residual information only up until the forecast + # ending at the last time step in `series` + last_res_idx = -delta_end + elif not last_points_only and delta_end >= forecast_horizon: + # useful residual information only up until the forecast + # starting at the last time step in `series` + last_res_idx = -(delta_end - forecast_horizon + 1) + if last_res_idx is not None: + res = res[:last_res_idx] + # skip solely based on `start` - skip_n_start = 0 + first_idx_start = 0 if start is not None: if isinstance(start, pd.Timestamp) or start_format == "value": start_time = start else: start_time = series_._time_index[start] - skip_n_start = n_steps_between( + first_idx_start = n_steps_between( end=start_time, start=first_hfc.start_time(), freq=series_.freq, ) # hfcs have shifted output; skip until end of shift - skip_n_start += self.output_chunk_shift + first_idx_start += self.output_chunk_shift # hfcs only contain last predicted points; skip until end of first forecast if last_points_only: - skip_n_start += forecast_horizon - 1 + first_idx_start += forecast_horizon - 1 # if start is out of bounds, we ignore it + last_idx = len(s_hfcs) - 1 if ( - skip_n_start < 0 - or skip_n_start >= last_fc_idx - or skip_n_start < skip_n_train + first_idx_start < 0 + or first_idx_start > last_idx + or first_idx_start < first_idx_train ): - skip_n_start = 0 + first_idx_start = 0 if show_warnings: # adjust to actual start point in case of output shift or `last_points_only=True` adjust_idx = ( @@ -504,8 +526,8 @@ def _calibrate_forecasts( + int(last_points_only) * (forecast_horizon - 1) ) * series_.freq hfc_predict_index = ( - s_hfcs[skip_n_train].start_time() - adjust_idx, - s_hfcs[last_fc_idx].start_time() - adjust_idx, + s_hfcs[first_idx_train].start_time() - adjust_idx, + s_hfcs[last_idx].start_time() - adjust_idx, ) _historical_forecasts_start_warnings( idx=series_idx, @@ -515,29 +537,11 @@ def _calibrate_forecasts( ) # get final first index - first_fc_idx = max([skip_n_train, skip_n_start]) - if first_fc_idx >= last_fc_idx: - ( - raise_log( - ValueError( - "Cannot build a single input for prediction with the provided model, " - f"`series` and `*_covariates` at series index: {series_idx}. The minimum " - "prediction input time index requirements were not met. " - "Please check the time index of `series` and `*_covariates`." - ), - logger=logger, - ), - ) - - # TODO: only works if all points with overlap end can be generated - n_examples = ( - len(s_hfcs) if cal_series is None else len(cal_forecasts[series_idx]) - ) - forecast_horizon - # assert len(s_hfcs) - forecast_horizon == last_fc_idx - first_fc_idx + first_fc_idx = max([first_idx_train, first_idx_start]) # bring into shape (forecasting steps, n components, n samples * n examples) if last_points_only: # -> (1, n components, n samples * n examples) - res = res[:n_examples].T + res = res.T else: res = np.array(res) # -> (forecast horizon, n components, n samples * n examples) @@ -548,23 +552,17 @@ def _calibrate_forecasts( # R3: t2_h1, R4: t2_h2 # - R4 would be unknown at time t3 -> we exclude it # - R1 is ignored to have the same number of examples per point in the horizon (1 in this case) - res = np.concatenate( - [ - res[-(i + 1) - n_examples : -(i + 1), i] - for i in range(forecast_horizon) - ], - axis=2, - ).T + res_ = [] + for irr in range(forecast_horizon - 1, -1, -1): + res_end_idx = -(forecast_horizon - (irr + 1)) + res_.append(res[irr : res_end_idx or None, abs(res_end_idx)]) + res = np.concatenate(res_, axis=2).T + assert not np.isnan(res).any().any() q_hat = None if cal_series is not None: - # with a calibration set, we use the same calibration for all forecasts - if self.output_chunk_shift: - res = res[:, :, : -self.output_chunk_shift] if train_length is not None: res = res[:, :, -train_length:] - else: - res = res q_hat = self._calibrate_interval(res) def conformal_predict(idx_, pred_vals_): @@ -595,7 +593,7 @@ def conformal_predict(idx_, pred_vals_): # historical conformal prediction if last_points_only: for idx, pred_vals in enumerate( - s_hfcs.values(copy=False)[first_fc_idx:last_fc_idx:stride] + s_hfcs.values(copy=False)[first_fc_idx::stride] ): pred_vals = np.expand_dims(pred_vals, 0) cp_pred = conformal_predict(idx, pred_vals) @@ -615,7 +613,7 @@ def conformal_predict(idx_, pred_vals_): ) cp_hfcs.append(cp_preds) else: - for idx, pred in enumerate(s_hfcs[first_fc_idx:last_fc_idx:stride]): + for idx, pred in enumerate(s_hfcs[first_fc_idx::stride]): pred_vals = pred.values(copy=False) cp_pred = conformal_predict(idx, pred_vals) cp_pred = _build_forecast_series( @@ -981,7 +979,7 @@ def _calibrate_interval( residuals The residuals are expected to have shape (horizon, n components, n historical forecasts * n samples) """ - q_hat = np.nanquantile(residuals, q=self.alpha, axis=2) + q_hat = np.quantile(residuals, q=self.alpha, axis=2) return -q_hat, q_hat @property diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 63bc28774f..3386a942f1 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -571,9 +571,9 @@ def test_output_chunk_shift(self): @pytest.mark.parametrize( "config", itertools.product( - [1, 3, 5], - [True, False], - [True, False], + [1, 3, 5], # horizon + [True, False], # univariate series + [True, False], # single series ), ) def test_naive_conformal_model_predict(self, config): @@ -636,27 +636,59 @@ def test_naive_conformal_model_predict(self, config): [True, False], # single series, [0, 1], # output chunk shift [None, 1], # train length - [True, False], # use too short covariates + [False, True], # use covariates ) ), ) def test_naive_conformal_model_historical_forecasts(self, config): - """Verifies naive conformal model historical forecasts.""" + """Checks correctness of naive conformal model historical forecasts for: + - different horizons (smaller, equal and larger the OCL) + - uni and multivariate series + - single and multiple series + - with and without output shift + - with and without training length + - with and without covariates in the forecast and calibration sets. + """ n, is_univar, is_single, ocs, train_length, use_covs = config if ocs and n > OUT_LEN: # auto-regression not allowed with ocs return + alpha = 0.8 series = self.helper_prepare_series(is_univar, is_single) model_params = {"output_chunk_shift": ocs} + + # for covariates, we check that shorter & longer covariates in the calibration set give expected results covs_kwargs = {} - cal_covs_kwargs = {} + cal_covs_kwargs_overlap = {} + cal_covs_kwargs_short = {} + cal_covs_kwargs_exact = {} if use_covs: model_params["lags_past_covariates"] = regr_kwargs["lags"] - # use shorter covariates, to test whether residuals are still properly extracted - past_covs = series[:-3] if is_single else [s[:-3] for s in series] + past_covs = series + if n > OUT_LEN: + append_vals = [[[1.0]] * (1 if is_univar else 2)] * (n - OUT_LEN) + if is_single: + past_covs = past_covs.append_values(append_vals) + else: + past_covs = [pc.append_values(append_vals) for pc in past_covs] covs_kwargs["past_covariates"] = past_covs - cal_covs_kwargs["cal_past_covariates"] = past_covs + # produces examples with all points in `overlap_end=True` (last example has no useful information) + cal_covs_kwargs_overlap["cal_past_covariates"] = past_covs + # produces one example less (drops the one with unuseful information) + cal_covs_kwargs_exact["cal_past_covariates"] = ( + past_covs[: -(1 + ocs)] + if is_single + else [pc[: -(1 + ocs)] for pc in past_covs] + ) + # produces another example less (drops the last one which contains useful information) + cal_covs_kwargs_short["cal_past_covariates"] = ( + past_covs[: -(2 + ocs)] + if is_single + else [pc[: -(2 + ocs)] for pc in past_covs] + ) + + # forecasts from forecasting model model_fc = train_model(series, model_params=model_params, **covs_kwargs) hfc_fc_list = model_fc.historical_forecasts( series, @@ -667,7 +699,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): stride=1, **covs_kwargs, ) - # compute the expected intervals + # residuals to compute the conformal intervals residuals_list = model_fc.residuals( series, historical_forecasts=hfc_fc_list, @@ -677,8 +709,11 @@ def test_naive_conformal_model_historical_forecasts(self, config): metric=ae, # absolute error **covs_kwargs, ) + + # conformal forecasts model = ConformalNaiveModel(model=model_fc, alpha=alpha) - hfc_cal_list = model.historical_forecasts( + # without calibration set + hfc_conf_list = model.historical_forecasts( series=series, forecast_horizon=n, overlap_end=True, @@ -687,7 +722,8 @@ def test_naive_conformal_model_historical_forecasts(self, config): train_length=train_length, **covs_kwargs, ) - hfc_cal_list_with_cal = model.historical_forecasts( + # with calibration set and covariates that can generate all calibration forecasts in the overlap + hfc_conf_list_with_cal = model.historical_forecasts( series=series, forecast_horizon=n, overlap_end=True, @@ -696,22 +732,23 @@ def test_naive_conformal_model_historical_forecasts(self, config): train_length=train_length, cal_series=series, **covs_kwargs, - **cal_covs_kwargs, + **cal_covs_kwargs_overlap, ) if is_single: - hfc_cal_list = [hfc_cal_list] + hfc_conf_list = [hfc_conf_list] residuals_list = [residuals_list] - hfc_cal_list_with_cal = [hfc_cal_list_with_cal] + hfc_conf_list_with_cal = [hfc_conf_list_with_cal] hfc_fc_list = [hfc_fc_list] + # validate computed conformal intervals that did not use a calibration set # conformal models start later since they need past residuals as input - first_fc_idx = len(hfc_fc_list[0]) - len(hfc_cal_list[0]) - for hfc_fc, hfc_cal, hfc_residuals in zip( - hfc_fc_list, hfc_cal_list, residuals_list + first_fc_idx = len(hfc_fc_list[0]) - len(hfc_conf_list[0]) + for hfc_fc, hfc_conf, hfc_residuals in zip( + hfc_fc_list, hfc_conf_list, residuals_list ): for idx, (pred_fc, pred_cal) in enumerate( - zip(hfc_fc[first_fc_idx:], hfc_cal) + zip(hfc_fc[first_fc_idx:], hfc_conf) ): # need to ignore additional `ocs` (output shift) residuals residuals = np.concatenate( @@ -726,12 +763,13 @@ def test_naive_conformal_model_historical_forecasts(self, config): pred_cal.all_values(), pred_vals_expected ) - for hfc_cal_with_cal, hfc_cal in zip(hfc_cal_list_with_cal, hfc_cal_list): + # validate computed conformal intervals that used a calibration set + for hfc_conf_with_cal, hfc_conf in zip(hfc_conf_list_with_cal, hfc_conf_list): # last forecast with calibration set must be equal to the last without calibration set # (since calibration set is the same series) - assert hfc_cal_with_cal[-1] == hfc_cal[-1] - hfc_0_vals = hfc_cal_with_cal[0].all_values() - for hfc_i in hfc_cal_with_cal[1:]: + assert hfc_conf_with_cal[-1] == hfc_conf[-1] + hfc_0_vals = hfc_conf_with_cal[0].all_values() + for hfc_i in hfc_conf_with_cal[1:]: hfc_i_vals = hfc_i.all_values() np.testing.assert_array_almost_equal( hfc_0_vals[:, 1::3] - hfc_0_vals[:, 0::3], @@ -742,6 +780,47 @@ def test_naive_conformal_model_historical_forecasts(self, config): hfc_i_vals[:, 2::3] - hfc_i_vals[:, 1::3], ) + if use_covs: + # `cal_covs_kwargs_exact` will not compute the last example in overlap_end (this one has anyways no + # useful information). Result is expected to be identical to the case when using `cal_covs_kwargs_overlap` + hfc_conf_list_with_cal_exact = model.historical_forecasts( + series=series, + forecast_horizon=n, + overlap_end=True, + last_points_only=False, + stride=1, + train_length=train_length, + cal_series=series, + **covs_kwargs, + **cal_covs_kwargs_exact, + ) + + # `cal_covs_kwargs_short` will compute example less that contains useful information + hfc_conf_list_with_cal_short = model.historical_forecasts( + series=series, + forecast_horizon=n, + overlap_end=True, + last_points_only=False, + stride=1, + train_length=train_length, + cal_series=series, + **covs_kwargs, + **cal_covs_kwargs_short, + ) + if is_single: + hfc_conf_list_with_cal_exact = [hfc_conf_list_with_cal_exact] + hfc_conf_list_with_cal_short = [hfc_conf_list_with_cal_short] + + # must match + assert hfc_conf_list_with_cal_exact == hfc_conf_list_with_cal + + # second last forecast with shorter calibration set (that has one example less) must be equal to the + # second last without calibration set + for hfc_conf_with_cal, hfc_conf in zip( + hfc_conf_list_with_cal_short, hfc_conf_list + ): + assert hfc_conf_with_cal[-2] == hfc_conf[-2] + # checking that last points only is equal to the last forecasted point hfc_lpo_list = model.historical_forecasts( series=series, @@ -761,19 +840,19 @@ def test_naive_conformal_model_historical_forecasts(self, config): train_length=train_length, cal_series=series, **covs_kwargs, - **cal_covs_kwargs, + **cal_covs_kwargs_overlap, ) if is_single: hfc_lpo_list = [hfc_lpo_list] hfc_lpo_list_with_cal = [hfc_lpo_list_with_cal] - for hfc_lpo, hfc_cal in zip(hfc_lpo_list, hfc_cal_list): - hfc_cal_lpo = concatenate([hfc[-1:] for hfc in hfc_cal], axis=0) - assert hfc_lpo == hfc_cal_lpo + for hfc_lpo, hfc_conf in zip(hfc_lpo_list, hfc_conf_list): + hfc_conf_lpo = concatenate([hfc[-1:] for hfc in hfc_conf], axis=0) + assert hfc_lpo == hfc_conf_lpo - for hfc_lpo, hfc_cal in zip(hfc_lpo_list_with_cal, hfc_cal_list_with_cal): - hfc_cal_lpo = concatenate([hfc[-1:] for hfc in hfc_cal], axis=0) - assert hfc_lpo == hfc_cal_lpo + for hfc_lpo, hfc_conf in zip(hfc_lpo_list_with_cal, hfc_conf_list_with_cal): + hfc_conf_lpo = concatenate([hfc[-1:] for hfc in hfc_conf], axis=0) + assert hfc_lpo == hfc_conf_lpo def helper_prepare_series(self, is_univar, is_single): series = self.ts_pass_train @@ -783,8 +862,9 @@ def helper_prepare_series(self, is_univar, is_single): series = [series, series + 5] return series + @staticmethod def helper_compute_naive_pred_cal( - self, residuals, pred_vals, n, alpha, train_length=None + residuals, pred_vals, n, alpha, train_length=None ): train_length = train_length or 0 q_hats = [] @@ -818,54 +898,216 @@ def helper_compute_naive_pred_cal( "config", list( itertools.product( - [1, 3, 5, 7], # horizon + [1, 3, 5], # horizon [0, 1], # output chunk shift - [None, 1], # train length [False, True], # use covariates ) ), ) - def test_too_short_input(self, config): - """Verifies naive conformal model historical forecasts.""" - n, ocs, train_length, use_covs = config + def test_too_short_input_predict(self, config): + """Checks conformal model predict with minimum required input and too short input.""" + n, ocs, use_covs = config if ocs and n > OUT_LEN: return icl = IN_LEN - min_len = icl + n + min_len = icl + ocs + n series = tg.linear_timeseries(length=min_len) model_params = {"output_chunk_shift": ocs} covs_kwargs = {} cal_covs_kwargs = {} + covs_kwargs_train = {} covs_kwargs_too_short = {} cal_covs_kwargs_short = {} + series = self.ts_pass_train.with_static_covariates(None) if use_covs: model_params["lags_past_covariates"] = regr_kwargs["lags"] # use shorter covariates, to test whether residuals are still properly extracted - covs_kwargs["past_covariates"] = series - cal_covs_kwargs["cal_past_covariates"] = series - covs_kwargs_too_short["past_covariates"] = series[:-1] - cal_covs_kwargs_short["past_covariates"] = series[:-1] - # model_fc = train_model(series, model_params=model_params, **covs_kwargs) + covs_kwargs_train["past_covariates"] = [series] * 2 + past_covs = series + # for auto-regression, we require longer past covariates + if n > OUT_LEN: + past_covs = past_covs.append_values([1.0] * (n - OUT_LEN)) + covs_kwargs["past_covariates"] = past_covs + covs_kwargs_too_short["past_covariates"] = past_covs[:-1] + # giving covs in calibration set requires one calibration example less + cal_covs_kwargs["cal_past_covariates"] = past_covs[: -(1 + ocs)] + cal_covs_kwargs_short["cal_past_covariates"] = past_covs[: -(2 + ocs)] model = ConformalNaiveModel( train_model( - self.ts_pass_train.with_static_covariates(None), + series=[series] * 2, model_params=model_params, + **covs_kwargs_train, ), alpha=0.8, ) - # prediction works with long enough series - _ = model.predict(n=n, series=series) - _ = model.predict(n=n, series=series, cal_series=series) - # series too short + + # prediction works with long enough input + preds1 = model.predict(n=n, series=series, **covs_kwargs) + assert not np.isnan(preds1.all_values()).any().any() + preds2 = model.predict( + n=n, series=series, **covs_kwargs, cal_series=series, **cal_covs_kwargs + ) + assert not np.isnan(preds2.all_values()).any().any() + # series too short: without covariates, make `series` shorter. Otherwise, use the shorter covariates + series_ = series[:-1] if not use_covs else series + with pytest.raises(ValueError) as exc: - _ = model.predict(n=n, series=series[:-1]) - assert str(exc.value).startswith( - "Could not build a single calibration input with the provided `cal_series`" + _ = model.predict(n=n, series=series_, **covs_kwargs_too_short) + if not use_covs: + assert str(exc.value).startswith( + "Could not build the minimum required calibration input with the provided `cal_series`" + ) + else: + # if `past_covariates` are too short, then it raises error from the forecasting_model.predict() + assert str(exc.value).startswith( + "The `past_covariates` at list/sequence index 0 are not long enough." + ) + + with pytest.raises(ValueError) as exc: + _ = model.predict( + n=n, + series=series, + cal_series=series_, + **covs_kwargs, + **cal_covs_kwargs_short, + ) + if not use_covs or n > 1: + assert str(exc.value).startswith( + "Could not build the minimum required calibration input with the provided `cal_series`" + ) + else: + # if `cal_past_covariates` are too short and `horizon=1`, then it raises error from the forecasting model + assert str(exc.value).startswith( + "Cannot build a single input for prediction with the provided model" + ) + + @pytest.mark.parametrize( + "config", + list( + itertools.product( + [False, True], # last points only + [False, True], # overlap end + [None, 2], # train length + [False, True], # use multi-series + [0, 1], # output chunk shift + [1, 3, 5], # horizon + [True, False], # use covs + ) + )[6:7], + ) + def test_too_short_input_hfc(self, config): + """Checks conformal model historical forecasts with minimum required input and too short input.""" + ( + last_points_only, + overlap_end, + train_length, + use_multi_series, + ocs, + n, + use_covs, + ) = config + if ocs and n > OUT_LEN: + return + + icl = IN_LEN + ocl = OUT_LEN + horizon_ocs = n + ocs + add_train_length = train_length - 1 if train_length is not None else 0 + # min length to generate 1 forecast + min_len_val_series = icl + 2 * horizon_ocs + add_train_length + + series_train = tg.linear_timeseries(length=min_len_val_series + (ocl + ocs - 1)) + series = series_train[:min_len_val_series] + + model_params = {"output_chunk_shift": ocs} + covs_kwargs = {} + cal_covs_kwargs = {} + covs_kwargs_train = {} + covs_kwargs_too_short = {} + cal_covs_kwargs_short = {} + if use_covs: + model_params["lags_past_covariates"] = regr_kwargs["lags"] + # use shorter covariates, to test whether residuals are still properly extracted + covs_kwargs_train["past_covariates"] = [series_train] * 2 + past_covs = series[: -(n + ocs)] + + # for auto-regression, we require longer past covariates + if n > OUT_LEN: + past_covs = past_covs.append_values([1.0] * (n - OUT_LEN)) + + covs_kwargs["past_covariates"] = past_covs + covs_kwargs_too_short["past_covariates"] = past_covs[:-1] + # giving covs in calibration set requires one calibration example less + cal_covs_kwargs["cal_past_covariates"] = past_covs[:-1] + cal_covs_kwargs_short["cal_past_covariates"] = past_covs[:-2] + + model = ConformalNaiveModel( + train_model( + series=[series_train] * 2, + model_params=model_params, + **covs_kwargs_train, + ), + alpha=0.8, + ) + + hfc_kwargs = { + "last_points_only": last_points_only, + "train_length": train_length, + "overlap_end": overlap_end, + "forecast_horizon": n, + } + # prediction works with long enough input + preds1 = model.historical_forecasts( + series=series, + **covs_kwargs, + **hfc_kwargs, + ) + preds2 = model.historical_forecasts( + series=series[: -(n + ocs)], + cal_series=series[: -(n + ocs)], + **covs_kwargs, + **cal_covs_kwargs, + **hfc_kwargs, ) + if last_points_only: + preds1 = [preds1] + preds2 = [preds2] + + # assert len(preds1) == 1 + n * int(overlap_end) + assert len(preds1) == len(preds2) == 1 + n * int(overlap_end) + + for pred1, pred2 in zip(preds1, preds2): + assert not np.isnan(pred1.all_values()).any().any() + assert not np.isnan(pred2.all_values()).any().any() + # input too short: without covariates, make `series` shorter. Otherwise, use the shorter covariates + series_ = series[:-1] if not use_covs else series + with pytest.raises(ValueError) as exc: - _ = model.predict(n=n, series=series, cal_series=series[:-1]) + _ = model.historical_forecasts( + series=series_, + **covs_kwargs_too_short, + **hfc_kwargs, + ) assert str(exc.value).startswith( - "Could not build a single calibration input with the provided `cal_series`" + "Could not build the minimum required calibration input with the provided `series` and `*_covariates`" ) + + with pytest.raises(ValueError) as exc: + _ = model.historical_forecasts( + series=series[: -(n + ocs)], + cal_series=series_[: -(n + ocs)], + **covs_kwargs, + **cal_covs_kwargs_short, + **hfc_kwargs, + ) + if not use_covs or n > 1: + assert str(exc.value).startswith( + "Could not build the minimum required calibration input with the provided `cal_series`" + ) + else: + # if `cal_past_covariates` are too short and `horizon=1`, then it raises error from the forecasting model + assert str(exc.value).startswith( + "Cannot build a single input for prediction with the provided model" + ) diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index e385a27596..6e75e38b01 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -2646,7 +2646,9 @@ def test_conformal_historical_forecasts(self, config): stride=stride, forecast_horizon=horizon, ) - assert str(exc.value).startswith("Cannot build a single input for prediction") + assert str(exc.value).startswith( + "Could not build the minimum required calibration input with the provided `series`" + ) if not isinstance(series_val, list): series_val = [series_val] From d19e947d772e3a2b2ddc15e8d7994af8552e3f43 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 30 Aug 2024 11:27:37 +0200 Subject: [PATCH 28/78] improve hist fc tests --- darts/models/cp/conformal_model.py | 115 ++++++----- .../forecasting/test_conformal_model.py | 151 +++++++++------ .../forecasting/test_historical_forecasts.py | 178 ++++++++++-------- 3 files changed, 256 insertions(+), 188 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 44992e42fe..859e6f3004 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -412,28 +412,30 @@ def _calibrate_forecasts( cp_preds = [] # no historical forecasts were generated - if not s_hfcs or (train_length is not None and train_length > len(s_hfcs)): + if not s_hfcs: cp_hfcs.append(cp_preds) continue first_hfc = get_single_series(s_hfcs) last_hfc = s_hfcs if last_points_only else s_hfcs[-1] - # determine first forecast index for conformal prediction and minimum number of - # calibration examples + # compute the minimum required number of useful calibration residuals + # at least one or `train_length` examples + min_n_cal = train_length or 1 + # `last_points_only=False` requires additional examples to use most recent information + # from all steps in the horizon + if not last_points_only: + min_n_cal += forecast_horizon - 1 + + # determine first forecast index for conformal prediction if cal_series is None: # we need at least one residual per point in the horizon prior to the first conformal forecast first_idx_train = forecast_horizon + self.output_chunk_shift # plus some additional examples based on `train_length` if train_length is not None: first_idx_train += train_length - 1 - - # the minimum number of calibration examples includes the first forecast (+1) - min_n_cal = first_idx_train + 1 - - # check if later we need to drop some residuals without useful information + # check if later we need to drop some residuals without useful information (unknown residuals) if overlap_end: - # compute number of steps between `series` end and last forecast end delta_end = n_steps_between( end=last_hfc.end_time(), start=series_.end_time(), @@ -442,16 +444,8 @@ def _calibrate_forecasts( else: delta_end = 0 else: - # calibration set is decoupled from `series` forecasts -> we can start with the first forecast + # calibration set is decoupled from `series` forecasts; we can start with the first forecast first_idx_train = 0 - - # at least one or `train_length` examples - min_n_cal = max(train_length or 0, 1) - # `last_points_only=False` requires additional examples to use most recent information - # from all steps in the horizon - if not last_points_only: - min_n_cal += forecast_horizon - 1 - # check if we need to drop some residuals without useful information cal_series_ = cal_series[series_idx] cal_last_hfc = cal_forecasts[series_idx][-1] @@ -460,24 +454,6 @@ def _calibrate_forecasts( start=cal_series_.end_time(), freq=cal_series_.freq, ) - # if calibration set gives residuals with unuseful information, increase the required size - if delta_end > 0: - if last_points_only: - min_n_cal += delta_end - elif delta_end >= forecast_horizon: - min_n_cal += delta_end - forecast_horizon + 1 - - if len(res) < min_n_cal: - set_name = "" if cal_series is None else "cal_" - raise_log( - ValueError( - "Could not build the minimum required calibration input with the provided " - f"`{set_name}series` and `{set_name}*_covariates` at series index: {series_idx}. " - f"Expected to generate at least `{min_n_cal}` calibration forecasts, " - f"but could only generate `{len(res)}`." - ), - logger=logger, - ) # drop residuals without useful information last_res_idx = None @@ -489,9 +465,27 @@ def _calibrate_forecasts( # useful residual information only up until the forecast # starting at the last time step in `series` last_res_idx = -(delta_end - forecast_horizon + 1) + if last_res_idx is None and cal_series is None: + # drop at least the one residuals/forecast from the end, since we can only use prior residuals + last_res_idx = -(self.output_chunk_shift + 1) + # with last points only, ignore the last `horizon` residuals to avoid look-ahead bias + if last_points_only: + last_res_idx -= forecast_horizon - 1 + if last_res_idx is not None: res = res[:last_res_idx] + if first_idx_train >= len(s_hfcs) or len(res) < min_n_cal: + set_name = "" if cal_series is None else "cal_" + raise_log( + ValueError( + "Could not build the minimum required calibration input with the provided " + f"`{set_name}series` and `{set_name}*_covariates` at series index: {series_idx}. " + f"Expected to generate at least `{min_n_cal}` calibration forecasts with known residuals " + f"before the first conformal forecast, but could only generate `{len(res)}`." + ), + logger=logger, + ) # skip solely based on `start` first_idx_start = 0 if start is not None: @@ -546,12 +540,27 @@ def _calibrate_forecasts( res = np.array(res) # -> (forecast horizon, n components, n samples * n examples) # rearrange the residuals to avoid look-ahead bias and to have the same number of examples per - # point in the horizon; - # e.g. for a horizon = 2, and some forecasting point at time t3, we would have residuals: - # R1: t1_h1, R2: t1_h2 (e.g. t1_h1 is the first forecasted point from time t1 -> t2) - # R3: t2_h1, R4: t2_h2 - # - R4 would be unknown at time t3 -> we exclude it - # - R1 is ignored to have the same number of examples per point in the horizon (1 in this case) + # point in the horizon. We want the most recent residuals in the past for each step in the horizon. + # Meaning that to conformalize any forecast at some time `t` with `horizon=n`: + # - for `horizon=1` of that forecast calibrate with residuals from all 1-step forecasts up until + # forecast time `t-1` + # - for `horizon=n` of that forecast calibrate with residuals from all n-step forecasts up until + # forecast time `t-n` + # The rearranged residuals will look as follows, where `res_ti_cj_hk` is the + # residuals at time `ti` for component `cj` at forecasted step/horizon `hk`. + # ``` + # [ # forecast horizon + # [ # components + # [res_t0_c0_h1, ...] # residuals at different times + # [..., res_tn_cn_h1], + # ], + # ..., + # [ + # [res_t0_c0_hn, ...], + # [..., res_tn_cn_hn], + # ], + # ] + # ``` res_ = [] for irr in range(forecast_horizon - 1, -1, -1): res_end_idx = -(forecast_horizon - (irr + 1)) @@ -559,6 +568,17 @@ def _calibrate_forecasts( res = np.concatenate(res_, axis=2).T assert not np.isnan(res).any().any() + # get the last forecast index based on the residual examples + if cal_series is None: + last_fc_idx = res.shape[2] + ( + forecast_horizon + self.output_chunk_shift + ) + else: + last_fc_idx = len(s_hfcs) + + if last_fc_idx > len(s_hfcs): + raise_log(ValueError("blabla"), logger=logger) + q_hat = None if cal_series is not None: if train_length is not None: @@ -584,6 +604,12 @@ def conformal_predict(idx_, pred_vals_): ) cal_res = res[:, :, cal_start:cal_end] + + # TODO: remove checks + len_exp = cal_end - (cal_start or 0) + if cal_res.shape[2] != len_exp: + raise_log(ValueError("Too short cal"), logger=logger) + q_hat_ = self._calibrate_interval(cal_res) else: # with a calibration set, use a constant q_hat @@ -593,7 +619,7 @@ def conformal_predict(idx_, pred_vals_): # historical conformal prediction if last_points_only: for idx, pred_vals in enumerate( - s_hfcs.values(copy=False)[first_fc_idx::stride] + s_hfcs.values(copy=False)[first_fc_idx:last_fc_idx:stride] ): pred_vals = np.expand_dims(pred_vals, 0) cp_pred = conformal_predict(idx, pred_vals) @@ -613,7 +639,7 @@ def conformal_predict(idx_, pred_vals_): ) cp_hfcs.append(cp_preds) else: - for idx, pred in enumerate(s_hfcs[first_fc_idx::stride]): + for idx, pred in enumerate(s_hfcs[first_fc_idx:last_fc_idx:stride]): pred_vals = pred.values(copy=False) cp_pred = conformal_predict(idx, pred_vals) cp_pred = _build_forecast_series( @@ -631,6 +657,7 @@ def conformal_predict(idx_, pred_vals_): def save( self, path: Optional[Union[str, os.PathLike, BinaryIO]] = None, **pkl_kwargs ) -> None: + # TODO: Use new save/load logic from EnsembleModel model_name = self.__class__.__name__ raise_log( NotImplementedError( diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 3386a942f1..1c3d44faab 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -629,15 +629,13 @@ def test_naive_conformal_model_predict(self, config): @pytest.mark.parametrize( "config", - list( - itertools.product( - [1, 3, 5], # horizon - [True, False], # univariate series - [True, False], # single series, - [0, 1], # output chunk shift - [None, 1], # train length - [False, True], # use covariates - ) + itertools.product( + [1, 3, 5], # horizon + [True, False], # univariate series + [True, False], # single series, + [0, 1], # output chunk shift + [None, 1], # train length + [False, True], # use covariates ), ) def test_naive_conformal_model_historical_forecasts(self, config): @@ -896,12 +894,10 @@ def helper_compute_naive_pred_cal( @pytest.mark.parametrize( "config", - list( - itertools.product( - [1, 3, 5], # horizon - [0, 1], # output chunk shift - [False, True], # use covariates - ) + itertools.product( + [1, 3, 5], # horizon + [0, 1], # output chunk shift + [False, True], # use covariates ), ) def test_too_short_input_predict(self, config): @@ -912,6 +908,7 @@ def test_too_short_input_predict(self, config): icl = IN_LEN min_len = icl + ocs + n series = tg.linear_timeseries(length=min_len) + series_train = [tg.linear_timeseries(length=IN_LEN + OUT_LEN + ocs)] * 2 model_params = {"output_chunk_shift": ocs} covs_kwargs = {} @@ -919,11 +916,10 @@ def test_too_short_input_predict(self, config): covs_kwargs_train = {} covs_kwargs_too_short = {} cal_covs_kwargs_short = {} - series = self.ts_pass_train.with_static_covariates(None) if use_covs: model_params["lags_past_covariates"] = regr_kwargs["lags"] + covs_kwargs_train["past_covariates"] = series_train # use shorter covariates, to test whether residuals are still properly extracted - covs_kwargs_train["past_covariates"] = [series] * 2 past_covs = series # for auto-regression, we require longer past covariates if n > OUT_LEN: @@ -936,7 +932,7 @@ def test_too_short_input_predict(self, config): model = ConformalNaiveModel( train_model( - series=[series] * 2, + series=series_train, model_params=model_params, **covs_kwargs_train, ), @@ -985,17 +981,14 @@ def test_too_short_input_predict(self, config): @pytest.mark.parametrize( "config", - list( - itertools.product( - [False, True], # last points only - [False, True], # overlap end - [None, 2], # train length - [False, True], # use multi-series - [0, 1], # output chunk shift - [1, 3, 5], # horizon - [True, False], # use covs - ) - )[6:7], + itertools.product( + [False, True], # last points only + [False, True], # overlap end + [None, 2], # train length + [0, 1], # output chunk shift + [1, 3, 5], # horizon + [True, False], # use covs + ), ) def test_too_short_input_hfc(self, config): """Checks conformal model historical forecasts with minimum required input and too short input.""" @@ -1003,7 +996,6 @@ def test_too_short_input_hfc(self, config): last_points_only, overlap_end, train_length, - use_multi_series, ocs, n, use_covs, @@ -1015,37 +1007,71 @@ def test_too_short_input_hfc(self, config): ocl = OUT_LEN horizon_ocs = n + ocs add_train_length = train_length - 1 if train_length is not None else 0 - # min length to generate 1 forecast - min_len_val_series = icl + 2 * horizon_ocs + add_train_length + # min length to generate 1 conformal forecast + min_len_val_series = ( + icl + horizon_ocs * (1 + int(not overlap_end)) + add_train_length + ) - series_train = tg.linear_timeseries(length=min_len_val_series + (ocl + ocs - 1)) - series = series_train[:min_len_val_series] + series_train = [tg.linear_timeseries(length=icl + ocl + ocs)] * 2 + series = tg.linear_timeseries(length=min_len_val_series) + + # define cal series to get the minimum required cal set + if overlap_end: + # with overlap_end `series` has the exact length to generate one forecast after the end of the input series + # Therefore, `series` has already the minimum length for one calibrated forecast + cal_series = series + else: + # without overlap_end, we use a shorter input, since the last forecast is within the input series + # (it generates more residuals with useful information than the minimum requirements) + cal_series = series[:-horizon_ocs] + + series_with_cal = series[: -(horizon_ocs + add_train_length)] model_params = {"output_chunk_shift": ocs} + covs_kwargs_train = {} covs_kwargs = {} + covs_with_cal_kwargs = {} cal_covs_kwargs = {} - covs_kwargs_train = {} - covs_kwargs_too_short = {} + covs_kwargs_short = {} cal_covs_kwargs_short = {} if use_covs: model_params["lags_past_covariates"] = regr_kwargs["lags"] - # use shorter covariates, to test whether residuals are still properly extracted - covs_kwargs_train["past_covariates"] = [series_train] * 2 - past_covs = series[: -(n + ocs)] + covs_kwargs_train["past_covariates"] = series_train + + # `- horizon_ocs` to generate forecasts extending up until end of target series + if not overlap_end: + past_covs = series[:-horizon_ocs] + else: + past_covs = series + + # calibration set is always generated internally with `overlap_end=True` + # make shorter to not compute residuals without useful information + cal_past_covs = cal_series[: -(1 + ocs)] + + # last_points_only requires `horizon` residuals less + if last_points_only: + cal_past_covs = cal_past_covs[: (-(n - 1) or None)] # for auto-regression, we require longer past covariates if n > OUT_LEN: past_covs = past_covs.append_values([1.0] * (n - OUT_LEN)) + cal_past_covs = cal_past_covs.append_values([1.0] * (n - OUT_LEN)) + # covariates lengths to generate exactly one forecast covs_kwargs["past_covariates"] = past_covs - covs_kwargs_too_short["past_covariates"] = past_covs[:-1] - # giving covs in calibration set requires one calibration example less - cal_covs_kwargs["cal_past_covariates"] = past_covs[:-1] - cal_covs_kwargs_short["cal_past_covariates"] = past_covs[:-2] + # giving a calibration set requires fewer forecasts + covs_with_cal_kwargs["past_covariates"] = past_covs[:-horizon_ocs] + cal_covs_kwargs["cal_past_covariates"] = cal_past_covs + + # use too short covariates to check that errors are raised + covs_kwargs_short["past_covariates"] = covs_kwargs["past_covariates"][:-1] + cal_covs_kwargs_short["cal_past_covariates"] = cal_covs_kwargs[ + "cal_past_covariates" + ][:-1] model = ConformalNaiveModel( train_model( - series=[series_train] * 2, + series=series_train, model_params=model_params, **covs_kwargs_train, ), @@ -1059,35 +1085,35 @@ def test_too_short_input_hfc(self, config): "forecast_horizon": n, } # prediction works with long enough input - preds1 = model.historical_forecasts( + hfcs = model.historical_forecasts( series=series, **covs_kwargs, **hfc_kwargs, ) - preds2 = model.historical_forecasts( - series=series[: -(n + ocs)], - cal_series=series[: -(n + ocs)], - **covs_kwargs, + hfcs_cal = model.historical_forecasts( + series=series_with_cal, + cal_series=cal_series, + **covs_with_cal_kwargs, **cal_covs_kwargs, **hfc_kwargs, ) if last_points_only: - preds1 = [preds1] - preds2 = [preds2] + hfcs = [hfcs] + hfcs_cal = [hfcs_cal] - # assert len(preds1) == 1 + n * int(overlap_end) - assert len(preds1) == len(preds2) == 1 + n * int(overlap_end) + assert len(hfcs) == len(hfcs_cal) == 1 + for hfc, hfc_cal in zip(hfcs, hfcs_cal): + assert not np.isnan(hfc.all_values()).any().any() + assert not np.isnan(hfc_cal.all_values()).any().any() - for pred1, pred2 in zip(preds1, preds2): - assert not np.isnan(pred1.all_values()).any().any() - assert not np.isnan(pred2.all_values()).any().any() # input too short: without covariates, make `series` shorter. Otherwise, use the shorter covariates series_ = series[:-1] if not use_covs else series + cal_series_ = cal_series[:-1] if not use_covs else cal_series with pytest.raises(ValueError) as exc: _ = model.historical_forecasts( series=series_, - **covs_kwargs_too_short, + **covs_kwargs_short, **hfc_kwargs, ) assert str(exc.value).startswith( @@ -1096,18 +1122,19 @@ def test_too_short_input_hfc(self, config): with pytest.raises(ValueError) as exc: _ = model.historical_forecasts( - series=series[: -(n + ocs)], - cal_series=series_[: -(n + ocs)], - **covs_kwargs, + series=series_with_cal, + cal_series=cal_series_, + **covs_with_cal_kwargs, **cal_covs_kwargs_short, **hfc_kwargs, ) - if not use_covs or n > 1: + if (not use_covs or n > 1 or (train_length or 1) > 1) and not ( + last_points_only and use_covs and train_length is None + ): assert str(exc.value).startswith( "Could not build the minimum required calibration input with the provided `cal_series`" ) else: - # if `cal_past_covariates` are too short and `horizon=1`, then it raises error from the forecasting model assert str(exc.value).startswith( "Cannot build a single input for prediction with the provided model" ) diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index 6e75e38b01..4747e55d2a 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -2516,26 +2516,26 @@ def test_sample_weight(self, config): @pytest.mark.parametrize( "config", - list( - itertools.product( - [False, True], # use covariates - [True, False], # last points only - [True, False], # overlap end - [1, 3], # stride - [ - 3, # horizon < ocl - 5, # horizon == ocl - 7, # horizon > ocl -> autoregression - ], - [False, True], # use integer indexed series - [False, True], # use multi-series - [0, 1], # output chunk shift - ) + itertools.product( + [False, True], # use covariates + [True, False], # last points only + [True, False], # overlap end + [1, 3], # stride + [ + 3, # horizon < ocl + 5, # horizon == ocl + 7, # horizon > ocl -> autoregression + ], + [False, True], # use integer indexed series + [False, True], # use multi-series + [0, 1], # output chunk shift ), ) def test_conformal_historical_forecasts(self, config): - """Tests naive conformal model with last points only, covariates, stride, - different horizons and overlap end.""" + """Tests historical forecasts output naive conformal model with last points only, covariates, stride, + different horizons and overlap end. + Tests that the returned dimensions, lengths and start / end times are correct. + """ ( use_covs, last_points_only, @@ -2546,16 +2546,18 @@ def test_conformal_historical_forecasts(self, config): use_multi_series, ocs, ) = config + # compute minimum series length to generate n forecasts icl = 3 ocl = 5 horizon_ocs = horizon + ocs min_len_val_series = icl + horizon_ocs + int(not overlap_end) * horizon_ocs - # generate n forecasts n_forecasts = 3 + # get train and val series of that length series_train, series_val = ( self.ts_pass_train[:10], self.ts_pass_val[: min_len_val_series + n_forecasts - 1], ) + if use_int_idx: series_train = TimeSeries.from_values( series_train.all_values(), columns=series_train.columns @@ -2570,16 +2572,10 @@ def test_conformal_historical_forecasts(self, config): ), columns=series_train.columns, ) + # check that too short input raises error series_val_too_short = series_val[:-n_forecasts] - # with pytest.raises(ValueError): - model_kwargs = ( - {} - if not use_covs - else {"lags_past_covariates": icl, "lags_future_covariates": (icl, ocl)} - ) - forecasting_model = LinearRegressionModel( - lags=icl, output_chunk_length=ocl, output_chunk_shift=ocs, **model_kwargs - ) + + # optionally, generate covariates if use_covs: pc = tg.gaussian_timeseries( start=series_train.start_time(), @@ -2595,10 +2591,18 @@ def test_conformal_historical_forecasts(self, config): else: pc, fc = None, None + # first train the ForecastingModel + model_kwargs = ( + {} + if not use_covs + else {"lags_past_covariates": icl, "lags_future_covariates": (icl, ocl)} + ) + forecasting_model = LinearRegressionModel( + lags=icl, output_chunk_length=ocl, output_chunk_shift=ocs, **model_kwargs + ) forecasting_model.fit(series_train, past_covariates=pc, future_covariates=fc) - model = ConformalNaiveModel(forecasting_model, alpha=0.8) - + # add an offset and rename columns in second series to make sure that conformal hist fc works as expected if use_multi_series: series_val = [ series_val, @@ -2609,6 +2613,9 @@ def test_conformal_historical_forecasts(self, config): pc = [pc, pc.shift(1)] if pc is not None else None fc = [fc, fc.shift(1)] if fc is not None else None + # conformal model + model = ConformalNaiveModel(forecasting_model, alpha=0.8) + # cannot perform auto regression with output chunk shift if ocs and horizon > ocl: with pytest.raises(ValueError) as exc: @@ -2625,6 +2632,7 @@ def test_conformal_historical_forecasts(self, config): assert str(exc.value).startswith("Cannot perform auto-regression") return + # compute conformal historical forecasts hist_fct = model.historical_forecasts( series=series_val, past_covariates=pc, @@ -2635,6 +2643,7 @@ def test_conformal_historical_forecasts(self, config): stride=stride, forecast_horizon=horizon, ) + # raises error with too short target series with pytest.raises(ValueError) as exc: _ = model.historical_forecasts( series=series_val_too_short, @@ -2661,50 +2670,49 @@ def test_conformal_historical_forecasts(self, config): if not isinstance(hfc, list): hfc = [hfc] - n_preds_with_overlap = len(series) - icl + 1 - horizon_ocs - if not last_points_only and overlap_end: + n_preds_with_overlap = ( + len(series) + - icl # input for first prediction + - horizon_ocs # skip first forecasts to avoid look-ahead bias + + 1 # minimum one forecast + ) + if not last_points_only: + # last points only = False gives a list of forecasts per input series + # where each forecast contains the predictions over the entire horizon n_pred_series_expected = n_preds_with_overlap n_pred_points_expected = horizon first_ts_expected = series.time_index[icl] + series.freq * ( horizon_ocs + ocs ) last_ts_expected = series.end_time() + series.freq * horizon_ocs - elif not last_points_only: # overlap_end = False - n_pred_series_expected = n_preds_with_overlap - horizon_ocs - n_pred_points_expected = horizon - first_ts_expected = series.time_index[icl] + series.freq * ( - horizon_ocs + ocs - ) - last_ts_expected = series.end_time() - elif overlap_end: # last_points_only = True + # no overlapping means less predictions + if not overlap_end: + n_pred_series_expected -= horizon_ocs + last_ts_expected -= series.freq * horizon_ocs + else: + # last points only = True gives one contiguous time series per input series + # with only predictions from the last point in the horizon n_pred_series_expected = 1 n_pred_points_expected = n_preds_with_overlap first_ts_expected = series.time_index[icl] + series.freq * ( horizon_ocs + ocs + horizon - 1 ) last_ts_expected = series.end_time() + series.freq * horizon_ocs - else: # last_points_only = True, overlap_end = False - n_pred_series_expected = 1 - n_pred_points_expected = n_preds_with_overlap - horizon_ocs - first_ts_expected = series.time_index[icl] + series.freq * ( - horizon_ocs + ocs + horizon - 1 - ) - last_ts_expected = series.end_time() + # no overlapping means less predictions + if not overlap_end: + n_pred_points_expected -= horizon_ocs + last_ts_expected -= series.freq * horizon_ocs - # to make it simple in case of stride, we assume that non-optimized hist fc returns correct results + # adapt based on stride if stride > 1: - n_pred_series_expected = ( - n_pred_series_expected - if last_points_only - else n_pred_series_expected // stride - + int(n_pred_series_expected % stride) - ) - n_pred_points_expected = ( - n_pred_points_expected - if not last_points_only - else n_pred_points_expected // stride - + int(n_pred_points_expected % stride) - ) + if not last_points_only: + n_pred_series_expected = n_pred_series_expected // stride + int( + n_pred_series_expected % stride + ) + else: + n_pred_points_expected = n_pred_points_expected // stride + int( + n_pred_points_expected % stride + ) first_ts_expected = hfc[0].start_time() last_ts_expected = hfc[-1].end_time() @@ -2723,16 +2731,14 @@ def test_conformal_historical_forecasts(self, config): @pytest.mark.parametrize( "config", - list( - itertools.product( - [False, True], # last points only - [None, 1, 2], # train length - [False, True], # use start - ["value", "position"], # start format - [False, True], # use integer indexed series - [False, True], # use multi-series - [0, 1], # output chunk shift - ) + itertools.product( + [False, True], # last points only + [None, 1, 2], # train length + [False, True], # use start + ["value", "position"], # start format + [False, True], # use integer indexed series + [False, True], # use multi-series + [0, 1], # output chunk shift ), ) def test_conformal_historical_start_train_length(self, config): @@ -2747,6 +2753,7 @@ def test_conformal_historical_start_train_length(self, config): use_multi_series, ocs, ) = config + # compute minimum series length to generate n forecasts icl = 3 ocl = 5 horizon = 5 @@ -2754,12 +2761,13 @@ def test_conformal_historical_start_train_length(self, config): add_train_length = train_length - 1 if train_length is not None else 0 add_start = 2 * int(use_start) min_len_val_series = icl + 2 * horizon_ocs + add_train_length + add_start - # generate n forecasts n_forecasts = 3 + # get train and val series of that length series_train, series_val = ( self.ts_pass_train[:10], self.ts_pass_val[: min_len_val_series + n_forecasts - 1], ) + if use_int_idx: series_train = TimeSeries.from_values( series_train.all_values(), columns=series_train.columns @@ -2774,6 +2782,8 @@ def test_conformal_historical_start_train_length(self, config): ), columns=series_train.columns, ) + + # first train the ForecastingModel forecasting_model = LinearRegressionModel( lags=icl, output_chunk_length=ocl, @@ -2781,6 +2791,7 @@ def test_conformal_historical_start_train_length(self, config): ) forecasting_model.fit(series_train) + # optionally compute the start as a positional index start_position = icl + horizon_ocs + add_train_length + add_start start = None if use_start: @@ -2788,8 +2799,8 @@ def test_conformal_historical_start_train_length(self, config): start = series_val.time_index[start_position] else: start = start_position - model = ConformalNaiveModel(forecasting_model, alpha=0.8) + # add an offset and rename columns in second series to make sure that conformal hist fc works as expected if use_multi_series: series_val = [ series_val, @@ -2798,25 +2809,27 @@ def test_conformal_historical_start_train_length(self, config): .with_columns_renamed(series_val.columns, "test_col"), ] - hist_fct = model.historical_forecasts( + # compute regular historical forecasts + hist_fct_all = forecasting_model.historical_forecasts( series=series_val, retrain=False, - train_length=train_length, start=start, start_format=start_format, last_points_only=last_points_only, forecast_horizon=horizon, ) - # using a calibration series should be able to calibrate all historical forecasts - # from the base forecasting model - hist_fct_all = forecasting_model.historical_forecasts( + # compute conformal historical forecasts (skips some of the first forecasts to get minimum required cal set) + model = ConformalNaiveModel(forecasting_model, alpha=0.8) + hist_fct = model.historical_forecasts( series=series_val, retrain=False, + train_length=train_length, start=start, start_format=start_format, last_points_only=last_points_only, forecast_horizon=horizon, ) + # using a calibration series should not skip any forecasts hist_fct_cal = model.historical_forecasts( series=series_val, cal_series=series_val, @@ -2851,12 +2864,13 @@ def test_conformal_historical_start_train_length(self, config): n_preds_without_overlap = ( len(series) - - icl - + 1 - - 2 * horizon_ocs - - add_train_length - - add_start - + add_start_series_2 + - icl # input for first prediction + - horizon_ocs # skip first forecasts to avoid look-ahead bias + - horizon_ocs # cannot compute with `overlap_end=False` + + 1 # minimum one forecast + - add_train_length # skip based on train length + - add_start # skip based on start + + add_start_series_2 # skip based on start if second series ) if not last_points_only: n_pred_series_expected = n_preds_without_overlap From 01e3d1e22bff30d3aca70e3e066b0111532c7cdc Mon Sep 17 00:00:00 2001 From: dennisbader Date: Mon, 23 Sep 2024 10:57:59 +0200 Subject: [PATCH 29/78] make naive conformal model accept quantiles --- darts/metrics/__init__.py | 4 +- darts/models/cp/conformal_model.py | 92 +++++++++++++++++------------- 2 files changed, 53 insertions(+), 43 deletions(-) diff --git a/darts/metrics/__init__.py b/darts/metrics/__init__.py index 2d0b5aaa2e..0ddf9a05fb 100644 --- a/darts/metrics/__init__.py +++ b/darts/metrics/__init__.py @@ -3,7 +3,7 @@ ------- For deterministic forecasts (point predictions with `num_samples == 1`), probabilistic forecasts (`num_samples > 1`), -and quantile forecasts. For probablistic and quantile forecasts, use parameter `q` to define the quantile(s) to +and quantile forecasts. For probabilistic and quantile forecasts, use parameter `q` to define the quantile(s) to compute the deterministic metrics on: - Aggregated over time: @@ -41,7 +41,7 @@ - :func:`sAPE `: symmetric Absolute Percentage Error - :func:`ARRE `: Absolute Ranged Relative Error -For probabilistic forecasts (storchastic predictions with `num_samples >> 1`): +For probabilistic forecasts (storchastic predictions with `num_samples >> 1`) and quantile forecasts: - Aggregated over time: - :func:`MQL `: Mean Quantile Loss - :func:`QR `: Quantile Risk diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 859e6f3004..a3c83a3856 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -24,7 +24,13 @@ get_single_series, series2seq, ) -from darts.utils.utils import generate_index, n_steps_between +from darts.utils.utils import ( + _check_quantiles, + generate_index, + likelihood_component_names, + n_steps_between, + quantile_names, +) logger = get_logger(__name__) @@ -59,9 +65,9 @@ def cqr_score_asym(row, quantile_lo_col, quantile_hi_col): class ConformalModel(GlobalForecastingModel, ABC): def __init__( self, - model, - alpha: Union[float, Tuple[float, float]], - quantiles: Optional[List[float]] = None, + model: GlobalForecastingModel, + quantiles: List[float], + # alpha: Union[float, Tuple[float, float]], ): """Base Conformal Prediction Model @@ -80,20 +86,27 @@ def __init__( ValueError("`model` must be a pre-trained `GlobalForecastingModel`."), logger=logger, ) + _check_quantiles(quantiles) super().__init__(add_encoders=None) - if isinstance(alpha, float): - self.symmetrical = True - self.q_hats = pd.DataFrame(columns=["q_hat_sym"]) - else: - self.symmetrical = False - self.alpha_lo, self.alpha_hi = alpha - self.q_hats = pd.DataFrame(columns=["q_hat_lo", "q_hat_hi"]) - self.model = model - self.noncon_scores = dict() - self.alpha = alpha + self.quantiles = quantiles + self._quantiles_no_med = [q for q in quantiles if q != 0.5] + + # if isinstance(alpha, float): + # self.symmetrical = True + # self.q_hats = pd.DataFrame(columns=["q_hat_sym"]) + # self.quantiles = [0.5 * (1 - alpha), 1 - 0.5 * (1 - alpha)] + # else: + # self.symmetrical = False + # self.alpha_lo, self.alpha_hi = alpha + # self.q_hats = pd.DataFrame(columns=["q_hat_lo", "q_hat_hi"]) + # self.quantiles = [1 - 0.5 * (1 - alpha_) for alpha_ in alpha] + # self.quantiles = self.quantiles[:1] + [0.50] + self.quantiles[1:] + # self.noncon_scores = dict() + # self.alpha = alpha + # self.quantiles = quantiles self._fit_called = True def fit( @@ -619,7 +632,7 @@ def conformal_predict(idx_, pred_vals_): # historical conformal prediction if last_points_only: for idx, pred_vals in enumerate( - s_hfcs.values(copy=False)[first_fc_idx:last_fc_idx:stride] + s_hfcs.all_values(copy=False)[first_fc_idx:last_fc_idx:stride] ): pred_vals = np.expand_dims(pred_vals, 0) cp_pred = conformal_predict(idx, pred_vals) @@ -640,7 +653,7 @@ def conformal_predict(idx_, pred_vals_): cp_hfcs.append(cp_preds) else: for idx, pred in enumerate(s_hfcs[first_fc_idx:last_fc_idx:stride]): - pred_vals = pred.values(copy=False) + pred_vals = pred.all_values(copy=False) cp_pred = conformal_predict(idx, pred_vals) cp_pred = _build_forecast_series( points_preds=cp_pred, @@ -675,24 +688,16 @@ def _calibrate_interval( """Computes the upper and lower calibrated forecast intervals based on residuals.""" @staticmethod - def _apply_interval(pred, q_hat): + def _apply_interval(pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray]): """Applies the calibrated interval to the predicted values. Returns an array with 3 predicted columns (lower bound, model forecast, upper bound) per component. E.g. output is `(target1_cq_low, target1_pred, target1_cq_high, target2_cq_low, ...)` """ - n_comps = pred.shape[1] - pred = np.concatenate([pred + q_hat[0], pred, pred + q_hat[1]], axis=1) - if n_comps == 1: - return pred - - n_cal_comps = 3 - # pre-compute axes swap (source and destination) for applying calibration intervals - axes_src = [i for i in range(n_comps * n_cal_comps)] - axes_dst = [] - for i in range(n_comps): - axes_dst += axes_src[i::n_comps] - return pred[:, axes_dst] + # shape (forecast horizon, n components, n quantiles) + pred = np.concatenate([pred + q_hat[0], pred, pred + q_hat[1]], axis=2) + # -> (forecast horizon, n components * n quantiles) + return pred.reshape(len(pred), -1) @property @abstractmethod @@ -794,11 +799,9 @@ def _get_q_hat(self, noncon_scores: dict) -> dict: return {"q_hat_sym": q_hat} def _cp_component_names(self, input_series) -> List[str]: - return [ - f"{tgt_name}{param_n}" - for tgt_name in input_series.components - for param_n in ["_cq_lo", "", "_cq_hi"] - ] + return likelihood_component_names( + input_series.components, quantile_names(self.quantiles) + ) @property def output_chunk_length(self) -> Optional[int]: @@ -988,13 +991,19 @@ def _get_evaluate_metrics_from_dataset( class ConformalNaiveModel(ConformalModel): - def __init__(self, model, alpha: Union[float, Tuple[float, float]]): - if not isinstance(alpha, float): - raise_log( - ValueError("`alpha` must be a `float`."), - logger=logger, + def __init__( + self, + model: GlobalForecastingModel, + quantiles: List[float], + ): + super().__init__(model=model, quantiles=quantiles) + half_idx = int(len(self.quantiles) / 2) + self.intervals = [ + q_high - q_low + for q_high, q_low in zip( + self.quantiles[half_idx + 1 :][::-1], self.quantiles[:half_idx] ) - super().__init__(model=model, alpha=alpha) + ] def _calibrate_interval( self, residuals: np.ndarray @@ -1006,7 +1015,8 @@ def _calibrate_interval( residuals The residuals are expected to have shape (horizon, n components, n historical forecasts * n samples) """ - q_hat = np.quantile(residuals, q=self.alpha, axis=2) + # shape (forecast horizon, n components, n quantile intervals) + q_hat = np.quantile(residuals, q=self.intervals, axis=2).transpose((1, 2, 0)) return -q_hat, q_hat @property From 3f136196a53d46c8e4f0a4dd532fbb4189d834c9 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Wed, 25 Sep 2024 10:41:43 +0200 Subject: [PATCH 30/78] add winkler score quantile interval metric --- darts/metrics/__init__.py | 81 ++-- darts/metrics/metrics.py | 574 +++++++++++++++++++++------- darts/models/cp/__init__.py | 0 darts/tests/metrics/test_metrics.py | 24 ++ 4 files changed, 509 insertions(+), 170 deletions(-) create mode 100644 darts/models/cp/__init__.py diff --git a/darts/metrics/__init__.py b/darts/metrics/__init__.py index 0ddf9a05fb..7a64485168 100644 --- a/darts/metrics/__init__.py +++ b/darts/metrics/__init__.py @@ -6,52 +6,62 @@ and quantile forecasts. For probabilistic and quantile forecasts, use parameter `q` to define the quantile(s) to compute the deterministic metrics on: - - Aggregated over time: - Absolute metrics: - - :func:`MERR `: Mean Error - - :func:`MAE `: Mean Absolute Error - - :func:`MSE `: Mean Squared Error - - :func:`RMSE `: Root Mean Squared Error - - :func:`RMSLE `: Root Mean Squared Log Error +- Aggregated over time: + Absolute metrics: + - :func:`MERR `: Mean Error + - :func:`MAE `: Mean Absolute Error + - :func:`MSE `: Mean Squared Error + - :func:`RMSE `: Root Mean Squared Error + - :func:`RMSLE `: Root Mean Squared Log Error - Relative metrics: - - :func:`MASE `: Mean Absolute Scaled Error - - :func:`MSSE `: Mean Squared Scaled Error - - :func:`RMSSE `: Root Mean Squared Scaled Error - - :func:`MAPE `: Mean Absolute Percentage Error - - :func:`sMAPE `: symmetric Mean Absolute Percentage Error - - :func:`OPE `: Overall Percentage Error - - :func:`MARRE `: Mean Absolute Ranged Relative Error + Relative metrics: + - :func:`MASE `: Mean Absolute Scaled Error + - :func:`MSSE `: Mean Squared Scaled Error + - :func:`RMSSE `: Root Mean Squared Scaled Error + - :func:`MAPE `: Mean Absolute Percentage Error + - :func:`sMAPE `: symmetric Mean Absolute Percentage Error + - :func:`OPE `: Overall Percentage Error + - :func:`MARRE `: Mean Absolute Ranged Relative Error - Other metrics: - - :func:`R2 `: Coefficient of Determination - - :func:`CV `: Coefficient of Variation + Other metrics: + - :func:`R2 `: Coefficient of Determination + - :func:`CV `: Coefficient of Variation - - Per time step: - Absolute metrics: - - :func:`ERR `: Error - - :func:`AE `: Absolute Error - - :func:`SE `: Squared Error - - :func:`SLE `: Squared Log Error +- Per time step: + Absolute metrics: + - :func:`ERR `: Error + - :func:`AE `: Absolute Error + - :func:`SE `: Squared Error + - :func:`SLE `: Squared Log Error - Relative metrics: - - :func:`ASE `: Absolute Scaled Error - - :func:`SSE `: Squared Scaled Error - - :func:`APE `: Absolute Percentage Error - - :func:`sAPE `: symmetric Absolute Percentage Error - - :func:`ARRE `: Absolute Ranged Relative Error + Relative metrics: + - :func:`ASE `: Absolute Scaled Error + - :func:`SSE `: Squared Scaled Error + - :func:`APE `: Absolute Percentage Error + - :func:`sAPE `: symmetric Absolute Percentage Error + - :func:`ARRE `: Absolute Ranged Relative Error For probabilistic forecasts (storchastic predictions with `num_samples >> 1`) and quantile forecasts: - - Aggregated over time: + +- Aggregated over time: + Quantile metrics: - :func:`MQL `: Mean Quantile Loss - :func:`QR `: Quantile Risk + + Quantile interval metrics: - :func:`MIW `: Mean Interval Width - - Per time step: + - :func:`MWS `: Mean Interval Winkler Score +- Per time step: + Quantile metrics: - :func:`QL `: Quantile Loss + + Quantile interval metrics: - :func:`IW `: Interval Width + - :func:`WS `: Interval Winkler Score For Dynamic Time Warping (DTW) (aggregated over time): - - :func:`DTW `: Dynamic Time Warping Metric + +- :func:`DTW `: Dynamic Time Warping Metric """ from darts.metrics.metrics import ( @@ -63,12 +73,14 @@ dtw_metric, err, iw, + iws, mae, mape, marre, mase, merr, miw, + miws, mql, mse, msse, @@ -98,6 +110,7 @@ sle, sse, iw, + iws, } __all__ = [ @@ -130,4 +143,6 @@ "sse", "iw", "miw", + "iws", + "miws", ] diff --git a/darts/metrics/metrics.py b/darts/metrics/metrics.py index 1c667a7eb3..6de57caf3e 100644 --- a/darts/metrics/metrics.py +++ b/darts/metrics/metrics.py @@ -656,7 +656,7 @@ def err( """Error (ERR). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed per - component/column and time step :math:`t` as: + component/column, (optional) quantile, and time step :math:`t` as: .. math:: y_t - \\hat{y}_t @@ -701,16 +701,18 @@ def err( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n time steps, n components) without time - and component reductions. For: + A numpy array of metric scores. The array has shape (n time steps, n components * n quantiles) without time + and component reductions, and shape (n time steps, n quantiles) without time but component reduction and + `len(q) > 1`. For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of @@ -747,7 +749,7 @@ def merr( """Mean Error (MERR). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed per - component/column as: + component/column and (optional) quantile as: .. math:: \\frac{1}{T}\\sum_{t=1}^T{(y_t - \\hat{y}_t)} @@ -787,16 +789,19 @@ def merr( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, + and shape (n quantiles,) with component reduction and `len(q) > 1`. + For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -830,7 +835,7 @@ def ae( """Absolute Error (AE). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed per - component/column and time step :math:`t` as: + component/column, (optional) quantile, and time step :math:`t` as: .. math:: |y_t - \\hat{y}_t| @@ -875,16 +880,18 @@ def ae( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n time steps, n components) without time - and component reductions. For: + A numpy array of metric scores. The array has shape (n time steps, n components * n quantiles) without time + and component reductions, and shape (n time steps, n quantiles) without time but component reduction and + `len(q) > 1`. For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of @@ -921,7 +928,7 @@ def mae( """Mean Absolute Error (MAE). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed per - component/column as: + component/column and (optional) quantile as: .. math:: \\frac{1}{T}\\sum_{t=1}^T{|y_t - \\hat{y}_t|} @@ -961,16 +968,19 @@ def mae( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, + and shape (n quantiles,) with component reduction and `len(q) > 1`. + For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -1008,7 +1018,7 @@ def ase( It is the Absolute Error (AE) scaled by the Mean AE (MAE) of the naive m-seasonal forecast. For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed per - component/column and time step :math:`t` as: + component/column, (optional) quantile, and time step :math:`t` as: .. math:: \\frac{AE(y_{t_p+1:t_p+T}, \\hat{y}_{t_p+1:t_p+T})}{E_m}, @@ -1072,16 +1082,18 @@ def ase( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n time steps, n components) without time - and component reductions. For: + A numpy array of metric scores. The array has shape (n time steps, n components * n quantiles) without time + and component reductions, and shape (n time steps, n quantiles) without time but component reduction and + `len(q) > 1`. For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of @@ -1125,7 +1137,7 @@ def mase( It is the Mean Absolute Error (MAE) scaled by the MAE of the naive m-seasonal forecast. For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed per - component/column as: + component/column and (optional) quantile as: .. math:: \\frac{MAE(y_{t_p+1:t_p+T}, \\hat{y}_{t_p+1:t_p+T})}{E_m}, @@ -1184,16 +1196,19 @@ def mase( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, + and shape (n quantiles,) with component reduction and `len(q) > 1`. + For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -1233,7 +1248,7 @@ def se( """Squared Error (SE). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed per - component/column and time step :math:`t` as: + component/column, (optional) quantile, and time step :math:`t` as: .. math:: (y_t - \\hat{y}_t)^2. @@ -1278,16 +1293,18 @@ def se( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n time steps, n components) without time - and component reductions. For: + A numpy array of metric scores. The array has shape (n time steps, n components * n quantiles) without time + and component reductions, and shape (n time steps, n quantiles) without time but component reduction and + `len(q) > 1`. For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of @@ -1324,7 +1341,7 @@ def mse( """Mean Squared Error (MSE). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed per - component/column as: + component/column and (optional) quantile as: .. math:: \\frac{1}{T}\\sum_{t=1}^T{(y_t - \\hat{y}_t)^2}. @@ -1364,16 +1381,19 @@ def mse( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, + and shape (n quantiles,) with component reduction and `len(q) > 1`. + For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -1411,7 +1431,7 @@ def sse( It is the Squared Error (SE) scaled by the Mean SE (MSE) of the naive m-seasonal forecast. For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed per - component/column and time step :math:`t` as: + component/column, (optional) quantile, and time step :math:`t` as: .. math:: \\frac{SE(y_{t_p+1:t_p+T}, \\hat{y}_{t_p+1:t_p+T})}{E_m}, @@ -1475,16 +1495,18 @@ def sse( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n time steps, n components) without time - and component reductions. For: + A numpy array of metric scores. The array has shape (n time steps, n components * n quantiles) without time + and component reductions, and shape (n time steps, n quantiles) without time but component reduction and + `len(q) > 1`. For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of @@ -1528,7 +1550,7 @@ def msse( It is the Mean Squared Error (MSE) scaled by the MSE of the naive m-seasonal forecast. For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed per - component/column as: + component/column and (optional) quantile as: .. math:: \\frac{MSE(y_{t_p+1:t_p+T}, \\hat{y}_{t_p+1:t_p+T})}{E_m}, @@ -1587,16 +1609,19 @@ def msse( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, + and shape (n quantiles,) with component reduction and `len(q) > 1`. + For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -1635,7 +1660,7 @@ def rmse( """Root Mean Squared Error (RMSE). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed per - component/column as: + component/column and (optional) quantile as: .. math:: \\sqrt{\\frac{1}{T}\\sum_{t=1}^T{(y_t - \\hat{y}_t)^2}} @@ -1675,16 +1700,19 @@ def rmse( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, + and shape (n quantiles,) with component reduction and `len(q) > 1`. + For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -1720,7 +1748,7 @@ def rmsse( It is the Root Mean Squared Error (RMSE) scaled by the RMSE of the naive m-seasonal forecast. For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed per - component/column as: + component/column and (optional) quantile as: .. math:: \\frac{RMSE(y_{t_p+1:t_p+T}, \\hat{y}_{t_p+1:t_p+T})}{E_m}, @@ -1779,16 +1807,19 @@ def rmsse( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, + and shape (n quantiles,) with component reduction and `len(q) > 1`. + For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -1825,7 +1856,7 @@ def sle( """Squared Log Error (SLE). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed per - component/column and time step :math:`t` as: + component/column, (optional) quantile, and time step :math:`t` as: .. math:: \\left(\\log{(y_t + 1)} - \\log{(\\hat{y} + 1)}\\right)^2 @@ -1872,16 +1903,18 @@ def sle( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n time steps, n components) without time - and component reductions. For: + A numpy array of metric scores. The array has shape (n time steps, n components * n quantiles) without time + and component reductions, and shape (n time steps, n quantiles) without time but component reduction and + `len(q) > 1`. For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of @@ -1919,7 +1952,7 @@ def rmsle( """Root Mean Squared Log Error (RMSLE). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed per - component/column as: + component/column and (optional) quantile as: .. math:: \\sqrt{\\frac{1}{T}\\sum_{t=1}^T{\\left(\\log{(y_t + 1)} - \\log{(\\hat{y}_t + 1)}\\right)^2}} @@ -1961,16 +1994,19 @@ def rmsle( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, + and shape (n quantiles,) with component reduction and `len(q) > 1`. + For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -2059,16 +2095,18 @@ def ape( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n time steps, n components) without time - and component reductions. For: + A numpy array of metric scores. The array has shape (n time steps, n components * n quantiles) without time + and component reductions, and shape (n time steps, n quantiles) without time but component reduction and + `len(q) > 1`. For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of @@ -2112,7 +2150,7 @@ def mape( """Mean Absolute Percentage Error (MAPE). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed as a - percentage value per component/column with: + percentage value per component/column and (optional) quantile with: .. math:: 100 \\cdot \\frac{1}{T} \\sum_{t=1}^{T}{\\left| \\frac{y_t - \\hat{y}_t}{y_t} \\right|} @@ -2160,16 +2198,19 @@ def mape( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, + and shape (n quantiles,) with component reduction and `len(q) > 1`. + For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -2204,7 +2245,7 @@ def sape( """symmetric Absolute Percentage Error (sAPE). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed as a - percentage value per component/column and time step :math:`t` with: + percentage value per component/column, (optional) quantile and time step :math:`t` with: .. math:: 200 \\cdot \\frac{\\left| y_t - \\hat{y}_t \\right|}{\\left| y_t \\right| + \\left| \\hat{y}_t \\right|} @@ -2258,16 +2299,18 @@ def sape( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n time steps, n components) without time - and component reductions. For: + A numpy array of metric scores. The array has shape (n time steps, n components * n quantiles) without time + and component reductions, and shape (n time steps, n quantiles) without time but component reduction and + `len(q) > 1`. For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of @@ -2311,7 +2354,7 @@ def smape( """symmetric Mean Absolute Percentage Error (sMAPE). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed as a - percentage value per component/column with: + percentage value per component/column and (optional) quantile with: .. math:: 200 \\cdot \\frac{1}{T} @@ -2362,16 +2405,19 @@ def smape( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, + and shape (n quantiles,) with component reduction and `len(q) > 1`. + For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -2405,7 +2451,7 @@ def ope( """Overall Percentage Error (OPE). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed as a - percentage value per component/column with: + percentage value per component/column and (optional) quantile with: .. math:: 100 \\cdot \\left| \\frac{\\sum_{t=1}^{T}{y_t} - \\sum_{t=1}^{T}{\\hat{y}_t}}{\\sum_{t=1}^{T}{y_t}} \\right|. @@ -2451,16 +2497,19 @@ def ope( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, + and shape (n quantiles,) with component reduction and `len(q) > 1`. + For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -2505,7 +2554,7 @@ def arre( """Absolute Ranged Relative Error (ARRE). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed as a - percentage value per component/column and time step :math:`t` with: + percentage value per component/column, (optional) quantile and time step :math:`t` with: .. math:: 100 \\cdot \\left| \\frac{y_t - \\hat{y}_t} {\\max_t{y_t} - \\min_t{y_t}} \\right| @@ -2555,16 +2604,18 @@ def arre( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n time steps, n components) without time - and component reductions. For: + A numpy array of metric scores. The array has shape (n time steps, n components * n quantiles) without time + and component reductions, and shape (n time steps, n quantiles) without time but component reduction and + `len(q) > 1`. For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of @@ -2611,7 +2662,7 @@ def marre( """Mean Absolute Ranged Relative Error (MARRE). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed as a - percentage value per component/column with: + percentage value per component/column and (optional) quantile with: .. math:: 100 \\cdot \\frac{1}{T} \\sum_{t=1}^{T} {\\left| \\frac{y_t - \\hat{y}_t} {\\max_t{y_t} - \\min_t{y_t}} \\right|} @@ -2697,7 +2748,7 @@ def r2_score( """Coefficient of Determination :math:`R^2` (see [1]_ for more details). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed per - component/column as: + component/column and (optional) quantile as: .. math:: 1 - \\frac{\\sum_{t=1}^T{(y_t - \\hat{y}_t)^2}}{\\sum_{t=1}^T{(y_t - \\bar{y})^2}}, @@ -2741,16 +2792,19 @@ def r2_score( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, + and shape (n quantiles,) with component reduction and `len(q) > 1`. + For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -2789,7 +2843,7 @@ def coefficient_of_variation( """Coefficient of Variation (percentage). For the true series :math:`y` and predicted series :math:`\\hat{y}` of length :math:`T`, it is computed per - component/column as a percentage value with: + component/column and (optional) quantile as a percentage value with: .. math:: 100 \\cdot \\text{RMSE}(y_t, \\hat{y}_t) / \\bar{y}, @@ -2832,16 +2886,19 @@ def coefficient_of_variation( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, + and shape (n quantiles,) with component reduction and `len(q) > 1`. + For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -2920,16 +2977,19 @@ def dtw_metric( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, + and shape (n quantiles,) with component reduction and `len(q) > 1`. + For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -2966,7 +3026,7 @@ def qr( sample values summed up along the time axis (QL computes the quantile and loss per time step). For the true series :math:`y` and predicted stochastic/probabilistic series (containing N samples) :math:`\\hat{y}` - of of shape :math:`T \\times N`, it is computed per column/component as: + of of shape :math:`T \\times N`, it is computed per column/component and quantile as: .. math:: 2 \\frac{QL(Z, \\hat{Z}_q)}{Z}, @@ -3006,16 +3066,19 @@ def qr( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, + and shape (n quantiles,) with component reduction and `len(q) > 1`. + For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -3074,7 +3137,7 @@ def ql( QL computes the quantile of all sample values and the loss per time step. For the true series :math:`y` and predicted stochastic/probabilistic series (containing N samples) :math:`\\hat{y}` - of of shape :math:`T \\times N`, it is computed per column/component and time step :math:`t` as: + of of shape :math:`T \\times N`, it is computed per column/component, quantile and time step :math:`t` as: .. math:: 2 \\max((q - 1) (y_t - \\hat{y}_{t,q}), q (y_t - \\hat{y}_{t,q})), @@ -3119,16 +3182,18 @@ def ql( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n time steps, n components) without time - and component reductions. For: + A numpy array of metric scores. The array has shape (n time steps, n components * n quantiles) without time + and component reductions, and shape (n time steps, n quantiles) without time but component reduction and + `len(q) > 1`. For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of @@ -3174,7 +3239,7 @@ def mql( time axis. For the true series :math:`y` and predicted stochastic/probabilistic series (containing N samples) :math:`\\hat{y}` - of of shape :math:`T \\times N`, it is computed per column/component as: + of of shape :math:`T \\times N`, it is computed per column/component and quantile as: .. math:: 2 \\frac{1}{T}\\sum_{t=1}^T{\\max((q - 1) (y_t - \\hat{y}_{t,q}), q (y_t - \\hat{y}_{t,q}))}, @@ -3214,16 +3279,19 @@ def mql( Returns ------- float - A single metric score for: + A single metric score for (with `len(q) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, + and shape (n quantiles,) with component reduction and `len(q) > 1`. + For: + - the input from the `float` return case above but with `len(q) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -3258,16 +3326,17 @@ def iw( ) -> METRIC_OUTPUT_TYPE: """Interval Width (IL). - IL gives the width of predicted quantile intervals. + IL gives the length / width of predicted quantile intervals. For the true series :math:`y` and predicted stochastic or quantile series :math:`\\hat{y}` of length :math:`T`, - it is computed per component/column, quantile interval, and time step + it is computed per component/column, quantile interval :math:`(q_l,q_h)`, and time step :math:`t` as: - .. math:: \\hat{y}_{t,qh} - \\hat{y}_{t,ql} + .. math:: U_t - L_t, - where :math:`\\hat{y}_{t,qh}` are the upper bound quantile values (of all predicted quantiles or samples) at time - :math:`t`, and :math:`\\hat{y}_{t,ql}` are the lower bound quantile values. + where :math:`U_t` are the predicted upper bound quantile values :math:`\\hat{y}_{q_h,t}` (of all predicted + quantiles or samples) at time :math:`t`, and :math:`L_t` are the predicted lower bound quantile values + :math:`\\hat{y}_{q_l,t}`. Parameters ---------- @@ -3309,16 +3378,18 @@ def iw( Returns ------- float - A single metric score for: + A single metric score for (with `len(q_interval) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n time steps, n components) without time - and component reductions. For: + A numpy array of metric scores. The array has shape (n time steps, n components * n q intervals) without time + and component reductions, and shape (n time steps, n q intervals) without time but component reduction and + `len(q_interval) > 1`. For: + - the input from the `float` return case above but with `len(q_interval) > 1`. - single multivariate series and at least `component_reduction=None`. - single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of @@ -3354,18 +3425,19 @@ def miw( n_jobs: int = 1, verbose: bool = False, ) -> METRIC_OUTPUT_TYPE: - """Mean Interval Width (IL). + """Mean Interval Width (MIL). - IL gives the width of predicted quantile intervals aggregated over time. + MIL gives the time-aggregated length / width of predicted quantile intervals. For the true series :math:`y` and predicted stochastic or quantile series :math:`\\hat{y}` of length :math:`T`, - it is computed per component/column, quantile interval, and time step + it is computed per component/column, quantile interval :math:`(q_l,q_h)`, and time step :math:`t` as: - .. math:: \\frac{1}{T}\\sum_{t=1}^T{\\hat{y}_{t,qh} - \\hat{y}_{t,ql}} + .. math:: \\frac{1}{T}\\sum_{t=1}^T{U_t - L_t}, - where :math:`\\hat{y}_{t,qh}` are the upper bound quantile values (of all predicted quantiles or samples) at time - :math:`t`, and :math:`\\hat{y}_{t,ql}` are the lower bound quantile values. + where :math:`U_t` are the predicted upper bound quantile values :math:`\\hat{y}_{q_h,t}` (of all predicted + quantiles or samples) at time :math:`t`, and :math:`L_t` are the predicted lower bound quantile values + :math:`\\hat{y}_{q_l,t}`. Parameters ---------- @@ -3402,16 +3474,19 @@ def miw( Returns ------- float - A single metric score for: + A single metric score for (with `len(q_interval) <= 1`): - single univariate series. - single multivariate series with `component_reduction`. - - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray - A numpy array of metric scores. The array has shape (n components,) without component reduction. For: + A numpy array of metric scores. The array has shape (n components * n q intervals,) without component reduction, + and shape (n q intervals,) with component reduction and `len(q_interval) > 1`. + For: + - the input from the `float` return case above but with `len(q_interval) > 1`. - single multivariate series and at least `component_reduction=None`. - - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. List[float] Same as for type `float` but for a sequence of series. List[np.ndarray] @@ -3427,3 +3502,228 @@ def miw( ), axis=TIME_AX, ) + + +@interval_support +@multi_ts_support +@multivariate_support +def iws( + actual_series: Union[TimeSeries, Sequence[TimeSeries]], + pred_series: Union[TimeSeries, Sequence[TimeSeries]], + intersect: bool = True, + *, + q_interval: Union[Tuple[float, float], Sequence[Tuple[float, float]]] = None, + q: Optional[Union[float, List[float], Tuple[np.ndarray, pd.Index]]] = None, + time_reduction: Optional[Callable[..., np.ndarray]] = None, + component_reduction: Optional[Callable[[np.ndarray], float]] = np.nanmean, + series_reduction: Optional[Callable[[np.ndarray], Union[float, np.ndarray]]] = None, + n_jobs: int = 1, + verbose: bool = False, +) -> METRIC_OUTPUT_TYPE: + """Interval Winkler Score (IWS) [1]_. + + IWS gives the length / width of the quantile intervals plus a penalty if the observation is outside the interval. + + For the true series :math:`y` and predicted stochastic or quantile series :math:`\\hat{y}` of length :math:`T`, + it is computed per component/column, quantile interval :math:`(q_l,q_h)`, and time step :math:`t` as: + + .. math:: + \\begin{equation} + \\begin{cases} + (U_t - L_t) + \\frac{1}{q_l} (L_t - y_t) & \\text{if } y_t < L_t \\\\ + (U_t - L_t) & \\text{if } L_t \\leq y_t \\leq U_t \\\\ + (U_t - L_t) + \\frac{1}{1 - q_h} (y_t - U_t) & \\text{if } y_t > U_t + \\end{cases} + \\end{equation}, + + where :math:`U_t` are the predicted upper bound quantile values :math:`\\hat{y}_{q_h,t}` (of all predicted + quantiles or samples) at time :math:`t`, and :math:`L_t` are the predicted lower bound quantile values + :math:`\\hat{y}_{q_l,t}`. + + Parameters + ---------- + actual_series + The (sequence of) actual series. + pred_series + The (sequence of) predicted series. + intersect + For time series that are overlapping in time without having the same time index, setting `True` + will consider the values only over their common time interval (intersection in time). + q_interval + The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence tuples + (multiple intervals) with elements (low quantile, high quantile). + q + Quantiles `q` not supported by this metric; use `q_interval` instead. + component_reduction + Optionally, a function to aggregate the metrics over the component/column axis. It must reduce a `np.ndarray` + of shape `(t, c)` to a `np.ndarray` of shape `(t,)`. The function takes as input a ``np.ndarray`` and a + parameter named `axis`, and returns the reduced array. The `axis` receives value `1` corresponding to the + component axis. If `None`, will return a metric per component. + time_reduction + Optionally, a function to aggregate the metrics over the time axis. It must reduce a `np.ndarray` + of shape `(t, c)` to a `np.ndarray` of shape `(c,)`. The function takes as input a ``np.ndarray`` and a + parameter named `axis`, and returns the reduced array. The `axis` receives value `0` corresponding to the + time axis. If `None`, will return a metric per time step. + series_reduction + Optionally, a function to aggregate the metrics over multiple series. It must reduce a `np.ndarray` + of shape `(s, t, c)` to a `np.ndarray` of shape `(t, c)` The function takes as input a ``np.ndarray`` and a + parameter named `axis`, and returns the reduced array. The `axis` receives value `0` corresponding to the + series axis. For example with `np.nanmean`, will return the average over all series metrics. If `None`, will + return a metric per component. + n_jobs + The number of jobs to run in parallel. Parallel jobs are created only when a ``Sequence[TimeSeries]`` is + passed as input, parallelising operations regarding different ``TimeSeries``. Defaults to `1` + (sequential). Setting the parameter to `-1` means using all the available processors. + verbose + Optionally, whether to print operations progress + + Returns + ------- + float + A single metric score for (with `len(q_interval) <= 1`): + + - single univariate series. + - single multivariate series with `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and + `time_reduction`. + np.ndarray + A numpy array of metric scores. The array has shape (n time steps, n components * n q intervals) without time + and component reductions, and shape (n time steps, n q intervals) without time but component reduction and + `len(q_interval) > 1`. For: + + - the input from the `float` return case above but with `len(q_interval) > 1`. + - single multivariate series and at least `component_reduction=None`. + - single uni/multivariate series and at least `time_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and at least one of + `component_reduction=None` or `time_reduction=None`. + List[float] + Same as for type `float` but for a sequence of series. + List[np.ndarray] + Same as for type `np.ndarray` but for a sequence of series. + + References + ---------- + .. [1] https://otexts.com/fpp3/distaccuracy.html + """ + y_true, y_pred = _get_values_or_raise( + actual_series, + pred_series, + intersect, + remove_nan_union=True, + q=q, + ) + y_pred_lo, y_pred_hi = _get_quantile_intervals(y_pred, q=q, q_interval=q_interval) + interval_width = y_pred_hi - y_pred_lo + + # `c_alpha = 2 / alpha` corresponds to: + # - `1 / (1 - q_hi)` for the high quantile + # - `1 / q_lo` for the low quantile + c_alpha_hi = 1 / (1 - q_interval[:, 1]) + c_alpha_lo = 1 / q_interval[:, 0] + + score = np.where( + y_true < y_pred_lo, + interval_width + c_alpha_lo * (y_pred_lo - y_true), + np.where( + y_true > y_pred_hi, + interval_width + c_alpha_hi * (y_true - y_pred_hi), + interval_width, + ), + ) + return score + + +@interval_support +@multi_ts_support +@multivariate_support +def miws( + actual_series: Union[TimeSeries, Sequence[TimeSeries]], + pred_series: Union[TimeSeries, Sequence[TimeSeries]], + intersect: bool = True, + *, + q_interval: Union[Tuple[float, float], Sequence[Tuple[float, float]]] = None, + q: Optional[Union[float, List[float], Tuple[np.ndarray, pd.Index]]] = None, + component_reduction: Optional[Callable[[np.ndarray], float]] = np.nanmean, + series_reduction: Optional[Callable[[np.ndarray], Union[float, np.ndarray]]] = None, + n_jobs: int = 1, + verbose: bool = False, +) -> METRIC_OUTPUT_TYPE: + """Mean Interval Winkler Score (IWS) [1]_. + + MIWS gives the time-aggregated length / width of the quantile intervals plus a penalty if the observation is + outside the interval. + + For the true series :math:`y` and predicted stochastic or quantile series :math:`\\hat{y}` of length :math:`T`, + it is computed per component/column, quantile interval :math:`(q_l,q_h)`, and time step :math:`t` as: + + .. math:: \\frac{1}{T}\\sum_{t=1}^T{W_t(y_t, \\hat{y}_{t}, q_h, q_l)}, + + where :math:`W` is the Winkler Score :func:`~darts.metrics.metrics.iws`. + + Parameters + ---------- + actual_series + The (sequence of) actual series. + pred_series + The (sequence of) predicted series. + intersect + For time series that are overlapping in time without having the same time index, setting `True` + will consider the values only over their common time interval (intersection in time). + q_interval + The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence tuples + (multiple intervals) with elements (low quantile, high quantile). + q + Quantiles `q` not supported by this metric; use `q_interval` instead. + component_reduction + Optionally, a function to aggregate the metrics over the component/column axis. It must reduce a `np.ndarray` + of shape `(t, c)` to a `np.ndarray` of shape `(t,)`. The function takes as input a ``np.ndarray`` and a + parameter named `axis`, and returns the reduced array. The `axis` receives value `1` corresponding to the + component axis. If `None`, will return a metric per component. + series_reduction + Optionally, a function to aggregate the metrics over multiple series. It must reduce a `np.ndarray` + of shape `(s, t, c)` to a `np.ndarray` of shape `(t, c)` The function takes as input a ``np.ndarray`` and a + parameter named `axis`, and returns the reduced array. The `axis` receives value `0` corresponding to the + series axis. For example with `np.nanmean`, will return the average over all series metrics. If `None`, will + return a metric per component. + n_jobs + The number of jobs to run in parallel. Parallel jobs are created only when a ``Sequence[TimeSeries]`` is + passed as input, parallelising operations regarding different ``TimeSeries``. Defaults to `1` + (sequential). Setting the parameter to `-1` means using all the available processors. + verbose + Optionally, whether to print operations progress + + Returns + ------- + float + A single metric score for (with `len(q_interval) <= 1`): + + - single univariate series. + - single multivariate series with `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + np.ndarray + A numpy array of metric scores. The array has shape (n components * n q intervals,) without component reduction, + and shape (n q intervals,) with component reduction and `len(q_interval) > 1`. + For: + + - the input from the `float` return case above but with `len(q_interval) > 1`. + - single multivariate series and at least `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + List[float] + Same as for type `float` but for a sequence of series. + List[np.ndarray] + Same as for type `np.ndarray` but for a sequence of series. + + References + ---------- + .. [1] https://otexts.com/fpp3/distaccuracy.html + """ + return np.nanmean( + _get_wrapped_metric(iws, n_wrappers=3)( + actual_series, + pred_series, + intersect, + q=q, + q_interval=q_interval, + ), + axis=TIME_AX, + ) diff --git a/darts/models/cp/__init__.py b/darts/models/cp/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/darts/tests/metrics/test_metrics.py b/darts/tests/metrics/test_metrics.py index df7a820bf5..480dc0e61d 100644 --- a/darts/tests/metrics/test_metrics.py +++ b/darts/tests/metrics/test_metrics.py @@ -79,6 +79,27 @@ def metric_iw(y_true, y_pred, q_interval=None, **kwargs): return res.reshape(len(y_pred), -1) +def metric_iws(y_true, y_pred, q_interval=None, **kwargs): + # this tests assumes `y_pred` are stochastic values + if isinstance(q_interval, tuple): + q_interval = [q_interval] + q_interval = np.array(q_interval) + q_lo = q_interval[:, 0] + q_hi = q_interval[:, 1] + y_pred_lo = np.quantile(y_pred, q_lo, axis=2).transpose(1, 2, 0) + y_pred_hi = np.quantile(y_pred, q_hi, axis=2).transpose(1, 2, 0) + interval_width = y_pred_hi - y_pred_lo + res = np.where( + y_true < y_pred_lo, + interval_width + 1 / q_lo * (y_pred_lo - y_true), + interval_width, + ) + res = np.where( + y_true > y_pred_hi, interval_width + 1 / (1 - q_hi) * (y_true - y_pred_hi), res + ) + return res.reshape(len(y_pred), -1) + + class TestMetrics: np.random.seed(42) pd_train = pd.Series( @@ -1853,6 +1874,7 @@ def test_wrong_error_scale(self): [ # only time dependent quantile interval metrics (metrics.iw, metric_iw), + (metrics.iws, metric_iws), ], ) def test_metric_quantile_interval_accuracy(self, config): @@ -1899,6 +1921,8 @@ def check_ref(**test_kwargs): # time dependent but with time reduction metrics.iw, metrics.miw, + metrics.iws, + metrics.miws, ], [True, False], # univariate series [True, False], # single series From 5187630306264ca9ea73a69b98657fd187f1fff0 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Wed, 25 Sep 2024 11:53:33 +0200 Subject: [PATCH 31/78] update tests for quantile instead of alpha --- darts/models/cp/conformal_model.py | 2 +- .../forecasting/test_conformal_model.py | 167 +++++++++++------- .../forecasting/test_historical_forecasts.py | 20 ++- 3 files changed, 114 insertions(+), 75 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index a3c83a3856..9fe51c657f 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -1017,7 +1017,7 @@ def _calibrate_interval( """ # shape (forecast horizon, n components, n quantile intervals) q_hat = np.quantile(residuals, q=self.intervals, axis=2).transpose((1, 2, 0)) - return -q_hat, q_hat + return -q_hat, q_hat[:, :, ::-1] @property def _residuals_metric(self): diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 1c3d44faab..0ca71f29fb 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -18,6 +18,7 @@ from darts.models.forecasting.forecasting_model import ForecastingModel from darts.tests.conftest import TORCH_AVAILABLE, tfm_kwargs from darts.utils import timeseries_generation as tg +from darts.utils.utils import likelihood_component_names, quantile_names IN_LEN = 3 OUT_LEN = 3 @@ -38,11 +39,13 @@ def train_model(*args, model_type="regression", model_params=None, **kwargs): return NLinearModel(**torch_kwargs, **model_params).fit(*args, **kwargs) +q = [0.1, 0.5, 0.9] + # pre-trained global model for conformal models models_cls_kwargs_errs = [ ( ConformalNaiveModel, - {"alpha": 0.8}, + {"quantiles": q}, "regression", ), ] @@ -50,7 +53,7 @@ def train_model(*args, model_type="regression", model_params=None, **kwargs): if TORCH_AVAILABLE: models_cls_kwargs_errs.append(( ConformalNaiveModel, - {"alpha": 0.8}, + {"quantiles": q}, "torch", )) @@ -106,23 +109,23 @@ def test_model_construction(self): model_err_msg = "`model` must be a pre-trained `GlobalForecastingModel`." # un-trained local model with pytest.raises(ValueError) as exc: - ConformalNaiveModel(model=local_model, alpha=0.8) + ConformalNaiveModel(model=local_model, quantiles=q) assert str(exc.value) == model_err_msg # pre-trained local model local_model.fit(series) with pytest.raises(ValueError) as exc: - ConformalNaiveModel(model=local_model, alpha=0.8) + ConformalNaiveModel(model=local_model, quantiles=q) assert str(exc.value) == model_err_msg # un-trained global model with pytest.raises(ValueError) as exc: - ConformalNaiveModel(model=global_model, alpha=0.0) + ConformalNaiveModel(model=global_model, quantiles=q) assert str(exc.value) == model_err_msg # pre-trained local model should work global_model.fit(series) - _ = ConformalNaiveModel(model=global_model, alpha=0.8) + _ = ConformalNaiveModel(model=global_model, quantiles=q) @pytest.mark.parametrize("config", models_cls_kwargs_errs) def test_save_model_parameters(self, config): @@ -165,8 +168,11 @@ def test_single_ts(self, config): pred_fc = model.model.predict(n=self.horizon) assert pred_fc.time_index.equals(pred.time_index) # the center forecasts must be equal to the forecasting model forecast + fc_columns = likelihood_component_names( + self.ts_pass_val.columns, quantile_names([0.5]) + ) np.testing.assert_array_almost_equal( - pred[self.ts_pass_val.columns.tolist()].all_values(), pred_fc.all_values() + pred[fc_columns].all_values(), pred_fc.all_values() ) assert pred.static_covariates is None @@ -202,10 +208,13 @@ def test_multi_ts(self, config): assert not np.isnan(pred.all_values()).any().any() # the center forecasts must be equal to the forecasting model forecast + fc_columns = likelihood_component_names( + self.ts_pass_val.columns, quantile_names([0.5]) + ) pred_fc = model.model.predict(n=self.horizon, series=self.ts_pass_train) assert pred_fc.time_index.equals(pred.time_index) np.testing.assert_array_almost_equal( - pred[self.ts_pass_val.columns.tolist()].all_values(), pred_fc.all_values() + pred[fc_columns].all_values(), pred_fc.all_values() ) # using a calibration series also requires an input series @@ -238,7 +247,7 @@ def test_multi_ts(self, config): assert not np.isnan(pred.all_values()).any().any() np.testing.assert_array_almost_equal( pred_fc.all_values(), - pred[self.ts_pass_val.columns.tolist()].all_values(), + pred[fc_columns].all_values(), ) # using a calibration series requires to have same number of series as target @@ -310,7 +319,7 @@ def test_multi_ts(self, config): @pytest.mark.parametrize( "config", itertools.product( - [(ConformalNaiveModel, {"alpha": 0.8}, "regression")], + [(ConformalNaiveModel, {"quantiles": [0.1, 0.5, 0.9]}, "regression")], [ {"lags_past_covariates": IN_LEN}, {"lags_future_covariates": (IN_LEN, OUT_LEN)}, @@ -408,8 +417,11 @@ def test_covariates(self, config): series=self.ts_pass_train, **cov_kwargs_notrain, ) + fc_columns = likelihood_component_names( + self.ts_pass_val.columns, quantile_names([0.5]) + ) np.testing.assert_array_almost_equal( - pred[self.ts_pass_val.columns.tolist()].all_values(), + pred[fc_columns].all_values(), pred_fc.all_values(), ) @@ -530,7 +542,7 @@ def test_predict(self, config): lags=IN_LEN, output_chunk_length=OUT_LEN, **model_kwargs ) model_instance.fit(series=series, past_covariates=pc, future_covariates=fc) - model = ConformalNaiveModel(model_instance, alpha=0.8) + model = ConformalNaiveModel(model_instance, quantiles=q) preds = model.predict( n=horizon, series=series, past_covariates=pc, future_covariates=fc @@ -541,9 +553,7 @@ def test_predict(self, config): preds = [preds] for s_, preds_ in zip(series, preds): - cols_expected = [] - for col in s_.columns: - cols_expected += [f"{col}{q}" for q in ["_cq_lo", "", "_cq_hi"]] + cols_expected = likelihood_component_names(s_.columns, quantile_names(q)) assert preds_.columns.tolist() == cols_expected assert len(preds_) == horizon assert preds_.start_time() == s_.end_time() + s_.freq @@ -552,15 +562,19 @@ def test_predict(self, config): def test_output_chunk_shift(self): model_params = {"output_chunk_shift": 1} model = ConformalNaiveModel( - train_model(self.ts_pass_train, model_params=model_params), alpha=0.8 + train_model(self.ts_pass_train, model_params=model_params), quantiles=q ) pred = model.predict(n=1) pred_fc = model.model.predict(n=1) assert pred_fc.time_index.equals(pred.time_index) # the center forecasts must be equal to the forecasting model forecast + fc_columns = likelihood_component_names( + self.ts_pass_train.columns, quantile_names([0.5]) + ) + np.testing.assert_array_almost_equal( - pred[self.ts_pass_train.columns.tolist()].all_values(), pred_fc.all_values() + pred[fc_columns].all_values(), pred_fc.all_values() ) pred_cal = model.predict(n=1, cal_series=self.ts_pass_train) @@ -574,25 +588,25 @@ def test_output_chunk_shift(self): [1, 3, 5], # horizon [True, False], # univariate series [True, False], # single series + [q, [0.2, 0.3, 0.5, 0.7, 0.8]], ), ) def test_naive_conformal_model_predict(self, config): """Verifies that naive conformal model computes the correct intervals The naive approach computes it as follows: - - pred_upper = pred + q_alpha(absolute error, past) + - pred_upper = pred + q_interval(absolute error, past) - pred_middle = pred - - pred_lower = pred - q_alpha(absolute error, past) + - pred_lower = pred - q_interval(absolute error, past) - Where q_alpha(absolute error) is the `alpha` quantile of all historic absolute errors between - `pred`, and the target series. + Where q_interval(absolute error) is the `q_hi - q_hi` quantile value of all historic absolute errors + between `pred`, and the target series. """ - n, is_univar, is_single = config - alpha = 0.8 + n, is_univar, is_single, quantiles = config series = self.helper_prepare_series(is_univar, is_single) model_fc = train_model(series) pred_fc_list = model_fc.predict(n, series=series) - model = ConformalNaiveModel(model=model_fc, alpha=alpha) + model = ConformalNaiveModel(model=model_fc, quantiles=quantiles) pred_cal_list = model.predict(n, series=series) pred_cal_list_with_cal = model.predict(n, series=series, cal_series=series) @@ -620,7 +634,7 @@ def test_naive_conformal_model_predict(self, config): pred_vals = pred_fc.all_values() pred_vals_expected = self.helper_compute_naive_pred_cal( - residuals, pred_vals, n, alpha + residuals, pred_vals, n, quantiles ) np.testing.assert_array_almost_equal( pred_cal.all_values(), pred_vals_expected @@ -636,6 +650,7 @@ def test_naive_conformal_model_predict(self, config): [0, 1], # output chunk shift [None, 1], # train length [False, True], # use covariates + [q, [0.2, 0.3, 0.5, 0.7, 0.8]], # quantiles ), ) def test_naive_conformal_model_historical_forecasts(self, config): @@ -647,12 +662,13 @@ def test_naive_conformal_model_historical_forecasts(self, config): - with and without training length - with and without covariates in the forecast and calibration sets. """ - n, is_univar, is_single, ocs, train_length, use_covs = config + n, is_univar, is_single, ocs, train_length, use_covs, quantiles = config + n_q = len(quantiles) + half_idx = n_q // 2 if ocs and n > OUT_LEN: # auto-regression not allowed with ocs return - alpha = 0.8 series = self.helper_prepare_series(is_univar, is_single) model_params = {"output_chunk_shift": ocs} @@ -709,7 +725,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): ) # conformal forecasts - model = ConformalNaiveModel(model=model_fc, alpha=alpha) + model = ConformalNaiveModel(model=model_fc, quantiles=quantiles) # without calibration set hfc_conf_list = model.historical_forecasts( series=series, @@ -755,7 +771,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): pred_vals = pred_fc.all_values() pred_vals_expected = self.helper_compute_naive_pred_cal( - residuals, pred_vals, n, alpha, train_length=train_length + residuals, pred_vals, n, quantiles, train_length=train_length ) np.testing.assert_array_almost_equal( pred_cal.all_values(), pred_vals_expected @@ -769,14 +785,11 @@ def test_naive_conformal_model_historical_forecasts(self, config): hfc_0_vals = hfc_conf_with_cal[0].all_values() for hfc_i in hfc_conf_with_cal[1:]: hfc_i_vals = hfc_i.all_values() - np.testing.assert_array_almost_equal( - hfc_0_vals[:, 1::3] - hfc_0_vals[:, 0::3], - hfc_i_vals[:, 1::3] - hfc_i_vals[:, 0::3], - ) - np.testing.assert_array_almost_equal( - hfc_0_vals[:, 2::3] - hfc_0_vals[:, 1::3], - hfc_i_vals[:, 2::3] - hfc_i_vals[:, 1::3], - ) + for q_idx in range(n_q): + np.testing.assert_array_almost_equal( + hfc_0_vals[:, half_idx::n_q] - hfc_0_vals[:, q_idx::n_q], + hfc_i_vals[:, half_idx::n_q] - hfc_i_vals[:, q_idx::n_q], + ) if use_covs: # `cal_covs_kwargs_exact` will not compute the last example in overlap_end (this one has anyways no @@ -862,35 +875,59 @@ def helper_prepare_series(self, is_univar, is_single): @staticmethod def helper_compute_naive_pred_cal( - residuals, pred_vals, n, alpha, train_length=None + residuals, pred_vals, n, quantiles, train_length=None ): train_length = train_length or 0 - q_hats = [] - # compute the quantile `alpha` of all past residuals (absolute "per time step" errors between historical - # forecasts and the target series) - for idx in range(n): - res_end = residuals.shape[2] - idx - if train_length: - res_start = res_end - train_length - else: - res_start = n - (idx + 1) - res_n = residuals[idx][:, res_start:res_end] - q_hat_n = np.quantile(res_n, q=alpha, axis=1) - q_hats.append(q_hat_n) - q_hats = np.expand_dims(np.array(q_hats), -1) - # the prediciton interval is given by pred +/- q_hat n_comps = pred_vals.shape[1] - pred_vals_expected = [] - for col_idx in range(n_comps): - q_col = q_hats[:, col_idx] - pred_col = pred_vals[:, col_idx] - pred_col_expected = np.concatenate( - [pred_col - q_col, pred_col, pred_col + q_col], axis=1 - ) - pred_col_expected = np.expand_dims(pred_col_expected, -1) - pred_vals_expected.append(pred_col_expected) - pred_vals_expected = np.concatenate(pred_vals_expected, axis=1) - return pred_vals_expected + half_idx = len(quantiles) // 2 + alphas = np.array(quantiles[half_idx + 1 :][::-1]) - np.array( + quantiles[:half_idx] + ) + pred_expected = [] + for alpha_idx, alpha in enumerate(alphas): + q_hats = [] + # compute the quantile `alpha` of all past residuals (absolute "per time step" errors between historical + # forecasts and the target series) + for idx in range(n): + res_end = residuals.shape[2] - idx + if train_length: + res_start = res_end - train_length + else: + res_start = n - (idx + 1) + res_n = residuals[idx][:, res_start:res_end] + q_hat_n = np.quantile(res_n, q=alpha, axis=1) + q_hats.append(q_hat_n) + q_hats = np.expand_dims(np.array(q_hats), -1) + # the prediciton interval is given by pred +/- q_hat + pred_vals_expected = [] + for col_idx in range(n_comps): + q_col = q_hats[:, col_idx] + pred_col = pred_vals[:, col_idx] + pred_col_expected = np.concatenate( + [pred_col - q_col, pred_col, pred_col + q_col], axis=1 + ) + pred_col_expected = np.expand_dims(pred_col_expected, 1) + pred_vals_expected.append(pred_col_expected) + pred_vals_expected = np.concatenate(pred_vals_expected, axis=1) + pred_expected.append(pred_vals_expected) + + # reorder to have columns going from lowest quantiles to highest per component + pred_expected_reshaped = [] + for comp_idx in range(n_comps): + for q_idx in [0, 1, 2]: + for pred_idx in range(len(pred_expected)): + # upper quantiles will have reversed order + if q_idx == 2: + pred_idx = len(pred_expected) - 1 - pred_idx + pred_ = pred_expected[pred_idx][:, comp_idx, q_idx] + pred_ = pred_.reshape(-1, 1, 1) + + # q_hat_idx = q_idx + comp_idx * 3 + alpha_idx * 3 * n_comps + pred_expected_reshaped.append(pred_) + # only add median quantile once + if q_idx == 1: + break + return np.concatenate(pred_expected_reshaped, axis=1) @pytest.mark.parametrize( "config", @@ -936,7 +973,7 @@ def test_too_short_input_predict(self, config): model_params=model_params, **covs_kwargs_train, ), - alpha=0.8, + quantiles=q, ) # prediction works with long enough input @@ -1075,7 +1112,7 @@ def test_too_short_input_hfc(self, config): model_params=model_params, **covs_kwargs_train, ), - alpha=0.8, + quantiles=q, ) hfc_kwargs = { diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index 26dab41cf0..bf502db531 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -22,6 +22,7 @@ ) from darts.tests.conftest import TORCH_AVAILABLE, tfm_kwargs from darts.utils import timeseries_generation as tg +from darts.utils.utils import likelihood_component_names, quantile_names if TORCH_AVAILABLE: import torch @@ -2633,6 +2634,7 @@ def test_conformal_historical_forecasts(self, config): use_multi_series, ocs, ) = config + q = [0.1, 0.5, 0.9] # compute minimum series length to generate n forecasts icl = 3 ocl = 5 @@ -2644,7 +2646,6 @@ def test_conformal_historical_forecasts(self, config): self.ts_pass_train[:10], self.ts_pass_val[: min_len_val_series + n_forecasts - 1], ) - if use_int_idx: series_train = TimeSeries.from_values( series_train.all_values(), columns=series_train.columns @@ -2701,7 +2702,7 @@ def test_conformal_historical_forecasts(self, config): fc = [fc, fc.shift(1)] if fc is not None else None # conformal model - model = ConformalNaiveModel(forecasting_model, alpha=0.8) + model = ConformalNaiveModel(forecasting_model, quantiles=q) # cannot perform auto regression with output chunk shift if ocs and horizon > ocl: @@ -2803,9 +2804,9 @@ def test_conformal_historical_forecasts(self, config): first_ts_expected = hfc[0].start_time() last_ts_expected = hfc[-1].end_time() - cols_excpected = [] - for col in series.columns: - cols_excpected += [f"{col}_cq_lo", f"{col}", f"{col}_cq_hi"] + cols_excpected = likelihood_component_names( + series.columns, quantile_names(q) + ) # check length match between optimized and default hist fc assert len(hfc) == n_pred_series_expected # check hist fc start @@ -2840,6 +2841,7 @@ def test_conformal_historical_start_train_length(self, config): use_multi_series, ocs, ) = config + q = [0.1, 0.5, 0.9] # compute minimum series length to generate n forecasts icl = 3 ocl = 5 @@ -2906,7 +2908,7 @@ def test_conformal_historical_start_train_length(self, config): forecast_horizon=horizon, ) # compute conformal historical forecasts (skips some of the first forecasts to get minimum required cal set) - model = ConformalNaiveModel(forecasting_model, alpha=0.8) + model = ConformalNaiveModel(forecasting_model, quantiles=q) hist_fct = model.historical_forecasts( series=series_val, retrain=False, @@ -2977,9 +2979,9 @@ def test_conformal_historical_start_train_length(self, config): ) last_ts_expected = series.end_time() - cols_excpected = [] - for col in series.columns: - cols_excpected += [f"{col}_cq_lo", f"{col}", f"{col}_cq_hi"] + cols_excpected = likelihood_component_names( + series.columns, quantile_names(q) + ) # check historical forecasts dimensions assert len(hfc) == n_pred_series_expected # check hist fc start From fb6cfd2657d5b5c06c9d001dd36f2d4eaf91e7ec Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 26 Sep 2024 13:49:33 +0200 Subject: [PATCH 32/78] add coverage metric and improve residuals and backtest --- darts/metrics/__init__.py | 52 +++++ darts/metrics/metrics.py | 209 +++++++++++++++++- darts/models/cp/conformal_model.py | 167 +++++++++++++- .../forecasting/test_conformal_model.py | 78 ++++++- 4 files changed, 493 insertions(+), 13 deletions(-) diff --git a/darts/metrics/__init__.py b/darts/metrics/__init__.py index 7a64485168..85bb33f875 100644 --- a/darts/metrics/__init__.py +++ b/darts/metrics/__init__.py @@ -72,6 +72,7 @@ coefficient_of_variation, dtw_metric, err, + ic, iw, iws, mae, @@ -79,6 +80,7 @@ marre, mase, merr, + mic, miw, miws, mql, @@ -98,6 +100,42 @@ sse, ) +ALL_METRICS = { + ae, + ape, + arre, + ase, + coefficient_of_variation, + dtw_metric, + err, + iw, + iws, + mae, + mape, + marre, + mase, + merr, + miw, + miws, + mql, + mse, + msse, + ope, + ql, + qr, + r2_score, + rmse, + rmsle, + rmsse, + sape, + se, + sle, + smape, + sse, + ic, + mic, +} + TIME_DEPENDENT_METRICS = { ae, ape, @@ -111,8 +149,20 @@ sse, iw, iws, + ic, +} + +Q_INTERVAL_METRICS = { + iw, + iws, + miw, + miws, + ic, + mic, } +NON_Q_METRICS = {dtw_metric} + __all__ = [ "ae", "ape", @@ -145,4 +195,6 @@ "miw", "iws", "miws", + "ic", + "mic", ] diff --git a/darts/metrics/metrics.py b/darts/metrics/metrics.py index 6de57caf3e..9a3cb1b6e6 100644 --- a/darts/metrics/metrics.py +++ b/darts/metrics/metrics.py @@ -3534,7 +3534,7 @@ def iws( (U_t - L_t) & \\text{if } L_t \\leq y_t \\leq U_t \\\\ (U_t - L_t) + \\frac{1}{1 - q_h} (y_t - U_t) & \\text{if } y_t > U_t \\end{cases} - \\end{equation}, + \\end{equation} where :math:`U_t` are the predicted upper bound quantile values :math:`\\hat{y}_{q_h,t}` (of all predicted quantiles or samples) at time :math:`t`, and :math:`L_t` are the predicted lower bound quantile values @@ -3727,3 +3727,210 @@ def miws( ), axis=TIME_AX, ) + + +@interval_support +@multi_ts_support +@multivariate_support +def ic( + actual_series: Union[TimeSeries, Sequence[TimeSeries]], + pred_series: Union[TimeSeries, Sequence[TimeSeries]], + intersect: bool = True, + *, + q_interval: Union[Tuple[float, float], Sequence[Tuple[float, float]]] = None, + q: Optional[Union[float, List[float], Tuple[np.ndarray, pd.Index]]] = None, + time_reduction: Optional[Callable[..., np.ndarray]] = None, + component_reduction: Optional[Callable[[np.ndarray], float]] = np.nanmean, + series_reduction: Optional[Callable[[np.ndarray], Union[float, np.ndarray]]] = None, + n_jobs: int = 1, + verbose: bool = False, +) -> METRIC_OUTPUT_TYPE: + """Interval Coverage (IC). + + IC gives a binary outcome with `1` if the observation is within the interval, and `0` otherwise. + + For the true series :math:`y` and predicted stochastic or quantile series :math:`\\hat{y}` of length :math:`T`, + it is computed per component/column, quantile interval :math:`(q_l,q_h)`, and time step :math:`t` as: + + .. math:: + \\begin{equation} + \\begin{cases} + 1 & \\text{if } L_t < y_t < U_t \\\\ + 0 & \\text{otherwise} + \\end{cases} + \\end{equation} + + where :math:`U_t` are the predicted upper bound quantile values :math:`\\hat{y}_{q_h,t}` (of all predicted + quantiles or samples) at time :math:`t`, and :math:`L_t` are the predicted lower bound quantile values + :math:`\\hat{y}_{q_l,t}`. + + Parameters + ---------- + actual_series + The (sequence of) actual series. + pred_series + The (sequence of) predicted series. + intersect + For time series that are overlapping in time without having the same time index, setting `True` + will consider the values only over their common time interval (intersection in time). + q_interval + The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence tuples + (multiple intervals) with elements (low quantile, high quantile). + q + Quantiles `q` not supported by this metric; use `q_interval` instead. + component_reduction + Optionally, a function to aggregate the metrics over the component/column axis. It must reduce a `np.ndarray` + of shape `(t, c)` to a `np.ndarray` of shape `(t,)`. The function takes as input a ``np.ndarray`` and a + parameter named `axis`, and returns the reduced array. The `axis` receives value `1` corresponding to the + component axis. If `None`, will return a metric per component. + time_reduction + Optionally, a function to aggregate the metrics over the time axis. It must reduce a `np.ndarray` + of shape `(t, c)` to a `np.ndarray` of shape `(c,)`. The function takes as input a ``np.ndarray`` and a + parameter named `axis`, and returns the reduced array. The `axis` receives value `0` corresponding to the + time axis. If `None`, will return a metric per time step. + series_reduction + Optionally, a function to aggregate the metrics over multiple series. It must reduce a `np.ndarray` + of shape `(s, t, c)` to a `np.ndarray` of shape `(t, c)` The function takes as input a ``np.ndarray`` and a + parameter named `axis`, and returns the reduced array. The `axis` receives value `0` corresponding to the + series axis. For example with `np.nanmean`, will return the average over all series metrics. If `None`, will + return a metric per component. + n_jobs + The number of jobs to run in parallel. Parallel jobs are created only when a ``Sequence[TimeSeries]`` is + passed as input, parallelising operations regarding different ``TimeSeries``. Defaults to `1` + (sequential). Setting the parameter to `-1` means using all the available processors. + verbose + Optionally, whether to print operations progress + + Returns + ------- + float + A single metric score for (with `len(q_interval) <= 1`): + + - single univariate series. + - single multivariate series with `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and + `time_reduction`. + np.ndarray + A numpy array of metric scores. The array has shape (n time steps, n components * n q intervals) without time + and component reductions, and shape (n time steps, n q intervals) without time but component reduction and + `len(q_interval) > 1`. For: + + - the input from the `float` return case above but with `len(q_interval) > 1`. + - single multivariate series and at least `component_reduction=None`. + - single uni/multivariate series and at least `time_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and at least one of + `component_reduction=None` or `time_reduction=None`. + List[float] + Same as for type `float` but for a sequence of series. + List[np.ndarray] + Same as for type `np.ndarray` but for a sequence of series. + + References + ---------- + .. [1] https://otexts.com/fpp3/distaccuracy.html + """ + y_true, y_pred = _get_values_or_raise( + actual_series, + pred_series, + intersect, + remove_nan_union=True, + q=q, + ) + y_pred_lo, y_pred_hi = _get_quantile_intervals(y_pred, q=q, q_interval=q_interval) + return np.where((y_pred_lo <= y_true) & (y_true <= y_pred_hi), 1.0, 0.0) + + +@interval_support +@multi_ts_support +@multivariate_support +def mic( + actual_series: Union[TimeSeries, Sequence[TimeSeries]], + pred_series: Union[TimeSeries, Sequence[TimeSeries]], + intersect: bool = True, + *, + q_interval: Union[Tuple[float, float], Sequence[Tuple[float, float]]] = None, + q: Optional[Union[float, List[float], Tuple[np.ndarray, pd.Index]]] = None, + component_reduction: Optional[Callable[[np.ndarray], float]] = np.nanmean, + series_reduction: Optional[Callable[[np.ndarray], Union[float, np.ndarray]]] = None, + n_jobs: int = 1, + verbose: bool = False, +) -> METRIC_OUTPUT_TYPE: + """Mean Interval Coverage (MIC). + + MIC gives the time-aggregated Interval Coverage :func:`~darts.metrics.metrics.ic` - the ratio of observations + being within the interval. + + For the true series :math:`y` and predicted stochastic or quantile series :math:`\\hat{y}` of length :math:`T`, + it is computed per component/column, quantile interval :math:`(q_l,q_h)`, and time step :math:`t` as: + + .. math:: \\frac{1}{T}\\sum_{t=1}^T{C(y_t, \\hat{y}_{t}, q_h, q_l)}, + + where :math:`C` is the Interval Coverage :func:`~darts.metrics.metrics.ic`. + + Parameters + ---------- + actual_series + The (sequence of) actual series. + pred_series + The (sequence of) predicted series. + intersect + For time series that are overlapping in time without having the same time index, setting `True` + will consider the values only over their common time interval (intersection in time). + q_interval + The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence tuples + (multiple intervals) with elements (low quantile, high quantile). + q + Quantiles `q` not supported by this metric; use `q_interval` instead. + component_reduction + Optionally, a function to aggregate the metrics over the component/column axis. It must reduce a `np.ndarray` + of shape `(t, c)` to a `np.ndarray` of shape `(t,)`. The function takes as input a ``np.ndarray`` and a + parameter named `axis`, and returns the reduced array. The `axis` receives value `1` corresponding to the + component axis. If `None`, will return a metric per component. + series_reduction + Optionally, a function to aggregate the metrics over multiple series. It must reduce a `np.ndarray` + of shape `(s, t, c)` to a `np.ndarray` of shape `(t, c)` The function takes as input a ``np.ndarray`` and a + parameter named `axis`, and returns the reduced array. The `axis` receives value `0` corresponding to the + series axis. For example with `np.nanmean`, will return the average over all series metrics. If `None`, will + return a metric per component. + n_jobs + The number of jobs to run in parallel. Parallel jobs are created only when a ``Sequence[TimeSeries]`` is + passed as input, parallelising operations regarding different ``TimeSeries``. Defaults to `1` + (sequential). Setting the parameter to `-1` means using all the available processors. + verbose + Optionally, whether to print operations progress + + Returns + ------- + float + A single metric score for (with `len(q_interval) <= 1`): + + - single univariate series. + - single multivariate series with `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + np.ndarray + A numpy array of metric scores. The array has shape (n components * n q intervals,) without component reduction, + and shape (n q intervals,) with component reduction and `len(q_interval) > 1`. + For: + + - the input from the `float` return case above but with `len(q_interval) > 1`. + - single multivariate series and at least `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + List[float] + Same as for type `float` but for a sequence of series. + List[np.ndarray] + Same as for type `np.ndarray` but for a sequence of series. + + References + ---------- + .. [1] https://otexts.com/fpp3/distaccuracy.html + """ + return np.nanmean( + _get_wrapped_metric(ic, n_wrappers=3)( + actual_series, + pred_series, + intersect, + q=q, + q_interval=q_interval, + ), + axis=TIME_AX, + ) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 9fe51c657f..1867d13887 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -11,9 +11,9 @@ import numpy as np import pandas as pd -import darts.metrics -from darts import TimeSeries +from darts import TimeSeries, metrics from darts.logging import get_logger, raise_log +from darts.metrics.metrics import METRIC_TYPE from darts.models.forecasting.forecasting_model import GlobalForecastingModel from darts.utils import _with_sanity_checks from darts.utils.historical_forecasts.utils import _historical_forecasts_start_warnings @@ -67,19 +67,16 @@ def __init__( self, model: GlobalForecastingModel, quantiles: List[float], - # alpha: Union[float, Tuple[float, float]], ): - """Base Conformal Prediction Model + """Base Conformal Prediction Model. Parameters ---------- model - The forecasting model. - alpha - Significance level of the prediction interval, float if coverage error spread arbitrarily over left and - right tails, tuple of two floats for different coverage error over left and right tails respectively + A pre-trained forecasting model. quantiles - Optionally, a list of quantiles from the quantile regression `model` to use. + Optionally, a list of quantiles centered around the median `q=0.5` to use. For example quantiles + [0.1, 0.5, 0.9] correspond to a (0.9 - 0.1) = 80% coverage interval around the median (model forecast). """ if not isinstance(model, GlobalForecastingModel) or not model._fit_called: raise_log( @@ -92,7 +89,13 @@ def __init__( self.model = model self.quantiles = quantiles + half_idx = len(quantiles) // 2 + self._q_intervals = [ + (q_l, q_h) + for q_l, q_h in zip(quantiles[:half_idx], quantiles[half_idx + 1 :][::-1]) + ] self._quantiles_no_med = [q for q in quantiles if q != 0.5] + self._likelihood = "quantile" # if isinstance(alpha, float): # self.symmetrical = True @@ -384,6 +387,136 @@ def historical_forecasts( else calibrated_forecasts ) + def backtest( + self, + series: Union[TimeSeries, Sequence[TimeSeries]], + past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + historical_forecasts: Optional[ + Union[TimeSeries, Sequence[TimeSeries], Sequence[Sequence[TimeSeries]]] + ] = None, + num_samples: int = 1, + train_length: Optional[int] = None, + start: Optional[Union[pd.Timestamp, float, int]] = None, + start_format: Literal["position", "value"] = "value", + forecast_horizon: int = 1, + stride: int = 1, + retrain: Union[bool, int, Callable[..., bool]] = True, + overlap_end: bool = False, + last_points_only: bool = False, + metric: Union[METRIC_TYPE, List[METRIC_TYPE]] = metrics.miw, + reduction: Union[Callable[..., float], None] = np.mean, + verbose: bool = False, + show_warnings: bool = True, + predict_likelihood_parameters: bool = False, + enable_optimization: bool = True, + metric_kwargs: Optional[Union[Dict[str, Any], List[Dict[str, Any]]]] = None, + fit_kwargs: Optional[Dict[str, Any]] = None, + predict_kwargs: Optional[Dict[str, Any]] = None, + sample_weight: Optional[Union[TimeSeries, Sequence[TimeSeries], str]] = None, + ) -> Union[float, np.ndarray, List[float], List[np.ndarray]]: + # make user's life easier by adding quantile intervals, or quantiles directly + if metric_kwargs is None: + metric = [metric] if not isinstance(metric, list) else metric + metric_kwargs = [] + for metric_ in metric: + if metric_ in metrics.ALL_METRICS: + if metric_ in metrics.Q_INTERVAL_METRICS: + metric_kwargs.append({"q_interval": self._q_intervals}) + elif metric_ not in metrics.NON_Q_METRICS: + metric_kwargs.append({"q": self.quantiles}) + else: + metric_kwargs.append({}) + else: + metric_kwargs.append({}) + return super().backtest( + series=series, + past_covariates=past_covariates, + future_covariates=future_covariates, + historical_forecasts=historical_forecasts, + num_samples=num_samples, + train_length=train_length, + start=start, + start_format=start_format, + forecast_horizon=forecast_horizon, + stride=stride, + retrain=retrain, + overlap_end=overlap_end, + last_points_only=last_points_only, + metric=metric, + reduction=reduction, + verbose=verbose, + show_warnings=show_warnings, + predict_likelihood_parameters=predict_likelihood_parameters, + enable_optimization=enable_optimization, + metric_kwargs=metric_kwargs, + fit_kwargs=fit_kwargs, + predict_kwargs=predict_kwargs, + sample_weight=sample_weight, + ) + + def residuals( + self, + series: Union[TimeSeries, Sequence[TimeSeries]], + past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + historical_forecasts: Optional[ + Union[TimeSeries, Sequence[TimeSeries], Sequence[Sequence[TimeSeries]]] + ] = None, + num_samples: int = 1, + train_length: Optional[int] = None, + start: Optional[Union[pd.Timestamp, float, int]] = None, + start_format: Literal["position", "value"] = "value", + forecast_horizon: int = 1, + stride: int = 1, + retrain: Union[bool, int, Callable[..., bool]] = True, + overlap_end: bool = False, + last_points_only: bool = True, + metric: METRIC_TYPE = metrics.iw, + verbose: bool = False, + show_warnings: bool = True, + predict_likelihood_parameters: bool = False, + enable_optimization: bool = True, + metric_kwargs: Optional[Dict[str, Any]] = None, + fit_kwargs: Optional[Dict[str, Any]] = None, + predict_kwargs: Optional[Dict[str, Any]] = None, + values_only: bool = False, + sample_weight: Optional[Union[TimeSeries, Sequence[TimeSeries], str]] = None, + ) -> Union[TimeSeries, List[TimeSeries], List[List[TimeSeries]]]: + # make user's life easier by adding quantile intervals, or quantiles directly + if metric_kwargs is None and metric in metrics.ALL_METRICS: + if metric in metrics.Q_INTERVAL_METRICS: + metric_kwargs = {"q_interval": self._q_intervals} + elif metric not in metrics.NON_Q_METRICS: + metric_kwargs = {"q": self.quantiles} + else: + metric_kwargs = {} + return super().residuals( + series=series, + past_covariates=past_covariates, + future_covariates=future_covariates, + historical_forecasts=historical_forecasts, + num_samples=num_samples, + train_length=train_length, + start=start, + start_format=start_format, + forecast_horizon=forecast_horizon, + stride=stride, + retrain=retrain, + overlap_end=overlap_end, + last_points_only=last_points_only, + metric=metric, + verbose=verbose, + show_warnings=show_warnings, + predict_likelihood_parameters=predict_likelihood_parameters, + enable_optimization=enable_optimization, + metric_kwargs=metric_kwargs, + fit_kwargs=fit_kwargs, + predict_kwargs=predict_kwargs, + values_only=values_only, + sample_weight=sample_weight, + ) + def _calibrate_forecasts( self, series: Sequence[TimeSeries], @@ -897,6 +1030,10 @@ def considers_static_covariates(self) -> bool: """ return self.model.considers_static_covariates + @property + def likelihood(self) -> str: + return self._likelihood + def uncertainty_evaluate(df_forecast: pd.DataFrame) -> pd.DataFrame: """Evaluate conformal prediction on test dataframe. @@ -996,6 +1133,16 @@ def __init__( model: GlobalForecastingModel, quantiles: List[float], ): + """Naive Conformal Prediction Model. + + Parameters + ---------- + model + A pre-trained forecasting model. + quantiles + Optionally, a list of quantiles centered around the median `q=0.5` to use. For example quantiles + [0.1, 0.5, 0.9] correspond to a (0.9 - 0.1) = 80% coverage interval around the median (model forecast). + """ super().__init__(model=model, quantiles=quantiles) half_idx = int(len(self.quantiles) / 2) self.intervals = [ @@ -1021,4 +1168,4 @@ def _calibrate_interval( @property def _residuals_metric(self): - return darts.metrics.ae + return metrics.ae diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 0ca71f29fb..97803cdf92 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -8,7 +8,7 @@ from darts import TimeSeries, concatenate from darts.datasets import AirPassengersDataset -from darts.metrics import ae +from darts.metrics import ae, ic, mic from darts.models import ( ConformalNaiveModel, LinearRegressionModel, @@ -18,7 +18,11 @@ from darts.models.forecasting.forecasting_model import ForecastingModel from darts.tests.conftest import TORCH_AVAILABLE, tfm_kwargs from darts.utils import timeseries_generation as tg -from darts.utils.utils import likelihood_component_names, quantile_names +from darts.utils.utils import ( + likelihood_component_names, + quantile_interval_names, + quantile_names, +) IN_LEN = 3 OUT_LEN = 3 @@ -1175,3 +1179,73 @@ def test_too_short_input_hfc(self, config): assert str(exc.value).startswith( "Cannot build a single input for prediction with the provided model" ) + + @pytest.mark.parametrize("quantiles", [[0.1, 0.5, 0.9], [0.1, 0.3, 0.5, 0.7, 0.9]]) + def test_backtest_and_residuals(self, quantiles): + """Residuals and backtest are already tested for quantile, and interval metrics based on stochastic or quantile + forecasts. So, a simple check that they give expected results should be enough. + """ + n_q = len(quantiles) + half_idx = n_q // 2 + q_interval = [ + (q_lo, q_hi) + for q_lo, q_hi in zip(quantiles[:half_idx], quantiles[half_idx + 1 :][::-1]) + ] + lpo = False + + # series long enough for 2 hfcs + series = self.helper_prepare_series(True, True).append_values([0.1]) + # conformal model + model = ConformalNaiveModel(model=train_model(series), quantiles=quantiles) + + hfc = model.historical_forecasts( + series=series, forecast_horizon=5, last_points_only=lpo + ) + bt = model.backtest( + series=series, historical_forecasts=hfc, last_points_only=lpo, metric=mic + ) + # default backtest is equal to backtest with metric kwargs + np.testing.assert_array_almost_equal( + bt, + model.backtest( + series=series, + historical_forecasts=hfc, + last_points_only=lpo, + metric=mic, + metric_kwargs={"q_interval": q_interval}, + ), + ) + np.testing.assert_array_almost_equal( + mic( + [series] * len(hfc), + hfc, + q_interval=q_interval, + series_reduction=np.mean, + ), + bt, + ) + + residuals = model.residuals( + series=series, historical_forecasts=hfc, last_points_only=lpo, metric=ic + ) + # default residuals is equal to residuals with metric kwargs + assert residuals == model.residuals( + series=series, + historical_forecasts=hfc, + last_points_only=lpo, + metric=ic, + metric_kwargs={"q_interval": q_interval}, + ) + expected_vals = ic([series] * len(hfc), hfc, q_interval=q_interval) + expected_residuals = [] + for vals, hfc_ in zip(expected_vals, hfc): + expected_residuals.append( + TimeSeries.from_times_and_values( + times=hfc_.time_index, + values=vals, + columns=likelihood_component_names( + series.components, quantile_interval_names(q_interval) + ), + ) + ) + assert residuals == expected_residuals From 880addba9fffd50b0222b48620c14124de0ae895 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 26 Sep 2024 15:27:29 +0200 Subject: [PATCH 33/78] add save load as in ensemble mode --- darts/models/cp/conformal_model.py | 70 ++++++++++++++++--- darts/models/forecasting/ensemble_model.py | 9 --- .../forecasting/test_conformal_model.py | 45 ++++++++++-- 3 files changed, 101 insertions(+), 23 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 1867d13887..5671a48de3 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -15,6 +15,7 @@ from darts.logging import get_logger, raise_log from darts.metrics.metrics import METRIC_TYPE from darts.models.forecasting.forecasting_model import GlobalForecastingModel +from darts.models.utils import TORCH_AVAILABLE from darts.utils import _with_sanity_checks from darts.utils.historical_forecasts.utils import _historical_forecasts_start_warnings from darts.utils.timeseries_generation import _build_forecast_series @@ -32,6 +33,11 @@ quantile_names, ) +if TORCH_AVAILABLE: + from darts.models.forecasting.torch_forecasting_model import TorchForecastingModel +else: + TorchForecastingModel = None + logger = get_logger(__name__) @@ -803,16 +809,60 @@ def conformal_predict(idx_, pred_vals_): def save( self, path: Optional[Union[str, os.PathLike, BinaryIO]] = None, **pkl_kwargs ) -> None: - # TODO: Use new save/load logic from EnsembleModel - model_name = self.__class__.__name__ - raise_log( - NotImplementedError( - f"`{model_name}` does not support saving / loading. Instead, " - f"save the underlying forecasting model `{self.model.__class__.__name__}` using its dedicated " - f"save / load functionality, and create a new `{model_name}` with it.", - ), - logger=logger, - ) + """ + Saves the conformal model under a given path or file handle. + + Additionally, two files are stored if `self.model` is a `TorchForecastingModel`. + + Example for saving and loading a :class:`ConformalNaiveModel`: + + .. highlight:: python + .. code-block:: python + + from darts.datasets import AirPassengersDataset + from darts.models import ConformalNaiveModel, LinearRegressionModel + + series = AirPassengersDataset().load() + forecasting_model = LinearRegressionModel(lags=4).fit(series) + + model = ConformalNaiveModel( + model=forecasting_model, + quantiles=[0.1, 0.5, 0.9], + ) + + model.save("my_model.pkl") + model_loaded = ConformalNaiveModel.load("my_model.pkl") + .. + + Parameters + ---------- + path + Path or file handle under which to save the ensemble model at its current state. If no path is specified, + the ensemble model is automatically saved under ``"{ConformalNaiveModel}_{YYYY-mm-dd_HH_MM_SS}.pkl"``. + If the forecasting model is a `TorchForecastingModel`, two files (model object and checkpoint) are saved + under ``"{path}.{ModelClass}.pt"`` and ``"{path}.{ModelClass}.ckpt"``. + pkl_kwargs + Keyword arguments passed to `pickle.dump()` + """ + + if path is None: + # default path + path = self._default_save_path() + ".pkl" + + super().save(path, **pkl_kwargs) + + if TORCH_AVAILABLE and issubclass(type(self.model), TorchForecastingModel): + path_tfm = f"{path}.{type(self.model).__name__}.pt" + self.model.save(path=path_tfm) + + @staticmethod + def load(path: Union[str, os.PathLike, BinaryIO]) -> "ConformalModel": + model: ConformalModel = GlobalForecastingModel.load(path) + + if TORCH_AVAILABLE and issubclass(type(model.model), TorchForecastingModel): + path_tfm = f"{path}.{type(model.model).__name__}.pt" + model.model = TorchForecastingModel.load(path_tfm) + return model @abstractmethod def _calibrate_interval( diff --git a/darts/models/forecasting/ensemble_model.py b/darts/models/forecasting/ensemble_model.py index 7314f26c30..8509f555f7 100644 --- a/darts/models/forecasting/ensemble_model.py +++ b/darts/models/forecasting/ensemble_model.py @@ -436,15 +436,6 @@ def save( @staticmethod def load(path: Union[str, os.PathLike, BinaryIO]) -> "EnsembleModel": - """ - Loads the ensemble model from a given path or file handle. - - Parameters - ---------- - path - Path or file handle from which to load the ensemble model. - """ - model: EnsembleModel = GlobalForecastingModel.load(path) for i, m in enumerate(model.forecasting_models): diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 97803cdf92..5950647eef 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -153,11 +153,48 @@ def test_save_load_model(self, tmpdir_fn, config): model = model_cls( train_model(self.ts_pass_train, model_type=model_type), **kwargs ) + model_prediction = model.predict(5) + + # check if save and load methods work and + # if loaded conformal model creates same forecasts as original ensemble models + cwd = os.getcwd() + os.chdir(tmpdir_fn) + expected_suffixes = [ + ".pkl", + ".pkl.NLinearModel.pt", + ".pkl.NLinearModel.pt.ckpt", + ] - model_path = os.path.join(tmpdir_fn, "model_test.pkl") - with pytest.raises(NotImplementedError) as exc: - model.save(model_path) - assert "does not support saving / loading" in str(exc.value) + # test save + model.save() + model.save(os.path.join(tmpdir_fn, f"{model_cls.__name__}.pkl")) + + assert os.path.exists(tmpdir_fn) + files = os.listdir(tmpdir_fn) + if model_type == "torch": + # 1 from conformal model, 2 from torch, * 2 as `save()` was called twice + assert len(files) == 6 + for f in files: + assert f.startswith(model_cls.__name__) + suffix_counts = { + suffix: sum(1 for p in os.listdir(tmpdir_fn) if p.endswith(suffix)) + for suffix in expected_suffixes + } + assert all(count == 2 for count in suffix_counts.values()) + else: + assert len(files) == 2 + for f in files: + assert f.startswith(model_cls.__name__) and f.endswith(".pkl") + + # test load + pkl_files = [] + for filename in os.listdir(tmpdir_fn): + if filename.endswith(".pkl"): + pkl_files.append(os.path.join(tmpdir_fn, filename)) + for p in pkl_files: + loaded_model = model_cls.load(p) + assert model_prediction == loaded_model.predict(5) + os.chdir(cwd) @pytest.mark.parametrize("config", models_cls_kwargs_errs) def test_single_ts(self, config): From 73bac08e4202e11758715b490fb596f4dcb64abc Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 26 Sep 2024 15:52:36 +0200 Subject: [PATCH 34/78] quantile tests --- .../models/forecasting/test_conformal_model.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 5950647eef..7bcb9310e3 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -131,6 +131,23 @@ def test_model_construction(self): global_model.fit(series) _ = ConformalNaiveModel(model=global_model, quantiles=q) + # non-centered quantiles + with pytest.raises(ValueError) as exc: + ConformalNaiveModel(model=global_model, quantiles=[0.2, 0.5, 0.6]) + assert str(exc.value) == ( + "quantiles lower than `q=0.5` need to share same difference to `0.5` as quantiles higher than `q=0.5`" + ) + + # quantiles missing median + with pytest.raises(ValueError) as exc: + ConformalNaiveModel(model=global_model, quantiles=[0.1, 0.9]) + assert str(exc.value) == "median quantile `q=0.5` must be in `quantiles`" + + # too low and high quantiles + with pytest.raises(ValueError) as exc: + ConformalNaiveModel(model=global_model, quantiles=[-0.1, 0.5, 1.1]) + assert str(exc.value) == "All provided quantiles must be between 0 and 1." + @pytest.mark.parametrize("config", models_cls_kwargs_errs) def test_save_model_parameters(self, config): # model creation parameters were saved before. check if re-created model has same params as original From cc3e02b83ee57b35efbc9a546faea81032af720f Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 26 Sep 2024 17:08:09 +0200 Subject: [PATCH 35/78] remove checks --- darts/models/cp/conformal_model.py | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 5671a48de3..b4bd048b98 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -718,7 +718,6 @@ def _calibrate_forecasts( res_end_idx = -(forecast_horizon - (irr + 1)) res_.append(res[irr : res_end_idx or None, abs(res_end_idx)]) res = np.concatenate(res_, axis=2).T - assert not np.isnan(res).any().any() # get the last forecast index based on the residual examples if cal_series is None: @@ -728,9 +727,6 @@ def _calibrate_forecasts( else: last_fc_idx = len(s_hfcs) - if last_fc_idx > len(s_hfcs): - raise_log(ValueError("blabla"), logger=logger) - q_hat = None if cal_series is not None: if train_length is not None: @@ -756,12 +752,6 @@ def conformal_predict(idx_, pred_vals_): ) cal_res = res[:, :, cal_start:cal_end] - - # TODO: remove checks - len_exp = cal_end - (cal_start or 0) - if cal_res.shape[2] != len_exp: - raise_log(ValueError("Too short cal"), logger=logger) - q_hat_ = self._calibrate_interval(cal_res) else: # with a calibration set, use a constant q_hat From e90431a48e0cf51e76b57be7f6c8a97120acc95d Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 27 Sep 2024 11:15:09 +0200 Subject: [PATCH 36/78] add non conformity scores for cqr --- darts/metrics/__init__.py | 13 ++ darts/metrics/metrics.py | 202 ++++++++++++++++++++++++++++ darts/models/cp/conformal_model.py | 173 ++++++++++-------------- darts/tests/metrics/test_metrics.py | 32 +++++ 4 files changed, 319 insertions(+), 101 deletions(-) diff --git a/darts/metrics/__init__.py b/darts/metrics/__init__.py index 85bb33f875..d8b15c3c2f 100644 --- a/darts/metrics/__init__.py +++ b/darts/metrics/__init__.py @@ -51,6 +51,9 @@ Quantile interval metrics: - :func:`MIW `: Mean Interval Width - :func:`MWS `: Mean Interval Winkler Score + - :func:`MIC `: Mean Interval Coverage + - :func:`MINCS_QR `: Mean Interval Non-Conformity Score for Quantile Regression + - Per time step: Quantile metrics: - :func:`QL `: Quantile Loss @@ -58,6 +61,8 @@ Quantile interval metrics: - :func:`IW `: Interval Width - :func:`WS `: Interval Winkler Score + - :func:`IC `: Interval Coverage + - :func:`INCS_QR `: Interval Non-Conformity Score for Quantile Regression For Dynamic Time Warping (DTW) (aggregated over time): @@ -73,6 +78,7 @@ dtw_metric, err, ic, + incs_qr, iw, iws, mae, @@ -81,6 +87,7 @@ mase, merr, mic, + mincs_qr, miw, miws, mql, @@ -134,6 +141,8 @@ sse, ic, mic, + incs_qr, + mincs_qr, } TIME_DEPENDENT_METRICS = { @@ -150,6 +159,7 @@ iw, iws, ic, + incs_qr, } Q_INTERVAL_METRICS = { @@ -159,6 +169,7 @@ miws, ic, mic, + incs_qr, } NON_Q_METRICS = {dtw_metric} @@ -197,4 +208,6 @@ "miws", "ic", "mic", + "incs_qr", + "mincs_qr", ] diff --git a/darts/metrics/metrics.py b/darts/metrics/metrics.py index 9a3cb1b6e6..d64ea8546c 100644 --- a/darts/metrics/metrics.py +++ b/darts/metrics/metrics.py @@ -3934,3 +3934,205 @@ def mic( ), axis=TIME_AX, ) + + +@interval_support +@multi_ts_support +@multivariate_support +def incs_qr( + actual_series: Union[TimeSeries, Sequence[TimeSeries]], + pred_series: Union[TimeSeries, Sequence[TimeSeries]], + intersect: bool = True, + *, + q_interval: Union[Tuple[float, float], Sequence[Tuple[float, float]]] = None, + q: Optional[Union[float, List[float], Tuple[np.ndarray, pd.Index]]] = None, + time_reduction: Optional[Callable[..., np.ndarray]] = None, + component_reduction: Optional[Callable[[np.ndarray], float]] = np.nanmean, + series_reduction: Optional[Callable[[np.ndarray], Union[float, np.ndarray]]] = None, + n_jobs: int = 1, + verbose: bool = False, +) -> METRIC_OUTPUT_TYPE: + """Interval Non-Conformity Score for Quantile Regression (INCS_QR). + + INCS_QR gives the absolute error to the closest predicted quantile interval bound when the observation is outside + the interval. Otherwise, it gives the negative absolute error to the closer bound. + + For the true series :math:`y` and predicted stochastic or quantile series :math:`\\hat{y}` of length :math:`T`, + it is computed per component/column, quantile interval :math:`(q_l,q_h)`, and time step :math:`t` as: + + .. math:: \\max(L_t - y_t, y_t - U_t) + + where :math:`U_t` are the predicted upper bound quantile values :math:`\\hat{y}_{q_h,t}` (of all predicted + quantiles or samples) at time :math:`t`, and :math:`L_t` are the predicted lower bound quantile values + :math:`\\hat{y}_{q_l,t}`. + + Parameters + ---------- + actual_series + The (sequence of) actual series. + pred_series + The (sequence of) predicted series. + intersect + For time series that are overlapping in time without having the same time index, setting `True` + will consider the values only over their common time interval (intersection in time). + q_interval + The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence tuples + (multiple intervals) with elements (low quantile, high quantile). + q + Quantiles `q` not supported by this metric; use `q_interval` instead. + component_reduction + Optionally, a function to aggregate the metrics over the component/column axis. It must reduce a `np.ndarray` + of shape `(t, c)` to a `np.ndarray` of shape `(t,)`. The function takes as input a ``np.ndarray`` and a + parameter named `axis`, and returns the reduced array. The `axis` receives value `1` corresponding to the + component axis. If `None`, will return a metric per component. + time_reduction + Optionally, a function to aggregate the metrics over the time axis. It must reduce a `np.ndarray` + of shape `(t, c)` to a `np.ndarray` of shape `(c,)`. The function takes as input a ``np.ndarray`` and a + parameter named `axis`, and returns the reduced array. The `axis` receives value `0` corresponding to the + time axis. If `None`, will return a metric per time step. + series_reduction + Optionally, a function to aggregate the metrics over multiple series. It must reduce a `np.ndarray` + of shape `(s, t, c)` to a `np.ndarray` of shape `(t, c)` The function takes as input a ``np.ndarray`` and a + parameter named `axis`, and returns the reduced array. The `axis` receives value `0` corresponding to the + series axis. For example with `np.nanmean`, will return the average over all series metrics. If `None`, will + return a metric per component. + n_jobs + The number of jobs to run in parallel. Parallel jobs are created only when a ``Sequence[TimeSeries]`` is + passed as input, parallelising operations regarding different ``TimeSeries``. Defaults to `1` + (sequential). Setting the parameter to `-1` means using all the available processors. + verbose + Optionally, whether to print operations progress + + Returns + ------- + float + A single metric score for (with `len(q_interval) <= 1`): + + - single univariate series. + - single multivariate series with `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and + `time_reduction`. + np.ndarray + A numpy array of metric scores. The array has shape (n time steps, n components * n q intervals) without time + and component reductions, and shape (n time steps, n q intervals) without time but component reduction and + `len(q_interval) > 1`. For: + + - the input from the `float` return case above but with `len(q_interval) > 1`. + - single multivariate series and at least `component_reduction=None`. + - single uni/multivariate series and at least `time_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and at least one of + `component_reduction=None` or `time_reduction=None`. + List[float] + Same as for type `float` but for a sequence of series. + List[np.ndarray] + Same as for type `np.ndarray` but for a sequence of series. + + References + ---------- + .. [1] https://otexts.com/fpp3/distaccuracy.html + """ + y_true, y_pred = _get_values_or_raise( + actual_series, + pred_series, + intersect, + remove_nan_union=True, + q=q, + ) + y_pred_lo, y_pred_hi = _get_quantile_intervals(y_pred, q=q, q_interval=q_interval) + return np.maximum(y_pred_lo - y_true, y_true - y_pred_hi) + + +@interval_support +@multi_ts_support +@multivariate_support +def mincs_qr( + actual_series: Union[TimeSeries, Sequence[TimeSeries]], + pred_series: Union[TimeSeries, Sequence[TimeSeries]], + intersect: bool = True, + *, + q_interval: Union[Tuple[float, float], Sequence[Tuple[float, float]]] = None, + q: Optional[Union[float, List[float], Tuple[np.ndarray, pd.Index]]] = None, + component_reduction: Optional[Callable[[np.ndarray], float]] = np.nanmean, + series_reduction: Optional[Callable[[np.ndarray], Union[float, np.ndarray]]] = None, + n_jobs: int = 1, + verbose: bool = False, +) -> METRIC_OUTPUT_TYPE: + """Mean Interval Non-Conformity Score for Quantile Regression (MINCS_QR). + + MINCS_QR gives the time-aggregated INCS_QR :func:`~darts.metrics.metrics.incs_qr`. + + For the true series :math:`y` and predicted stochastic or quantile series :math:`\\hat{y}` of length :math:`T`, + it is computed per component/column, quantile interval :math:`(q_l,q_h)`, and time step :math:`t` as: + + .. math:: \\frac{1}{T}\\sum_{t=1}^T{INCS_QR(y_t, \\hat{y}_{t}, q_h, q_l)}, + + where :math:`INCS_QR` is the Interval Non-Conformity Score for Quantile Regression + :func:`~darts.metrics.metrics.incs_qr`. + + Parameters + ---------- + actual_series + The (sequence of) actual series. + pred_series + The (sequence of) predicted series. + intersect + For time series that are overlapping in time without having the same time index, setting `True` + will consider the values only over their common time interval (intersection in time). + q_interval + The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence tuples + (multiple intervals) with elements (low quantile, high quantile). + q + Quantiles `q` not supported by this metric; use `q_interval` instead. + component_reduction + Optionally, a function to aggregate the metrics over the component/column axis. It must reduce a `np.ndarray` + of shape `(t, c)` to a `np.ndarray` of shape `(t,)`. The function takes as input a ``np.ndarray`` and a + parameter named `axis`, and returns the reduced array. The `axis` receives value `1` corresponding to the + component axis. If `None`, will return a metric per component. + series_reduction + Optionally, a function to aggregate the metrics over multiple series. It must reduce a `np.ndarray` + of shape `(s, t, c)` to a `np.ndarray` of shape `(t, c)` The function takes as input a ``np.ndarray`` and a + parameter named `axis`, and returns the reduced array. The `axis` receives value `0` corresponding to the + series axis. For example with `np.nanmean`, will return the average over all series metrics. If `None`, will + return a metric per component. + n_jobs + The number of jobs to run in parallel. Parallel jobs are created only when a ``Sequence[TimeSeries]`` is + passed as input, parallelising operations regarding different ``TimeSeries``. Defaults to `1` + (sequential). Setting the parameter to `-1` means using all the available processors. + verbose + Optionally, whether to print operations progress + + Returns + ------- + float + A single metric score for (with `len(q_interval) <= 1`): + + - single univariate series. + - single multivariate series with `component_reduction`. + - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. + np.ndarray + A numpy array of metric scores. The array has shape (n components * n q intervals,) without component reduction, + and shape (n q intervals,) with component reduction and `len(q_interval) > 1`. + For: + + - the input from the `float` return case above but with `len(q_interval) > 1`. + - single multivariate series and at least `component_reduction=None`. + - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. + List[float] + Same as for type `float` but for a sequence of series. + List[np.ndarray] + Same as for type `np.ndarray` but for a sequence of series. + + References + ---------- + .. [1] https://otexts.com/fpp3/distaccuracy.html + """ + return np.nanmean( + _get_wrapped_metric(ic, n_wrappers=3)( + actual_series, + pred_series, + intersect, + q=q, + q_interval=q_interval, + ), + axis=TIME_AX, + ) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index b4bd048b98..7ac75e2b6e 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -1,5 +1,4 @@ import os -import re from abc import ABC, abstractmethod from typing import Any, BinaryIO, Callable, Dict, List, Optional, Sequence, Tuple, Union @@ -35,8 +34,10 @@ if TORCH_AVAILABLE: from darts.models.forecasting.torch_forecasting_model import TorchForecastingModel + from darts.utils.likelihood_models import QuantileRegression else: TorchForecastingModel = None + QuantileRegression = None logger = get_logger(__name__) @@ -79,7 +80,7 @@ def __init__( Parameters ---------- model - A pre-trained forecasting model. + A pre-trained global forecasting model. quantiles Optionally, a list of quantiles centered around the median `q=0.5` to use. For example quantiles [0.1, 0.5, 0.9] correspond to a (0.9 - 0.1) = 80% coverage interval around the median (model forecast). @@ -103,16 +104,21 @@ def __init__( self._quantiles_no_med = [q for q in quantiles if q != 0.5] self._likelihood = "quantile" + half_idx = int(len(self.quantiles) / 2) + self.intervals = [ + q_high - q_low + for q_high, q_low in zip( + self.quantiles[half_idx + 1 :][::-1], self.quantiles[:half_idx] + ) + ] + # if isinstance(alpha, float): # self.symmetrical = True # self.q_hats = pd.DataFrame(columns=["q_hat_sym"]) - # self.quantiles = [0.5 * (1 - alpha), 1 - 0.5 * (1 - alpha)] # else: # self.symmetrical = False # self.alpha_lo, self.alpha_hi = alpha # self.q_hats = pd.DataFrame(columns=["q_hat_lo", "q_hat_hi"]) - # self.quantiles = [1 - 0.5 * (1 - alpha_) for alpha_ in alpha] - # self.quantiles = self.quantiles[:1] + [0.50] + self.quantiles[1:] # self.noncon_scores = dict() # self.alpha = alpha # self.quantiles = quantiles @@ -1075,122 +1081,87 @@ def likelihood(self) -> str: return self._likelihood -def uncertainty_evaluate(df_forecast: pd.DataFrame) -> pd.DataFrame: - """Evaluate conformal prediction on test dataframe. - - Parameters - ---------- - df_forecast : pd.DataFrame - forecast dataframe with the conformal prediction intervals - - Returns - ------- - pd.DataFrame - table containing evaluation metrics such as interval_width and miscoverage_rate - """ - # Remove beginning rows used as lagged regressors (if any), or future dataframes without y-values - # therefore, this ensures that all forecast rows for evaluation contains both y and y-hat - df_forecast_eval = df_forecast.dropna(subset=["y", "yhat1"]).reset_index(drop=True) - - # Get evaluation params - df_eval = pd.DataFrame() - cols = df_forecast_eval.columns - yhat_cols = [col for col in cols if "%" in col] - n_forecasts = int(re.search("yhat(\\d+)", yhat_cols[-1]).group(1)) - - # get the highest and lowest quantile percentages - quantiles = [] - for col in yhat_cols: - match = re.search(r"\d+\.\d+", col) - if match: - quantiles.append(float(match.group())) - quantiles = sorted(set(quantiles)) - - # Begin conformal evaluation steps - for step_number in range(1, n_forecasts + 1): - y = df_forecast_eval["y"].values - # only relevant if show_all_PI is true - if len([col for col in cols if "qhat" in col]) > 0: - qhat_cols = [col for col in cols if f"qhat{step_number}" in col] - yhat_lo = df_forecast_eval[qhat_cols[0]].values - yhat_hi = df_forecast_eval[qhat_cols[-1]].values - else: - yhat_lo = df_forecast_eval[f"yhat{step_number} {quantiles[0]}%"].values - yhat_hi = df_forecast_eval[f"yhat{step_number} {quantiles[-1]}%"].values - interval_width, miscoverage_rate = _get_evaluate_metrics_from_dataset( - y, yhat_lo, yhat_hi - ) - - # Construct row dataframe with current timestep using its q-hat, interval width, and miscoverage rate - col_names = ["interval_width", "miscoverage_rate"] - row = [interval_width, miscoverage_rate] - df_row = pd.DataFrame( - [row], - columns=pd.MultiIndex.from_product([[f"yhat{step_number}"], col_names]), - ) - - # Add row dataframe to overall evaluation dataframe with all forecasted timesteps - df_eval = pd.concat([df_eval, df_row], axis=1) - - return df_eval - - -def _get_evaluate_metrics_from_dataset( - y: np.ndarray, yhat_lo: np.ndarray, yhat_hi: np.ndarray -) -> Tuple[float, float]: - # df_forecast_eval: pd.DataFrame, - # quantile_lo_col: str, - # quantile_hi_col: str, - # ) -> Tuple[float, float]: - """Infers evaluation parameters based on the evaluation dataframe columns. +class ConformalNaiveModel(ConformalModel): + def __init__( + self, + model: GlobalForecastingModel, + quantiles: List[float], + ): + """Naive Conformal Prediction Model. - Parameters - ---------- - df_forecast_eval : pd.DataFrame - forecast dataframe with the conformal prediction intervals + Parameters + ---------- + model + A pre-trained global forecasting model. + quantiles + Optionally, a list of quantiles centered around the median `q=0.5` to use. For example quantiles + [0.1, 0.5, 0.9] correspond to a (0.9 - 0.1) = 80% coverage interval around the median (model forecast). + """ + super().__init__(model=model, quantiles=quantiles) - Returns - ------- - float, float - conformal prediction evaluation metrics - """ - # Interval width (efficiency metric) - quantile_lo_mean = np.mean(yhat_lo) - quantile_hi_mean = np.mean(yhat_hi) - interval_width = quantile_hi_mean - quantile_lo_mean + def _calibrate_interval( + self, residuals: np.ndarray + ) -> Tuple[np.ndarray, np.ndarray]: + """Computes the lower and upper calibrated forecast intervals based on residuals. - # Miscoverage rate (validity metric) - n_covered = np.sum((y >= yhat_lo) & (y <= yhat_hi)) - coverage_rate = n_covered / len(y) - miscoverage_rate = 1 - coverage_rate + Parameters + ---------- + residuals + The residuals are expected to have shape (horizon, n components, n historical forecasts * n samples) + """ + # shape (forecast horizon, n components, n quantile intervals) + q_hat = np.quantile(residuals, q=self.intervals, axis=2).transpose((1, 2, 0)) + return -q_hat, q_hat[:, :, ::-1] - return interval_width, miscoverage_rate + @property + def _residuals_metric(self): + return metrics.ae -class ConformalNaiveModel(ConformalModel): +class ConformalQRModel(ConformalModel): def __init__( self, model: GlobalForecastingModel, quantiles: List[float], ): - """Naive Conformal Prediction Model. + """Conformalized Quantile Regression Model. Parameters ---------- model - A pre-trained forecasting model. + A pre-trained global forecasting model using a Quantile Regression likelihood. + If `model` is a `RegressionModel`, it must have been created with `likelihood='quantile'` and a list of + quantiles `quantiles`. + If `model` is a `RegressionModel`, it must have been created with + `likelihood=darts.utils.likelihood_models.QuantileRegression(quantiles)` with a list of `quantiles`. quantiles Optionally, a list of quantiles centered around the median `q=0.5` to use. For example quantiles [0.1, 0.5, 0.9] correspond to a (0.9 - 0.1) = 80% coverage interval around the median (model forecast). """ - super().__init__(model=model, quantiles=quantiles) - half_idx = int(len(self.quantiles) / 2) - self.intervals = [ - q_high - q_low - for q_high, q_low in zip( - self.quantiles[half_idx + 1 :][::-1], self.quantiles[:half_idx] + if not hasattr(model, "likelihood"): + raise_log( + ValueError("`model` must must support `likelihood`."), logger=logger ) - ] + if TORCH_AVAILABLE and isinstance(model, TorchForecastingModel): + if not isinstance(model.likelihood, QuantileRegression): + raise_log( + ValueError( + "Since `model` is a `TorchForecastingModel` it must use `likelihood=QuantileRegression()`." + ), + logger=logger, + ) + else: + quantiles = model.likelihood.quantiles + else: # regression models + if model.likelihood != "quantile": + raise_log( + ValueError( + f"Since `model` is a `{model.__class__.__name__} it must use `likelihood='quantile'`." + ), + logger=logger, + ) + quantiles = model.quantiles + super().__init__(model=model, quantiles=quantiles) def _calibrate_interval( self, residuals: np.ndarray diff --git a/darts/tests/metrics/test_metrics.py b/darts/tests/metrics/test_metrics.py index 480dc0e61d..16a6197e4d 100644 --- a/darts/tests/metrics/test_metrics.py +++ b/darts/tests/metrics/test_metrics.py @@ -100,6 +100,32 @@ def metric_iws(y_true, y_pred, q_interval=None, **kwargs): return res.reshape(len(y_pred), -1) +def metric_ic(y_true, y_pred, q_interval=None, **kwargs): + # this tests assumes `y_pred` are stochastic values + if isinstance(q_interval, tuple): + q_interval = [q_interval] + q_interval = np.array(q_interval) + q_lo = q_interval[:, 0] + q_hi = q_interval[:, 1] + y_pred_lo = np.quantile(y_pred, q_lo, axis=2).transpose(1, 2, 0) + y_pred_hi = np.quantile(y_pred, q_hi, axis=2).transpose(1, 2, 0) + res = np.where((y_pred_lo <= y_true) & (y_true <= y_pred_hi), 1, 0) + return res.reshape(len(y_pred), -1) + + +def metric_incs_qr(y_true, y_pred, q_interval=None, **kwargs): + # this tests assumes `y_pred` are stochastic values + if isinstance(q_interval, tuple): + q_interval = [q_interval] + q_interval = np.array(q_interval) + q_lo = q_interval[:, 0] + q_hi = q_interval[:, 1] + y_pred_lo = np.quantile(y_pred, q_lo, axis=2).transpose(1, 2, 0) + y_pred_hi = np.quantile(y_pred, q_hi, axis=2).transpose(1, 2, 0) + res = np.maximum(y_pred_lo - y_true, y_true - y_pred_hi) + return res.reshape(len(y_pred), -1) + + class TestMetrics: np.random.seed(42) pd_train = pd.Series( @@ -1875,6 +1901,8 @@ def test_wrong_error_scale(self): # only time dependent quantile interval metrics (metrics.iw, metric_iw), (metrics.iws, metric_iws), + (metrics.ic, metric_ic), + (metrics.incs_qr, metric_incs_qr), ], ) def test_metric_quantile_interval_accuracy(self, config): @@ -1923,6 +1951,10 @@ def check_ref(**test_kwargs): metrics.miw, metrics.iws, metrics.miws, + metrics.ic, + metrics.mic, + metrics.incs_qr, + metrics.mincs_qr, ], [True, False], # univariate series [True, False], # single series From 5fb9d306f3e35bf3d91e3112cdaf6aead155acca Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 27 Sep 2024 11:19:16 +0200 Subject: [PATCH 37/78] add conformalized quantile regression --- darts/metrics/metrics.py | 1 + darts/models/__init__.py | 3 +- darts/models/cp/conformal_model.py | 100 +++++++++++++----- .../forecasting/test_conformal_model.py | 46 ++++++-- 4 files changed, 115 insertions(+), 35 deletions(-) diff --git a/darts/metrics/metrics.py b/darts/metrics/metrics.py index d64ea8546c..e989fa60ca 100644 --- a/darts/metrics/metrics.py +++ b/darts/metrics/metrics.py @@ -4039,6 +4039,7 @@ def incs_qr( q=q, ) y_pred_lo, y_pred_hi = _get_quantile_intervals(y_pred, q=q, q_interval=q_interval) + # return np.concatenate([y_pred_lo - y_true, y_true - y_pred_hi], axis=SMPL_AX) return np.maximum(y_pred_lo - y_true, y_true - y_pred_hi) diff --git a/darts/models/__init__.py b/darts/models/__init__.py index 41554e98b2..fedc7ca8bc 100644 --- a/darts/models/__init__.py +++ b/darts/models/__init__.py @@ -109,7 +109,7 @@ XGBModel = NotImportedModule(module_name="XGBoost") # Conformal Prediction -from darts.models.cp.conformal_model import ConformalNaiveModel +from darts.models.cp.conformal_model import ConformalNaiveModel, ConformalQRModel # Filtering from darts.models.filtering.gaussian_process_filter import GaussianProcessFilter @@ -168,4 +168,5 @@ "NaiveEnsembleModel", "EnsembleModel", "ConformalNaiveModel", + "ConformalQRModel", ] diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 7ac75e2b6e..72eaaf90cb 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -104,11 +104,12 @@ def __init__( self._quantiles_no_med = [q for q in quantiles if q != 0.5] self._likelihood = "quantile" - half_idx = int(len(self.quantiles) / 2) + self.idx_q_med = int(len(self.quantiles) / 2) self.intervals = [ q_high - q_low for q_high, q_low in zip( - self.quantiles[half_idx + 1 :][::-1], self.quantiles[:half_idx] + self.quantiles[self.idx_q_med + 1 :][::-1], + self.quantiles[: self.idx_q_med], ) ] @@ -205,10 +206,11 @@ def predict( series=series, past_covariates=past_covariates, future_covariates=future_covariates, - num_samples=num_samples, + # num_samples=num_samples, verbose=verbose, predict_likelihood_parameters=predict_likelihood_parameters, show_warnings=show_warnings, + **self._get_forecast_params(), ) # convert to multi series case with `last_points_only=False` preds = [[pred] for pred in preds] @@ -218,7 +220,7 @@ def predict( series=cal_series, past_covariates=cal_past_covariates, future_covariates=cal_future_covariates, - num_samples=num_samples, + # num_samples=num_samples, forecast_horizon=n, retrain=False, overlap_end=True, @@ -226,6 +228,7 @@ def predict( verbose=verbose, show_warnings=show_warnings, predict_likelihood_parameters=predict_likelihood_parameters, + **self._get_forecast_params(), ) cal_preds = self._calibrate_forecasts( series=series, @@ -346,7 +349,7 @@ def historical_forecasts( series=series, past_covariates=past_covariates, future_covariates=future_covariates, - num_samples=num_samples, + # num_samples=num_samples, forecast_horizon=forecast_horizon, retrain=False, overlap_end=overlap_end, @@ -357,6 +360,7 @@ def historical_forecasts( enable_optimization=enable_optimization, fit_kwargs=fit_kwargs, predict_kwargs=predict_kwargs, + **self._get_forecast_params(), ) # optionally, generate calibration forecasts if cal_series is None: @@ -366,7 +370,7 @@ def historical_forecasts( series=cal_series, past_covariates=cal_past_covariates, future_covariates=cal_future_covariates, - num_samples=num_samples, + # num_samples=num_samples, forecast_horizon=forecast_horizon, retrain=False, overlap_end=True, @@ -377,6 +381,7 @@ def historical_forecasts( enable_optimization=enable_optimization, fit_kwargs=fit_kwargs, predict_kwargs=predict_kwargs, + **self._get_forecast_params(), ) calibrated_forecasts = self._calibrate_forecasts( series=series, @@ -552,6 +557,7 @@ def _calibrate_forecasts( # - predict_likelihood_parameters # - tqdm iterator over series # - support for different CP algorithms + metric, metric_kwargs = self._residuals_metric residuals = self.model.residuals( series=series if cal_series is None else cal_series, historical_forecasts=forecasts if cal_series is None else cal_forecasts, @@ -560,7 +566,8 @@ def _calibrate_forecasts( verbose=verbose, show_warnings=show_warnings, values_only=True, - metric=self._residuals_metric, + metric=metric, + metric_kwargs=metric_kwargs, ) cp_hfcs = [] @@ -860,28 +867,30 @@ def load(path: Union[str, os.PathLike, BinaryIO]) -> "ConformalModel": model.model = TorchForecastingModel.load(path_tfm) return model + def _get_forecast_params(self): + if self.model.supports_probabilistic_prediction: + return {"num_samples": 500} + else: + return {"num_samples": 1} + @abstractmethod def _calibrate_interval( self, residuals: np.ndarray ) -> Tuple[np.ndarray, np.ndarray]: """Computes the upper and lower calibrated forecast intervals based on residuals.""" - @staticmethod - def _apply_interval(pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray]): - """Applies the calibrated interval to the predicted values. Returns an array with 3 predicted columns - (lower bound, model forecast, upper bound) per component. - - E.g. output is `(target1_cq_low, target1_pred, target1_cq_high, target2_cq_low, ...)` + @abstractmethod + def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray]): + """Implements the logic to apply the calibrated interval to the predicted values. + Must return an array with shape (n times, n components * n quantiles, 1). """ - # shape (forecast horizon, n components, n quantiles) - pred = np.concatenate([pred + q_hat[0], pred, pred + q_hat[1]], axis=2) - # -> (forecast horizon, n components * n quantiles) - return pred.reshape(len(pred), -1) + pass @property @abstractmethod - def _residuals_metric(self): - """Gives the "per time step" metric used to compute residuals.""" + def _residuals_metric(self) -> Tuple[METRIC_TYPE, Optional[dict]]: + """Gives the "per time step" metric and optional metric kwargs used to compute residuals / + non-conformity scores.""" def _get_nonconformity_scores(self, df_cal: pd.DataFrame, step_number: int) -> dict: """Get the nonconformity scores using the given conformal prediction technique. @@ -1113,9 +1122,20 @@ def _calibrate_interval( q_hat = np.quantile(residuals, q=self.intervals, axis=2).transpose((1, 2, 0)) return -q_hat, q_hat[:, :, ::-1] + def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray]): + """Applies the calibrated interval to the predicted values. Returns an array with `len(quantiles)` + conformalized quantile predictions (lower quantiles, model forecast, upper quantiles) per component. + + E.g. output is `(target1_q1, target1_pred, target1_q2, target2_q1, ...)` + """ + # shape (forecast horizon, n components, n quantiles) + pred = np.concatenate([pred + q_hat[0], pred, pred + q_hat[1]], axis=2) + # -> (forecast horizon, n components * n quantiles) + return pred.reshape(len(pred), -1) + @property - def _residuals_metric(self): - return metrics.ae + def _residuals_metric(self) -> Tuple[METRIC_TYPE, Optional[dict]]: + return metrics.ae, None class ConformalQRModel(ConformalModel): @@ -1174,9 +1194,41 @@ def _calibrate_interval( The residuals are expected to have shape (horizon, n components, n historical forecasts * n samples) """ # shape (forecast horizon, n components, n quantile intervals) - q_hat = np.quantile(residuals, q=self.intervals, axis=2).transpose((1, 2, 0)) + n_comps = residuals.shape[1] // len(self.intervals) + n_intervals = len(self.intervals) + # + # is there a more efficient way? + q_hat_tmp = np.quantile(residuals, q=self.intervals, axis=2).transpose(( + 1, + 2, + 0, + )) + q_hat = np.empty((len(residuals), n_comps, n_intervals)) + for i in range(n_intervals): + for c in range(n_comps): + q_hat[:, c, i] = q_hat_tmp[:, i + c * n_intervals, i] return -q_hat, q_hat[:, :, ::-1] + def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray]): + """Applies the calibrated interval to the predicted quantiles. Returns an array with `len(quantiles)` + conformalized quantile predictions (lower quantiles, model forecast, upper quantiles) per component. + + E.g. output is `(target1_q1, target1_pred, target1_q2, target2_q1, ...)` + """ + # get quantile predictions with shape (n times, n components, n quantiles) + pred = np.quantile(pred, self.quantiles, axis=2).transpose((1, 2, 0)) + # shape (forecast horizon, n components, n quantiles) + pred = np.concatenate( + [ + pred[:, :, : self.idx_q_med] + q_hat[0], # lower quantiles + pred[:, :, self.idx_q_med : self.idx_q_med + 1], # model forecast + pred[:, :, self.idx_q_med + 1 :] + q_hat[1], # upper quantiles + ], + axis=2, + ) + # -> (forecast horizon, n components * n quantiles) + return pred.reshape(len(pred), -1) + @property - def _residuals_metric(self): - return metrics.ae + def _residuals_metric(self) -> Tuple[METRIC_TYPE, Optional[dict]]: + return metrics.incs_qr, {"q_interval": self._q_intervals} diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 7bcb9310e3..ea900af760 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -11,6 +11,7 @@ from darts.metrics import ae, ic, mic from darts.models import ( ConformalNaiveModel, + ConformalQRModel, LinearRegressionModel, NaiveSeasonal, NLinearModel, @@ -34,17 +35,26 @@ **tfm_kwargs, ) +q = [0.1, 0.5, 0.9] + -def train_model(*args, model_type="regression", model_params=None, **kwargs): +def train_model( + *args, model_type="regression", model_params=None, quantiles=None, **kwargs +): model_params = model_params or {} if model_type == "regression": return LinearRegressionModel(**regr_kwargs, **model_params).fit(*args, **kwargs) + elif model_type == "regression_qr": + return LinearRegressionModel( + likelihood="quantile", + quantiles=quantiles, + **regr_kwargs, + **model_params, + ).fit(*args, **kwargs) else: return NLinearModel(**torch_kwargs, **model_params).fit(*args, **kwargs) -q = [0.1, 0.5, 0.9] - # pre-trained global model for conformal models models_cls_kwargs_errs = [ ( @@ -52,6 +62,7 @@ def train_model(*args, model_type="regression", model_params=None, **kwargs): {"quantiles": q}, "regression", ), + (ConformalQRModel, {"quantiles": q}, "regression_qr"), ] if TORCH_AVAILABLE: @@ -153,7 +164,10 @@ def test_save_model_parameters(self, config): # model creation parameters were saved before. check if re-created model has same params as original model_cls, kwargs, model_type = config model = model_cls( - model=train_model(self.ts_pass_train, model_type=model_type), **kwargs + model=train_model( + self.ts_pass_train, model_type=model_type, quantiles=kwargs["quantiles"] + ), + **kwargs, ) model_fresh = model.untrained_model() assert model._model_params.keys() == model_fresh._model_params.keys() @@ -168,7 +182,10 @@ def test_save_load_model(self, tmpdir_fn, config): # check if save and load methods work and if loaded model creates same forecasts as original model model_cls, kwargs, model_type = config model = model_cls( - train_model(self.ts_pass_train, model_type=model_type), **kwargs + train_model( + self.ts_pass_train, model_type=model_type, quantiles=kwargs["quantiles"] + ), + **kwargs, ) model_prediction = model.predict(5) @@ -217,7 +234,10 @@ def test_save_load_model(self, tmpdir_fn, config): def test_single_ts(self, config): model_cls, kwargs, model_type = config model = model_cls( - train_model(self.ts_pass_train, model_type=model_type), **kwargs + train_model( + self.ts_pass_train, model_type=model_type, quantiles=kwargs["quantiles"] + ), + **kwargs, ) pred = model.predict(n=self.horizon) assert pred.n_components == self.ts_pass_train.n_components * 3 @@ -248,12 +268,14 @@ def test_single_ts(self, config): n=self.horizon, series=self.ts_pass_train.stack(self.ts_pass_train) ) - @pytest.mark.parametrize("config", models_cls_kwargs_errs) + @pytest.mark.parametrize("config", models_cls_kwargs_errs[:]) def test_multi_ts(self, config): model_cls, kwargs, model_type = config model = model_cls( train_model( - [self.ts_pass_train, self.ts_pass_train_1], model_type=model_type + [self.ts_pass_train, self.ts_pass_train_1], + model_type=model_type, + quantiles=kwargs["quantiles"], ), **kwargs, ) @@ -549,7 +571,10 @@ def test_use_static_covariates(self, config, ts): Also check that the static covariates are present in the forecasted series """ model_cls, kwargs, model_type = config - model = model_cls(train_model(ts, model_type=model_type), **kwargs) + model = model_cls( + train_model(ts, model_type=model_type, quantiles=kwargs["quantiles"]), + **kwargs, + ) assert model.uses_static_covariates pred = model.predict(OUT_LEN) assert pred.static_covariates is None @@ -620,7 +645,8 @@ def test_predict(self, config): def test_output_chunk_shift(self): model_params = {"output_chunk_shift": 1} model = ConformalNaiveModel( - train_model(self.ts_pass_train, model_params=model_params), quantiles=q + train_model(self.ts_pass_train, model_params=model_params, quantiles=q), + quantiles=q, ) pred = model.predict(n=1) pred_fc = model.model.predict(n=1) From ff602549731842238fe3d3fd0ed93537dee443d6 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sun, 29 Sep 2024 13:36:47 +0200 Subject: [PATCH 38/78] allow all global prob models for ConformalQR --- darts/models/cp/conformal_model.py | 36 ++++++++++-------------------- 1 file changed, 12 insertions(+), 24 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 72eaaf90cb..8fb8df822e 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -82,7 +82,7 @@ def __init__( model A pre-trained global forecasting model. quantiles - Optionally, a list of quantiles centered around the median `q=0.5` to use. For example quantiles + A list of quantiles centered around the median `q=0.5` to use. For example quantiles [0.1, 0.5, 0.9] correspond to a (0.9 - 0.1) = 80% coverage interval around the median (model forecast). """ if not isinstance(model, GlobalForecastingModel) or not model._fit_called: @@ -1103,7 +1103,7 @@ def __init__( model A pre-trained global forecasting model. quantiles - Optionally, a list of quantiles centered around the median `q=0.5` to use. For example quantiles + A list of quantiles centered around the median `q=0.5` to use. For example quantiles [0.1, 0.5, 0.9] correspond to a (0.9 - 0.1) = 80% coverage interval around the median (model forecast). """ super().__init__(model=model, quantiles=quantiles) @@ -1128,6 +1128,9 @@ def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray] E.g. output is `(target1_q1, target1_pred, target1_q2, target2_q1, ...)` """ + # stochastic predictions + if pred.shape[2] != 1: + pred = np.expand_dims(np.quantile(pred, 0.5, axis=2), -1) # shape (forecast horizon, n components, n quantiles) pred = np.concatenate([pred + q_hat[0], pred, pred + q_hat[1]], axis=2) # -> (forecast horizon, n components * n quantiles) @@ -1155,32 +1158,17 @@ def __init__( If `model` is a `RegressionModel`, it must have been created with `likelihood=darts.utils.likelihood_models.QuantileRegression(quantiles)` with a list of `quantiles`. quantiles - Optionally, a list of quantiles centered around the median `q=0.5` to use. For example quantiles + A list of quantiles centered around the median `q=0.5` to use. For example quantiles [0.1, 0.5, 0.9] correspond to a (0.9 - 0.1) = 80% coverage interval around the median (model forecast). """ - if not hasattr(model, "likelihood"): + if not model.supports_probabilistic_prediction: raise_log( - ValueError("`model` must must support `likelihood`."), logger=logger + ValueError( + "`model` must must support probabilistic forecasting. Consider using a `likelihood` at " + "forecasting model creation, or use another conformal model." + ), + logger=logger, ) - if TORCH_AVAILABLE and isinstance(model, TorchForecastingModel): - if not isinstance(model.likelihood, QuantileRegression): - raise_log( - ValueError( - "Since `model` is a `TorchForecastingModel` it must use `likelihood=QuantileRegression()`." - ), - logger=logger, - ) - else: - quantiles = model.likelihood.quantiles - else: # regression models - if model.likelihood != "quantile": - raise_log( - ValueError( - f"Since `model` is a `{model.__class__.__name__} it must use `likelihood='quantile'`." - ), - logger=logger, - ) - quantiles = model.quantiles super().__init__(model=model, quantiles=quantiles) def _calibrate_interval( From 5ab3631cfed5daed69d1f680680d8cd0e8c89cf5 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Mon, 30 Sep 2024 13:03:33 +0200 Subject: [PATCH 39/78] add asymmetric naive model --- darts/metrics/metrics.py | 15 ++++- darts/models/cp/conformal_model.py | 102 +++++++++++++++++++++-------- 2 files changed, 86 insertions(+), 31 deletions(-) diff --git a/darts/metrics/metrics.py b/darts/metrics/metrics.py index e989fa60ca..c544d45183 100644 --- a/darts/metrics/metrics.py +++ b/darts/metrics/metrics.py @@ -3945,6 +3945,7 @@ def incs_qr( intersect: bool = True, *, q_interval: Union[Tuple[float, float], Sequence[Tuple[float, float]]] = None, + symmetric: bool = True, q: Optional[Union[float, List[float], Tuple[np.ndarray, pd.Index]]] = None, time_reduction: Optional[Callable[..., np.ndarray]] = None, component_reduction: Optional[Callable[[np.ndarray], float]] = np.nanmean, @@ -3978,6 +3979,9 @@ def incs_qr( q_interval The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence tuples (multiple intervals) with elements (low quantile, high quantile). + symmetric + Whether to return symmetric non-conformity scores. If `False`, returns asymmetric scores (individual scores + for lower- and upper quantile interval bounds; returned in the component axis). q Quantiles `q` not supported by this metric; use `q_interval` instead. component_reduction @@ -4039,8 +4043,10 @@ def incs_qr( q=q, ) y_pred_lo, y_pred_hi = _get_quantile_intervals(y_pred, q=q, q_interval=q_interval) - # return np.concatenate([y_pred_lo - y_true, y_true - y_pred_hi], axis=SMPL_AX) - return np.maximum(y_pred_lo - y_true, y_true - y_pred_hi) + if symmetric: + return np.maximum(y_pred_lo - y_true, y_true - y_pred_hi) + else: + return np.concatenate([y_pred_lo - y_true, y_true - y_pred_hi], axis=SMPL_AX) @interval_support @@ -4052,6 +4058,7 @@ def mincs_qr( intersect: bool = True, *, q_interval: Union[Tuple[float, float], Sequence[Tuple[float, float]]] = None, + symmetric: bool = True, q: Optional[Union[float, List[float], Tuple[np.ndarray, pd.Index]]] = None, component_reduction: Optional[Callable[[np.ndarray], float]] = np.nanmean, series_reduction: Optional[Callable[[np.ndarray], Union[float, np.ndarray]]] = None, @@ -4082,6 +4089,9 @@ def mincs_qr( q_interval The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence tuples (multiple intervals) with elements (low quantile, high quantile). + symmetric + Whether to return symmetric non-conformity scores. If `False`, returns asymmetric scores (individual scores + for lower- and upper quantile interval bounds; returned in the component axis). q Quantiles `q` not supported by this metric; use `q_interval` instead. component_reduction @@ -4134,6 +4144,7 @@ def mincs_qr( intersect, q=q, q_interval=q_interval, + symmetric=symmetric, ), axis=TIME_AX, ) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 8fb8df822e..4dbf79063a 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -34,10 +34,8 @@ if TORCH_AVAILABLE: from darts.models.forecasting.torch_forecasting_model import TorchForecastingModel - from darts.utils.likelihood_models import QuantileRegression else: TorchForecastingModel = None - QuantileRegression = None logger = get_logger(__name__) @@ -69,11 +67,15 @@ def cqr_score_asym(row, quantile_lo_col, quantile_hi_col): ) +# class NCScorer + + class ConformalModel(GlobalForecastingModel, ABC): def __init__( self, model: GlobalForecastingModel, quantiles: List[float], + symmetric: bool = True, ): """Base Conformal Prediction Model. @@ -84,6 +86,9 @@ def __init__( quantiles A list of quantiles centered around the median `q=0.5` to use. For example quantiles [0.1, 0.5, 0.9] correspond to a (0.9 - 0.1) = 80% coverage interval around the median (model forecast). + symmetric + Whether to use symmetric non-conformity scores. If `False`, uses asymmetric scores (individual scores + for lower- and upper quantile interval bounds). """ if not isinstance(model, GlobalForecastingModel) or not model._fit_called: raise_log( @@ -105,14 +110,15 @@ def __init__( self._likelihood = "quantile" self.idx_q_med = int(len(self.quantiles) / 2) - self.intervals = [ + self.intervals = np.array([ q_high - q_low for q_high, q_low in zip( self.quantiles[self.idx_q_med + 1 :][::-1], self.quantiles[: self.idx_q_med], ) - ] + ]) + self.symmetric = symmetric # if isinstance(alpha, float): # self.symmetrical = True # self.q_hats = pd.DataFrame(columns=["q_hat_sym"]) @@ -1095,6 +1101,7 @@ def __init__( self, model: GlobalForecastingModel, quantiles: List[float], + symmetric: bool = True, ): """Naive Conformal Prediction Model. @@ -1105,8 +1112,11 @@ def __init__( quantiles A list of quantiles centered around the median `q=0.5` to use. For example quantiles [0.1, 0.5, 0.9] correspond to a (0.9 - 0.1) = 80% coverage interval around the median (model forecast). + symmetric + Whether to use symmetric non-conformity scores. If `False`, uses asymmetric scores (individual scores + for lower- and upper quantile interval bounds). """ - super().__init__(model=model, quantiles=quantiles) + super().__init__(model=model, quantiles=quantiles, symmetric=symmetric) def _calibrate_interval( self, residuals: np.ndarray @@ -1118,9 +1128,21 @@ def _calibrate_interval( residuals The residuals are expected to have shape (horizon, n components, n historical forecasts * n samples) """ - # shape (forecast horizon, n components, n quantile intervals) - q_hat = np.quantile(residuals, q=self.intervals, axis=2).transpose((1, 2, 0)) - return -q_hat, q_hat[:, :, ::-1] + if self.symmetric: + # shape (forecast horizon, n components, n quantile intervals) + q_hat = np.quantile(residuals, q=self.intervals, axis=2).transpose(( + 1, + 2, + 0, + )) + return -q_hat, q_hat[:, :, ::-1] + + # for asymmetric, use intervals `1 - alpha / 2` + intervals = 1 - (1 - self.intervals) / 2 + n_comps = residuals.shape[1] + res = np.concatenate([-residuals, residuals], axis=1) + q_hat = np.quantile(res, q=intervals, axis=2).transpose((1, 2, 0)) + return -q_hat[:, :n_comps, :], q_hat[:, n_comps:, ::-1] def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray]): """Applies the calibrated interval to the predicted values. Returns an array with `len(quantiles)` @@ -1138,7 +1160,10 @@ def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray] @property def _residuals_metric(self) -> Tuple[METRIC_TYPE, Optional[dict]]: - return metrics.ae, None + if self.symmetric: + return metrics.ae, None + else: + return metrics.err, None class ConformalQRModel(ConformalModel): @@ -1146,20 +1171,20 @@ def __init__( self, model: GlobalForecastingModel, quantiles: List[float], + symmetric: bool = True, ): """Conformalized Quantile Regression Model. Parameters ---------- model - A pre-trained global forecasting model using a Quantile Regression likelihood. - If `model` is a `RegressionModel`, it must have been created with `likelihood='quantile'` and a list of - quantiles `quantiles`. - If `model` is a `RegressionModel`, it must have been created with - `likelihood=darts.utils.likelihood_models.QuantileRegression(quantiles)` with a list of `quantiles`. + A pre-trained probabilistic global forecasting model using a `likelihood`. quantiles A list of quantiles centered around the median `q=0.5` to use. For example quantiles [0.1, 0.5, 0.9] correspond to a (0.9 - 0.1) = 80% coverage interval around the median (model forecast). + symmetric + Whether to use symmetric non-conformity scores. If `False`, uses asymmetric scores (individual scores + for lower- and upper quantile interval bounds). """ if not model.supports_probabilistic_prediction: raise_log( @@ -1169,7 +1194,7 @@ def __init__( ), logger=logger, ) - super().__init__(model=model, quantiles=quantiles) + super().__init__(model=model, quantiles=quantiles, symmetric=symmetric) def _calibrate_interval( self, residuals: np.ndarray @@ -1182,20 +1207,36 @@ def _calibrate_interval( The residuals are expected to have shape (horizon, n components, n historical forecasts * n samples) """ # shape (forecast horizon, n components, n quantile intervals) - n_comps = residuals.shape[1] // len(self.intervals) + n_comps = residuals.shape[1] // ( + len(self.intervals) * (1 + int(not self.symmetric)) + ) n_intervals = len(self.intervals) - # - # is there a more efficient way? - q_hat_tmp = np.quantile(residuals, q=self.intervals, axis=2).transpose(( - 1, - 2, - 0, - )) - q_hat = np.empty((len(residuals), n_comps, n_intervals)) - for i in range(n_intervals): - for c in range(n_comps): - q_hat[:, c, i] = q_hat_tmp[:, i + c * n_intervals, i] - return -q_hat, q_hat[:, :, ::-1] + + def q_hat_from_residuals(residuals_, intervals_): + # is there a more efficient way? + q_hat_tmp = np.quantile(residuals_, q=intervals_, axis=2).transpose(( + 1, + 2, + 0, + )) + q_hat_ = np.empty((len(residuals_), n_comps, n_intervals)) + for i in range(n_intervals): + for c in range(n_comps): + q_hat_[:, c, i] = q_hat_tmp[:, i + c * n_intervals, i] + return q_hat_ + + if self.symmetric: + # symmetric has one nc-score per intervals + q_hat = q_hat_from_residuals(residuals, self.intervals) + return -q_hat, q_hat[:, :, ::-1] + else: + # asymmetric has two nc-score per intervals (for lower and upper quantiles) + half_idx = residuals.shape[1] // 2 + # for asymmetric, use intervals `1 - alpha / 2` + intervals = 1 - (1 - self.intervals) / 2 + q_hat_lo = q_hat_from_residuals(residuals[:, :half_idx], intervals) + q_hat_hi = q_hat_from_residuals(residuals[:, half_idx:], intervals) + return -q_hat_lo, q_hat_hi[:, :, ::-1] def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray]): """Applies the calibrated interval to the predicted quantiles. Returns an array with `len(quantiles)` @@ -1219,4 +1260,7 @@ def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray] @property def _residuals_metric(self) -> Tuple[METRIC_TYPE, Optional[dict]]: - return metrics.incs_qr, {"q_interval": self._q_intervals} + return metrics.incs_qr, { + "q_interval": self._q_intervals, + "symmetric": self.symmetric, + } From a4b03443f1a0ddc3baf8f9ff8a4b84d007fa006c Mon Sep 17 00:00:00 2001 From: dennisbader Date: Mon, 30 Sep 2024 13:19:56 +0200 Subject: [PATCH 40/78] remove old code --- darts/models/cp/conformal_model.py | 238 +++-------------------------- 1 file changed, 25 insertions(+), 213 deletions(-) diff --git a/darts/models/cp/conformal_model.py b/darts/models/cp/conformal_model.py index 4dbf79063a..4c827992fd 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/cp/conformal_model.py @@ -40,36 +40,6 @@ logger = get_logger(__name__) -def cqr_score_sym(row, quantile_lo_col, quantile_hi_col): - return ( - [None, None] - if row[quantile_lo_col] is None or row[quantile_hi_col] is None - else [ - max(row[quantile_lo_col] - row["y"], row["y"] - row[quantile_hi_col]), - 0 - if row[quantile_lo_col] - row["y"] > row["y"] - row[quantile_hi_col] - else 1, - ] - ) - - -def cqr_score_asym(row, quantile_lo_col, quantile_hi_col): - return ( - [None, None] - if row[quantile_lo_col] is None or row[quantile_hi_col] is None - else [ - row[quantile_lo_col] - row["y"], - row["y"] - row[quantile_hi_col], - 0 - if row[quantile_lo_col] - row["y"] > row["y"] - row[quantile_hi_col] - else 1, - ] - ) - - -# class NCScorer - - class ConformalModel(GlobalForecastingModel, ABC): def __init__( self, @@ -98,37 +68,27 @@ def __init__( _check_quantiles(quantiles) super().__init__(add_encoders=None) - self.model = model - + # quantiles and interval setup self.quantiles = quantiles - half_idx = len(quantiles) // 2 - self._q_intervals = [ + self.idx_median = quantiles.index(0.5) + self.interval_bounds = [ (q_l, q_h) - for q_l, q_h in zip(quantiles[:half_idx], quantiles[half_idx + 1 :][::-1]) + for q_l, q_h in zip( + quantiles[: self.idx_median], quantiles[self.idx_median + 1 :][::-1] + ) ] - self._quantiles_no_med = [q for q in quantiles if q != 0.5] - self._likelihood = "quantile" - - self.idx_q_med = int(len(self.quantiles) / 2) - self.intervals = np.array([ + self.interval_range = np.array([ q_high - q_low for q_high, q_low in zip( - self.quantiles[self.idx_q_med + 1 :][::-1], - self.quantiles[: self.idx_q_med], + self.quantiles[self.idx_median + 1 :][::-1], + self.quantiles[: self.idx_median], ) ]) - self.symmetric = symmetric - # if isinstance(alpha, float): - # self.symmetrical = True - # self.q_hats = pd.DataFrame(columns=["q_hat_sym"]) - # else: - # self.symmetrical = False - # self.alpha_lo, self.alpha_hi = alpha - # self.q_hats = pd.DataFrame(columns=["q_hat_lo", "q_hat_hi"]) - # self.noncon_scores = dict() - # self.alpha = alpha - # self.quantiles = quantiles + + # model setup + self.model = model + self._likelihood = "quantile" self._fit_called = True def fit( @@ -252,59 +212,6 @@ def predict( return cal_preds[0][0] else: return [cp[0] for cp in cal_preds] - # for step_number in range(1, self.n_forecasts + 1): - # # conformalize - # noncon_scores = self._get_nonconformity_scores(df_cal, step_number) - # q_hat = self._get_q_hat(df_cal, noncon_scores) - # y_hat_col = f"yhat{step_number}" - # y_hat_lo_col = f"{y_hat_col} {min(self.quantiles) * 100}%" - # y_hat_hi_col = f"{y_hat_col} {max(self.quantiles) * 100}%" - # if self.method == "naive" and self.symmetrical: - # q_hat_sym = q_hat["q_hat_sym"] - # df[y_hat_lo_col] = df[y_hat_col] - q_hat_sym - # df[y_hat_hi_col] = df[y_hat_col] + q_hat_sym - # elif self.method == "cqr" and self.symmetrical: - # q_hat_sym = q_hat["q_hat_sym"] - # df[y_hat_lo_col] = df[y_hat_lo_col] - q_hat_sym - # df[y_hat_hi_col] = df[y_hat_hi_col] + q_hat_sym - # elif self.method == "cqr" and not self.symmetrical: - # q_hat_lo = q_hat["q_hat_lo"] - # q_hat_hi = q_hat["q_hat_hi"] - # df[y_hat_lo_col] = df[y_hat_lo_col] - q_hat_lo - # df[y_hat_hi_col] = df[y_hat_hi_col] + q_hat_hi - # else: - # raise ValueError( - # f"Unknown conformal prediction method '{self.method}'. Please input either 'naive' or 'cqr'." - # ) - # if step_number == 1: - # # save nonconformity scores of the first timestep - # self.noncon_scores = noncon_scores - # - # # append the dictionary of q_hats to the dataframe based on the keys of the dictionary - # q_hat_df = pd.DataFrame([q_hat]) - # self.q_hats = pd.concat([self.q_hats, q_hat_df], ignore_index=True) - # - # # if show_all_PI is True, add the quantile regression prediction intervals - # if show_all_PI: - # df_quantiles = [col for col in df_qr.columns if "%" in col and f"yhat{step_number}" in col] - # df_add = df_qr[df_quantiles] - # - # if self.method == "naive": - # cp_lo_col = f"yhat{step_number} - qhat{step_number}" # e.g. yhat1 - qhat1 - # cp_hi_col = f"yhat{step_number} + qhat{step_number}" # e.g. yhat1 + qhat1 - # df.rename(columns={y_hat_lo_col: cp_lo_col, y_hat_hi_col: cp_hi_col}, inplace=True) - # elif self.method == "cqr": - # qr_lo_col = ( - # f"yhat{step_number} {max(self.quantiles) * 100}% - qhat{step_number}" #e.g. yhat1 95% - qhat1 - # ) - # qr_hi_col = ( - # f"yhat{step_number} {min(self.quantiles) * 100}% + qhat{step_number}" #e.g. yhat1 5% + qhat1 - # ) - # df.rename(columns={y_hat_lo_col: qr_lo_col, y_hat_hi_col: qr_hi_col}, inplace=True) - # - # df = pd.concat([df, df_add], axis=1, ignore_index=False) - # - # return df @_with_sanity_checks("_historical_forecasts_sanity_checks") def historical_forecasts( @@ -445,7 +352,7 @@ def backtest( for metric_ in metric: if metric_ in metrics.ALL_METRICS: if metric_ in metrics.Q_INTERVAL_METRICS: - metric_kwargs.append({"q_interval": self._q_intervals}) + metric_kwargs.append({"q_interval": self.interval_bounds}) elif metric_ not in metrics.NON_Q_METRICS: metric_kwargs.append({"q": self.quantiles}) else: @@ -509,7 +416,7 @@ def residuals( # make user's life easier by adding quantile intervals, or quantiles directly if metric_kwargs is None and metric in metrics.ALL_METRICS: if metric in metrics.Q_INTERVAL_METRICS: - metric_kwargs = {"q_interval": self._q_intervals} + metric_kwargs = {"q_interval": self.interval_bounds} elif metric not in metrics.NON_Q_METRICS: metric_kwargs = {"q": self.quantiles} else: @@ -562,7 +469,6 @@ def _calibrate_forecasts( # - num_samples # - predict_likelihood_parameters # - tqdm iterator over series - # - support for different CP algorithms metric, metric_kwargs = self._residuals_metric residuals = self.model.residuals( series=series if cal_series is None else cal_series, @@ -898,100 +804,6 @@ def _residuals_metric(self) -> Tuple[METRIC_TYPE, Optional[dict]]: """Gives the "per time step" metric and optional metric kwargs used to compute residuals / non-conformity scores.""" - def _get_nonconformity_scores(self, df_cal: pd.DataFrame, step_number: int) -> dict: - """Get the nonconformity scores using the given conformal prediction technique. - - Parameters - ---------- - df_cal : pd.DataFrame - calibration dataframe - step_number : int - i-th step ahead forecast - - Returns - ------- - Dict[str, np.ndarray] - dictionary with one entry (symmetrical) or two entries (asymmetrical) of nonconformity scores - - """ - y_hat_col = f"yhat{step_number}" - if self.method == "cqr": - # CQR nonconformity scoring function - quantile_lo = str(min(self.quantiles) * 100) - quantile_hi = str(max(self.quantiles) * 100) - quantile_lo_col = f"{y_hat_col} {quantile_lo}%" - quantile_hi_col = f"{y_hat_col} {quantile_hi}%" - if self.symmetrical: - scores_df = df_cal.apply( - cqr_score_sym, - axis=1, - result_type="expand", - quantile_lo_col=quantile_lo_col, - quantile_hi_col=quantile_hi_col, - ) - scores_df.columns = ["scores", "arg"] - noncon_scores = scores_df["scores"].values - else: # asymmetrical intervals - scores_df = df_cal.apply( - cqr_score_asym, - axis=1, - result_type="expand", - quantile_lo_col=quantile_lo_col, - quantile_hi_col=quantile_hi_col, - ) - scores_df.columns = ["scores_lo", "scores_hi", "arg"] - noncon_scores_lo = scores_df["scores_lo"].values - noncon_scores_hi = scores_df["scores_hi"].values - # Remove NaN values - noncon_scores_lo: Any = noncon_scores_lo[~pd.isnull(noncon_scores_lo)] - noncon_scores_hi: Any = noncon_scores_hi[~pd.isnull(noncon_scores_hi)] - # Sort - noncon_scores_lo.sort() - noncon_scores_hi.sort() - # return dict of nonconformity scores - return { - "noncon_scores_hi": noncon_scores_lo, - "noncon_scores_lo": noncon_scores_hi, - } - else: # self.method == "naive" - # Naive nonconformity scoring function - noncon_scores = abs(df_cal["y"] - df_cal[y_hat_col]).values - # Remove NaN values - noncon_scores: Any = noncon_scores[~pd.isnull(noncon_scores)] - # Sort - noncon_scores.sort() - - return {"noncon_scores": noncon_scores} - - def _get_q_hat(self, noncon_scores: dict) -> dict: - """Get the q_hat that is derived from the nonconformity scores. - - Parameters - ---------- - noncon_scores : dict - dictionary with one entry (symmetrical) or two entries (asymmetrical) of nonconformity scores - - Returns - ------- - Dict[str, float] - upper and lower q_hat value, or the one-sided prediction interval width - - """ - # Get the q-hat index and value - if self.method == "cqr" and self.symmetrical is False: - noncon_scores_lo = noncon_scores["noncon_scores_lo"] - noncon_scores_hi = noncon_scores["noncon_scores_hi"] - q_hat_idx_lo = int(len(noncon_scores_lo) * self.alpha_lo) - q_hat_idx_hi = int(len(noncon_scores_hi) * self.alpha_hi) - q_hat_lo = noncon_scores_lo[-q_hat_idx_lo] - q_hat_hi = noncon_scores_hi[-q_hat_idx_hi] - return {"q_hat_lo": q_hat_lo, "q_hat_hi": q_hat_hi} - else: - noncon_scores = noncon_scores["noncon_scores"] - q_hat_idx = int(len(noncon_scores) * self.alpha) - q_hat = noncon_scores[-q_hat_idx] - return {"q_hat_sym": q_hat} - def _cp_component_names(self, input_series) -> List[str]: return likelihood_component_names( input_series.components, quantile_names(self.quantiles) @@ -1130,7 +942,7 @@ def _calibrate_interval( """ if self.symmetric: # shape (forecast horizon, n components, n quantile intervals) - q_hat = np.quantile(residuals, q=self.intervals, axis=2).transpose(( + q_hat = np.quantile(residuals, q=self.interval_range, axis=2).transpose(( 1, 2, 0, @@ -1138,7 +950,7 @@ def _calibrate_interval( return -q_hat, q_hat[:, :, ::-1] # for asymmetric, use intervals `1 - alpha / 2` - intervals = 1 - (1 - self.intervals) / 2 + intervals = 1 - (1 - self.interval_range) / 2 n_comps = residuals.shape[1] res = np.concatenate([-residuals, residuals], axis=1) q_hat = np.quantile(res, q=intervals, axis=2).transpose((1, 2, 0)) @@ -1208,9 +1020,9 @@ def _calibrate_interval( """ # shape (forecast horizon, n components, n quantile intervals) n_comps = residuals.shape[1] // ( - len(self.intervals) * (1 + int(not self.symmetric)) + len(self.interval_range) * (1 + int(not self.symmetric)) ) - n_intervals = len(self.intervals) + n_intervals = len(self.interval_range) def q_hat_from_residuals(residuals_, intervals_): # is there a more efficient way? @@ -1227,13 +1039,13 @@ def q_hat_from_residuals(residuals_, intervals_): if self.symmetric: # symmetric has one nc-score per intervals - q_hat = q_hat_from_residuals(residuals, self.intervals) + q_hat = q_hat_from_residuals(residuals, self.interval_range) return -q_hat, q_hat[:, :, ::-1] else: # asymmetric has two nc-score per intervals (for lower and upper quantiles) half_idx = residuals.shape[1] // 2 # for asymmetric, use intervals `1 - alpha / 2` - intervals = 1 - (1 - self.intervals) / 2 + intervals = 1 - (1 - self.interval_range) / 2 q_hat_lo = q_hat_from_residuals(residuals[:, :half_idx], intervals) q_hat_hi = q_hat_from_residuals(residuals[:, half_idx:], intervals) return -q_hat_lo, q_hat_hi[:, :, ::-1] @@ -1249,9 +1061,9 @@ def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray] # shape (forecast horizon, n components, n quantiles) pred = np.concatenate( [ - pred[:, :, : self.idx_q_med] + q_hat[0], # lower quantiles - pred[:, :, self.idx_q_med : self.idx_q_med + 1], # model forecast - pred[:, :, self.idx_q_med + 1 :] + q_hat[1], # upper quantiles + pred[:, :, : self.idx_median] + q_hat[0], # lower quantiles + pred[:, :, self.idx_median : self.idx_median + 1], # model forecast + pred[:, :, self.idx_median + 1 :] + q_hat[1], # upper quantiles ], axis=2, ) @@ -1261,6 +1073,6 @@ def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray] @property def _residuals_metric(self) -> Tuple[METRIC_TYPE, Optional[dict]]: return metrics.incs_qr, { - "q_interval": self._q_intervals, + "q_interval": self.interval_bounds, "symmetric": self.symmetric, } From 0cc20ac4508f33f8bd8b51da6d769e711ed2568b Mon Sep 17 00:00:00 2001 From: dennisbader Date: Mon, 30 Sep 2024 15:53:49 +0200 Subject: [PATCH 41/78] add tests for asymetric naive mdoel --- .../forecasting/test_conformal_model.py | 158 ++++++++++++++---- 1 file changed, 128 insertions(+), 30 deletions(-) diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index ea900af760..ca6982a71b 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -8,7 +8,7 @@ from darts import TimeSeries, concatenate from darts.datasets import AirPassengersDataset -from darts.metrics import ae, ic, mic +from darts.metrics import ae, err, ic, mic from darts.models import ( ConformalNaiveModel, ConformalQRModel, @@ -43,13 +43,18 @@ def train_model( ): model_params = model_params or {} if model_type == "regression": - return LinearRegressionModel(**regr_kwargs, **model_params).fit(*args, **kwargs) - elif model_type == "regression_qr": + return LinearRegressionModel( + **regr_kwargs, + **model_params, + random_state=42, + ).fit(*args, **kwargs) + elif model_type in ["regression_prob", "regression_qr"]: return LinearRegressionModel( likelihood="quantile", quantiles=quantiles, **regr_kwargs, **model_params, + random_state=42, ).fit(*args, **kwargs) else: return NLinearModel(**torch_kwargs, **model_params).fit(*args, **kwargs) @@ -62,7 +67,6 @@ def train_model( {"quantiles": q}, "regression", ), - (ConformalQRModel, {"quantiles": q}, "regression_qr"), ] if TORCH_AVAILABLE: @@ -72,6 +76,11 @@ def train_model( "torch", )) +models_cls_kwargs_errs_prob = [ + (ConformalNaiveModel, {"quantiles": q}, "regression_prob"), + (ConformalQRModel, {"quantiles": q}, "regression_qr"), +] + class TestConformalModel: np.random.seed(42) @@ -668,15 +677,26 @@ def test_output_chunk_shift(self): @pytest.mark.parametrize( "config", - itertools.product( - [1, 3, 5], # horizon - [True, False], # univariate series - [True, False], # single series - [q, [0.2, 0.3, 0.5, 0.7, 0.8]], + list( + itertools.product( + [1, 3, 5], # horizon + [True, False], # univariate series + [True, False], # single series + [q, [0.2, 0.3, 0.5, 0.7, 0.8]], + ["regression", "regression_prob"], # model type + [True, False], # symmetric non-conformity score + ) ), ) def test_naive_conformal_model_predict(self, config): - """Verifies that naive conformal model computes the correct intervals + """Verifies that naive conformal model computes the correct intervals for: + - different horizons (smaller, equal, larger than ocl) + - uni/multivariate series + - single/multi series + - single/multi quantile intervals + - deterministic/probabilistic forecasting model + - symmetric/asymmetric non-conformity scores + The naive approach computes it as follows: - pred_upper = pred + q_interval(absolute error, past) @@ -686,16 +706,22 @@ def test_naive_conformal_model_predict(self, config): Where q_interval(absolute error) is the `q_hi - q_hi` quantile value of all historic absolute errors between `pred`, and the target series. """ - n, is_univar, is_single, quantiles = config + n, is_univar, is_single, quantiles, model_type, symmetric = config + # if symmetric or is_univar: + # return series = self.helper_prepare_series(is_univar, is_single) - model_fc = train_model(series) - pred_fc_list = model_fc.predict(n, series=series) - model = ConformalNaiveModel(model=model_fc, quantiles=quantiles) + pred_kwargs = {"num_samples": 1000} if model_type == "regression_prob" else {} + + model_fc = train_model(series, model_type=model_type, quantiles=q) + model = ConformalNaiveModel( + model=model_fc, quantiles=quantiles, symmetric=symmetric + ) + pred_fc_list = model.model.predict(n, series=series, **pred_kwargs) pred_cal_list = model.predict(n, series=series) pred_cal_list_with_cal = model.predict(n, series=series, cal_series=series) # compute the expected intervals - residuals_list = model_fc.residuals( + residuals_list = model.model.residuals( series, retrain=False, forecast_horizon=n, @@ -703,7 +729,9 @@ def test_naive_conformal_model_predict(self, config): last_points_only=False, stride=1, values_only=True, - metric=ae, # absolute error + metric=ae + if symmetric + else err, # absolute error for symmetric ncs, otherwise the error ) if is_single: pred_fc_list = [pred_fc_list] @@ -711,19 +739,17 @@ def test_naive_conformal_model_predict(self, config): residuals_list = [residuals_list] pred_cal_list_with_cal = [pred_cal_list_with_cal] - for pred_fc, pred_cal, residuals in zip( - pred_fc_list, pred_cal_list, residuals_list + for pred_fc, pred_cal, pred_cal_with_cal, residuals in zip( + pred_fc_list, pred_cal_list, pred_cal_list_with_cal, residuals_list ): residuals = np.concatenate(residuals[:-1], axis=2) pred_vals = pred_fc.all_values() pred_vals_expected = self.helper_compute_naive_pred_cal( - residuals, pred_vals, n, quantiles - ) - np.testing.assert_array_almost_equal( - pred_cal.all_values(), pred_vals_expected + residuals, pred_vals, n, quantiles, model_type, symmetric ) - assert pred_cal_list_with_cal == pred_cal_list + self.helper_compare_preds(pred_cal, pred_vals_expected, model_type) + self.helper_compare_preds(pred_cal_with_cal, pred_vals_expected, model_type) @pytest.mark.parametrize( "config", @@ -855,7 +881,13 @@ def test_naive_conformal_model_historical_forecasts(self, config): pred_vals = pred_fc.all_values() pred_vals_expected = self.helper_compute_naive_pred_cal( - residuals, pred_vals, n, quantiles, train_length=train_length + residuals, + pred_vals, + n, + quantiles, + train_length=train_length, + model_type="regression", + symmetric=True, ) np.testing.assert_array_almost_equal( pred_cal.all_values(), pred_vals_expected @@ -949,6 +981,41 @@ def test_naive_conformal_model_historical_forecasts(self, config): hfc_conf_lpo = concatenate([hfc[-1:] for hfc in hfc_conf], axis=0) assert hfc_lpo == hfc_conf_lpo + def test_probabilistic_historical_forecast(self): + """Checks correctness of naive conformal historical forecast from probabilistic fc model compared to + deterministic one, + """ + series = self.helper_prepare_series(False, False) + # forecasts from forecasting model + model_det = ConformalNaiveModel( + train_model(series, model_type="regression", quantiles=q), + quantiles=q, + ) + model_prob = ConformalNaiveModel( + train_model(series, model_type="regression_prob", quantiles=q), + quantiles=q, + ) + hfcs_det = model_det.historical_forecasts( + series, + forecast_horizon=2, + last_points_only=True, + stride=1, + ) + hfcs_prob = model_prob.historical_forecasts( + series, + forecast_horizon=2, + last_points_only=True, + stride=1, + ) + assert isinstance(hfcs_det, list) and len(hfcs_det) == 2 + assert isinstance(hfcs_prob, list) and len(hfcs_prob) == 2 + for hfc_det, hfc_prob in zip(hfcs_det, hfcs_prob): + assert hfc_det.columns.equals(hfc_prob.columns) + assert hfc_det.time_index.equals(hfc_prob.time_index) + self.helper_compare_preds( + hfc_prob, hfc_det.all_values(), model_type="regression_prob" + ) + def helper_prepare_series(self, is_univar, is_single): series = self.ts_pass_train if not is_univar: @@ -957,16 +1024,39 @@ def helper_prepare_series(self, is_univar, is_single): series = [series, series + 5] return series + def helper_compare_preds(self, cp_pred, pred_expected, model_type, tol_rel=0.1): + if model_type == "regression": + # deterministic fc model should give almost identical results + np.testing.assert_array_almost_equal(cp_pred.all_values(), pred_expected) + else: + # probabilistic fc models have some randomness + cp_pred_vals = cp_pred.all_values() + diffs_rel = np.abs((cp_pred_vals - pred_expected) / pred_expected) + assert (diffs_rel < tol_rel).all().all() + @staticmethod def helper_compute_naive_pred_cal( - residuals, pred_vals, n, quantiles, train_length=None + residuals, pred_vals, n, quantiles, model_type, symmetric, train_length=None ): + """Generates expected prediction results for naive conformal model from: + + - residuals and predictions from deterministic/probabilistic model + - any forecast horizon + - any quantile intervals + - symmetric/ asymmetric non-conformity scores + - any train length + """ train_length = train_length or 0 n_comps = pred_vals.shape[1] half_idx = len(quantiles) // 2 alphas = np.array(quantiles[half_idx + 1 :][::-1]) - np.array( quantiles[:half_idx] ) + if not symmetric: + alphas = 1 - (1 - alphas) / 2 + + if model_type == "regression_prob": + pred_vals = np.expand_dims(np.quantile(pred_vals, 0.5, axis=2), -1) pred_expected = [] for alpha_idx, alpha in enumerate(alphas): q_hats = [] @@ -979,16 +1069,24 @@ def helper_compute_naive_pred_cal( else: res_start = n - (idx + 1) res_n = residuals[idx][:, res_start:res_end] - q_hat_n = np.quantile(res_n, q=alpha, axis=1) - q_hats.append(q_hat_n) - q_hats = np.expand_dims(np.array(q_hats), -1) - # the prediciton interval is given by pred +/- q_hat + if symmetric: + # identical correction for upper and lower bounds + q_hat_n = np.quantile(res_n, q=alpha, axis=1) + q_hats.append((-q_hat_n, q_hat_n)) + else: + # correction separately for upper and lower bounds + q_hat_hi = np.quantile(res_n, q=alpha, axis=1) + q_hat_lo = np.quantile(-res_n, q=alpha, axis=1) + q_hats.append((-q_hat_lo, q_hat_hi)) + q_hats = np.array(q_hats).transpose(0, 2, 1) + # the prediction interval is given by pred +/- q_hat pred_vals_expected = [] for col_idx in range(n_comps): q_col = q_hats[:, col_idx] pred_col = pred_vals[:, col_idx] pred_col_expected = np.concatenate( - [pred_col - q_col, pred_col, pred_col + q_col], axis=1 + [pred_col + q_col[:, 0:1], pred_col, pred_col + q_col[:, 1:2]], + axis=1, ) pred_col_expected = np.expand_dims(pred_col_expected, 1) pred_vals_expected.append(pred_col_expected) From f6802f037adace6939bd0527e12993b1d5984a42 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Tue, 1 Oct 2024 09:30:56 +0200 Subject: [PATCH 42/78] add tests for cqr --- darts/metrics/metrics.py | 16 -- darts/models/__init__.py | 6 +- darts/models/cp/__init__.py | 0 darts/models/forecasting/__init__.py | 3 + .../conformal_models.py} | 190 ++++++++++------- .../forecasting/torch_forecasting_model.py | 3 - .../forecasting/test_conformal_model.py | 198 +++++++++++++----- .../forecasting/test_historical_forecasts.py | 20 +- docs/source/conf.py | 2 +- 9 files changed, 280 insertions(+), 158 deletions(-) delete mode 100644 darts/models/cp/__init__.py rename darts/models/{cp/conformal_model.py => forecasting/conformal_models.py} (89%) diff --git a/darts/metrics/metrics.py b/darts/metrics/metrics.py index c544d45183..7409b0e565 100644 --- a/darts/metrics/metrics.py +++ b/darts/metrics/metrics.py @@ -3824,10 +3824,6 @@ def ic( Same as for type `float` but for a sequence of series. List[np.ndarray] Same as for type `np.ndarray` but for a sequence of series. - - References - ---------- - .. [1] https://otexts.com/fpp3/distaccuracy.html """ y_true, y_pred = _get_values_or_raise( actual_series, @@ -3919,10 +3915,6 @@ def mic( Same as for type `float` but for a sequence of series. List[np.ndarray] Same as for type `np.ndarray` but for a sequence of series. - - References - ---------- - .. [1] https://otexts.com/fpp3/distaccuracy.html """ return np.nanmean( _get_wrapped_metric(ic, n_wrappers=3)( @@ -4030,10 +4022,6 @@ def incs_qr( Same as for type `float` but for a sequence of series. List[np.ndarray] Same as for type `np.ndarray` but for a sequence of series. - - References - ---------- - .. [1] https://otexts.com/fpp3/distaccuracy.html """ y_true, y_pred = _get_values_or_raise( actual_series, @@ -4132,10 +4120,6 @@ def mincs_qr( Same as for type `float` but for a sequence of series. List[np.ndarray] Same as for type `np.ndarray` but for a sequence of series. - - References - ---------- - .. [1] https://otexts.com/fpp3/distaccuracy.html """ return np.nanmean( _get_wrapped_metric(ic, n_wrappers=3)( diff --git a/darts/models/__init__.py b/darts/models/__init__.py index fedc7ca8bc..f4218c4ea8 100644 --- a/darts/models/__init__.py +++ b/darts/models/__init__.py @@ -109,8 +109,6 @@ XGBModel = NotImportedModule(module_name="XGBoost") # Conformal Prediction -from darts.models.cp.conformal_model import ConformalNaiveModel, ConformalQRModel - # Filtering from darts.models.filtering.gaussian_process_filter import GaussianProcessFilter from darts.models.filtering.kalman_filter import KalmanFilter @@ -118,6 +116,10 @@ # Ensembling from darts.models.forecasting.baselines import NaiveEnsembleModel +from darts.models.forecasting.conformal_models import ( + ConformalNaiveModel, + ConformalQRModel, +) from darts.models.forecasting.ensemble_model import EnsembleModel __all__ = [ diff --git a/darts/models/cp/__init__.py b/darts/models/cp/__init__.py deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/darts/models/forecasting/__init__.py b/darts/models/forecasting/__init__.py index 37a50aa4bc..b3559f9b62 100644 --- a/darts/models/forecasting/__init__.py +++ b/darts/models/forecasting/__init__.py @@ -50,4 +50,7 @@ Ensemble Models (`GlobalForecastingModel `_) - :class:`~darts.models.forecasting.baselines.NaiveEnsembleModel` - :class:`~darts.models.forecasting.regression_ensemble_model.RegressionEnsembleModel` +Conformal Models (`GlobalForecastingModel `_) + - :class:`~darts.models.forecasting.conformal_models.ConformalNaiveModel` + - :class:`~darts.models.forecasting.conformal_models.ConformalQRModel` """ diff --git a/darts/models/cp/conformal_model.py b/darts/models/forecasting/conformal_models.py similarity index 89% rename from darts/models/cp/conformal_model.py rename to darts/models/forecasting/conformal_models.py index 4c827992fd..feec10a6a0 100644 --- a/darts/models/cp/conformal_model.py +++ b/darts/models/forecasting/conformal_models.py @@ -1,3 +1,11 @@ +""" +Conformal Models +--------------- + +A collection of conformal prediction models for pre-trained global forecasting models. +""" + +import copy import os from abc import ABC, abstractmethod from typing import Any, BinaryIO, Callable, Dict, List, Optional, Sequence, Tuple, Union @@ -46,6 +54,8 @@ def __init__( model: GlobalForecastingModel, quantiles: List[float], symmetric: bool = True, + cal_length: Optional[int] = None, + num_samples: int = 500, ): """Base Conformal Prediction Model. @@ -59,6 +69,13 @@ def __init__( symmetric Whether to use symmetric non-conformity scores. If `False`, uses asymmetric scores (individual scores for lower- and upper quantile interval bounds). + cal_length + The number of past forecast residuals/errors to consider as calibration input for each conformal forecast. + If `None`, considers all past residuals. + num_samples + Number of times a prediction is sampled from the underlying `model` if it is probabilistic. Uses `1` for + deterministic models. This is different to the `num_samples` produced by the conformal model which can be + set in downstream forecasting tasks. """ if not isinstance(model, GlobalForecastingModel) or not model._fit_called: raise_log( @@ -84,10 +101,18 @@ def __init__( self.quantiles[: self.idx_median], ) ]) + if symmetric: + # symmetric considers both tails together + self.interval_range_sym = copy.deepcopy(self.interval_range) + else: + # asymmetric considers tails separately + self.interval_range_sym = 1 - (1 - self.interval_range) / 2 self.symmetric = symmetric # model setup self.model = model + self.cal_length = cal_length + self.num_samples = num_samples if model.supports_probabilistic_prediction else 1 self._likelihood = "quantile" self._fit_called = True @@ -172,11 +197,10 @@ def predict( series=series, past_covariates=past_covariates, future_covariates=future_covariates, - # num_samples=num_samples, + num_samples=self.num_samples, verbose=verbose, predict_likelihood_parameters=predict_likelihood_parameters, show_warnings=show_warnings, - **self._get_forecast_params(), ) # convert to multi series case with `last_points_only=False` preds = [[pred] for pred in preds] @@ -186,7 +210,7 @@ def predict( series=cal_series, past_covariates=cal_past_covariates, future_covariates=cal_future_covariates, - # num_samples=num_samples, + num_samples=self.num_samples, forecast_horizon=n, retrain=False, overlap_end=True, @@ -194,7 +218,6 @@ def predict( verbose=verbose, show_warnings=show_warnings, predict_likelihood_parameters=predict_likelihood_parameters, - **self._get_forecast_params(), ) cal_preds = self._calibrate_forecasts( series=series, @@ -262,7 +285,7 @@ def historical_forecasts( series=series, past_covariates=past_covariates, future_covariates=future_covariates, - # num_samples=num_samples, + num_samples=self.num_samples, forecast_horizon=forecast_horizon, retrain=False, overlap_end=overlap_end, @@ -273,7 +296,6 @@ def historical_forecasts( enable_optimization=enable_optimization, fit_kwargs=fit_kwargs, predict_kwargs=predict_kwargs, - **self._get_forecast_params(), ) # optionally, generate calibration forecasts if cal_series is None: @@ -283,7 +305,7 @@ def historical_forecasts( series=cal_series, past_covariates=cal_past_covariates, future_covariates=cal_future_covariates, - # num_samples=num_samples, + num_samples=self.num_samples, forecast_horizon=forecast_horizon, retrain=False, overlap_end=True, @@ -294,14 +316,12 @@ def historical_forecasts( enable_optimization=enable_optimization, fit_kwargs=fit_kwargs, predict_kwargs=predict_kwargs, - **self._get_forecast_params(), ) calibrated_forecasts = self._calibrate_forecasts( series=series, forecasts=hfcs, cal_series=cal_series, cal_forecasts=cal_hfcs, - train_length=train_length, start=start, start_format=start_format, forecast_horizon=forecast_horizon, @@ -455,7 +475,6 @@ def _calibrate_forecasts( cal_forecasts: Optional[ Union[Sequence[Sequence[TimeSeries]], Sequence[TimeSeries]] ] = None, - train_length: Optional[int] = None, start: Optional[Union[pd.Timestamp, float, int]] = None, start_format: Literal["position", "value"] = "value", forecast_horizon: int = 1, @@ -469,6 +488,7 @@ def _calibrate_forecasts( # - num_samples # - predict_likelihood_parameters # - tqdm iterator over series + cal_length = self.cal_length metric, metric_kwargs = self._residuals_metric residuals = self.model.residuals( series=series if cal_series is None else cal_series, @@ -497,8 +517,8 @@ def _calibrate_forecasts( last_hfc = s_hfcs if last_points_only else s_hfcs[-1] # compute the minimum required number of useful calibration residuals - # at least one or `train_length` examples - min_n_cal = train_length or 1 + # at least one or `cal_length` examples + min_n_cal = cal_length or 1 # `last_points_only=False` requires additional examples to use most recent information # from all steps in the horizon if not last_points_only: @@ -508,9 +528,9 @@ def _calibrate_forecasts( if cal_series is None: # we need at least one residual per point in the horizon prior to the first conformal forecast first_idx_train = forecast_horizon + self.output_chunk_shift - # plus some additional examples based on `train_length` - if train_length is not None: - first_idx_train += train_length - 1 + # plus some additional examples based on `cal_length` + if cal_length is not None: + first_idx_train += cal_length - 1 # check if later we need to drop some residuals without useful information (unknown residuals) if overlap_end: delta_end = n_steps_between( @@ -654,8 +674,8 @@ def _calibrate_forecasts( q_hat = None if cal_series is not None: - if train_length is not None: - res = res[:, :, -train_length:] + if cal_length is not None: + res = res[:, :, -cal_length:] q_hat = self._calibrate_interval(res) def conformal_predict(idx_, pred_vals_): @@ -670,11 +690,9 @@ def conformal_predict(idx_, pred_vals_): + idx_ * stride - (forecast_horizon + self.output_chunk_shift - 1) ) - # first residual index is shifted back by the horizon to get `train_length` points for + # first residual index is shifted back by the horizon to get `cal_length` points for # the last point in the horizon - cal_start = ( - cal_end - train_length if train_length is not None else None - ) + cal_start = cal_end - cal_length if cal_length is not None else None cal_res = res[:, :, cal_start:cal_end] q_hat_ = self._calibrate_interval(cal_res) @@ -684,6 +702,7 @@ def conformal_predict(idx_, pred_vals_): return self._apply_interval(pred_vals_, q_hat_) # historical conformal prediction + # for each forecast, compute calibrated quantile intervals based on past residuals if last_points_only: for idx, pred_vals in enumerate( s_hfcs.all_values(copy=False)[first_fc_idx:last_fc_idx:stride] @@ -699,7 +718,7 @@ def conformal_predict(idx_, pred_vals_): start=s_hfcs._time_index[first_fc_idx], length=len(cp_preds), freq=series_.freq * stride, - name=series_.time_index.name, + name=series_._time_index.name, ), with_static_covs=False, with_hierarchy=False, @@ -779,22 +798,24 @@ def load(path: Union[str, os.PathLike, BinaryIO]) -> "ConformalModel": model.model = TorchForecastingModel.load(path_tfm) return model - def _get_forecast_params(self): - if self.model.supports_probabilistic_prediction: - return {"num_samples": 500} - else: - return {"num_samples": 1} - @abstractmethod def _calibrate_interval( self, residuals: np.ndarray ) -> Tuple[np.ndarray, np.ndarray]: - """Computes the upper and lower calibrated forecast intervals based on residuals.""" + """Computes the lower and upper calibrated forecast intervals based on residuals. + + Parameters + ---------- + residuals + The residuals are expected to have shape (horizon, n components, n historical forecasts * n samples) + """ @abstractmethod def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray]): - """Implements the logic to apply the calibrated interval to the predicted values. - Must return an array with shape (n times, n components * n quantiles, 1). + """Applies the calibrated interval to the predicted quantiles. Returns an array with `len(quantiles)` + conformalized quantile predictions (lower quantiles, model forecast, upper quantiles) per component. + + E.g. output is `(target1_q1, target1_pred, target1_q2, target2_q1, ...)` """ pass @@ -805,6 +826,7 @@ def _residuals_metric(self) -> Tuple[METRIC_TYPE, Optional[dict]]: non-conformity scores.""" def _cp_component_names(self, input_series) -> List[str]: + """Gives the component names for generated forecasts.""" return likelihood_component_names( input_series.components, quantile_names(self.quantiles) ) @@ -844,6 +866,7 @@ def min_train_series_length(self) -> int: def min_train_samples(self) -> int: raise NotImplementedError(f"not supported by `{self.__class__.__name__}`.") + @property def supports_multivariate(self) -> bool: return self.model.supports_multivariate @@ -914,6 +937,8 @@ def __init__( model: GlobalForecastingModel, quantiles: List[float], symmetric: bool = True, + cal_length: Optional[int] = None, + num_samples: int = 500, ): """Naive Conformal Prediction Model. @@ -925,44 +950,45 @@ def __init__( A list of quantiles centered around the median `q=0.5` to use. For example quantiles [0.1, 0.5, 0.9] correspond to a (0.9 - 0.1) = 80% coverage interval around the median (model forecast). symmetric - Whether to use symmetric non-conformity scores. If `False`, uses asymmetric scores (individual scores - for lower- and upper quantile interval bounds). + Whether to use symmetric non-conformity scores. If `True`, uses metric `ae()` (see + :func:`~darts.metrics.metrics.ae`) to compute the non-conformity scores. If `False`, uses metric `-err()` + (see :func:`~darts.metrics.metrics.err`) for the lower, and `err()` for the upper quantile interval bound. + cal_length + The number of past forecast residuals/errors to consider as calibration input for each conformal forecast. + If `None`, considers all past residuals. + num_samples + Number of times a prediction is sampled from the underlying `model` if it is probabilistic. Uses `1` for + deterministic models. This is different to the `num_samples` produced by the conformal model which can be + set in downstream forecasting tasks. """ - super().__init__(model=model, quantiles=quantiles, symmetric=symmetric) + super().__init__( + model=model, + quantiles=quantiles, + symmetric=symmetric, + cal_length=cal_length, + num_samples=num_samples, + ) def _calibrate_interval( self, residuals: np.ndarray ) -> Tuple[np.ndarray, np.ndarray]: - """Computes the lower and upper calibrated forecast intervals based on residuals. - - Parameters - ---------- - residuals - The residuals are expected to have shape (horizon, n components, n historical forecasts * n samples) - """ if self.symmetric: # shape (forecast horizon, n components, n quantile intervals) - q_hat = np.quantile(residuals, q=self.interval_range, axis=2).transpose(( + q_hat = np.quantile(residuals, q=self.interval_range_sym, axis=2).transpose(( 1, 2, 0, )) return -q_hat, q_hat[:, :, ::-1] - # for asymmetric, use intervals `1 - alpha / 2` - intervals = 1 - (1 - self.interval_range) / 2 + # asymmetric n_comps = residuals.shape[1] res = np.concatenate([-residuals, residuals], axis=1) - q_hat = np.quantile(res, q=intervals, axis=2).transpose((1, 2, 0)) + q_hat = np.quantile(res, q=self.interval_range_sym, axis=2).transpose((1, 2, 0)) return -q_hat[:, :n_comps, :], q_hat[:, n_comps:, ::-1] def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray]): - """Applies the calibrated interval to the predicted values. Returns an array with `len(quantiles)` - conformalized quantile predictions (lower quantiles, model forecast, upper quantiles) per component. - - E.g. output is `(target1_q1, target1_pred, target1_q2, target2_q1, ...)` - """ - # stochastic predictions + # convert stochastic predictions to median if pred.shape[2] != 1: pred = np.expand_dims(np.quantile(pred, 0.5, axis=2), -1) # shape (forecast horizon, n components, n quantiles) @@ -972,10 +998,7 @@ def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray] @property def _residuals_metric(self) -> Tuple[METRIC_TYPE, Optional[dict]]: - if self.symmetric: - return metrics.ae, None - else: - return metrics.err, None + return (metrics.ae if self.symmetric else metrics.err), None class ConformalQRModel(ConformalModel): @@ -984,6 +1007,8 @@ def __init__( model: GlobalForecastingModel, quantiles: List[float], symmetric: bool = True, + cal_length: Optional[int] = None, + num_samples: int = 500, ): """Conformalized Quantile Regression Model. @@ -995,8 +1020,17 @@ def __init__( A list of quantiles centered around the median `q=0.5` to use. For example quantiles [0.1, 0.5, 0.9] correspond to a (0.9 - 0.1) = 80% coverage interval around the median (model forecast). symmetric - Whether to use symmetric non-conformity scores. If `False`, uses asymmetric scores (individual scores - for lower- and upper quantile interval bounds). + Whether to use symmetric non-conformity scores. If `True`, uses symmetric metric + `incs_qr(..., symmetric=True)` (see :func:`~darts.metrics.metrics.incs_qr`) to compute the non-conformity + scores. If `False`, uses asymmetric metric `incs_qr(..., symmetric=False)` with individual scores for the + lower- and upper quantile interval bounds. + cal_length + The number of past forecast residuals/errors to consider as calibration input for each conformal forecast. + If `None`, considers all past residuals. + num_samples + Number of times a prediction is sampled from the underlying `model` if it is probabilistic. Uses `1` for + deterministic models. This is different to the `num_samples` produced by the conformal model which can be + set in downstream forecasting tasks. """ if not model.supports_probabilistic_prediction: raise_log( @@ -1006,27 +1040,29 @@ def __init__( ), logger=logger, ) - super().__init__(model=model, quantiles=quantiles, symmetric=symmetric) + super().__init__( + model=model, + quantiles=quantiles, + symmetric=symmetric, + cal_length=cal_length, + num_samples=num_samples, + ) def _calibrate_interval( self, residuals: np.ndarray ) -> Tuple[np.ndarray, np.ndarray]: - """Computes the lower and upper calibrated forecast intervals based on residuals. - - Parameters - ---------- - residuals - The residuals are expected to have shape (horizon, n components, n historical forecasts * n samples) - """ - # shape (forecast horizon, n components, n quantile intervals) n_comps = residuals.shape[1] // ( len(self.interval_range) * (1 + int(not self.symmetric)) ) n_intervals = len(self.interval_range) - def q_hat_from_residuals(residuals_, intervals_): - # is there a more efficient way? - q_hat_tmp = np.quantile(residuals_, q=intervals_, axis=2).transpose(( + def q_hat_from_residuals(residuals_): + # TODO: is there a more efficient way? + # compute quantiles with shape (horizon, n components, n quantile intervals) + # over all past residuals + q_hat_tmp = np.quantile( + residuals_, q=self.interval_range_sym, axis=2 + ).transpose(( 1, 2, 0, @@ -1039,23 +1075,19 @@ def q_hat_from_residuals(residuals_, intervals_): if self.symmetric: # symmetric has one nc-score per intervals - q_hat = q_hat_from_residuals(residuals, self.interval_range) + # residuals shape (horizon, n components * n intervals, n past forecasts) + q_hat = q_hat_from_residuals(residuals) return -q_hat, q_hat[:, :, ::-1] else: # asymmetric has two nc-score per intervals (for lower and upper quantiles) + # lower and upper residuals are concatenated along axis=1; + # residuals shape (horizon, n components * n intervals * 2, n past forecasts) half_idx = residuals.shape[1] // 2 - # for asymmetric, use intervals `1 - alpha / 2` - intervals = 1 - (1 - self.interval_range) / 2 - q_hat_lo = q_hat_from_residuals(residuals[:, :half_idx], intervals) - q_hat_hi = q_hat_from_residuals(residuals[:, half_idx:], intervals) + q_hat_lo = q_hat_from_residuals(residuals[:, :half_idx]) + q_hat_hi = q_hat_from_residuals(residuals[:, half_idx:]) return -q_hat_lo, q_hat_hi[:, :, ::-1] def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray]): - """Applies the calibrated interval to the predicted quantiles. Returns an array with `len(quantiles)` - conformalized quantile predictions (lower quantiles, model forecast, upper quantiles) per component. - - E.g. output is `(target1_q1, target1_pred, target1_q2, target2_q1, ...)` - """ # get quantile predictions with shape (n times, n components, n quantiles) pred = np.quantile(pred, self.quantiles, axis=2).transpose((1, 2, 0)) # shape (forecast horizon, n components, n quantiles) diff --git a/darts/models/forecasting/torch_forecasting_model.py b/darts/models/forecasting/torch_forecasting_model.py index 1f2797f40d..f6194d15f4 100644 --- a/darts/models/forecasting/torch_forecasting_model.py +++ b/darts/models/forecasting/torch_forecasting_model.py @@ -14,9 +14,6 @@ as well as past and future values of some future covariates. * SplitCovariatesTorchModel(TorchForecastingModel) for torch models consuming past-observed as well as future values of some future covariates. - - * TorchParametricProbabilisticForecastingModel(TorchForecastingModel) is the super-class of all probabilistic torch - forecasting models. """ import copy diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index ca6982a71b..a7da81a082 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -8,7 +8,7 @@ from darts import TimeSeries, concatenate from darts.datasets import AirPassengersDataset -from darts.metrics import ae, err, ic, mic +from darts.metrics import ae, err, ic, incs_qr, mic from darts.models import ( ConformalNaiveModel, ConformalQRModel, @@ -76,13 +76,15 @@ def train_model( "torch", )) -models_cls_kwargs_errs_prob = [ - (ConformalNaiveModel, {"quantiles": q}, "regression_prob"), - (ConformalQRModel, {"quantiles": q}, "regression_qr"), -] - class TestConformalModel: + """ + Tests all general model behavior for Naive Conformal Model with symmetric non-conformity score. + Additionally, checks correctness of predictions for: + - ConformalNaiveModel with symmetric & asymmetric non-conformity scores + - ConformaQRlModel with symmetric & asymmetric non-conformity scores + """ + np.random.seed(42) # forecasting horizon used in runnability tests @@ -125,7 +127,7 @@ class TestConformalModel: pd.DataFrame([[0, 1], [2, 3]], columns=["st1", "st2"]) ) - def test_model_construction(self): + def test_model_construction_naive(self): local_model = NaiveSeasonal(K=5) global_model = LinearRegressionModel(**regr_kwargs) series = self.ts_pass_train @@ -168,6 +170,28 @@ def test_model_construction(self): ConformalNaiveModel(model=global_model, quantiles=[-0.1, 0.5, 1.1]) assert str(exc.value) == "All provided quantiles must be between 0 and 1." + def test_model_construction_cqr(self): + model_det = train_model(self.ts_pass_train, model_type="regression") + model_prob_q = train_model( + self.ts_pass_train, model_type="regression_prob", quantiles=q + ) + model_prob_poisson = train_model( + self.ts_pass_train, + model_type="regression", + model_params={"likelihood": "poisson"}, + ) + + # deterministic global model + with pytest.raises(ValueError) as exc: + ConformalQRModel(model=model_det, quantiles=q) + assert str(exc.value).startswith( + "`model` must must support probabilistic forecasting." + ) + # probabilistic model works + _ = ConformalQRModel(model=model_prob_q, quantiles=q) + # works also with different likelihood + _ = ConformalQRModel(model=model_prob_poisson, quantiles=q) + @pytest.mark.parametrize("config", models_cls_kwargs_errs) def test_save_model_parameters(self, config): # model creation parameters were saved before. check if re-created model has same params as original @@ -683,18 +707,24 @@ def test_output_chunk_shift(self): [True, False], # univariate series [True, False], # single series [q, [0.2, 0.3, 0.5, 0.7, 0.8]], - ["regression", "regression_prob"], # model type + [ + (ConformalNaiveModel, "regression"), + (ConformalNaiveModel, "regression_prob"), + (ConformalQRModel, "regression_qr"), + ], # model type [True, False], # symmetric non-conformity score + [None, 1], # train length ) ), ) - def test_naive_conformal_model_predict(self, config): + def test_conformal_model_predict_accuracy(self, config): """Verifies that naive conformal model computes the correct intervals for: - different horizons (smaller, equal, larger than ocl) - uni/multivariate series - single/multi series - single/multi quantile intervals - deterministic/probabilistic forecasting model + - naive conformal and conformalized quantile regression - symmetric/asymmetric non-conformity scores The naive approach computes it as follows: @@ -706,20 +736,44 @@ def test_naive_conformal_model_predict(self, config): Where q_interval(absolute error) is the `q_hi - q_hi` quantile value of all historic absolute errors between `pred`, and the target series. """ - n, is_univar, is_single, quantiles, model_type, symmetric = config - # if symmetric or is_univar: - # return + ( + n, + is_univar, + is_single, + quantiles, + (model_cls, model_type), + symmetric, + cal_length, + ) = config + idx_med = quantiles.index(0.5) + q_intervals = [ + (q_hi, q_lo) + for q_hi, q_lo in zip(quantiles[:idx_med], quantiles[idx_med + 1 :][::-1]) + ] series = self.helper_prepare_series(is_univar, is_single) - pred_kwargs = {"num_samples": 1000} if model_type == "regression_prob" else {} + pred_kwargs = ( + {"num_samples": 1000} + if model_type in ["regression_prob", "regression_qr"] + else {} + ) model_fc = train_model(series, model_type=model_type, quantiles=q) - model = ConformalNaiveModel( - model=model_fc, quantiles=quantiles, symmetric=symmetric + model = model_cls( + model=model_fc, + quantiles=quantiles, + symmetric=symmetric, + cal_length=cal_length, ) pred_fc_list = model.model.predict(n, series=series, **pred_kwargs) pred_cal_list = model.predict(n, series=series) pred_cal_list_with_cal = model.predict(n, series=series, cal_series=series) + if issubclass(model_cls, ConformalNaiveModel): + metric = ae if symmetric else err + metric_kwargs = {} + else: + metric = incs_qr + metric_kwargs = {"q_interval": q_intervals, "symmetric": symmetric} # compute the expected intervals residuals_list = model.model.residuals( series, @@ -729,9 +783,9 @@ def test_naive_conformal_model_predict(self, config): last_points_only=False, stride=1, values_only=True, - metric=ae - if symmetric - else err, # absolute error for symmetric ncs, otherwise the error + metric=metric, + metric_kwargs=metric_kwargs, + **pred_kwargs, ) if is_single: pred_fc_list = [pred_fc_list] @@ -745,8 +799,14 @@ def test_naive_conformal_model_predict(self, config): residuals = np.concatenate(residuals[:-1], axis=2) pred_vals = pred_fc.all_values() - pred_vals_expected = self.helper_compute_naive_pred_cal( - residuals, pred_vals, n, quantiles, model_type, symmetric + pred_vals_expected = self.helper_compute_pred_cal( + residuals, + pred_vals, + n, + quantiles, + model_type, + symmetric, + cal_length=cal_length, ) self.helper_compare_preds(pred_cal, pred_vals_expected, model_type) self.helper_compare_preds(pred_cal_with_cal, pred_vals_expected, model_type) @@ -772,7 +832,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): - with and without training length - with and without covariates in the forecast and calibration sets. """ - n, is_univar, is_single, ocs, train_length, use_covs, quantiles = config + n, is_univar, is_single, ocs, cal_length, use_covs, quantiles = config n_q = len(quantiles) half_idx = n_q // 2 if ocs and n > OUT_LEN: @@ -835,7 +895,9 @@ def test_naive_conformal_model_historical_forecasts(self, config): ) # conformal forecasts - model = ConformalNaiveModel(model=model_fc, quantiles=quantiles) + model = ConformalNaiveModel( + model=model_fc, quantiles=quantiles, cal_length=cal_length + ) # without calibration set hfc_conf_list = model.historical_forecasts( series=series, @@ -843,7 +905,6 @@ def test_naive_conformal_model_historical_forecasts(self, config): overlap_end=True, last_points_only=False, stride=1, - train_length=train_length, **covs_kwargs, ) # with calibration set and covariates that can generate all calibration forecasts in the overlap @@ -853,7 +914,6 @@ def test_naive_conformal_model_historical_forecasts(self, config): overlap_end=True, last_points_only=False, stride=1, - train_length=train_length, cal_series=series, **covs_kwargs, **cal_covs_kwargs_overlap, @@ -880,12 +940,12 @@ def test_naive_conformal_model_historical_forecasts(self, config): ) pred_vals = pred_fc.all_values() - pred_vals_expected = self.helper_compute_naive_pred_cal( + pred_vals_expected = self.helper_compute_pred_cal( residuals, pred_vals, n, quantiles, - train_length=train_length, + cal_length=cal_length, model_type="regression", symmetric=True, ) @@ -916,7 +976,6 @@ def test_naive_conformal_model_historical_forecasts(self, config): overlap_end=True, last_points_only=False, stride=1, - train_length=train_length, cal_series=series, **covs_kwargs, **cal_covs_kwargs_exact, @@ -929,7 +988,6 @@ def test_naive_conformal_model_historical_forecasts(self, config): overlap_end=True, last_points_only=False, stride=1, - train_length=train_length, cal_series=series, **covs_kwargs, **cal_covs_kwargs_short, @@ -955,7 +1013,6 @@ def test_naive_conformal_model_historical_forecasts(self, config): overlap_end=True, last_points_only=True, stride=1, - train_length=train_length, **covs_kwargs, ) hfc_lpo_list_with_cal = model.historical_forecasts( @@ -964,7 +1021,6 @@ def test_naive_conformal_model_historical_forecasts(self, config): overlap_end=True, last_points_only=True, stride=1, - train_length=train_length, cal_series=series, **covs_kwargs, **cal_covs_kwargs_overlap, @@ -1035,8 +1091,8 @@ def helper_compare_preds(self, cp_pred, pred_expected, model_type, tol_rel=0.1): assert (diffs_rel < tol_rel).all().all() @staticmethod - def helper_compute_naive_pred_cal( - residuals, pred_vals, n, quantiles, model_type, symmetric, train_length=None + def helper_compute_pred_cal( + residuals, pred_vals, n, quantiles, model_type, symmetric, cal_length=None ): """Generates expected prediction results for naive conformal model from: @@ -1046,17 +1102,25 @@ def helper_compute_naive_pred_cal( - symmetric/ asymmetric non-conformity scores - any train length """ - train_length = train_length or 0 + cal_length = cal_length or 0 n_comps = pred_vals.shape[1] half_idx = len(quantiles) // 2 + + # get alphas from quantiles (alpha = q_hi - q_lo) per interval alphas = np.array(quantiles[half_idx + 1 :][::-1]) - np.array( quantiles[:half_idx] ) if not symmetric: + # asymmetric non-conformity scores look only on one tail -> alpha/2 alphas = 1 - (1 - alphas) / 2 - if model_type == "regression_prob": + # naive conformal model converts probabilistic forecasts to median (deterministic) pred_vals = np.expand_dims(np.quantile(pred_vals, 0.5, axis=2), -1) + elif model_type == "regression_qr": + # conformalized quantile regression consumes quantile forecasts + pred_vals = np.quantile(pred_vals, quantiles, axis=2).transpose(1, 2, 0) + + is_naive = model_type in ["regression", "regression_prob"] pred_expected = [] for alpha_idx, alpha in enumerate(alphas): q_hats = [] @@ -1064,28 +1128,68 @@ def helper_compute_naive_pred_cal( # forecasts and the target series) for idx in range(n): res_end = residuals.shape[2] - idx - if train_length: - res_start = res_end - train_length + if cal_length: + res_start = res_end - cal_length else: res_start = n - (idx + 1) res_n = residuals[idx][:, res_start:res_end] - if symmetric: + if is_naive and symmetric: # identical correction for upper and lower bounds + # metric is `ae()` q_hat_n = np.quantile(res_n, q=alpha, axis=1) q_hats.append((-q_hat_n, q_hat_n)) - else: + elif is_naive: # correction separately for upper and lower bounds + # metric is `err()` q_hat_hi = np.quantile(res_n, q=alpha, axis=1) q_hat_lo = np.quantile(-res_n, q=alpha, axis=1) q_hats.append((-q_hat_lo, q_hat_hi)) - q_hats = np.array(q_hats).transpose(0, 2, 1) + elif symmetric: # CQR symmetric + # identical correction for upper and lower bounds + # metric is `incs_qr(symmetric=True)` + q_hat_n = np.quantile(res_n, q=alpha, axis=1) + q_hats.append((-q_hat_n, q_hat_n)) + else: # CQR asymmetric + # correction separately for upper and lower bounds + # metric is `incs_qr(symmetric=False)` + half_idx = len(res_n) // 2 + + # residuals have shape (n components * n intervals * 2) + # the factor 2 comes from the metric being computed for lower, and upper bounds separately + # (comp_1_qlow_1, comp_1_qlow_2, ... comp_n_qlow_m, comp_1_qhigh_1, ...) + q_hat_lo = np.quantile(res_n[:half_idx], q=alpha, axis=1) + q_hat_hi = np.quantile(res_n[half_idx:], q=alpha, axis=1) + q_hats.append(( + -q_hat_lo[alpha_idx :: len(alphas)], + q_hat_hi[alpha_idx :: len(alphas)], + )) + # bring to shape (horizon, n components, 2) + q_hats = np.array(q_hats).transpose((0, 2, 1)) # the prediction interval is given by pred +/- q_hat pred_vals_expected = [] for col_idx in range(n_comps): q_col = q_hats[:, col_idx] pred_col = pred_vals[:, col_idx] + if is_naive: + # conformal model corrects deterministic predictions + idx_q_lo = slice(0, None) + idx_q_med = slice(0, None) + idx_q_hi = slice(0, None) + else: + # conformal model corrects quantile predictions + idx_q_lo = slice(alpha_idx, alpha_idx + 1) + idx_q_med = slice(len(alphas), len(alphas) + 1) + idx_q_hi = slice( + pred_col.shape[1] - (alpha_idx + 1), + pred_col.shape[1] - alpha_idx, + ) + # correct lower and upper bounds pred_col_expected = np.concatenate( - [pred_col + q_col[:, 0:1], pred_col, pred_col + q_col[:, 1:2]], + [ + pred_col[:, idx_q_lo] + q_col[:, :1], # lower quantile + pred_col[:, idx_q_med], # median forecast + pred_col[:, idx_q_hi] + q_col[:, 1:], + ], # upper quantile axis=1, ) pred_col_expected = np.expand_dims(pred_col_expected, 1) @@ -1214,7 +1318,7 @@ def test_too_short_input_hfc(self, config): ( last_points_only, overlap_end, - train_length, + cal_length, ocs, n, use_covs, @@ -1225,10 +1329,10 @@ def test_too_short_input_hfc(self, config): icl = IN_LEN ocl = OUT_LEN horizon_ocs = n + ocs - add_train_length = train_length - 1 if train_length is not None else 0 + add_cal_length = cal_length - 1 if cal_length is not None else 0 # min length to generate 1 conformal forecast min_len_val_series = ( - icl + horizon_ocs * (1 + int(not overlap_end)) + add_train_length + icl + horizon_ocs * (1 + int(not overlap_end)) + add_cal_length ) series_train = [tg.linear_timeseries(length=icl + ocl + ocs)] * 2 @@ -1244,7 +1348,7 @@ def test_too_short_input_hfc(self, config): # (it generates more residuals with useful information than the minimum requirements) cal_series = series[:-horizon_ocs] - series_with_cal = series[: -(horizon_ocs + add_train_length)] + series_with_cal = series[: -(horizon_ocs + add_cal_length)] model_params = {"output_chunk_shift": ocs} covs_kwargs_train = {} @@ -1295,11 +1399,11 @@ def test_too_short_input_hfc(self, config): **covs_kwargs_train, ), quantiles=q, + cal_length=cal_length, ) hfc_kwargs = { "last_points_only": last_points_only, - "train_length": train_length, "overlap_end": overlap_end, "forecast_horizon": n, } @@ -1347,8 +1451,8 @@ def test_too_short_input_hfc(self, config): **cal_covs_kwargs_short, **hfc_kwargs, ) - if (not use_covs or n > 1 or (train_length or 1) > 1) and not ( - last_points_only and use_covs and train_length is None + if (not use_covs or n > 1 or (cal_length or 1) > 1) and not ( + last_points_only and use_covs and cal_length is None ): assert str(exc.value).startswith( "Could not build the minimum required calibration input with the provided `cal_series`" diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index bf502db531..a837f9273a 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -2821,7 +2821,7 @@ def test_conformal_historical_forecasts(self, config): "config", itertools.product( [False, True], # last points only - [None, 1, 2], # train length + [None, 1, 2], # cal length [False, True], # use start ["value", "position"], # start format [False, True], # use integer indexed series @@ -2829,12 +2829,12 @@ def test_conformal_historical_forecasts(self, config): [0, 1], # output chunk shift ), ) - def test_conformal_historical_start_train_length(self, config): + def test_conformal_historical_start_cal_length(self, config): """Tests naive conformal model with start, train length, calibration set, and center forecasts against the forecasting model's forecast.""" ( last_points_only, - train_length, + cal_length, use_start, start_format, use_int_idx, @@ -2847,9 +2847,9 @@ def test_conformal_historical_start_train_length(self, config): ocl = 5 horizon = 5 horizon_ocs = horizon + ocs - add_train_length = train_length - 1 if train_length is not None else 0 + add_cal_length = cal_length - 1 if cal_length is not None else 0 add_start = 2 * int(use_start) - min_len_val_series = icl + 2 * horizon_ocs + add_train_length + add_start + min_len_val_series = icl + 2 * horizon_ocs + add_cal_length + add_start n_forecasts = 3 # get train and val series of that length series_train, series_val = ( @@ -2881,7 +2881,7 @@ def test_conformal_historical_start_train_length(self, config): forecasting_model.fit(series_train) # optionally compute the start as a positional index - start_position = icl + horizon_ocs + add_train_length + add_start + start_position = icl + horizon_ocs + add_cal_length + add_start start = None if use_start: if start_format == "value": @@ -2908,11 +2908,12 @@ def test_conformal_historical_start_train_length(self, config): forecast_horizon=horizon, ) # compute conformal historical forecasts (skips some of the first forecasts to get minimum required cal set) - model = ConformalNaiveModel(forecasting_model, quantiles=q) + model = ConformalNaiveModel( + forecasting_model, quantiles=q, cal_length=cal_length + ) hist_fct = model.historical_forecasts( series=series_val, retrain=False, - train_length=train_length, start=start, start_format=start_format, last_points_only=last_points_only, @@ -2923,7 +2924,6 @@ def test_conformal_historical_start_train_length(self, config): series=series_val, cal_series=series_val, retrain=False, - train_length=train_length, start=start, start_format=start_format, last_points_only=last_points_only, @@ -2957,7 +2957,7 @@ def test_conformal_historical_start_train_length(self, config): - horizon_ocs # skip first forecasts to avoid look-ahead bias - horizon_ocs # cannot compute with `overlap_end=False` + 1 # minimum one forecast - - add_train_length # skip based on train length + - add_cal_length # skip based on train length - add_start # skip based on start + add_start_series_2 # skip based on start if second series ) diff --git a/docs/source/conf.py b/docs/source/conf.py index e2cb8752f4..4b64571a5b 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -52,7 +52,7 @@ "exclude-members": "ForecastingModel,LocalForecastingModel,FutureCovariatesLocalForecastingModel," + "TransferableFutureCovariatesLocalForecastingModel,GlobalForecastingModel,TorchForecastingModel," + "PastCovariatesTorchModel,FutureCovariatesTorchModel,DualCovariatesTorchModel,MixedCovariatesTorchModel," - + "SplitCovariatesTorchModel,TorchParametricProbabilisticForecastingModel," + + "SplitCovariatesTorchModel,ConformalModel," + "min_train_series_length," + "untrained_model,first_prediction_index,future_covariate_series,past_covariate_series," + "initialize_encoders,register_datapipe_as_function,register_function,functions," From e8d922a8dcfc285dc6a8ff0310241af567ac9889 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Tue, 1 Oct 2024 15:18:41 +0200 Subject: [PATCH 43/78] add progress bars --- darts/metrics/metrics.py | 1 + darts/models/forecasting/conformal_models.py | 38 +++++++++++++++---- darts/models/forecasting/forecasting_model.py | 14 +++++-- ...timized_historical_forecasts_regression.py | 8 +++- 4 files changed, 48 insertions(+), 13 deletions(-) diff --git a/darts/metrics/metrics.py b/darts/metrics/metrics.py index 7409b0e565..6ea845ddaa 100644 --- a/darts/metrics/metrics.py +++ b/darts/metrics/metrics.py @@ -215,6 +215,7 @@ def wrapper_multi_ts_support(*args, **kwargs): iterable=zip(*input_series), verbose=verbose, total=len(actual_series), + desc=f"metric `{func.__name__}()`", ) # `vals` is a list of series metrics of length `len(actual_series)`. Each metric has shape diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index feec10a6a0..8b51225684 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -23,7 +23,7 @@ from darts.metrics.metrics import METRIC_TYPE from darts.models.forecasting.forecasting_model import GlobalForecastingModel from darts.models.utils import TORCH_AVAILABLE -from darts.utils import _with_sanity_checks +from darts.utils import _build_tqdm_iterator, _with_sanity_checks from darts.utils.historical_forecasts.utils import _historical_forecasts_start_warnings from darts.utils.timeseries_generation import _build_forecast_series from darts.utils.ts_utils import ( @@ -487,7 +487,6 @@ def _calibrate_forecasts( # TODO: add support for: # - num_samples # - predict_likelihood_parameters - # - tqdm iterator over series cal_length = self.cal_length metric, metric_kwargs = self._residuals_metric residuals = self.model.residuals( @@ -502,10 +501,19 @@ def _calibrate_forecasts( metric_kwargs=metric_kwargs, ) + outer_iterator = enumerate(zip(series, forecasts, residuals)) + if len(series) > 1: + # Use tqdm on the outer loop only if there's more than one series to iterate over + # (otherwise use tqdm on the inner loop). + outer_iterator = _build_tqdm_iterator( + outer_iterator, + verbose, + total=len(series), + desc="conformal forecasts", + ) + cp_hfcs = [] - for series_idx, (series_, s_hfcs, res) in enumerate( - zip(series, forecasts, residuals) - ): + for series_idx, (series_, s_hfcs, res) in outer_iterator: cp_preds = [] # no historical forecasts were generated @@ -704,9 +712,23 @@ def conformal_predict(idx_, pred_vals_): # historical conformal prediction # for each forecast, compute calibrated quantile intervals based on past residuals if last_points_only: - for idx, pred_vals in enumerate( + inner_iterator = enumerate( s_hfcs.all_values(copy=False)[first_fc_idx:last_fc_idx:stride] - ): + ) + else: + inner_iterator = enumerate(s_hfcs[first_fc_idx:last_fc_idx:stride]) + + if len(series) == 1: + # Only use progress bar if there's no outer loop + inner_iterator = _build_tqdm_iterator( + inner_iterator, + verbose, + total=(last_fc_idx - 1 - first_fc_idx) // stride + 1, + desc="conformal forecasts", + ) + + if last_points_only: + for idx, pred_vals in inner_iterator: pred_vals = np.expand_dims(pred_vals, 0) cp_pred = conformal_predict(idx, pred_vals) cp_preds.append(cp_pred) @@ -725,7 +747,7 @@ def conformal_predict(idx_, pred_vals_): ) cp_hfcs.append(cp_preds) else: - for idx, pred in enumerate(s_hfcs[first_fc_idx:last_fc_idx:stride]): + for idx, pred in inner_iterator: pred_vals = pred.all_values(copy=False) cp_pred = conformal_predict(idx, pred_vals) cp_pred = _build_forecast_series( diff --git a/darts/models/forecasting/forecasting_model.py b/darts/models/forecasting/forecasting_model.py index 74149cd809..9c5294f095 100644 --- a/darts/models/forecasting/forecasting_model.py +++ b/darts/models/forecasting/forecasting_model.py @@ -943,7 +943,9 @@ def retrain_func( # (otherwise use tqdm on the inner loop). outer_iterator = series else: - outer_iterator = _build_tqdm_iterator(series, verbose) + outer_iterator = _build_tqdm_iterator( + series, verbose, total=len(series), desc="historical forecasts" + ) # deactivate the warning after displaying it once if show_warnings is True show_predict_warnings = show_warnings @@ -1038,7 +1040,10 @@ def retrain_func( if len(series) == 1: # Only use tqdm if there's no outer loop iterator = _build_tqdm_iterator( - historical_forecasts_time_index[::stride], verbose + historical_forecasts_time_index[::stride], + verbose, + total=(len(historical_forecasts_time_index) - 1) // stride + 1, + desc="historical forecasts", ) else: iterator = historical_forecasts_time_index[::stride] @@ -1708,7 +1713,10 @@ def gridsearch( # iterate through all combinations of the provided parameters and choose the best one iterator = _build_tqdm_iterator( - zip(params_cross_product), verbose, total=len(params_cross_product) + zip(params_cross_product), + verbose, + total=len(params_cross_product), + desc="gridsearch", ) def _evaluate_combination(param_combination) -> float: diff --git a/darts/utils/historical_forecasts/optimized_historical_forecasts_regression.py b/darts/utils/historical_forecasts/optimized_historical_forecasts_regression.py index eeef59f04b..e613977e7c 100644 --- a/darts/utils/historical_forecasts/optimized_historical_forecasts_regression.py +++ b/darts/utils/historical_forecasts/optimized_historical_forecasts_regression.py @@ -41,7 +41,9 @@ def _optimized_historical_forecasts_last_points_only( Rely on _check_optimizable_historical_forecasts() to check that the assumptions are verified. """ forecasts_list = [] - iterator = _build_tqdm_iterator(series, verbose) + iterator = _build_tqdm_iterator( + series, verbose, total=len(series), desc="historical forecasts" + ) for idx, series_ in enumerate(iterator): past_covariates_ = past_covariates[idx] if past_covariates is not None else None future_covariates_ = ( @@ -203,7 +205,9 @@ def _optimized_historical_forecasts_all_points( Rely on _check_optimizable_historical_forecasts() to check that the assumptions are verified. """ forecasts_list = [] - iterator = _build_tqdm_iterator(series, verbose) + iterator = _build_tqdm_iterator( + series, verbose, total=len(series), desc="historical forecasts" + ) for idx, series_ in enumerate(iterator): past_covariates_ = past_covariates[idx] if past_covariates is not None else None future_covariates_ = ( From 9c5875ca9eadc36f51ea9dd0855fcee7b3597cd4 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Wed, 2 Oct 2024 10:52:59 +0200 Subject: [PATCH 44/78] add quantile sampler --- darts/models/forecasting/conformal_models.py | 73 +++++++++------ darts/tests/utils/test_utils.py | 94 ++++++++++++++++++++ darts/utils/utils.py | 71 +++++++++++++++ 3 files changed, 209 insertions(+), 29 deletions(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index 8b51225684..77aeffc22f 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -38,6 +38,7 @@ likelihood_component_names, n_steps_between, quantile_names, + sample_from_quantiles, ) if TORCH_AVAILABLE: @@ -86,9 +87,9 @@ def __init__( super().__init__(add_encoders=None) # quantiles and interval setup - self.quantiles = quantiles + self.quantiles = np.array(quantiles) self.idx_median = quantiles.index(0.5) - self.interval_bounds = [ + self.q_interval = [ (q_l, q_h) for q_l, q_h in zip( quantiles[: self.idx_median], quantiles[self.idx_median + 1 :][::-1] @@ -224,6 +225,7 @@ def predict( forecasts=preds, cal_series=cal_series, cal_forecasts=cal_hfcs, + num_samples=num_samples, forecast_horizon=n, overlap_end=True, last_points_only=False, @@ -324,6 +326,7 @@ def historical_forecasts( cal_forecasts=cal_hfcs, start=start, start_format=start_format, + num_samples=num_samples, forecast_horizon=forecast_horizon, stride=stride, overlap_end=overlap_end, @@ -372,7 +375,7 @@ def backtest( for metric_ in metric: if metric_ in metrics.ALL_METRICS: if metric_ in metrics.Q_INTERVAL_METRICS: - metric_kwargs.append({"q_interval": self.interval_bounds}) + metric_kwargs.append({"q_interval": self.q_interval}) elif metric_ not in metrics.NON_Q_METRICS: metric_kwargs.append({"q": self.quantiles}) else: @@ -436,7 +439,7 @@ def residuals( # make user's life easier by adding quantile intervals, or quantiles directly if metric_kwargs is None and metric in metrics.ALL_METRICS: if metric in metrics.Q_INTERVAL_METRICS: - metric_kwargs = {"q_interval": self.interval_bounds} + metric_kwargs = {"q_interval": self.q_interval} elif metric not in metrics.NON_Q_METRICS: metric_kwargs = {"q": self.quantiles} else: @@ -475,6 +478,7 @@ def _calibrate_forecasts( cal_forecasts: Optional[ Union[Sequence[Sequence[TimeSeries]], Sequence[TimeSeries]] ] = None, + num_samples: int = 1, start: Optional[Union[pd.Timestamp, float, int]] = None, start_format: Literal["position", "value"] = "value", forecast_horizon: int = 1, @@ -707,7 +711,12 @@ def conformal_predict(idx_, pred_vals_): else: # with a calibration set, use a constant q_hat q_hat_ = q_hat - return self._apply_interval(pred_vals_, q_hat_) + vals = self._apply_interval(pred_vals_, q_hat_) + if num_samples > 1: + vals = sample_from_quantiles( + vals, self.quantiles, num_samples=num_samples + ) + return vals # historical conformal prediction # for each forecast, compute calibrated quantile intervals based on past residuals @@ -717,7 +726,9 @@ def conformal_predict(idx_, pred_vals_): ) else: inner_iterator = enumerate(s_hfcs[first_fc_idx:last_fc_idx:stride]) - + comp_names_out = ( + self._cp_component_names(series_) if num_samples == 1 else None + ) if len(series) == 1: # Only use progress bar if there's no outer loop inner_iterator = _build_tqdm_iterator( @@ -735,7 +746,7 @@ def conformal_predict(idx_, pred_vals_): cp_preds = _build_forecast_series( points_preds=np.concatenate(cp_preds, axis=0), input_series=series_, - custom_columns=self._cp_component_names(series_), + custom_columns=comp_names_out, time_index=generate_index( start=s_hfcs._time_index[first_fc_idx], length=len(cp_preds), @@ -753,7 +764,7 @@ def conformal_predict(idx_, pred_vals_): cp_pred = _build_forecast_series( points_preds=cp_pred, input_series=series_, - custom_columns=self._cp_component_names(series_), + custom_columns=comp_names_out, time_index=pred._time_index, with_static_covs=False, with_hierarchy=False, @@ -994,20 +1005,27 @@ def __init__( def _calibrate_interval( self, residuals: np.ndarray ) -> Tuple[np.ndarray, np.ndarray]: + def q_hat_from_residuals(residuals_): + # compute quantiles of shape (forecast horizon, n components, n quantile intervals) + return np.quantile( + residuals_, + q=self.interval_range_sym, + method="higher", + axis=2, + ).transpose((1, 2, 0)) + + # residuals shape (horizon, n components, n past forecasts) if self.symmetric: - # shape (forecast horizon, n components, n quantile intervals) - q_hat = np.quantile(residuals, q=self.interval_range_sym, axis=2).transpose(( - 1, - 2, - 0, - )) + # symmetric (from metric `ae()`) + q_hat = q_hat_from_residuals(residuals) return -q_hat, q_hat[:, :, ::-1] - - # asymmetric - n_comps = residuals.shape[1] - res = np.concatenate([-residuals, residuals], axis=1) - q_hat = np.quantile(res, q=self.interval_range_sym, axis=2).transpose((1, 2, 0)) - return -q_hat[:, :n_comps, :], q_hat[:, n_comps:, ::-1] + else: + # asymmetric (from metric `err()`) + q_hat = q_hat_from_residuals( + np.concatenate([-residuals, residuals], axis=1) + ) + n_comps = residuals.shape[1] + return -q_hat[:, :n_comps, :], q_hat[:, n_comps:, ::-1] def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray]): # convert stochastic predictions to median @@ -1083,12 +1101,8 @@ def q_hat_from_residuals(residuals_): # compute quantiles with shape (horizon, n components, n quantile intervals) # over all past residuals q_hat_tmp = np.quantile( - residuals_, q=self.interval_range_sym, axis=2 - ).transpose(( - 1, - 2, - 0, - )) + residuals_, q=self.interval_range_sym, method="higher", axis=2 + ).transpose((1, 2, 0)) q_hat_ = np.empty((len(residuals_), n_comps, n_intervals)) for i in range(n_intervals): for c in range(n_comps): @@ -1096,12 +1110,13 @@ def q_hat_from_residuals(residuals_): return q_hat_ if self.symmetric: - # symmetric has one nc-score per intervals + # symmetric has one nc-score per intervals (from metric `incs_qr(symmetric=True)`) # residuals shape (horizon, n components * n intervals, n past forecasts) q_hat = q_hat_from_residuals(residuals) return -q_hat, q_hat[:, :, ::-1] else: - # asymmetric has two nc-score per intervals (for lower and upper quantiles) + # asymmetric has two nc-score per intervals (for lower and upper quantiles, from metric + # `incs_qe(symmetric=False)`) # lower and upper residuals are concatenated along axis=1; # residuals shape (horizon, n components * n intervals * 2, n past forecasts) half_idx = residuals.shape[1] // 2 @@ -1127,6 +1142,6 @@ def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray] @property def _residuals_metric(self) -> Tuple[METRIC_TYPE, Optional[dict]]: return metrics.incs_qr, { - "q_interval": self.interval_bounds, + "q_interval": self.q_interval, "symmetric": self.symmetric, } diff --git a/darts/tests/utils/test_utils.py b/darts/tests/utils/test_utils.py index d629851cea..003d2253aa 100644 --- a/darts/tests/utils/test_utils.py +++ b/darts/tests/utils/test_utils.py @@ -1,3 +1,5 @@ +import itertools + import numpy as np import pandas as pd import pytest @@ -15,6 +17,7 @@ n_steps_between, quantile_interval_names, quantile_names, + sample_from_quantiles, ) @@ -631,3 +634,94 @@ def test_quantile_interval_names(self, config): q, names_expected = config names = quantile_interval_names(q, "a") assert names == names_expected + + @pytest.mark.parametrize("ndim", [2, 3]) + def test_generate_samples_shape(self, ndim): + """Checks that the output shape of generated samples from quantiles and quantile predictions + is as expected.""" + n_time_steps = 10 + n_columns = 5 + n_quantiles = 20 + num_samples = 50 + + q = np.linspace(0, 1, n_quantiles) + q_pred = np.random.rand(n_time_steps, n_columns, n_quantiles) + if ndim == 2: + q_pred = q_pred.reshape((n_time_steps, n_columns * n_quantiles)) + y_pred = sample_from_quantiles(q_pred, q, num_samples) + assert y_pred.shape == (n_time_steps, n_columns, num_samples) + + @pytest.mark.parametrize( + "config", + itertools.product( + [1, 2], # n times + [2, 3], # ndim + [1, 2], # n components + ), + ) + def test_generate_samples_output(self, config): + """Tests sample generation from quantiles and quantile predictions for: + + - single/multiple time steps + - from 2 or 3 dimensions + - uni/multivariate + """ + np.random.seed(42) + n_times, ndim, n_comps = config + num_samples = 100000 + + q = np.array([0.2, 0.5, 0.75]) + q_pred = np.array([[[1.0, 2.0, 3.0]]]) + if n_times == 2: + q_pred = np.concatenate([q_pred, np.array([[[5.0, 7.0, 9.0]]])], axis=0) + if n_comps == 2: + q_pred = np.concatenate([q_pred, q_pred + 1.0], axis=1) + if ndim == 2: + q_pred = q_pred.reshape((len(q_pred), -1)) + y_pred = sample_from_quantiles(q_pred, q, num_samples) + + q_pred = q_pred.reshape((q_pred.shape[0], n_comps, len(q))) + for i in range(n_comps): + # edges must be identical to min/max predicted quantiles + assert y_pred[:, i].min() == q_pred[:, i].min() + assert y_pred[:, i].max() == q_pred[:, i].max() + + # check that sampled quantiles values equal to the predicted quantiles + assert np.quantile(y_pred[:, i], q[0], axis=1) == pytest.approx( + q_pred[:, i, 0], abs=0.02 + ) + assert np.quantile(y_pred[:, i], q[1], axis=1) == pytest.approx( + q_pred[:, i, 1], abs=0.02 + ) + assert np.quantile(y_pred[:, i], q[2], axis=1) == pytest.approx( + q_pred[:, i, 2], abs=0.02 + ) + + # for each component and quantile, check that the expected ratio of sampled values is approximately + # equal to the quantile + assert (y_pred[:, i] == q_pred[:, i, 0:1]).mean(axis=1) == pytest.approx( + 0.2, abs=0.02 + ) + assert ( + (q_pred[:, i, 0:1] < y_pred[:, i]) & (y_pred[:, i] <= q_pred[:, i, 1:2]) + ).mean(axis=1) == pytest.approx(0.3, abs=0.02) + assert ( + (q_pred[:, i, 1:2] < y_pred[:, i]) & (y_pred[:, i] < q_pred[:, i, 2:3]) + ).mean(axis=1) == pytest.approx(0.25, abs=0.02) + assert (y_pred[:, i] == q_pred[:, i, 2:3]).mean(axis=1) == pytest.approx( + 0.25, abs=0.02 + ) + + # between the quantiles, the values must be linearly interpolated + # check that number of unique values is approximately equal to the difference between two adjacent quantiles + mask1 = (q_pred[:, i, 0:1] < y_pred[:, i]) & ( + y_pred[:, i] < q_pred[:, i, 1:2] + ) + share_unique1 = len(np.unique(y_pred[:, i][mask1])) / num_samples + assert share_unique1 == pytest.approx(n_times * (q[1] - q[0]), abs=0.05) + + mask2 = (q_pred[:, i, 1:2] < y_pred[:, i]) & ( + y_pred[:, i] < q_pred[:, i, 2:3] + ) + share_unique2 = len(np.unique(y_pred[:, i][mask2])) / num_samples + assert share_unique2 == pytest.approx(n_times * (q[2] - q[1]), abs=0.05) diff --git a/darts/utils/utils.py b/darts/utils/utils.py index c7c2480215..90640fc6cf 100644 --- a/darts/utils/utils.py +++ b/darts/utils/utils.py @@ -586,3 +586,74 @@ def expand_arr(arr: np.ndarray, ndim: int): if len(shape) != ndim: arr = arr.reshape(shape + tuple(1 for _ in range(ndim - len(shape)))) return arr + + +def sample_from_quantiles( + vals: np.ndarray, + quantiles: np.ndarray, + num_samples: int, +): + """Generates `num_samples` samples from quantile predictions using linear interpolation. The generated samples + should have quantile values close to the quantile predictions. For the lowest and highest quantiles, the lowest + and highest quantile predictions are repeated. + + Parameters + ---------- + vals + A numpy array of quantile predictions/values. Either an array with two dimensions + (n times, n components * n quantiles), or with three dimensions (n times, n components, n quantiles). + In the two-dimensional case, the order is first by ascending column, then by ascending quantile value + `(comp_0_q_0, comp_0_q_1, ... comp_n_q_m)` + quantiles + A numpy array of quantiles. + num_samples + The number of samples to generate. + """ + if not 2 <= vals.ndim <= 3: + raise_log( + ValueError( + "`vals` must have either two dimensions with `(n times, n components * n quantiles)` or three " + "dimensions with shape `(n times, n components, n quantiles)`" + ) + ) + n_time_steps = len(vals) + n_quantiles = len(quantiles) + if vals.ndim == 2: + if vals.shape[1] % n_quantiles > 0: + raise_log( + ValueError( + "`vals` with two dimension must have shape `(n times, n components * n quantiles)`." + ) + ) + vals = vals.reshape((n_time_steps, -1, n_quantiles)) + elif vals.ndim == 3 and vals.shape[2] != n_quantiles: + raise_log( + ValueError( + "`vals` with three dimension must have shape `(n times, n components, n quantiles)`." + ) + ) + n_columns = vals.shape[1] + + # Generate uniform random samples + random_samples = np.random.uniform(0, 1, (n_time_steps, n_columns, num_samples)) + # Find the indices of the quantiles just below and above the random samples + lower_indices = np.searchsorted(quantiles, random_samples, side="right") - 1 + upper_indices = lower_indices + 1 + + # Handle edge cases + lower_indices = np.clip(lower_indices, 0, n_quantiles - 1) + upper_indices = np.clip(upper_indices, 0, n_quantiles - 1) + + # Gather the corresponding quantile values and vals values + q_lower = quantiles[lower_indices] + q_upper = quantiles[upper_indices] + z_lower = np.take_along_axis(vals, lower_indices, axis=2) + z_upper = np.take_along_axis(vals, upper_indices, axis=2) + + y = z_lower + # Linear interpolation + mask = q_lower != q_upper + y[mask] = z_lower[mask] + (z_upper[mask] - z_lower[mask]) * ( + random_samples[mask] - q_lower[mask] + ) / (q_upper[mask] - q_lower[mask]) + return y From 3761894b7e9d5ab1299ff290f4a895a5cc797ba3 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 3 Oct 2024 10:08:57 +0200 Subject: [PATCH 45/78] add predict lkl params and num samples --- darts/models/forecasting/conformal_models.py | 151 ++---------------- darts/tests/conftest.py | 21 ++- .../forecasting/test_conformal_model.py | 31 ++-- .../forecasting/test_ensemble_models.py | 10 +- .../test_global_forecasting_models.py | 12 +- .../test_local_forecasting_models.py | 4 - 6 files changed, 54 insertions(+), 175 deletions(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index 77aeffc22f..6249f5d6fe 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -200,7 +200,7 @@ def predict( future_covariates=future_covariates, num_samples=self.num_samples, verbose=verbose, - predict_likelihood_parameters=predict_likelihood_parameters, + predict_likelihood_parameters=False, show_warnings=show_warnings, ) # convert to multi series case with `last_points_only=False` @@ -218,7 +218,7 @@ def predict( last_points_only=False, verbose=verbose, show_warnings=show_warnings, - predict_likelihood_parameters=predict_likelihood_parameters, + predict_likelihood_parameters=False, ) cal_preds = self._calibrate_forecasts( series=series, @@ -231,6 +231,7 @@ def predict( last_points_only=False, verbose=verbose, show_warnings=show_warnings, + predict_likelihood_parameters=predict_likelihood_parameters, ) # convert historical forecasts output to simple forecast / prediction if called_with_single_series: @@ -294,7 +295,7 @@ def historical_forecasts( last_points_only=last_points_only, verbose=verbose, show_warnings=show_warnings, - predict_likelihood_parameters=predict_likelihood_parameters, + predict_likelihood_parameters=False, enable_optimization=enable_optimization, fit_kwargs=fit_kwargs, predict_kwargs=predict_kwargs, @@ -314,7 +315,7 @@ def historical_forecasts( last_points_only=last_points_only, verbose=verbose, show_warnings=show_warnings, - predict_likelihood_parameters=predict_likelihood_parameters, + predict_likelihood_parameters=False, enable_optimization=enable_optimization, fit_kwargs=fit_kwargs, predict_kwargs=predict_kwargs, @@ -324,15 +325,16 @@ def historical_forecasts( forecasts=hfcs, cal_series=cal_series, cal_forecasts=cal_hfcs, + num_samples=num_samples, start=start, start_format=start_format, - num_samples=num_samples, forecast_horizon=forecast_horizon, stride=stride, overlap_end=overlap_end, last_points_only=last_points_only, verbose=verbose, show_warnings=show_warnings, + predict_likelihood_parameters=predict_likelihood_parameters, ) return ( calibrated_forecasts[0] @@ -340,136 +342,6 @@ def historical_forecasts( else calibrated_forecasts ) - def backtest( - self, - series: Union[TimeSeries, Sequence[TimeSeries]], - past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - historical_forecasts: Optional[ - Union[TimeSeries, Sequence[TimeSeries], Sequence[Sequence[TimeSeries]]] - ] = None, - num_samples: int = 1, - train_length: Optional[int] = None, - start: Optional[Union[pd.Timestamp, float, int]] = None, - start_format: Literal["position", "value"] = "value", - forecast_horizon: int = 1, - stride: int = 1, - retrain: Union[bool, int, Callable[..., bool]] = True, - overlap_end: bool = False, - last_points_only: bool = False, - metric: Union[METRIC_TYPE, List[METRIC_TYPE]] = metrics.miw, - reduction: Union[Callable[..., float], None] = np.mean, - verbose: bool = False, - show_warnings: bool = True, - predict_likelihood_parameters: bool = False, - enable_optimization: bool = True, - metric_kwargs: Optional[Union[Dict[str, Any], List[Dict[str, Any]]]] = None, - fit_kwargs: Optional[Dict[str, Any]] = None, - predict_kwargs: Optional[Dict[str, Any]] = None, - sample_weight: Optional[Union[TimeSeries, Sequence[TimeSeries], str]] = None, - ) -> Union[float, np.ndarray, List[float], List[np.ndarray]]: - # make user's life easier by adding quantile intervals, or quantiles directly - if metric_kwargs is None: - metric = [metric] if not isinstance(metric, list) else metric - metric_kwargs = [] - for metric_ in metric: - if metric_ in metrics.ALL_METRICS: - if metric_ in metrics.Q_INTERVAL_METRICS: - metric_kwargs.append({"q_interval": self.q_interval}) - elif metric_ not in metrics.NON_Q_METRICS: - metric_kwargs.append({"q": self.quantiles}) - else: - metric_kwargs.append({}) - else: - metric_kwargs.append({}) - return super().backtest( - series=series, - past_covariates=past_covariates, - future_covariates=future_covariates, - historical_forecasts=historical_forecasts, - num_samples=num_samples, - train_length=train_length, - start=start, - start_format=start_format, - forecast_horizon=forecast_horizon, - stride=stride, - retrain=retrain, - overlap_end=overlap_end, - last_points_only=last_points_only, - metric=metric, - reduction=reduction, - verbose=verbose, - show_warnings=show_warnings, - predict_likelihood_parameters=predict_likelihood_parameters, - enable_optimization=enable_optimization, - metric_kwargs=metric_kwargs, - fit_kwargs=fit_kwargs, - predict_kwargs=predict_kwargs, - sample_weight=sample_weight, - ) - - def residuals( - self, - series: Union[TimeSeries, Sequence[TimeSeries]], - past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - historical_forecasts: Optional[ - Union[TimeSeries, Sequence[TimeSeries], Sequence[Sequence[TimeSeries]]] - ] = None, - num_samples: int = 1, - train_length: Optional[int] = None, - start: Optional[Union[pd.Timestamp, float, int]] = None, - start_format: Literal["position", "value"] = "value", - forecast_horizon: int = 1, - stride: int = 1, - retrain: Union[bool, int, Callable[..., bool]] = True, - overlap_end: bool = False, - last_points_only: bool = True, - metric: METRIC_TYPE = metrics.iw, - verbose: bool = False, - show_warnings: bool = True, - predict_likelihood_parameters: bool = False, - enable_optimization: bool = True, - metric_kwargs: Optional[Dict[str, Any]] = None, - fit_kwargs: Optional[Dict[str, Any]] = None, - predict_kwargs: Optional[Dict[str, Any]] = None, - values_only: bool = False, - sample_weight: Optional[Union[TimeSeries, Sequence[TimeSeries], str]] = None, - ) -> Union[TimeSeries, List[TimeSeries], List[List[TimeSeries]]]: - # make user's life easier by adding quantile intervals, or quantiles directly - if metric_kwargs is None and metric in metrics.ALL_METRICS: - if metric in metrics.Q_INTERVAL_METRICS: - metric_kwargs = {"q_interval": self.q_interval} - elif metric not in metrics.NON_Q_METRICS: - metric_kwargs = {"q": self.quantiles} - else: - metric_kwargs = {} - return super().residuals( - series=series, - past_covariates=past_covariates, - future_covariates=future_covariates, - historical_forecasts=historical_forecasts, - num_samples=num_samples, - train_length=train_length, - start=start, - start_format=start_format, - forecast_horizon=forecast_horizon, - stride=stride, - retrain=retrain, - overlap_end=overlap_end, - last_points_only=last_points_only, - metric=metric, - verbose=verbose, - show_warnings=show_warnings, - predict_likelihood_parameters=predict_likelihood_parameters, - enable_optimization=enable_optimization, - metric_kwargs=metric_kwargs, - fit_kwargs=fit_kwargs, - predict_kwargs=predict_kwargs, - values_only=values_only, - sample_weight=sample_weight, - ) - def _calibrate_forecasts( self, series: Sequence[TimeSeries], @@ -487,6 +359,7 @@ def _calibrate_forecasts( last_points_only: bool = True, verbose: bool = False, show_warnings: bool = True, + predict_likelihood_parameters: bool = False, ) -> Union[TimeSeries, List[TimeSeries], List[List[TimeSeries]]]: # TODO: add support for: # - num_samples @@ -712,7 +585,7 @@ def conformal_predict(idx_, pred_vals_): # with a calibration set, use a constant q_hat q_hat_ = q_hat vals = self._apply_interval(pred_vals_, q_hat_) - if num_samples > 1: + if not predict_likelihood_parameters: vals = sample_from_quantiles( vals, self.quantiles, num_samples=num_samples ) @@ -727,7 +600,9 @@ def conformal_predict(idx_, pred_vals_): else: inner_iterator = enumerate(s_hfcs[first_fc_idx:last_fc_idx:stride]) comp_names_out = ( - self._cp_component_names(series_) if num_samples == 1 else None + self._cp_component_names(series_) + if predict_likelihood_parameters + else None ) if len(series) == 1: # Only use progress bar if there's no outer loop @@ -866,7 +741,7 @@ def _cp_component_names(self, input_series) -> List[str]: @property def output_chunk_length(self) -> Optional[int]: - return self.model.output_chunk_length + return None @property def output_chunk_shift(self) -> int: diff --git a/darts/tests/conftest.py b/darts/tests/conftest.py index b0b97a0131..90bf29e20b 100644 --- a/darts/tests/conftest.py +++ b/darts/tests/conftest.py @@ -1,4 +1,5 @@ import logging +import os import shutil import tempfile @@ -40,15 +41,31 @@ def tear_down_tests(): @pytest.fixture(scope="module") def tmpdir_module(): - """Sets up a temporary directory that will be deleted after the test module (script) finished.""" + """Sets up and moves into a temporary directory that will be deleted after the test module (script) finished.""" temp_work_dir = tempfile.mkdtemp(prefix="darts") + # remember origin + cwd = os.getcwd() + # move to temp dir + os.chdir(temp_work_dir) + # go into test with temp dir as input yield temp_work_dir + # move back to origin shutil.rmtree(temp_work_dir) + # remove temp dir + os.chdir(cwd) @pytest.fixture(scope="function") def tmpdir_fn(): - """Sets up a temporary directory that will be deleted after the test function finished.""" + """Sets up and moves into a temporary directory that will be deleted after the test function finished.""" temp_work_dir = tempfile.mkdtemp(prefix="darts") + # remember origin + cwd = os.getcwd() + # move to temp dir + os.chdir(temp_work_dir) + # go into test with temp dir as input yield temp_work_dir + # move back to origin + os.chdir(cwd) + # remove temp dir shutil.rmtree(temp_work_dir) diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index a7da81a082..d6067d170a 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -34,7 +34,7 @@ {"input_chunk_length": IN_LEN, "output_chunk_length": OUT_LEN, "random_state": 0}, **tfm_kwargs, ) - +pred_lklp = {"num_samples": 1, "predict_likelihood_parameters": True} q = [0.1, 0.5, 0.9] @@ -210,22 +210,22 @@ def test_save_model_parameters(self, config): continue assert val == model_fresh._model_params[param] - @pytest.mark.parametrize("config", models_cls_kwargs_errs) + @pytest.mark.parametrize( + "config", itertools.product(models_cls_kwargs_errs, [{}, pred_lklp]) + ) def test_save_load_model(self, tmpdir_fn, config): # check if save and load methods work and if loaded model creates same forecasts as original model - model_cls, kwargs, model_type = config + (model_cls, kwargs, model_type), pred_kwargs = config model = model_cls( train_model( self.ts_pass_train, model_type=model_type, quantiles=kwargs["quantiles"] ), **kwargs, ) - model_prediction = model.predict(5) + model_prediction = model.predict(5, **pred_kwargs) # check if save and load methods work and # if loaded conformal model creates same forecasts as original ensemble models - cwd = os.getcwd() - os.chdir(tmpdir_fn) expected_suffixes = [ ".pkl", ".pkl.NLinearModel.pt", @@ -260,8 +260,7 @@ def test_save_load_model(self, tmpdir_fn, config): pkl_files.append(os.path.join(tmpdir_fn, filename)) for p in pkl_files: loaded_model = model_cls.load(p) - assert model_prediction == loaded_model.predict(5) - os.chdir(cwd) + assert model_prediction == loaded_model.predict(5, **pred_kwargs) @pytest.mark.parametrize("config", models_cls_kwargs_errs) def test_single_ts(self, config): @@ -1136,18 +1135,18 @@ def helper_compute_pred_cal( if is_naive and symmetric: # identical correction for upper and lower bounds # metric is `ae()` - q_hat_n = np.quantile(res_n, q=alpha, axis=1) + q_hat_n = np.quantile(res_n, q=alpha, method="higher", axis=1) q_hats.append((-q_hat_n, q_hat_n)) elif is_naive: # correction separately for upper and lower bounds # metric is `err()` - q_hat_hi = np.quantile(res_n, q=alpha, axis=1) - q_hat_lo = np.quantile(-res_n, q=alpha, axis=1) + q_hat_hi = np.quantile(res_n, q=alpha, method="higher", axis=1) + q_hat_lo = np.quantile(-res_n, q=alpha, method="higher", axis=1) q_hats.append((-q_hat_lo, q_hat_hi)) elif symmetric: # CQR symmetric # identical correction for upper and lower bounds # metric is `incs_qr(symmetric=True)` - q_hat_n = np.quantile(res_n, q=alpha, axis=1) + q_hat_n = np.quantile(res_n, q=alpha, method="higher", axis=1) q_hats.append((-q_hat_n, q_hat_n)) else: # CQR asymmetric # correction separately for upper and lower bounds @@ -1157,8 +1156,12 @@ def helper_compute_pred_cal( # residuals have shape (n components * n intervals * 2) # the factor 2 comes from the metric being computed for lower, and upper bounds separately # (comp_1_qlow_1, comp_1_qlow_2, ... comp_n_qlow_m, comp_1_qhigh_1, ...) - q_hat_lo = np.quantile(res_n[:half_idx], q=alpha, axis=1) - q_hat_hi = np.quantile(res_n[half_idx:], q=alpha, axis=1) + q_hat_lo = np.quantile( + res_n[:half_idx], q=alpha, method="higher", axis=1 + ) + q_hat_hi = np.quantile( + res_n[half_idx:], q=alpha, method="higher", axis=1 + ) q_hats.append(( -q_hat_lo[alpha_idx :: len(alphas)], q_hat_hi[alpha_idx :: len(alphas)], diff --git a/darts/tests/models/forecasting/test_ensemble_models.py b/darts/tests/models/forecasting/test_ensemble_models.py index 06cb2bff80..5a7eb0122a 100644 --- a/darts/tests/models/forecasting/test_ensemble_models.py +++ b/darts/tests/models/forecasting/test_ensemble_models.py @@ -766,14 +766,10 @@ def get_global_ensemble_model(output_chunk_length=5): ) @pytest.mark.parametrize("model_cls", [NaiveEnsembleModel, RegressionEnsembleModel]) - def test_save_load_ensemble_models(self, tmpdir_module, model_cls): + def test_save_load_ensemble_models(self, tmpdir_fn, model_cls): # check if save and load methods work and # if loaded ensemble model creates same forecasts as original ensemble models - cwd = os.getcwd() - os.chdir(tmpdir_module) - os.mkdir(model_cls.__name__) - full_model_path_str = os.path.join(tmpdir_module, model_cls.__name__) - os.chdir(full_model_path_str) + full_model_path_str = os.getcwd() kwargs = {} expected_suffixes = [".pkl", ".pkl.RNNModel_2.pt", ".pkl.RNNModel_2.pt.ckpt"] @@ -827,5 +823,3 @@ def test_save_load_ensemble_models(self, tmpdir_module, model_cls): for p in pkl_files: loaded_model = model_cls.load(p) assert model_prediction == loaded_model.predict(5) - - os.chdir(cwd) diff --git a/darts/tests/models/forecasting/test_global_forecasting_models.py b/darts/tests/models/forecasting/test_global_forecasting_models.py index 94b3098e34..6b33942f51 100644 --- a/darts/tests/models/forecasting/test_global_forecasting_models.py +++ b/darts/tests/models/forecasting/test_global_forecasting_models.py @@ -276,12 +276,10 @@ def test_save_model_parameters(self, config): ), ], ) - def test_save_load_model(self, tmpdir_module, model): + def test_save_load_model(self, tmpdir_fn, model): # check if save and load methods work and if loaded model creates same forecasts as original model - cwd = os.getcwd() - os.chdir(tmpdir_module) model_path_str = type(model).__name__ - full_model_path_str = os.path.join(tmpdir_module, model_path_str) + full_model_path_str = os.path.join(tmpdir_fn, model_path_str) model.fit(self.ts_pass_train) model_prediction = model.predict(self.forecasting_horizon) @@ -293,9 +291,7 @@ def test_save_load_model(self, tmpdir_module, model): assert os.path.exists(full_model_path_str) assert ( len([ - p - for p in os.listdir(tmpdir_module) - if p.startswith(type(model).__name__) + p for p in os.listdir(tmpdir_fn) if p.startswith(type(model).__name__) ]) == 4 ) @@ -305,8 +301,6 @@ def test_save_load_model(self, tmpdir_module, model): assert model_prediction == loaded_model.predict(self.forecasting_horizon) - os.chdir(cwd) - @pytest.mark.parametrize("config", models_cls_kwargs_errs) def test_single_ts(self, config): model_cls, kwargs, err = config diff --git a/darts/tests/models/forecasting/test_local_forecasting_models.py b/darts/tests/models/forecasting/test_local_forecasting_models.py index b9d0bf5084..e1e7361a60 100644 --- a/darts/tests/models/forecasting/test_local_forecasting_models.py +++ b/darts/tests/models/forecasting/test_local_forecasting_models.py @@ -142,8 +142,6 @@ def test_save_model_parameters(self): @pytest.mark.parametrize("model", [ARIMA(1, 1, 1), LinearRegressionModel(lags=12)]) def test_save_load_model(self, tmpdir_module, model): # check if save and load methods work and if loaded model creates same forecasts as original model - cwd = os.getcwd() - os.chdir(tmpdir_module) model_path_str = type(model).__name__ model_path_pathlike = pathlib.Path(model_path_str + "_pathlike") model_path_binary = model_path_str + "_binary" @@ -186,8 +184,6 @@ def test_save_load_model(self, tmpdir_module, model): for loaded_model in loaded_models: assert model_prediction == loaded_model.predict(self.forecasting_horizon) - os.chdir(cwd) - def test_save_load_model_invalid_path(self): # check if save and load methods raise an error when given an invalid path model = ARIMA(1, 1, 1) From a93ef39958d3cc34f026fa3fd65ffd7077430c31 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 3 Oct 2024 11:01:32 +0200 Subject: [PATCH 46/78] add random method for handling randomness of non-torch models --- darts/models/forecasting/conformal_models.py | 6 ++ .../forecasting/test_conformal_model.py | 3 +- darts/utils/torch.py | 43 +++-------- darts/utils/utils.py | 76 ++++++++++++++++++- 4 files changed, 93 insertions(+), 35 deletions(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index 6249f5d6fe..b8a215131d 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -38,6 +38,7 @@ likelihood_component_names, n_steps_between, quantile_names, + random_method, sample_from_quantiles, ) @@ -50,6 +51,7 @@ class ConformalModel(GlobalForecastingModel, ABC): + @random_method def __init__( self, model: GlobalForecastingModel, @@ -57,6 +59,7 @@ def __init__( symmetric: bool = True, cal_length: Optional[int] = None, num_samples: int = 500, + random_state: Optional[int] = None, ): """Base Conformal Prediction Model. @@ -77,6 +80,8 @@ def __init__( Number of times a prediction is sampled from the underlying `model` if it is probabilistic. Uses `1` for deterministic models. This is different to the `num_samples` produced by the conformal model which can be set in downstream forecasting tasks. + random_state + Control the randomness of probabilistic conformal forecasts (sample generation) across different runs. """ if not isinstance(model, GlobalForecastingModel) or not model._fit_called: raise_log( @@ -342,6 +347,7 @@ def historical_forecasts( else calibrated_forecasts ) + @random_method def _calibrate_forecasts( self, series: Sequence[TimeSeries], diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index d6067d170a..6b3a64e97e 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -222,7 +222,6 @@ def test_save_load_model(self, tmpdir_fn, config): ), **kwargs, ) - model_prediction = model.predict(5, **pred_kwargs) # check if save and load methods work and # if loaded conformal model creates same forecasts as original ensemble models @@ -236,6 +235,8 @@ def test_save_load_model(self, tmpdir_fn, config): model.save() model.save(os.path.join(tmpdir_fn, f"{model_cls.__name__}.pkl")) + model_prediction = model.predict(5, **pred_kwargs) + assert os.path.exists(tmpdir_fn) files = os.listdir(tmpdir_fn) if model_type == "torch": diff --git a/darts/utils/torch.py b/darts/utils/torch.py index 710e0809b8..81edf78d01 100644 --- a/darts/utils/torch.py +++ b/darts/utils/torch.py @@ -4,24 +4,21 @@ """ from functools import wraps -from inspect import signature -from typing import Any, Callable, TypeVar +from typing import Callable, TypeVar +import numpy as np import torch.nn as nn import torch.nn.functional as F -from numpy.random import randint from sklearn.utils import check_random_state from torch import Tensor from torch.random import fork_rng, manual_seed -from darts.logging import get_logger, raise_if_not +from darts.logging import get_logger, raise_log +from darts.utils.utils import MAX_NUMPY_SEED_VALUE, MAX_TORCH_SEED_VALUE, _is_method T = TypeVar("T") logger = get_logger(__name__) -MAX_TORCH_SEED_VALUE = (1 << 31) - 1 # to accommodate 32-bit architectures -MAX_NUMPY_SEED_VALUE = (1 << 31) - 1 - class MonteCarloDropout(nn.Dropout): """ @@ -53,26 +50,6 @@ def mc_dropout_enabled(self) -> bool: return self._mc_dropout_enabled or self.training -def _is_method(func: Callable[..., Any]) -> bool: - """Check if the specified function is a method. - - Parameters - ---------- - func - the function to inspect. - - Returns - ------- - bool - true if `func` is a method, false otherwise. - """ - spec = signature(func) - if len(spec.parameters) > 0: - if list(spec.parameters.keys())[0] == "self": - return True - return False - - def random_method(decorated: Callable[..., T]) -> Callable[..., T]: """Decorator usable on any method within a class that will provide an isolated torch random context. @@ -82,22 +59,22 @@ def random_method(decorated: Callable[..., T]) -> Callable[..., T]: ---------- decorated A method to be run in an isolated torch random context. - """ # check that @random_method has been applied to a method. - raise_if_not( - _is_method(decorated), "@random_method can only be used on methods.", logger - ) + if not _is_method(decorated): + raise_log(ValueError("@random_method can only be used on methods."), logger) @wraps(decorated) def decorator(self, *args, **kwargs) -> T: if "random_state" in kwargs.keys(): + # get random state for first time from model constructor self._random_instance = check_random_state(kwargs["random_state"]) elif not hasattr(self, "_random_instance"): + # get random state for first time from other method self._random_instance = check_random_state( - randint(0, high=MAX_NUMPY_SEED_VALUE) + np.random.randint(0, high=MAX_NUMPY_SEED_VALUE) ) - + # handle the randomness with fork_rng(): manual_seed(self._random_instance.randint(0, high=MAX_TORCH_SEED_VALUE)) return decorated(self, *args, **kwargs) diff --git a/darts/utils/utils.py b/darts/utils/utils.py index 90640fc6cf..120384664f 100644 --- a/darts/utils/utils.py +++ b/darts/utils/utils.py @@ -6,12 +6,23 @@ from enum import Enum from functools import wraps from inspect import Parameter, getcallargs, signature -from typing import Callable, Iterator, List, Optional, Sequence, Tuple, TypeVar, Union +from typing import ( + Any, + Callable, + Iterator, + List, + Optional, + Sequence, + Tuple, + TypeVar, + Union, +) import numpy as np import pandas as pd from joblib import Parallel, delayed from pandas._libs.tslibs.offsets import BusinessMixin +from sklearn.utils import check_random_state from tqdm import tqdm from tqdm.notebook import tqdm as tqdm_notebook @@ -24,6 +35,9 @@ logger = get_logger(__name__) +MAX_TORCH_SEED_VALUE = (1 << 31) - 1 # to accommodate 32-bit architectures +MAX_NUMPY_SEED_VALUE = (1 << 31) - 1 + # Enums class SeasonalityMode(Enum): @@ -264,6 +278,26 @@ def _parallel_apply( return returned_data +def _is_method(func: Callable[..., Any]) -> bool: + """Check if the specified function is a method. + + Parameters + ---------- + func + the function to inspect. + + Returns + ------- + bool + true if `func` is a method, false otherwise. + """ + spec = signature(func) + if len(spec.parameters) > 0: + if list(spec.parameters.keys())[0] == "self": + return True + return False + + def _check_quantiles(quantiles): raise_if_not( all([0 < q < 1 for q in quantiles]), @@ -657,3 +691,43 @@ def sample_from_quantiles( random_samples[mask] - q_lower[mask] ) / (q_upper[mask] - q_lower[mask]) return y + + +def random_method(decorated: Callable[..., T]) -> Callable[..., T]: + """Decorator usable on any method within a class that will provide a random context. + + The decorator will store a `_random_instance` property on the object in order to persist successive calls to the + RNG. + + This is the equivalent to `darts.utils.torch.random_method` but for non-torch models. + + Parameters + ---------- + decorated + A method to be run in an isolated torch random context. + """ + # check that @random_method has been applied to a method. + if not _is_method(decorated): + raise_log(ValueError("@random_method can only be used on methods."), logger) + + @wraps(decorated) + def decorator(self, *args, **kwargs): + if "random_state" in kwargs.keys(): + # get random state for first time from model constructor + self._random_instance = check_random_state( + kwargs["random_state"] + ).get_state() + elif not hasattr(self, "_random_instance"): + # get random state for first time from other method + self._random_instance = check_random_state( + np.random.randint(0, high=MAX_NUMPY_SEED_VALUE) + ).get_state() + + # handle the randomness + np.random.set_state(self._random_instance) + result = decorated(self, *args, **kwargs) + # update the random state after the function call + self._random_instance = np.random.get_state() + return result + + return decorator From 9318aeaa1330b2bd9c8b9c46b6d831898169bf97 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 3 Oct 2024 11:31:09 +0200 Subject: [PATCH 47/78] fix all tests --- darts/models/forecasting/forecasting_model.py | 8 +- .../forecasting/test_conformal_model.py | 97 +++++++++++++------ .../forecasting/test_historical_forecasts.py | 7 ++ 3 files changed, 79 insertions(+), 33 deletions(-) diff --git a/darts/models/forecasting/forecasting_model.py b/darts/models/forecasting/forecasting_model.py index 9c5294f095..4d1690ea73 100644 --- a/darts/models/forecasting/forecasting_model.py +++ b/darts/models/forecasting/forecasting_model.py @@ -354,8 +354,12 @@ def predict( ), logger, ) - - if self.output_chunk_shift and n > self.output_chunk_length: + is_autoregression = ( + False + if self.output_chunk_length is None + else (n > self.output_chunk_length) + ) + if self.output_chunk_shift and is_autoregression: raise_log( ValueError( "Cannot perform auto-regression `(n > output_chunk_length)` with a model that uses a " diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 6b3a64e97e..1ab82d6c0a 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -272,7 +272,7 @@ def test_single_ts(self, config): ), **kwargs, ) - pred = model.predict(n=self.horizon) + pred = model.predict(n=self.horizon, **pred_lklp) assert pred.n_components == self.ts_pass_train.n_components * 3 assert not np.isnan(pred.all_values()).any().any() @@ -288,20 +288,24 @@ def test_single_ts(self, config): assert pred.static_covariates is None # using a different `n`, gives different results, since we can generate more residuals for the horizon - pred1 = model.predict(n=1) + pred1 = model.predict(n=1, **pred_lklp) assert not pred1 == pred # giving the same series as calibration set must give the same results - pred_cal = model.predict(n=self.horizon, cal_series=self.ts_pass_train) + pred_cal = model.predict( + n=self.horizon, cal_series=self.ts_pass_train, **pred_lklp + ) np.testing.assert_array_almost_equal(pred.all_values(), pred_cal.all_values()) # wrong dimension with pytest.raises(ValueError): model.predict( - n=self.horizon, series=self.ts_pass_train.stack(self.ts_pass_train) + n=self.horizon, + series=self.ts_pass_train.stack(self.ts_pass_train), + **pred_lklp, ) - @pytest.mark.parametrize("config", models_cls_kwargs_errs[:]) + @pytest.mark.parametrize("config", models_cls_kwargs_errs) def test_multi_ts(self, config): model_cls, kwargs, model_type = config model = model_cls( @@ -316,7 +320,7 @@ def test_multi_ts(self, config): # when model is fit from >1 series, one must provide a series in argument model.predict(n=1) - pred = model.predict(n=self.horizon, series=self.ts_pass_train) + pred = model.predict(n=self.horizon, series=self.ts_pass_train, **pred_lklp) assert pred.n_components == self.ts_pass_train.n_components * 3 assert not np.isnan(pred.all_values()).any().any() @@ -333,12 +337,13 @@ def test_multi_ts(self, config): # using a calibration series also requires an input series with pytest.raises(ValueError): # when model is fit from >1 series, one must provide a series in argument - model.predict(n=1, cal_series=self.ts_pass_train) + model.predict(n=1, cal_series=self.ts_pass_train, **pred_lklp) # giving the same series as calibration set must give the same results pred_cal = model.predict( n=self.horizon, series=self.ts_pass_train, cal_series=self.ts_pass_train, + **pred_lklp, ) np.testing.assert_array_almost_equal(pred.all_values(), pred_cal.all_values()) @@ -346,6 +351,7 @@ def test_multi_ts(self, config): pred_list = model.predict( n=self.horizon, series=[self.ts_pass_train, self.ts_pass_train_1], + **pred_lklp, ) pred_fc_list = model.model.predict( n=self.horizon, @@ -370,6 +376,7 @@ def test_multi_ts(self, config): n=1, series=[self.ts_pass_train, self.ts_pass_val], cal_series=self.ts_pass_train, + **pred_lklp, ) assert ( str(exc.value) @@ -382,6 +389,7 @@ def test_multi_ts(self, config): n=1, series=[self.ts_pass_train, self.ts_pass_val], cal_series=[self.ts_pass_train] * 3, + **pred_lklp, ) assert ( str(exc.value) @@ -393,6 +401,7 @@ def test_multi_ts(self, config): n=self.horizon, series=[self.ts_pass_train, self.ts_pass_train_1], cal_series=[self.ts_pass_train, self.ts_pass_train_1], + **pred_lklp, ) for pred, pred_cal in zip(pred_list, pred_cal_list): np.testing.assert_array_almost_equal( @@ -405,6 +414,7 @@ def test_multi_ts(self, config): n=self.horizon, series=[self.ts_pass_train, self.ts_pass_train_1], cal_series=[self.ts_pass_train, self.ts_pass_train], + **pred_lklp, ) pred_0_vals = pred_cal_list[0].all_values() @@ -427,6 +437,7 @@ def test_multi_ts(self, config): self.ts_pass_train, self.ts_pass_train.stack(self.ts_pass_train), ], + **pred_lklp, ) @pytest.mark.parametrize( @@ -523,7 +534,7 @@ def test_covariates(self, config): ) pred = model.predict( - n=self.horizon, series=self.ts_pass_train, **cov_kwargs_notrain + n=self.horizon, series=self.ts_pass_train, **cov_kwargs_notrain, **pred_lklp ) pred_fc = model_fc.predict( n=self.horizon, @@ -549,41 +560,43 @@ def test_covariates(self, config): if is_past: # can only predict up until ocl with pytest.raises(ValueError): - _ = model.predict(n=OUT_LEN + 1) + _ = model.predict(n=OUT_LEN + 1, **pred_lklp) # wrong covariates dimension with pytest.raises(ValueError): covs = cov_kwargs_train[cov_name] covs = {cov_name: covs.stack(covs)} - _ = model.predict(n=OUT_LEN + 1, **covs) + _ = model.predict(n=OUT_LEN + 1, **covs, **pred_lklp) # with past covariates from train we can predict up until output_chunk_length - pred1 = model.predict(n=OUT_LEN) - pred2 = model.predict(n=OUT_LEN, series=self.ts_pass_train) - pred3 = model.predict(n=OUT_LEN, **cov_kwargs_train) + pred1 = model.predict(n=OUT_LEN, **pred_lklp) + pred2 = model.predict(n=OUT_LEN, series=self.ts_pass_train, **pred_lklp) + pred3 = model.predict(n=OUT_LEN, **cov_kwargs_train, **pred_lklp) pred4 = model.predict( - n=OUT_LEN, **cov_kwargs_train, series=self.ts_pass_train + n=OUT_LEN, **cov_kwargs_train, series=self.ts_pass_train, **pred_lklp ) else: # with future covariates we need additional time steps to predict with pytest.raises(ValueError): - _ = model.predict(n=1) + _ = model.predict(n=1, **pred_lklp) with pytest.raises(ValueError): - _ = model.predict(n=1, series=self.ts_pass_train) + _ = model.predict(n=1, series=self.ts_pass_train, **pred_lklp) with pytest.raises(ValueError): - _ = model.predict(n=1, **cov_kwargs_train) + _ = model.predict(n=1, **cov_kwargs_train, **pred_lklp) with pytest.raises(ValueError): - _ = model.predict(n=1, **cov_kwargs_train, series=self.ts_pass_train) + _ = model.predict( + n=1, **cov_kwargs_train, series=self.ts_pass_train, **pred_lklp + ) # wrong covariates dimension with pytest.raises(ValueError): covs = cov_kwargs_notrain[cov_name] covs = {cov_name: covs.stack(covs)} - _ = model.predict(n=OUT_LEN + 1, **covs) - pred1 = model.predict(n=OUT_LEN, **cov_kwargs_notrain) + _ = model.predict(n=OUT_LEN + 1, **covs, **pred_lklp) + pred1 = model.predict(n=OUT_LEN, **cov_kwargs_notrain, **pred_lklp) pred2 = model.predict( - n=OUT_LEN, series=self.ts_pass_train, **cov_kwargs_notrain + n=OUT_LEN, series=self.ts_pass_train, **cov_kwargs_notrain, **pred_lklp ) - pred3 = model.predict(n=OUT_LEN, **cov_kwargs_notrain) + pred3 = model.predict(n=OUT_LEN, **cov_kwargs_notrain, **pred_lklp) pred4 = model.predict( - n=OUT_LEN, **cov_kwargs_notrain, series=self.ts_pass_train + n=OUT_LEN, **cov_kwargs_notrain, series=self.ts_pass_train, **pred_lklp ) assert pred1 == pred2 @@ -661,7 +674,11 @@ def test_predict(self, config): model = ConformalNaiveModel(model_instance, quantiles=q) preds = model.predict( - n=horizon, series=series, past_covariates=pc, future_covariates=fc + n=horizon, + series=series, + past_covariates=pc, + future_covariates=fc, + **pred_lklp, ) if is_single: @@ -681,7 +698,7 @@ def test_output_chunk_shift(self): train_model(self.ts_pass_train, model_params=model_params, quantiles=q), quantiles=q, ) - pred = model.predict(n=1) + pred = model.predict(n=1, **pred_lklp) pred_fc = model.model.predict(n=1) assert pred_fc.time_index.equals(pred.time_index) @@ -694,7 +711,7 @@ def test_output_chunk_shift(self): pred[fc_columns].all_values(), pred_fc.all_values() ) - pred_cal = model.predict(n=1, cal_series=self.ts_pass_train) + pred_cal = model.predict(n=1, cal_series=self.ts_pass_train, **pred_lklp) assert pred_fc.time_index.equals(pred_cal.time_index) # the center forecasts must be equal to the forecasting model forecast np.testing.assert_array_almost_equal(pred_cal.all_values(), pred.all_values()) @@ -765,8 +782,10 @@ def test_conformal_model_predict_accuracy(self, config): cal_length=cal_length, ) pred_fc_list = model.model.predict(n, series=series, **pred_kwargs) - pred_cal_list = model.predict(n, series=series) - pred_cal_list_with_cal = model.predict(n, series=series, cal_series=series) + pred_cal_list = model.predict(n, series=series, **pred_lklp) + pred_cal_list_with_cal = model.predict( + n, series=series, cal_series=series, **pred_lklp + ) if issubclass(model_cls, ConformalNaiveModel): metric = ae if symmetric else err @@ -906,6 +925,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): last_points_only=False, stride=1, **covs_kwargs, + **pred_lklp, ) # with calibration set and covariates that can generate all calibration forecasts in the overlap hfc_conf_list_with_cal = model.historical_forecasts( @@ -917,6 +937,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): cal_series=series, **covs_kwargs, **cal_covs_kwargs_overlap, + **pred_lklp, ) if is_single: @@ -979,6 +1000,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): cal_series=series, **covs_kwargs, **cal_covs_kwargs_exact, + **pred_lklp, ) # `cal_covs_kwargs_short` will compute example less that contains useful information @@ -991,6 +1013,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): cal_series=series, **covs_kwargs, **cal_covs_kwargs_short, + **pred_lklp, ) if is_single: hfc_conf_list_with_cal_exact = [hfc_conf_list_with_cal_exact] @@ -1014,6 +1037,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): last_points_only=True, stride=1, **covs_kwargs, + **pred_lklp, ) hfc_lpo_list_with_cal = model.historical_forecasts( series=series, @@ -1024,6 +1048,7 @@ def test_naive_conformal_model_historical_forecasts(self, config): cal_series=series, **covs_kwargs, **cal_covs_kwargs_overlap, + **pred_lklp, ) if is_single: hfc_lpo_list = [hfc_lpo_list] @@ -1056,12 +1081,14 @@ def test_probabilistic_historical_forecast(self): forecast_horizon=2, last_points_only=True, stride=1, + **pred_lklp, ) hfcs_prob = model_prob.historical_forecasts( series, forecast_horizon=2, last_points_only=True, stride=1, + **pred_lklp, ) assert isinstance(hfcs_det, list) and len(hfcs_det) == 2 assert isinstance(hfcs_prob, list) and len(hfcs_prob) == 2 @@ -1485,10 +1512,14 @@ def test_backtest_and_residuals(self, quantiles): model = ConformalNaiveModel(model=train_model(series), quantiles=quantiles) hfc = model.historical_forecasts( - series=series, forecast_horizon=5, last_points_only=lpo + series=series, forecast_horizon=5, last_points_only=lpo, **pred_lklp ) bt = model.backtest( - series=series, historical_forecasts=hfc, last_points_only=lpo, metric=mic + series=series, + historical_forecasts=hfc, + last_points_only=lpo, + metric=mic, + metric_kwargs={"q_interval": model.q_interval}, ) # default backtest is equal to backtest with metric kwargs np.testing.assert_array_almost_equal( @@ -1512,7 +1543,11 @@ def test_backtest_and_residuals(self, quantiles): ) residuals = model.residuals( - series=series, historical_forecasts=hfc, last_points_only=lpo, metric=ic + series=series, + historical_forecasts=hfc, + last_points_only=lpo, + metric=ic, + metric_kwargs={"q_interval": q_interval}, ) # default residuals is equal to residuals with metric kwargs assert residuals == model.residuals( diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index a837f9273a..1c6740edc5 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -2635,6 +2635,7 @@ def test_conformal_historical_forecasts(self, config): ocs, ) = config q = [0.1, 0.5, 0.9] + pred_lklp = {"num_samples": 1, "predict_likelihood_parameters": True} # compute minimum series length to generate n forecasts icl = 3 ocl = 5 @@ -2716,6 +2717,7 @@ def test_conformal_historical_forecasts(self, config): overlap_end=overlap_end, stride=stride, forecast_horizon=horizon, + **pred_lklp, ) assert str(exc.value).startswith("Cannot perform auto-regression") return @@ -2730,6 +2732,7 @@ def test_conformal_historical_forecasts(self, config): overlap_end=overlap_end, stride=stride, forecast_horizon=horizon, + **pred_lklp, ) # raises error with too short target series with pytest.raises(ValueError) as exc: @@ -2742,6 +2745,7 @@ def test_conformal_historical_forecasts(self, config): overlap_end=overlap_end, stride=stride, forecast_horizon=horizon, + **pred_lklp, ) assert str(exc.value).startswith( "Could not build the minimum required calibration input with the provided `series`" @@ -2842,6 +2846,7 @@ def test_conformal_historical_start_cal_length(self, config): ocs, ) = config q = [0.1, 0.5, 0.9] + pred_lklp = {"num_samples": 1, "predict_likelihood_parameters": True} # compute minimum series length to generate n forecasts icl = 3 ocl = 5 @@ -2918,6 +2923,7 @@ def test_conformal_historical_start_cal_length(self, config): start_format=start_format, last_points_only=last_points_only, forecast_horizon=horizon, + **pred_lklp, ) # using a calibration series should not skip any forecasts hist_fct_cal = model.historical_forecasts( @@ -2928,6 +2934,7 @@ def test_conformal_historical_start_cal_length(self, config): start_format=start_format, last_points_only=last_points_only, forecast_horizon=horizon, + **pred_lklp, ) if not isinstance(series_val, list): From 7c37f7df1c995545549cdaef94fa58e5640bfc8a Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 3 Oct 2024 11:42:46 +0200 Subject: [PATCH 48/78] code cleanup --- darts/models/forecasting/conformal_models.py | 35 +++++++++----------- 1 file changed, 15 insertions(+), 20 deletions(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index b8a215131d..82dd5f6aa0 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -564,6 +564,7 @@ def _calibrate_forecasts( last_fc_idx = len(s_hfcs) q_hat = None + # with a calibration set, the calibrated interval is constant across all forecasts if cal_series is not None: if cal_length is not None: res = res[:, :, -cal_length:] @@ -637,7 +638,6 @@ def conformal_predict(idx_, pred_vals_): with_static_covs=False, with_hierarchy=False, ) - cp_hfcs.append(cp_preds) else: for idx, pred in inner_iterator: pred_vals = pred.all_values(copy=False) @@ -651,7 +651,7 @@ def conformal_predict(idx_, pred_vals_): with_hierarchy=False, ) cp_preds.append(cp_pred) - cp_hfcs.append(cp_preds) + cp_hfcs.append(cp_preds) return cp_hfcs def save( @@ -723,6 +723,7 @@ def _calibrate_interval( residuals The residuals are expected to have shape (horizon, n components, n historical forecasts * n samples) """ + pass @abstractmethod def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray]): @@ -738,6 +739,7 @@ def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray] def _residuals_metric(self) -> Tuple[METRIC_TYPE, Optional[dict]]: """Gives the "per time step" metric and optional metric kwargs used to compute residuals / non-conformity scores.""" + pass def _cp_component_names(self, input_series) -> List[str]: """Gives the component names for generated forecasts.""" @@ -747,6 +749,7 @@ def _cp_component_names(self, input_series) -> List[str]: @property def output_chunk_length(self) -> Optional[int]: + # conformal models can predict any horizon if the calibration set is large enough return None @property @@ -798,14 +801,10 @@ def supports_static_covariates(self) -> bool: @property def supports_sample_weight(self) -> bool: - """Whether the model supports a validation set during training.""" return False @property def supports_likelihood_parameter_prediction(self) -> bool: - """EnsembleModel can predict likelihood parameters if all its forecasting models were fitted with the - same likelihood. - """ return True @property @@ -814,30 +813,18 @@ def supports_probabilistic_prediction(self) -> bool: @property def uses_past_covariates(self) -> bool: - """ - Whether the model uses past covariates, once fitted. - """ return self.model.uses_past_covariates @property def uses_future_covariates(self) -> bool: - """ - Whether the model uses future covariates, once fitted. - """ return self.model.uses_future_covariates @property def uses_static_covariates(self) -> bool: - """ - Whether the model uses static covariates, once fitted. - """ return self.model.uses_static_covariates @property def considers_static_covariates(self) -> bool: - """ - Whether the model considers static covariates, if there are any. - """ return self.model.considers_static_covariates @property @@ -853,6 +840,7 @@ def __init__( symmetric: bool = True, cal_length: Optional[int] = None, num_samples: int = 500, + random_state: Optional[int] = None, ): """Naive Conformal Prediction Model. @@ -874,6 +862,8 @@ def __init__( Number of times a prediction is sampled from the underlying `model` if it is probabilistic. Uses `1` for deterministic models. This is different to the `num_samples` produced by the conformal model which can be set in downstream forecasting tasks. + random_state + Control the randomness of probabilistic conformal forecasts (sample generation) across different runs. """ super().__init__( model=model, @@ -881,6 +871,7 @@ def __init__( symmetric=symmetric, cal_length=cal_length, num_samples=num_samples, + random_state=random_state, ) def _calibrate_interval( @@ -930,6 +921,7 @@ def __init__( symmetric: bool = True, cal_length: Optional[int] = None, num_samples: int = 500, + random_state: Optional[int] = None, ): """Conformalized Quantile Regression Model. @@ -952,6 +944,8 @@ def __init__( Number of times a prediction is sampled from the underlying `model` if it is probabilistic. Uses `1` for deterministic models. This is different to the `num_samples` produced by the conformal model which can be set in downstream forecasting tasks. + random_state + Control the randomness of probabilistic conformal forecasts (sample generation) across different runs. """ if not model.supports_probabilistic_prediction: raise_log( @@ -967,6 +961,7 @@ def __init__( symmetric=symmetric, cal_length=cal_length, num_samples=num_samples, + random_state=random_state, ) def _calibrate_interval( @@ -991,12 +986,12 @@ def q_hat_from_residuals(residuals_): return q_hat_ if self.symmetric: - # symmetric has one nc-score per intervals (from metric `incs_qr(symmetric=True)`) + # symmetric has one nc-score per interval (from metric `incs_qr(symmetric=True)`) # residuals shape (horizon, n components * n intervals, n past forecasts) q_hat = q_hat_from_residuals(residuals) return -q_hat, q_hat[:, :, ::-1] else: - # asymmetric has two nc-score per intervals (for lower and upper quantiles, from metric + # asymmetric has two nc-score per interval (for lower and upper quantiles, from metric # `incs_qe(symmetric=False)`) # lower and upper residuals are concatenated along axis=1; # residuals shape (horizon, n components * n intervals * 2, n past forecasts) From fe103e00ef545ce7d8818ccfda926469599d2468 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 3 Oct 2024 14:01:21 +0200 Subject: [PATCH 49/78] add probabilistic test --- darts/models/forecasting/conformal_models.py | 9 ++++- .../forecasting/test_conformal_model.py | 36 +++++++++++++++++-- .../forecasting/test_probabilistic_models.py | 25 ++++++++++--- 3 files changed, 61 insertions(+), 9 deletions(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index 82dd5f6aa0..ffc4c5b446 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -127,8 +127,15 @@ def fit( series: Union[TimeSeries, Sequence[TimeSeries]], past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + **kwargs, ) -> "ConformalModel": - # does not have to be trained + # does not have to be trained, but we allow it for unified API + self.model.fit( + series=series, + past_covariates=past_covariates, + future_covariates=future_covariates, + **kwargs, + ) return self def predict( diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 1ab82d6c0a..5ea15fb7cd 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -1108,13 +1108,14 @@ def helper_prepare_series(self, is_univar, is_single): return series def helper_compare_preds(self, cp_pred, pred_expected, model_type, tol_rel=0.1): + if isinstance(cp_pred, TimeSeries): + cp_pred = cp_pred.all_values(copy=False) if model_type == "regression": # deterministic fc model should give almost identical results - np.testing.assert_array_almost_equal(cp_pred.all_values(), pred_expected) + np.testing.assert_array_almost_equal(cp_pred, pred_expected) else: # probabilistic fc models have some randomness - cp_pred_vals = cp_pred.all_values() - diffs_rel = np.abs((cp_pred_vals - pred_expected) / pred_expected) + diffs_rel = np.abs((cp_pred - pred_expected) / pred_expected) assert (diffs_rel < tol_rel).all().all() @staticmethod @@ -1570,3 +1571,32 @@ def test_backtest_and_residuals(self, quantiles): ) ) assert residuals == expected_residuals + + def test_predict_probabilistic_equals_quantile(self): + """Tests that sampled quantiles predictions have approx. the same quantiles as direct quantile predictions.""" + quantiles = [0.1, 0.3, 0.5, 0.7, 0.9] + + # multiple multivariate series + series = self.helper_prepare_series(False, False) + + # conformal model + model = ConformalNaiveModel(model=train_model(series), quantiles=quantiles) + # direct quantile predictions + pred_quantiles = model.predict(n=3, series=series, **pred_lklp) + # smapled predictions + pred_samples = model.predict(n=3, series=series, num_samples=500) + for pred_q, pred_s in zip(pred_quantiles, pred_samples): + assert pred_q.n_samples == 1 + assert pred_q.n_components == series[0].n_components * len(quantiles) + assert pred_s.n_samples == 500 + assert pred_s.n_components == series[0].n_components + + vals_q = pred_q.all_values() + vals_s = pred_s.all_values() + vals_s_q = np.quantile(vals_s, quantiles, axis=2).transpose((1, 2, 0)) + vals_s_q = vals_s_q.reshape(vals_q.shape) + self.helper_compare_preds( + vals_s_q, + vals_q, + model_type="regression_prob", + ) diff --git a/darts/tests/models/forecasting/test_probabilistic_models.py b/darts/tests/models/forecasting/test_probabilistic_models.py index d576dac8ee..9c754090d0 100644 --- a/darts/tests/models/forecasting/test_probabilistic_models.py +++ b/darts/tests/models/forecasting/test_probabilistic_models.py @@ -12,6 +12,7 @@ BATS, TBATS, CatBoostModel, + ConformalNaiveModel, ExponentialSmoothing, LightGBMModel, LinearRegressionModel, @@ -61,13 +62,16 @@ lgbm_available = not isinstance(LightGBMModel, NotImportedModule) cb_available = not isinstance(CatBoostModel, NotImportedModule) +# conformal models require a fitted base model +# in tests below, the model is re-trained for new input series. +# using a fake trained model should allow the same API with conformal models +conformal_forecaster = LinearRegressionModel(lags=10, output_chunk_length=5) +conformal_forecaster._fit_called = True + # model_cls, model_kwargs, err_univariate, err_multivariate models_cls_kwargs_errs = [ (ExponentialSmoothing, {}, 0.3, None), (ARIMA, {"p": 1, "d": 0, "q": 1, "random_state": 42}, 0.03, None), -] - -models_cls_kwargs_errs += [ ( BATS, { @@ -92,6 +96,17 @@ 0.04, 0.04, ), + ( + ConformalNaiveModel, + { + "model": conformal_forecaster, + "cal_length": 1, + "random_state": 42, + "quantiles": [0.1, 0.5, 0.9], + }, + 0.04, + 0.04, + ), ] xgb_test_params = { @@ -137,7 +152,7 @@ **tfm_kwargs, }, 0.06, - 0.05, + 0.06, ), ( BlockRNNModel, @@ -285,7 +300,7 @@ def test_probabilistic_forecast_accuracy_multivariate(self, config): def helper_test_probabilistic_forecast_accuracy(self, model, err, ts, noisy_ts): model.fit(noisy_ts[:100]) - pred = model.predict(n=100, num_samples=100) + pred = model.predict(n=50, num_samples=100) # test accuracy of the median prediction compared to the noiseless ts mae_err_median = mae(ts[100:], pred) From 60f9080fb22e69bc0637c262927e2ba24c51378d Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 3 Oct 2024 16:20:32 +0200 Subject: [PATCH 50/78] add conformal models to readme and covariates user guide --- README.md | 6 ++++++ docs/userguide/covariates.md | 3 +++ 2 files changed, 9 insertions(+) diff --git a/README.md b/README.md index bd3f6198d8..13360fecf1 100644 --- a/README.md +++ b/README.md @@ -174,6 +174,9 @@ series.plot() flavours of probabilistic forecasting (such as estimating parametric distributions or quantiles). Some anomaly detection scorers are also able to exploit these predictive distributions. +* **Conformal Prediction Support:** Our conformal prediction models allow to generate probabilistic forecasts with + calibrated quantile intervals for any pre-trained global forecasting model. + * **Past and Future Covariates support:** Many models in Darts support past-observed and/or future-known covariate (external data) time series as inputs for producing forecasts. @@ -266,6 +269,9 @@ on bringing more models and features. | **Ensemble Models**
([GlobalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#global-forecasting-models-gfms)): Model support is dependent on ensembled forecasting models and the ensemble model itself | | | | | | | [NaiveEnsembleModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveEnsembleModel) | | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | | [RegressionEnsembleModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.regression_ensemble_model.html#darts.models.forecasting.regression_ensemble_model.RegressionEnsembleModel) | | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | +| **Conformal Models**
([GlobalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#global-forecasting-models-gfms)): Model support is dependent on the forecasting model used | | | | | | +| [ConformalNaiveModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.conformal_models.ConformalNaiveModel) | [Conformalized Prediction](https://arxiv.org/pdf/1905.03222) | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | +| [ConformalQRModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.regression_ensemble_model.html#darts.models.forecasting.conformal_models.ConformalQRModel) | [Conformalized Quantile Regression](https://arxiv.org/pdf/1905.03222) | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | ## Community & Contact Anyone is welcome to join our [Gitter room](https://gitter.im/u8darts/darts) to ask questions, make proposals, diff --git a/docs/userguide/covariates.md b/docs/userguide/covariates.md index 97f82c6d92..8df7dc94eb 100644 --- a/docs/userguide/covariates.md +++ b/docs/userguide/covariates.md @@ -154,6 +154,7 @@ GFMs are models that can be trained on multiple target (and covariate) time seri | [TiDEModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tide_model.html#darts.models.forecasting.tide_model.TiDEModel) | ✅ | ✅ | ✅ | | [TSMixerModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tsmixer_model.html#darts.models.forecasting.tsmixer_model.TSMixerModel) | ✅ | ✅ | ✅ | | Ensemble Models (f) | ✅ | ✅ | ✅ | +| Conformal Prediction Models (g) | ✅ | ✅ | ✅ | **Table 1: Darts' forecasting models and their covariate support** @@ -170,6 +171,8 @@ GFMs are models that can be trained on multiple target (and covariate) time seri (f) Ensemble Model including [RegressionEnsembleModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.regression_ensemble_model.html#darts.models.forecasting.regression_ensemble_model.RegressionEnsembleModel), and [NaiveEnsembleModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveEnsembleModel). The covariate support is given by the covariate support of the ensembled forecasting models. +(g) Conformal Prediction Model including [ConformalNaiveModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.conformal_models.html#darts.models.forecasting.conformal_models.ConformalNaiveModel), and [ConformalQRModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.conformal_models.html#darts.models.forecasting.conformal_models.ConformalQRModel). The covariate support is given by the covariate support of the underlying forecasting model. + ---- ## Quick guide on how to use past and/or future covariates with Darts' forecasting models From 298211dcc2c92f2408d948ada51f64bd8e2ff0c0 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 3 Oct 2024 16:24:18 +0200 Subject: [PATCH 51/78] fix failing tests --- darts/metrics/metrics.py | 2 +- darts/tests/models/forecasting/test_regression_models.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/darts/metrics/metrics.py b/darts/metrics/metrics.py index 6ea845ddaa..a74dee8cc7 100644 --- a/darts/metrics/metrics.py +++ b/darts/metrics/metrics.py @@ -4123,7 +4123,7 @@ def mincs_qr( Same as for type `np.ndarray` but for a sequence of series. """ return np.nanmean( - _get_wrapped_metric(ic, n_wrappers=3)( + _get_wrapped_metric(incs_qr, n_wrappers=3)( actual_series, pred_series, intersect, diff --git a/darts/tests/models/forecasting/test_regression_models.py b/darts/tests/models/forecasting/test_regression_models.py index 7f8aba098a..7c981ce2ff 100644 --- a/darts/tests/models/forecasting/test_regression_models.py +++ b/darts/tests/models/forecasting/test_regression_models.py @@ -1027,7 +1027,7 @@ def test_models_runnability(self, config): future_covariates=self.sine_multivariate1, ) - model_instance = model(lags=4, lags_future_covariates=3, multi_models=mode) + model_instance = model(lags=4, lags_future_covariates=(0, 3), multi_models=mode) with pytest.raises(ValueError): # testing lags_covariate but no covariate during fit model_instance.fit(series=self.sine_univariate1) From a6f9056712e1b42c20b30ae470c03a1baf4068e4 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 3 Oct 2024 17:28:40 +0200 Subject: [PATCH 52/78] improve docs --- README.md | 84 ++++++------ darts/models/forecasting/conformal_models.py | 133 ++++++++++++++++++- 2 files changed, 172 insertions(+), 45 deletions(-) diff --git a/README.md b/README.md index 13360fecf1..02f5b2a17b 100644 --- a/README.md +++ b/README.md @@ -224,54 +224,54 @@ on bringing more models and features. | Model | Sources | Target Series Support:

Univariate/
Multivariate | Covariates Support:

Past-observed/
Future-known/
Static | Probabilistic Forecasting:

Sampled/
Distribution Parameters | Training & Forecasting on Multiple Series | |-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------|--------------------------------------------------------------------------|--------------------------------------------------------------------------|-------------------------------------------| | **Baseline Models**
([LocalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#local-forecasting-models-lfms)) | | | | | | -| [NaiveMean](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveMean) | | ✅ ✅ | 🔴 🔴 🔴 | 🔴 🔴 | 🔴 | -| [NaiveSeasonal](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveSeasonal) | | ✅ ✅ | 🔴 🔴 🔴 | 🔴 🔴 | 🔴 | -| [NaiveDrift](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveDrift) | | ✅ ✅ | 🔴 🔴 🔴 | 🔴 🔴 | 🔴 | -| [NaiveMovingAverage](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveMovingAverage) | | ✅ ✅ | 🔴 🔴 🔴 | 🔴 🔴 | 🔴 | +| [NaiveMean](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveMean) | | ✅ ✅ | 🔴 🔴 🔴 | 🔴 🔴 | 🔴 | +| [NaiveSeasonal](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveSeasonal) | | ✅ ✅ | 🔴 🔴 🔴 | 🔴 🔴 | 🔴 | +| [NaiveDrift](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveDrift) | | ✅ ✅ | 🔴 🔴 🔴 | 🔴 🔴 | 🔴 | +| [NaiveMovingAverage](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveMovingAverage) | | ✅ ✅ | 🔴 🔴 🔴 | 🔴 🔴 | 🔴 | | **Statistical / Classic Models**
([LocalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#local-forecasting-models-lfms)) | | | | | | -| [ARIMA](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.arima.html#darts.models.forecasting.arima.ARIMA) | | ✅ 🔴 | 🔴 ✅ 🔴 | ✅ 🔴 | 🔴 | -| [VARIMA](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.varima.html#darts.models.forecasting.varima.VARIMA) | | 🔴 ✅ | 🔴 ✅ 🔴 | ✅ 🔴 | 🔴 | -| [AutoARIMA](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.auto_arima.html#darts.models.forecasting.auto_arima.AutoARIMA) | | ✅ 🔴 | 🔴 ✅ 🔴 | 🔴 🔴 | 🔴 | -| [StatsForecastAutoArima](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.sf_auto_arima.html#darts.models.forecasting.sf_auto_arima.StatsForecastAutoARIMA) (faster AutoARIMA) | [Nixtla's statsforecast](https://github.com/Nixtla/statsforecast) | ✅ 🔴 | 🔴 ✅ 🔴 | ✅ 🔴 | 🔴 | -| [ExponentialSmoothing](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.exponential_smoothing.html#darts.models.forecasting.exponential_smoothing.ExponentialSmoothing) | | ✅ 🔴 | 🔴 🔴 🔴 | ✅ 🔴 | 🔴 | -| [StatsforecastAutoETS](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.sf_auto_ets.html#darts.models.forecasting.sf_auto_ets.StatsForecastAutoETS) | [Nixtla's statsforecast](https://github.com/Nixtla/statsforecast) | ✅ 🔴 | 🔴 ✅ 🔴 | ✅ 🔴 | 🔴 | -| [StatsforecastAutoCES](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.sf_auto_ces.html#darts.models.forecasting.sf_auto_ces.StatsForecastAutoCES) | [Nixtla's statsforecast](https://github.com/Nixtla/statsforecast) | ✅ 🔴 | 🔴 🔴 🔴 | 🔴 🔴 | 🔴 | -| [BATS](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tbats_model.html#darts.models.forecasting.tbats_model.BATS) and [TBATS](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tbats_model.html#darts.models.forecasting.tbats_model.TBATS) | [TBATS paper](https://robjhyndman.com/papers/ComplexSeasonality.pdf) | ✅ 🔴 | 🔴 🔴 🔴 | ✅ 🔴 | 🔴 | -| [Theta](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.theta.html#darts.models.forecasting.theta.Theta) and [FourTheta](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.theta.html#darts.models.forecasting.theta.FourTheta) | [Theta](https://robjhyndman.com/papers/Theta.pdf) & [4 Theta](https://github.com/Mcompetitions/M4-methods/blob/master/4Theta%20method.R) | ✅ 🔴 | 🔴 🔴 🔴 | 🔴 🔴 | 🔴 | -| [StatsForecastAutoTheta](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.sf_auto_theta.html#darts.models.forecasting.sf_auto_theta.StatsForecastAutoTheta) | [Nixtla's statsforecast](https://github.com/Nixtla/statsforecast) | ✅ 🔴 | 🔴 🔴 🔴 | ✅ 🔴 | 🔴 | -| [Prophet](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.prophet_model.html#darts.models.forecasting.prophet_model.Prophet) | [Prophet repo](https://github.com/facebook/prophet) | ✅ 🔴 | 🔴 ✅ 🔴 | ✅ 🔴 | 🔴 | -| [FFT](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.fft.html#darts.models.forecasting.fft.FFT) (Fast Fourier Transform) | | ✅ 🔴 | 🔴 🔴 🔴 | 🔴 🔴 | 🔴 | -| [KalmanForecaster](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.kalman_forecaster.html#darts.models.forecasting.kalman_forecaster.KalmanForecaster) using the Kalman filter and N4SID for system identification | [N4SID paper](https://people.duke.edu/~hpgavin/SystemID/References/VanOverschee-Automatica-1994.pdf) | ✅ ✅ | 🔴 ✅ 🔴 | ✅ 🔴 | 🔴 | -| [Croston](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.croston.html#darts.models.forecasting.croston.Croston) method | | ✅ 🔴 | 🔴 🔴 🔴 | 🔴 🔴 | 🔴 | +| [ARIMA](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.arima.html#darts.models.forecasting.arima.ARIMA) | | ✅ 🔴 | 🔴 ✅ 🔴 | ✅ 🔴 | 🔴 | +| [VARIMA](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.varima.html#darts.models.forecasting.varima.VARIMA) | | 🔴 ✅ | 🔴 ✅ 🔴 | ✅ 🔴 | 🔴 | +| [AutoARIMA](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.auto_arima.html#darts.models.forecasting.auto_arima.AutoARIMA) | | ✅ 🔴 | 🔴 ✅ 🔴 | 🔴 🔴 | 🔴 | +| [StatsForecastAutoArima](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.sf_auto_arima.html#darts.models.forecasting.sf_auto_arima.StatsForecastAutoARIMA) (faster AutoARIMA) | [Nixtla's statsforecast](https://github.com/Nixtla/statsforecast) | ✅ 🔴 | 🔴 ✅ 🔴 | ✅ 🔴 | 🔴 | +| [ExponentialSmoothing](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.exponential_smoothing.html#darts.models.forecasting.exponential_smoothing.ExponentialSmoothing) | | ✅ 🔴 | 🔴 🔴 🔴 | ✅ 🔴 | 🔴 | +| [StatsforecastAutoETS](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.sf_auto_ets.html#darts.models.forecasting.sf_auto_ets.StatsForecastAutoETS) | [Nixtla's statsforecast](https://github.com/Nixtla/statsforecast) | ✅ 🔴 | 🔴 ✅ 🔴 | ✅ 🔴 | 🔴 | +| [StatsforecastAutoCES](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.sf_auto_ces.html#darts.models.forecasting.sf_auto_ces.StatsForecastAutoCES) | [Nixtla's statsforecast](https://github.com/Nixtla/statsforecast) | ✅ 🔴 | 🔴 🔴 🔴 | 🔴 🔴 | 🔴 | +| [BATS](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tbats_model.html#darts.models.forecasting.tbats_model.BATS) and [TBATS](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tbats_model.html#darts.models.forecasting.tbats_model.TBATS) | [TBATS paper](https://robjhyndman.com/papers/ComplexSeasonality.pdf) | ✅ 🔴 | 🔴 🔴 🔴 | ✅ 🔴 | 🔴 | +| [Theta](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.theta.html#darts.models.forecasting.theta.Theta) and [FourTheta](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.theta.html#darts.models.forecasting.theta.FourTheta) | [Theta](https://robjhyndman.com/papers/Theta.pdf) & [4 Theta](https://github.com/Mcompetitions/M4-methods/blob/master/4Theta%20method.R) | ✅ 🔴 | 🔴 🔴 🔴 | 🔴 🔴 | 🔴 | +| [StatsForecastAutoTheta](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.sf_auto_theta.html#darts.models.forecasting.sf_auto_theta.StatsForecastAutoTheta) | [Nixtla's statsforecast](https://github.com/Nixtla/statsforecast) | ✅ 🔴 | 🔴 🔴 🔴 | ✅ 🔴 | 🔴 | +| [Prophet](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.prophet_model.html#darts.models.forecasting.prophet_model.Prophet) | [Prophet repo](https://github.com/facebook/prophet) | ✅ 🔴 | 🔴 ✅ 🔴 | ✅ 🔴 | 🔴 | +| [FFT](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.fft.html#darts.models.forecasting.fft.FFT) (Fast Fourier Transform) | | ✅ 🔴 | 🔴 🔴 🔴 | 🔴 🔴 | 🔴 | +| [KalmanForecaster](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.kalman_forecaster.html#darts.models.forecasting.kalman_forecaster.KalmanForecaster) using the Kalman filter and N4SID for system identification | [N4SID paper](https://people.duke.edu/~hpgavin/SystemID/References/VanOverschee-Automatica-1994.pdf) | ✅ ✅ | 🔴 ✅ 🔴 | ✅ 🔴 | 🔴 | +| [Croston](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.croston.html#darts.models.forecasting.croston.Croston) method | | ✅ 🔴 | 🔴 🔴 🔴 | 🔴 🔴 | 🔴 | | **Global Baseline Models**
([GlobalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#global-forecasting-models-gfms)) | | | | | | -| [GlobalNaiveAggregate](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.global_baseline_models.html#darts.models.forecasting.global_baseline_models.GlobalNaiveAggregate) | | ✅ ✅ | 🔴 🔴 🔴 | 🔴 🔴 | ✅ | -| [GlobalNaiveDrift](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.global_baseline_models.html#darts.models.forecasting.global_baseline_models.GlobalNaiveDrift) | | ✅ ✅ | 🔴 🔴 🔴 | 🔴 🔴 | ✅ | -| [GlobalNaiveSeasonal](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.global_baseline_models.html#darts.models.forecasting.global_baseline_models.GlobalNaiveSeasonal) | | ✅ ✅ | 🔴 🔴 🔴 | 🔴 🔴 | ✅ | +| [GlobalNaiveAggregate](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.global_baseline_models.html#darts.models.forecasting.global_baseline_models.GlobalNaiveAggregate) | | ✅ ✅ | 🔴 🔴 🔴 | 🔴 🔴 | ✅ | +| [GlobalNaiveDrift](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.global_baseline_models.html#darts.models.forecasting.global_baseline_models.GlobalNaiveDrift) | | ✅ ✅ | 🔴 🔴 🔴 | 🔴 🔴 | ✅ | +| [GlobalNaiveSeasonal](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.global_baseline_models.html#darts.models.forecasting.global_baseline_models.GlobalNaiveSeasonal) | | ✅ ✅ | 🔴 🔴 🔴 | 🔴 🔴 | ✅ | | **Regression Models**
([GlobalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#global-forecasting-models-gfms)) | | | | | | -| [RegressionModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.regression_model.html#darts.models.forecasting.regression_model.RegressionModel): generic wrapper around any sklearn regression model | | ✅ ✅ | ✅ ✅ ✅ | 🔴 🔴 | ✅ | -| [LinearRegressionModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.linear_regression_model.html#darts.models.forecasting.linear_regression_model.LinearRegressionModel) | | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | -| [RandomForest](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.random_forest.html#darts.models.forecasting.random_forest.RandomForest) | | ✅ ✅ | ✅ ✅ ✅ | 🔴 🔴 | ✅ | -| [LightGBMModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.lgbm.html#darts.models.forecasting.lgbm.LightGBMModel) | | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | -| [XGBModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.xgboost.html#darts.models.forecasting.xgboost.XGBModel) | | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | -| [CatBoostModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.catboost_model.html#darts.models.forecasting.catboost_model.CatBoostModel) | | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | +| [RegressionModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.regression_model.html#darts.models.forecasting.regression_model.RegressionModel): generic wrapper around any sklearn regression model | | ✅ ✅ | ✅ ✅ ✅ | 🔴 🔴 | ✅ | +| [LinearRegressionModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.linear_regression_model.html#darts.models.forecasting.linear_regression_model.LinearRegressionModel) | | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | +| [RandomForest](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.random_forest.html#darts.models.forecasting.random_forest.RandomForest) | | ✅ ✅ | ✅ ✅ ✅ | 🔴 🔴 | ✅ | +| [LightGBMModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.lgbm.html#darts.models.forecasting.lgbm.LightGBMModel) | | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | +| [XGBModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.xgboost.html#darts.models.forecasting.xgboost.XGBModel) | | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | +| [CatBoostModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.catboost_model.html#darts.models.forecasting.catboost_model.CatBoostModel) | | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | | **PyTorch (Lightning)-based Models**
([GlobalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#global-forecasting-models-gfms)) | | | | | | -| [RNNModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.rnn_model.html#darts.models.forecasting.rnn_model.RNNModel) (incl. LSTM and GRU); equivalent to DeepAR in its probabilistic version | [DeepAR paper](https://arxiv.org/abs/1704.04110) | ✅ ✅ | 🔴 ✅ 🔴 | ✅ ✅ | ✅ | -| [BlockRNNModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.block_rnn_model.html#darts.models.forecasting.block_rnn_model.BlockRNNModel) (incl. LSTM and GRU) | | ✅ ✅ | ✅ 🔴 🔴 | ✅ ✅ | ✅ | -| [NBEATSModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.nbeats.html#darts.models.forecasting.nbeats.NBEATSModel) | [N-BEATS paper](https://arxiv.org/abs/1905.10437) | ✅ ✅ | ✅ 🔴 🔴 | ✅ ✅ | ✅ | -| [NHiTSModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.nhits.html#darts.models.forecasting.nhits.NHiTSModel) | [N-HiTS paper](https://arxiv.org/abs/2201.12886) | ✅ ✅ | ✅ 🔴 🔴 | ✅ ✅ | ✅ | -| [TCNModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tcn_model.html#darts.models.forecasting.tcn_model.TCNModel) | [TCN paper](https://arxiv.org/abs/1803.01271), [DeepTCN paper](https://arxiv.org/abs/1906.04397), [blog post](https://medium.com/unit8-machine-learning-publication/temporal-convolutional-networks-and-forecasting-5ce1b6e97ce4) | ✅ ✅ | ✅ 🔴 🔴 | ✅ ✅ | ✅ | -| [TransformerModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.transformer_model.html#darts.models.forecasting.transformer_model.TransformerModel) | | ✅ ✅ | ✅ 🔴 🔴 | ✅ ✅ | ✅ | -| [TFTModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tft_model.html#darts.models.forecasting.tft_model.TFTModel) (Temporal Fusion Transformer) | [TFT paper](https://arxiv.org/pdf/1912.09363.pdf), [PyTorch Forecasting](https://pytorch-forecasting.readthedocs.io/en/latest/models.html) | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | -| [DLinearModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.dlinear.html#darts.models.forecasting.dlinear.DLinearModel) | [DLinear paper](https://arxiv.org/pdf/2205.13504.pdf) | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | -| [NLinearModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.nlinear.html#darts.models.forecasting.nlinear.NLinearModel) | [NLinear paper](https://arxiv.org/pdf/2205.13504.pdf) | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | -| [TiDEModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tide_model.html#darts.models.forecasting.tide_model.TiDEModel) | [TiDE paper](https://arxiv.org/pdf/2304.08424.pdf) | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | -| [TSMixerModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tsmixer_model.html#darts.models.forecasting.tsmixer_model.TSMixerModel) | [TSMixer paper](https://arxiv.org/pdf/2303.06053.pdf), [PyTorch Implementation](https://github.com/ditschuk/pytorch-tsmixer) | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | +| [RNNModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.rnn_model.html#darts.models.forecasting.rnn_model.RNNModel) (incl. LSTM and GRU); equivalent to DeepAR in its probabilistic version | [DeepAR paper](https://arxiv.org/abs/1704.04110) | ✅ ✅ | 🔴 ✅ 🔴 | ✅ ✅ | ✅ | +| [BlockRNNModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.block_rnn_model.html#darts.models.forecasting.block_rnn_model.BlockRNNModel) (incl. LSTM and GRU) | | ✅ ✅ | ✅ 🔴 🔴 | ✅ ✅ | ✅ | +| [NBEATSModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.nbeats.html#darts.models.forecasting.nbeats.NBEATSModel) | [N-BEATS paper](https://arxiv.org/abs/1905.10437) | ✅ ✅ | ✅ 🔴 🔴 | ✅ ✅ | ✅ | +| [NHiTSModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.nhits.html#darts.models.forecasting.nhits.NHiTSModel) | [N-HiTS paper](https://arxiv.org/abs/2201.12886) | ✅ ✅ | ✅ 🔴 🔴 | ✅ ✅ | ✅ | +| [TCNModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tcn_model.html#darts.models.forecasting.tcn_model.TCNModel) | [TCN paper](https://arxiv.org/abs/1803.01271), [DeepTCN paper](https://arxiv.org/abs/1906.04397), [blog post](https://medium.com/unit8-machine-learning-publication/temporal-convolutional-networks-and-forecasting-5ce1b6e97ce4) | ✅ ✅ | ✅ 🔴 🔴 | ✅ ✅ | ✅ | +| [TransformerModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.transformer_model.html#darts.models.forecasting.transformer_model.TransformerModel) | | ✅ ✅ | ✅ 🔴 🔴 | ✅ ✅ | ✅ | +| [TFTModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tft_model.html#darts.models.forecasting.tft_model.TFTModel) (Temporal Fusion Transformer) | [TFT paper](https://arxiv.org/pdf/1912.09363.pdf), [PyTorch Forecasting](https://pytorch-forecasting.readthedocs.io/en/latest/models.html) | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | +| [DLinearModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.dlinear.html#darts.models.forecasting.dlinear.DLinearModel) | [DLinear paper](https://arxiv.org/pdf/2205.13504.pdf) | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | +| [NLinearModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.nlinear.html#darts.models.forecasting.nlinear.NLinearModel) | [NLinear paper](https://arxiv.org/pdf/2205.13504.pdf) | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | +| [TiDEModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tide_model.html#darts.models.forecasting.tide_model.TiDEModel) | [TiDE paper](https://arxiv.org/pdf/2304.08424.pdf) | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | +| [TSMixerModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.tsmixer_model.html#darts.models.forecasting.tsmixer_model.TSMixerModel) | [TSMixer paper](https://arxiv.org/pdf/2303.06053.pdf), [PyTorch Implementation](https://github.com/ditschuk/pytorch-tsmixer) | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | | **Ensemble Models**
([GlobalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#global-forecasting-models-gfms)): Model support is dependent on ensembled forecasting models and the ensemble model itself | | | | | | -| [NaiveEnsembleModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveEnsembleModel) | | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | -| [RegressionEnsembleModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.regression_ensemble_model.html#darts.models.forecasting.regression_ensemble_model.RegressionEnsembleModel) | | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | +| [NaiveEnsembleModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.baselines.NaiveEnsembleModel) | | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | +| [RegressionEnsembleModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.regression_ensemble_model.html#darts.models.forecasting.regression_ensemble_model.RegressionEnsembleModel) | | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | | **Conformal Models**
([GlobalForecastingModel](https://unit8co.github.io/darts/userguide/covariates.html#global-forecasting-models-gfms)): Model support is dependent on the forecasting model used | | | | | | -| [ConformalNaiveModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html#darts.models.forecasting.conformal_models.ConformalNaiveModel) | [Conformalized Prediction](https://arxiv.org/pdf/1905.03222) | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | -| [ConformalQRModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.regression_ensemble_model.html#darts.models.forecasting.conformal_models.ConformalQRModel) | [Conformalized Quantile Regression](https://arxiv.org/pdf/1905.03222) | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | +| [ConformalNaiveModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.conformal_models.html#darts.models.forecasting.conformal_models.ConformalNaiveModel) | [Conformalized Prediction](https://arxiv.org/pdf/1905.03222) | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | +| [ConformalQRModel](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.conformal_models.html#darts.models.forecasting.conformal_models.ConformalQRModel) | [Conformalized Quantile Regression](https://arxiv.org/pdf/1905.03222) | ✅ ✅ | ✅ ✅ ✅ | ✅ ✅ | ✅ | ## Community & Contact Anyone is welcome to join our [Gitter room](https://gitter.im/u8darts/darts) to ask questions, make proposals, diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index ffc4c5b446..40f1ecb98b 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -63,13 +63,48 @@ def __init__( ): """Base Conformal Prediction Model. + Base class for any probabilistic conformal model. A conformal model calibrates the predictions from any + pre-trained global forecasting model. It does not have to be trained, and can generated calibrated forecasts + directly using the underlying trained forecasting model. Since it is a probabilistic model, you can generate + forecasts in two ways (when calling `predict()`, `historical_forecasts()`, ...): + + - Predict the calibrated quantile intervals directly: Pass parameters `predict_likelihood_parameters=True`, and + `num_samples=1` to the forecast method. + - Predict stochastic samples from the calibrated quantile intervals: Pass parameters + `predict_likelihood_parameters=False`, and `num_samples>>1` to the forecast method. + + Conformal models can be applied to any of Darts' global forecasting model, as long as the model has been + fitted before. In general the workflow of the models to produce one calibrated forecast/prediction is as + follows: + + - Extract a calibration set: The number of calibration examples from the most recent past to use for one + conformal prediction can be defined at model creation with parameter `cal_length`. To make your life simpler, + we support two modes: + - Automatic extraction of the calibration set from the past of your input series (`series`, + `past_covariates`, ...). This is the default mode and our predict/forecasting/backtest/.... API is + identical to any other forecasting model + - Supply a fixed calibration set with parameters `cal_series`, `cal_past_covariates`, ... . + - Generate historical forecasts on the calibration set (using the forecasting model) + - Compute the errors/non-conformity scores (specific to each conformal model) on these historical forecasts + - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model + creation with parameter `quantiles`). + - Compute the conformal prediction: Add the calibrated intervals to (or adjust the existing intervals of) the + forecasting model's predictions. + + Some notes: + + - When computing historical_forecasts(), backtest(), residuals(), ... the above is applied for each forecast + (the forecasting model's historical forecasts are only generated once for efficiency). + - For multi-horizon forecasts, the above is applied for each step in the horizon separately + Parameters ---------- model A pre-trained global forecasting model. quantiles A list of quantiles centered around the median `q=0.5` to use. For example quantiles - [0.1, 0.5, 0.9] correspond to a (0.9 - 0.1) = 80% coverage interval around the median (model forecast). + [0.1, 0.2, 0.5, 0.8 0.9] correspond to two intervals with (0.9 - 0.1) = 80%, and (0.8 - 0.2) 60% coverage + around the median (model forecast). symmetric Whether to use symmetric non-conformity scores. If `False`, uses asymmetric scores (individual scores for lower- and upper quantile interval bounds). @@ -851,13 +886,58 @@ def __init__( ): """Naive Conformal Prediction Model. + A probabilistic model that adds calibrated intervals around the median forecast from a pre-trained + global forecasting model. It does not have to be trained and can generated calibrated forecasts + directly using the underlying trained forecasting model. It supports two symmetry modes: + + - `symmetric=True`: + - The lower and upper interval bounds are calibrated with the same magnitude. + - Non-conformity scores: uses metric `ae()` (see absolute error :func:`~darts.metrics.metrics.ae`) to + compute the non-conformity scores on the calibration set. + - `symmetric=False` + - The lower and upper interval bounds are calibrated separately. + - Non-conformity scores: uses metric `err()` (see error :func:`~darts.metrics.metrics.err`) to compute the + non-conformity scores on the calibration set for the upper bounds, an `-err()` for the lower bounds. + + Since it is a probabilistic model, you can generate forecasts in two ways (when calling `predict()`, + `historical_forecasts()`, ...): + + - Predict the calibrated quantile intervals directly: Pass parameters `predict_likelihood_parameters=True`, and + `num_samples=1` to the forecast method. + - Predict stochastic samples from the calibrated quantile intervals: Pass parameters + `predict_likelihood_parameters=False`, and `num_samples>>1` to the forecast method. + + Conformal models can be applied to any of Darts' global forecasting model, as long as the model has been + fitted before. In general the workflow of the models to produce one calibrated forecast/prediction is as + follows: + + - Extract a calibration set: The number of calibration examples from the most recent past to use for one + conformal prediction can be defined at model creation with parameter `cal_length`. To make your life simpler, + we support two modes: + - Automatic extraction of the calibration set from the past of your input series (`series`, + `past_covariates`, ...). This is the default mode and our predict/forecasting/backtest/.... API is + identical to any other forecasting model + - Supply a fixed calibration set with parameters `cal_series`, `cal_past_covariates`, ... . + - Generate historical forecasts on the calibration set (using the forecasting model) + - Compute the errors/non-conformity scores (as defined above) on these historical forecasts + - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model + creation with parameter `quantiles`). + - Compute the conformal prediction: Add the calibrated intervals to the forecasting model's predictions. + + Some notes: + + - When computing historical_forecasts(), backtest(), residuals(), ... the above is applied for each forecast + (the forecasting model's historical forecasts are only generated once for efficiency). + - For multi-horizon forecasts, the above is applied for each step in the horizon separately + Parameters ---------- model A pre-trained global forecasting model. quantiles A list of quantiles centered around the median `q=0.5` to use. For example quantiles - [0.1, 0.5, 0.9] correspond to a (0.9 - 0.1) = 80% coverage interval around the median (model forecast). + [0.1, 0.2, 0.5, 0.8 0.9] correspond to two intervals with (0.9 - 0.1) = 80%, and (0.8 - 0.2) 60% coverage + around the median (model forecast). symmetric Whether to use symmetric non-conformity scores. If `True`, uses metric `ae()` (see :func:`~darts.metrics.metrics.ae`) to compute the non-conformity scores. If `False`, uses metric `-err()` @@ -932,13 +1012,60 @@ def __init__( ): """Conformalized Quantile Regression Model. + A probabilistic model that calibrates the quantile predictions from a pre-trained probabilistic global + forecasting model. It does not have to be trained and can generated calibrated forecasts + directly using the underlying trained forecasting model. It supports two symmetry modes: + + - `symmetric=True`: + - The lower and upper quantile predictions are calibrated with the same magnitude. + - Non-conformity scores: uses metric `incs_qr(symmetric=True)` (see Non-Conformity Score for Quantile + Regression :func:`~darts.metrics.metrics.incs_qr`) to compute the non-conformity scores on the calibration + set. + - `symmetric=False` + - The lower and upper quantile predictions are calibrated separately. + - Non-conformity scores: uses metric `incs_qr(symmetric=False)` (see Non-Conformity Score for Quantile + Regression :func:`~darts.metrics.metrics.incs_qr`) to compute the non-conformity scores for the upper and + lower bound separately. + + Since it is a probabilistic model, you can generate forecasts in two ways (when calling `predict()`, + `historical_forecasts()`, ...): + + - Predict the calibrated quantile intervals directly: Pass parameters `predict_likelihood_parameters=True`, and + `num_samples=1` to the forecast method. + - Predict stochastic samples from the calibrated quantile intervals: Pass parameters + `predict_likelihood_parameters=False`, and `num_samples>>1` to the forecast method. + + Conformal models can be applied to any of Darts' global forecasting model, as long as the model has been + fitted before. In general the workflow of the models to produce one calibrated forecast/prediction is as + follows: + + - Extract a calibration set: The number of calibration examples from the most recent past to use for one + conformal prediction can be defined at model creation with parameter `cal_length`. To make your life simpler, + we support two modes: + - Automatic extraction of the calibration set from the past of your input series (`series`, + `past_covariates`, ...). This is the default mode and our predict/forecasting/backtest/.... API is + identical to any other forecasting model + - Supply a fixed calibration set with parameters `cal_series`, `cal_past_covariates`, ... . + - Generate historical forecasts (quantile predictions) on the calibration set (using the forecasting model) + - Compute the errors/non-conformity scores (as defined above) on these historical quantile predictions + - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model + creation with parameter `quantiles`). + - Compute the conformal prediction: Calibrate the predicted quantiles from the forecasting model's predictions. + + Some notes: + + - When computing historical_forecasts(), backtest(), residuals(), ... the above is applied for each forecast + (the forecasting model's historical forecasts are only generated once for efficiency). + - For multi-horizon forecasts, the above is applied for each step in the horizon separately + Parameters ---------- model A pre-trained probabilistic global forecasting model using a `likelihood`. quantiles A list of quantiles centered around the median `q=0.5` to use. For example quantiles - [0.1, 0.5, 0.9] correspond to a (0.9 - 0.1) = 80% coverage interval around the median (model forecast). + [0.1, 0.2, 0.5, 0.8 0.9] correspond to two intervals with (0.9 - 0.1) = 80%, and (0.8 - 0.2) 60% coverage + around the median (model forecast). symmetric Whether to use symmetric non-conformity scores. If `True`, uses symmetric metric `incs_qr(..., symmetric=True)` (see :func:`~darts.metrics.metrics.incs_qr`) to compute the non-conformity From 6d1572d6c9e93ca9b4f8c3de5d85356d55f6bcf5 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 3 Oct 2024 18:32:12 +0200 Subject: [PATCH 53/78] add sketch of cp example notebook --- .../23-Conformal-Prediction-examples.ipynb | 5734 +++++++++++++++++ 1 file changed, 5734 insertions(+) create mode 100644 examples/23-Conformal-Prediction-examples.ipynb diff --git a/examples/23-Conformal-Prediction-examples.ipynb b/examples/23-Conformal-Prediction-examples.ipynb new file mode 100644 index 0000000000..4f27a62a4e --- /dev/null +++ b/examples/23-Conformal-Prediction-examples.ipynb @@ -0,0 +1,5734 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "45bd6e88-1be9-4de1-9933-143eda71d501", + "metadata": {}, + "source": [ + "# Conformal Prediction Models\n", + "\n", + "The following is a in depth demonstration of the regression models in Darts - from basic to advanced features, including:\n", + "\n", + "- Darts' regression models\n", + "- lags and lagged data extraction\n", + "- covariates usage\n", + "- parameters output_chunk_length in relation with multi_models\n", + "- one-shot and auto-regressive predictions\n", + "- multi output support\n", + "- probablistic forecasting\n", + "- explainability\n", + "- and more" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3ef9bc25-7b86-4de5-80e9-6eff27025b44", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# fix python path if working locally\n", + "from utils import fix_pythonpath_if_working_locally\n", + "\n", + "fix_pythonpath_if_working_locally()\n", + "\n", + "# activate javascript\n", + "from shap import initjs\n", + "\n", + "initjs()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9d9d76e9-5753-4762-a1cb-c8c61d0313d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "%matplotlib inline\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from darts import TimeSeries, concatenate\n", + "from darts.models import (\n", + " ConformalNaiveModel,\n", + " ConformalQRModel,\n", + " LightGBMModel,\n", + " LinearRegressionModel,\n", + ")\n", + "from darts import metrics\n", + "from darts.datasets import ElectricityConsumptionZurichDataset" + ] + }, + { + "cell_type": "markdown", + "id": "eacf6328-6b51-43e9-8b44-214f5df15684", + "metadata": {}, + "source": [ + "### Input Dataset\n", + "For this notebook, we use the Electricity Consumption Dataset from households in Zurich, Switzerland.\n", + "\n", + "The dataset has a quarter-hourly frequency (15 Min time intervals), but we resample it to hourly \n", + "frequency to keep things simple.\n", + "\n", + "**Target series** (the series we want to forecast):\n", + "- **Value_NE5**: Electricity consumption by households on grid level 5 (in kWh).\n", + "\n", + "**Covariates** (external data to help improve forecasts):\n", + "The dataset also comes with weather measurements that we can use as covariates. For simplicity, we use:\n", + "- **T [°C]**: Measured temperature\n", + "- **StrGlo [W/m2]**: Measured solar irradation\n", + "- **RainDur [min]**: Measured raining duration" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ea0d05f6-03cc-4422-afed-36acb2b94fa7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/dennisbader/miniconda3/envs/darts310/lib/python3.10/site-packages/xarray/groupers.py:403: FutureWarning: 'H' is deprecated and will be removed in a future version, please use 'h' instead.\n", + " self.index_grouper = pd.Grouper(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ts_energy = ElectricityConsumptionZurichDataset().load()\n", + "\n", + "# extract values recorded between 2017 and 2019\n", + "start_date = pd.Timestamp(\"2017-01-01\")\n", + "end_date = pd.Timestamp(\"2019-01-31\")\n", + "ts_energy = ts_energy[start_date:end_date]\n", + "\n", + "# resample to hourly frequency\n", + "ts_energy = ts_energy.resample(freq=\"H\")\n", + "\n", + "# extract temperature, solar irradiation and rain duration\n", + "ts_weather = ts_energy[[\"T [°C]\", \"StrGlo [W/m2]\", \"RainDur [min]\"]]\n", + "\n", + "# extract households energy consumption\n", + "ts_energy = ts_energy[\"Value_NE5\"]\n", + "\n", + "# create train and validation splits\n", + "validation_cutoff = pd.Timestamp(\"2018-10-31\")\n", + "ts_energy_train, ts_energy_val = ts_energy.split_after(validation_cutoff)\n", + "\n", + "ts_energy.plot()\n", + "plt.show()\n", + "\n", + "ts_weather.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "4fefe4e3-1fee-4f52-a2d9-5b2d24d928d3", + "metadata": {}, + "source": [ + "## Darts Conformal Prediction Models\n", + "\n", + "*Conformal prediction is a technique for constructing prediction intervals that try to achieve valid coverage in finite samples, without making distributional assumptions.* [(source)](https://arxiv.org/pdf/1905.03222)\n", + "\n", + "In other words: If we want a prediction interval that includes 80% of all actual values over some period of time, then a conformal model tries to build such an interval with actually has 80% of points inside.\n", + "... WIP" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "6a3f3753-b7db-448c-942a-9db51390b1b9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "input_length = 24\n", + "horizon = 24\n", + "\n", + "model = LinearRegressionModel(lags=input_length, output_chunk_length=horizon)\n", + "model.fit(ts_energy_train)\n", + "pred = model.predict(horizon)\n", + "\n", + "ts_energy_train[-2*horizon:].plot(label=\"training\")\n", + "ts_energy_val[:horizon].plot(label=\"validation\")\n", + "pred.plot(label=\"forecast\")" + ] + }, + { + "cell_type": "markdown", + "id": "f58cf17c-fb1a-4f3f-bd0a-bb2445c84a04", + "metadata": {}, + "source": [ + "### Hist fc over validation series" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "id": "788660a0-b879-435b-8fbd-235436c0f3d8", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "000eae68dd4a48de9de0019ae7bf5734", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "historical forecasts: 0%| | 0/1 [00:00" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hist_fc = model.historical_forecasts(\n", + " series=ts_energy_val,\n", + " forecast_horizon=horizon,\n", + " stride=horizon,\n", + " last_points_only=False,\n", + " retrain=False,\n", + " verbose=True,\n", + ")\n", + "hist_fc = concatenate(hist_fc)\n", + "print(metrics.mae(ts_energy_val, hist_fc))\n", + "\n", + "fig, ax = plt.subplots(figsize=(12, 6))\n", + "end_ts = ts_energy_val.start_time() + 2 * 7 * horizon * ts_energy_val.freq\n", + "ts_energy_val[:end_ts].plot()\n", + "hist_fc[:end_ts].plot()" + ] + }, + { + "cell_type": "markdown", + "id": "14573b68-537c-4916-a9b5-a4eb7bb84400", + "metadata": {}, + "source": [ + "### Point Forecasts Are not so good\n", + "No idea about uncertainty. Can we do better?" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "f47c68a5-922f-4e36-b10a-ea34162c0250", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "10eebeb049d447fe94271b11d718c427", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "historical forecasts: 0%| | 0/1 [00:00" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "quantiles = [0.05, 0.1, 0.5, 0.9, 0.95]\n", + "cp_model = ConformalNaiveModel(model=model, quantiles=quantiles, cal_length=7*horizon)\n", + "pred_params = {\"predict_likelihood_parameters\": True}\n", + "# pred_params = {\"num_samples\": 500}\n", + "\n", + "cp_hist_fc = cp_model.historical_forecasts(\n", + " series=ts_energy_val,\n", + " forecast_horizon=horizon,\n", + " stride=horizon,\n", + " last_points_only=False,\n", + " retrain=False,\n", + " verbose=True,\n", + " **pred_params\n", + ")\n", + "cp_hist_fc = concatenate(cp_hist_fc)\n", + "\n", + "fig, ax = plt.subplots(figsize=(12, 6))\n", + "ts_energy_val[:end_ts].plot()\n", + "cp_hist_fc[:end_ts].plot()" + ] + }, + { + "cell_type": "markdown", + "id": "1e854774-bbfe-4ff3-b0c8-3734973724c9", + "metadata": {}, + "source": [ + "### What's the overall coverage?" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "845ce322-e5de-45fa-9d7c-f3bddbd1f0a3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " q0.05-q0.95 q0.1-q0.9\n", + "Interval Width 10054.736762 6305.233124\n", + "Interval Coverage 0.851908 0.719880\n" + ] + } + ], + "source": [ + "def compute_backtest(forecasts):\n", + " bt = cp_model.backtest(\n", + " series=ts_energy_val,\n", + " historical_forecasts=forecasts,\n", + " last_points_only=True,\n", + " metric=[metrics.miw, metrics.mic],\n", + " metric_kwargs={\"q_interval\": cp_model.q_interval},\n", + " )\n", + " bt_df = pd.DataFrame(bt).T\n", + " bt_df.columns = [\"q0.05-q0.95\", \"q0.1-q0.9\"]\n", + " bt_df.index = [\"Interval Width\", \"Interval Coverage\"]\n", + " return bt_df\n", + "\n", + "print(compute_backtest(cp_hist_fc))" + ] + }, + { + "cell_type": "markdown", + "id": "8fb59539-b8a5-40ef-90c8-f1e429e3d656", + "metadata": {}, + "source": [ + "Ideally we should be at 90% and 80% overall coverage" + ] + }, + { + "cell_type": "markdown", + "id": "910cf6a7-df6b-4ac3-a17c-78949c974949", + "metadata": {}, + "source": [ + "### What's the interval width over time?" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "4fce24be-58dd-4e09-96c2-0e6185b7e34a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAGvCAYAAABB3D9ZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADNyklEQVR4nOydd3gU1dfHv7Ob3gklBBIgofcuPfQWpAoIiggqYBdRERsiIvIiCP4AlV4URRRRuogISO/FSGihhBBaCCWbssnuff+YTNtski2zuzOz9/M8PNzdnZ29ezJ775nvOfdchhBCQKFQKBQKhaJCdJ7uAIVCoVAoFIqjUEeGQqFQKBSKaqGODIVCoVAoFNVCHRkKhUKhUCiqhToyFAqFQqFQVAt1ZCgUCoVCoagW6shQKBQKhUJRLdSRoVAoFAqFolqoI+MgZrMZly9fhtls9nRXNA21s+uhNnY91MbugdrZ9SjRxtSRoVAoFAqFolqoI0OhUCgUCkW1UEeGQqFQKBSKaqGODIVCoVAoFNVCHRkKhUKhUCiqhToyFAqFQqFQVAt1ZCgUCoVCoagW6shQKBQKhUJRLdSRoVAoFAqFolqoI0OhUCgUCkW1UEeGQqFQKBSKaqGODIVCoVAoFNVCHRkKhUKhUCiqhToyFAqFQqFQVAt1ZCgAgLNnz2L58uXIzMz0dFc0S05ODr777jscPnzY012hUCgUzUAdGQp+/vlnNGnSBM899xxq166NlStXghDi6W5pijt37qBTp04YOXIkWrVqhWeeeQa3bt3ydLcoFApF9VBHxsuZN28ennzySRiNRgDshDtq1Ch06tQJSUlJHu6dNrh8+TLatWsnUWK+//571K5dG19//TVMJpMHe0ehUCjqhjoyXgohBO+99x5ef/11Xn2pV68e//qePXvQtGlTbNiwwVNd1AQnTpxA27ZtceHCBQBAxYoVUaZMGQDAgwcP8Morr2DgwIHIz8/3ZDcpFApFtVBHxgvJz8/H6NGjMWPGDP65Dz74AP/++y+2bt2K6tWr88cNHToUO3fulO2zFy1ahISEBPz555+ynVOp7Ny5Ex07dsTNmzcBAHXq1MGhQ4eQnJyMUaNG8cdt3LgRI0eOlE2ZuXbtGnr37o1XX31Vsw5SQUGBp7ugeQgh1M4UdUAoDmEymUhKSgoxmUye7opdZGVlkcTERAKAACAMw5D58+dLjsnJySHDhw/njwkODiYHDx4s9px37twhhw8fJgaDocTPPnv2LNHpdPw5k5OTJa/n5uaSFStWkF27dvHPqdXOP/30E/Hz8+Nt2LZtW3L37l3JMdu2bSMBAQH8MePGjSNms9nq+UwmEzly5Ai5du1ascdw9OnThz/nO++8U+T148ePk2+//ZY8fPiQP7eabLx582YSEhJCEhMTVdNntdnYaDSSxx57jERERJBDhw55ujs2ozY7qxEl2pg6Mg6ixD9mady9e5e0bt2an+T8/PzIzz//bPVYo9FI+vbtyx9bpkwZcubMmSLH/fLLLyQ8PJwAIHq9njRr1oy8/PLLEmeEY9iwYfz5AJCGDRuS7OxsQgghBoOBdO/enT/P9evXCSHqtPP8+fMJwzD89+zbt2+xTt6mTZuIj48Pf+y7775b5Jj09HTStWtX/phKlSqRQYMGkTlz5hQ574EDByQ2BkA2bdrEv/7jjz8SvV5PAJBJkyYRQtRn44EDB/Lf7ejRo57ujk2ozca7d+/mbTxixAhPd8dm1GZnNaJEG1NHxkGU+McsievXr5O6devyg1NYWBj5+++/S3xPTk4O6dy5s0SZmTBhAklNTSU5OTnklVdeKTJpiv+tWrWKP9fp06etHjN27FiSlZUl+RwAfN/UZGez2UwmT54s+R7PPfccyc/PL/F9P/zwg8TxSUhIIJs3byZms5ns2LGDREVFFWvj1q1bk7y8PP5c3bp1K3JMZGQkuXbtGvnuu+94RQwA6d+/PyFEXTYmhJAWLVrw32HevHme7o5NqM3G33//PW/j6tWre7o7NqM2O6sRJdqYOjIOosQ/ZnGkpqaS6tWr8wNTVFQUOXHihE3vffjwIWnZsqVkYvT19SVxcXGS5zp27EgaNGggmZCDgoLIv//+SwiR3kWPGzeOBAUF8Y9r1qxZZPLdsWMHIUQ9djabzWTSpEmS7/D++++XGgbi+Pbbb4vYoEaNGhJ7VqpUiXTr1o2EhoZKjnvjjTcIIdK76Pj4eNK/f3/JZCQ+FwDy+OOPE0LUY2OOihUr8t/hqaee8nR3bEJtNp4xY4bkWrl165anu2QTarOzGlGijakj4yBK/GNa49q1axInJi4ujly6dMmuc2RmZpKXX35Zks/B/QsICCCLFi3iJ+wHDx6QZ599ln+9du3akgk2OjqaZGdnkxUrVpSo5vzxxx+EEHXY2Ww2k3fffVfS/zlz5th9nrVr15LatWtbtUevXr3I7du3CSGEFBQUkB07dkhycH7++WeSkJDAP165ciW5d+8eqVatWrE27t27NyFEHTbmMBqNEocsLi6uyDF5eXmKm3jVZGNCCHnttdck18rvv/9e5Ji0tDTFfR+12VmNKNHG1JFxECX+MS25du0aiY+Pl9yVX7t2zeHz3bp1i3zwwQckIiKCd1JOnTpV5Ljs7GzSqFEj/nP9/f2thgJGjRrFP1+mTBkyYMAA/vHmzZsJIcq3s9lsJhMnTpQM+l9//bXD5zOZTGT9+vV8LpNeryczZsyw+v2//vprqzauXbs2KSgoIIQQcujQIeLr68u/9vzzz/Pt7t2785+pZBuLuXbtWhGHLD09nX/94cOHJC4ujuh0OrJx40YP9lSKmmxMCCGDBg2S2Ngyd2vatGkEAOnZs6fNqqM7UJud1YgSbUwdGQdR4h9TTFZWFqlRo4bEiUlNTZXl3I8ePSJ79+4lubm5xR5z/vx5EhYWJhkMY2NjJe/JysoigwcPJq1btyYnT57kB0cAZMOGDYQQ5dt55syZku/4zTffyHJes9lMTp8+TVJSUko85qmnnioysf/444+S43744QdSp04dMm3aNPLo0SP+uC5duhBClG9jMdaSmX/99Vf+9ZUrV/LPDxgwwIM9laImGxNCSKtWrSQ2TkhI4F/Lz88n5cqV41+7cuWKB3sqRW12ViNKtDGtI6NRfv31V1y8eBEAUKNGDezatQsxMTGynDskJATt2rWDv79/scfUrFkTy5cvlzz30UcfSd4THByMn3/+GQcOHEDjxo2h1+v519RQ7dZkMmHmzJn842+++QYvvviiLOdmGAYNGzZEXFxciccsXLgQdevW5Z9r0KABhg4dKjlu+PDhOHv2LD744AP4+PhI+q82rl+/XuS5AwcO8O3ffvuNb+/du5duteEglnY+cuQIX5No//79uHv3Lv/a3r173do3CsUS6sholI0bN/LtJUuWyObE2MOgQYPw4YcfAgAee+wxSRE4a6jNkTl06BA/oA8YMEA2J8YeQkJC8Msvv6B8+fLw9fXF3LlzodMV/7NWm40tSUtLK/Ic58hkZ2dj27Zt/PN3797F+fPn3dY3rWAymfgijhw5OTk4ffo0AGD9+vWS16gjQ/E01JHRIEajkR/QIyMj0a5dO4/15dNPP0Vqair27NkDX1/fEo8VT7JqqCgq3r6hf//+HutHvXr1cOHCBaSlpaFr164lHqtFR+bo0aMwGo3Yvn07cnJyJK/9888/7uqaZrh165bVa+PAgQMghBRxZKiNKZ6GOjIaZPfu3Xj06BEAoE+fPpJwgieIiYkpMQzFobZJllO9GIZBnz59PNqX8PBwlC9fvtTjxGqNGpxFS8SOTIsWLQAAubm5OHXqVJEJFqBqgSNYszHAOjInT57E1atXJccnJSXh3r17busfhWIJdWQ0iFgp6Nu3rwd7Yh9qyt+4dOkS/vvvPwBAmzZtbHIilALnMCrdxtYQ524MHjyYb//zzz+8YxkaGso7ztSRsR+xjRMTExEQEACAdWTEzqL4mt+/f7/7OkihWEAdGY1BCOEHdF9fX/Ts2dPDPbIdNSky4hykfv36ebAn9sM5jEq3sTU4tSA8PBzdu3fnn587dy4yMzMBsJPvY489BoB1ONPT093fURUjVmTi4uLQsmVLAMDly5exYsUK/rXJkyfzbeowUjwJdWQ0xpkzZ3jpt1OnTggLC/Nwj2xHTY6MWlUvQL2KDCGEn2QrV66MRo0aISgoCACQmprKHzdw4EC0b9+ef0wnWfsQOzKVK1dGmzZt+MecnVu3bo0hQ4bwz9M8GYonoY6MxlCzUqCWZN/MzEzs2bMHAFC9enXJ8mc1oFZHJjMzE7m5uQDYvCsfHx9eLeDw8/ND7969qSPjBGJHJiYmRuLIcAwcOBBRUVGoWbMmAHZ5tmWiNYXiLqgjozHUrBSoJUdm27ZtfP/69u0LhmE83CP74BwZJTuL1hDnblSuXBkAikyy3bp1Q1hYGNq2bcv/XVzlyPz999/47LPP8ODBA5ec31NY2rk4RwYAOnToAADIz8/H0aNHZe9LRkYGpk+fzt84UCjWoI6Mhrh58yYOHz4MAGjUqBGqVq3q4R7Zh1pCS2pWvQD1KjKWIQ+gqCMzYMAAAEBERAQaNmwIADh58iQePnwIADh9+jSeeeYZ/Prrr0715e7du+jTpw8+/PBDvPHGG06dS2lwdg4JCUFYWBiioqIkhRnr1avHKzFi5YsLLxmNRkyePBlvvPGG0yrNe++9hw8++AA9e/akuU6UYqGOjIbYtGkT31abGgOow5HJz8/Hli1bALAJp+KBXC2oNdnXmiPTunVr/jmGYSSOJfe3MZvNOHjwIC5duoSuXbvi+++/x7Bhw3Dr1i2H+7Jz505+kl6zZg0yMjIcPpeSsMxD4hA7jJwaA6BICI8QghdffBGffvop/ve//2HGjBlO9YUb03Jzc7Fs2TKHz0XRNtSR0RBaUQoA5YY99u7dy4cSEhMTSy3yp0S0oMhwlaorVKjAF3x8/PHHERUVxR8jnmQ3btyIPn368JWY8/PzJStw7GXXrl18Oy8vDytXrnT4XEri4cOHMBgMACCpBs4pXb6+vnj66af552vUqIEKFSoAYJdgT58+XbI1ydKlSx3+LV+4cEGiwixevFh11yzFPVBHRiMQQrBz504AQFRUlKSQlVpQgyLD2RhQp+oFqNeRsZYjAwC///471q1bh++++05yPJe/AQDz58/HuXPnJK8vWbLE4b2Y/v77b8njRYsWaWJfp+JsPHjwYPz55584cuSIJLmdYRjezg8ePOC3JOFIS0uTbBthD5Y2vnr1KrZv3+7QuSjahjoyGsFoNCIrKwsAULt27RL321Eqakj2FW+WV6dOHQ/2xHHUmuxrLbQEAGXLlsWgQYMQHh4uOT4mJqZInlj58uXRvHlzAMDFixclyoqtpKenIzk5WfLcuXPnsHv3brvPpTSKszHDMOjWrRsaN25c5D3Wwqu9e/fm24sXL3aoL5aODAAsXLjQoXNRtI36ZjuKVbgtCQA2SU+NqEGR0ZKdlWrj4uAmWT8/P5QrV86m94gnWX9/f/z++++YOHEi/9yiRYuKfe+DBw/w2WefFUkMFjssYmdWC5OstfBdaVg6MqNGjcKGDRt4R2jTpk1W98ji2LRpEyZPnixZ/UUI4Z3M0NBQVKpUyaZzUbwTuxyZhQsXYsiQIWjZsiX++OOPIq8XFBTgySefxBNPPCF5PikpCcOHD0e7du0wduxYSdwzNzcXH330ERISEtCnT58iMuTGjRuRmJiIjh074pNPPuG3kqdIEU+woaGhHuyJ46jNkVGrndWe7FupUiWbFUdx0baVK1eiTZs26N+/P+8I/frrrxKVjSMrKws9e/bEhx9+iMGDB0uWFouVgpkzZ/LnWrduHe7cuWP/F1MQxSkyJdGkSRNUr14dAFuEc+HChfDx8cFzzz0HgE22FufNiFmyZAn69u2LTz/9FK+//jr/fHJyMp+M3aFDBzz//PMA2Gt26dKl9n8xiqaxy5GJjY3FW2+9hfr161t9fe3atUXuUo1GIyZOnIhhw4Zh586daNCggaS09cKFC/HgwQNs2bIF06dPx4wZM/jKtBcvXsScOXMwa9YsbN68GTdu3KAXcTFoYYJVQ7KvluysJkcmJyeHXxlk6wQLsLuS79y5E8ePH8eTTz4JgFVmnn32WQDs+GSZW5OXl4cBAwbg0KFDAFh1YN68efzrnFLg4+ODzp07Y/To0QCEBOL09HRMmTIFTZo0wdtvv+3YF/YQxeXIlISPjw927dqF9evX448//oCfnx8A4Pnnn+dr+SxZsgRms1nyvrVr12Ls2LH84x9//BE3b94EIE2m7tSpE1544QXeeV2yZAmMRiN+++039OrVC23btsXFixft/7IU7UAcYMyYMWTbtm2S5+7evUsGDx5M/vnnHzJo0CD++f3795MnnniCf5ydnU3atm1Lbty4QQghpEePHuTMmTP86x999BFZtGgRIYSQefPmkenTp/OvHT58mPTr18+RLsuOyWQiKSkpxGQyeborhBBC9u3bRwAQAOTNN9/0dHccYufOnfx3mDRpEiFEeXZu2bIlAUAYhiFms9nT3XGIhg0bEgAkMDCQEKI8G1vj4sWL/LUxdOhQp8939uxZ/nx16tTh/5b5+flk4MCB/GvcPz8/P3L79m2SlpbGP9e2bVtCCCHnz5/nnwsLCyO+vr6S996+fVsVNiaEkMcff5zvNzdGO0OvXr3484nnjK1btxaxEwAydepUQgghQ4YM4Z87cuQIIYSQPn368M+VK1dO8r4PPviAEKKOa1ntKNHGQnalk8ybNw+jR4/md0rlSElJQY0aNfjHgYGBiImJQUpKCoKDg5GRkSF5vVatWkhKSuLfK65fULNmTaSlpSE3N7fI53AYjUYYjUbJcz4+PvxdglxwdxeWdxmeQhxfDg4OVky/7EFcIbegoABms1lxduYUmZCQEBBCVLlSRZzsq0QbW0O8l1LlypWd7mutWrWQkJCAPXv2IDk5GR999BH0ej0OHjzIr4wJCgpCx44dsXXrVhiNRixevBhVqlThz9GpUyeYzWZUr14dXbp0wc6dO/nCe2IePXqEMmXKAFC2jQEhtOTj44Ny5co53d/nn3+eTxeYNm0aTpw4gVu3bmHhwoV8msDAgQPx+++/w2w249tvv8U777zDKzJhYWFo3LgxzGYzxowZg82bNwNAkXDgo0ePVHMtqx1329iWMLIsjszp06dx7do1fPzxxzh27JjktZycHAQHB0ueCw4ORk5ODrKzs6HX6yVOSXBwMLKzs62+lwtb5eTkFOvILF++vEiW/JAhQzB06FDHv2AJiAdYT5KSksK3CwoK+PCcmhDnF2RmZkq+g1LsfP/+fQDsJKdGGwNC2M5kMinSxtY4efIk3w4MDJTF9gMGDOBL33/22WeS1/z8/PDNN9+gatWq2LZtGwghmD9/Pl+zBmATfbl+PPXUU/zS/DJlyiAwMBA3btwAwC4b5px0JdsYAK5duwaAXd0lDjM5SqNGjVCuXDncvXsXe/fuLbJdRGJiImbOnAmDwYDt27fjxo0bePfdd/mxoEWLFnw/6tevj+rVq+PSpUv8Y+6mV6njhZZxl43FVaWLw2lHxmw2Y9asWXj33Xet7jkTGBjIF1jiMBgMCAwMRFBQEEwmk0RhMRgM/I62lu/llhcHBgYW25/Ro0dLCjYBrlNkUlNTERsbq4ilzmLHLjY2VnXbEwCQJIEHBQWhatWqirMz52RHRESo0sYA+JsDs9mMKlWqgBCiKBtbQ6yyNmjQQBbbjx07FrNmzeIdDo7Q0FAsX76cr2CbmJiIzZs3Iz09Hb/99hsAtjDcwIED+bFq9OjRiI2NxcOHD9G7d2+89NJLfO5NxYoVERsbq3gb5+Xl8XlIVatWle36fu211/Dxxx8XeX7QoEFYvXo1/Pz88Pbbb/NK2Ndff80fk5iYKOnH33//jb/++gutW7eGwWDg62UpdbzQIkq0sdOOjMFgQHJyMiZMmACATXgzGAzo2bMnfv/9d8THx2P9+vX88Tk5Obh+/Tri4+MRFhaGsmXL4uLFi2jQoAEA4Pz584iPjwcAxMfHS5K4Lly4gMqVKxerxgDsnZTcTktJ6HQ6RfwxuQkWYEvnK6FP9iKukms2myXfQQl2JoTwznRoaKjH++Mo4qRqQJBulWDj4hA7G3INoMHBwdi9eze2bduGkJAQVKhQAeXLl0etWrUkNWlee+01PqTBqVmtWrUqsrChR48efLu4a1nJNhZv2VC5cmXZ+vn+++8jPj4ejx49Qvny5VGhQgVUrlyZX+kEsJt91qlTB8nJyZJE/86dO0v6ERsbi1GjRgEAzpw5wz+vxPFC6yjJxnY5MgUFBTCZTCCEoKCgAHl5eQgKCuL3ngHYMNO8efOwePFi+Pv7o3nz5sjJycHGjRvRs2dPLF26FPXq1UN0dDQA1uNesmQJPvvsM6SkpGDPnj186fBevXph3LhxGDhwIGJiYrBs2TJJoSWKgBbqmyi9IF5OTg4fF1arjYGiy9zFdlcqjtQ3sYUaNWrg1VdfLfGY7t27o2bNmrhw4QL/XOfOnUt8jxpKCVjiKhv7+PhgxIgRJR7DMAxeffVVyd8iIiLCagE+DjWscqS4B7vcqWnTpqFdu3Y4ceIEPv74Y75drlw5/l9YWBh0Oh3KlSsHhmHg5+eHmTNnYvXq1ejcuTNOnTqFqVOn8uccN24cQkJC0KtXL0yaNAmTJk1CtWrVALCDzPjx4/Hmm28iMTERUVFRfG0CihQtLQsGlDn4a8HGgDonAHG+BlcczV3odLoizk6nTp1KfI/YOVSjje1Z4i4XI0eOlPyuEhISiqiHYpQ+XlDch123YlOmTMGUKVNKPKZFixZYt26d5Ln69etjzZo1Vo8PCAjAtGnTij1f3759VbunjTvRwiSr9IFJCzYGlG9na3BqQfny5d0aOuZ49tln8f7778NgMMDPz0+ymtIaarYx4BlHJjQ0FKNGjeJr9pSmeqnRWXSG27dvY9asWWjatCmGDx/u6e4oCuVryhSb4HI3APVOskpXCrRgY0D5ITxLzGYznwguZ8jDHsLDw/HFF1/g448/xptvvlniggNAnZOsq0JL9jBp0iTs3r0bOp0OI0eOLPFYNTqLjnLnzh107twZ//33HwB2xVzTpk093CvlQB0ZjUBzZFyPFmwMqG8CuH37Nu8MeEIp4HjppZfw0ksv2XSs2mwMeF6RAdiw4alTp2w6VunjhVzcv38fPXv25J0YAFiwYAGWLFniwV4pC2WkHFOcRgthD6UP/lqwMaB8O1vi6dwNR1CjIuPJPCRHULqCKwdZWVno06cPTpw4IXn+hx9+QGZmpod6pTyoI6MRtKAWKH2C1aIjo4YJQI2OjNKvZWtwdo6MjCw1dKYE1GhjezAajRgwYAD2798PgM0P69+/PwB2BWVxG3F6I9SR0QjiYoElZforGaVPsFrJkVHbBCDeKFa8nYmSUVvY46+//uIr41IbK4NZs2bhr7/+AsAuRd++fTtmzJjBv/7111/TrRgKoY6MRuDUAjVPsEofmLSgegHKt7OYnTt3YtOmTQBYNYa7I1U6SnfKxZhMJrz11lv849Lq6igFNdnYXi5fvoxPP/0UAPs9N2/ejCZNmqBOnTro2rUrAODSpUt8NWRvhzoyGkELjozSlQIthpaUaGcOywl2+vTp/JYASkctNgaAVatW8Qm2zZs3L7LFi1JRk43tgRCC119/Hbm5uQCA119/HW3btuVff+WVV/j2ggUL3N4/JUIdGY1AHRnXQx0Z9/Ldd9/xm0U2a9as1OqwSkItyb4GgwEffPAB/3j27NmKKTtfGmqxsb1s2LCBVyErVapUpHZb3759ERsbCwDYvHkzDh8+jFWrVmH48OHo168frly54uYeex66/FoDGI1G5OfnA1B3yEPpEyzNkXEfap5gAXXYGGDzMLgaPf3790fHjh093CPbUYuN7cFgMOD111/nH8+ZMwdhYWGSY3x8fDBu3Dh8+OGHIISgVatWkteNRiO2bdvmlv4qBfWMDJRi0aJSoMQ7LK3kyCjdzgDruHAbRfbr16/ULQGUhhrUghs3bmDmzJkA2P5ybbWgFkfm7Nmz2L59u02JudOmTcO1a9cAsHt8DRkyxOpxL7zwgmRjUjF//PEHkpOTHe+wCqGOjAbQiiOj9CRUamf3kJOTgy+++AIAO1mpbYIF1DHJzpkzB9nZ2QDYYn+1atXycI/sQ6fTgWEYAMp1Fm/fvo1mzZqhZ8+eeOaZZ0rs56lTpzBr1iwAgJ+fH+bPn89/P0uioqIwdepUBAYGolGjRpg0aZIkSft///ufbN/ht99+Q+3atfnfpBKhjowG0MoEq/TBn9rZPVy/fp0P4/Xv3x+1a9f2cI/sRw2KjLhS7DvvvOPBnjgOdy0r8ToGWOeES9r94YcfMGLECKvXQ0FBAZ577jn+tUmTJpXqWE6aNAnZ2dk4deoUPv/8c3z66acIDg4GAKxcuVKWgnmPHj3C888/j/Pnz5e6z6InoY6MBhDnbmgl5KHEgYmzM8Mwqlk9Yw2l2/n+/ft8Ozo62nMdcQKl2xiQ2rlixYqe64gTcA6jGmwMAD/99BOGDx/O5zRyzJo1C8ePHwfAbrL8/vvv2/1ZERERGDVqFAAgOztbUn/Jkh07dmDMmDFISkoq8Zzz58/HvXv3+HMSQuzulzugjowG0IpSwDCMoqVizs7BwcGqSjy1ROmT7IMHD/h2eHi4B3viOGpQZDg7BwUFFZtvoXS4a1npNhbzyy+/YODAgUhJSQHA5tBwaodOp8OyZcvg7+/v0Oe99tprfHv+/PlW7bJlyxb06tULS5YsQWJiIgwGg9VzZWVlYfbs2ZLnlDheANSR0QRacWQAZd9haWGJO6D8ZF/xXWxERITH+uEMSncWAcHOarUxoOzxApBey2PGjEFAQAAAdtl0rVq1MHLkSIwaNQp5eXkAgAkTJuCxxx5z+PNq166N3r17AwCuXr2KDRs2SF4/cOAABg8ezNvr2rVrxYaMFixYgIyMDMlzSrUzdWQ0gJYcGSXHvLXiyCg92VcLjowaFBktODJKV2TE1/KQIUOwceNG3t4mkwnfffcdDh8+DACoWbMmpk6d6vRnvvHGG3x77ty5/G88KSkJffr0QU5OjuT4OXPmFNlxPCsry2pyr1LtTB0ZDaCVHBlAuY4MIYS3s9odGaWrBVoILSndxgUFBXxIQa02BpQ7XnCIr+WIiAh069aN334gMjJScuySJUtk2ayzR48eqFOnDgDgn3/+QUhICJo2bYouXbrwCcDdunXDhx9+CIC13YsvvihZHv71118XUWO4Y5UIdWQ0AFVkXE9ubi7fJ604i4Dy7AxoT5FRoo0tJ1i1oqbQEucwRkRE4MMPP8TVq1cxc+ZMdOrUCYsWLUJCQoIsn8kwDN58803+cW5uLk6ePInbt28DAFq0aIFff/0VH374Ib8i8ODBg1i0aBHy8/Nx4sQJXo1hGEayiahSFRla2VcDaNGRUdoPRos2BpQ5AWhNkVHatQxow8aAcscLjpIcxpCQELzzzjsuWfr+wgsvICcnB3v27MF///2HCxcuwGQyoX79+tiyZQs/hn377bfo3LkzAGD8+PEYP348n68DAE8++SQMBgMuXrwIQJnjBUAVGU2gpUlWqXdYWrKx0idZLSgySncWtWBjQLkKLoc1RcYd6HQ6vPHGG1i3bh3Onj0Lg8GACxcu4NixYyhfvjx/XKdOnfDss88CAPLy8iROjL+/PyZPnqz4axmgiowmoDkyrkcr+ywByp9ktaAWKD3ZVws2BgQ7K9HGgGDngIAAh5dUy4G/v78kRCRm1qxZOHToEJKTk1GzZk20aNECzZs3R2JiIurWrav4axmgjowm0KJaoLQJViv7LAHKz9/QglqgdGdRCzYGlDtecHB2VrKzWK5cOfz333/Izc21mmys9GsZoKElTaBFR0Zpnr8WbQwoc2Di7mL9/Pz4uhtqQ+l3sVpTZJR4HQOCnZXuLDIMU+yKKaWHogHqyGgCLaoFShuYqCPjPrRU3wRQto0BbdhZiROs2WzGw4cPAajbxkpXcAHqyGgCLn8jICBActGpEaVKxVrNkVHiBKAFR0bpiozWHBmljRcA8PDhQ35vIjWrXkofLwDqyGgCrVScBZQ7MFFFxj2I72K1MvgrzcYADS25A63V6gGUaWeAOjKagDoyrkeL4TtAmXbm7mK1Mvgr8S5Wi4qM0nZm9tTSa7mhigzFLXCTrNonWEC5MW+qyLgHrSgFSrYxoE07i0vsKwGqyLgP6sioHKPRCKPRCED9EyygXKlYqzkySrOzVpQCqsi4ByXbWYuKjNLGCw7qyKgcLU2wgDpCS2q3s5KlYi0qBUq7lgHBznq9HkFBQR7ujeMo2c5aUWSUPF5wUEdG5WhpggWEHw0hRFFSsZZyZJQ8+GtRKVCajQHpyjCGYTzbGSdQsp3ptew+qCOjcrQ0wQLKnWS15DAqeWDSohyvxLtYNVSctQUl25ley+6DOjIqR2uhJaVOsmI7BwcHe7AnzqNUZxHQphyvNBsTQlRTcbY0lGxnrVzLSh2TxVBHRuVoSSkAlDswiVeG6XTq/tko1caANuV4pd3FGgwG/u+uZhsDyp5kqSLjPtQ9IlOoI+MmtLjEHVDewESTfV2PVmwMqOdaVrPDqGRnkYM6MiqH5si4By0WHQSUZWOAKjLuQCs2BpQ9yVJFxn1QR0blaDlHRik/GkIIb2et2Vhpg79W1AIlO4tasTGg7EmWs7NOp1P1TaaSxwsO6sioHBpacj15eXn8IElt7Fq0ohYo0SHn0IqNAXVcy+Hh4arOq1OyjTnUa10KAOrIuAMavnMf3ODPMIyqr2c12BhQvyKjZLWALnF3H9SRUTl0knU9WnYWlTYwcXJ8WFiYqu9ilazIaCUJFVDutaylJe5KdhY57BopFi5ciCFDhqBly5b4448/+Oc3btyIp556CgkJCejfvz9++eUXyfuSkpIwfPhwtGvXDmPHjkV6ejr/Wm5uLj766CMkJCSgT58+2LZtm+S9GzduRGJiIjp27IhPPvkE+fn5jnxPzaK1HBklDkxatrHSBiYt3sUq1cYAtbOryM3N5ffA05KNlTImW2KXIxMbG4u33noL9evXlzxvNBrx3nvvYefOnfjyyy+xaNEiHD9+nH9t4sSJGDZsGHbu3IkGDRpg8uTJ/HsXLlyIBw8eYMuWLZg+fTpmzJiBq1evAgAuXryIOXPmYNasWdi8eTNu3LiBpUuXOvudNYXW1AIlev/Uxu5DK3exSh78taTIKPVapjZ2Lz6lHyKQmJgIAFi2bJnk+SeeeIJvV69eHY899hj+++8/NGvWDMeOHUNgYCD69+8PABgzZgy6deuG9PR0REdHY8uWLZg9ezZCQkLQuHFjJCQkYPv27RgzZgy2bduG7t27o169egCAF154AdOmTcOLL75YbB/Fu0HzX9LHB35+fvZ81VLh9gHy9H5ADx8+5NvBwcEe74+ziMMJ+fn5irCzeFDSgo3Fe+sUFBQowsYAexebl5cHgB38Pd0fZ2EYBoQQmEwmxdgYADIzM/l2WFiYIvrkKOLxwmg0KsbO9+7d49tqt7F4vPCEjW0JMdvlyNiCyWRCUlIS7/SkpKSgRo0a/OuBgYGIiYlBSkoKgoODkZGRIXm9Vq1aSEpK4t/bpk0b/rWaNWsiLS0Nubm5CAgIsPr5y5cvx+LFiyXPDRkyBEOHDpXtO4pJTU11yXltJSMjQ9IWOzZqJCcnh2+npqYiMDCQb3uKy5cv8+2CggJeMVQrt2/f5tsPHjzgbevpa/nOnTt829fXV/V29vHxQX5+PnJychRjYwC4ceMG387KylK1nbOzs/l2WloaoqKiAHjezufOnePber1e1TYW38jduXPH7ddyXFxcqcfI7sh88803KF++PO+A5OTkFNmbJjg4GDk5OcjOzoZer5c4JcHBwfzFafleLpk1JyenWEdm9OjRePrppyXPuUqRSU1NRWxsrEeTErmcIX9/f4lDqFbE8eSoqCjExsZ63M7iay02NhZVq1b1SD/kQhwqCwgIUISNAVaR4YiOjla9nfV6PfLz86HT6RRjYwCSPMP69esjMjLSg71xjjJlyvDtcuXKKcbOycnJfDsmJkbV13KFChX4dkREhGJsLEZWR+aXX37Bzp07sWzZMl6OCgwMhMFgkBxnMBgQGBiIoKAgmEwmicJiMBgQFBRk9b1c0iV3l24NPz8/2Z2WktDpdB79Y4orzirlonIGX19fvm02m/nv5Ek7i69BtdeEAJRpY0DqYEVERKjezlyejMlkUoyNAWk4Wu12FudvEEIUY2fxtVymTBlV21g8nyrtWuaQrRfbt2/H8uXLMX/+fElyU3x8PC5evMg/zsnJwfXr1xEfH4+wsDCULVtW8vr58+cRHx9v9b0XLlxA5cqVi1VjvBEtlc4HlLkKQWtL3JWavKelQm2AYGelJftydg4JCZFcC2qEXsuuR4ljsiV2OTIFBQXIy8sDIYRvm81mHDx4EF988QXmzp2LSpUqSd7TvHlz5OTkYOPGjTAajVi6dCnq1auH6OhoAGwC8ZIlS2AwGHDmzBns2bMH3bt3BwD06tULO3bsQHJyMrKysrBs2TL07t1bpq+uDbS0mSGgzB+N1lYtKdHGgLaWBQNSRUZJaGWJO6Dc1WFaupaVamMxdjky06ZNQ7t27XDixAl8/PHHaNeuHY4fP47ly5fj4cOHeO6559ChQwd06NAB06dPB8DKUjNnzsTq1avRuXNnnDp1ClOnTuXPOW7cOISEhKBXr16YNGkSJk2ahGrVqgEAatSogfHjx+PNN99EYmIioqKi8Nxzz8n37VVOfn4+v8pDCxMsoMxJltaRcQ9aWrIKKFeR0coSd4Bey+5AqaqXGLt0xSlTpmDKlClFnm/RokWJ76tfvz7WrFlj9bWAgABMmzat2Pf27dsXffv2taebXoPWJlhAmQOTlhUZJU2yWpLjAWUqMvn5+fxiCi3YWKkVlKki416UkalDcQitTbCAMgcmreXIKNFZBLS1KzOgTEVGazZWw7WsdodRDYoMdWRUjNYmWECZA5PWHEalDkxUkXE9WrOxGq5ltTuMVJGhuBQaWnIPYjtrwWFUoo0B7akFVJFxPUqdZLVkZ6U6i2KoI6NitKYUAMqcZDk7BwcHK6ZugjMo0caA9tQCqsi4HqVfy0FBQW6ta+YKlGpjMeoflb0YLYaWlJwjoxUbK/UuVktyPKBMRUarNgaUNcnSJe7uhToyKoYqMu6BFh10D5wcHxAQAH9/fw/3xnmUqMhoKQkVUO4kq6Ul7kp1FsVQR0bF0BwZ98DZWSs2VurApKW7WIAqMu5AideyyWTib360YGOlOotiqCOjYqgi43ry8vL4TfaojV2Llu5iAarIuAMlTrKWe1mpHSU6i5ZQR0bFaDFHRmmTrBZtLE5YVoKNAbYf3ASghcEfEK5lQgjMZrOHe8NCk31dj9ZULyU6i5ZQR0bFaFGRUVqyrxZtDAiDkxJsDEjtrIXBH1DmnayWlgUDyrexFpxFJdrYEnVvfeqFnD59GqmpqahSpQru3LnDP6+VSVYJd1iZmZnYv38/IiIiYDAY+Oe1YmOAtbPJZFLMwKQ1pQBQxrVsidbsrES1QMs2Vsp1bAl1ZFTErl270LlzZ6uvaWWS9fSPhhCCrl274sSJE0Ve04qNAfYuy2g0KmZg0pocDyhPXQS0Z2dPjxfW0LLqpZTr2BIaWlIRK1assPo8wzAoU6aMezvjIjw9MJ08edKqEwMAZcuWdXNvXIfSElG1JscDnr+WrcHZ2dfXF4GBgR7ujfMoMexBFRn3QxUZlWA2m7Ft2zYAbLXIIUOG4OrVq7h16xYGDx6MsLAwD/dQHjzt/W/dupVvd+vWDUFBQbhy5QrKlCmDZ555xu39cRVKc2S0phQAnr+WrSFe4s4wjGc7IwNKDy1p4VpWoo0toY6MSjh58iRu3boFAOjatWux6oza8bT3L3ZkFi5ciPj4eLf3wR0oLdmXKjLuQWtL3JWoyGjtWlaijS2hoSWVIJ5ge/fu7cGeuBZPDv7379/HgQMHAAC1atXSrBMDUEXGHShNkSGE8JOsVmysRLVAa9eyEm1sCXVkVAJ1ZFzPn3/+yX+mlm0MCJOsJx2ZgwcP4tq1awC0dxcLKEORSU9Px969e0EIQVZWFl/PhtrYdWjtWqaKDEUWMjMzeaWgTp06qFatmmc75EI8+aMRO4uJiYlu/Wx342lFZvHixWjTpg3q1KmDffv2aS5BEvC8InP//n20aNECHTp0wOjRo5GZmcm/pkUbK2WS1dq1rAZFhubIqIDt27fzd1LeMsEC7v3RmM1m3pEJCgpCQkKC2z7bE3jSkSkoKMC0adMAADk5OejXrx8aNmzIv64FOR4oqhaIKyq7g8WLF+PGjRsAgJUrV0r2ZtOijZUyyWp5+bVSnEVLqCKjArwlrAR4Tio+deoUbt68CQDo3LkzAgIC3PbZnsCTyb7r16/nQ0oAcO/ePezevZt/rIW7WMCzikxBQQHmzZsneW7dunV8Wys2VmJoiVNk9Ho9goODPdsZGVCijS2hjozCES+7Dg4ORocOHTzcI9fiqR+NNzmLgGcVmTlz5vDt6OjoIq9r4S4W8OwE8OuvvyI1NRWAtm2sRLVAa0vcxUqiUlQvS6gjo3DEy667dOkCf39/D/fItVBHxj14ypE5dOgQn+/VoEEDHD58GDExMfzrOp1OM5tzetKRmTt3Lt9etWoV3nzzTcnrWlRklDLJam2JO8MwHs+pKw3qyCgcb5tgPSHHi5dd165dW9PLrjk8tWpJPMGOHz8eMTEx2Lp1K68Q1KhRw+25JK7CU6ElS2exa9eumDVrFoYMGcIfU7NmTbf1x5UoTZG5desW7t69CwCoUKGCh3sjH0qrO2UJTfZVON7myHjiLtabll1zeOIO6/r16/j5558BAOXKlcNTTz0FgJ1s//nnHyxevJh/Tgt4SpGxdBYZhgHDMFi1ahWaNm0KvV6Pnj17uq0/rkRpiswff/zBt4vbF0+NKG1vNkuoI6NgxEpB3bp1Nb3smsMTgz+XgwR4nyPjzsF//vz5/N/0pZdekuz107BhQ/zvf/9zW1/cgScUmdTUVImz+PTTT/OvBQQE4L333nNLP9yF0hJRtXrjqXRFRhsarka5fPkyv+y6Xbt2Hu6Ne/DEwHTp0iW+7W12NpvNIIS4/PMMBgMWLVoEgN2w8KWXXnL5Z3oaT1zLCxYskDiLWl99p6TQkslkwvbt2wGwib5t2rTxaH/kRAkFNEuCOjIKRlyPQEs7L5eEJwamhw8f8p8dFBTkls/0NOJJlnOWXcm+ffv4gmxPPvmk1ZU0WsMTisyGDRv4z3755Zfd8pmeREmhpcOHD+PevXsAgO7du0v+/mqHKjIUh9FahUhb8MTA9OjRIwBAWFiYJpZL2oK7HUZugAeAZs2aufzzlIAnFBku0TQmJgYVK1Z0y2d6EiUpMloNKwFUkaE4gbc7Mu5WZEJDQ93yeUrA3XbmbAywDqM34G5FRrwpJB0v3I/YkenVq5cHeyI/dPk1xWGoI+OeHw2nyHirI+OOSZazMeA9dnb3tZybmwuj0QhAOwXvSkMpoaXbt2/j6NGjAIBGjRqhUqVKHuuLK6ChJYrDUEfG9YN/QUEBcnJyAHiPUgBQRcYduFuR0doeP7aglNCSeNm11sJKAA0tUZxA7Mh448BElQLXQR0Z1+NuG3v7jY8n1QIt58cAVJGhOIG3D0zuGPy91ZFx952s2M7e4shQRcb1KCFHxmQy8YpMWFgY2rZt65F+uBKqyFAcRjwwUUfGNXijUgB41s7e4jBSRcb1KCG0dOTIEX5VXrdu3eDr6+uRfrgSqshQHMYbByaqyLgHd0vy3ugwuvta9nZFxlOTrNbDSgBVZChOwDkyfn5+mq/QyUFDHu6BOoyux92hJW/MqVNCaOnw4cN8u0ePHh7pg6uhy68pDsMNTBEREV5TqM2TSoG3TLCA50JLgYGBmqp4WhKeVGS8RcFlGIbfLd1Tisz169cBsDecsbGxHumDq+F+szS0RLEbzpHxlrsrgCoF7sLdyhfnyHiT6kWTfd2Dp9UCzpGJiYnR7A2nu7c0sRfqyCgUs9nsdVU6Ac86Mt40yXrKztTGrsMbc+oAz+ZvZGVl8XaPiYlx++e7CyXkIpUEdWQUSlZWFr8rsTcNSnQ1jXtw58BECPHKbSDcrXp5uyLjiQk2LS2Nb2s1rAQoY3VYSdjlyCxcuBBDhgxBy5YtJZUMAWDFihXo1q0bunTpgq+++oqfhAEgKSkJw4cPR7t27TB27Fikp6fzr+Xm5uKjjz5CQkIC+vTpg23btknOu3HjRiQmJqJjx4745JNPkJ+f78j3VB3efncFuL8gHlULXENOTg7/GdTGrsNbxwxPhpZSU1P5NlVkPIddjkxsbCzeeust1K9fX/L83r178csvv2DFihVYu3Yt9u7dy28nbzQaMXHiRAwbNgw7d+5EgwYNMHnyZP69CxcuxIMHD7BlyxZMnz4dM2bMwNWrVwEAFy9exJw5czBr1ixs3rwZN27cwNKlS539zqrA2wclgCoyrsSddvZWZ5HmyLgHT4aWuPwYQNuOjNIVGbuWDyQmJgIAli1bJnl+y5YtGDx4MP+HHDFiBLZu3Yr+/fvj2LFjCAwMRP/+/QEAY8aMQbdu3ZCeno7o6Ghs2bIFs2fPRkhICBo3boyEhARs374dY8aMwbZt29C9e3fUq1cPAPDCCy9g2rRpePHFF4vto9Fo5DdO47+kjw/8/Pzs+aqlwiU8uSrxiSuwBLCDkhITrFyNyWRyuZ3FjkxwcLDX2FnsyHAqp6u+u9gpDwkJ8RobixM/OUfGld+ds7O/vz98fX29xs7i0JKrxwtLxIpMpUqVNGtzbmUYAH5+ddd3FX92cciyDvLy5cu8kwMAtWrVwoIFCwAAKSkpqFGjBv9aYGAgYmJikJKSguDgYGRkZEher1WrFpKSkvj3tmnThn+tZs2aSEtLQ25ubrF1VZYvX47FixdLnhsyZAiGDh3q/Be1gvhClpMLFy7wbUIIr1J5A3q9HiaTCdnZ2bx9XWXn27dv8+0HDx54jZ0NBgPf5m4qXGXjc+fO8W2GYbzGxpmZmXw7IyMDgOuuY/FnhIaGeo2NAcFhzMvLc/l4YcnZs2f5tl6v16zdxSkd165dQ/ny5d1m47i4uFKPkcWRyc7ORkhICP84ODgY2dnZANj4eHBwsOT44OBg5OTkIDs7G3q9XuKUlPRe7jNycnKKdWRGjx6Np59+WvKcqxSZ1NRUxMbG2uQx2ou4zHW1atVQtWpV2T9Dqfj4+MBkMsHHxwexsbEutbNY8q9Xrx6CgoJk/wwlUqZMGb5dtmxZAHCZjS9fvsy3K1eu7DXXcsWKFfk2N3a5ysaA4JxGRkZ6jY0BSMZ2V48XlojDeS1btpT8zbWEeH6vWLEiTCaT22xsC7I4MkFBQcjKyuIfGwwGfkIIDAyU3P1xrwcGBiIoKAgmk0misJT0Xu4zAgMDi+2Ln5+f7E5LSeh0Opf8McV5BWXKlFHMBeMOxFIx971dbWe9Xo/g4GDN1oGwRBzz5iRiV9lYPDaEhYV5zbUsHoe4vAJX2dhsNvNh0oiICK+xMSBN9nX1eGEJt2rJ19cXFStW1KzdxTfWrh4vHEGWXsTFxeHixYv84/PnzyM+Ph4AEB8fL3ktJycH169fR3x8PMLCwlC2bFmb33vhwgVUrlzZK8r1e2uyL+DeVQjiZcHe4sQA7k329cZ9lgD3J1RzK0W9KdEXUEayb+XKlRUzqbsCJWwFURJ2Wb6goAB5eXkghPBts9mMxMRErFu3Dmlpabh79y5Wr17Nb57VvHlz5OTkYOPGjTAajVi6dCnq1auH6OhoAGwC8ZIlS2AwGHDmzBns2bMH3bt3BwD06tULO3bsQHJyMrKysrBs2TLNbsplCXVk3FuozZtWLAHuXYXgrauW3Dn40/HC/cuCs7Oz+bwkLa9YApS//Nqu0NK0adOwadMmAMCJEyfw8ccf49tvv0X79u1x4cIFjBw5EmazGQMGDEC/fv0AsPLqzJkz8emnn2LGjBmoV68epk6dyp9z3LhxmDZtGnr16oWwsDBMmjQJ1apVAwDUqFED48ePx5tvvgmDwYAuXbrgueeek+mrKxs6MNGKs67EU4qMNzmM7lx+7a1LrwHP1ZERF8PTuiOjqeXXU6ZMwZQpU6y+Nnr0aIwePdrqa/Xr18eaNWusvhYQEIBp06YV+5l9+/ZF37597emmJvDGnWw53LVBmclk4nOwvGmCBWhoyR14SpHx1vHC3ROst9SQAZSvyGg3qKdyqCLj+oHJMgnVm3DnwOStoSVPKTLeOl64e4L1JkdG6YoMdWQUCufIcKtpvAl3OTLeuvM1QENL7oAqMu6BKjKuR1PJvhT3Id752ptW0wDuc2S8dYIF3HuH5a2hJarIuAduvDCbzZI9/lyN2JHR8oaRgPu327AX6sgoFO4Oy9sGJcB9d1jeGvIA6F5L7sCdNqbJvizuVAuoIqMcqCOjQAghXu3IuCvm7c2KjKdCS94UJnXnXaw359R5Kn+DK9Gv1+sRFRXlts/1BDTZl2I3BoOB/0F626AE0BwZd+DOgUlcdFDLRcMsoYqMe/DUJMspMpUqVZL0QYvQZF+K3Xhz4h7gGUfGm0IegGdCS95mY08pMt42Znhiks3NzcWdO3cAaD+sBFBFhuIA3iwTA+7LkfHm0JInkn29zcaeUmS8bczwRP7GjRs3+LY3ODJUkaHYjTcPSoD7cmSoIsPiyoHJbDZTRQbuVWS82WF0l1rgTYm+AFVkKA7g7YqMu5ZTerMiIx6YuN1sXYF493pvc2Q8ociEhYVpPl/DEk+oBd609BqgigzFAagj455Jlib7srjyDos6iyzuqiPjbfkxAFVk3AFdfk2xG+rIuOdHQ0NLLK60sbcWwwPcexdLyzWweEKR8QZHhhbEo9iNN69AANw3AXizWuAuG1NnkcWVymJeXh5yc3MB0PHCXY4MV0MG8A5HhioyFLuhiox7pGI6ybJQZ9E1uOsu1ptryACeDS3pdDpUrFjRLZ/pSWiyL8VuqCPj3klWp9MhKCjIZZ+jRGhoyfW4y8bevsrRk8m+FStWhK+vr1s+05PQZF+K3Xj7wOTuHJmQkBCv3ZgToKqXq3CXjb09FO1utcBoNOLWrVsAvGPFEkAVGYoDeLsi4+78DW+bYAEaWnIHOp2Od5C1psjcf0TwzW8El9KKlkcwmQjmriWYssyM/ALX70bt7vyN9PR0viyEN+THAMpXZHxKP4TibjhHRqfTISQkxLOd8QDuXhrsbRMs4JmEam90GH18fJCfn685RWb0DILf/gHCQ4CTS4Fq0YKi+cWPwHuL2Ilerwc+eta1fXH3JOvOFUsH/iUw5ALdWnhWMabJvhS74QamsLAwr9pkj8MdPxqz2YysrCwA3jnB0iXu7sEd+4a5W5G5kk7w+97Cz84CnppKeOXl2DmCj5YKKszX6wmM+a5VZdwd9nCXI7P3NEH7Vwm6TyCYv871ylZJKF2R8b5ZUgV4c00IwD2TrLjirDcqMjS05B64CUBLq5aWbiYQF9w+kAR8spwgO5fg6U8JCkSX0817wLrdru2Pu9WC5ORkvl21alWXfc7MHwi4VfvvfENw7prnnBmqyFDsghDiEUdm7U6C0Z+bkXLDs54/4J4fjScm2LQ7BC/8nxnLtyjLxu6q7OsuRWbRBoLXvzLjoUE5dnbl4O+q0NLlGwT7z0htWFBAsGwL29brAZ/Cy2j690DfSQTnrrGPK5cX3jPPxWqCu9WCY8eO8e1mzZo5da6cPIIdR0mRa/VCKsGmA8LjXCPw7HSCAjfkHFmDFsSj2EVubi7y8/MBuM+RuXOfYMQ0ghVbgVfneH7wd8fA5ImQx4dLCJZuBp6bQZB81bN21mpoaecxgnGzCOatAybMV8617C5FRq4x43YmQbMXCNq9QjBtpWDHrYeAG3fZ9uNtgM/GsLkbhAA7j7PPBwUAf81h0DCefXwgCTia7Lq/hbtDS0ePHgXA2jo+Pt6pc73zNRs6avYCwYMswUbzfhVUL85ZPPQf8MUa4b35BQTXbxOYTNpLqLYX6sgoDE+sWPrrGJBf+PvffpR1bDyJOwYmdysyhBBsPSQ8XvOXcmyspdDSrDWCXX/YAWQ+Uoad1abI/HkEuM+mkGHKCoID/7J2XLRRsOeYvgzeHgZ0ayF975evMKhdhcFrTwgJqq5UZdypyNy4cQPp6ekAgObNmztdtoELu11KA94sdLzvPxJUr6AAYMPnDLhUyY+XESzbTPD8DDOi+hPEDiZ4cbZ7HRmqyFBKxROOzJ9HhB+CyQT86uKYdmm4Y5J194aR/6YAt+4Jj3/aCZfu7F0a7l61pNfrERgY6LLPAYB/U6TOYk4esHKrSz+yVLhrWW2KzKGz0jFhxDRWRdxykH0upjzQ6zFAp2Pw3QcMKkayzw/oAIztx7af7g6UKfxprdnJqjyuwJ2TrDis1KJFixKOLJ2bGQQ3RWPC8i3Axn2sE2PIYZ8b1Qvo3ZrBxOHs4/wC4Pn/Y4/JLBzClm4G0u9qK3xnL9SRURjuXkpJCMGfR6XP/bRTGXexgHZCSzuOSR8nXwPOpLj8Y4vF3aGlsLAwlxcd/HJt0ev22w1EEQ6j2hSZQ/9JH6fcADq+LiSfPt8H0OvZv2fFsgyOL2Hw+3QGaz9h+L9zUACDFx5njzfmA4s2yNK1Irgz7MGFlQDnHZkTF4o+98JMgrk/C9fr64NZW04ZzaBBnPXzEAL8useprpQKVWQoduFuRebidSD1tvS5XSdd7+GXhDu8f3eHPHYcLWpPT4aXtFarJ/0uwffb2XZECNC6Pts+dw34+7hLP7pE3Ln82tfXVxbVK89IcPIi244uC4QUnvJ2Jvs/wwDP9ZE6pdHlGPRrz8DXR/r8ywOEsMi07wjqjDCjzUtm9H/PbPU34QjuVAtc5ciUK/Q/b2cK43HvVkDtKqw9/f0YrP+MweNtgae6Ab9OY3DwW8HWa/+migxFQbjbkRErBRXKsP8TAvziwfCSOyZZdyoyxnyC3afYdmQY+IHdk+Eld+fIuNrG834lfJ7XSwOAN4cIg/w3v3veKXdHaCk8PFwW1evkRVZBAYDuLYB546Xn7PUYUCXKts+pFs2gXzu2nWdkHcuDScCGfcDADwiu3nT+b+Mup5wQwjsykZGRTi+9PnlR+O4/TWEQafETGT9EauMaMQw2ztBh9WQdBiYweKwuULsK+9o/p11780mTfSl24W5HRpwf88VLwg9HKWqBFhSZg0lCzLtPG6BzU7adcgM4mlz8+1yJO2xcUFCAnBz2i7vSkcnKJvjmN7bt6wO8NojBgA5AVGHexvp/gBseUhjdmezrirDSY3UZPNsLeKKj8Ny4fvY5S7NfYdClGVC1IhAq2ps1KwcY+4XzoT93qQXXr1/H7dusXNKiRQunncYT59n/A/2Bjk2AbyYI56tbFejesuT3MwyDIZ3YNiGurddDl19T7MKdVTpNJoKdJ9h2ZBgwogdQvzAOu/9fIPWWdtUCdyb77jgm2LFbcwbDugoDlqfykdy9xN2VNl62RVhhM6IHG+bw82XwQh/2OZMJWLLJZR9fIq5WZAgh/JghW6Lvf8I12aoeO2Euf49doTT7FQb92tt3vvhKDP6aq8OVtTo83KZD5maGrzOz/Qib5OoM7lIL5Ez0fWgguJjGthvGs/lGQ7sw+Hwsg3YNgRXvMTY5SkM7C8f8vIsqMhSF4E5F5tg5tsQ4AHRtzq5AeLKLOO7q0o8vFq0l++4QJVN3bQ4MShBqQ6z9GzCb3e/MuFv1cqWNF6wX7PfWk8L1O7afkJ+xaKNniom5WpHJysqCuTADVzZF5iz7v78f0Kg62w4NYvDFyzpMeNK2CbYkIkIZLHxbOMeEBQRpdxz/27grtCRnfsypi0K7aU2hPWkEg70LdHisnm02bhBvPbx0O5NgzEwzXpsrT2FIqshQ7MKdq5bEq5W6NWd/OE92EZ5bo2G1wF2hpQdZBIcLw0d1qwKVyzOIDGPQo1A2Tr3NFgxzN1rJQ7p+m+B8Kttu3wioHydMAFWiGDzehm2n3QGe+z/3FA8T42pFRm4FN+MBwaVCpaBZTcDP1zUrzfq0YfBMT7b9IAt4cbbjISZ3hZZclejbtKbjNmYYBkM7s20uvHQ7k6DLeIIlm4D5vwKPv8tuH+EMVJGh2IU7FRlxyKN74e+yVizD3yEcTQYuXvesWqDmSRYAdp1gQxuAYGMAEuXrxx1UkXGUfWeEdqcmRV+f9DTDq1/f/cGWeXenM+NqRUbuG5/DZ4V2q3pOn65E5r7G8HlMm/YDK7c5dh53jBfiRN/y5cs7vVmkONFXrMg4wpBOwliyfCtB1/EESZeF1/85zSZW5xmVr3o5CnVkFIa7HBlDDsH+f9l2fCUgrpLwYxBPsk9OkZbOdgdaypGR5Me0EOzavz3g58u2v90A/P6P9mzsDtVr37+C3do1LHpn26YBW9uEc2ZW/wk885n7wkycWkAI4UNAciK3IiPNj3Ft3Z/IMEaS4PrSbIIjZ+3/u7jjWr527RoyMjIAyJToW6jI6HRseMgZGsQDdQrDS8fPA/8WOjGVywNhwWx7+xFg2CfCLuX2QpdfU+xC7Mi4UinYe0ZYYtmtufS15/sAlcqx7ePn2c3gnJUm7cHdk2xwcLBLPgMQ8mP0enZlAkd4CIM3h7BtkwkYOoXgr2Pus7FW9rPae5r9n2GANvWtHzMwgcG6Txn4Fn7lH3ewg3pOnvr3qJFbkTkkVmTqOn26UhmYIBTNyzUC/d8ndq8wc8e1LGdYyZgvKCZ1qrCFA52BYRgM6Sx9rnJ5YNdXDDb/H4OgAPa53/5hV4k5AlVkKHbB3WGFhYVJLh65ES+77t5S+kMqF8Hgzy8ZlC0cF/85DQz+iMCY7967WMD1k2xoaCh0Otf8DK7fJkgu3A24dT0gLFhq5+ljGYzowbaN+ewgLr4jdiXia8sVSgHg+tDSo2yCU5fYdqPqrHNYHP3aM/h1GsOrYOt2A13GE9y6p+5CYmJFxllHhhDCh5bKhQPVop06nc0seJNB+0ZsOz0DGPC+fU6mO2585HRkki4Le9s5G1biEKvonBNTI4ZB+0ZsxWXuul+xFUV2NLcFqshQbCY9PR0XL7Lp7FFRUS77HEIINhduEc8wQl0TMfWqMdj2BcPXfdh6iM0vcEcBN3duGunKsBJnY6Co6gWwq8SWTRIKhhlygN7vEPx3RVs2Blxj54NJ4Evmt2tQ+vGPt2UH9eBA4f2tXiRIuqzeZatyhpYuXgfuFf7JuGXX7sDPl1XMqhQOeUeSgRf+z/axRm2KjFyJvmLqxzFYMpHB832APfNYJ4ajWwsG894QHk//XpnhO2egjoyCWLRoET+pDB061GWfc+wceKWgQyOgbLj1H1OLOgw2zmAQ4Mc+XvMXsGyzy7rF484cGVeG777bLgwY/dtbt7GvD4OfpjC8M5n5CBjxqeOxbFvRwhL3vaI7y/aNbJsQerVisHe+UMfk6k2g7csEizY4lwxZHGoKLUnCSi7Oj7GkQhkGGz4XnMwfdrCVr23B1TYmhPA1ZCpWrIhKlSo5dT45E33FPP84gyXv6hBfqejfbnQieEdx8wHg5AXHw3c0tEQplvz8fCxcuBAAoNPpMG7cOJd91nd/CBfxMz1LHrA6NmHww2RpzYfrt9U9yRJCJKElV5Byg/AraurHAU1KGLAC/Bn8/jnDFyM8cQGY+YNLusWjhVVLXH4MALRraPv7mtRkcHghg2a12McPDcC4WQQ1hhPMWydv7ozcagEhBFOnTkWHDh1Qp04dfPbZZ/xrzioykkRfN+THWNK4BoPlk4Sx5pPltq0wc7W6ePnyZWRmshtNNW9uRVq1E7EiU9K4ICe+PgzeGSbY9nM7VRmqyFBsYv369UhPTwcADBgwALGxsS75nPwCgh//Ytv+fsDgjiUfD7AJeSMLaz5wg74rQ0yulooNBgPff1c5MtwGhgDwTI/Si4iFBrGDOJeuM3Wla0Me4rwgNa5ayi8gvIIQW8H2vX84KpVjsGeeUIMDAK7fAV7/iqBCP4JW48wYNd2M/1tNcOaSPMtW5bDznj178PHHH2Pv3r04d+4cDAYD/5qzY4Z46fVjHnBkAGBwJ1YlBljVeM1fpb/H1ePFiRMn+LazjozZTHCy0JGpEsWu3HIXzz8u7Kf38y7g3DXH8pCoIkMplgULFvDtV155xWWfs/0IcOc+2+7Xjq2yaQtzXmNQsbDmw5aDbE0OV+Fq79/VIQ9CCK96MQzwdHfb3teyLoN3hrFtYz4w+nPXLRNmGMblNU5caedTF4X9q7hEUXsJDmTw0yc6HPyWQd+2wvNZOeykvnIbMGkhQctxBP+mKGPZ6n//CRshBQUFIT4+Hq1atcKsWbNQo0YNh8/70EBwvHDvn9pVbB8X5IZhGHzynEiVWVH6b8DVk+zJkyf5dpMmTZw616U09voC5A0r2UKgP4MJQ1nbEgL83w+2X9NeleybnJyM5557Dh07dkT//v2xYcMG/rUVK1agW7du6NKlC7766ivJHX1SUhKGDx+Odu3aYezYsbwyAQC5ubn46KOPkJCQgD59+mDbNgerJimYM2fOYM+ePQCAunXronPnzqW8w3EkYaUetg9WkWHSsuJv/I+4bLdVVw9Mrk5CPfQf+H1UOjcFYirYbucpoxm+JsSRZODLtbJ3j4ezszuSfZ1xZPKMBKOmm/HMNDMyHrDXnLgQXrsGzk26reox2DBDh1PL2VVkVStafj67bNWRrSTkdsqvXbvGt3///XdcunQJBw8exFtvveXUef86BhQUds9aYro76dyM4UsVXLjO5suUhKtvfMSKTNOmVlZG2HMuFyT62sNLA4CIELb93R/ANRv30/MqRWby5Mlo164d/v77b/zf//0fZs2ahatXr2Lv3r345ZdfsGLFCqxduxZ79+7lnRyj0YiJEydi2LBh2LlzJxo0aIDJkyfz51y4cCEePHiALVu2YPr06ZgxYwauXr0qZ7c9jqUaI9dqAZOJIFcU73+QRfD7XrZdNhzo+Zh95+vXnsFT3dj2/Sy29gk3sciJ2hQZyxo79uQgWRLgz65k4i6BycsINux1rcOo9NDS99tZdeT77cCAwgql0kRfp7rJ06g6g+8+ZDc3NGxncHwJg1qF0ZoDScDCDSW/3xpy38mKHRk5w89bDwn27N3aM2qMGLEqM3VlyaqMq9UCTpGJiIhA1apVnTqX+Lpt4riA5jBhwQxee4JtF5iAmTaqMmIbu6pcgzPI6sjcvHkTvXr1gk6nQ506dVCtWjVcvXoVW7ZsweDBgxETE4Ny5cphxIgR2Lp1KwB2R9HAwED0798f/v7+GDNmDP777z9eldmyZQvGjh2LkJAQNG7cGAkJCdi+fXuxfTAajcjKypL8y83Nhdlslv0fAKfPkZmZie+//x4AEBISgqefflqWvj3IMqPeSILIxwlmfG9Gfr4ZP+8iyDWydnqyM+CjJ3afd+5rQpx172ngsXEE/6bIa1exI8d5/3KeX7xkNSQkxKlzff6dGSE9CTq/bkZKmhm5eWasKVxtEegPDOxgv41b1SN8sbw8Izt5f/6dGSaTvHa2dGTkPLfZbOYdRn9/f/j4+Dh8HnH13r2ngdEzCJ/oGxYM1Ktqv41L+xfgR9C4BsE3E4SxZdJCguu37TuPZS6Ss/0SOzKVK1eW5buaTGZsPcie098X6NhYfnva+69DI4Iuzdg+XUoDVv5RfJ/E40V+fr6s1/KtW7eQlsbKq02aNOErNDvyLz/fjJ8LN+L18wUSPGTnVweCL5K3eBOQklb6e1w9Jpf0zxZ8Sj/EdoYOHYotW7Zg9OjRSE5Oxq1bt9CgQQN88803SExM5I+rVasWr0KkpKRIYruBgYGIiYlBSkoKgoODkZGRIXm9Vq1aSEoqfpe95cuXY/HixZLnhgwZ4rLlzKmpqU69f9WqVXzC3sCBA5GZmclnyDvDb/uDcT6VLc/73iLgtz25yM5jAPgDALo1SsfVq0aHzr3wNT+M+aoC7j7QI+UG0OZFM+a+dBddmuQ43W9AuqSUKwvurJ3FXLp0iW8XFBQ4rPARAsz+KQaE6LHrJND4OTP6tjLg3kNWfejW1IB7d+7ingPnHtMDOH+1HDYdCgYhwPuLgUP/ZmHGcxnw93Oou0XgJtnc3FwA8toYAO7dY795SEiIUyrqvtPRAIQv/aMo1NAkPgfXr992+NylERcJDEkoi5/3hOChARgzw4CvX7tr8/vz8vL4tslkctrGKSkpAIDIyEjcuXPHqXNxnLvui+t32CXFj9XOwZ1brrOnPYzr7Y+dx9k43yfL8tG2RjoC/IoqCHfvCn8PbuyQ61r+559/+HZ8fLxT1/GBs/64eY/9Pp0aZuN+xh3cz3C6iw4xqnsEvt4YDmM+8Pa8LMweV3JHxOEkbr6Se7wojri4uFKPkdWRadOmDT7++GMsWbIEAPD+++8jMjIS2dnZCAkJ4Y8LDg5GdnY2ACAnJ6dIifjg4GDk5OQgOzsber0eAQEBVt9rjdGjR+Ppp5+WPOfj4wM/P5lG/0LMZjNSU1MRGxvrVGXYM2eEYP/48eOdli45kixyKw4lCzasGQP06xwNRyNYVasCTRsAAz9gY75ZuTqMmVsBqz4AH3pyBnExQO66cdbOYsTXU9WqVR22+YXrQIYQPUFWjg4/7hJCKOMGBqNqVce3P/htBjD9O2DyMvbx7wdCkJkdgj9mCfs0OYOvL3sSzq5y2hgA/zsNDw932MaPsoELhflGkWFsnR3xgrluLQNl+80Ux9dvA7tOs0ny244G49T1YL6IYWmIQ5cmk8kpGxcUFODWrVsAgGrVqsn2vX8WFW4c2NH19rSVqlWBbn+w23yk3vHF8p1VMMNKVYobN27w7aAgtoKnXNfy2rXCQNqhQwenbDPjF6H9bJ8gj9r507HAj7vY39NvB0Lw8QshaFjCnk/inFYuzCT3eOEMsjky9+/fx4QJEzBlyhQkJCTg8uXLeP3111G9enUEBQUhKyuLP9ZgMPAXXGBgoGQJIfd6YGAggoKCYDKZkJuby08+4vdaw8/PT3anpSR0Op1Tf0zuDkuv16Nhw4ayXRi7T7KSnK8PEF0WuHZLeO2Zngz0eufi4FUrAv/MJxj1OcEvu9jJZdwsNoGtfpxz5+YmWED4ATlrZzHi6y0sLMzh8+7/lwBg+xcXDVwWctQRFQn0bMlAp3POFh+NAhrEEzzzGYEhB9hzilXY5rzmvC0sk33ltDEgLTro6HlPXhSW+g/pxO7O/tYCaSE8Z21cGuUigLmvETz9Kfu5r8wBOjRiii0kKUZ8LZtMJqdsfOvWLT4MWKVKFdn+VtsOCfJ9YhvX29MevnqdoOnzBMZ8YPZPwBMdmSLF+ixtDMh3LYtXLDVv3tzhc+YXEKzbw14/QQFsgUxP2jkyHHh/BME73xAQAny4BNg4o+TvptPpYDabZbexHMjWi7S0NISEhKBz587Q6/WoUaMGmjdvjuPHjyMuLo4vvQ8A58+fR3w86/7Fx8dLXsvJycH169cRHx+PsLAwlC1bttj3qh1CCB/mqFq1quQH6Qxpdwi/aqZVPeDUMiFJNzwEGN1blo9hl69OYTCq8HzZucCQyQRZ2c4lp7o62ff2bUE6d6aI2N7Twvdc+T6DNR8z/IqA1wYx8PGRZ6AamMDgrznCfilzfwZ+3e18ArArk30fPnwIo5ENXTpjY2ltEwZvDgWfrFijcvEbRcrN8G5Ar1Zs+8ZdYMxM22opyXkti/NjqlSp4tS5OB5lE+wtFIXjosEnNyuFetUYfDyK/R2ZzcBzM4pWYHZlsi/nyPj7+6NOnToOn2fncSCjMDXv8Tbs2OlpXh0ExBRWuN60XzqeWcPViwOcQTZHpmrVqjAYDNizZw8IIbhy5QqOHDmCGjVqIDExEevWrUNaWhru3r2L1atXo3dvdvZr3rw5cnJysHHjRhiNRixduhT16tVDdDS7Y1liYiKWLFkCg8HAL1Pu3t3GwhwKJyMjg1/ZUb16ddnOu/uk0O7UhK0JsXqyDqeXMzi7irFrOXBp6HQMvp7AoFFh989eBV6c7VzBPFevQjh//jzfdqb2BjcB+PoALeoAT3ZlcPknBkcWMXhvhLO9lNKqHoM5rwp/t9EzCC6lyeMwusLGFy4I60ydubYPnxW+42N12Toj/3uDvZaPLmYQ4O+eCYFhGCx9V9hIdf0/wJJNpb9PzmvZFY7MX8eEDQx7t3Lf/kr2MHE40Lw22/7vCruKSYyrlgYbDAacO3cOANCgQQOnbjR/2in0WbzBoycJ8JfW7Hn325LHbVeXa3AG2RyZkJAQfP755/j222/RsWNHvPLKKxg6dCjatm2L9u3bY9CgQRg5ciSGDBmCdu3aoV+/fgDYUNDMmTOxevVqdO7cGadOncLUqVP5844bNw4hISHo1asXJk2ahEmTJqFatWpyddujcGElALKqTLtOChdjxybChdqwOoPocvL/iAL9Gfw8lUFI4T4pq/+0bZAvDlcrMpwjwzCMw5Ps7UyC84W5bi1qszYAWKexRR3XyMYvDQCe7MK2HxpY9SvXiXL63CTrakemZk3HK39xikxIIFBXlFLQsDpT4m7XrqBSOQbL3pXWUkq+anuxNmftLE6ulMuR2XpQWcuureHjw1a99i30Cf/vB+Dwf0VzNgB5r+XTp0/zE7szhfDyjAS/smXCEBoE9G4tQ+dkYmRP8HWr9v8L/PZP8ce6crxwFtmTfdu0aWP1tdGjR2P06NFWX6tfvz7WrFlj9bWAgABMmzZNtj4qCfHqGVcoMr4+7pPea8UyWDIRGPYJ+8N/7SuCdg1ZadheXFl8iRDCOzLVqlWTJP7aw/5/hbZcdUxKg2EYLJ4InLjAOlEnLgATvyX43xuOTUCuVGTEqpejjszNDMLndrWoA6fzuuSgX3sGL/Yn+PZ3ICcPeGoqwYFvAH8/632T81qWW5EhhGDrIbbt5wt+41Il0rA6gw9HAh8vIzCZgE5vEHz0LPDWk6678RHnxzhTCG/7EeBBYYpo//bCTY8S8PFhMH0sMOhDdtx++UuChMbWNxL2CkWGYj+ucGRu3BWUgpZ13BuLfbIrg1cGsu08I/DC/ymjGqqY27dv8+G8WrVqOXwecTy5fUP32Tg0iFW/uB3J5/8K7D/jmCrjyoFJDkXmSLLQfszx9ATZmf0Kw6tDJy4ADUcRfPu79c0m5SwkJrcj898VILUwXaxjY2XkbZTEeyPYMQ1gncj3FxE0eY7g+EVhZaCc17K4oq8zisyav4TrYlhX5dl4QAegT6H+cPMe8Moc6+OJkhUZ6sh4EFc4MpL8GA/cYc16WVoN9Zvf7D+HKx0ZsVLglCMjKpHftoEzPbKfRtUZTB8r7JnywsyiCZC2oPQcGWl+jHImgKAABj9+zPD1fC5cB16aTVBlMMHIz8x48mMz+kw0o/sEM/6905J/n1w5Mr6+vpISBY7CFcEDlBtWEuPrw2DHHAZvDAa/uerZq8DTMysDZdg6Za5QZBiGQaNGjsmu2bkEG/ax7TKhQPcWMnVORhiGweJ3GJQprBzx007gp7+KjidekexLsR+xIyNXjsxuUX5MpybuH5wC/Bksekf43EkLCVJt3M+Dw5XJvlzyHuC4I5OdS3Cs8DR1qwLlItxv59efEO5Oz14FZqy2/xzucGRiY2NLLJdQEoeE/RE9thtzcTSuwWDXVwy6ivYluvuA3b9m7d/sxqo7jgJbL/YD9GyGsFyOTExMjCzLXvecEn6XvezcrsRThAUzmPu6DkcXMdJrokxXAPIpMgUFBXyNrxo1aji8xcbBJGGTyAEdAD9fZTqM0eXYRRscL88pupceNy7T0BJFApfsW6FCBdk2L9x1kv3fR+9+pYCjYxMGY/uy7awc9kdhzyomV+bIiBWZ2rVrO3SOw2eFDfbclR9jiV7PYPFEBj6FpvrsO4L/rjjmMMrtyNy7d4+v6utoWMlsJnxoqWIkEFNBrt7JR+v6DHbM0eHYYra8geiy5TETPeBbFoBzdn706BFf8VuuRN+zhUVqgwLYHa/VRNNaDL4RTbxgWHlMrms5OTmZr3jtTH4MZ2MAaF1PmU4Mx7CuDIYW7ld87yEw5gvpuE0VGUoRcnJy+D085FJjbmYQnCsMo7s7P8aS/3uRQTQ7fmPTfmDpZpS48ZsYpYeWuH1+APfmx1jSuAaDiU+x7fwCtrbJvYf2O4xy21iO/JiLaezGpICw7FqpNKvNlje49RuDf1cyuLKWwXBxhWsduy2IM3aWe8VSnpEgpbCAY+1YKKoInq1IqlvLYGMx4kRfZ/Jjkq8Jv0fxqjul8vUEBlGRbHvzAeCtBYIzQxUZShEuX77Mt12RH9OxiSyndJiIUAbzxwuD45iZBGX6EPSYYMZnqwhuZpRerwBwnSPj7+/v8O7Brth52VE+GsmgZgzb3v8vUPZxggbPmvHiLDP+PGJ7gStn6v5YIocjY1kITw2UDWerWletyCBcvDOFDGqB3Im+F9PYAnMAUEcFE6w1/MWOTKGN5ZpkxYm+zigyycKfTRV2LhvOLnXn7hvmrAWmrmDbVJGhFMEVib7i+jGdmnp+8B/UUZAqATbM9OdR4MMlBHWfIVi22XrIyVU5MgUFBXyV6Jo1azqUZ2AyEX7pdXRZthqqJwnwl4aYACDpMrBwA9DjLYInPzbj1j3rTorYYXR2RY0YeRwZaSE8teEnLmwhg1ogtyOTLAp51Kni+bHCEVShyBTaOTIMKBfuXJ/cRe/WbPIvx5TlBF/+ROjya0pRXLliSa8H2nkoP8aS1R+xyb9PdgEqlROev58FPP9/BD3eIki5UXylTjkdmatXryI/Px+A4/kxZ1LYjQwBVo1RQsijYxMGh75ly/e3rCPN1Vj7N1D3GYJV24o6ja6ysxw1ZMSKTAsFLb22FckO5YwCHRmRUqCGkIc1rCkyclzH+fn5OHLkCACgYsWKqFixokPneZRNcL1wg/I6VZQxVtjK849LK4m/tYDgURC7NwhVZCg8cjsyGQ8In1jWvBYQEqSMH42PD4MxfRmsmaLD9XUMLv7I4Jmewus7jgINniUY/z8zv7rJVcm+WsqPsaRZbQZfvqrD4UU63N/MYMV7Qjn9zEfAs9MJ2r1MsGl/0Zg34BpFRqfTOZT/ZcwnOFEo6tSKBcqEKsfOtiKZZHXKCy2JczfqqCzRl8NVisyRI0f4DU87derk8HnOC2lNqrTx+KHSLQxuB70OgCoyFBFyb08gXqrqqdVKpcEwDKpXZrDqAx22zGQQW7gSJScP+OoXoPpwgudmmHE9Q6i26yqlwFFHZt+/wgTQrqHTXXIJIUEMnu3N4Ox3wmahAFvXp+8kgsajCX7cQaDTya/IEEJ4R6ZKlSrw9/e3+xzHzwNGVjhTZVgJsFhmK7Mi42hulxhOkWEY8DlWakMSvmNYr0aO63jnzp18u2vXrg6fR7xiqU5V9TnjAPDRs0CzwqGyQFcegI4qMhQBTpEJCgpyWLoUcyBJmGDb1Ff+j6Z3awZJqxhMGAoEFs51+QXA8i3AoE+rAL5sHErOH424howjoSVCCP4pVGSCA4HG8u0q4RLKR7CraTb9H4P6ccLzZ1LY0vqp5En+ObnsfOfOHb5ysqNhpX2iYoNKUr3swd+KWuDMnSy3aqlMmTJOl2oghPC5G3HRcNvGm3IjCd/JYGOOv/76i28748iI9+FSoyIDsDefYeLEdZ0fdWQoLCaTiV+1FB8fL0vs9KBIkWntpv2VnCU0iMHsV3W4+jO7j0pECPu8IVcHBLGykpIUmWu3gLTCmHeb+mzYTA30acPg9HIGv09n0Kqe8PwDIjyQy87iRF+Hw3cKWhXmKNZCS46G78xmM+/IyBFWSrsjFGlT6wQLQJLgLleOTHZ2Nvbv3w+A3YstLi6ulHcUjxbykABL5csfZrNZ1lWOckAdGQ+QlpYGo9EIQJ78GJOJ8KGl6LLgQzZqoXwEg09f0OGNwaInZbzD4uAcmcjISJQtW9bu94uVAqUkU9uKTsegX3sG274QnC/CCLe0rnBkHFFkCCG8nSNC1DsBSPI3GOeu5Vu3bvFJ6nKGlQB1OzIMI2wTAT0bjnb2Ot63bx8/NjujxgCCnf18gWrOi+4ew5q6qDRVhjoyHkDuRN+zV4WVNG3qqys7XoxkB2EZ8grEZGdn83e18igFarWx0CYQHsiV7OusI3PhOnDnPttu11CdhdoA64O/ozZ25dLrug7sTq8keLVAJ08dGbnCSgUFBBeus+2aMepRb60hXYEnbwVluaCOjAcQJ/rK4chIw0oq/sFIBn957rA4xBOso0uvuRVLej0kIRo1IbaxGcpTZJS6Ksxe5Fy1RFcsFQ9nZ0YmpUCc6NulSxeHz3PlppCwrnYby10TyRVQR8YDyL1Z5EFRom9rlU6wgGslTGfzY+4/Ivi3sBhz4+psfo8a0emE4nkEgsHltrNer0e1atXsfr9Y9VLqqjBbkPMu1pU1ZFQ/yXKXsAxKwf3793Hs2DEAQIMGDZzaYVyyYknlNnZVUrWcUEfGA8gdWjqQxP7voweaOyY2KIIAKz8YpTgyB5IALr+tvYonWEAYmMwyOzKEEL5yclxcHHx9fUt5R1G4/Bg/X2F3bzUi512sqxyZsuGe2bldTvwtHBlnJthdu3bx4T+58mMA9S695vC3ku8lZ90pOaCOjAfgHBmdToeqVZ3LZrz/iOC/K2y7cQ0gKEC9Pxprd7Fyef7OOjJayI/hCHCRI5Oeng6DwQDAsbDS7UzCFxFrUVu9y4IBeSv7yunIPMom/Mo7tSsFgEiRkeHGR678GEC69FqtCescUqec5shQCuEcmSpVqsDPz6+Uo0vmSLLQVnNYCZA3QdIScQ0ZRyZZyYoltSsyhXY2E8HgctjZ2fwYbg8rQDs2BiBbjoxer0d0tHObe0kSfVU+wQKCnYkMNz6cI6PX69GxY0en+iVWZGo7v9DMo1gLLVFHxsvJzMzE/fv3AcgbVgLUUQivJFyV7EsI4R2ZKlWqIDAw0K73G/OF5e1x0UClctqws0lmRcb5RF+R6qXiRF+gaO0NwHlHpnLlypJtJRxBmh+jbhsD8uXIpKen4+xZdoOvFi1aICwszOE+ESJsFxNTXjnbxTiKtdCS0hwZ534VFLuROz9GkuirkkJ4xSGn53/kyBHMmjULFy9exNWrV3nn0ZGw0vHzQC5bWkK1BdrECIqMc7uMG41GzJgxA5cvX0aFChVw9OhR/jXHwndCW6nbbNiKXNeywWDA3bt3AchVQ0a0YklDigwYPZwpny/XtgQAcPcBu78ZoBUbMwAKrxuFhpaoI+NmuGRIwPkVS4QQful1uXAgvpJTp/M4AVbyChyVikeOHInk5OQizzdv3tzuc0kL4an77goQJlkTcU6RWblyJT7++GOrr9mryGTnEhwvTGOqU0VDSaiAU/le4vGiRo0aznZLElrSRI6MRVK1o+PFvn37+LazjszZK0JbEzamigzFEnGuhqOF2TjOpwqev5oL4XFIBn8nKnUaDAbeidHpdIiNjUXVqlXRtGlTvPPOO3afTwsl88XwoSUnc2SOHDli9fmaNWvanZR6JJndawvQho2t7czsiI3l2OhUDBda8vdTd7VZDj8Lh9HRCVZc26tRI+cuQK2F79RQ2Zc6Mm7G2Y0LxRwU5ceouRAeh/gHo9MHwAzHfjDiu9hnnnkGK1ascLhP4pL5ZUK1lSAJgN01mOQ7ZGdxTszmzZuRlZWFrKwsdO/eHXq9voR3FkUrhfA45No00tm8IzHiarO1YgC9Xnt2NpnyHDrPlStXAADBwcEObV8iRhy+08R4oYLKvtSRcTOcI6PX653KkckzEvz4lzYK4XGIfzCME4qMnHex51OFkvltG6i3ZL6YIvV6TI45Mpydy5cvj8TERKf6pJVCeBzWQkueVmQupwuqlxZyN4CiikxBgcHuc5jNZt6RqVatmtPKtiR8pwE7W6uJRAvieTGEEH5giouLg7+/v0PnuXufoPsEgj8Os4/DgoHH6srVS88hHvwZHbuyyNOOzM9/C+2Exup3YgB5apxkZWXhxo0bAJy3ccYDgr/YgqqILgtUr+zU6RSBtdCSI4O/+Fp2NkdGS9VmOYoqMvaPF7du3UJeHqvkOLPbNQdn59Ag9npWO3Lu5O4qqCLjRm7cuIGsrCwAjoeVzl0j6PMuwaU09nGgP/DdB4zql/gB1nNkPCnHE0KwYhurFDAMMMy5HEDFIEfMW86Qx487BKXgqW7qz/UC5Bv8OTtXrlwZwcHBTvXp7xOC6tUgTv02BiwdRj8UGO0fLzg1BoBD22qIOXKW4MpNtt2oukauZRmLO7oK6si4EfEqGkccmfOpBK1fJLjP+kKoGAlsnMGgRR31/1gAacjDmU3g5LqL3XcGvMPYtTlQJUobdrZWr8feSVbsyDiryHDOIgA820uDNnZw1VJmZia/9NpZZ5EQgl/3sG1fH6BHS6dOpxgsa5w4Ml5cvnyZbzvryMz7VbiWR/XW4LWs0OXXNLTkRpxN9P1kueDENK4BHF6oHScGkK/2BufIxMTEOHUXu3yLaFDSyAQLyGNnucJ3Zy4RHCv8WTSvDTSsrg076/WsigfA4VVLcjqLx84B126x7a7NgYhQbdjZsnw+IcRuO4sVGWdCS7czCX4qLEdTJpRVF7WAtTCp0hwZqsi4EWccmas3CX4qzNcoGw7smccgLFgbgxGHNEfGsR/MvXv3kJGRAcC5wd+QQ7C20N6hQcDABIdPpTjkqNQplyOzcps2nUWGYeDvS9hCih62MQD8ukew86AE7dhZjhU1cikyizYAxny2/cLj6t73TowaKvtSRcaNiB2ZOnXs29p3zloC7tp5bZD2nBiAlbw5iM6xHBm5cjd+3QNk5bDtJ7toZ1AC5MmREU+yjq6+yy8g+P5Ptu3rAwzXyB0sBz/JejgPiRCCdbvZNsMA/ds7fCrFYW1FjTOKjKOOTH4BwTe/s86iTge8PECr4wUNLXk9nCMTHh6OChUq2Py+ew8Jlmxm24H+wCsDXdE7z8MwjDD4e/gudsVW4Q52tEZi3RxFll/DcTvHxsYiKCjIoX78cRi4dY9t92sHlA3Xlp35SdZBpUCua/nsVfC7indoBFQoox07+/uJvouDuUicIxMWFoYyZco41I/1e4AbbDoT+rYFqkVrx8ZqqOxLHRk3kZOTg6tX2XV5tWvXtiub/ZvfAEOhOjC6t/rLt5cEP8l6cPC/kk6w8zjbrhkDtFH5vj+WWFuFYM9dbEZGBjIzMwHI5yxqJTFSDH8n66SzqNPpnNrO5NfdQltLYSXAuiJjj51NJhM/LjtTQ2a+KMn3tSe0ZWM1VPaljoybuHDhAghhL3Z78mNy8wj+t06QLCc8qa0fiSXcj4Z4MAl11R9Ce1RvRhNLKMWwm8AV4oCd5bBxxgOCDYXb20RFAj0fc+g0isaZ0BIhhA8tVatWDX5+fqW8o3jWifJjtJTrBRQtiAfY55Snp6cjP59NbHE0rHTqIsE/hZWp61UDujRz6DSKhToyFB5HE31X/QHcZm9+8URHoHplbU2qlgg/GscUGW7w1+v1Dq1AIITwCagMAzzTw+5TKB5nl1+LHRlHczfW/CXUjhnRHfD10d51LezMbH/I49atW3j0iN1IzZn8mJQbBCcLU21a1NFOCQEOZ7eCkGPFkliNeXWQBm98VLBFAXVk3IQjib5mM8Hsn4QfyTvDtPUDsQavyDgw+FtWTvb19S3lHUU5eQFIYQvWomtzIFZjAz9gfRWCPXaWQ5H5eZdwXY/U0GolMX4WoSV7nEW5ll6v3yO0n9BYWAlwXpFxdsXSQwPBDzvYdliwNm98nA3fuQPqyLgJRxSZDfuEJL1OTYGWdbU3EFnCef/EgaSy9PR0GAzsXiuODv7r/xEm2Cc6atPeztaRcXaSvXNfkOJrxgANHU//UDSWOTLudhYBi2XXHR0+jWJxdkWNsyuWftgBZOey7RHdoYkK65aoobIvdWTcBOfIMAxjc7XZmT94lxoDCMm+ZrAjlLtzN7g7WIYB+rdz6BSKx9ny+ZydfXx8HBr8N+4DuI8b2EEbZdytYbnLuLvDd7fuEez/l23XjwNqxWrPzhK1wIGwhzOhJUIIFm4Qxuix/bRnX8ByvLB/XHYH1JFxA4QQfnuCatWqISAgoNT37DtDcCCJbTeIA3q3dmUPlYOQV+ADQOewUuDI4H/xOsG/hUpz63pAdDltDkwBTtxhmc1m3s6Ohu/EqtdADYY7OCwrotqjyMgRWtp9Umj30ej44ay6KA4tVa1q31bVR5PB5x89VhdoXEOb17LUWaSKjNdy8+ZNPnHP1rDSFz8Kg/3bw7SXQFYclsl79pQcd1aRWf+P0NbyBGstQdJWG9+4cQPZ2dkAHLPxo2yCP4+y7UrltLFre3FY5iI5osj4+fmhShXHtqredVIYQzo30+b1bLlFAeCYIhMREYGIiAi7PnvRRsG+4zSqxgCAjw8DHecpeEuOzIoVK9CnTx8kJCTgqaee4ifwFStWoFu3bujSpQu++uorfikyACQlJWH48OFo164dxo4di/T0dP613NxcfPTRR0hISECfPn2wbds2ubvscuzNj0m+SvD7XrZdubz2Kp6WhDN3WE47MuJlqh3sfrtqkNrYvgrKztp42yEgz8i2B7QHdDrtTgCWITxbbWw2m3Hx4kUAbNVkvV7v0OdzioxeD7Rr6NApFI8z+RsFBQVITWWTEO0NKz00EPz4F9sODWKrf2sZId/LC1YtrVmzBvv378eSJUuwe/duTJ06FX5+fti7dy9++eUXrFixAmvXrsXevXuxYcMGAIDRaMTEiRMxbNgw7Ny5Ew0aNMDkyZP5cy5cuBAPHjzAli1bMH36dMyYMYMvYKQW7F2xJF6pNH4wAz9f7Q72lkjvYu1bGsxNsgEBAYiJibHrc9PvSkN5NWK0a3NnFBlnQx7eElYCilZEtdXGqampyMvLA+B4fsztTIL/rrDt5rWAUA0moQLOKTJpaWm8c2lvrtcPO4QipSN6AMGB2rQvhxDyV6YiI9umkSaTCcuXL8fixYsRHR0NAHxS65YtWzB48GB+chkxYgS2bt2K/v3749ixYwgMDET//v0BAGPGjEG3bt2Qnp6O6OhobNmyBbNnz0ZISAgaN26MhIQEbN++HWPGjLHaD6PRCKPRKP2SPj5OFZSyBjco2TI4cfkxADswlfSe9AyhIFtYMPDC4wRmMyn2eK1R3E6rpdnZZDLh0qVLAITrzh4pXxxWGtDB/v1a1IRvMTFvW76z2CmvXr26XXYy5gObD7DtMqFAh0bavrYtl63aamN7xovi2HVCaCc01u717FtMsq8t3zclJYVvV61a1WYbEQIs/F14/EIf7dqXw7KUgK02lgOdrnS9RTZH5vbt28jLy8OOHTuwZs0ahISE4KmnnsLgwYNx+fJlJCYm8sfWqlULCxYsAMBeTOJVPIGBgYiJiUFKSgqCg4ORkZEheb1WrVpISkoqth+cMyVmyJAhGDp0qFxfVQInTZbEiRPCqBIcHFyiovTFzxEw5ocDAIZ1fIDMu/eRedf5fqoFk7EsgBD2gehHU5qdr127xlforFy5st2q3U87KgAIBAC0qnEDV6/m2/V+NXHvrh8A9mbDHhsDwKlTp/h2UFCQXXbefToADw1RAIBODbNwIy3D9k6rkPy8SACh7AOdP0ymHJtsfOjQIb4dGRnpkAK9eW8ZAGEAgLqVbuHq1Vy7z6EGMu74AqjEPrDzWj527BjfDg8Pt9nOpy/74eRF9vfTOD4PZfxuQmVBArvRM5UB+NhtYzmwJewnqyOTlZWF69evY8OGDUhLS8PLL7+MatWqITs7GyEhIfyxwcHBfMJgTk4OgoODJecKDg5GTk4OsrOzodfrJat8xO+1xujRo/H0009LnnOVIpOamorY2NhSPUbuDx4SEoKWLVsWm7hLCPBb4R2rrw/w4ehwVC4fLmu/lU6keM82kVpQmp3Pnj3Lt5s0aWLXCoQHWcCBwrdXjQJ6d6gELedWPxKrwqLQki3X8vXr1wGwNxytWrWy6W6JY9/PQvvp3iGoWjWk+IM1gPRa9oPJlGWTjTMyBAevdevWdq+mAYDjrDgJnQ4Y1DUKYcElH69WJDOBqCCeLXbm8jcBoGnTpjbb+TvR3lUvDvR36O+jNoIDCxsi1csWG7sL2RwZf392QBw7diwCAgJQvXp1JCYmYt++fQgKCkJWVhZ/rMFg4HfMDQwM5IuYiV8PDAxEUFAQTCYTcnNzeWdG/F5r+Pn5ye60lIROpyvxj5mbm8tnxteuXbvExL1LaQTpGazU3rkpEBuljIvEnQT4ieRKkfdfmp25sBLA2tmeH9jWQwT5BazdB3QA9Hpt2z0ogAAoDOkwttu4oKCAl+Nr1qwJHx/bhw+TiWDDPvYzA/2B3q0YTSf6AkWvZVtsDEid8jp16tg9Wdy9T/DvZdbWzWoBEaHavZ4D/ETXsqjwoC12Fisw8fHxNtv52Dnh79q1mfavYwDw8y38znaMye5Etl5UrVq12JoScXFxfBY+wCZlcru5xsfHS17LycnB9evXER8fj7CwMJQtW7bY96qBkydP8rHEhg1LXjqw74zQ7tBI+z8OaziaiCrO3bA3QfLHv7wnARVwfBO4y5cv88mR9tr48Flhz7CejwFBAV5gZ4sVeLbYOCMjA7t27QIAREdH8/mG9rBHiP6hY2O7364qrBXEszV3w9GqvkcLh5rwEKCGfWsKVIvSk31lc2QCAwPRtWtXLF26FEajEVeuXMHWrVvRrl07JCYmYt26dUhLS8Pdu3exevVq9O7dGwDQvHlz5OTkYOPGjTAajVi6dCnq1avH/4ATExOxZMkSGAwGnDlzBnv27EH37t3l6rbLOXjwIN9u3brkqlR7zwgTqlaXS5aGtaXBtvxoDh8+zLfr1atn8+clXSbYtJ9tVy4PtGtg81tVixw2btDAPkNJirO10b4TAwB+4o0wGT+bbPzTTz/xuV5PPfWUQ/Wjdovqx3Rqqm1bWyvXYOsyd64YXtmyZREaGmrTe27cJbhRmLPYorZ2q1JbIuzk7guAUZwjI1toCQDeffddTJ06Fd26dUN4eDheeOEFtGjRAgC7bHPkyJEwm80YMGAA+vXrB4ANBc2cOROffvopZsyYgXr16mHq1Kn8OceNG4dp06ahV69eCAsLw6RJkxzebt0TiB2ZVq1alXjs3sL9Z3z02i4UVhIBfgyshT1KwmAw8AnV9erVQ2RkpM2fN2O1qPDgkwx8NLgLsyWOKjL79u3j2+3a2bd/w75/BTt3aGTXW1WLpZ1tsfF3333Ht5955hmHPnfXSfZ/hgHaa/yGyNEtCvLz8/l8L7vUGGFBGVrYVttUE0jLYtjmlLsTWR2Z0NBQfPHFF1ZfGz16NEaPHm31tfr162PNmjVWXwsICMC0adNk66O74VYgBAUFlXgXm/GA4GxhyLZZLe3XJSgORybZw4cP83dh9kywl28IRa3KhgNj+trVVdViOSgBtsnxe/eyVRp1Ol2p6qIYs1nY86dcOFAr1ua3qhrLYm2lXccXLlzgb3waNWqExo3tjwvde0hwpnBVcdOaQESotscRqSJj+7V8/fp1/jh7iuEdPSc45C3raNu2YqyVElASysjU0Sg3b97k47AtW7YsMTmSG+gB7d9FlYQjjoxYKWjfvr3Nn/XFGgLu1G8MZrzGeSyuVk9J3L9/H//+y16kjRs3tlmKB4Dka8C9h2y7XUMvkuMtKvuWZmM51Jg9p9jVjwDQsYlDp1AV1hQZW0JL4j2W7FFkjogVmdJrm2oGR/K93Al1ZFyIuB5EqfkxpwVPv72XJvoC1kuOl3aHxSkFgO2KzM0MgmVb2HZIIPDqILu6qWp0OkYoJGajI3Pw4EF+WxG7w0qiJPZ2Db3n2ras7FvSBEsIwffffw+AVbyeeuophz5Tkh/TRPu21usZ8AtB7VgcwCVUA7ZVWwfYvxEXWioXDlSJsqen6sZSxVVaAUDqyLgQu/JjJIO9q3qkfOxVZEwmEw4cYIvvREVF2byibc5awu/589IAoIzGJXhL+B2wbcxDEjuL9qhegNRJ94Zkag5LRaakwX/fvn28StCtWzdUqlTJ7s8jhOCPwnxshgE6aHzFEgevytixRcFvv/0GgFUH+/TpY9PnXL0J3H3AtlvW8R5lEXBuJ3d3QB0ZGcjPz8eKFSuwY8cOyfO2OjK5eYRf0lczBqhQxnt+IJaU5MicOHEC8+fPl9QdSkpKwsOHbNyiffv2Ng0umY8Ivv6t8PP8gDeHeJ+9/S1Kjpd2h+Vcom/hZ/oBzb04QbKkwX/VqlV829Gw0s7j4PPs2jbwHufc3qXBly5dwpkz7J1j69atUbFiRZs+56hQ4cGrwkpA0XFZaYqMrMm+3srKlSsxZswY6HQ67Nu3D61bt4bJZMKRI0cAAFWqVCnxDuvoOXYfGgBo7yUrOoojwMpySpPJhLy8PHTt2hWZmZk4ePAgL8M7Elaas5Ygq3DDt9G9gehy3jHgixGWU5a+/Do/P58Pk1atWtWuDTlvZhBcSmPbLesA/n7eY2vLu9jiBv/c3FysXbsWAFu5fODAgQ593py1gvL1xmAvtLONiszvvwsbJXF7/NnC0WTBvi1qe499Afucck9AFRkZ4JIgzWYzZs6cCYBVCjjloPT8GKHd3otyCKxhLUfGZDLhxo0byMxkK6r9+OOPfIVZe5WCO/cJ5rBzBnz0wMTh3mlvS0WmpMH/xIkTyMlhPT9n8mO8LYnd1uXX69evx4MHbMziiSeeKLJliy2cTyX8hpxVooCBHew+hWoRFBnbHBkurAQAAwYMsPlzvDXRF3CslIA7oY6MDHCDEMD+SM6fP+9wITxvV2SKq+wrtrHZbMacOXMACIpMYGAgmjZtWur5Z3wvqDFj+gJxlbzckbFBjperfow3JfoClnex/iCEFFFlcnJy8P777/OPR44c6dBnffWzYOfXBnlHPSQOazszF8ft27f567lOnTqoXdu2WKfZTHDsPNuuVA6o5GUqrmXiOnVkNMj9+/f5NiEEX375pc35MeIaG+Uj2BwZb8aaI1NQUCCxMQAsW7YMp0+fxrVr1wCwNi5uiwyO67cJFvzGtgP8gA9HetdgJEYILdnnyNif6Cu023pRoi9gGVqyrhZ88cUXfImGLl26oEuXLnZ/TuYjghXb2HZwIPDC4470Vr3Yo8hs2rSJdybtUWMupbGbywLeVQiPQ+mKDM2RkQHLSXbFihWoUKECAMDX17dEpeDsVSCzcBPW9l5UY6M4pD8YNn/DbDYXsXF2djZGjRrFP7ZFKZi2Slip9Oog77urEmNrsi8hhFe9wsLCUL9+fZs/IzuX4MQFtl2vGhAZ5l32Ls4p5zbYvXr1Kj7//HMAgI+PD+bNm+fQ73/xRiA7l22P7q39IniW2KPIyBFW8qZCeBz+korrdPm1JhGHPQAgLy8PqampAIAmTZogMDDQ2tsASO9YvU16t0aAv+iBKOxhaWMA/LYEQOlKwaU0gqWb2XZoEPDuU95ta0lSdQklx1NSUnDr1i0AQNu2bUvcvd2Sw2eBgsLTemNJgeLyvTjeeust5OayHshrr71m1x5hHPkFBPPWsRMMwwCvP+F917WfjTWRsrKysH37dgDshpwtW7a0+TPEFX29LT8GKFrZlyb7ahBOLQgMDCwy0JeWH/P3CbpRpJjill+LHZmwsDDJexiGQZs2bUo875TlhJ9U33qSQbkI7xvwxVgqX8XdYTmTHyNx0ht4n72lg7+06uyOHTuwbt06AGz9o48//tihz/j5b+D6Hbb9eBugZqz32Vmai+Rb7LW8fft25OXlAWBXK+l0tk9/R7x0jyUOpS+/po6MDHCOTExMDIYNGyZ5rSRHpqBAKGAVEeKdPxBLikv2FYeW3nrrLcl7GjZsiPDw8GLPeSWdYPWfbLtsOPDmULl6q14s7cxNsEeOHEGjRo3QtGlTDBs2DPPmzeMPcybR1xuT2C2TfQHWKTeZTHj99df5l2bMmFHi9Vsc9x8RvPONYOPxXlgPCbBMRC1+abA4rGTPsmuTieB4YaJvtYrwypsgfwsFlyoyGoMQwqsF4eHhePvttyWvl5Tou/9f4H5hAlnv1vCqlQbFYW3wLygokCgyXbt2RadOnfjHpU2w63YL+8+8MZhBWDC1c3EbGs6bNw9nzpzByZMn8dNPP+Ho0aMA2ByOxx57zKZzX71JMPpzM7azZZQQFQnE21+oVvVY7k8DsNfyyZMncfbsWQDs+ODoSqWJ3xLcuMu2e7UCOjdzprfqxRa1wGg0YtOmTQDYzY07d+5s8/kXbxJykFrWdaan6sUytEQVGY2RlZXF/1EjIiLQpEkT9O3LbqNcp06dEkvmbzog3E31aU0nV8D64G+pyEREROCDDz7gH/fr16/Ec67bLdj5SfsXhWiS4gZ/Lh/Gkl69epVa38SQQ/DmPDNqPU2wYivAjXX92nlnEru1DQ1NJhNu377NP92zZ0+7QhwcO48RLN7ItkMCgYVvM15pY8A2RWbTpk18HarHH3+cT7gujWu3CN75Whg/XurvnTa23GVcaYoMXbXkJJYTLAB8//332LBhAzp37lzi4LJpP/u/TsfeUVGKr+xraef69etj9+7dyMnJQY8ePYo93427BAeS2HaDOKCWF+YQWKO45ZTcYM8wDJKSknDhwgU8evQIvXv3LvWcL84m+H678DgiBJj0NIPxQ+TsuXooTpHhbAwAZcqUsfu8hhyCMV8Ik+v/vcigSpT3Xte2KDLLli3j2+LVjiVBCMHYL6R1pzo38047K33TSOrIOIk45MHFucPCwjBixIgS35dyg/D7orSpD5QN984fiCXWQktms5nfTwkQ7JyQkFDq+dbvEdqDOsrSRU1gGVriBiZukg0PD0fdunVRt65tWvr12wQ//sW2A/yA8UOAiU8xXrPfjzUsN40EWKfcWUdm8lKClBtsO6Ex8KLt6R6axLJej+WqpRs3bmDr1q0AgNjYWHTt2tWm867cBj6HsXJ54IuX6LUMQJGrlqgj4yTWFBlb4MqJA8Djbbz3B2KJXs9ArycwmWC1IJ5er7erhPuve4Q71yc6UjtzWCpf3MDETbL2TrCLNhb+zQBMfAr45Dkatfa1ElqyVGQiIyPtOuexcwRzf2HbAX7A4okMdDrvvq4tb34sHZlVq1bxjvqoUaNsKiFw4y7Bm/OEsWPh2wzCQ7zXzpaVfZWmyNDRxkkcd2RE+TElrxz2OqwVa+PsHBERYXMuwN37BLtPse3qlYGGxacreR3Wll8TQng72zPBGvOFfA29HhjzuPcO+GIYhrFarM1RRYYQgtfmEj73aMpohoZKUXSZu9iRIYTYHVYihODFWYRfiDGiB9DHy282lV7ZlzoyTmIttFQaWdkEfxfWcqsSBTSgE6wEa/sAiVeG2cqGfeBVgicSvDPhtDisDUyPHj3iByh7Jtjf/gFu3mPb/dsBMRWonTmsbc557949/nV77Lz6T/D5XnWrAhOelKuX6sYyTCoOe+zbtw8XLrDlpTt37lzi4guORRuAjYX5ixXKAHNfo9ezZY4MdWQ0htiRsVWR2XEMMOaz7T5t6ARriTD4s1sUiJN97VG9xGGlQTSsJIEtOV5IoRzv6AT79W+CnV8eSO0sxnIfIEeTfR9lE0wU1Yz56nUGvrRcA4Ciiow47CFWY5577rlSz5V8leDN+YKdl77L0PxFWOYhUUVGczgSWhKHlWh+TFECLDY0FCsFttr4oYHgT7YECmLKAy29sKx4SVhb6eHIBJt0mWD3SbZduwrQxUtrmRSHXKGlz1YRpGew7f7tge4t6bjBYVmsjRsrHj16hLVr1wJgF2AMGjSoxPMY8wme/pQghy3+i5cGAI+3pXYGlJ/sSx0ZJ7E3tEQI4RN9A/29t4hVSVjuzCx2Fm0NLW0+IKheAxPg9QmRllgbmByZYL/5TVpjg6qLUizDpGI7+/v7l7gPG8eFVIIv1xaezw/48lVqYzF+YmVKpBb8/PPPMBgMAIDhw4cjKCioxPNMXipU8K1TBZj1MrUzh6WzSJN9NYa9isyJ8+DvrLo2BwL96Y/FEsvBXzzB2qrIiIvgDUqgNrbE2vJrex2ZR9kEq/5g24H+wLO9ZO6kBrCWI2PvyrC3FhDkF94Av/0kEF+JXs9iLAvicY4Mp8YApYeV/jlFMPNHtu3rA/wwmUFQALUzB1VkNI69jszWQ0Lb2zPhi8Ny8Lc3DynPSLCtsP5DuXCggxfu81MaARaVOh0JeazdCTzKZttPdwcivLhmTHH4lZAjY4uNU28RPvG0cnngvRHUxpYUVxAvNTUVABAUFFTqTtdf/UL4bUw+G8OgaS1qZzHSKtV0+bXmsDe09MdhQSnoafsu8l4FrxYwOoDxkUywtth43xnAUFiNM7E1W5uGIsXa8muxU27LJLthn3Atv0CXXFvF0inPzc3lwx22LHHfJKo3NbYvg+BAamdLituigEteL1u2bIkhzzyjsHlvuXBgAt1UtgiWVappsq/G4BwZhmEQGhpa4rEPDUK5/JoxQByViK0iVQsC7A4tbRM5i71aURtbw9rya3sKteUZCXYcY9tRkTSZujgsnfK7d+/yr9niLG4UOYt928rdO21gTZEhhEgcmZLYfRL8NgT0xsc6Uhv7UkdGa3B3sWFhYaVu/vb3caCg8O/f07aNhL0Sy0qd9obvthWG7xgG6N5C1q5pBmu7X9sTWtp9UtgRuHcrmkxdHJYbR9rjyBhyCHYW1puqXB5oUtMFHdQA0uXXvigoKIDBYIDRaARQulMu3ry3bzt6HVvDsrIvdWQ0BqfI2DLB/nFEFFZ6jP5gisPyDsueVUtpdwjOpLDtlnWAchHUztYoTZEpbZLdclBcmZrauDgs7Xznzh3+YWk23nEUyGPnYjxO600VizWnXFwTqSRHhhCCjfvYtq8P0IOG+63io2dvDAHQ0JIWsadQGxeH9fUBOjVxWZdUj2U8Nicnh39Ymp05GwN0R/GScNaR4UoI+Oip6lUSlpOsPY4MVQpsw1pBvIyMDP6pkkJL/10Brtxk2x2bAGHB1M7WYBhGUtyROjIaIi8vD3l5bPWk0pSCi9eFHWvbNwRCgugPpjis7YDNUZojs/WQMPj3pvkxxWJpY3GyL8MwCAsLK/a9F1IJLqax7faN4NWb6ZWG5SRra2jJbCbYVLhaKdCfFhosCWtbFNiqyHBqDAD0pcXvSkRc34s6Mhri4cOHfNsepYCGlUrGMtlXTEkOY0GBUM23TChNQC2JALF/qAuQyPEREREl5nuJd25PbE2v5ZKwVBdtdWSOnxf2r+pG602VSGmKTEmOjFj1epwmU5cIb2fqyGiLR48e8e3SHRnhB0PjsCVjGfYQU5KdD50FHhTuWNujJV19UBIlhZbsy49xRe+0g6XyZasjs3E/DSvZiqWNLXNkigst3b0vrCKtV40WGiwNJYeWfEo/hFIcYkWmJKXAmC/sdl2hDNC4hqt7pm5KcmRKCnlsO0SXXduKtUqdXC5SSXewWdkEu0+x7aoV2V2YKcVTNLR0nX9oa8iDOoslI93QsGhxx+LsvOUgwNV1e5zauFSUHFqijowT2BpaOpAk1Cno0ZIuVS0Ny5g3R2hoKPR6fbHv2yYO31HVq0QsbczlegElKwV/iXdub01X0pSGpZ1tUWTS7hCcuMC2m9cGKpWjNi4JqSLDOjK2JPvSZGr74J1yuvxaW9gaWpJU86X5MaXi7yvdBI6jJBvfziQ4msy2G9cAoungXyIlqV4lOTKbRWGlRLrsulSKK58PFG9nLskXoEqBLfhZCZOWluxrzCd8vanIMKB1PRd3UgMoWZGhjowT2BpaEif60vyY0iluki3Jkdl+RGj3psuuS8XfQo4XU9wESwjBloNsO8AP6NzURZ3TEI44jOKVd1QpKB3LooOWiow1R2b/v8I+YYmtAR8faufSELbbYG1MCCnxeHdCHRknsCW0dO+hsDV8k5pAhTL0B1MaklVLjLBqqSRn8a9jVPWyB8tKnWKKm2DPXgXSCsugdG4KujuwDfiJ1UVGuLADAgIQEBBg5R3gx4vwEKApreZbKpYrwyx3crfmyHA2BoAuzeh1bAuWITwlbRxJHRknsCW0dCRZaHds7OIOaQTLgYmjJEWGG5j0eioT2wLDMCKpWDqhFufIiAf/hMZ08LeF4hSZ4mz8IIsg9TbbbhhP8+lswVKREdeRCQkJgZ+fX5H3/HtZuPFpVN3VPdQG1kJ4SoE6Mk5gS2jp8Fmh/VhdOijZQnFhj+IcmTwjwX9X2HbdKkAArblhE5Y7M3MUN8mevCAM/k1ruapX2qK44o7F2fjfy0K7QZyLOqUxrO3MzIWWilux9G/hNiYMQ1fe2YqlIsPtMq4EqCPjBLaElg6fFQb/x+q6ukfaoLjBvzhnMemysBknnWBtR6gLYaMjc1FoN6ElBGzCcmkwR7GOTIrQbhBHHXJbsNw0Upzsa23FktlMkHSFbVevREOktmKt9pRScIkjc/r0abRs2RIrVqzgn1uxYgW6deuGLl264KuvvpIkCiUlJWH48OFo164dxo4di/T0dP613NxcfPTRR0hISECfPn2wbds2V3TZIUoLLRFCeEUmMgyoXtlNHVM59oaWuKWqANCkBh2UbKU4RcbaXSwhhHdkKkYCUZHUzrZQXGipWKVAFPJoEO+qXmkLy3yvhw8f8mqBNTtfThd2bqc2th2vCi2ZzWZ8+eWXqFdPSFTYu3cvfvnlF6xYsQJr167F3r17sWHDBgCA0WjExIkTMWzYMOzcuRMNGjTA5MmT+fcuXLgQDx48wJYtWzB9+nTMmDEDV69elbvbDlFaaOnqTeB2Yc7ZY3VpzQ1bCbDbkRGFPGhypM2Il1OKsaYWpN0BMtiN3tGE2thmpHVkbFBkaGjJbhiGgS9fPt+v1BoyUtXLxZ3TEJZKuZJCS7IXxPv111/RoEEDZGVl8c9t2bIFgwcPRkxMDABgxIgR2Lp1K/r3749jx44hMDAQ/fv3BwCMGTMG3bp1Q3p6OqKjo7FlyxbMnj0bISEhaNy4MRISErB9+3aMGTPG6ucbjUYYjUbpl/TxsZrw5Qxms5lXZIKCgqDX64tkcR/8T2i3rANFZXkrGV+JVCwkooaGhlq14UmRItOoOoHZrJxlgUqmuNBSeHh4ETuLE30bV6fXsq34iOs3WuR7WdqQEODMJbYdXRYoE0qvZVvx9wXyCwAw/sjNzeWfL1OmTBE7nxE5MvXj6LVsK5Zh0vz8fLfYrqR93zhkdWQePHiAH3/8EcuXL8eXX37JP3/58mUkJibyj2vVqoUFCxYAAFJSUlCjhhBwDwwMRExMDFJSUhAcHIyMjAzJ67Vq1UJSUlKxfVi+fDkWL14seW7IkCEYOnSo09/PEs6RCQ0NtaoS/XUoAgCr1FSNvI2rV3Nk74MWyczwB1CRfSCaZAsKCorY2WwGTl6MBaBD5XIFeHgvDQ/vgWIDOlIRgH8RRebRo0dF7Lz7aDiACABA5Yg7uHo12z2dVDkPMgMBVGAfiK5lhmGK2PjOAx0yHsYCAKpXzMHVq7fd1U3V46OLAaAvUhNJr9cXsfOhf8sBCAYARPrfwNWr+W7qpbox5pYBULhFDOOPa9euFRENXEFcXOmymayOzIIFCzB8+PAi++FkZ2cjJCSEfxwcHIzsbHYgzMnJQXBwsOT44OBg5OTkIDs7G3q9XlJvQfxea4wePRpPP/205DlXKTJcaCkyMhJVqxZNfT93Q2j3SaiACiXvxUcp5G6u6IFokq1Ro0YRO1+4DhgKj29Rx8fq34FinVDuJ6nzA8AAINDpdKhfv36Ru6ArQmV9dGtdHlWruKuX6ib2juiB6FqOi4srei0fFdot6gXSa9kOAgOA+wYUURfj4+OL2PFKoX/o6wN0fKySVAGmFEtZ8fyl80dUVJRirlHZ/oTJyclISkrCu+++W+S1oKAgSajJYDAgKCgIAKvAGAwGyfEGgwGBgYEICgqCyWRCbm4u78yI32sNPz8/2Z0WaxQUFPD9joiIKDLwFxQQHDvPysLVKgIVy9IFYrYS6E8AFErqFrU3LO186qJwbNOaDK27YQf+fiJZWOcPmHMREREBH5+iw8KpS+yxQQFArVhqZ1sJ8BNdy6IcmcjIyCLX8n9XhGMbxlMb24Ofb+G1bKHIlC1bVmJnYz5B8jXWxnWqAP5+dFy2lQB/8XjBFsRLTk7GzJkzERUVhV69eqFz584e6Ztsjszx48dx7do1PoSUlZUFvV6P69evIy4uDhcvXkT79u0BAOfPn0d8PJsuHh8fj/Xr1/PnycnJwfXr1xEfH4+wsDCULVsWFy9eRIMGDYq815OUtvT6v6tCZnwrWqDNLqSVfUtO9qWJvo5TdJl7rtUk1IcGgktpbLtRdUCvpxOsrRS3As+anSUrlmgSql0I+V5SR8Zy1dL5VKFUA12xZB/sHnicU86uWjp37hxWrlwJgM2t85QjI5s7OmjQIKxfvx6rV6/G6tWrkZCQgGHDhuGNN95AYmIi1q1bh7S0NNy9exerV69G7969AQDNmzdHTk4ONm7cCKPRiKVLl6JevXqIjo4GACQmJmLJkiUwGAw4c+YM9uzZg+7du8vVbYe5f/8+37a2YumQKNGXFsKzD+mSVSGsaM2REdc2oY6MfVhbGmxtgj19SWhTG9uHPZV9xSuW6lVzXZ+0CF9LxiLfy3LVknRVGB2X7UFar4ddtXTr1i3+qaioKPd3qhDZFBnLvUP8/f0RFBSE0NBQtG/fHhcuXMDIkSNhNpsxYMAA9OvXDwAbCpo5cyY+/fRTzJgxA/Xq1cPUqVP584wbNw7Tpk1Dr169EBYWhkmTJqFatWpyddthxI6MtQmWFsJznOLuYq05jFwNmcgwIKaCizumMazZ2VrdjZO0To/D+FlUQ+WwtLPZTJBUOMnGVwJCgqid7cHPRkXm3xRhXG5IFRm7sCwlYDKZtOfIWDJlyhTJ49GjR2P06NFWj61fvz7WrFlj9bWAgABMmzZN7u45zYMHD/i2tQmWK4Sn19O7WHuxdhcbEBAAf3/p3dbNDIJbhSuUmtakdXrsxVoFZWtKwcmLwuBPK/rah62KzNWbQFbhokYaVrIfobijL7jEdaA0RcYtXdMM1ir73r4trKzzpCNDM50cpCRFxpBD+B9MgzggOJBOsPZguacHUFx+jNCmE6z9SAsPsmqqdUem8BAdzSuwF1sdGckES21sN8UpX8XZOTgQqFrRDR3TEJbXspJCS9SRcZCSHJnj59n6JgDQioaV7MayFDZQclgJYFcsUezDlhyZ/ALBKa8dS/elsRd/K4nrgYGBRdRFmrvhHNau5dDQUPj6Ci8YcghSCkti1K9Gdxa3F0tn0TK0VKGC52L71JFxkJK2J6CJvs6h0zHCj6ZwULKe6Et3Y3YGWxyZc9eAvMKaV3RrAvuRJkiyXo3VRN8UumLJGaxtzmkZVvrvCls9GaA2dgR/CxuLFZmwsDBJjqy7oY6MgxSnyJjNBNuP0ERfZxFi3uyPw6oiU1g2P8APqBXjpo5pCGtqgeUkK93xmjrl9mItTFrSiiUfPVCbFhu0G2v5XkUSfSXhO3ot24uljcWKjCfDSgB1ZBzGmiNDCMGrcwn+LKzQGRkG1FVG4UPVYbkPkKUj89BAcFFU28THhw5M9sLWhSikGEXm5AWa6OsM1sKk1sJ3ydfYdq1YwM+XXsv2Yk2RoSuW5MXyWs7KyuIjE9SRUSmWq5YIIXh1DsE3v7HP6XTANxMYOsE6iOXOzGLVK/0uwXsL6QTrLKWFlvILCPb9KxzSmNrZbnQ6Bj56aWVfS0fmwnXAWLjdD51gHcOaIkNXLMmLpbqYnp7OP/S0I0N3mXAQaUG8CLw2l+Dr39jHOh2w6n0GQ7tQJ8ZR/K3kyFy7RfDZKoIV24SBHwBa16d2dgRroSXuLnbLAYIJCwjOFSoF0WWBqEhqZ0fw8yEoMDFWa/WcvUIwZ604P4ba2BGs5SIVF1oqGw5EFS2XRCkFy7pTYkfGk4m+AHVkHEasyPx9JhILCndZYBhg5fsMnu5BByRn4JcGF06wIaFl0OYlghuizQv9fIExjwPDu7q/f1rA2vLrAl1Z9H7HjG2HpMe+9SS9nh3F3xfIzoNE9Vq2mXVgxCoBwIZJKfZjzSkXKzJ37wtjR4M4WnPKESwr+964IZT8poqMSuEcGR8fH+xLEn5FC95kMII6MU5jmexr9o3hB6LQIODlAcAbgxlEl6O2dhRroaVvt1SQODHtGgJzX2PQog61s6NYVp01+8fj+f8jRY7r2xbo+ZgbO6YhSlNkjp0XXqYFSh3D0llMS0vjH1JHRqVwoaWIiAhcvyM837+9Z/qjNYQcGT8ADPJ1wg9lbF9gxos0vctZLJdT6vV6XLklPPn9hwye6k7vXp3FspRALiOsAKhbFRjbl8HgTkBMBWpnR7Esnw9IHZmjycLLLWpTOzuC5XhBc2Q0gNiRuVZYE8jXB6hIY6+yYJlYlkcEmbgSVWFkwfIOKyIiAmmFTnlQAKgTIxMBFivw8nXl+dfeHMpgTF9qY2fx8xHtzKwrGlo6dk5QwJrXdmfPtIOlgqskRYbe1joAIYQPLYWHhyO1cLuJyuVotUi5sPzRZJsi+IeVy7m9O5rE0sZlypRBWmH4rnI56sTIhaDIsJ5jrlm426lEr2VZsLZFgUSROcf+HxLILnGn2I+fxcowpVT1Bagj4xBZWVkwF+5BEBpeEZmP2Odj6e7LshFgkSH/KC+Mf1i5fNHjKfZj6ciElamMR9nsQzrByoe/X6FDWKgUGPKFa7lSWWvvoNiLtXwvzpG5nUn4m81mtejNpqNYhpa4ORCgiowqES+99g0RChJQR0Y+LMMemYZA/iGdZOVBauMABIQJRUyo6iUfAZwjw/gA0OF+djD/GnXK5UGS7MtItyg4dk54qQUNKzmMtSrVALt3WEhIiPs7JII6Mg4gXnrNBAqJe9SRkQ+p9x+AjCxhkz16FysPlqqXX2g1/iF1FuXDsiLqvcJr2UcPlCu68wbFASxrnABC4UGxI9OcJvo6jLUq1QCrxng6DE0dGQcQKzLEV9jkp0oU/ZHIhdiR0fsG4eY99lItGw4E+FM7y4GlHK8LEK7lyjShWjYs72Rv32flg+iyNMwhF5bLr8PDw+Hjwz55VJTo26KOmzumIXwt6shweDqsBFBHxiHEjky+riLfpoqMfIgH/46de+JGBjvgUzVGPizLuhNf4VqmIQ/5ENs5IKQ8bt8vvJap6iUblsuvJTVkChWZ0CCgRmX39ktLMAwDX72p8IFgcE8n+gLUkXGIbt264cKFC9i4cSMqVGnOP08dGfkQD0zDRk7gtySgE6x8WMrxRka4gOkkKx9iO4eUrc+3qVMuH5aKDOfI3LpH+DpfzWtTBcxZfDhHRmGKDK0j4wABAQGIj4+HXq/HvZ1C4h51ZORDnL9x7Y5wmdLBXz4sQ0uMfyX+IU32lQ/xJFspvg3u5hW2qY1lw3JxAOfISPJjarm3T1rER8dtgKosR4YqMk5yvXBZX6A/EBlW8rEU2/H3Fe6cUkWODFVk5EPsyNSt3wQFemFAiqYOo2yI7dzt8TF8u3J5qg7IRXGKzFHxiiW6zYbT+PoULrnWCZ4jdWRUDiHg6xPEVqAFxOREPPhfuy1yZGgSqmyI72LLlI1G+l3WtuXCRbVPKE4jtvO97Ai+TdVF+bDM9xIUGVFFX6rIOI2vnnNkqCKjGR4YdDDksu0qnv9bagrx4C9WZKgcLx/i8N3p33sj9eCbAKjqJTditeDqTaFNr2X58LMo1sbVkOEUmfAQoDpN9HUaX33R0BJN9lU56ff0fJvmx8iL+A5LElqig38R+vbti27dull97cCBA2AYBsePHy/ymo8e4EREYwEDrlCnO5SCKVOmgGEYvPjii5LnT548CYZhcOXKFQDAlStXwDCM1X8HDx4EAOzatcvq68nJyZYf6xRff/014uLiEBAQgObNm+Off/4p9T27d+/Gmlktgb1BwJEaOLX3W/61SuWAFStWWO17bm6ubP0mhGDKlCmoVKkSAgMD0alTJyQlJZX4nvz8fEydOhXVq1dHQEAAGjdujG3btkmO4f6G4n8VK1Ys5oyuxXKJe2RkJNLvEtwo3HKjWU2a6CsHfjS0pD1u3BMmWOrIyItYLcjLFy5TqhYU5fnnn8fOnTtx9erVIq8tW7YMTZo0QbNmzYq8xjAMPwFwq8IA99k4ICAAS5cuxfnz50s9dseOHUhPT5f8a968ueSYc+fOSV6vWbOmbH396aefMH78eHzwwQc4ceIEOnTogN69e+PatWvFvufy5ctITExE1drtgWbHgNhJuHdiPHB3HQBBkQkLCyvy3QICAmTr+8yZM/Hll19i/vz5OHLkCCpWrIju3bvj0aNHxb7nww8/xMKFCzFv3jz8999/ePHFFzFw4ECcOHFCclz9+vUl/T5z5oxs/bYHy2JtkZGROCa6rOhGkfLg68NtzClcn9SRUTnpGWJFhnr7ciK5wyrERw+Uj3B7VxTP448/jgoVKmDFihWS57Ozs/HTTz9hwIABGD58OGJiYhAUFISGDRvixx9/BCAO4QnXb6XCDSN/++03yfkiIiIkn5GWloYnn3wSZcqUQdmyZdG/f39eSbGF2rVro3Pnzvjwww9LPbZs2bKoWLGi5J+vr/QiqVChguR1vV5fzNmkmEwmTJgwAREREShbtiwmTpyIZ599FgMGDOCP+fLLL/H888/jhRdeQN26dTF37lzExsbim2++Kfa83377LapUqYK+I+YCQXWBii8AUaOB618iwA+IKKzqzikZ4n+2YjAYMHLkSISEhCA6OhqzZ89Gp06dMH78eACsGjN37lx88MEHGDRoEBo0aICVK1ciOzsbP/zwQ7Hn/e677/D+++8jMTER8fHxeOmll9CzZ0/Mnj1bcpyPj4+k3+XLe+ZOw3KLgnLlyuFosqgQHq3oKwt+PoJNwfjC19eXr6DsSagj4wTpVJFxGZLllIV4qhJqixYtEBMT49Z/LVq0sLl/Pj4+GDlyJFasWAFChIHm559/htFoxAsvvIDmzZtj06ZN+PfffzF27Fg888wzOHTokFWH0ZaE6uzsbHTu3BkhISHYs2cP9u7di5CQEPTq1QtGo9Hmvs+YMQPr1q3DkSNHbH5PcTRt2hTR0dHo2rUr/v77b5vfN3v2bCxbtgxLly7F3r17ce/ePaxfv55/3Wg04tixY+jRo4fkfT169MD+/fuLPe+BAwfQo0cP6bVcpgeQdRSVyubziwOysrJQtWpVxMTE4PHHHy+iepTEO++8g7///hvr16/H9u3bsWvXLhw7dox//fLly7h586ak7/7+/ujYsWOJfc/LyyuiCgUGBmLv3r2S5y5cuIBKlSohLi4Ow4YNQ0pKis19lxOxjUMjyqFz585UkXEBfhbVfStUqKCIRS60jowT0BwZ12FtgvVUcuTNmzeRlpbmmQ+3keeeew5ffPEFdu3ahc6dOwNgw0qDBg1C5cqV8fbbb/PHvvbaa9i2bRt+/vln+Pu2LHIuW+y8Zs0a6HQ6LFmyhB/Ili9fjoiICOzatavIpF8czZo1w9ChQzFp0iT89ddfxR7Xtm1b6HTS+64HDx5Ar9cjOjoaixYtQvPmzZGXl4fvvvsOXbt2xa5du5CQkFBqH+bOnYv33nsPTzzxBABWSfnjjz/41+/evQuTyVREQo+KisLNmzdRHDdv3kRUVJT0WvaLAkgBygfdBVAZderUwYoVK9CwYUM8fPgQX331Fdq1a4dTp06VGhrLysrC0qVLsWrVKnTv3h0AsHLlSsTECFtNcP2z1ndroUiOnj174ssvv0RCQgKqV6+Ov/76C7///jtMJhN/TKtWrbBq1SrUqlULt27dwrRp09C2bVskJSXxybbuQjzBtmqdgICAACRdZh+HBNJEX7nw8xUrMn6KSPQFqCPjFDcyqCLjKqwrBe7vBwCPJDDa+5l16tRB27ZtsWzZMnTu3BmXLl3CP//8g+3bt8NkMmHGjBn46aefkJaWhry8POTl5SE4ONhhOx87dgwXL15EaGio5Pnc3FxcunTJrr5PmzYNdevWxfbt24sdGH/66SfUrVtX8hwXOqpduzZq1xZuudu0aYPU1FTMmjWrVEfmwYMHSE9PR5s2bfjnfHx80KJFC4m6BRQtr0AIKfVulGEYaf5G4TmjyrLva926NVq3bs2/3K5dOzRr1gzz5s3D//73vxLPfenSJRiNRknfIyMjJbZwtO9fffUVxowZgzp16oBhGFSvXh2jR4/G8uXL+WN69+7Ntxs2bIg2bdqgevXqWLlyJSZMmFBi3+VGrMjkFzDIyQOuFPqYdavS0hhyYZmLpIT8GIA6Mk7BKTIRIUBoEP2hyEmAldCSpxJ9jx496pkPtpPnn38er776KhYsWIDly5ejatWq6Nq1K7744gvMmTMHc+fORcOGDREcHIzx48fDaDQiwMruy5XLswO/5USeny9kBJvNZjRv3hyrV68u8n578ySqV6+OMWPGYNKkSVi6dKnVY2JjY1GjRg2bz9m6dWt8//33dvWjOMqVKwe9Xl9Efbl9+3aJA3nFihVx8+ZNVGwsejL/NsD4oFqsdcVCp9OhZcuWuHDhQqn9svz7FNcHgFVmoqOjbe57+fLl8dtvvyE3NxcZGRmoVKkSJk2ahLi4uGLfExwcjIYNG9rUd7kRKzJGE3DhOu8zok5Vt3dHs0hzZJTjyNAcGQcxm4GbhTkyVI2RH2s5MpXKUmexJIYOHQq9Xo8ffvgBK1euxOjRo8EwDP755x/0798fI0aMQOPGjREfH89PNpZ29vVhC+KVL18e6enp/PMXLlxAdnY2/7hZs2a4cOECKlSogBo1akj+hYdb8Y5KYfLkyTh//jzWrFnj2Je34MSJE5KJuzjCw8MRHR3NL+UGgIKCAkmeiZ+fH5o3b44///xT8t4///wTbdu2Lfbcbdq0wZ9//ilVvTL/BEJaILaClQscrHNy8uRJm/peo0YN+Pr6SvqemZkpWQUWFxeHihUrSvpuNBqxe/fuEvvOERAQgMqVK6OgoADr1q1D//79iz02Ly8PZ8+etanvciO2sTGfQbJoMVmdKnTckAvp/mx+inFkqCLjILczgXwT+wOhjoz8WA150KXXJRISEoInn3wS77//Ph48eIBRo0YBYCe8devWYf/+/ShTpgy+/PJL3Lx5E3Xr1i1iZy6hukuXLpg/fz5at24Ns9mMd999V7JK6Omnn8YXX3yB/v37Y+rUqYiJicG1a9fw66+/4p133pHkadhCVFQUJkyYgC+++MLq6xkZGUUUkYiICAQEBGDu3LmoVq0a6tevD6PRiO+//x7r1q3DunXrbPrsN954AzNmzEDNmjVRt25dfPnll5Id7gFgwoQJeOaZZ9CiRQu0adMGixYtwrVr1yR1cN577z2kpaVh1apVAIAXX3wR8+fPxw+LJgDZLwAPDwC3lgF1VvN5SJ988glat26NmjVr4uHDh/jf//6HkydPYsGCBaX2OyQkBM8//zzeeecdlC1bFlFRUfjggw8kuUQMw2D8+PGYPn06atasiZo1a2L69OkICgrCU089xR83cuRIVK5cGZ9//jkA4NChQ0hLS0OTJk2QlpaGKVOmwGw2Y+LEifx73n77bfTt2xdVqlTB7du3MW3aNDx8+BDPPvusTXaXE31hTSRC2NDSOYkj4/buaBbLCsrUkVE5qXeENnVk5EdJOTJq4vnnn8fSpUvRo0cPVKnCjuAfffQRLl++jJ49eyIoKAhjx47FgAED8ODBgyJ25ibY2bNnY/To0UhISEClSpXw1VdfSVSKoKAg7NmzB++++y4GDRqER48eoXLlyujatev/t3fncVHV6wPHPwQKCAouiIClgOJaoVIuKbghSineQLRcElPsZ9fliqbZ4nLF3NOyxUShjEwFF0xM3FC4aqVppnZz44oiuKBgrAMz5/cHl6MjYEiD43if9+vFqznfM+ecZ76NM898t0OdOlW76djUqVP57LPPyl0MrrwF/9atW8eQIUPQaDRMmTKFtLQ0rK2tadOmDdu3b8ff379S1w0LCyM9PZ2RI0fyxBNPMGrUKP72t7+RnZ2tPmfw4MFkZmYyZ84c0tPTadu2LfHx8TRpcqffIj09XW9dGVdXV+Lj4xkV+g84+ynUdAb3ZdAgUE3Ks7KyCA0NJSMjAzs7O9q1a8eBAwd4/vnnKxX7okWLyMnJYcCAAdSuXZuwsDC9uAHeeust8vPzGTduHLdu3aJjx44kJCTojW9KTU3VS4AKCgp49913uXDhAra2tvj7+7N27Vrs7e3V51y+fJlXXnmFGzdu4ODgQKdOnTh8+LBenTwsJWsiKRRoShZ31GuRka4lg7n7Hnils5YeBWZKZTpaRRkb9+kInlnyOHyMGTOGS/OlIV24ouA+RP+t+dtaM1o2kXo2pH5TdXz/w53tQB+I+af0OI8cOZKsrKwya+lURcKPCn5T9N/LZ6LNaP5k9byXu3fvjqenJ8uWLauW8z+q7PrpuJ0L7k5F1LGtwbGzJS01uTvN5N5hBjLqn5lE7vrvujG/eLNjwyzsXHrR3sO492eTT6wqKr3rNUiLTHWQrqWH4956llYvw6toTSRhWKXv5cIiM36/VPLYzUlugGpIenVpVpPs4qfoMk6hTj+F9yJ0RotLupaqSLqWqte9s5Zq15KZYdWhbNeSYerY1ta2wn07duygW7duBrmOKcRS855P2To2YFuJ93JqaiqtW7eucP/p06fV7kNxZ2pw+k1ztP/9TpXxMYZlVVO/aykls2SMjKYIGtgZ7/NZEpkquiQtMtWqzBes/IKtFvcmjIZq9Tp+/HiF+1xcHu7qZFWJ5d7bPfwVVX0vOzs73zd2Z2fncssTExMrd4HHTGnCqNXd+UKV8TGGZXlPInPy4p0fCZ3bGCGg/5JEporu7lpqLF0eBndvc7x0K1WPe+vZUAnjg6z5Ut2MHUuZOq5k952FhYXRYzcl5XVHt5IxdQZlZXmnPmvbNeDQqZJtq5rgabh7tD4wGSNTRaUtMg3rSh9sdbD473TKUjKmoHqUGSMjCaPB3du1JHVcPWqWk8hI15Jh3d21ZFO3BReulDz2agk1a8hgX5NSVKxwJbPk8VPSrVQtSqZT3tmWQajVo6Lp18JwqqvVS+grr0WmhSQyBmVjfScrL7Z9QX3cxYjdSiCJTJVcuXFn+evGkshUm7vHb8iv2Oqhd9dgGVBdLaprQLXQd2+LTMO6UK+O1LUh2dW2Vh/nWnRQH3dua9x6Nlgio9FomD17Nv7+/vj4+BAaGsq5c+fU/VFRUfTu3ZuePXuyfPlyvfuEnDp1ildeeYUXXniB0NBQvaXRCwoKeO+99/D29ubFF1/k+++/N1TIVSYDfR+Ou79kpWupety9wJW0elWPe79gpdWretybMEq3kuHdXcf5mjsbxhzoCwZMZLRaLS4uLkRGRrJ37168vb0JCwsDIDk5mZiYGKKiotiwYQPJycnExcUBJQnQW2+9xZAhQ9i7dy9t27bl/fffV8+7cuVKsrOziY+PZ968ecyfP/++t59/GNIz7zx+UloKqo10LVW/u+tYvmCrh8zAezjuTRglkTG88tZEcnMGx3rGbZEx2Kwla2trRo8erW4PHjyY5cuXk5WVRXx8PEFBQer9V4YNG8aOHTsICAjg6NGjWFtbqzcjGzNmDL179yY9PR0nJyfi4+NZsmQJtra2PPvss3h7e5OQkMCYMWPKjUOj0aDRaPRfpIUFNWuWf5O2qgj0gaztOo78mk7LZk7ojLcO0GPt7i8Ap/o6qedqoNbxiZ6kFT2LTvehUeN5HNUw199uVE9Bp5MF1Q3t3kHVLZ4quUu7MBwL87JlndtUbz3ffeuMilTb9OsTJ05Qr1497O3tSUlJ0bvviYeHh3pTtAsXLuhNMbS2tqZx48ZcuHABGxsbMjMz9fZ7eHhw6tSpCq8bGRnJqlWr9MoGDRpEcHCwoV6ays0JNLmXuJhr8FML4AmcgJqYmSkU5V7CyA1xj6zRo0dTUFDA119/XWbfzz//TFBQEHFxcbRt27bM/pw/bIGSJoIa5oUPrbVz2bJlfPTRR7zyyiuEh4er5adPn+all17iwIEDNG7cmMuXL+Pt7V3uOWJjY2nXrh2HDx/WuwFiqV27duHu7m6wmNeuXcuqVau4du0aHh4evPvuu/e9J9K1a9cIDw/n5MmTkPIfcB4P7h+iyb2o917esWMHH374IampqTz11FOEhYXh5+dnsLgVRWH58uV8++23ZGdn4+npyezZs/Hw8KjwmKKiIj777DM2bdpERkYGbm5uTJs2DR8fH73nPWidVKdiTQPARt2ua3mVixfL3rdLVF3WTStA/0aRHk6ZXLyYU23XdHV1/dPnVEsik5OTw7x58xg3bhwAeXl5eqtr2tjYkJeXB0B+fj42NjZ6x9vY2JCfn09eXh7m5uZYWVmVe2x5QkJCGDp0qF6ZoVtkoCQDvXTpEk8++WSlMkbx4F7uDh98Db7t8nFzlXquyJtvvklQUBBAmRv2hYeH4+npyYsvvljusU3uukl1fbuaD+2Gf6V3rt64cSPvv/+++qV669YtoGShuiZNmqhj6RISEmjTRr8jvn79+tSoUYOUlBQAfvvtN70bVjo4OGBuXs5PyCpYv349c+fOZcWKFbzwwgt88cUXvP7665w8ebLC1XUVRaFp06a8/PLLjBq/HAVoYKfg0exOHR86dIgJEyYwZ84cBg4cyJYtWxg/fjwHDhygY8eOBol94cKFREZGsmbNGjw8PAgPDyckJITffvtN78aRd5s+fTobNmxg5cqVtGzZkp07d/J///d/JCcn065duyrXSXWqa6+/7f2cI02cHnoYj7VL2WXLXupWnyZNjNxfqhhYQUGBEhoaqixdulQtGzJkiJKUlKRunz59WvH19VUURVG+/vprZdq0aXrnCA4OVpKTk5Xs7GylQ4cOSn5+vrpv7dq1yvTp0w0d9gPTarXKhQsXFK1Wa+xQHmtnUrXKuXNSz/dTVFSkODo6KrNmzdIrz83NVWrXrq3MmjVLGTJkiOLi4qJYW1srbdu2Vb755htFURTl1m2d4hmiVawbdlNCx05QjwWUzZs3653Pzs5OiYyMVLcvX76sBAcHK/b29kq9evWUAQMGKCkpKZWKeebMmcqzzz6r+Pr6KoMGDVLLjx07pgDqeVJSUhRAOXbsWIXn2rdvnwIot27dqtS171VcXKz84x//UOzs7JR69eopU6dOVUaMGKEEBASoz3n++eeVN954Q++4li1bVvqzqJajj4LzBKXnRP33cXBwsNK3b1+9Mj8/P2XIkCGVOm9OTo4yfPhwxcbGRmnUqJGyePFixcfHR5k4caKiKIqi0+mURo0aKfPnz1ePKSgoUOzs7JTPP/+8wvM6OTkpK1as0CsLCAhQhg4dqm7/1ToxtFEfaBW6lfxZ9dIqxcU6o8TxOPvxtE6tY7ppFZs+WqWoyPj1bNCfuMXFxcyYMQMHBwcmTZqklru6uurNYDpz5gxubm4AuLm56e3Lz8/n8uXLuLm5UadOHerXr1/hseLx5+4Cxm6I8Rqjo3Hgw/3zGlP5PmcLCwtGjBhBVFSU3mzAjRs3otFoGD16NB06dOC7777j5MmThIaGMnz4cH744Qfsa5txZBU846rByrLydZKXl0ePHj2wtbXlwIEDJCcnY2trS9++fcuMUbuf+fPnExsby08//VT5i1egXbt2ODk50atXL/bt21fp45YsWcKaNWtYvXo1ycnJ3Lx5k82bN6v7NRoNR48epU+fPnrH9enTh4MHD1bqGq2awDNuhXw6Wb/80KFDZc7r5+dX6fNOnTqVffv2sXnzZhISEkhMTOTo0aPq/pSUFDIyMvSuYWlpiY+Pz32vUVhYqNcSDiXd/snJyYBh6sTQ7h6I2uJJMDeXqdeGdu+A6udbgoWF8evZoF1L4eHhFBYWsmDBAszuWpbV39+fBQsW4Ovri6WlJdHR0Wr3T4cOHcjPz2fbtm34+fmxevVqWrdujZOTk3psREQE4eHhXLhwgQMHDhj0PihC/JmMm5B2/c+fZ0yjRo1i0aJFJCYm0qNHDwDWrFnDyy+/jIuLC1OmTFGfO378eL7//ns2btxIx44d9VZQrqxvv/2WJ554goiICPXfemRkJPb29iQmJpb5gqtI+/btCQ4OZvr06ezZs6fC53Xp0qVM12J2djbm5uY4OTnxxRdf0KFDBwoLC1m7di29evUiMTGxwvE1d1u2bBlvv/02gYGBAHz++efs3LlT3X/jxg20Wi2OjvpjAxwdHcnIyKjU67S1BlfXQpo31i/PyMio8nlzcnJYvXo1X331Fb6+vgB8+eWX6qSK0vOXnvPea9xvPJSfnx9Lly7F29sbd3d39uzZw9atW9FqtYBh6sTQ7h7sKwvhVY97Z+B1KTvszigMlsikp6ezbds2LC0t1Q9SgI8++oiuXbty9uxZRowYgU6nY+DAgQwYMACAmjVrsnDhQv75z38yf/58WrduzZw5c9Tjx44dy9y5c+nbty916tRh+vTpNG3a1FBhC/GnGtV79K/ZsmVLunTpwpo1a+jRowfnz58nKSmJhIQEtFot8+fPZ/369aSlpVFYWEhhYWGZsWkP4ujRo5w7d67MGIuCggLOnz//QOeaO3curVq1IiEhgYYNy1+Yaf369bRq1UqvrHT8S4sWLWjRooVa3rlzZy5dusTixYv/NJHJzs4mPT2dzp07q2UWFhZ4eXnptW4Bej/OoGQMzL1lVVHV854/fx6NRqMXe7169fTqoqrXWL58OWPGjKFly5aYmZnh7u5OSEgIkZGRBom9OtzdWiBTr6vHvYmMsRfCK2WwRMbJyYkjR45UuD8kJISQkJBy97Vp04Zvv/223H1WVlbMnTvXIDEKURVHVpnGIOPXX3+dv//973zyySdERkbSpEkTevXqxaJFi/jwww9ZtmwZTz/9NDY2NkyaNOm+XUBmZmZlvsiLiorUxzqdjg4dOhAdHV3mWAeHB1tcyd3dnTFjxjB9+nRWr15d7nOefPLJB7qBYqdOncqdxVUVDRo0wNzcvExLw7Vr18q0SDyoRo0aVfm89/7/qej8UNIyU9rKXZlrODg4sGXLFgoKCsjMzMTZ2Znp06erM0iqs06q6u6VwKVFpnrc27XUqbVx4riXaXxCCyH+VHBwMObm5nzzzTd8+eWXhISEYGZmRlJSEgEBAQwbNoxnn30WNzc3zp49e99zOTg46K2wffbsWb3Zgu3bt+fs2bM0bNiQZs2a6f3Z2dk9cOzvv/8+Z86cqfAHzYM6duyY3hd3Rezs7HBycuLw4cNqWXFxsd44k5o1a9KhQwd27dqld+yuXbvo0qXLX4qzc+fOZc6bkJBQqfM2a9aMGjVq6MV+69Ytzpw5o267urrSqFEjvWtoNBr2799fqWtYWVnh4uJCcXExsbGx6npf1VknVdX3eTNqWEC92lr6PGeUEB57d7fItHgS6ts9Zi0yQgjjsrW1ZfDgwcyYMYPs7GxGjhwJlHzhxcbGcvDgQerWrcvSpUvJyMgo01Vzt549e7JixQo6deqETqdj2rRp1Khx51Ns6NChLFq0iICAAObMmUPjxo1JTU1l06ZNTJ06VW+cRmU4OjoyefJkFi1aVO7+zMzMMr/+S6dwL1u2jKZNm9KmTRs0Gg1ff/01sbGxxMbGVuraEydOZP78+TRv3pxWrVqxdOlSsrKy9J4zefJkhg8fjpeXF507d+aLL74gNTWVN954Q33O22+/TVpaGl999ZVadvz4caBkPMvNmzc5fvw4VlZWtG7dWr22t7c3CxYsICAggK1bt7J79251UO392Nra8vrrrzN16lTq16+Po6Mj77zzjt5YIjMzMyZNmsS8efNo3rw5zZs3Z968edSqVUtv7Z0RI0bg4uLCBx98AMAPP/xAWloanp6epKWlMWvWLHQ6HW+99dYD1cnD1OVpM1I3Kty6kUa9OtIkUx3q20GbpnDqP/Cqr7GjuYvxJkyZNpl+/XBIPT+YgwcPKoDSp08ftSwzM1MJCAhQbG1tlYYNGyrvvvuu3vRirVardOzYUZkw4c7067S0NKVPnz6KjY2N0rx5cyU+Pr7M9Ov09HRlxIgRSoMGDRRLS0vFzc1NGTNmjJKdnf2ncZZOv77b7du3lQYNGpQ7/bq8v3Xr1imKoigLFixQ3N3dFSsrK6Vu3bpK165dle3bt1e6zoqKipSJEycqderUUezt7ZXJkyeXmX6tKIryySefKE2aNFFq1qyptG/fXtm/f7/e/tdee03x8fHRKysv7iZNmug9Z+PGjUqLFi2UGjVqKC1btlRiY2MrHfsff/yhDBs2TKlVq5bi6OioLFy4UG/6taKUTMGeOXOm0qhRI8XS0lLx9vZWfv31V73z+Pj4KK+99pq6nZiYqLRq1UqxtLRU6tevrwwfPlxJS0src/0/q5OHTT4vql/2H1pl8+7Likbz6NSxmaJUoqNVlKHT6bh48SJNmjSRhdqqkdRz9ZM6LmvkyJFkZWWxZcsWg5zvYdZx9+7d8fT0ZNmyZdV6nUeRvJer36NYx49GFEIIIYQQVSCJjBDC4GxtbSv8S0pK+p+N5UGkpqbeN/bU1FRjhyjEI0EG+wohDK50kGt5XFxcHl4gVC2WR2HRTWdn5/vG7uzsXG55YmJi9QQkxCNKEhkhhME9yJov1e1RiuVBWFhYmGzsQjxM0rUkhBBCCJMliYwQQgghTJYkMkIIIYQwWZLICCGEEMJkSSIjhBBCCJMliYwQQgghTJYkMkIIIYQwWZLICCGEEMJkSSIjhBBCCJMliYwQQgghTJaZoiiKsYMQQgghhKgKaZERQgghhMmSREYIIYQQJksSGSGEEEKYLElkhBBCCGGyJJERQgghhMmSREYIIYQQJksSGSGEEEKYLElkhBBCCGGyJJERQgghhMmSREYIIYQQJksSmUq6desWEydO5IUXXuDll1/mxx9/BKCgoIDw8HB8fX3p06cPa9euNXKkpmnlypUMGjSI5557jp07d+rti4qKonfv3vTs2ZPly5cjd9Wouorq+eeff2bMmDF07dqV8ePHGzFC01dRHW/bto1XX30Vb29vAgICiImJMWKUpq+iek5MTCQwMBAfHx/8/PxYunQpWq3WiJGarvt9LgMUFxczePBgAgMDjRDdHZLIVNKCBQtwcHBgz549TJgwgenTp3P79m1Wr17NlStX2Lx5M1999RWbNm3i0KFDxg7X5Dz55JOEhYXRpk0bvfLk5GRiYmKIiopiw4YNJCcnExcXZ6QoTV9F9WxlZUVgYCAjR440TmCPkYrqWKPR8Pbbb7N3716WLl3KF198wc8//2ykKE1fRfXcunVrIiIi2L9/Pxs3buTcuXNs3rzZSFGatorquNSGDRuwtbV9yFGVJYlMJeTl5bF//37eeOMNrKys6N69O+7u7hw4cIBDhw7x6quvYmtrS6NGjRgwYADbt283dsgmx9/fn06dOlGzZk298vj4eIKCgmjcuDENGjRg2LBh7Nixw0hRmr6K6rl169b07dsXR0dHI0X2+KiojgMDA3n66aexsLDA3d2d559/ntOnTxspStNXUT03bNiQunXr6pWlpaU9zNAeGxXVMUBmZiabN28mJCTECJHpk0SmElJTU7G1taVBgwZqWfPmzblw4QKAXleHoihqufjrUlJSaNasmbrt4eEh9StMnlar5dSpU7i5uRk7lMfS8ePH8fHxoWfPnpw7d46AgABjh/TY+fjjjwkJCcHKysrYoUgiUxn5+fnY2NjoldnY2JCfn0+nTp1Yt24df/zxB1euXOG7776joKDASJE+fvLy8vSaLm1sbMjLyzNiREL8dZ999hkODg507tzZ2KE8ljw9Pdm/fz9bt24lMDCQ2rVrGzukx8qJEydITU2lX79+xg4FkESmUqytrcnNzdUry83Nxdramtdffx1nZ2eCgoKYMGECvXr1wsHBwUiRPn5q1apFTk6Oup2bm0utWrWMGJEQf01MTAx79+5l4cKFmJmZGTucx5qLiwvu7u4sWbLE2KE8NnQ6HYsXLyYsLOyRef9KIlMJTz31FDk5Ody4cUMtO3v2LG5ublhbW/POO++wc+dOYmJiMDMzo3Xr1kaM9vHi6urKuXPn1O0zZ85Ic7wwWQkJCURGRrJixQrs7e2NHc7/BEVRuHz5srHDeGzk5uby73//m8mTJ+Pn58dbb73F5cuX8fPzM1pvhCQylVCrVi28vb1ZuXIlBQUF7N+/n/Pnz+Pt7c3Vq1e5ceMGWq2Ww4cPq1MsxYMpLi6msLAQRVHUxzqdDn9/f2JjY0lLS+PGjRtER0c/Ms2ZpqiietbpdBQWFlJcXKz3WDy4iur48OHDLFq0iGXLluHs7GzsME1eRfW8e/duMjIyALh06RJRUVF4eXkZOVrTVF4d16pVi/j4eKKjo4mOjubdd9/F2dmZ6OhoLC0tjRKnmSKLclTKrVu3mDlzJkePHsXR0ZFp06bRsWNHjhw5wsyZM8nKyqJp06ZMmTKFdu3aGTtckzNr1iy+++47vbLPP/8cLy8vIiMj+frrr9HpdAwcOJAJEyY8Mk2apqaiegZ444039MpfeuklZs2a9bBCe2xUVMerVq3i+PHjejNA+vXrx4wZMx52iI+Fiur5xIkTxMTEcPv2bezs7Ojduzfjxo0z2pesKbvf53KpI0eO8MEHHxAbG/uww1NJIiOEEEIIkyVdS0IIIYQwWZLICCGEEMJkSSIjhBBCCJMliYwQQgghTJYkMkIIIYQwWZLICCGEEMJkSSIjhBBCCJMliYwQQghhojQaDbNnz8bf3x8fHx9CQ0P1busSFRVF79696dmzJ8uXL6d06bji4mKmTp1Kv3798PLy0rsFD0BaWhpvvvkm3bt3p1+/fkRGRlYYw5UrV/Dy8iqzuGNgYCBHjhwx4KstnyQyQogHduTIEby8vPDy8uLKlSvGDkeI/1larRYXFxciIyPZu3cv3t7ehIWFAZCcnExMTAxRUVFs2LCB5ORk4uLi1GPbt2/PwoULyz3vokWLcHFxYffu3URERLB+/Xp+/PHHCuMwNzfn0KFDpKSkGPYFVoIkMkIIPf3791eTlIr+oqOjadu2LW3bttVbct+YJLkS/4usra0ZPXo0jo6OmJubM3jwYK5cuUJWVhbx8fEEBQXRuHFjGjRowLBhw9ixYwcAFhYWvPLKKzz99NPlnjc9PZ0+ffpgYWGBi4sLnp6eXLhwocI4zM3NCQoKIiIiotz9BQUFfPDBB/j5+fHiiy+yevVqFEWhoKAAHx8f0tPT1ef+8MMPBAcHV7oOJJERQuhp0aKFmqQ0bNhQLffw8FDLfXx8iIqKIioqigYNGhgxWiHE3U6cOEG9evWwt7cnJSWFZs2aqfs8PDzum4zcbdCgQezcuRONRkNqaiq//vrrn958c9iwYfzrX//iP//5T5l9ERERpKamsnHjRiIiIti+fTs7duzAysqKrl27snv3bvW5u3fvpk+fPpV7wYBFpZ8phPifsHjxYvXxypUrWbVqlVpeetfm0tYPgLi4OJydndUbzDk5OTF27Fg+++wzcnJyGDBgAG+++SaffPIJcXFx1K5dm5EjRxIUFKRe5/r163z66accOnSIrKwsHB0d6d+/PyNHjsTCouRj6tdff+XTTz/lzJkz5OXlUbduXVq0aEFYWBjbt29X4wQYMGAAcOfGl2vXrmXHjh1kZGSQm5tLnTp18PT05O9//ztNmjQBYNu2bcyePRuA+fPns2bNGi5evEiHDh2YPXs2iYmJREREUFBQgK+vL1OmTFFjK62LSZMmcfr0aZKSkrCysiIwMJCxY8fKTU7FQ5GTk8O8efMYN24cAHl5edja2qr7bWxsyMvLq9S5nn32WWJiYujWrRtarZbQ0FC9pKg8dnZ2DBo0iIiICObOnau3b9euXcyaNYs6depQp04dhg4dys6dO/H398fX15c1a9YwfPhwiouL2bdvH6tXr67065YWGSGEQd24cYP58+dTo0YNcnNzWbduHcOHDycuLg5bW1syMjJYuHCh2peelZXFyJEj2bZtG/n5+bi6upKRkcHnn39OeHg4ADqdjkmTJvHTTz9hYWGBq6srRUVFJCUlkZGRgaOjI66urmoMpa1HjRs3BuDo0aNcunSJ+vXr07RpU27fvs2+ffsYN24chYWFZV7DzJkz0Wg0aDQaDh48SGhoKAsWLMDS0pLs7GxiYmLYunVrmeM+/fRTjh07Ru3atbl165Y6tkCI6lZYWEhYWBhdu3YlICAAgFq1apGTk6M+Jzc3l1q1av3pubRaLRMnTmTgwIH861//Ii4ujt27d6utJsHBwXTr1o1u3bqRkZGhd+zQoUNJTk4u0ypz/fp1GjVqpG47OTlx/fp1ALp06UJqaipXrlzhp59+omHDhuoPjMqQREYIYVBFRUWsWLGCTZs24ejoCMClS5dYt24dMTExWFpaotPpOHr0KAAbNmzg6tWr1K9fny1btrBu3ToWLFgAwHfffcelS5e4ffs22dnZAERGRvLNN9+wa9cu1q9fj5ubGwMHDmTatGlqDIsXLyYqKorRo0cDMH78ePbt28fGjRtZv349H330EQBXr17ll19+KfMaRo0aRUxMDH379gUgJSWFmTNnsmnTJjw9PQHKnY3Rpk0btm3bRlxcHO3atVPjFaI6FRcXM2PGDBwcHJg0aZJa7urqqjeD6cyZM7i5uf3p+W7fvs3169cJCgrCwsICZ2dnunfvrvdvNikpiaSkJL3kBMDe3p6goKAyLSoODg56SU9GRgYODg4A1KxZEx8fH3bv3s2uXbseqFsJJJERQhhYabfNE088oX7Iubu74+zsjLW1NXXr1gXg5s2bAJw6dQqAzMxMfH198fLyYsqUKQAoisLJkyext7fnmWeeASAoKIjBgwczY8YMfv/9d+zt7f80poyMDMaOHYuPjw/PPfccb775prqv9Ffh3by9vYGSX42lunXrBoCLi4te/Hfr1asXFhYWWFhY0KtXL/V13bp1609jFKKqwsPDKSwsZNasWXrdmP7+/sTGxpKWlsaNGzeIjo6mX79+6n6NRqO2SBYVFamP69ati6OjI1u2bEGn03H16lX279+Pu7t7peIZNmwYSUlJelO6e/XqxapVq/jjjz/IyMggOjpaL2Hx9fXl+++/Z//+/fTu3fuBXr+MkRFCGJSNjY362NzcvExZ6Qdt6XoWpf+1sbHR6x4qZWVlBZR023z//ff88ssvpKSksGfPHhISErhx4wYjRoyoMJ7Lly8zZcoUioqKsLGxoVWrVhQXF3PmzBmgpNuqotdQGj+gjjW4N34hjCk9PZ1t27ZhaWlJjx491PKPPvqIrl27cvbsWUaMGIFOp2PgwIHq+DEoWeeldLZQ//79gTstjQsWLGDJkiV8/PHHWFlZ0adPH/72t79VKiZ7e3sCAwP58ssv1bLQ0FCWLFlCYGAgNWrUYODAgXpJVadOnZg5cyYuLi5ql3BlSSIjhDCqNm3acPDgQczNzZk3b546oDg3N5d9+/bRo0cPFEXhxIkT9O/fn4EDBwIwZ84c4uLiOHbsGCNGjFATHoD8/Hz18e+//05RUREAH3/8Mc888ww7d+7knXfeMfhr2bNnjzqIee/evQDUr19fbYUSwtCcnJzuu+hcSEgIISEh5e7btm1bhce1adOGNWvWVCoGZ2dnDh48qFc2fvx4xo8fr25bWVnxzjvvVPjvzsLCgj179lTqemWOrdJRQghhIMHBwWzdupVr164RGBiIq6srubm5XL16leLiYl566SW0Wi3jxo3DxsYGR0dHzMzM1MHCpTMpGjdujIWFBcXFxYwbNw4nJyeGDRtGs2bNMDc3R6vVMn78eBo1akRmZma1vJZ///vf9O/fHzMzM65duwbAa6+9Vi3XEkKUkDEyQgijqlu3LpGRkfTv3x87OzvOnz9PYWEh7dq1Y/LkyUBJF09gYCDOzs5cu3aNy5cv4+TkxPDhwxkzZgxQ0pw9ZcoUHB0duXnzJidPniQzM5OmTZvy3nvv4eLiQnFxMfb29upsKEMbN24cXl5e5OTkYGdnx6hRoxgyZEi1XEsIUcJMkY5eIYT4S0rXkZk5c6Y61kAI8XBIi4wQQgghTJYkMkIIIYQwWdK1JIQQQgiTJS0yQgghhDBZksgIIYQQwmRJIiOEEEIIkyWJjBBCCCFMliQyQgghhDBZksgIIYQQwmRJIiOEEEIIkyWJjBBCCCFM1v8DqPcFX3a4OdMAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def compute_residuals(forecasts, metric=metrics.ic):\n", + " residuals = cp_model.residuals(\n", + " series=ts_energy_val,\n", + " historical_forecasts=forecasts,\n", + " last_points_only=True,\n", + " metric=metric,\n", + " metric_kwargs={\"q_interval\": cp_model.q_interval},\n", + " )\n", + " return residuals\n", + "\n", + "coverage = compute_residuals(cp_hist_fc, metric=metrics.iw)\n", + "coverage[:end_ts].plot()" + ] + }, + { + "cell_type": "markdown", + "id": "1d59cf90-73f9-4661-8177-b31940d087d5", + "metadata": {}, + "source": [ + "Very nice to see increasing intervals for increasing forecast horizon (model was trained to predict 24 steps, we also use a stride of 24) -> thats why we see these ramps" + ] + }, + { + "cell_type": "markdown", + "id": "a7acf71f-de84-47e7-9295-4790a06e3588", + "metadata": {}, + "source": [ + "### What's the coverage over time?" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "bc4f6fa7-45cb-4b1c-9ec6-769253bafe60", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "coverage = compute_residuals(cp_hist_fc, metric=metrics.ic)\n", + "coverage.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "3c845961-d07f-45f3-9a22-aa4dedf32b82", + "metadata": {}, + "source": [ + "# Not very informative, how about a windowed aggregation?" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "29409d44-e5bd-484c-8ec6-54e61bcc6535", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "coverage.window_transform(transforms={\"function\": \"mean\", \"mode\": \"rolling\", \"window\": 2*7*24}).plot()" + ] + }, + { + "cell_type": "markdown", + "id": "2f794816-60da-4b43-8c15-39dc4c7af75d", + "metadata": {}, + "source": [ + "Not too bad. What about an expanding calibration length?" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "ee3e7121-7091-42fa-a595-22f49384bff1", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2ec12472a3f24df29ec9a18e40d86dad", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "historical forecasts: 0%| | 0/1 [00:00" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cp_model = ConformalNaiveModel(model=model, quantiles=quantiles, cal_length=None)\n", + "\n", + "cp_hist_fc = cp_model.historical_forecasts(\n", + " series=ts_energy_val,\n", + " forecast_horizon=horizon,\n", + " stride=horizon,\n", + " last_points_only=False,\n", + " retrain=False,\n", + " verbose=True,\n", + " **pred_params\n", + ")\n", + "cp_hist_fc = concatenate(cp_hist_fc)\n", + "print(compute_backtest(cp_hist_fc))\n", + "coverage = compute_residuals(cp_hist_fc, metric=metrics.ic)\n", + "coverage.window_transform(transforms={\"function\": \"mean\", \"mode\": \"rolling\", \"window\": 2*7*24}).plot()" + ] + }, + { + "cell_type": "markdown", + "id": "d6067bce-628e-44af-b9b5-7463597d5aac", + "metadata": {}, + "source": [ + "Okay we're getting closer. Also, interesting to see the coverage drop for the smaller interval, but not for the large one." + ] + }, + { + "cell_type": "markdown", + "id": "795afb75-e70e-4a58-aa28-500279d221fe", + "metadata": {}, + "source": [ + "### Improving the underlying forecasting model\n", + "Let's add the day of the week to our forecasting model, see if it gets more accuracte, and what the influence is on our conformal model. This is because the calibration set is expanding, and our calibration cannot react to distribution shifts quickly." + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "19e9ca2b-b4e2-4c09-8a88-b084a92b0712", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "957bf3a80e324e7cb06f43ff73d2b082", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "historical forecasts: 0%| | 0/1 [00:00" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "input_length = 24\n", + "horizon = 24\n", + "\n", + "model = LinearRegressionModel(\n", + " lags=input_length, \n", + " lags_future_covariates=(input_length, horizon), \n", + " output_chunk_length=horizon,\n", + " add_encoders={\"cyclic\": {\"future\": [\"dayofweek\"]}}\n", + ")\n", + "model.fit(ts_energy_train)\n", + "hist_fc = model.historical_forecasts(\n", + " series=ts_energy_val,\n", + " forecast_horizon=horizon,\n", + " stride=horizon,\n", + " last_points_only=False,\n", + " retrain=False,\n", + " verbose=True,\n", + ")\n", + "hist_fc = concatenate(hist_fc)\n", + "print(metrics.mae(ts_energy_val, hist_fc))\n", + "\n", + "fig, ax = plt.subplots(figsize=(12, 6))\n", + "end_ts = ts_energy_val.start_time() + 2 * 7 * horizon * ts_energy_val.freq\n", + "ts_energy_val[:end_ts].plot()\n", + "hist_fc[:end_ts].plot()" + ] + }, + { + "cell_type": "markdown", + "id": "cd75baab-45b5-4314-bc7f-cbc4a0934e25", + "metadata": {}, + "source": [ + "Forecast error is lower with the new model. And the conformal model?" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "0a297b7e-36be-4da7-96a1-3c37561b7e57", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "544d62d2555b422a90b6743a59554577", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "historical forecasts: 0%| | 0/1 [00:00" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cp_model = ConformalNaiveModel(model=model, quantiles=quantiles, cal_length=None)\n", + "\n", + "cp_hist_fc = cp_model.historical_forecasts(\n", + " series=ts_energy_val,\n", + " forecast_horizon=horizon,\n", + " stride=horizon,\n", + " last_points_only=False,\n", + " retrain=False,\n", + " verbose=True,\n", + " **pred_params\n", + ")\n", + "cp_hist_fc = concatenate(cp_hist_fc)\n", + "print(compute_backtest(cp_hist_fc))\n", + "coverage = compute_residuals(cp_hist_fc, metric=metrics.ic)\n", + "coverage.window_transform(transforms={\"function\": \"mean\", \"mode\": \"rolling\", \"window\": 2*7*24}).plot()" + ] + }, + { + "cell_type": "markdown", + "id": "b221557f-f4ee-4488-b137-b43743546f00", + "metadata": {}, + "source": [ + "Lower interval widths shile almost having the same coverage, nice. ...WIP" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "000eae68dd4a48de9de0019ae7bf5734": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_e59c7f2a15014da59c6781ccac26a36e", + "IPY_MODEL_2befe7be21cb42fb8e8fa564346c22b6", + "IPY_MODEL_2bb628242e764232a5d4d973d2917588" + ], + "layout": "IPY_MODEL_ed806c4e08384cd09eca536a92ea4055" + } + }, + "01d5e57d11024dfb84fd6e6aff24894e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "01f0742d352a4dc69ef1a8988c73e5ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "01f17d372087468dbfba867b610db337": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_eebe728bdc824b8d83d3e73653063c3e", + "max": 1, + "style": "IPY_MODEL_e255bc9adb1f45c7bb3b7beb958eeee2", + "value": 1 + } + }, + "0240077fbccd479aa50f3edbe55ed78a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "0306df6cb7d84b69a900b096325e3c58": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "03bbceffa51b42b29f29f18b33b7cf9b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "040491ab03ac47229a116a53e99975a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_c338c2806f9b4c59be2cf11be848b737", + "IPY_MODEL_aa0c0897f1254968927e8c44c28045e4", + "IPY_MODEL_732d6aecb5e9436cae6b7d11e74e73f0" + ], + "layout": "IPY_MODEL_3477381b8f9f4d3fbb29eb28db3da885" + } + }, + "040ccd63278c4421b91fd587727168f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0421915453f14d8c96a2b86cb33e62c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "043cfd8c94c743939207ce6de3310b1a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "046f29bba4e140f09f33b6014c0bd0b6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "047eceaff8694fa392bff90945d70257": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_6035f11ae5f84cf6bec60ad9c1073262", + "style": "IPY_MODEL_dd92365d08204e5686869c4a807533f9", + "value": " 1/1 [00:00<00:00, 20.37it/s]" + } + }, + "04d59a50ffe04b85b80598c7e2b57135": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_ba9168075b7748cc862a53aac42fa94f", + "style": "IPY_MODEL_f368bd9c4a154647a9e8f94071f07a5c", + "value": "historical forecasts: 100%" + } + }, + "04df748240d64691b812efcacc96ff0c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_cd062bb62bc44b029b0b7f537c9e80bb", + "max": 1, + "style": "IPY_MODEL_9cfda695597845b98cc6a3aa522ac996", + "value": 1 + } + }, + "059de4716a1f45ac8dbc46b096ec4750": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_bee653ba243f4978a1c04d238eab8fa7", + "max": 1, + "style": "IPY_MODEL_64927e6d576b492a8bad3b99be3f6cb8", + "value": 1 + } + }, + "05bb1d7bfdf3415481e9f1df4224ed37": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_e4970bf9dbe540a1bb723533bb4845a3", + "max": 1, + "style": "IPY_MODEL_845fde0f6aaf414c971753e986df164d", + "value": 1 + } + }, + "05c74684fefd4feead8200aa3279d44a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "06ffd0eb0e3e43b6b58b37772a97005e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "076c5f1e4f374f02b0d4bc2a896ebc9b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "07c8b47b400d4bb0bf49660ef67030e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "08847aa1cf33464bae2d031792a32afd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0a57142b423e4d9a9522d1d4b015200f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "0a7929a3761943cdb0b6f76a1378a770": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0b440daae6124fc48d2943d66d5c1fed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "0bd92d81827341b7b61071fde691c1ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0c612d221a5e47ae820dc01623277090": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "0c63269791d74b169276650cd0f77c8c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_368b744a3b8343529f719a299a599d26", + "IPY_MODEL_c19cfd2aecdb448682d202167cdd5c24", + "IPY_MODEL_899e5f3019db40c6a916e4fd2ebbc167" + ], + "layout": "IPY_MODEL_7535919f0fe44867b3f88f6950a0e02c" + } + }, + "0c8ceabd9a0b467cb5a4089ceae0d539": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0d87a7f460e340d0919d70f295333b5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_06ffd0eb0e3e43b6b58b37772a97005e", + "style": "IPY_MODEL_2326fdd999cb4ad8b83dd69ee34fc422", + "value": "conformal forecasts: 100%" + } + }, + "0dab5325b93647bb8e3bfa4c49e19f64": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "0dad4efb53224d3d97bd90b95382b769": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "0e0af2ade6094764bc916676e1af5e80": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0e197b702eaf48ab92dfee241fc2b8c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_1a2c5914783e4a11aefaf46f3618bacb", + "style": "IPY_MODEL_f811d597cb524f47ba9f0360f16017f5", + "value": " 83/83 [00:00<00:00, 1011.93it/s]" + } + }, + "0e31654f8c764ac78b4052e6cee6215f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_9f760a7781994e3a9b5f5139a3649e7f", + "style": "IPY_MODEL_53213e54fc374ad78d07a29042fdd915", + "value": "conformal forecasts: 100%" + } + }, + "0e6a1e32b9644a5a8bba1bdc128db7fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_795a16731e3d43c9ae2e0a747cc7c0f3", + "IPY_MODEL_bc86551b3d85486881de18be47d5af76", + "IPY_MODEL_b2f28eacf0d64fd2971d1828b894b301" + ], + "layout": "IPY_MODEL_7250965f21ae43a69a1d98ca58567e2a" + } + }, + "0f451514f3bf4d7c99e96765097e6ac9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "10494a41766f4ce68ca53cf723e1aa86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_7a099adc59f5476b8c0cc7a262b0de60", + "style": "IPY_MODEL_74bf110923b0411f9c0334f73351f811", + "value": " 83/83 [00:00<00:00, 2198.37it/s]" + } + }, + "10593fd6999c4ee49af36a48808a7c3f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_bfc521d8860f4ddb8a4af396e4c77eac", + "style": "IPY_MODEL_a8103984268d48c4bf00bcdd5fd3e9d0", + "value": " 1/1 [00:00<00:00,  1.66it/s]" + } + }, + "109a2735813c4372b555b09378ea30df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "10eebeb049d447fe94271b11d718c427": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_9515d34e06034b68b022512acfe4fd3c", + "IPY_MODEL_ebdfe712edde49789dd7d52f0befe396", + "IPY_MODEL_a2287fe10489492dabad7e1452191210" + ], + "layout": "IPY_MODEL_623b3074379244328182141e5fa74e34" + } + }, + "1196b368df1f479390e20b63d8931d66": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_cb8ce9f130714ae8991950d01a06563c", + "style": "IPY_MODEL_5897c039193a40cd931eb499778b03e9", + "value": "historical forecasts: 100%" + } + }, + "1198e4c854054721a80343ce90dc9f13": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "124f380daa3949669ac7a1f287bdd4d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_d47d46397ae3483fa9b7513524cd9c26", + "max": 1, + "style": "IPY_MODEL_0b440daae6124fc48d2943d66d5c1fed", + "value": 1 + } + }, + "12a3d12426384d6f92e3d41f284512a7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "12ee64ee1422425abe1989cb3805f13b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "1379a78defaa4a3490d97bcdb3dad9c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_04d59a50ffe04b85b80598c7e2b57135", + "IPY_MODEL_2c14965e02e84b8f8b5ce1ebf0db3829", + "IPY_MODEL_047eceaff8694fa392bff90945d70257" + ], + "layout": "IPY_MODEL_b744fe458c384f20b529bd35ad049379" + } + }, + "141204ffe29e4aecb7fd9bf6fc38defd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "14658617a4924363897e3308e532d1d0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "1502d0c150ac4cbf8c4a5cbfc5ac6498": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_3ea83c4bb2114bf2b3e894aaf526396f", + "style": "IPY_MODEL_3e633b73496748a2929afe11951e7d23", + "value": "historical forecasts: 100%" + } + }, + "153a0a6dd62b432aa5934b7ed69540b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "1613368a8a32450683b6764795d2d82a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "1659698c03d04d9490cfeeaf8230ca46": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_a6a3a9736ddb4f0686cb3e03f367cd70", + "max": 83, + "style": "IPY_MODEL_8c96e5f964f84fa28ddc6baa1aa6e5b0", + "value": 83 + } + }, + "16ad072807e04d9889b1d02f6ae7cc61": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "173133b58e6d418fa0e1ef54b1812baf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "17fb8acd00c045949dadf73f4945716d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "18ef9f7b83f647dfa9a466df55454b61": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "19493d5de029407bbb41c52af930e5ae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "19e131628522434aa1b582521619b899": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "1a2c5914783e4a11aefaf46f3618bacb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "1a3540097a8d4b55b591f60e0a2ebae6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "1ae34bb8d5cc4cfcbdd34df3ee303a99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "1b0c9c892ac04932ad13ca8476a311a1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "1ba3db9ff95d4fb9aa934eaf9185a014": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "1bf4f18f6f724dffac72495bd9bc9770": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "1c23955e971c44789df8e177e26d958f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "1d755a09f64143f592d192a739b489bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1e7de43343e4481ea039fa9f4acfb319": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_f53cad6f60b247f1be1de43552d434e0", + "IPY_MODEL_1659698c03d04d9490cfeeaf8230ca46", + "IPY_MODEL_274ef89082c3493e9ce402612873abcc" + ], + "layout": "IPY_MODEL_6fda16224e8448fcb99eb62bf8ad44f0" + } + }, + "1eed59df3b1f4a4cb7e84e590f255c16": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "1f594807859c463bab1926755138fd37": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_1ba3db9ff95d4fb9aa934eaf9185a014", + "max": 1, + "style": "IPY_MODEL_7d330695d1b446d8a84cb59c3532df6f", + "value": 1 + } + }, + "1f748aec2d6643d9bc218a12c1a40ca3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_f213ff856269417595488428ff121a7d", + "max": 83, + "style": "IPY_MODEL_0f451514f3bf4d7c99e96765097e6ac9", + "value": 83 + } + }, + "1fe635120d3f46a8837df02c0a213a62": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "2035ee22bc854ef4b4750d7ae9673c66": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_a9327c21915540fa880fd9301c940154", + "IPY_MODEL_4f1aec86643b4fdf965cb1842095b9dc", + "IPY_MODEL_6d87f3b130034941b50f65ad8880b9ca" + ], + "layout": "IPY_MODEL_de74f152deac4e9b971c16da1a037230" + } + }, + "2046a0b74b96401ea580af6919e3196f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "20641e1e311b44ba8bf413a659980bff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_f6824305140b41f99cc8154b960f4756", + "style": "IPY_MODEL_6dbf6aa796b64a2eb21e15c6e4a4612b", + "value": "historical forecasts: 100%" + } + }, + "211294bbf7b14ddea19697e702febdee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "212b9c00c3344080af23937485f3df0e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "219600708b874d5bbca0d74c0af559a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_1613368a8a32450683b6764795d2d82a", + "max": 1, + "style": "IPY_MODEL_7441cbc2533b4f15bbeb2781ffc022ad", + "value": 1 + } + }, + "22518f27f5c74454b6c67d4654bddaab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_27c5cc8b1437495e854a130839625469", + "style": "IPY_MODEL_2e61715974b24b20b2760e2b1096d50f", + "value": "historical forecasts: 100%" + } + }, + "22739443669f4b8aaa9b97fb6464a66a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2276400232ec423a89585db4b7d35528": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "230a646d8ba545e884a3de401d1e877b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2326fdd999cb4ad8b83dd69ee34fc422": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "235eaf7f33b54235bcaa7b816d06231b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "23b66ce21def4202b81cd71184794d66": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "23da17d76627430ea96fdd8c29c54d0f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "23f1daafe1af4de7b075602a3d5a0a09": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "24038457afab4ecea846ed35d003885f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "24b1c032ac794a688ca4276964462482": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_2b97e20265f34b398fe405653fbaf081", + "IPY_MODEL_d50293e756534cafb0685cb12f0828be", + "IPY_MODEL_f26b7671b02748218c0b7744f5c1e9e4" + ], + "layout": "IPY_MODEL_b11aa1aa2cf6498b9b06060603da02e8" + } + }, + "250785cc51164f87a82343860a229f05": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_19493d5de029407bbb41c52af930e5ae", + "max": 1, + "style": "IPY_MODEL_cb7adc044ead45179cfb2f1949b5a3d2", + "value": 1 + } + }, + "25355f22e2c842d7a429abecea14e204": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "2560238b81d34069b1aca0f34618c838": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "257c42d542c74462885387125e64c0ff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "25f34c9a655e4d2c8062d3802ce5e1f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "261f9b19a1d24e3d8ff1b1675bcd68a0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "270f4ebb672a466fb6d8ae14fed37bec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_63e2a552172340c0ac090f009cb3d638", + "IPY_MODEL_ea0100ef3d834ff3bd144727fbfbed00", + "IPY_MODEL_5dd608e79c98467a87ee0709981ee3fe" + ], + "layout": "IPY_MODEL_796fd5ff8ff24089809d8be1746a0806" + } + }, + "274ef89082c3493e9ce402612873abcc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_6905754d916346a0a8c7433065b5fc0b", + "style": "IPY_MODEL_9bb7c28f043843a5b99e16371c4839d8", + "value": " 83/83 [00:00<00:00, 2343.45it/s]" + } + }, + "27c5cc8b1437495e854a130839625469": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "292cb8e0ed0a4439b9137748d6918dd9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "2a6e83d3c47c4ee9a7d7e487f3ecbcce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_b1f95aa0033d4ae8ac59b609d3411603", + "IPY_MODEL_059de4716a1f45ac8dbc46b096ec4750", + "IPY_MODEL_6fc0fd0ad9844b489bb70f73397f0b17" + ], + "layout": "IPY_MODEL_b9b393b01a0d44ad8d930360b1fc271f" + } + }, + "2ae871fd255b4838bec89c213decbb42": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_53d1140e674d4a38b7de1f783fd19547", + "style": "IPY_MODEL_dc23ee0d3935449c9af3f760e62a9f4f", + "value": " 1/1 [00:00<00:00,  1.55it/s]" + } + }, + "2b1d91c674694226bc54f51a7aa100f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_0240077fbccd479aa50f3edbe55ed78a", + "max": 83, + "style": "IPY_MODEL_faa70ef2bf3143b391c8772f732b850f", + "value": 83 + } + }, + "2b97e20265f34b398fe405653fbaf081": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_c8731dbdce1e488aa822f99b115447b0", + "style": "IPY_MODEL_d3dc2db6215a4091bcbde9ee6b600679", + "value": "conformal forecasts: 100%" + } + }, + "2bb628242e764232a5d4d973d2917588": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_3ec928e2915245728d9a25f44e9469ad", + "style": "IPY_MODEL_84709d2adb67470a83cda9886910bb0a", + "value": " 1/1 [00:00<00:00, 18.88it/s]" + } + }, + "2befe7be21cb42fb8e8fa564346c22b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_ae432b41f0364812ba8adedf7c83ee83", + "max": 1, + "style": "IPY_MODEL_dbd653a803a3401b8fea29371d2dde11", + "value": 1 + } + }, + "2c0015847be14191b060e16b67806be0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_75f77ea66cf446b9807943b97aabffb3", + "IPY_MODEL_34493bfc92ba4c6f8c63b9c744dfe94f", + "IPY_MODEL_2ae871fd255b4838bec89c213decbb42" + ], + "layout": "IPY_MODEL_c9b8bff68668414e86c1bd4b02efc80d" + } + }, + "2c14965e02e84b8f8b5ce1ebf0db3829": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_82affe409ce84ba78bbddd55bbe38780", + "max": 1, + "style": "IPY_MODEL_a962a7ed08bf40938edd9e40b3ac9fd7", + "value": 1 + } + }, + "2cb324ef035d4c5d83a3631da5fb5d9d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "2cd25b364fb544e5ab1a22ad45a0d049": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_8215748aa4004ba2872b47e2228d8d11", + "style": "IPY_MODEL_0c8ceabd9a0b467cb5a4089ceae0d539", + "value": " 1/1 [00:00<00:00,  1.18it/s]" + } + }, + "2d337bf0c89243b7ba20f61106f3230c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "2d649a44f76a4611a3ed2c7dd32ef8f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2d85df4a054b4ff5b603d374049e666d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2deb970d485a4da680cc308119207024": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2e61715974b24b20b2760e2b1096d50f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2ec12472a3f24df29ec9a18e40d86dad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_33876a7eefa64245b1e4ef0f0681c725", + "IPY_MODEL_462fa37a482442d8b1267bd69416fbaf", + "IPY_MODEL_ee46c46710634a5685104c15de0c964f" + ], + "layout": "IPY_MODEL_1b0c9c892ac04932ad13ca8476a311a1" + } + }, + "2ed16635c1524403af097afdc06c7996": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2f287b35ac2446cfb9a6f6bb4deeb12a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "2f4bffd21f934bb0b8d2e0d999f57340": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "2f5b115cbfa147ad92ca2734feb947b3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "301c290b5980464394dfc90b36d62850": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "305e929eac2e4f3f9a6e8e7533b8ce71": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "30adc481cd3b4756a5c1ba7ed3e12960": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_6bc055499c8d44eaa998484b874265b4", + "style": "IPY_MODEL_8d21d5cbb1f844109553e732e4d0d2ee", + "value": " 1/1 [00:00<00:00, 22.98it/s]" + } + }, + "311f5c64eb3d4283b948e0ad7252e7bc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "322f0f9516f8408dbcc3e99fbe3da110": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "326836d4a47a4de9bb61bae9cda583bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "32ab3a13da6149ba8c500e680932f880": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "32bc6b70169643b5a0e2507bfbdb31ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_a7f79f22f8b1404d9e74ca8a18ba78ed", + "max": 90, + "style": "IPY_MODEL_6090139006db4d7084a9075257ca4766", + "value": 90 + } + }, + "32e69ae21de84b95b493a8bc78074c57": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_c49c04387eb542a89828fe439d796972", + "max": 1, + "style": "IPY_MODEL_211294bbf7b14ddea19697e702febdee", + "value": 1 + } + }, + "33876a7eefa64245b1e4ef0f0681c725": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_14658617a4924363897e3308e532d1d0", + "style": "IPY_MODEL_b1f6895c944e46af81fae5303d8ce45a", + "value": "historical forecasts: 100%" + } + }, + "33907617ee4941f494cb94741e4d6f99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "34493bfc92ba4c6f8c63b9c744dfe94f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_5d0e73b96ceb4190b1ec9a4c1977cc9c", + "max": 1, + "style": "IPY_MODEL_b752afd9189244fbaf2ec82d757076dc", + "value": 1 + } + }, + "3477381b8f9f4d3fbb29eb28db3da885": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "34c1994eb7c24ec2913cc52b3176129d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_fcc152f4e20b4f73b1bb5a77576981ef", + "style": "IPY_MODEL_c0ac6b3f6e9a45d78e48d4d8c0b6445a", + "value": " 90/90 [00:00<00:00, 1569.13it/s]" + } + }, + "3512e1c0bbc44af19e5b444331605abe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_f8b53993f91344a8b886fdc375a4a735", + "max": 83, + "style": "IPY_MODEL_fd964e19deb345ddaad2e933436fa26f", + "value": 83 + } + }, + "3601d652dd854e709addd69a199be5a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "368b744a3b8343529f719a299a599d26": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_aaacb910c5164088884c07409b51c89a", + "style": "IPY_MODEL_07c8b47b400d4bb0bf49660ef67030e3", + "value": "historical forecasts: 100%" + } + }, + "36f02e5e15a24438ae05dd9140ba939b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "379bf7e41dfd497da9a40b3acaaf5737": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_b0f6b402165849a3b966321b698572d3", + "max": 1, + "style": "IPY_MODEL_17fb8acd00c045949dadf73f4945716d", + "value": 1 + } + }, + "37b1858f5ffa41ad9b5eb8b4f9e64092": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "37c96fba45e6423c948ac7529447ad66": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_305e929eac2e4f3f9a6e8e7533b8ce71", + "style": "IPY_MODEL_0bd92d81827341b7b61071fde691c1ec", + "value": " 1/1 [00:00<00:00, 23.37it/s]" + } + }, + "3bcbe2a9faf149d085a2fbaca0a7751a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_8dd1cc54fc2941059cd6b903fe43aad6", + "IPY_MODEL_fd53235aadcb460e8833a5db5881e1fa", + "IPY_MODEL_91d36af966e543968a2cc9560215c61b" + ], + "layout": "IPY_MODEL_2f5b115cbfa147ad92ca2734feb947b3" + } + }, + "3c5759cde1b64149b0d9b7d56c86d793": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3c9e0cf48e054f4fbbbc5247ff0c3639": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3cfb7897b42b465ea0988fb553e0a33d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_292cb8e0ed0a4439b9137748d6918dd9", + "style": "IPY_MODEL_91bbd89729f14e00bb2d5efb1661e958", + "value": " 1/1 [00:00<00:00,  1.66it/s]" + } + }, + "3e065117698d4aeaa591cc86a053ef90": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "3e0ad78978d641cead7a3d5cec0b806f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_ccc1b69935ba4b0885aa0ed7aec51478", + "style": "IPY_MODEL_7781b195d2ef48619537ff65c73d9e7f", + "value": " 1/1 [00:00<00:00,  1.63it/s]" + } + }, + "3e633b73496748a2929afe11951e7d23": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3e919c8f0f774d069b98b346a3b358ea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "3ea83c4bb2114bf2b3e894aaf526396f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "3ec928e2915245728d9a25f44e9469ad": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "3f02cc78934e4373afc3826c24c274b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_19e131628522434aa1b582521619b899", + "style": "IPY_MODEL_efebc254756c4ce78f387ab227e7b8b4", + "value": "conformal forecasts: 100%" + } + }, + "3f242fc075dc4411875f05c60d1e0ed1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "3fb431fd7f0a42afb89b4b612ad4284f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "40ff67a292944c4180f383705a6451fe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "414a39bb1bed486186b0f468cede8872": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "41fe671c972044a898d41d7ec53e4319": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "4206d5b6d7fb4b1182b0d2e26500153e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_0306df6cb7d84b69a900b096325e3c58", + "max": 83, + "style": "IPY_MODEL_b99336648ff64c27972a10828806758c", + "value": 83 + } + }, + "4325a523e06c471cb7b250b2188bce7e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_ebbd993a55504c4099e1c386119933b5", + "max": 1, + "style": "IPY_MODEL_afaabeefd0024f3fb85c4dfb4b44bc89", + "value": 1 + } + }, + "432a73bb9dc54a01b2ad97cfbba08421": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "437e70bdf4c546de8be110f2d75ce345": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "44d7cf0fea2a40b295cd216b84c4cafd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "44fbf9f904d846788c28443dca138b67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_8b1e97708b2948688b721438d4fa6fb5", + "IPY_MODEL_e031820d407d499ea2405ce253fc057f", + "IPY_MODEL_9e1f438a9019494f9c2dd373035124f3" + ], + "layout": "IPY_MODEL_b0288164929046f3b8b6db935d05af29" + } + }, + "4525b5e09cfd49bda31ba97ad829afb1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "45262e41a91c407c8c570f6871eab490": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "46139ccb65664027b96b01562fc5c349": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "462fa37a482442d8b1267bd69416fbaf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_5e101868de1046b8b62381adb3c3dfbc", + "max": 1, + "style": "IPY_MODEL_bfad31e3f8b44cbe84f9e22cef8f16d5", + "value": 1 + } + }, + "4694711f2b354a7ab34d1c57214ef250": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_840526fab74640ad9fb903b7eaff6628", + "max": 90, + "style": "IPY_MODEL_a9b5007ef99242ca8fe3ba02f732dca0", + "value": 90 + } + }, + "472f3d1718d74e7caa9e10091678d596": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_52251431d1864acda4a6e2f4f473a57e", + "style": "IPY_MODEL_ffbaf5a647c64b3eb80fc6fd53b729db", + "value": "historical forecasts: 100%" + } + }, + "476c01e6ec4b44e8a93209f0f00bba59": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "4a7db6f8a70d46d8b9191bf0a803b983": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_043cfd8c94c743939207ce6de3310b1a", + "max": 1, + "style": "IPY_MODEL_4be8f2787cdc48e1bbe8da79b36ca600", + "value": 1 + } + }, + "4ae5477607814e759a563de4b1331600": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "4ba07ab9e8574ac59d960d91db2ea913": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "4bd616ad7e314fd2ac8dbb4d7b2ae09e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_1fe635120d3f46a8837df02c0a213a62", + "style": "IPY_MODEL_e296745a4b7e4ac4a1c13c202fa7f5da", + "value": "conformal forecasts: 100%" + } + }, + "4be8f2787cdc48e1bbe8da79b36ca600": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "4c2bc5a5590c4e2bb2ab52e990d1bf99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "4cca89ba9f2c43fd8111d045791363fb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "4e28e97800ae432fa2d6b03a8ee8d595": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "4f0523494f124771979bf2a5827e05ab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "4f1aec86643b4fdf965cb1842095b9dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_5f7e1456e0444578bdd9a07111080d3f", + "max": 83, + "style": "IPY_MODEL_d54fb00e03764a48b3566a1268fb47c5", + "value": 83 + } + }, + "4f573d1f19e54eea82824dbdddb30f64": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_b9756643d3b049bcb9412b2098dd94ce", + "max": 83, + "style": "IPY_MODEL_87b0d0c627c842c9a5aedcfa2681c869", + "value": 83 + } + }, + "4fa4679a9a1c47e9a854241b579d4b91": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "4fbf852739d646889fe2262b0aeb72c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "50568d5ef90946f68f676e0fd4cdd682": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "5088008902e84fbfb8f6d37b4c2cbdd9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "508a4417af3a47a699908a2490599606": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "513d435a3d45489d828109795204dce8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_cb5e336c581c4689a13f94570be87e9b", + "style": "IPY_MODEL_631dbb196b294e878c24421efdffcda0", + "value": "conformal forecasts: 100%" + } + }, + "52251431d1864acda4a6e2f4f473a57e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "525c3f5999a3415d8f93036f993a3e47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5289dd553cf944dd92b8bd9144884ce0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "53213e54fc374ad78d07a29042fdd915": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "53d1140e674d4a38b7de1f783fd19547": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "53e25a3cd02a4692991d103f05b9a83b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_e5e4088f450b469dbf5f68c83e4b533a", + "IPY_MODEL_b9b7f924a5bc4866a48329163128da5c", + "IPY_MODEL_f69eb4bb0a8249d0b6e21ea39430534e" + ], + "layout": "IPY_MODEL_05c74684fefd4feead8200aa3279d44a" + } + }, + "54022decbd5f4ef6938f066cbe40b1fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "54210ce290fd41e0b926777e99db6ad4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "544d62d2555b422a90b6743a59554577": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_57b0ac8c8fc64b9cbd829bd4743d6603", + "IPY_MODEL_4325a523e06c471cb7b250b2188bce7e", + "IPY_MODEL_10593fd6999c4ee49af36a48808a7c3f" + ], + "layout": "IPY_MODEL_a3dd8f7a6639424da780a4145c719a0b" + } + }, + "54b1a444e38e434ba761b494f87f9ee2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "55ba47206b5245ada90924272ce3e811": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_bcbe92d4a6a44d79b4611b0bbbd09201", + "IPY_MODEL_32bc6b70169643b5a0e2507bfbdb31ce", + "IPY_MODEL_34c1994eb7c24ec2913cc52b3176129d" + ], + "layout": "IPY_MODEL_d6607d1a2f1a4c7189d088e42030b8fb" + } + }, + "565326362f7b45dfa8b2baf217fcd3b7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "56a0609fde2e4d9581e3082ea60031d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_e1637d15aec14d1aacf6d22613784ae0", + "IPY_MODEL_250785cc51164f87a82343860a229f05", + "IPY_MODEL_6babfb5b36d1493f91ef984478a73ea8" + ], + "layout": "IPY_MODEL_9de09ecfb8014c6da02f689efa1387ee" + } + }, + "56eea1d0dd824d4eb6cc9a7d15b8e6b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "57b0ac8c8fc64b9cbd829bd4743d6603": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_b5720bcdfff54d14bcc822cfda5be8bc", + "style": "IPY_MODEL_2ed16635c1524403af097afdc06c7996", + "value": "historical forecasts: 100%" + } + }, + "5897c039193a40cd931eb499778b03e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5925fe560d2948c38ba3e3b9f6c15af3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "5b1c2a7907f34ac9ae2f7c4485156a1b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "5b4d64f43263413ba2c79548dbb37f01": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5d0e73b96ceb4190b1ec9a4c1977cc9c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "5d7ae906654d4f6dae1bb9e77e3829f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5dd608e79c98467a87ee0709981ee3fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_40ff67a292944c4180f383705a6451fe", + "style": "IPY_MODEL_0e0af2ade6094764bc916676e1af5e80", + "value": " 1/1 [00:00<00:00,  1.63it/s]" + } + }, + "5e101868de1046b8b62381adb3c3dfbc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "5e180f874b2a4f93b8f7c31b21ae9eb1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5f16a9df375d4159abbaaeaf59159ca7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "5f77b26770a2405bb251b70ff69b1cd7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_212b9c00c3344080af23937485f3df0e", + "max": 1, + "style": "IPY_MODEL_141204ffe29e4aecb7fd9bf6fc38defd", + "value": 1 + } + }, + "5f7e1456e0444578bdd9a07111080d3f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "6035f11ae5f84cf6bec60ad9c1073262": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "6090139006db4d7084a9075257ca4766": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "612f3fadf8ca4dcea11971849451ccb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_841ab83792014d00b01434b3c79e3693", + "IPY_MODEL_04df748240d64691b812efcacc96ff0c", + "IPY_MODEL_d8535ee2a0244c61a3da7018918dcbee" + ], + "layout": "IPY_MODEL_3f242fc075dc4411875f05c60d1e0ed1" + } + }, + "61c97b7313e4447eaf89bdd81d6cb4d4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "623b3074379244328182141e5fa74e34": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "62d36383dc9c4c7cb8ca3d1819eb8d07": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "631dbb196b294e878c24421efdffcda0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6379bf0cc2ff4b46b753cfed14a79ef6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "63e2a552172340c0ac090f009cb3d638": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_23da17d76627430ea96fdd8c29c54d0f", + "style": "IPY_MODEL_898bb97a346543358e50d59e6c095602", + "value": "historical forecasts: 100%" + } + }, + "6483342185ae47b5bbea96cc595a5d0c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "64927e6d576b492a8bad3b99be3f6cb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "652bcd47f1164b6184b29ea04c8cd3a6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "6545d0e29edc41b6aa96c99a7a3758e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_61c97b7313e4447eaf89bdd81d6cb4d4", + "style": "IPY_MODEL_0a7929a3761943cdb0b6f76a1378a770", + "value": " 83/83 [00:00<00:00, 990.50it/s]" + } + }, + "670a5c507c29421b8a2c3bbdde9ce167": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "67af7d7a9139469c9db4fedc3703f0ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_f5df6035927f4bba8069fd186a551766", + "style": "IPY_MODEL_2d649a44f76a4611a3ed2c7dd32ef8f9", + "value": " 83/83 [00:00<00:00, 2400.98it/s]" + } + }, + "67ea3d7d6553408cb6afe960e6de69e8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "67f3053228884ef2a44a1d35896a1a8e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "68622042951c4ffd9a61517d04976b24": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "6905754d916346a0a8c7433065b5fc0b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "693df426b0d143f4b4aeee620952501d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "69ad518c8cd448d6a9dadf77f1373081": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6a157bebd1204d338bd847917da2f137": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "6babfb5b36d1493f91ef984478a73ea8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_7f37ab59131c4af498b9041538640106", + "style": "IPY_MODEL_56eea1d0dd824d4eb6cc9a7d15b8e6b0", + "value": " 1/1 [00:00<00:00, 20.76it/s]" + } + }, + "6bc055499c8d44eaa998484b874265b4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "6c1fd804027844888daa6a511581df36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_4f0523494f124771979bf2a5827e05ab", + "style": "IPY_MODEL_70114d35d5ce4f959da1d46de1010b4b", + "value": "conformal forecasts: 100%" + } + }, + "6c8a160968c34bd2a9bfc18c2d6ac10f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_d39a633ad0c942319077c077187c6e19", + "IPY_MODEL_a2cd5068203045c38dda1d8af182f54b", + "IPY_MODEL_37c96fba45e6423c948ac7529447ad66" + ], + "layout": "IPY_MODEL_df526894bdb2487fb057540ecb8225cf" + } + }, + "6d7b914053794b2abfef977380b970b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_20641e1e311b44ba8bf413a659980bff", + "IPY_MODEL_902e81612a4e40bbabe7b310578f812e", + "IPY_MODEL_eb143183e36f4f169215aac3028e0371" + ], + "layout": "IPY_MODEL_18ef9f7b83f647dfa9a466df55454b61" + } + }, + "6d87f3b130034941b50f65ad8880b9ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_d2776168f8064f4eb719b384021f6d4e", + "style": "IPY_MODEL_91a3a2a5e8424a2aa0cf6315550d848e", + "value": " 83/83 [00:00<00:00, 2204.98it/s]" + } + }, + "6d9af8c43625462abc2fd451f95fdf49": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_4bd616ad7e314fd2ac8dbb4d7b2ae09e", + "IPY_MODEL_fe87ea92075043068c113e956db6ba07", + "IPY_MODEL_bf7d1073aae5463f9dfd5c0d9988fdbf" + ], + "layout": "IPY_MODEL_a66de86cad5b449a909e3efbf4e8ed13" + } + }, + "6dbf6aa796b64a2eb21e15c6e4a4612b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6e93ce66abe24cdf8228d9d511c3a977": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "6f962983ef944dfca8f7c825f35f3dab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "6fc0fd0ad9844b489bb70f73397f0b17": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_7f88ac533c1d4a96b42591ae29ea04d7", + "style": "IPY_MODEL_735bc631b77d42a5922fd725d7a2762b", + "value": " 1/1 [00:00<00:00, 16.88it/s]" + } + }, + "6fda16224e8448fcb99eb62bf8ad44f0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "70114d35d5ce4f959da1d46de1010b4b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "709f6c77118e4e26bc7c4d017aceacb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_6c1fd804027844888daa6a511581df36", + "IPY_MODEL_ccf98993b99a46f58ffa5c94a6a7b5dd", + "IPY_MODEL_b22c7e7cdfa0482fa4ee1c48eab38229" + ], + "layout": "IPY_MODEL_89bd65761a6142899b2a1c281cd7e5ce" + } + }, + "70c5c9cb78ec4b31b44b4f3ba74bbcc1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_afd80a018d354240b3d4f95832c60ee9", + "max": 1, + "style": "IPY_MODEL_8b27fabded3e47cfb1d7d11fde136d01", + "value": 1 + } + }, + "70f1c6ff27bf40978710cc9466d1da4d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "7250965f21ae43a69a1d98ca58567e2a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "728ed0839786489ca6f92e73ada17589": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "729b953ed9e9446687261f2fb8486153": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_03bbceffa51b42b29f29f18b33b7cf9b", + "style": "IPY_MODEL_5b4d64f43263413ba2c79548dbb37f01", + "value": "conformal forecasts: 100%" + } + }, + "7320833d710048d8a51498937d2a147c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "732d6aecb5e9436cae6b7d11e74e73f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_98bb361809744bcab7585a5feeedf66f", + "style": "IPY_MODEL_8dbd230b8e6946f1bc3cc3d402155217", + "value": " 1/1 [00:00<00:00,  5.26it/s]" + } + }, + "73561c3527ae470b82ebab5e7d327177": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "735bc631b77d42a5922fd725d7a2762b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "73f352a5f24249b4a58229eee190878b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_a15bdbadf5de4764b2d0fd2434294ce1", + "style": "IPY_MODEL_7320833d710048d8a51498937d2a147c", + "value": "historical forecasts: 100%" + } + }, + "7403967ab01146d7a5e34beed855cd30": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_793cc64d66354b989931bfe354c99a1b", + "IPY_MODEL_1f748aec2d6643d9bc218a12c1a40ca3", + "IPY_MODEL_6545d0e29edc41b6aa96c99a7a3758e7" + ], + "layout": "IPY_MODEL_728ed0839786489ca6f92e73ada17589" + } + }, + "742bc4322c50468c83abad02ba4960ff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "7441cbc2533b4f15bbeb2781ffc022ad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "74775bb9d32f476abe383b6078555e7d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "74b75bd7fb934ead9aff9df5910e3ea0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_0d87a7f460e340d0919d70f295333b5f", + "IPY_MODEL_4f573d1f19e54eea82824dbdddb30f64", + "IPY_MODEL_764c69b6637c43378561b246d341a0c6" + ], + "layout": "IPY_MODEL_68622042951c4ffd9a61517d04976b24" + } + }, + "74bf110923b0411f9c0334f73351f811": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7535919f0fe44867b3f88f6950a0e02c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "7567f733a742484c840995ec070be624": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_d264237f2c674838a836964118610259", + "style": "IPY_MODEL_f1b240b33bab43baa8264d49f64a5228", + "value": " 1/1 [00:00<00:00, 18.66it/s]" + } + }, + "75e3b57272894a87be6bc335902681d9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "75f77ea66cf446b9807943b97aabffb3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_e7b71ab74d78424391a70f63d91c2f24", + "style": "IPY_MODEL_e48628240b6244259953b5e55a14d49e", + "value": "historical forecasts: 100%" + } + }, + "764c69b6637c43378561b246d341a0c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_bd91a1c604a6492da715f6f1a586fabb", + "style": "IPY_MODEL_a293c2b365144076875e6ee3f8e5d3eb", + "value": " 83/83 [00:00<00:00, 2344.91it/s]" + } + }, + "7699561eac114a9690c653859f16a854": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "7781b195d2ef48619537ff65c73d9e7f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "78c6148423dd4b349ef3a2ca3fc6aa8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_d8d062164169456889eb8bfacbfdd71a", + "IPY_MODEL_5f77b26770a2405bb251b70ff69b1cd7", + "IPY_MODEL_946da6d1818840a98776152dbd4287f9" + ], + "layout": "IPY_MODEL_301c290b5980464394dfc90b36d62850" + } + }, + "793cc64d66354b989931bfe354c99a1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_d83c06173bc04e019722046ef7f79ed7", + "style": "IPY_MODEL_46139ccb65664027b96b01562fc5c349", + "value": "conformal forecasts: 100%" + } + }, + "795a16731e3d43c9ae2e0a747cc7c0f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_9384a2180dcc4a1f91173ac25655e6b5", + "style": "IPY_MODEL_7975d48378094f068528fdc769aaef64", + "value": "historical forecasts: 100%" + } + }, + "796fd5ff8ff24089809d8be1746a0806": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "7975d48378094f068528fdc769aaef64": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7a099adc59f5476b8c0cc7a262b0de60": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "7a73d4da7a264f21ab453f714846e070": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_261f9b19a1d24e3d8ff1b1675bcd68a0", + "style": "IPY_MODEL_99f09b6a5e28462f85fb18cceeab9ae7", + "value": "historical forecasts: 100%" + } + }, + "7d330695d1b446d8a84cb59c3532df6f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "7e4d4bc33350416ba73dd248009df0ba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "7e9509e25dd442bc804c6c5233429f44": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "7f37ab59131c4af498b9041538640106": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "7f88ac533c1d4a96b42591ae29ea04d7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "7fa801a85335427aaf80f351fa36ceeb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_8bd46b7ca53441939a2d4b0228192d03", + "IPY_MODEL_05bb1d7bfdf3415481e9f1df4224ed37", + "IPY_MODEL_ba79b76577fa4acab6c23eec93294596" + ], + "layout": "IPY_MODEL_1bf4f18f6f724dffac72495bd9bc9770" + } + }, + "8030add04f054264bbc1a923f8d2dca8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "8215748aa4004ba2872b47e2228d8d11": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "82affe409ce84ba78bbddd55bbe38780": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "83369f3092dc485582a191ac1bac8b8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "83496947ae6443cba9788f8878b9a694": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_4cca89ba9f2c43fd8111d045791363fb", + "style": "IPY_MODEL_1d755a09f64143f592d192a739b489bb", + "value": " 1/1 [00:00<00:00, 24.72it/s]" + } + }, + "840526fab74640ad9fb903b7eaff6628": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "841ab83792014d00b01434b3c79e3693": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_3fb431fd7f0a42afb89b4b612ad4284f", + "style": "IPY_MODEL_2560238b81d34069b1aca0f34618c838", + "value": "historical forecasts: 100%" + } + }, + "845fde0f6aaf414c971753e986df164d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "84709d2adb67470a83cda9886910bb0a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "84713ec1aeaa46ca9ac78cd443a3d894": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "850bb57c7b4749de9facfe3ea3fe96ba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "860b3b5ee9ab4a0c8cf3abfd4c4e2855": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_437e70bdf4c546de8be110f2d75ce345", + "max": 90, + "style": "IPY_MODEL_9741f5b0fc444fc09cfa7e78e16ef321", + "value": 90 + } + }, + "87646aaecef0455db20f363d89052333": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_3f02cc78934e4373afc3826c24c274b3", + "IPY_MODEL_2b1d91c674694226bc54f51a7aa100f7", + "IPY_MODEL_f798c5364ee14f88a149aaef1f644d7b" + ], + "layout": "IPY_MODEL_2f287b35ac2446cfb9a6f6bb4deeb12a" + } + }, + "87b0d0c627c842c9a5aedcfa2681c869": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "898bb97a346543358e50d59e6c095602": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "899e5f3019db40c6a916e4fd2ebbc167": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_076c5f1e4f374f02b0d4bc2a896ebc9b", + "style": "IPY_MODEL_08847aa1cf33464bae2d031792a32afd", + "value": " 1/1 [00:00<00:00,  9.48it/s]" + } + }, + "89bd65761a6142899b2a1c281cd7e5ce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "8a11e7fac7914714baabd804abb353f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8b1e97708b2948688b721438d4fa6fb5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_eb657554be5c4c3abe749168b88d2c02", + "style": "IPY_MODEL_62d36383dc9c4c7cb8ca3d1819eb8d07", + "value": "historical forecasts: 100%" + } + }, + "8b27fabded3e47cfb1d7d11fde136d01": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "8b3f824fa5534af697e19ead204e023d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8b717975ac3e473bb9a1c13f129ecd47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_fa52ed03da0b45f497a2af01ae1d3949", + "IPY_MODEL_379bf7e41dfd497da9a40b3acaaf5737", + "IPY_MODEL_a6da7e9b85ec46cd8f2413244aafe861" + ], + "layout": "IPY_MODEL_ee40878b24224d7fb97734e9bae9db94" + } + }, + "8bd46b7ca53441939a2d4b0228192d03": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_9ceb5dbe6fe04e6dbd35da3b67bafbae", + "style": "IPY_MODEL_22739443669f4b8aaa9b97fb6464a66a", + "value": "historical forecasts: 100%" + } + }, + "8c96e5f964f84fa28ddc6baa1aa6e5b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "8d21d5cbb1f844109553e732e4d0d2ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8dbd230b8e6946f1bc3cc3d402155217": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8dd1cc54fc2941059cd6b903fe43aad6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_67ea3d7d6553408cb6afe960e6de69e8", + "style": "IPY_MODEL_54210ce290fd41e0b926777e99db6ad4", + "value": "conformal forecasts: 100%" + } + }, + "8e78016e2b8440dbae46714e4c9d4f6b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8ec4fb1806d64869801257a182c9e4b5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "902e81612a4e40bbabe7b310578f812e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_5f16a9df375d4159abbaaeaf59159ca7", + "max": 1, + "style": "IPY_MODEL_5289dd553cf944dd92b8bd9144884ce0", + "value": 1 + } + }, + "910d6de1b997490d806f1ebb239c7bb3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_98ab70a918fc41d2933875696b76e54d", + "IPY_MODEL_860b3b5ee9ab4a0c8cf3abfd4c4e2855", + "IPY_MODEL_fe11cb18fec149efbd505aba6eecf608" + ], + "layout": "IPY_MODEL_9ae66c6f9b48415ea8d62813fb3075d6" + } + }, + "917b0eca17b7420183c7c21c5d150ee0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "91a3a2a5e8424a2aa0cf6315550d848e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "91bbd89729f14e00bb2d5efb1661e958": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "91d36af966e543968a2cc9560215c61b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_2cb324ef035d4c5d83a3631da5fb5d9d", + "style": "IPY_MODEL_525c3f5999a3415d8f93036f993a3e47", + "value": " 83/83 [00:00<00:00, 2280.54it/s]" + } + }, + "91ed5710d5274e12bae407b8b5635135": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "92eda515424946559a80f6904bca9c0d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "9384a2180dcc4a1f91173ac25655e6b5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "946da6d1818840a98776152dbd4287f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_44d7cf0fea2a40b295cd216b84c4cafd", + "style": "IPY_MODEL_9938c360824449779f385657b5cf6782", + "value": " 1/1 [00:00<00:00, 21.47it/s]" + } + }, + "9515d34e06034b68b022512acfe4fd3c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_e653368295814c3c9d75fcbb64d6807a", + "style": "IPY_MODEL_2d85df4a054b4ff5b603d374049e666d", + "value": "historical forecasts: 100%" + } + }, + "955091278b384f15bd0f09df7b2fad90": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "957bf3a80e324e7cb06f43ff73d2b082": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_22518f27f5c74454b6c67d4654bddaab", + "IPY_MODEL_cbdc9496536042ce95524ba428356936", + "IPY_MODEL_7567f733a742484c840995ec070be624" + ], + "layout": "IPY_MODEL_8030add04f054264bbc1a923f8d2dca8" + } + }, + "96c6e9b9dcf1415dbfc7620ff9a244dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_1196b368df1f479390e20b63d8931d66", + "IPY_MODEL_32e69ae21de84b95b493a8bc78074c57", + "IPY_MODEL_3cfb7897b42b465ea0988fb553e0a33d" + ], + "layout": "IPY_MODEL_a7672520293b4d76b8b1af1803bcee3c" + } + }, + "9741f5b0fc444fc09cfa7e78e16ef321": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "97fde8c05aae43f19c8c10293bceccb5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_7a73d4da7a264f21ab453f714846e070", + "IPY_MODEL_01f17d372087468dbfba867b610db337", + "IPY_MODEL_b52d4d49f25a47a8a64269bdf02eee84" + ], + "layout": "IPY_MODEL_4c2bc5a5590c4e2bb2ab52e990d1bf99" + } + }, + "9860c4c09b1b4a1d97224884855b5121": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_e4484c147e9c414b9c65db55fd443fd0", + "IPY_MODEL_4206d5b6d7fb4b1182b0d2e26500153e", + "IPY_MODEL_10494a41766f4ce68ca53cf723e1aa86" + ], + "layout": "IPY_MODEL_dc5fcb67874041e993fc0aabb3e91fda" + } + }, + "98ab70a918fc41d2933875696b76e54d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_2046a0b74b96401ea580af6919e3196f", + "style": "IPY_MODEL_e1e1c8cbce574d3aa94a497409a83182", + "value": "conformal forecasts: 100%" + } + }, + "98bb361809744bcab7585a5feeedf66f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "9938c360824449779f385657b5cf6782": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "99f09b6a5e28462f85fb18cceeab9ae7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "9ae66c6f9b48415ea8d62813fb3075d6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "9b1cdee9eaab4d118dd6c531567ebd77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_45262e41a91c407c8c570f6871eab490", + "style": "IPY_MODEL_ae85c72d450e4f18a6ec84159bcb6fee", + "value": "historical forecasts: 100%" + } + }, + "9b7b8a83c663466db8f62694e1d700d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_8ec4fb1806d64869801257a182c9e4b5", + "style": "IPY_MODEL_1198e4c854054721a80343ce90dc9f13", + "value": " 1/1 [00:00<00:00,  1.56it/s]" + } + }, + "9bb7c28f043843a5b99e16371c4839d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "9c9ff8962659417b8adb0e202493c8a3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "9ceb5dbe6fe04e6dbd35da3b67bafbae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "9cfda695597845b98cc6a3aa522ac996": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "9d555c8eb2fd45be84a549d8113e0d33": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "9dd71a7b9b224b879309dc6157c2eac0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "9de09ecfb8014c6da02f689efa1387ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "9e1f438a9019494f9c2dd373035124f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_4ae5477607814e759a563de4b1331600", + "style": "IPY_MODEL_6379bf0cc2ff4b46b753cfed14a79ef6", + "value": " 1/1 [00:00<00:00,  1.66it/s]" + } + }, + "9f168bfac8494e21b1f4313873d4f21b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "9f760a7781994e3a9b5f5139a3649e7f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "a146177985ed494cb17ffd84fb84694f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_73f352a5f24249b4a58229eee190878b", + "IPY_MODEL_219600708b874d5bbca0d74c0af559a2", + "IPY_MODEL_dd73c82169344c49b5da881e77dd0b61" + ], + "layout": "IPY_MODEL_fcc82951e7914c43a2dd0eeb86217932" + } + }, + "a15790c4dec9419ca2660da05768820f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "a15bdbadf5de4764b2d0fd2434294ce1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "a2287fe10489492dabad7e1452191210": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_e7343679126049a6b9f1da6e4d7f23e8", + "style": "IPY_MODEL_8e78016e2b8440dbae46714e4c9d4f6b", + "value": " 1/1 [00:00<00:00,  1.38it/s]" + } + }, + "a293c2b365144076875e6ee3f8e5d3eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a2cd5068203045c38dda1d8af182f54b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_cda24b6b1f4b4b9894f0716fe889a811", + "max": 1, + "style": "IPY_MODEL_173133b58e6d418fa0e1ef54b1812baf", + "value": 1 + } + }, + "a3dd8f7a6639424da780a4145c719a0b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "a45d38c972a64d50b240149d27939337": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "a511c6d154114dc6b3663dffcc784cfa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "a62e54a301c04cbda985d5dd318f1f2d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "a66de86cad5b449a909e3efbf4e8ed13": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "a6a3a9736ddb4f0686cb3e03f367cd70": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "a6da7e9b85ec46cd8f2413244aafe861": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_5b1c2a7907f34ac9ae2f7c4485156a1b", + "style": "IPY_MODEL_040ccd63278c4421b91fd587727168f5", + "value": " 1/1 [00:00<00:00, 17.62it/s]" + } + }, + "a6fada1e0d11459c88db982a79eb6cdd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_2276400232ec423a89585db4b7d35528", + "max": 76, + "style": "IPY_MODEL_109a2735813c4372b555b09378ea30df", + "value": 76 + } + }, + "a7672520293b4d76b8b1af1803bcee3c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "a7f79f22f8b1404d9e74ca8a18ba78ed": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "a8103984268d48c4bf00bcdd5fd3e9d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a9327c21915540fa880fd9301c940154": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_cef7816bccc34465a7e7b7ec13f16c52", + "style": "IPY_MODEL_fa927bc8de7e4699bb1ae478419f3370", + "value": "conformal forecasts: 100%" + } + }, + "a962a7ed08bf40938edd9e40b3ac9fd7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "a9b5007ef99242ca8fe3ba02f732dca0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "aa0c0897f1254968927e8c44c28045e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_16ad072807e04d9889b1d02f6ae7cc61", + "max": 1, + "style": "IPY_MODEL_a45d38c972a64d50b240149d27939337", + "value": 1 + } + }, + "aa574b4b08754fb093a7bba7c210c224": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "aa98949899604246aeda7cc0c6bc8d41": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_a511c6d154114dc6b3663dffcc784cfa", + "max": 1, + "style": "IPY_MODEL_6e93ce66abe24cdf8228d9d511c3a977", + "value": 1 + } + }, + "aaacb910c5164088884c07409b51c89a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "aac800df192c4a398e4a9260faf14f76": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "aacb794925ba4998b154efba03f017cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_9b1cdee9eaab4d118dd6c531567ebd77", + "IPY_MODEL_e93bc0fb80dc4d0d83477ed4eb81ac63", + "IPY_MODEL_d7e62f9fd3ec47c5a89edcecf75fe67e" + ], + "layout": "IPY_MODEL_e40111a7cf8b4da191ffd1952c405eff" + } + }, + "ab09faee5d684e708d10a76e3059f402": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "ae1efd5ad9a9404bb18e730ccac9d2b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ae3436ccca8c4317aa7da1dc330dad97": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ae432b41f0364812ba8adedf7c83ee83": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "ae85c72d450e4f18a6ec84159bcb6fee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "aeb9d6c8ba114b2aa7c26c7f566ba11d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "aeeb3c88151b4bc9a684562193ef713c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_0c612d221a5e47ae820dc01623277090", + "style": "IPY_MODEL_230a646d8ba545e884a3de401d1e877b", + "value": " 1/1 [00:00<00:00,  1.25it/s]" + } + }, + "af32588550d74c13ab923434afefc9b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "afaabeefd0024f3fb85c4dfb4b44bc89": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "afd80a018d354240b3d4f95832c60ee9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b0288164929046f3b8b6db935d05af29": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b0f6b402165849a3b966321b698572d3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b11aa1aa2cf6498b9b06060603da02e8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b195cff54aa84446967972b8ecac888a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b1b5a081744846fea5f49d9983f2a2ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_d64cce733220426ab43bb20bd313307a", + "IPY_MODEL_ce7dc129d13943b4a21d7febdbe469f6", + "IPY_MODEL_e1a3b8f19ffc47f58d23de259c2e49a1" + ], + "layout": "IPY_MODEL_f493e4ff28694bdeb324d42f8b631624" + } + }, + "b1c727a12bb64e0d9d402223e5dd18c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_472f3d1718d74e7caa9e10091678d596", + "IPY_MODEL_4a7db6f8a70d46d8b9191bf0a803b983", + "IPY_MODEL_fab0c9fa40a54ccfb1d91b9747c9e434" + ], + "layout": "IPY_MODEL_01d5e57d11024dfb84fd6e6aff24894e" + } + }, + "b1f6895c944e46af81fae5303d8ce45a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b1f95aa0033d4ae8ac59b609d3411603": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_742bc4322c50468c83abad02ba4960ff", + "style": "IPY_MODEL_8b3f824fa5534af697e19ead204e023d", + "value": "historical forecasts: 100%" + } + }, + "b22c7e7cdfa0482fa4ee1c48eab38229": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_3e065117698d4aeaa591cc86a053ef90", + "style": "IPY_MODEL_f8116c7518a847f0b0e0c818b79fea6a", + "value": " 90/90 [00:00<00:00, 1599.75it/s]" + } + }, + "b27da71036894d49a6654bfc5729eaed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_92eda515424946559a80f6904bca9c0d", + "style": "IPY_MODEL_2deb970d485a4da680cc308119207024", + "value": "historical forecasts: 100%" + } + }, + "b2f28eacf0d64fd2971d1828b894b301": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_9f168bfac8494e21b1f4313873d4f21b", + "style": "IPY_MODEL_b6c6808fc8dc4c1c9594f5387c749eb7", + "value": " 1/1 [00:00<00:00, 20.25it/s]" + } + }, + "b335382757dd4f2985142a9e33db3cf7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_4e28e97800ae432fa2d6b03a8ee8d595", + "style": "IPY_MODEL_d0c992e4d28043d68c9ea2e00e45e9a3", + "value": "historical forecasts: 100%" + } + }, + "b52d4d49f25a47a8a64269bdf02eee84": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_74775bb9d32f476abe383b6078555e7d", + "style": "IPY_MODEL_5d7ae906654d4f6dae1bb9e77e3829f8", + "value": " 1/1 [00:00<00:00, 22.57it/s]" + } + }, + "b5720bcdfff54d14bcc822cfda5be8bc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b6c6808fc8dc4c1c9594f5387c749eb7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b744fe458c384f20b529bd35ad049379": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b752afd9189244fbaf2ec82d757076dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "b94428b9240949288d3f5b6d9c53385a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b9756643d3b049bcb9412b2098dd94ce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b99336648ff64c27972a10828806758c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "b9b393b01a0d44ad8d930360b1fc271f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b9b7f924a5bc4866a48329163128da5c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_1c23955e971c44789df8e177e26d958f", + "max": 90, + "style": "IPY_MODEL_0a57142b423e4d9a9522d1d4b015200f", + "value": 90 + } + }, + "ba79b76577fa4acab6c23eec93294596": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_0dad4efb53224d3d97bd90b95382b769", + "style": "IPY_MODEL_5088008902e84fbfb8f6d37b4c2cbdd9", + "value": " 1/1 [00:00<00:00,  1.43it/s]" + } + }, + "ba8715e3f29147e7bca4cfdaeaabfa57": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "ba9168075b7748cc862a53aac42fa94f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "bc86551b3d85486881de18be47d5af76": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_7699561eac114a9690c653859f16a854", + "max": 1, + "style": "IPY_MODEL_54b1a444e38e434ba761b494f87f9ee2", + "value": 1 + } + }, + "bcbe92d4a6a44d79b4611b0bbbd09201": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_6a157bebd1204d338bd847917da2f137", + "style": "IPY_MODEL_693df426b0d143f4b4aeee620952501d", + "value": "conformal forecasts: 100%" + } + }, + "bd4384c207ba4748a640d1cd8921785e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "bd91a1c604a6492da715f6f1a586fabb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "bee653ba243f4978a1c04d238eab8fa7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "bf7d1073aae5463f9dfd5c0d9988fdbf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_e4d33cfa33764128bb1679f340e42d4f", + "style": "IPY_MODEL_f3443f898d8e4541b2e6b8b45e29da3f", + "value": " 83/83 [00:00<00:00, 2354.14it/s]" + } + }, + "bfad31e3f8b44cbe84f9e22cef8f16d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "bfc521d8860f4ddb8a4af396e4c77eac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "c0ac6b3f6e9a45d78e48d4d8c0b6445a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c0e40037fb5c4d908d88f5c5f2e9e42b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_b27da71036894d49a6654bfc5729eaed", + "IPY_MODEL_124f380daa3949669ac7a1f287bdd4d9", + "IPY_MODEL_ea25232ab9f94343a1f9c0d5169d0a15" + ], + "layout": "IPY_MODEL_d9247af3d40c44b5a14a224d4373481d" + } + }, + "c19cfd2aecdb448682d202167cdd5c24": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_3e919c8f0f774d069b98b346a3b358ea", + "max": 1, + "style": "IPY_MODEL_fbd07f9a78044cc78e6ca1383f0a99bd", + "value": 1 + } + }, + "c338c2806f9b4c59be2cf11be848b737": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_1ae34bb8d5cc4cfcbdd34df3ee303a99", + "style": "IPY_MODEL_efa8d685606d40e09f8f1a5823bf1c79", + "value": "historical forecasts: 100%" + } + }, + "c3fb520d60af4c6188730a9be8415050": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c49c04387eb542a89828fe439d796972": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "c6a5ccdbc8e24f2d8831d5cf761eddf1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_b335382757dd4f2985142a9e33db3cf7", + "IPY_MODEL_ff070d6c97f244e6ae46cd864c88c614", + "IPY_MODEL_30adc481cd3b4756a5c1ba7ed3e12960" + ], + "layout": "IPY_MODEL_9dd71a7b9b224b879309dc6157c2eac0" + } + }, + "c72226a3db38408386368ab0becac56d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_23f1daafe1af4de7b075602a3d5a0a09", + "max": 1, + "style": "IPY_MODEL_153a0a6dd62b432aa5934b7ed69540b6", + "value": 1 + } + }, + "c748f293ef5c45698b4d59e3f13ec4c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_f034d20c3f2e4e3e98734132ab1803de", + "IPY_MODEL_70c5c9cb78ec4b31b44b4f3ba74bbcc1", + "IPY_MODEL_2cd25b364fb544e5ab1a22ad45a0d049" + ], + "layout": "IPY_MODEL_37b1858f5ffa41ad9b5eb8b4f9e64092" + } + }, + "c86e03a2f87247798bc8f72f8e213c72": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "c8731dbdce1e488aa822f99b115447b0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "c8d61ddf5df64e3fa3a2ed71cbbd1c14": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_41fe671c972044a898d41d7ec53e4319", + "max": 83, + "style": "IPY_MODEL_670a5c507c29421b8a2c3bbdde9ce167", + "value": 83 + } + }, + "c9b8bff68668414e86c1bd4b02efc80d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "cb5e336c581c4689a13f94570be87e9b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "cb7adc044ead45179cfb2f1949b5a3d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "cb8ce9f130714ae8991950d01a06563c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "cbdc9496536042ce95524ba428356936": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_25f34c9a655e4d2c8062d3802ce5e1f9", + "max": 1, + "style": "IPY_MODEL_ce51fefbc7c94f83af5c367e2de93f4f", + "value": 1 + } + }, + "ccc1b69935ba4b0885aa0ed7aec51478": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "ccf98993b99a46f58ffa5c94a6a7b5dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_c86e03a2f87247798bc8f72f8e213c72", + "max": 90, + "style": "IPY_MODEL_fe2ae6e302f849be8a4d5006270fdea1", + "value": 90 + } + }, + "cd03113757ac49ffba8e6569cd606de4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_0e31654f8c764ac78b4052e6cee6215f", + "IPY_MODEL_3512e1c0bbc44af19e5b444331605abe", + "IPY_MODEL_0e197b702eaf48ab92dfee241fc2b8c4" + ], + "layout": "IPY_MODEL_aac800df192c4a398e4a9260faf14f76" + } + }, + "cd062bb62bc44b029b0b7f537c9e80bb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "cd1f8088982342ddbe58b3c3df5d42b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_513d435a3d45489d828109795204dce8", + "IPY_MODEL_4694711f2b354a7ab34d1c57214ef250", + "IPY_MODEL_e73baf7b8a7d4f72b6d7aa24f7c653e2" + ], + "layout": "IPY_MODEL_36f02e5e15a24438ae05dd9140ba939b" + } + }, + "cda24b6b1f4b4b9894f0716fe889a811": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "ce51fefbc7c94f83af5c367e2de93f4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "ce7dc129d13943b4a21d7febdbe469f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_33907617ee4941f494cb94741e4d6f99", + "max": 1, + "style": "IPY_MODEL_aeb9d6c8ba114b2aa7c26c7f566ba11d", + "value": 1 + } + }, + "ced449477e7b4b04897e3423b2b10d65": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "cef7816bccc34465a7e7b7ec13f16c52": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "d0c992e4d28043d68c9ea2e00e45e9a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d130eda4991c4b39b38236f896e9a579": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_ed9b67ad897c47ca8a0fa18cf7077018", + "IPY_MODEL_aa98949899604246aeda7cc0c6bc8d41", + "IPY_MODEL_9b7b8a83c663466db8f62694e1d700d6" + ], + "layout": "IPY_MODEL_046f29bba4e140f09f33b6014c0bd0b6" + } + }, + "d264237f2c674838a836964118610259": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "d2776168f8064f4eb719b384021f6d4e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "d39a633ad0c942319077c077187c6e19": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_25355f22e2c842d7a429abecea14e204", + "style": "IPY_MODEL_3601d652dd854e709addd69a199be5a8", + "value": "historical forecasts: 100%" + } + }, + "d3dc2db6215a4091bcbde9ee6b600679": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d47d46397ae3483fa9b7513524cd9c26": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "d50293e756534cafb0685cb12f0828be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_ced449477e7b4b04897e3423b2b10d65", + "max": 62, + "style": "IPY_MODEL_83369f3092dc485582a191ac1bac8b8d", + "value": 62 + } + }, + "d53eb0bdd13e4749803dd43e50dfa10f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_fc89f10b682346b1bbda76b1421f50f8", + "IPY_MODEL_a6fada1e0d11459c88db982a79eb6cdd", + "IPY_MODEL_ee220e8d7a7f47b2810904a754232b33" + ], + "layout": "IPY_MODEL_23b66ce21def4202b81cd71184794d66" + } + }, + "d54fb00e03764a48b3566a1268fb47c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "d5907c2c1c7940458460f086ac7f5adf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d64cce733220426ab43bb20bd313307a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_12ee64ee1422425abe1989cb3805f13b", + "style": "IPY_MODEL_432a73bb9dc54a01b2ad97cfbba08421", + "value": "historical forecasts: 100%" + } + }, + "d6607d1a2f1a4c7189d088e42030b8fb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "d66ecfd08ab34af3b82755827f6e3474": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_565326362f7b45dfa8b2baf217fcd3b7", + "style": "IPY_MODEL_414a39bb1bed486186b0f468cede8872", + "value": "historical forecasts: 100%" + } + }, + "d7729ffa74b94ceab27ffce5e1ba671d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_652bcd47f1164b6184b29ea04c8cd3a6", + "style": "IPY_MODEL_4fbf852739d646889fe2262b0aeb72c4", + "value": "historical forecasts: 100%" + } + }, + "d7e62f9fd3ec47c5a89edcecf75fe67e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_efa5676aaf87433c86dfc3062ca16316", + "style": "IPY_MODEL_8a11e7fac7914714baabd804abb353f3", + "value": " 1/1 [00:00<00:00, 22.51it/s]" + } + }, + "d83c06173bc04e019722046ef7f79ed7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "d8535ee2a0244c61a3da7018918dcbee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_b195cff54aa84446967972b8ecac888a", + "style": "IPY_MODEL_01f0742d352a4dc69ef1a8988c73e5ea", + "value": " 1/1 [00:00<00:00, 27.55it/s]" + } + }, + "d8d062164169456889eb8bfacbfdd71a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_24038457afab4ecea846ed35d003885f", + "style": "IPY_MODEL_ecd2712c2d4d4d16aae8da29d9011607", + "value": "historical forecasts: 100%" + } + }, + "d9247af3d40c44b5a14a224d4373481d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "daff091b192b4574a5f509431bb1ba82": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "dbd653a803a3401b8fea29371d2dde11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "dc23ee0d3935449c9af3f760e62a9f4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "dc5fcb67874041e993fc0aabb3e91fda": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "dd73c82169344c49b5da881e77dd0b61": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_fc6179df9b8d43f99b5acf28116b6c39", + "style": "IPY_MODEL_f3a3ab8bfeac4afeba5095b6804a519b", + "value": " 1/1 [00:00<00:00,  1.73it/s]" + } + }, + "dd92365d08204e5686869c4a807533f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "de74f152deac4e9b971c16da1a037230": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "df526894bdb2487fb057540ecb8225cf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "df621b30e8494e78999c738510add577": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "e031820d407d499ea2405ce253fc057f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_e13eba8e1f4644c3a5b47edd16e5c692", + "max": 1, + "style": "IPY_MODEL_f36f7b2a368a4d9eb46132521f01f9d7", + "value": 1 + } + }, + "e13eba8e1f4644c3a5b47edd16e5c692": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "e1637d15aec14d1aacf6d22613784ae0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_7e4d4bc33350416ba73dd248009df0ba", + "style": "IPY_MODEL_3c9e0cf48e054f4fbbbc5247ff0c3639", + "value": "historical forecasts: 100%" + } + }, + "e1a3b8f19ffc47f58d23de259c2e49a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_7e9509e25dd442bc804c6c5233429f44", + "style": "IPY_MODEL_235eaf7f33b54235bcaa7b816d06231b", + "value": " 1/1 [00:00<00:00,  1.62it/s]" + } + }, + "e1e1c8cbce574d3aa94a497409a83182": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e255bc9adb1f45c7bb3b7beb958eeee2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "e296745a4b7e4ac4a1c13c202fa7f5da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e40111a7cf8b4da191ffd1952c405eff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "e4484c147e9c414b9c65db55fd443fd0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_a15790c4dec9419ca2660da05768820f", + "style": "IPY_MODEL_ae3436ccca8c4317aa7da1dc330dad97", + "value": "conformal forecasts: 100%" + } + }, + "e48628240b6244259953b5e55a14d49e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e4970bf9dbe540a1bb723533bb4845a3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "e4d33cfa33764128bb1679f340e42d4f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "e59c7f2a15014da59c6781ccac26a36e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_aa574b4b08754fb093a7bba7c210c224", + "style": "IPY_MODEL_c3fb520d60af4c6188730a9be8415050", + "value": "historical forecasts: 100%" + } + }, + "e5a2dab9bf0e49cb9b51d25c39d16cb9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_d66ecfd08ab34af3b82755827f6e3474", + "IPY_MODEL_c72226a3db38408386368ab0becac56d", + "IPY_MODEL_3e0ad78978d641cead7a3d5cec0b806f" + ], + "layout": "IPY_MODEL_1eed59df3b1f4a4cb7e84e590f255c16" + } + }, + "e5e4088f450b469dbf5f68c83e4b533a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_fffb7937e50e4c85a531d39c8225f956", + "style": "IPY_MODEL_5e180f874b2a4f93b8f7c31b21ae9eb1", + "value": "conformal forecasts: 100%" + } + }, + "e64a6409d08844ae82860d97a4964a64": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_75e3b57272894a87be6bc335902681d9", + "max": 1, + "style": "IPY_MODEL_67f3053228884ef2a44a1d35896a1a8e", + "value": 1 + } + }, + "e653368295814c3c9d75fcbb64d6807a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "e7343679126049a6b9f1da6e4d7f23e8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "e73baf7b8a7d4f72b6d7aa24f7c653e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_2d337bf0c89243b7ba20f61106f3230c", + "style": "IPY_MODEL_bd4384c207ba4748a640d1cd8921785e", + "value": " 90/90 [00:00<00:00, 1542.45it/s]" + } + }, + "e7b71ab74d78424391a70f63d91c2f24": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "e93bc0fb80dc4d0d83477ed4eb81ac63": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_4525b5e09cfd49bda31ba97ad829afb1", + "max": 1, + "style": "IPY_MODEL_50568d5ef90946f68f676e0fd4cdd682", + "value": 1 + } + }, + "ea0100ef3d834ff3bd144727fbfbed00": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_efccdc70aea34a059ead5d089b26280f", + "max": 1, + "style": "IPY_MODEL_84713ec1aeaa46ca9ac78cd443a3d894", + "value": 1 + } + }, + "ea25232ab9f94343a1f9c0d5169d0a15": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_850bb57c7b4749de9facfe3ea3fe96ba", + "style": "IPY_MODEL_4ba07ab9e8574ac59d960d91db2ea913", + "value": " 1/1 [00:00<00:00,  1.61it/s]" + } + }, + "eb143183e36f4f169215aac3028e0371": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_70f1c6ff27bf40978710cc9466d1da4d", + "style": "IPY_MODEL_32ab3a13da6149ba8c500e680932f880", + "value": " 1/1 [00:00<00:00,  1.39it/s]" + } + }, + "eb657554be5c4c3abe749168b88d2c02": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "ebbd993a55504c4099e1c386119933b5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "ebdfe712edde49789dd7d52f0befe396": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_0dab5325b93647bb8e3bfa4c49e19f64", + "max": 1, + "style": "IPY_MODEL_ee7b3c424b9c4023b77de5409dd3b3f8", + "value": 1 + } + }, + "ec394383bb404e73ba01278096576f95": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_d7729ffa74b94ceab27ffce5e1ba671d", + "IPY_MODEL_1f594807859c463bab1926755138fd37", + "IPY_MODEL_83496947ae6443cba9788f8878b9a694" + ], + "layout": "IPY_MODEL_2f4bffd21f934bb0b8d2e0d999f57340" + } + }, + "ecd2712c2d4d4d16aae8da29d9011607": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ed806c4e08384cd09eca536a92ea4055": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "ed9b67ad897c47ca8a0fa18cf7077018": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_9c9ff8962659417b8adb0e202493c8a3", + "style": "IPY_MODEL_508a4417af3a47a699908a2490599606", + "value": "historical forecasts: 100%" + } + }, + "ee220e8d7a7f47b2810904a754232b33": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_4fa4679a9a1c47e9a854241b579d4b91", + "style": "IPY_MODEL_917b0eca17b7420183c7c21c5d150ee0", + "value": " 76/76 [00:00<00:00, 2170.18it/s]" + } + }, + "ee40878b24224d7fb97734e9bae9db94": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "ee46c46710634a5685104c15de0c964f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_12a3d12426384d6f92e3d41f284512a7", + "style": "IPY_MODEL_3c5759cde1b64149b0d9b7d56c86d793", + "value": " 1/1 [00:00<00:00,  1.63it/s]" + } + }, + "ee56ca1e4b5f42fa831b085e2a6c87d5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "ee7b3c424b9c4023b77de5409dd3b3f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "eebe728bdc824b8d83d3e73653063c3e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "efa5676aaf87433c86dfc3062ca16316": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "efa8d685606d40e09f8f1a5823bf1c79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "efccdc70aea34a059ead5d089b26280f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "efebc254756c4ce78f387ab227e7b8b4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f034d20c3f2e4e3e98734132ab1803de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_a62e54a301c04cbda985d5dd318f1f2d", + "style": "IPY_MODEL_ae1efd5ad9a9404bb18e730ccac9d2b1", + "value": "historical forecasts: 100%" + } + }, + "f1b240b33bab43baa8264d49f64a5228": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f213ff856269417595488428ff121a7d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "f26b7671b02748218c0b7744f5c1e9e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_df621b30e8494e78999c738510add577", + "style": "IPY_MODEL_91ed5710d5274e12bae407b8b5635135", + "value": " 62/62 [00:00<00:00, 1329.59it/s]" + } + }, + "f3443f898d8e4541b2e6b8b45e29da3f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f368bd9c4a154647a9e8f94071f07a5c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f36f7b2a368a4d9eb46132521f01f9d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "f3a3ab8bfeac4afeba5095b6804a519b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f493e4ff28694bdeb324d42f8b631624": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "f53cad6f60b247f1be1de43552d434e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_ee56ca1e4b5f42fa831b085e2a6c87d5", + "style": "IPY_MODEL_b94428b9240949288d3f5b6d9c53385a", + "value": "conformal forecasts: 100%" + } + }, + "f5df6035927f4bba8069fd186a551766": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "f6824305140b41f99cc8154b960f4756": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "f69eb4bb0a8249d0b6e21ea39430534e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_476c01e6ec4b44e8a93209f0f00bba59", + "style": "IPY_MODEL_73561c3527ae470b82ebab5e7d327177", + "value": " 90/90 [00:00<00:00, 1576.93it/s]" + } + }, + "f798c5364ee14f88a149aaef1f644d7b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_257c42d542c74462885387125e64c0ff", + "style": "IPY_MODEL_daff091b192b4574a5f509431bb1ba82", + "value": " 83/83 [00:00<00:00, 2336.58it/s]" + } + }, + "f8116c7518a847f0b0e0c818b79fea6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f811d597cb524f47ba9f0360f16017f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f8b53993f91344a8b886fdc375a4a735": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "fa52ed03da0b45f497a2af01ae1d3949": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_9d555c8eb2fd45be84a549d8113e0d33", + "style": "IPY_MODEL_0421915453f14d8c96a2b86cb33e62c5", + "value": "historical forecasts: 100%" + } + }, + "fa927bc8de7e4699bb1ae478419f3370": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "faa70ef2bf3143b391c8772f732b850f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "fab0c9fa40a54ccfb1d91b9747c9e434": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_5925fe560d2948c38ba3e3b9f6c15af3", + "style": "IPY_MODEL_d5907c2c1c7940458460f086ac7f5adf", + "value": " 1/1 [00:00<00:00,  1.73it/s]" + } + }, + "fbd07f9a78044cc78e6ca1383f0a99bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "fc6179df9b8d43f99b5acf28116b6c39": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "fc89f10b682346b1bbda76b1421f50f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_ba8715e3f29147e7bca4cfdaeaabfa57", + "style": "IPY_MODEL_69ad518c8cd448d6a9dadf77f1373081", + "value": "conformal forecasts: 100%" + } + }, + "fcc152f4e20b4f73b1bb5a77576981ef": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "fcc82951e7914c43a2dd0eeb86217932": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "fd53235aadcb460e8833a5db5881e1fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_326836d4a47a4de9bb61bae9cda583bd", + "max": 83, + "style": "IPY_MODEL_6483342185ae47b5bbea96cc595a5d0c", + "value": 83 + } + }, + "fd964e19deb345ddaad2e933436fa26f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "fe11cb18fec149efbd505aba6eecf608": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_1a3540097a8d4b55b591f60e0a2ebae6", + "style": "IPY_MODEL_af32588550d74c13ab923434afefc9b7", + "value": " 90/90 [00:00<00:00, 1563.77it/s]" + } + }, + "fe2ae6e302f849be8a4d5006270fdea1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "fe87ea92075043068c113e956db6ba07": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_ab09faee5d684e708d10a76e3059f402", + "max": 83, + "style": "IPY_MODEL_6f962983ef944dfca8f7c825f35f3dab", + "value": 83 + } + }, + "ff070d6c97f244e6ae46cd864c88c614": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_955091278b384f15bd0f09df7b2fad90", + "max": 1, + "style": "IPY_MODEL_54022decbd5f4ef6938f066cbe40b1fa", + "value": 1 + } + }, + "ff15cca20d5644328684a1cfc846a3aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_1502d0c150ac4cbf8c4a5cbfc5ac6498", + "IPY_MODEL_e64a6409d08844ae82860d97a4964a64", + "IPY_MODEL_aeeb3c88151b4bc9a684562193ef713c" + ], + "layout": "IPY_MODEL_322f0f9516f8408dbcc3e99fbe3da110" + } + }, + "ff4ab42fd56d443ea79e6f319a197ada": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_729b953ed9e9446687261f2fb8486153", + "IPY_MODEL_c8d61ddf5df64e3fa3a2ed71cbbd1c14", + "IPY_MODEL_67af7d7a9139469c9db4fedc3703f0ed" + ], + "layout": "IPY_MODEL_311f5c64eb3d4283b948e0ad7252e7bc" + } + }, + "ffbaf5a647c64b3eb80fc6fd53b729db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "fffb7937e50e4c85a531d39c8225f956": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 98811424f949853a78f786c6cbb5581ad5925fee Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 3 Oct 2024 18:36:11 +0200 Subject: [PATCH 54/78] small update --- examples/23-Conformal-Prediction-examples.ipynb | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/examples/23-Conformal-Prediction-examples.ipynb b/examples/23-Conformal-Prediction-examples.ipynb index 4f27a62a4e..153b95d9e1 100644 --- a/examples/23-Conformal-Prediction-examples.ipynb +++ b/examples/23-Conformal-Prediction-examples.ipynb @@ -665,7 +665,8 @@ "id": "d6067bce-628e-44af-b9b5-7463597d5aac", "metadata": {}, "source": [ - "Okay we're getting closer. Also, interesting to see the coverage drop for the smaller interval, but not for the large one." + "Okay we're getting closer. Also, interesting to see the coverage drop for the smaller interval, but not for the large one.\n", + "This is (for the lower) because the calibration set is expanding, and our calibration cannot react to distribution shifts quickly anymore." ] }, { @@ -674,7 +675,7 @@ "metadata": {}, "source": [ "### Improving the underlying forecasting model\n", - "Let's add the day of the week to our forecasting model, see if it gets more accuracte, and what the influence is on our conformal model. This is because the calibration set is expanding, and our calibration cannot react to distribution shifts quickly." + "Let's add the day of the week to our forecasting model, see if it gets more accuracte, and what the influence is on our conformal model." ] }, { From dd3e4c49390e0b658d1691e501fc6880bfcc5e72 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 4 Oct 2024 10:38:45 +0200 Subject: [PATCH 55/78] improve docs --- darts/ad/anomaly_model/forecasting_am.py | 25 +- darts/models/forecasting/conformal_models.py | 733 +++++++++++++++++- darts/models/forecasting/forecasting_model.py | 353 +++++---- darts/models/forecasting/regression_model.py | 4 +- .../forecasting/torch_forecasting_model.py | 20 +- docs/source/conf.py | 4 +- 6 files changed, 929 insertions(+), 210 deletions(-) diff --git a/darts/ad/anomaly_model/forecasting_am.py b/darts/ad/anomaly_model/forecasting_am.py index fd3eb9a33a..9e06e632eb 100644 --- a/darts/ad/anomaly_model/forecasting_am.py +++ b/darts/ad/anomaly_model/forecasting_am.py @@ -123,10 +123,9 @@ def fit( If set to 'value', `start` corresponds to the index value/label of the first predicted point. Will raise an error if the value is not in `series`' index. Default: `'value'` num_samples - Number of times a prediction is sampled from a probabilistic model. Should be left set to 1 for - deterministic models. + Number of times a prediction is sampled from a probabilistic model. Must be `1` for deterministic models. verbose - Whether to print progress. + Whether to print the progress. show_warnings Whether to show warnings related to historical forecasts optimization, or parameters `start` and `train_length`. @@ -204,10 +203,9 @@ def score( If set to 'value', `start` corresponds to the index value/label of the first predicted point. Will raise an error if the value is not in `series`' index. Default: `'value'` num_samples - Number of times a prediction is sampled from a probabilistic model. Should be left set to 1 for - deterministic models. + Number of times a prediction is sampled from a probabilistic model. Must be `1` for deterministic models. verbose - Whether to print progress. + Whether to print the progress. show_warnings Whether to show warnings related to historical forecasts optimization, or parameters `start` and `train_length`. @@ -292,10 +290,9 @@ def predict_series( If set to 'value', `start` corresponds to the index value/label of the first predicted point. Will raise an error if the value is not in `series`' index. Default: `'value'` num_samples - Number of times a prediction is sampled from a probabilistic model. Should be left set to 1 for - deterministic models. + Number of times a prediction is sampled from a probabilistic model. Must be `1` for deterministic models. verbose - Whether to print progress. + Whether to print the progress. show_warnings Whether to show warnings related to historical forecasts optimization, or parameters `start` and `train_length`. @@ -388,10 +385,9 @@ def eval_metric( If set to 'value', `start` corresponds to the index value/label of the first predicted point. Will raise an error if the value is not in `series`' index. Default: `'value'` num_samples - Number of times a prediction is sampled from a probabilistic model. Should be left set to 1 for - deterministic models. + Number of times a prediction is sampled from a probabilistic model. Must be `1` for deterministic models. verbose - Whether to print progress. + Whether to print the progress. show_warnings Whether to show warnings related to historical forecasts optimization, or parameters `start` and `train_length`. @@ -494,10 +490,9 @@ def show_anomalies( If set to 'value', `start` corresponds to the index value/label of the first predicted point. Will raise an error if the value is not in `series`' index. Default: `'value'` num_samples - Number of times a prediction is sampled from a probabilistic model. Should be left set to 1 for - deterministic models. + Number of times a prediction is sampled from a probabilistic model. Must be `1` for deterministic models. verbose - Whether to print progress. + Whether to print the progress. show_warnings Whether to show warnings related to historical forecasts optimization, or parameters `start` and `train_length`. diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index 40f1ecb98b..05bb6f3358 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -164,6 +164,39 @@ def fit( future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, **kwargs, ) -> "ConformalModel": + """Fit/train the underlying forecasting model on (potentially multiple) series. + + Optionally, one or multiple past and/or future covariates series can be provided as well, depending on the + forecasting model used. The number of covariates series must match the number of target series. + + Notes + ----- + Conformal Models do not required calling `fit()`, since they use pre-trained global forecasting models. + You can call `predict()` directly. Also, make sure that the input series used in `predict()` corresponds to + a calibration set, and not the same as used during training with `fit()`. + + Parameters + ---------- + series + One or several target time series. The model will be trained to forecast these time series. + The series may or may not be multivariate, but if multiple series are provided + they must have the same number of components. + past_covariates + One or several past-observed covariate time series. These time series will not be forecast, but can + be used by some models as an input. The covariate(s) may or may not be multivariate, but if multiple + covariates are provided they must have the same number of components. If `past_covariates` is provided, + it must contain the same number of series as `series`. + future_covariates + One or several future-known covariate time series. These time series will not be forecast, but can + be used by some models as an input. The covariate(s) may or may not be multivariate, but if multiple + covariates are provided they must have the same number of components. If `future_covariates` is provided, + it must contain the same number of series as `series`. + + Returns + ------- + self + Fitted model. + """ # does not have to be trained, but we allow it for unified API self.model.fit( series=series, @@ -179,14 +212,88 @@ def predict( series: Union[TimeSeries, Sequence[TimeSeries]] = None, past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + cal_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + cal_past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + cal_future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, num_samples: int = 1, verbose: bool = False, predict_likelihood_parameters: bool = False, show_warnings: bool = True, - cal_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - cal_past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - cal_future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, ) -> Union[TimeSeries, Sequence[TimeSeries]]: + """Forecasts calibrated quantile intervals (or samples from calibrated intervals) for `n` time steps after the + end of the `series`. + + It is important that the input series for prediction correspond to a calibration set - a set different to the + series that the underlying forecasting `model` was trained one. + + Since it is a probabilistic model, you can generate forecasts in two ways: + + - Predict the calibrated quantile intervals directly: Pass parameters `predict_likelihood_parameters=True`, and + `num_samples=1` to the forecast method. + - Predict stochastic samples from the calibrated quantile intervals: Pass parameters + `predict_likelihood_parameters=False`, and `num_samples>>1` to the forecast method. + + Under the hood, the simplified workflow to produce one calibrated forecast/prediction for every step in the + horizon `n` is as follows: + + - Extract a calibration set: The number of calibration examples from the most recent past to use for one + conformal prediction can be defined at model creation with parameter `cal_length`. To make your life simpler, + we support two modes: + - Automatic extraction of the calibration set from the past of your input series (`series`, + `past_covariates`, ...). This is the default mode. + - Supply a fixed calibration set with parameters `cal_series`, `cal_past_covariates`, ... . + - Generate historical forecasts on the calibration set (using the forecasting model) + - Compute the errors/non-conformity scores (specific to each conformal model) on these historical forecasts + - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model + creation with parameter `quantiles`). + - Compute the conformal prediction: Add the calibrated intervals to (or adjust the existing intervals of) the + forecasting model's predictions. + + Parameters + ---------- + n + Forecast horizon - the number of time steps after the end of the series for which to produce predictions. + series + A series or sequence of series, representing the history of the target series whose future is to be + predicted. If `cal_series` is `None`, will use the past of this series for calibration. + past_covariates + Optionally, a (sequence of) past-observed covariate time series for every input time series in `series`. + Their dimension must match that of the past covariates used for training. If `cal_series` is `None`, will + use this series for calibration. + future_covariates + Optionally, a (sequence of) future-known covariate time series for every input time series in `series`. + Their dimension must match that of the past covariates used for training. If `cal_series` is `None`, will + use this series for calibration. + cal_series + Optionally, a (sequence of) target series for every input time series in `series` to use for calibration + instead of `series`. + cal_past_covariates + Optionally, a (sequence of) past covariates series for every input time series in `series` to use for + calibration instead of `past_covariates`. + cal_future_covariates + Optionally, a future covariates series for every input time series in `series` to use for calibration + instead of `future_covariates`. + num_samples + Number of times a prediction is sampled from the calibrated quantile predictions using linear + interpolation in-between the quantiles. For larger values, the sample distribution approximates the + calibrated quantile predictions. + verbose + Whether to print the progress. + predict_likelihood_parameters + If set to `True`, generates the quantile predictions directly. Only supported with `num_samples = 1`. + show_warnings + Whether to show warnings related auto-regression and past covariates usage. + + Returns + ------- + Union[TimeSeries, Sequence[TimeSeries]] + If `series` is not specified, this function returns a single time series containing the `n` + next points after then end of the training series. + If `series` is given and is a simple ``TimeSeries``, this function returns the `n` next points + after the end of `series`. + If `series` is given and is a sequence of several time series, this function returns + a sequence where each element contains the corresponding `n` points forecasts. + """ if series is None: # then there must be a single TS, and that was saved in super().fit as self.training_series if self.model.training_series is None: @@ -292,11 +399,14 @@ def historical_forecasts( series: Union[TimeSeries, Sequence[TimeSeries]], past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + cal_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + cal_past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + cal_future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + forecast_horizon: int = 1, num_samples: int = 1, train_length: Optional[int] = None, start: Optional[Union[pd.Timestamp, float, int]] = None, start_format: Literal["position", "value"] = "value", - forecast_horizon: int = 1, stride: int = 1, retrain: Union[bool, int, Callable[..., bool]] = True, overlap_end: bool = False, @@ -308,10 +418,134 @@ def historical_forecasts( fit_kwargs: Optional[Dict[str, Any]] = None, predict_kwargs: Optional[Dict[str, Any]] = None, sample_weight: Optional[Union[TimeSeries, Sequence[TimeSeries], str]] = None, - cal_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - cal_past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - cal_future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, ) -> Union[TimeSeries, List[TimeSeries], List[List[TimeSeries]]]: + """Generates calibrated historical forecasts by simulating predictions at various points in time throughout the + history of the provided (potentially multiple) `series`. This process involves retrospectively applying the + model to different time steps, as if the forecasts were made in real-time at those specific moments. This + allows for an evaluation of the model's performance over the entire duration of the series, providing insights + into its predictive accuracy and robustness across different historical periods. + + Currently, conformal models only support the pre-trained historical forecasts mode (`retrain=False`). + Parameters `retrain` and `train_length` are ignored. + + **Pre-trained Mode:** First, all historical forecasts are generated using the underlying pre-trained global + forecasting model (see :meth:`ForecastingModel.historical_forecasts() + ` for more info). Then it + repeatedly builds a calibration set by either expanding from the beginning of the historical forecasts or by + using a fixed-length `cal_length` (the start point can also be configured with `start` and `start_format`). + The next forecast of length `forecast_horizon` is then calibrated on this calibration set. Subsequently, the + end of the calibration set is moved forward by `stride` time steps, and the process is repeated. + You can also use a fixed calibration set to calibrate all forecasts equally by passing `cal_series`, and + optional `cal_past_covariates` and `cal_future_covariates`. + + By default, with `last_points_only=True`, this method returns a single time series (or a sequence of time + series) composed of the last point from each calibrated historical forecast. This time series will thus have a + frequency of `series.freq * stride`. + If `last_points_only=False`, it will instead return a list (or a sequence of lists) of the full calibrate + historical forecast series each with frequency `series.freq`. + + Parameters + ---------- + series + A (sequence of) target time series used to successively compute the historical forecasts. If `cal_series` + is `None`, will use the past of this series for calibration. + past_covariates + Optionally, a (sequence of) past-observed covariate time series for every input time series in `series`. + Their dimension must match that of the past covariates used for training. If `cal_series` is `None`, will + use this series for calibration. + future_covariates + Optionally, a (sequence of) future-known covariate time series for every input time series in `series`. + Their dimension must match that of the past covariates used for training. If `cal_series` is `None`, will + use this series for calibration. + cal_series + Optionally, a (sequence of) target series for every input time series in `series` to use as a fixed + calibration set instead of `series`. + cal_past_covariates + Optionally, a (sequence of) past covariates series for every input time series in `series` to use as a fixed + calibration set instead of `past_covariates`. + cal_future_covariates + Optionally, a future covariates series for every input time series in `series` to use as a fixed + calibration set instead of `future_covariates`. + forecast_horizon + The forecast horizon for the predictions. + num_samples + Number of times a prediction is sampled from the calibrated quantile predictions using linear + interpolation in-between the quantiles. For larger values, the sample distribution approximates the + calibrated quantile predictions. + train_length + Currently ignored by conformal models. + start + Optionally, the first point in time at which a prediction is computed. This parameter supports: + ``float``, ``int``, ``pandas.Timestamp``, and ``None``. + If a ``float``, it is the proportion of the time series that should lie before the first prediction point. + If an ``int``, it is either the index position of the first prediction point for `series` with a + `pd.DatetimeIndex`, or the index value for `series` with a `pd.RangeIndex`. The latter can be changed to + the index position with `start_format="position"`. + If a ``pandas.Timestamp``, it is the time stamp of the first prediction point. + If ``None``, the first prediction point will automatically be set to: + + - the first predictable point if `retrain` is ``False``, or `retrain` is a Callable and the first + predictable point is earlier than the first trainable point. + - the first trainable point if `retrain` is ``True`` or ``int`` (given `train_length`), + or `retrain` is a ``Callable`` and the first trainable point is earlier than the first predictable point. + - the first trainable point (given `train_length`) otherwise + + Note: If the model uses a shifted output (`output_chunk_shift > 0`), then the first predicted point is also + shifted by `output_chunk_shift` points into the future. + Note: Raises a ValueError if `start` yields a time outside the time index of `series`. + Note: If `start` is outside the possible historical forecasting times, will ignore the parameter + (default behavior with ``None``) and start at the first trainable/predictable point. + start_format + Defines the `start` format. + If set to ``'position'``, `start` corresponds to the index position of the first predicted point and can + range from `(-len(series), len(series) - 1)`. + If set to ``'value'``, `start` corresponds to the index value/label of the first predicted point. Will raise + an error if the value is not in `series`' index. Default: ``'value'``. + stride + The number of time steps between two consecutive predictions. + retrain + Currently ignored by conformal models. + overlap_end + Whether the returned forecasts can go beyond the series' end or not. + last_points_only + Whether to return only the last point of each historical forecast. If set to ``True``, the method returns a + single ``TimeSeries`` (for each time series in `series`) containing the successive point forecasts. + Otherwise, returns a list of historical ``TimeSeries`` forecasts. + verbose + Whether to print the progress. + show_warnings + Whether to show warnings related to historical forecasts optimization, or parameters `start` and + `train_length`. + predict_likelihood_parameters + If set to `True`, generates the quantile predictions directly. Only supported with `num_samples = 1`. + enable_optimization + Whether to use the optimized version of `historical_forecasts` when supported and available. + Default: ``True``. + fit_kwargs + Currently ignored by conformal models. + predict_kwargs + Optionally, some additional arguments passed to the model `predict()` method. + sample_weight + Currently ignored by conformal models. + + Returns + ------- + TimeSeries + A single historical forecast for a single `series` and `last_points_only=True`: it contains only the + predictions at step `forecast_horizon` from all historical forecasts. + List[TimeSeries] + A list of historical forecasts for: + + - a sequence (list) of `series` and `last_points_only=True`: for each series, it contains only the + predictions at step `forecast_horizon` from all historical forecasts. + - a single `series` and `last_points_only=False`: for each historical forecast, it contains the entire + horizon `forecast_horizon`. + List[List[TimeSeries]] + A list of lists of historical forecasts for a sequence of `series` and `last_points_only=False`. For each + series, and historical forecast, it contains the entire horizon `forecast_horizon`. The outer list + is over the series provided in the input sequence, and the inner lists contain the historical forecasts for + each series. + """ called_with_single_series = get_series_seq_type(series) == SeriesType.SINGLE series = series2seq(series) past_covariates = series2seq(past_covariates) @@ -389,6 +623,466 @@ def historical_forecasts( else calibrated_forecasts ) + def backtest( + self, + series: Union[TimeSeries, Sequence[TimeSeries]], + past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + cal_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + cal_past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + cal_future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + historical_forecasts: Optional[ + Union[TimeSeries, Sequence[TimeSeries], Sequence[Sequence[TimeSeries]]] + ] = None, + forecast_horizon: int = 1, + num_samples: int = 1, + train_length: Optional[int] = None, + start: Optional[Union[pd.Timestamp, float, int]] = None, + start_format: Literal["position", "value"] = "value", + stride: int = 1, + retrain: Union[bool, int, Callable[..., bool]] = True, + overlap_end: bool = False, + last_points_only: bool = False, + metric: Union[METRIC_TYPE, List[METRIC_TYPE]] = metrics.mape, + reduction: Union[Callable[..., float], None] = np.mean, + verbose: bool = False, + show_warnings: bool = True, + predict_likelihood_parameters: bool = False, + enable_optimization: bool = True, + metric_kwargs: Optional[Union[Dict[str, Any], List[Dict[str, Any]]]] = None, + fit_kwargs: Optional[Dict[str, Any]] = None, + predict_kwargs: Optional[Dict[str, Any]] = None, + sample_weight: Optional[Union[TimeSeries, Sequence[TimeSeries], str]] = None, + ) -> Union[float, np.ndarray, List[float], List[np.ndarray]]: + """Compute error values that the model produced for historical forecasts on (potentially multiple) `series`. + + If `historical_forecasts` are provided, the metric(s) (given by the `metric` function) is evaluated directly on + all forecasts and actual values. The same `series` and `last_points_only` value must be passed that were used + to generate the historical forecasts. Finally, the method returns an optional `reduction` (the mean by default) + of all these metric scores. + + If `historical_forecasts` is ``None``, it first generates the historical forecasts with the parameters given + below (see :meth:`ConformalModel.historical_forecasts() + ` for more info) and then + evaluates as described above. + + The metric(s) can be further customized `metric_kwargs` (e.g. control the aggregation over components, time + steps, multiple series, other required arguments such as `q` for quantile metrics, ...). + + Notes + ----- + Darts has several metrics to evaluate probabilistic forecasts. For conformal models, we recommend using + quantile interval metrics (see `here `_). + You can specify which intervals to evaluate by setting `metric_kwargs={'q_interval': my_intervals}`. To check + all intervals used by your conformal model `my_model`, you can set ``{'q_interval': my_model.q_interval}``. + + Parameters + ---------- + series + A (sequence of) target time series used to successively compute the historical forecasts. If `cal_series` + is `None`, will use the past of this series for calibration. + past_covariates + Optionally, a (sequence of) past-observed covariate time series for every input time series in `series`. + Their dimension must match that of the past covariates used for training. If `cal_series` is `None`, will + use this series for calibration. + future_covariates + Optionally, a (sequence of) future-known covariate time series for every input time series in `series`. + Their dimension must match that of the past covariates used for training. If `cal_series` is `None`, will + use this series for calibration. + cal_series + Optionally, a (sequence of) target series for every input time series in `series` to use as a fixed + calibration set instead of `series`. + cal_past_covariates + Optionally, a (sequence of) past covariates series for every input time series in `series` to use as a fixed + calibration set instead of `past_covariates`. + cal_future_covariates + Optionally, a future covariates series for every input time series in `series` to use as a fixed + calibration set instead of `future_covariates`. + historical_forecasts + Optionally, the (or a sequence of / a sequence of sequences of) historical forecasts time series to be + evaluated. Corresponds to the output of :meth:`historical_forecasts() + `. The same `series` and + `last_points_only` values must be passed that were used to generate the historical forecasts. If provided, + will skip historical forecasting and ignore all parameters except `series`, `last_points_only`, `metric`, + and `reduction`. + forecast_horizon + The forecast horizon for the predictions. + num_samples + Number of times a prediction is sampled from the calibrated quantile predictions using linear + interpolation in-between the quantiles. For larger values, the sample distribution approximates the + calibrated quantile predictions. + train_length + Currently ignored by conformal models. + start + Optionally, the first point in time at which a prediction is computed. This parameter supports: + ``float``, ``int``, ``pandas.Timestamp``, and ``None``. + If a ``float``, it is the proportion of the time series that should lie before the first prediction point. + If an ``int``, it is either the index position of the first prediction point for `series` with a + `pd.DatetimeIndex`, or the index value for `series` with a `pd.RangeIndex`. The latter can be changed to + the index position with `start_format="position"`. + If a ``pandas.Timestamp``, it is the time stamp of the first prediction point. + If ``None``, the first prediction point will automatically be set to: + + - the first predictable point if `retrain` is ``False``, or `retrain` is a Callable and the first + predictable point is earlier than the first trainable point. + - the first trainable point if `retrain` is ``True`` or ``int`` (given `train_length`), + or `retrain` is a ``Callable`` and the first trainable point is earlier than the first predictable point. + - the first trainable point (given `train_length`) otherwise + + Note: If the model uses a shifted output (`output_chunk_shift > 0`), then the first predicted point is also + shifted by `output_chunk_shift` points into the future. + Note: Raises a ValueError if `start` yields a time outside the time index of `series`. + Note: If `start` is outside the possible historical forecasting times, will ignore the parameter + (default behavior with ``None``) and start at the first trainable/predictable point. + start_format + Defines the `start` format. + If set to ``'position'``, `start` corresponds to the index position of the first predicted point and can + range from `(-len(series), len(series) - 1)`. + If set to ``'value'``, `start` corresponds to the index value/label of the first predicted point. Will raise + an error if the value is not in `series`' index. Default: ``'value'``. + stride + The number of time steps between two consecutive predictions. + retrain + Currently ignored by conformal models. + overlap_end + Whether the returned forecasts can go beyond the series' end or not. + last_points_only + Whether to return only the last point of each historical forecast. If set to ``True``, the method returns a + single ``TimeSeries`` (for each time series in `series`) containing the successive point forecasts. + Otherwise, returns a list of historical ``TimeSeries`` forecasts. + metric + A metric function or a list of metric functions. Each metric must either be a Darts metric (see `here + `_), or a custom metric that has an + identical signature as Darts' metrics, uses decorators :func:`~darts.metrics.metrics.multi_ts_support` and + :func:`~darts.metrics.metrics.multi_ts_support`, and returns the metric score. + reduction + A function used to combine the individual error scores obtained when `last_points_only` is set to `False`. + When providing several metric functions, the function will receive the argument `axis = 1` to obtain single + value for each metric function. + If explicitly set to `None`, the method will return a list of the individual error scores instead. + Set to ``np.mean`` by default. + verbose + Whether to print the progress. + show_warnings + Whether to show warnings related to historical forecasts optimization, or parameters `start` and + `train_length`. + predict_likelihood_parameters + If set to `True`, generates the quantile predictions directly. Only supported with `num_samples = 1`. + enable_optimization + Whether to use the optimized version of `historical_forecasts` when supported and available. + Default: ``True``. + metric_kwargs + Additional arguments passed to `metric()`, such as `'n_jobs'` for parallelization, `'component_reduction'` + for reducing the component wise metrics, seasonality `'m'` for scaled metrics, etc. Will pass arguments to + each metric separately and only if they are present in the corresponding metric signature. Parameter + `'insample'` for scaled metrics (e.g. mase`, `rmsse`, ...) is ignored, as it is handled internally. + fit_kwargs + Currently ignored by conformal models. + predict_kwargs + Optionally, some additional arguments passed to the model `predict()` method. + sample_weight + Currently ignored by conformal models. + + Returns + ------- + float + A single backtest score for single uni/multivariate series, a single `metric` function and: + + - `historical_forecasts` generated with `last_points_only=True` + - `historical_forecasts` generated with `last_points_only=False` and using a backtest `reduction` + np.ndarray + An numpy array of backtest scores. For single series and one of: + + - a single `metric` function, `historical_forecasts` generated with `last_points_only=False` + and backtest `reduction=None`. The output has shape (n forecasts, *). + - multiple `metric` functions and `historical_forecasts` generated with `last_points_only=False`. + The output has shape (*, n metrics) when using a backtest `reduction`, and (n forecasts, *, n metrics) + when `reduction=None` + - multiple uni/multivariate series including `series_reduction` and at least one of + `component_reduction=None` or `time_reduction=None` for "per time step metrics" + List[float] + Same as for type `float` but for a sequence of series. The returned metric list has length + `len(series)` with the `float` metric for each input `series`. + List[np.ndarray] + Same as for type `np.ndarray` but for a sequence of series. The returned metric list has length + `len(series)` with the `np.ndarray` metrics for each input `series`. + """ + historical_forecasts = historical_forecasts or self.historical_forecasts( + series=series, + past_covariates=past_covariates, + future_covariates=future_covariates, + cal_series=cal_series, + cal_past_covariates=cal_past_covariates, + cal_future_covariates=cal_future_covariates, + num_samples=num_samples, + train_length=train_length, + start=start, + start_format=start_format, + forecast_horizon=forecast_horizon, + stride=stride, + retrain=retrain, + last_points_only=last_points_only, + verbose=verbose, + show_warnings=show_warnings, + predict_likelihood_parameters=predict_likelihood_parameters, + enable_optimization=enable_optimization, + fit_kwargs=fit_kwargs, + predict_kwargs=predict_kwargs, + overlap_end=overlap_end, + sample_weight=sample_weight, + ) + return super().backtest( + series=series, + historical_forecasts=historical_forecasts, + forecast_horizon=forecast_horizon, + num_samples=num_samples, + train_length=train_length, + start=start, + start_format=start_format, + stride=stride, + retrain=retrain, + overlap_end=overlap_end, + last_points_only=last_points_only, + metric=metric, + reduction=reduction, + verbose=verbose, + show_warnings=show_warnings, + predict_likelihood_parameters=predict_likelihood_parameters, + enable_optimization=enable_optimization, + metric_kwargs=metric_kwargs, + fit_kwargs=fit_kwargs, + predict_kwargs=predict_kwargs, + sample_weight=sample_weight, + ) + + def residuals( + self, + series: Union[TimeSeries, Sequence[TimeSeries]], + past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + cal_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + cal_past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + cal_future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + historical_forecasts: Optional[ + Union[TimeSeries, Sequence[TimeSeries], Sequence[Sequence[TimeSeries]]] + ] = None, + forecast_horizon: int = 1, + num_samples: int = 1, + train_length: Optional[int] = None, + start: Optional[Union[pd.Timestamp, float, int]] = None, + start_format: Literal["position", "value"] = "value", + stride: int = 1, + retrain: Union[bool, int, Callable[..., bool]] = True, + overlap_end: bool = False, + last_points_only: bool = True, + metric: METRIC_TYPE = metrics.err, + verbose: bool = False, + show_warnings: bool = True, + predict_likelihood_parameters: bool = False, + enable_optimization: bool = True, + metric_kwargs: Optional[Dict[str, Any]] = None, + fit_kwargs: Optional[Dict[str, Any]] = None, + predict_kwargs: Optional[Dict[str, Any]] = None, + sample_weight: Optional[Union[TimeSeries, Sequence[TimeSeries], str]] = None, + values_only: bool = False, + ) -> Union[TimeSeries, List[TimeSeries], List[List[TimeSeries]]]: + """Compute the residuals that the model produced for historical forecasts on (potentially multiple) `series`. + + This function computes the difference (or one of Darts' "per time step" metrics) between the actual + observations from `series` and the fitted values obtained by training the model on `series` (or using a + pre-trained model with `retrain=False`). Not all models support fitted values, so we use historical forecasts + as an approximation for them. + + In sequence this method performs: + + - use pre-computed `historical_forecasts` or compute historical forecasts for each series (see + :meth:`~darts.models.forecasting.conformal_models.ConformalModel.historical_forecasts` for more details). + How the historical forecasts are generated can be configured with parameters `num_samples`, `train_length`, + `start`, `start_format`, `forecast_horizon`, `stride`, `retrain`, `last_points_only`, `fit_kwargs`, and + `predict_kwargs`. + - compute a backtest using a "per time step" `metric` between the historical forecasts and `series` per + component/column and time step (see + :meth:`~darts.models.forecasting.conformal_models.ConformalModel.backtest` for more details). By default, + uses the residuals :func:`~darts.metrics.metrics.err` (error) as a `metric`. + - create and return `TimeSeries` (or simply a np.ndarray with `values_only=True`) with the time index from + historical forecasts, and values from the metrics per component and time step. + + This method works for single or multiple univariate or multivariate series. + It uses the median prediction (when dealing with stochastic forecasts). + + Notes + ----- + Darts has several metrics to evaluate probabilistic forecasts. For conformal models, we recommend using + "per time step" quantile interval metrics (see `here + `_). You can specify which intervals to + evaluate by setting `metric_kwargs={'q_interval': my_intervals}`. To check all intervals used by your conformal + model `my_model`, you can set ``{'q_interval': my_model.q_interval}``. + + Parameters + ---------- + series + A (sequence of) target time series used to successively compute the historical forecasts. If `cal_series` + is `None`, will use the past of this series for calibration. + past_covariates + Optionally, a (sequence of) past-observed covariate time series for every input time series in `series`. + Their dimension must match that of the past covariates used for training. If `cal_series` is `None`, will + use this series for calibration. + future_covariates + Optionally, a (sequence of) future-known covariate time series for every input time series in `series`. + Their dimension must match that of the past covariates used for training. If `cal_series` is `None`, will + use this series for calibration. + cal_series + Optionally, a (sequence of) target series for every input time series in `series` to use as a fixed + calibration set instead of `series`. + cal_past_covariates + Optionally, a (sequence of) past covariates series for every input time series in `series` to use as a fixed + calibration set instead of `past_covariates`. + cal_future_covariates + Optionally, a future covariates series for every input time series in `series` to use as a fixed + calibration set instead of `future_covariates`. + historical_forecasts + Optionally, the (or a sequence of / a sequence of sequences of) historical forecasts time series to be + evaluated. Corresponds to the output of :meth:`historical_forecasts() + `. The same `series` and + `last_points_only` values must be passed that were used to generate the historical forecasts. If provided, + will skip historical forecasting and ignore all parameters except `series`, `last_points_only`, `metric`, + and `reduction`. + forecast_horizon + The forecast horizon for the predictions. + num_samples + Number of times a prediction is sampled from the calibrated quantile predictions using linear + interpolation in-between the quantiles. For larger values, the sample distribution approximates the + calibrated quantile predictions. + train_length + Currently ignored by conformal models. + start + Optionally, the first point in time at which a prediction is computed. This parameter supports: + ``float``, ``int``, ``pandas.Timestamp``, and ``None``. + If a ``float``, it is the proportion of the time series that should lie before the first prediction point. + If an ``int``, it is either the index position of the first prediction point for `series` with a + `pd.DatetimeIndex`, or the index value for `series` with a `pd.RangeIndex`. The latter can be changed to + the index position with `start_format="position"`. + If a ``pandas.Timestamp``, it is the time stamp of the first prediction point. + If ``None``, the first prediction point will automatically be set to: + + - the first predictable point if `retrain` is ``False``, or `retrain` is a Callable and the first + predictable point is earlier than the first trainable point. + - the first trainable point if `retrain` is ``True`` or ``int`` (given `train_length`), + or `retrain` is a ``Callable`` and the first trainable point is earlier than the first predictable point. + - the first trainable point (given `train_length`) otherwise + + Note: If the model uses a shifted output (`output_chunk_shift > 0`), then the first predicted point is also + shifted by `output_chunk_shift` points into the future. + Note: Raises a ValueError if `start` yields a time outside the time index of `series`. + Note: If `start` is outside the possible historical forecasting times, will ignore the parameter + (default behavior with ``None``) and start at the first trainable/predictable point. + start_format + Defines the `start` format. + If set to ``'position'``, `start` corresponds to the index position of the first predicted point and can + range from `(-len(series), len(series) - 1)`. + If set to ``'value'``, `start` corresponds to the index value/label of the first predicted point. Will raise + an error if the value is not in `series`' index. Default: ``'value'``. + stride + The number of time steps between two consecutive predictions. + retrain + Currently ignored by conformal models. + overlap_end + Whether the returned forecasts can go beyond the series' end or not. + last_points_only + Whether to return only the last point of each historical forecast. If set to ``True``, the method returns a + single ``TimeSeries`` (for each time series in `series`) containing the successive point forecasts. + Otherwise, returns a list of historical ``TimeSeries`` forecasts. + metric + Either one of Darts' "per time step" metrics (see `here + `_), or a custom metric that has an + identical signature as Darts' "per time step" metrics, uses decorators + :func:`~darts.metrics.metrics.multi_ts_support` and :func:`~darts.metrics.metrics.multi_ts_support`, + and returns one value per time step. + verbose + Whether to print the progress. + show_warnings + Whether to show warnings related to historical forecasts optimization, or parameters `start` and + `train_length`. + predict_likelihood_parameters + If set to `True`, generates the quantile predictions directly. Only supported with `num_samples = 1`. + enable_optimization + Whether to use the optimized version of `historical_forecasts` when supported and available. + Default: ``True``. + metric_kwargs + Additional arguments passed to `metric()`, such as `'n_jobs'` for parallelization, `'m'` for scaled + metrics, etc. Will pass arguments only if they are present in the corresponding metric signature. Ignores + reduction arguments `"series_reduction", "component_reduction", "time_reduction"`, and parameter + `'insample'` for scaled metrics (e.g. mase`, `rmsse`, ...), as they are handled internally. + fit_kwargs + Currently ignored by conformal models. + predict_kwargs + Optionally, some additional arguments passed to the model `predict()` method. + sample_weight + Currently ignored by conformal models. + values_only + Whether to return the residuals as `np.ndarray`. If `False`, returns residuals as `TimeSeries`. + + Returns + ------- + TimeSeries + Residual `TimeSeries` for a single `series` and `historical_forecasts` generated with + `last_points_only=True`. + List[TimeSeries] + A list of residual `TimeSeries` for a sequence (list) of `series` with `last_points_only=True`. + The residual list has length `len(series)`. + List[List[TimeSeries]] + A list of lists of residual `TimeSeries` for a sequence of `series` with `last_points_only=False`. + The outer residual list has length `len(series)`. The inner lists consist of the residuals from + all possible series-specific historical forecasts. + """ + historical_forecasts = historical_forecasts or self.historical_forecasts( + series=series, + past_covariates=past_covariates, + future_covariates=future_covariates, + cal_series=cal_series, + cal_past_covariates=cal_past_covariates, + cal_future_covariates=cal_future_covariates, + num_samples=num_samples, + train_length=train_length, + start=start, + start_format=start_format, + forecast_horizon=forecast_horizon, + stride=stride, + retrain=retrain, + last_points_only=last_points_only, + verbose=verbose, + show_warnings=show_warnings, + predict_likelihood_parameters=predict_likelihood_parameters, + enable_optimization=enable_optimization, + fit_kwargs=fit_kwargs, + predict_kwargs=predict_kwargs, + overlap_end=overlap_end, + sample_weight=sample_weight, + ) + return super().residuals( + series=series, + historical_forecasts=historical_forecasts, + forecast_horizon=forecast_horizon, + num_samples=num_samples, + train_length=train_length, + start=start, + start_format=start_format, + stride=stride, + retrain=retrain, + overlap_end=overlap_end, + last_points_only=last_points_only, + metric=metric, + verbose=verbose, + show_warnings=show_warnings, + predict_likelihood_parameters=predict_likelihood_parameters, + enable_optimization=enable_optimization, + metric_kwargs=metric_kwargs, + fit_kwargs=fit_kwargs, + predict_kwargs=predict_kwargs, + sample_weight=sample_weight, + values_only=values_only, + ) + @random_method def _calibrate_forecasts( self, @@ -409,9 +1103,26 @@ def _calibrate_forecasts( show_warnings: bool = True, predict_likelihood_parameters: bool = False, ) -> Union[TimeSeries, List[TimeSeries], List[List[TimeSeries]]]: - # TODO: add support for: - # - num_samples - # - predict_likelihood_parameters + """Generate calibrated historical forecasts. + + In general the workflow of the models to produce one calibrated forecast/prediction per step in the horizon + is as follows: + + - Generate historical forecasts for `series` and optional calibration set (`cal_series`) (using the forecasting + model) + - Extract a calibration set: The forecasts from the most recent past to use as calibration + for one conformal prediction. The number of examples to use can be defined at model creation with parameter + `cal_length`. We support two modes: + - Automatic extraction of the calibration set from the past of your input series (`series`, + `past_covariates`, ...). This is the default mode and our predict/forecasting/backtest/.... API is + identical to any other forecasting model + - Supply a fixed calibration set with parameters `cal_series`, `cal_past_covariates`, ... . + - Compute the errors/non-conformity scores (specific to each conformal model) on these historical forecasts + - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model + creation with parameter `quantiles`). + - Compute the conformal prediction: Add the calibrated intervals to (or adjust the existing intervals of) the + forecasting model's predictions. + """ cal_length = self.cal_length metric, metric_kwargs = self._residuals_metric residuals = self.model.residuals( @@ -843,7 +1554,7 @@ def supports_static_covariates(self) -> bool: @property def supports_sample_weight(self) -> bool: - return False + return self.model.supports_sample_weight @property def supports_likelihood_parameter_prediction(self) -> bool: diff --git a/darts/models/forecasting/forecasting_model.py b/darts/models/forecasting/forecasting_model.py index 4d1690ea73..35dbf68b00 100644 --- a/darts/models/forecasting/forecasting_model.py +++ b/darts/models/forecasting/forecasting_model.py @@ -333,8 +333,7 @@ def predict( n Forecast horizon - the number of time steps after the end of the series for which to produce predictions. num_samples - Number of times a prediction is sampled from a probabilistic model. Should be left set to 1 - for deterministic models. + Number of times a prediction is sampled from a probabilistic model. Must be `1` for deterministic models. verbose Optionally, set the prediction verbosity. Not effective for all models. show_warnings @@ -643,11 +642,11 @@ def historical_forecasts( series: Union[TimeSeries, Sequence[TimeSeries]], past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + forecast_horizon: int = 1, num_samples: int = 1, train_length: Optional[int] = None, start: Optional[Union[pd.Timestamp, float, int]] = None, start_format: Literal["position", "value"] = "value", - forecast_horizon: int = 1, stride: int = 1, retrain: Union[bool, int, Callable[..., bool]] = True, overlap_end: bool = False, @@ -660,42 +659,60 @@ def historical_forecasts( predict_kwargs: Optional[Dict[str, Any]] = None, sample_weight: Optional[Union[TimeSeries, Sequence[TimeSeries], str]] = None, ) -> Union[TimeSeries, List[TimeSeries], List[List[TimeSeries]]]: - """Compute the historical forecasts that would have been obtained by this model on - (potentially multiple) `series`. - - This method repeatedly builds a training set: either expanding from the beginning of `series` or moving with - a fixed length `train_length`. It trains the model on the training set, emits a forecast of length equal to - forecast_horizon, and then moves the end of the training set forward by `stride` time steps. - - By default, this method will return one (or a sequence of) single time series made up of - the last point of each historical forecast. - This time series will thus have a frequency of ``series.freq * stride``. - If `last_points_only` is set to `False`, it will instead return one (or a sequence of) list of the - historical forecasts series. - - By default, this method always re-trains the models on the entire available history, corresponding to an - expanding window strategy. If `retrain` is set to `False`, the model must have been fit before. This is not - supported by all models. + """Generates historical forecasts by simulating predictions at various points in time throughout the history of + the provided (potentially multiple) `series`. This process involves retrospectively applying the model to + different time steps, as if the forecasts were made in real-time at those specific moments. This allows for an + evaluation of the model's performance over the entire duration of the series, providing insights into its + predictive accuracy and robustness across different historical periods. + + There are two main modes for this method: + + - Re-training Mode (Default, `retrain=True`): The model is re-trained at each step of the simulation, and + generates a forecast using the updated model. + - Pre-trained Mode (`retrain=False`): The forecasts are generated at each step of the simulation without + re-training. It is only supported for pre-trained global forecasting models. This mode is significantly + faster as it skips the re-training step. + + By choosing the appropriate mode, you can balance between computational efficiency and the need for up-to-date + model training. + + **Re-training Mode:** This mode repeatedly builds a training set by either expanding from the beginning of + the `series` or by using a fixed-length `train_length` (the start point can also be configured with `start` + and `start_format`). The model is then trained on this training set, and a forecast of length `forecast_horizon` + is generated. Subsequently, the end of the training set is moved forward by `stride` time steps, and the process + is repeated. + + **Pre-trained Mode:** This mode is only supported for pre-trained global forecasting models. It uses the same + simulation steps as in the *Re-training Mode* (ignoring `train_length`), but generates the forecasts directly + without re-training. + + By default, with `last_points_only=True`, this method returns a single time series (or a sequence of time + series) composed of the last point from each historical forecast. This time series will thus have a frequency of + `series.freq * stride`. + If `last_points_only=False`, it will instead return a list (or a sequence of lists) of the full historical + forecast series each with frequency `series.freq`. Parameters ---------- series - The (or a sequence of) target time series used to successively train and compute the historical forecasts. + A (sequence of) target time series used to successively train (if `retrain` is not ``False``) and compute + the historical forecasts. past_covariates - Optionally, one (or a sequence of) past-observed covariate series. This applies only if the model - supports past covariates. + Optionally, a (sequence of) past-observed covariate time series for every input time series in `series`. + This applies only if the model supports past covariates. future_covariates - Optionally, one (or a sequence of) of future-known covariate series. This applies only if the model - supports future covariates. + Optionally, a (sequence of) future-known covariate time series for every input time series in `series`. + This applies only if the model supports future covariates. + forecast_horizon + The forecast horizon for the predictions. num_samples - Number of times a prediction is sampled from a probabilistic model. Use values `>1` only for probabilistic + Number of times a prediction is sampled from a probabilistic model. Use values ``>1`` only for probabilistic models. train_length - Number of time steps in our training set (size of backtesting window to train on). Only effective when - `retrain` is not ``False``. Default is set to `train_length=None` where it takes all available time steps - up until prediction time, otherwise the moving window strategy is used. If larger than the number of time - steps available, all steps up until prediction time are used, as in default case. Needs to be at least - `min_train_series_length`. + Optionally, use a fixed length / number of time steps for every constructed training set (rolling window + mode). Only effective when `retrain` is not ``False``. The default is ``None``, where it uses all time + steps up until the prediction time (expanding window mode). If larger than the number of available time + steps, uses the expanding mode. Needs to be at least `min_train_series_length`. start Optionally, the first point in time at which a prediction is computed. This parameter supports: ``float``, ``int``, ``pandas.Timestamp``, and ``None``. @@ -709,7 +726,7 @@ def historical_forecasts( - the first predictable point if `retrain` is ``False``, or `retrain` is a Callable and the first predictable point is earlier than the first trainable point. - the first trainable point if `retrain` is ``True`` or ``int`` (given `train_length`), - or `retrain` is a Callable and the first trainable point is earlier than the first predictable point. + or `retrain` is a ``Callable`` and the first trainable point is earlier than the first predictable point. - the first trainable point (given `train_length`) otherwise Note: If the model uses a shifted output (`output_chunk_shift > 0`), then the first predicted point is also @@ -718,21 +735,18 @@ def historical_forecasts( Note: If `start` is outside the possible historical forecasting times, will ignore the parameter (default behavior with ``None``) and start at the first trainable/predictable point. start_format - Defines the `start` format. Only effective when `start` is an integer and `series` is indexed with a - `pd.RangeIndex`. - If set to 'position', `start` corresponds to the index position of the first predicted point and can range - from `(-len(series), len(series) - 1)`. - If set to 'value', `start` corresponds to the index value/label of the first predicted point. Will raise - an error if the value is not in `series`' index. Default: ``'value'`` - forecast_horizon - The forecast horizon for the predictions. + Defines the `start` format. + If set to ``'position'``, `start` corresponds to the index position of the first predicted point and can + range from `(-len(series), len(series) - 1)`. + If set to ``'value'``, `start` corresponds to the index value/label of the first predicted point. Will raise + an error if the value is not in `series`' index. Default: ``'value'``. stride The number of time steps between two consecutive predictions. retrain Whether and/or on which condition to retrain the model before predicting. - This parameter supports 3 different datatypes: ``bool``, (positive) ``int``, and - ``Callable`` (returning a ``bool``). - In the case of ``bool``: retrain the model at each step (`True`), or never retrains the model (`False`). + This parameter supports 3 different types: ``bool``, (positive) ``int``, and ``Callable`` (returning a + ``bool``). + In the case of ``bool``: retrain the model at each step (`True`), or never retrain the model (`False`). In the case of ``int``: the model is retrained every `retrain` iterations. In the case of ``Callable``: the model is retrained whenever callable returns `True`. The callable must have the following positional arguments: @@ -741,35 +755,35 @@ def historical_forecasts( - `pred_time` (pd.Timestamp or int): timestamp of forecast time (end of the training series) - `train_series` (TimeSeries): train series up to `pred_time` - `past_covariates` (TimeSeries): past_covariates series up to `pred_time` - - `future_covariates` (TimeSeries): future_covariates series up - to `min(pred_time + series.freq * forecast_horizon, series.end_time())` + - `future_covariates` (TimeSeries): future_covariates series up to `min(pred_time + series.freq * + forecast_horizon, series.end_time())` Note: if any optional `*_covariates` are not passed to `historical_forecast`, ``None`` will be passed to the corresponding retrain function argument. - Note: some models do require being retrained every time and do not support anything other - than `retrain=True`. + Note: some models require being retrained every time and do not support anything other than + `retrain=True`. overlap_end Whether the returned forecasts can go beyond the series' end or not. last_points_only - Whether to retain only the last point of each historical forecast. - If set to `True`, the method returns a single ``TimeSeries`` containing the successive point forecasts. + Whether to return only the last point of each historical forecast. If set to ``True``, the method returns a + single ``TimeSeries`` (for each time series in `series`) containing the successive point forecasts. Otherwise, returns a list of historical ``TimeSeries`` forecasts. verbose - Whether to print progress. + Whether to print the progress. show_warnings Whether to show warnings related to historical forecasts optimization, or parameters `start` and `train_length`. predict_likelihood_parameters - If set to `True`, the model predict the parameters of its Likelihood parameters instead of the target. Only + If set to `True`, the model predicts the parameters of its `likelihood` instead of the target. Only supported for probabilistic models with a likelihood, `num_samples = 1` and `n<=output_chunk_length`. - Default: ``False`` + Default: ``False``. enable_optimization - Whether to use the optimized version of historical_forecasts when supported and available. + Whether to use the optimized version of `historical_forecasts` when supported and available. Default: ``True``. fit_kwargs - Additional arguments passed to the model `fit()` method. + Optionally, some additional arguments passed to the model `fit()` method. predict_kwargs - Additional arguments passed to the model `predict()` method. + Optionally, some additional arguments passed to the model `predict()` method. sample_weight Optionally, some sample weights to apply to the target `series` labels for training. Only effective when `retrain` is not ``False``. They are applied per observation, per label (each step in @@ -1197,11 +1211,11 @@ def backtest( historical_forecasts: Optional[ Union[TimeSeries, Sequence[TimeSeries], Sequence[Sequence[TimeSeries]]] ] = None, + forecast_horizon: int = 1, num_samples: int = 1, train_length: Optional[int] = None, start: Optional[Union[pd.Timestamp, float, int]] = None, start_format: Literal["position", "value"] = "value", - forecast_horizon: int = 1, stride: int = 1, retrain: Union[bool, int, Callable[..., bool]] = True, overlap_end: bool = False, @@ -1217,51 +1231,49 @@ def backtest( predict_kwargs: Optional[Dict[str, Any]] = None, sample_weight: Optional[Union[TimeSeries, Sequence[TimeSeries], str]] = None, ) -> Union[float, np.ndarray, List[float], List[np.ndarray]]: - """Compute error values that the model would have produced when - used on (potentially multiple) `series`. + """Compute error values that the model produced for historical forecasts on (potentially multiple) `series`. - If `historical_forecasts` are provided, the metric (given by the `metric` function) is evaluated directly on - the forecast and the actual values. The same `series` must be passed that was used to generate the historical - forecasts. Otherwise, it repeatedly builds a training set: either expanding from the - beginning of `series` or moving with a fixed length `train_length`. It trains the current model on the - training set, emits a forecast of length equal to `forecast_horizon`, and then moves the end of the training - set forward by `stride` time steps. The metric is then evaluated on the forecast and the actual values. - Finally, the method returns a `reduction` (the mean by default) of all these metric scores. + If `historical_forecasts` are provided, the metric(s) (given by the `metric` function) is evaluated directly on + all forecasts and actual values. The same `series` and `last_points_only` value must be passed that were used + to generate the historical forecasts. Finally, the method returns an optional `reduction` (the mean by default) + of all these metric scores. - By default, this method uses each historical forecast (whole) to compute error scores. - If `last_points_only` is set to `True`, it will use only the last point of each historical - forecast. In this case, no reduction is used. + If `historical_forecasts` is ``None``, it first generates the historical forecasts with the parameters given + below (see :meth:`ForecastingModel.historical_forecasts() + ` for more info) and then + evaluates as described above. - By default, this method always re-trains the models on the entire available history, corresponding to an - expanding window strategy. If `retrain` is set to `False` (useful for models for which training might be - time-consuming, such as deep learning models), the trained model will be used directly to emit the forecasts. + The metric(s) can be further customized `metric_kwargs` (e.g. control the aggregation over components, time + steps, multiple series, other required arguments such as `q` for quantile metrics, ...). Parameters ---------- series - The (or a sequence of) target time series used to successively train and evaluate the historical forecasts. + A (sequence of) target time series used to successively train (if `retrain` is not ``False``) and compute + the historical forecasts. past_covariates - Optionally, one (or a sequence of) past-observed covariate series. This applies only if the model - supports past covariates. + Optionally, a (sequence of) past-observed covariate time series for every input time series in `series`. + This applies only if the model supports past covariates. future_covariates - Optionally, one (or a sequence of) future-known covariate series. This applies only if the model - supports future covariates. + Optionally, a (sequence of) future-known covariate time series for every input time series in `series`. + This applies only if the model supports future covariates. historical_forecasts Optionally, the (or a sequence of / a sequence of sequences of) historical forecasts time series to be evaluated. Corresponds to the output of :meth:`historical_forecasts() `. The same `series` and - `last_points_only` values must be passed that were used to generate the historical forecasts. - If provided, will skip historical forecasting and ignore all parameters except `series`, - `last_points_only`, `metric`, and `reduction`. + `last_points_only` values must be passed that were used to generate the historical forecasts. If provided, + will skip historical forecasting and ignore all parameters except `series`, `last_points_only`, `metric`, + and `reduction`. + forecast_horizon + The forecast horizon for the predictions. num_samples - Number of times a prediction is sampled from a probabilistic model. Use values `>1` only for probabilistic + Number of times a prediction is sampled from a probabilistic model. Use values ``>1`` only for probabilistic models. train_length - Number of time steps in our training set (size of backtesting window to train on). Only effective when - `retrain` is not ``False``. Default is set to `train_length=None` where it takes all available time steps - up until prediction time, otherwise the moving window strategy is used. If larger than the number of time - steps available, all steps up until prediction time are used, as in default case. Needs to be at least - `min_train_series_length`. + Optionally, use a fixed length / number of time steps for every constructed training set (rolling window + mode). Only effective when `retrain` is not ``False``. The default is ``None``, where it uses all time + steps up until the prediction time (expanding window mode). If larger than the number of available time + steps, uses the expanding mode. Needs to be at least `min_train_series_length`. start Optionally, the first point in time at which a prediction is computed. This parameter supports: ``float``, ``int``, ``pandas.Timestamp``, and ``None``. @@ -1275,47 +1287,48 @@ def backtest( - the first predictable point if `retrain` is ``False``, or `retrain` is a Callable and the first predictable point is earlier than the first trainable point. - the first trainable point if `retrain` is ``True`` or ``int`` (given `train_length`), - or `retrain` is a Callable and the first trainable point is earlier than the first predictable point. + or `retrain` is a ``Callable`` and the first trainable point is earlier than the first predictable point. - the first trainable point (given `train_length`) otherwise + Note: If the model uses a shifted output (`output_chunk_shift > 0`), then the first predicted point is also + shifted by `output_chunk_shift` points into the future. Note: Raises a ValueError if `start` yields a time outside the time index of `series`. Note: If `start` is outside the possible historical forecasting times, will ignore the parameter (default behavior with ``None``) and start at the first trainable/predictable point. start_format - Defines the `start` format. Only effective when `start` is an integer and `series` is indexed with a - `pd.RangeIndex`. - If set to 'position', `start` corresponds to the index position of the first predicted point and can range - from `(-len(series), len(series) - 1)`. - If set to 'value', `start` corresponds to the index value/label of the first predicted point. Will raise - an error if the value is not in `series`' index. Default: ``'value'`` - forecast_horizon - The forecast horizon for the point predictions. + Defines the `start` format. + If set to ``'position'``, `start` corresponds to the index position of the first predicted point and can + range from `(-len(series), len(series) - 1)`. + If set to ``'value'``, `start` corresponds to the index value/label of the first predicted point. Will raise + an error if the value is not in `series`' index. Default: ``'value'``. stride The number of time steps between two consecutive predictions. retrain Whether and/or on which condition to retrain the model before predicting. - This parameter supports 3 different datatypes: ``bool``, (positive) ``int``, and - ``Callable`` (returning a ``bool``). - In the case of ``bool``: retrain the model at each step (`True`), or never retrains the model (`False`). + This parameter supports 3 different types: ``bool``, (positive) ``int``, and ``Callable`` (returning a + ``bool``). + In the case of ``bool``: retrain the model at each step (`True`), or never retrain the model (`False`). In the case of ``int``: the model is retrained every `retrain` iterations. In the case of ``Callable``: the model is retrained whenever callable returns `True`. The callable must have the following positional arguments: - - `counter` (int): current `retrain` iteration - - `pred_time` (pd.Timestamp or int): timestamp of forecast time (end of the training series) - - `train_series` (TimeSeries): train series up to `pred_time` - - `past_covariates` (TimeSeries): past_covariates series up to `pred_time` - - `future_covariates` (TimeSeries): future_covariates series up - to `min(pred_time + series.freq * forecast_horizon, series.end_time())` + - `counter` (int): current `retrain` iteration + - `pred_time` (pd.Timestamp or int): timestamp of forecast time (end of the training series) + - `train_series` (TimeSeries): train series up to `pred_time` + - `past_covariates` (TimeSeries): past_covariates series up to `pred_time` + - `future_covariates` (TimeSeries): future_covariates series up to `min(pred_time + series.freq * + forecast_horizon, series.end_time())` Note: if any optional `*_covariates` are not passed to `historical_forecast`, ``None`` will be passed to the corresponding retrain function argument. - Note: some models do require being retrained every time and do not support anything other - than `retrain=True`. + Note: some models require being retrained every time and do not support anything other than + `retrain=True`. overlap_end Whether the returned forecasts can go beyond the series' end or not. last_points_only - Whether to use the whole historical forecasts or only the last point of each forecast to compute the error. + Whether to return only the last point of each historical forecast. If set to ``True``, the method returns a + single ``TimeSeries`` (for each time series in `series`) containing the successive point forecasts. + Otherwise, returns a list of historical ``TimeSeries`` forecasts. metric A metric function or a list of metric functions. Each metric must either be a Darts metric (see `here `_), or a custom metric that has an @@ -1328,15 +1341,16 @@ def backtest( If explicitly set to `None`, the method will return a list of the individual error scores instead. Set to ``np.mean`` by default. verbose - Whether to print progress. + Whether to print the progress. show_warnings - Whether to show warnings related to parameters `start`, and `train_length`. + Whether to show warnings related to historical forecasts optimization, or parameters `start` and + `train_length`. predict_likelihood_parameters - If set to `True`, the model predict the parameters of its Likelihood parameters instead of the target. Only - supported for probabilistic models with `likelihood="quantile"`, `num_samples = 1` and - `n<=output_chunk_length`. Default: ``False``. + If set to `True`, the model predicts the parameters of its `likelihood` instead of the target. Only + supported for probabilistic models with a likelihood, `num_samples = 1` and `n<=output_chunk_length`. + Default: ``False``. enable_optimization - Whether to use the optimized version of historical_forecasts when supported and available. + Whether to use the optimized version of `historical_forecasts` when supported and available. Default: ``True``. metric_kwargs Additional arguments passed to `metric()`, such as `'n_jobs'` for parallelization, `'component_reduction'` @@ -1344,9 +1358,9 @@ def backtest( each metric separately and only if they are present in the corresponding metric signature. Parameter `'insample'` for scaled metrics (e.g. mase`, `rmsse`, ...) is ignored, as it is handled internally. fit_kwargs - Additional arguments passed to the model `fit()` method. + Optionally, some additional arguments passed to the model `fit()` method. predict_kwargs - Additional arguments passed to the model `predict()` method. + Optionally, some additional arguments passed to the model `predict()` method. sample_weight Optionally, some sample weights to apply to the target `series` labels for training. Only effective when `retrain` is not ``False``. They are applied per observation, per label (each step in @@ -1624,7 +1638,7 @@ def gridsearch( A reduction function (mapping array to float) describing how to aggregate the errors obtained on the different validation series when backtesting. By default it'll compute the mean of errors. verbose - Whether to print progress. + Whether to print the progress. n_jobs The number of jobs to run in parallel. Parallel jobs are created only when there are two or more parameters combinations to evaluate. Each job will instantiate, train, and evaluate a different instance of the model. @@ -1808,11 +1822,11 @@ def residuals( historical_forecasts: Optional[ Union[TimeSeries, Sequence[TimeSeries], Sequence[Sequence[TimeSeries]]] ] = None, + forecast_horizon: int = 1, num_samples: int = 1, train_length: Optional[int] = None, start: Optional[Union[pd.Timestamp, float, int]] = None, start_format: Literal["position", "value"] = "value", - forecast_horizon: int = 1, stride: int = 1, retrain: Union[bool, int, Callable[..., bool]] = True, overlap_end: bool = False, @@ -1825,10 +1839,10 @@ def residuals( metric_kwargs: Optional[Dict[str, Any]] = None, fit_kwargs: Optional[Dict[str, Any]] = None, predict_kwargs: Optional[Dict[str, Any]] = None, - values_only: bool = False, sample_weight: Optional[Union[TimeSeries, Sequence[TimeSeries], str]] = None, + values_only: bool = False, ) -> Union[TimeSeries, List[TimeSeries], List[List[TimeSeries]]]: - """Compute the residuals produced by this model on a (or sequence of) `TimeSeries`. + """Compute the residuals that the model produced for historical forecasts on (potentially multiple) `series`. This function computes the difference (or one of Darts' "per time step" metrics) between the actual observations from `series` and the fitted values obtained by training the model on `series` (or using a @@ -1837,7 +1851,7 @@ def residuals( In sequence this method performs: - - compute historical forecasts for each series or use pre-computed `historical_forecasts` (see + - use pre-computed `historical_forecasts` or compute historical forecasts for each series (see :meth:`~darts.models.forecasting.forecasting_model.ForecastingModel.historical_forecasts` for more details). How the historical forecasts are generated can be configured with parameters `num_samples`, `train_length`, `start`, `start_format`, `forecast_horizon`, `stride`, `retrain`, `last_points_only`, `fit_kwargs`, and @@ -1845,7 +1859,7 @@ def residuals( - compute a backtest using a "per time step" `metric` between the historical forecasts and `series` per component/column and time step (see :meth:`~darts.models.forecasting.forecasting_model.ForecastingModel.backtest` for more details). By default, - uses the residuals :func:`~darts.metrics.metrics.err` as a `metric`. + uses the residuals :func:`~darts.metrics.metrics.err` (error) as a `metric`. - create and return `TimeSeries` (or simply a np.ndarray with `values_only=True`) with the time index from historical forecasts, and values from the metrics per component and time step. @@ -1855,13 +1869,14 @@ def residuals( Parameters ---------- series - The univariate TimeSeries instance which the residuals will be computed for. + A (sequence of) target time series used to successively train (if `retrain` is not ``False``) and compute + the historical forecasts. past_covariates - One or several past-observed covariate time series. + Optionally, a (sequence of) past-observed covariate time series for every input time series in `series`. + This applies only if the model supports past covariates. future_covariates - One or several future-known covariate time series. - forecast_horizon - The forecasting horizon used to predict each fitted value. + Optionally, a (sequence of) future-known covariate time series for every input time series in `series`. + This applies only if the model supports future covariates. historical_forecasts Optionally, the (or a sequence of / a sequence of sequences of) historical forecasts time series to be evaluated. Corresponds to the output of :meth:`historical_forecasts() @@ -1869,15 +1884,16 @@ def residuals( `last_points_only` values must be passed that were used to generate the historical forecasts. If provided, will skip historical forecasting and ignore all parameters except `series`, `last_points_only`, `metric`, and `reduction`. + forecast_horizon + The forecast horizon for the predictions. num_samples - Number of times a prediction is sampled from a probabilistic model. Use values `>1` only for probabilistic + Number of times a prediction is sampled from a probabilistic model. Use values ``>1`` only for probabilistic models. train_length - Number of time steps in our training set (size of backtesting window to train on). Only effective when - `retrain` is not ``False``. Default is set to `train_length=None` where it takes all available time steps - up until prediction time, otherwise the moving window strategy is used. If larger than the number of time - steps available, all steps up until prediction time are used, as in default case. Needs to be at least - `min_train_series_length`. + Optionally, use a fixed length / number of time steps for every constructed training set (rolling window + mode). Only effective when `retrain` is not ``False``. The default is ``None``, where it uses all time + steps up until the prediction time (expanding window mode). If larger than the number of available time + steps, uses the expanding mode. Needs to be at least `min_train_series_length`. start Optionally, the first point in time at which a prediction is computed. This parameter supports: ``float``, ``int``, ``pandas.Timestamp``, and ``None``. @@ -1891,47 +1907,48 @@ def residuals( - the first predictable point if `retrain` is ``False``, or `retrain` is a Callable and the first predictable point is earlier than the first trainable point. - the first trainable point if `retrain` is ``True`` or ``int`` (given `train_length`), - or `retrain` is a Callable and the first trainable point is earlier than the first predictable point. + or `retrain` is a ``Callable`` and the first trainable point is earlier than the first predictable point. - the first trainable point (given `train_length`) otherwise + Note: If the model uses a shifted output (`output_chunk_shift > 0`), then the first predicted point is also + shifted by `output_chunk_shift` points into the future. Note: Raises a ValueError if `start` yields a time outside the time index of `series`. Note: If `start` is outside the possible historical forecasting times, will ignore the parameter (default behavior with ``None``) and start at the first trainable/predictable point. start_format - Defines the `start` format. Only effective when `start` is an integer and `series` is indexed with a - `pd.RangeIndex`. - If set to 'position', `start` corresponds to the index position of the first predicted point and can range - from `(-len(series), len(series) - 1)`. - If set to 'value', `start` corresponds to the index value/label of the first predicted point. Will raise - an error if the value is not in `series`' index. Default: ``'value'`` - forecast_horizon - The forecast horizon for the point predictions. + Defines the `start` format. + If set to ``'position'``, `start` corresponds to the index position of the first predicted point and can + range from `(-len(series), len(series) - 1)`. + If set to ``'value'``, `start` corresponds to the index value/label of the first predicted point. Will raise + an error if the value is not in `series`' index. Default: ``'value'``. stride The number of time steps between two consecutive predictions. retrain Whether and/or on which condition to retrain the model before predicting. - This parameter supports 3 different datatypes: ``bool``, (positive) ``int``, and - ``Callable`` (returning a ``bool``). - In the case of ``bool``: retrain the model at each step (`True`), or never retrains the model (`False`). + This parameter supports 3 different types: ``bool``, (positive) ``int``, and ``Callable`` (returning a + ``bool``). + In the case of ``bool``: retrain the model at each step (`True`), or never retrain the model (`False`). In the case of ``int``: the model is retrained every `retrain` iterations. In the case of ``Callable``: the model is retrained whenever callable returns `True`. The callable must have the following positional arguments: - - `counter` (int): current `retrain` iteration - - `pred_time` (pd.Timestamp or int): timestamp of forecast time (end of the training series) - - `train_series` (TimeSeries): train series up to `pred_time` - - `past_covariates` (TimeSeries): past_covariates series up to `pred_time` - - `future_covariates` (TimeSeries): future_covariates series up - to `min(pred_time + series.freq * forecast_horizon, series.end_time())` + - `counter` (int): current `retrain` iteration + - `pred_time` (pd.Timestamp or int): timestamp of forecast time (end of the training series) + - `train_series` (TimeSeries): train series up to `pred_time` + - `past_covariates` (TimeSeries): past_covariates series up to `pred_time` + - `future_covariates` (TimeSeries): future_covariates series up to `min(pred_time + series.freq * + forecast_horizon, series.end_time())` Note: if any optional `*_covariates` are not passed to `historical_forecast`, ``None`` will be passed to the corresponding retrain function argument. - Note: some models do require being retrained every time and do not support anything other - than `retrain=True`. + Note: some models require being retrained every time and do not support anything other than + `retrain=True`. overlap_end Whether the returned forecasts can go beyond the series' end or not. last_points_only - Whether to use the whole historical forecasts or only the last point of each forecast to compute the error. + Whether to return only the last point of each historical forecast. If set to ``True``, the method returns a + single ``TimeSeries`` (for each time series in `series`) containing the successive point forecasts. + Otherwise, returns a list of historical ``TimeSeries`` forecasts. metric Either one of Darts' "per time step" metrics (see `here `_), or a custom metric that has an @@ -1939,15 +1956,16 @@ def residuals( :func:`~darts.metrics.metrics.multi_ts_support` and :func:`~darts.metrics.metrics.multi_ts_support`, and returns one value per time step. verbose - Whether to print progress. + Whether to print the progress. show_warnings - Whether to show warnings related to parameters `start`, and `train_length`. + Whether to show warnings related to historical forecasts optimization, or parameters `start` and + `train_length`. predict_likelihood_parameters - If set to `True`, the model predict the parameters of its Likelihood parameters instead of the target. Only - supported for probabilistic models with `likelihood="quantile"`, `num_samples = 1` and - `n<=output_chunk_length`. Default: ``False``. + If set to `True`, the model predicts the parameters of its `likelihood` instead of the target. Only + supported for probabilistic models with a likelihood, `num_samples = 1` and `n<=output_chunk_length`. + Default: ``False``. enable_optimization - Whether to use the optimized version of historical_forecasts when supported and available. + Whether to use the optimized version of `historical_forecasts` when supported and available. Default: ``True``. metric_kwargs Additional arguments passed to `metric()`, such as `'n_jobs'` for parallelization, `'m'` for scaled @@ -1955,11 +1973,9 @@ def residuals( reduction arguments `"series_reduction", "component_reduction", "time_reduction"`, and parameter `'insample'` for scaled metrics (e.g. mase`, `rmsse`, ...), as they are handled internally. fit_kwargs - Additional arguments passed to the model `fit()` method. + Optionally, some additional arguments passed to the model `fit()` method. predict_kwargs - Additional arguments passed to the model `predict()` method. - values_only - Whether to return the residuals as `np.ndarray`. If `False`, returns residuals as `TimeSeries`. + Optionally, some additional arguments passed to the model `predict()` method. sample_weight Optionally, some sample weights to apply to the target `series` labels for training. Only effective when `retrain` is not ``False``. They are applied per observation, per label (each step in @@ -1970,6 +1986,8 @@ def residuals( If a string, then the weights are generated using built-in weighting functions. The available options are `"linear"` or `"exponential"` decay - the further in the past, the lower the weight. The weights are computed per time `series`. + values_only + Whether to return the residuals as `np.ndarray`. If `False`, returns residuals as `TimeSeries`. Returns ------- @@ -2801,12 +2819,11 @@ def predict( One future-known covariate time series for every input time series in `series`. They must match the past covariates that have been used with the :func:`fit()` function for training in terms of dimension. num_samples - Number of times a prediction is sampled from a probabilistic model. Should be left set to 1 - for deterministic models. + Number of times a prediction is sampled from a probabilistic model. Must be `1` for deterministic models. verbose - Optionally, whether to print progress. + Whether to print the progress. predict_likelihood_parameters - If set to `True`, the model predict the parameters of its Likelihood parameters instead of the target. Only + If set to `True`, the model predicts the parameters of its `likelihood` instead of the target. Only supported for probabilistic models with a likelihood, `num_samples = 1` and `n<=output_chunk_length`. Default: ``False`` show_warnings @@ -3013,8 +3030,7 @@ def predict( the covariate time series that has been used with the :func:`fit()` method for training, and it must contain at least the next `n` time steps/indices after the end of the training target series. num_samples - Number of times a prediction is sampled from a probabilistic model. Should be left set to 1 - for deterministic models. + Number of times a prediction is sampled from a probabilistic model. Must be `1` for deterministic models. verbose Optionally, set the prediction verbosity. Not effective for all models. show_warnings @@ -3188,8 +3204,7 @@ def predict( training target series. If `series` is set, it must contain at least the time steps/indices corresponding to the new target series (historic future covariates), plus the next `n` time steps/indices after the end. num_samples - Number of times a prediction is sampled from a probabilistic model. Should be left set to 1 - for deterministic models. + Number of times a prediction is sampled from a probabilistic model. Must be `1` for deterministic models. verbose Optionally, set the prediction verbosity. Not effective for all models. show_warnings diff --git a/darts/models/forecasting/regression_model.py b/darts/models/forecasting/regression_model.py index 649a7b1432..83ef7eb7fe 100644 --- a/darts/models/forecasting/regression_model.py +++ b/darts/models/forecasting/regression_model.py @@ -992,9 +992,9 @@ def predict( Number of times a prediction is sampled from a probabilistic model. Should be set to 1 for deterministic models. verbose - Optionally, whether to print progress. + Whether to print the progress. predict_likelihood_parameters - If set to `True`, the model predict the parameters of its Likelihood parameters instead of the target. Only + If set to `True`, the model predicts the parameters of its `likelihood` instead of the target. Only supported for probabilistic models with a likelihood, `num_samples = 1` and `n<=output_chunk_length`. Default: ``False`` **kwargs : dict, optional diff --git a/darts/models/forecasting/torch_forecasting_model.py b/darts/models/forecasting/torch_forecasting_model.py index f6194d15f4..e9eb59111a 100644 --- a/darts/models/forecasting/torch_forecasting_model.py +++ b/darts/models/forecasting/torch_forecasting_model.py @@ -707,7 +707,7 @@ def fit( Optionally, a custom PyTorch-Lightning Trainer object to perform training. Using a custom ``trainer`` will override Darts' default trainer. verbose - Optionally, whether to print the progress. Ignored if there is a `ProgressBar` callback in + Whether to print the progress. Ignored if there is a `ProgressBar` callback in `pl_trainer_kwargs`. epochs If specified, will train the model for ``epochs`` (additional) epochs, irrespective of what ``n_epochs`` @@ -933,7 +933,7 @@ def fit_from_dataset( Optionally, a custom PyTorch-Lightning Trainer object to perform prediction. Using a custom `trainer` will override Darts' default trainer. verbose - Optionally, whether to print the progress. Ignored if there is a `ProgressBar` callback in + Whether to print the progress. Ignored if there is a `ProgressBar` callback in `pl_trainer_kwargs`. epochs If specified, will train the model for ``epochs`` (additional) epochs, irrespective of what ``n_epochs`` @@ -1238,7 +1238,7 @@ def lr_find( Optionally, a custom PyTorch-Lightning Trainer object to perform training. Using a custom ``trainer`` will override Darts' default trainer. verbose - Optionally, whether to print the progress. Ignored if there is a `ProgressBar` callback in + Whether to print the progress. Ignored if there is a `ProgressBar` callback in `pl_trainer_kwargs`. epochs If specified, will train the model for ``epochs`` (additional) epochs, irrespective of what ``n_epochs`` @@ -1367,7 +1367,7 @@ def predict( batch_size Size of batches during prediction. Defaults to the models' training ``batch_size`` value. verbose - Optionally, whether to print the progress. Ignored if there is a `ProgressBar` callback in + Whether to print the progress. Ignored if there is a `ProgressBar` callback in `pl_trainer_kwargs`. n_jobs The number of jobs to run in parallel. ``-1`` means using all processors. Defaults to ``1``. @@ -1377,8 +1377,7 @@ def predict( (and optionally future covariates) back into the model. If this parameter is not provided, it will be set ``output_chunk_length`` by default. num_samples - Number of times a prediction is sampled from a probabilistic model. Should be left set to 1 - for deterministic models. + Number of times a prediction is sampled from a probabilistic model. Must be `1` for deterministic models. dataloader_kwargs Optionally, a dictionary of keyword arguments used to create the PyTorch `DataLoader` instance for the inference/prediction dataset. For more information on `DataLoader`, check out `this link @@ -1389,7 +1388,7 @@ def predict( Optionally, enable monte carlo dropout for predictions using neural network based models. This allows bayesian approximation by specifying an implicit prior over learned models. predict_likelihood_parameters - If set to `True`, the model predict the parameters of its Likelihood parameters instead of the target. Only + If set to `True`, the model predicts the parameters of its `likelihood` instead of the target. Only supported for probabilistic models with a likelihood, `num_samples = 1` and `n<=output_chunk_length`. Default: ``False``. show_warnings @@ -1515,7 +1514,7 @@ def predict_from_dataset( batch_size Size of batches during prediction. Defaults to the models ``batch_size`` value. verbose - Optionally, whether to print the progress. Ignored if there is a `ProgressBar` callback in + Whether to print the progress. Ignored if there is a `ProgressBar` callback in `pl_trainer_kwargs`. n_jobs The number of jobs to run in parallel. ``-1`` means using all processors. Defaults to ``1``. @@ -1525,8 +1524,7 @@ def predict_from_dataset( (and optionally future covariates) back into the model. If this parameter is not provided, it will be set ``output_chunk_length`` by default. num_samples - Number of times a prediction is sampled from a probabilistic model. Should be left set to 1 - for deterministic models. + Number of times a prediction is sampled from a probabilistic model. Must be `1` for deterministic models. dataloader_kwargs Optionally, a dictionary of keyword arguments used to create the PyTorch `DataLoader` instance for the inference/prediction dataset. For more information on `DataLoader`, check out `this link @@ -1537,7 +1535,7 @@ def predict_from_dataset( Optionally, enable monte carlo dropout for predictions using neural network based models. This allows bayesian approximation by specifying an implicit prior over learned models. predict_likelihood_parameters - If set to `True`, the model predict the parameters of its Likelihood parameters instead of the target. Only + If set to `True`, the model predicts the parameters of its `likelihood` instead of the target. Only supported for probabilistic models with a likelihood, `num_samples = 1` and `n<=output_chunk_length`. Default: ``False`` diff --git a/docs/source/conf.py b/docs/source/conf.py index 4b64571a5b..4475d76cda 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -49,10 +49,10 @@ "inherited-members": None, "show-inheritance": None, "ignore-module-all": True, - "exclude-members": "ForecastingModel,LocalForecastingModel,FutureCovariatesLocalForecastingModel," + "exclude-members": "LocalForecastingModel,FutureCovariatesLocalForecastingModel," + "TransferableFutureCovariatesLocalForecastingModel,GlobalForecastingModel,TorchForecastingModel," + "PastCovariatesTorchModel,FutureCovariatesTorchModel,DualCovariatesTorchModel,MixedCovariatesTorchModel," - + "SplitCovariatesTorchModel,ConformalModel," + + "SplitCovariatesTorchModel," + "min_train_series_length," + "untrained_model,first_prediction_index,future_covariate_series,past_covariate_series," + "initialize_encoders,register_datapipe_as_function,register_function,functions," From 8e8ac1decd4176eed666bc46d6b804f4048ec544 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Tue, 15 Oct 2024 17:56:02 +0200 Subject: [PATCH 56/78] attempt to fix failing test on linux --- .../models/forecasting/test_conformal_model.py | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 5ea15fb7cd..10acaa8b1e 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -1020,7 +1020,19 @@ def test_naive_conformal_model_historical_forecasts(self, config): hfc_conf_list_with_cal_short = [hfc_conf_list_with_cal_short] # must match - assert hfc_conf_list_with_cal_exact == hfc_conf_list_with_cal + assert len(hfc_conf_list_with_cal_exact) == len( + hfc_conf_list_with_cal_short + ) + for hfc_cal_exact, hfc_cal in zip( + hfc_conf_list_with_cal_exact, hfc_conf_list_with_cal + ): + assert len(hfc_cal_exact) == len(hfc_cal) + for hfc_cal_exact_, hfc_cal_ in zip(hfc_cal_exact, hfc_cal): + assert hfc_cal_exact_.time_index.equals(hfc_cal_.time_index) + assert hfc_cal_exact_.columns.equals(hfc_cal_.columns) + np.testing.assert_array_almost_equal( + hfc_cal_exact_.all_values(), hfc_cal_.all_values() + ) # second last forecast with shorter calibration set (that has one example less) must be equal to the # second last without calibration set From cc6fe0736dfa5c79edac7dbfe2e1207509db978f Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sun, 10 Nov 2024 16:37:48 +0100 Subject: [PATCH 57/78] update start logic --- darts/models/forecasting/conformal_models.py | 107 ++++++++-------- .../forecasting/test_historical_forecasts.py | 119 ++++++++++++++++++ 2 files changed, 177 insertions(+), 49 deletions(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index da96345241..0727abafd7 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -24,13 +24,13 @@ from darts.models.forecasting.forecasting_model import GlobalForecastingModel from darts.models.utils import TORCH_AVAILABLE from darts.utils import _build_tqdm_iterator, _with_sanity_checks - -# from darts.utils.historical_forecasts.utils import _historical_forecasts_start_warnings +from darts.utils.historical_forecasts.utils import ( + _adjust_historical_forecasts_time_index, +) from darts.utils.timeseries_generation import _build_forecast_series from darts.utils.ts_utils import ( SeriesType, get_series_seq_type, - get_single_series, series2seq, ) from darts.utils.utils import ( @@ -61,6 +61,7 @@ def __init__( cal_length: Optional[int] = None, num_samples: int = 500, random_state: Optional[int] = None, + stride_cal: bool = False, ): """Base Conformal Prediction Model. @@ -79,8 +80,10 @@ def __init__( follows: - Extract a calibration set: The number of calibration examples from the most recent past to use for one - conformal prediction can be defined at model creation with parameter `cal_length`. To make your life simpler, - we support two modes: + conformal prediction can be defined at model creation with parameter `cal_length`. If `stride_cal` is `True`, + then the same `stride` from the forecasting methods is applied to the calibration set, and more calibration + examples are required (`cal_length * stride` historical forecasts that were generated with `stride=1`). + To make your life simpler, we support two modes: - Automatic extraction of the calibration set from the past of your input series (`series`, `past_covariates`, ...). This is the default mode and our predict/forecasting/backtest/.... API is identical to any other forecasting model @@ -118,6 +121,8 @@ def __init__( set in downstream forecasting tasks. random_state Control the randomness of probabilistic conformal forecasts (sample generation) across different runs. + stride_cal + Whether to apply the same historical forecast `stride` to the non-conformity scores of the calibration set. """ if not isinstance(model, GlobalForecastingModel) or not model._fit_called: raise_log( @@ -154,6 +159,7 @@ def __init__( # model setup self.model = model self.cal_length = cal_length + self.stride_cal = stride_cal self.num_samples = num_samples if model.supports_probabilistic_prediction else 1 self._likelihood = "quantile" self._fit_called = True @@ -216,6 +222,7 @@ def predict( cal_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, cal_past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, cal_future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + stride: int = 1, num_samples: int = 1, verbose: bool = False, predict_likelihood_parameters: bool = False, @@ -274,6 +281,9 @@ def predict( cal_future_covariates Optionally, a future covariates series for every input time series in `series` to use for calibration instead of `future_covariates`. + stride + The number of time steps between two consecutive predictions (and non-conformity scores) of the + calibration set. Right-bound by the first time step of the generated forecast. num_samples Number of times a prediction is sampled from the calibrated quantile predictions using linear interpolation in-between the quantiles. For larger values, the sample distribution approximates the @@ -382,6 +392,7 @@ def predict( cal_forecasts=cal_hfcs, num_samples=num_samples, forecast_horizon=n, + stride=stride, overlap_end=True, last_points_only=False, verbose=verbose, @@ -1124,6 +1135,8 @@ def _calibrate_forecasts( - Compute the conformal prediction: Add the calibrated intervals to (or adjust the existing intervals of) the forecasting model's predictions. """ + # TODO: add proper handling of `cal_stride` > 1 + # cal_stride = stride if self.stride_cal else 1 cal_length = self.cal_length metric, metric_kwargs = self._residuals_metric residuals = self.model.residuals( @@ -1158,7 +1171,6 @@ def _calibrate_forecasts( cp_hfcs.append(cp_preds) continue - first_hfc = get_single_series(s_hfcs) last_hfc = s_hfcs if last_points_only else s_hfcs[-1] # compute the minimum required number of useful calibration residuals @@ -1228,50 +1240,35 @@ def _calibrate_forecasts( ), logger=logger, ) - # skip solely based on `start` + # adjust first index based on `start` first_idx_start = 0 if start is not None: - if isinstance(start, pd.Timestamp) or start_format == "value": - start_time = start - else: - start_time = series_._time_index[start] - + # adjust forecastable index in case of output shift or `last_points_only=True` + adjust_idx = ( + self.output_chunk_shift + + int(last_points_only) * (forecast_horizon - 1) + ) * series_.freq + historical_forecastable_index = ( + s_hfcs[first_idx_train].start_time() - adjust_idx, + s_hfcs[-1].start_time() - adjust_idx, + ) + # TODO: add proper start handling with `cal_stride>1` + # adjust forecastable index based on start, assuming hfcs were generated with `stride=1` + first_idx_start, _ = _adjust_historical_forecasts_time_index( + series=series_, + series_idx=series_idx, + start=start, + start_format=start_format, + stride=stride, + historical_forecasts_time_index=historical_forecastable_index, + show_warnings=show_warnings, + ) + # find position relative to start first_idx_start = n_steps_between( - end=start_time, - start=first_hfc.start_time(), + first_idx_start + adjust_idx, + s_hfcs[0].start_time(), freq=series_.freq, ) - # hfcs have shifted output; skip until end of shift - first_idx_start += self.output_chunk_shift - # hfcs only contain last predicted points; skip until end of first forecast - if last_points_only: - first_idx_start += forecast_horizon - 1 - - # if start is out of bounds, we ignore it - last_idx = len(s_hfcs) - 1 - if ( - first_idx_start < 0 - or first_idx_start > last_idx - or first_idx_start < first_idx_train - ): - first_idx_start = 0 - # TODO: proper start handling - # if show_warnings: - # # adjust to actual start point in case of output shift or `last_points_only=True` - # adjust_idx = ( - # self.output_chunk_shift - # + int(last_points_only) * (forecast_horizon - 1) - # ) * series_.freq - # hfc_predict_index = ( - # s_hfcs[first_idx_train].start_time() - adjust_idx, - # s_hfcs[last_idx].start_time() - adjust_idx, - # ) - # _historical_forecasts_start_warnings( - # idx=series_idx, - # start=start, - # start_time_=start_time, - # historical_forecasts_time_index=hfc_predict_index, - # ) # get final first index first_fc_idx = max([first_idx_train, first_idx_start]) @@ -1596,6 +1593,7 @@ def __init__( cal_length: Optional[int] = None, num_samples: int = 500, random_state: Optional[int] = None, + stride_cal: bool = False, ): """Naive Conformal Prediction Model. @@ -1625,8 +1623,10 @@ def __init__( follows: - Extract a calibration set: The number of calibration examples from the most recent past to use for one - conformal prediction can be defined at model creation with parameter `cal_length`. To make your life simpler, - we support two modes: + conformal prediction can be defined at model creation with parameter `cal_length`. If `stride_cal` is `True`, + then the same `stride` from the forecasting methods is applied to the calibration set, and more calibration + examples are required (`cal_length * stride` historical forecasts that were generated with `stride=1`). + To make your life simpler, we support two modes: - Automatic extraction of the calibration set from the past of your input series (`series`, `past_covariates`, ...). This is the default mode and our predict/forecasting/backtest/.... API is identical to any other forecasting model @@ -1664,6 +1664,8 @@ def __init__( set in downstream forecasting tasks. random_state Control the randomness of probabilistic conformal forecasts (sample generation) across different runs. + stride_cal + Whether to apply the same historical forecast `stride` to the non-conformity scores of the calibration set. """ super().__init__( model=model, @@ -1672,6 +1674,7 @@ def __init__( cal_length=cal_length, num_samples=num_samples, random_state=random_state, + stride_cal=stride_cal, ) def _calibrate_interval( @@ -1722,6 +1725,7 @@ def __init__( cal_length: Optional[int] = None, num_samples: int = 500, random_state: Optional[int] = None, + stride_cal: bool = False, ): """Conformalized Quantile Regression Model. @@ -1753,8 +1757,10 @@ def __init__( follows: - Extract a calibration set: The number of calibration examples from the most recent past to use for one - conformal prediction can be defined at model creation with parameter `cal_length`. To make your life simpler, - we support two modes: + conformal prediction can be defined at model creation with parameter `cal_length`. If `stride_cal` is `True`, + then the same `stride` from the forecasting methods is applied to the calibration set, and more calibration + examples are required (`cal_length * stride` historical forecasts that were generated with `stride=1`). + To make your life simpler, we support two modes: - Automatic extraction of the calibration set from the past of your input series (`series`, `past_covariates`, ...). This is the default mode and our predict/forecasting/backtest/.... API is identical to any other forecasting model @@ -1793,6 +1799,8 @@ def __init__( set in downstream forecasting tasks. random_state Control the randomness of probabilistic conformal forecasts (sample generation) across different runs. + stride_cal + Whether to apply the same historical forecast `stride` to the non-conformity scores of the calibration set. """ if not model.supports_probabilistic_prediction: raise_log( @@ -1809,6 +1817,7 @@ def __init__( cal_length=cal_length, num_samples=num_samples, random_state=random_state, + stride_cal=stride_cal, ) def _calibrate_interval( diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index a612ca0364..67f727b16e 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -3276,3 +3276,122 @@ def test_conformal_historical_start_cal_length(self, config): vals_cal_0[:, 1] - vals_cal_0[:, 2], vals_cal_i[:, 1] - vals_cal_i[:, 2], ) + + @pytest.mark.parametrize( + "config", + list( + itertools.product( + [False, True], # last points only + [None, 2], # cal length + ["value", "position"], # start format + [1, 2], # stride + [0, 1], # output chunk shift + ) + ), + ) + def test_conformal_historical_forecast_start(self, caplog, config): + """Tests naive conformal model with `start` being the first forecastable index is identical to a start + before forecastable index (including stride). + """ + ( + last_points_only, + cal_length, + start_format, + stride, + ocs, + ) = config + # TODO: adjust this test (the input length of `series_val`), once `stride_cal` has been properly implemented + q = [0.1, 0.5, 0.9] + pred_lklp = {"num_samples": 1, "predict_likelihood_parameters": True} + # compute minimum series length to generate n forecasts + icl = 3 + ocl = 5 + horizon = 2 + horizon_ocs = horizon + ocs + add_cal_length = cal_length - 1 if cal_length is not None else 0 + min_len_val_series = icl + 2 * horizon_ocs + add_cal_length + n_forecasts = 3 + # to get `n_forecasts` with `stride`, we need more points + n_forecasts_stride = stride * n_forecasts - int(1 % stride > 0) + # get train and val series of that length + series_train, series_val = ( + self.ts_pass_train[:10], + self.ts_pass_val[: min_len_val_series + n_forecasts_stride - 1], + ) + + # first train the ForecastingModel + forecasting_model = LinearRegressionModel( + lags=icl, + output_chunk_length=ocl, + output_chunk_shift=ocs, + ) + forecasting_model.fit(series_train) + + # optionally compute the start as a positional index + start_position = icl + horizon_ocs + add_cal_length + if start_format == "value": + start = series_val.time_index[start_position] + start_too_early = series_val.time_index[start_position - stride] + else: + start = start_position + start_too_early = start_position - stride + start_first_fc = series_val.time_index[start_position] + series_val.freq * ( + horizon_ocs - 1 if last_points_only else ocs + ) + too_early_warn_exp = "is before the first predictable/trainable historical" + + hfc_params = { + "series": series_val, + "retrain": False, + "start_format": start_format, + "stride": stride, + "last_points_only": last_points_only, + "forecast_horizon": horizon, + } + # compute regular historical forecasts + hist_fct_all = forecasting_model.historical_forecasts(start=start, **hfc_params) + assert len(hist_fct_all) == n_forecasts + assert hist_fct_all[0].start_time() == start_first_fc + assert ( + hist_fct_all[1].start_time() - stride * series_val.freq + == hist_fct_all[0].start_time() + ) + + # compute conformal historical forecasts (starting at first possible conformal forecast) + model = ConformalNaiveModel( + forecasting_model, quantiles=q, cal_length=cal_length, stride_cal=stride > 1 + ) + with caplog.at_level(logging.WARNING): + hist_fct = model.historical_forecasts( + start=start, **hfc_params, **pred_lklp + ) + assert too_early_warn_exp not in caplog.text + caplog.clear() + assert len(hist_fct) == len(hist_fct_all) + assert hist_fct_all[0].start_time() == hist_fct[0].start_time() + assert ( + hist_fct[1].start_time() - stride * series_val.freq + == hist_fct[0].start_time() + ) + + # start one earlier raises warning but still starts at same time + with caplog.at_level(logging.WARNING): + hist_fct_too_early = model.historical_forecasts( + start=start_too_early, **hfc_params, **pred_lklp + ) + assert too_early_warn_exp in caplog.text + caplog.clear() + assert hist_fct_too_early == hist_fct + + # using a calibration series should not skip any forecasts + hist_fct_cal = model.historical_forecasts( + start=start, + cal_series=series_val[:-horizon_ocs], + **hfc_params, + **pred_lklp, + ) + assert len(hist_fct_all) == len(hist_fct_cal) + assert hist_fct_all[0].start_time() == hist_fct_cal[0].start_time() + + # cal_series yields same calibration set on the last hist fc + assert hist_fct[-1] == hist_fct_cal[-1] From 1272bfc56738cac220d42137cbb2553905f24f9f Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sat, 16 Nov 2024 14:09:11 +0100 Subject: [PATCH 58/78] upgrade python target version --- darts/models/forecasting/conformal_models.py | 69 +- .../23-Conformal-Prediction-examples.ipynb | 4898 +---------------- 2 files changed, 59 insertions(+), 4908 deletions(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index 0727abafd7..33ffb766d2 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -8,7 +8,8 @@ import copy import os from abc import ABC, abstractmethod -from typing import Any, BinaryIO, Callable, Dict, List, Optional, Sequence, Tuple, Union +from collections.abc import Sequence +from typing import Any, BinaryIO, Callable, Optional, Union try: from typing import Literal @@ -56,7 +57,7 @@ class ConformalModel(GlobalForecastingModel, ABC): def __init__( self, model: GlobalForecastingModel, - quantiles: List[float], + quantiles: list[float], symmetric: bool = True, cal_length: Optional[int] = None, num_samples: int = 500, @@ -427,10 +428,10 @@ def historical_forecasts( show_warnings: bool = True, predict_likelihood_parameters: bool = False, enable_optimization: bool = True, - fit_kwargs: Optional[Dict[str, Any]] = None, - predict_kwargs: Optional[Dict[str, Any]] = None, + fit_kwargs: Optional[dict[str, Any]] = None, + predict_kwargs: Optional[dict[str, Any]] = None, sample_weight: Optional[Union[TimeSeries, Sequence[TimeSeries], str]] = None, - ) -> Union[TimeSeries, List[TimeSeries], List[List[TimeSeries]]]: + ) -> Union[TimeSeries, list[TimeSeries], list[list[TimeSeries]]]: """Generates calibrated historical forecasts by simulating predictions at various points in time throughout the history of the provided (potentially multiple) `series`. This process involves retrospectively applying the model to different time steps, as if the forecasts were made in real-time at those specific moments. This @@ -545,14 +546,14 @@ def historical_forecasts( TimeSeries A single historical forecast for a single `series` and `last_points_only=True`: it contains only the predictions at step `forecast_horizon` from all historical forecasts. - List[TimeSeries] + list[TimeSeries] A list of historical forecasts for: - a sequence (list) of `series` and `last_points_only=True`: for each series, it contains only the predictions at step `forecast_horizon` from all historical forecasts. - a single `series` and `last_points_only=False`: for each historical forecast, it contains the entire horizon `forecast_horizon`. - List[List[TimeSeries]] + list[list[TimeSeries]] A list of lists of historical forecasts for a sequence of `series` and `last_points_only=False`. For each series, and historical forecast, it contains the entire horizon `forecast_horizon`. The outer list is over the series provided in the input sequence, and the inner lists contain the historical forecasts for @@ -655,17 +656,17 @@ def backtest( retrain: Union[bool, int, Callable[..., bool]] = True, overlap_end: bool = False, last_points_only: bool = False, - metric: Union[METRIC_TYPE, List[METRIC_TYPE]] = metrics.mape, + metric: Union[METRIC_TYPE, list[METRIC_TYPE]] = metrics.mape, reduction: Union[Callable[..., float], None] = np.mean, verbose: bool = False, show_warnings: bool = True, predict_likelihood_parameters: bool = False, enable_optimization: bool = True, - metric_kwargs: Optional[Union[Dict[str, Any], List[Dict[str, Any]]]] = None, - fit_kwargs: Optional[Dict[str, Any]] = None, - predict_kwargs: Optional[Dict[str, Any]] = None, + metric_kwargs: Optional[Union[dict[str, Any], list[dict[str, Any]]]] = None, + fit_kwargs: Optional[dict[str, Any]] = None, + predict_kwargs: Optional[dict[str, Any]] = None, sample_weight: Optional[Union[TimeSeries, Sequence[TimeSeries], str]] = None, - ) -> Union[float, np.ndarray, List[float], List[np.ndarray]]: + ) -> Union[float, np.ndarray, list[float], list[np.ndarray]]: """Compute error values that the model produced for historical forecasts on (potentially multiple) `series`. If `historical_forecasts` are provided, the metric(s) (given by the `metric` function) is evaluated directly on @@ -812,10 +813,10 @@ def backtest( when `reduction=None` - multiple uni/multivariate series including `series_reduction` and at least one of `component_reduction=None` or `time_reduction=None` for "per time step metrics" - List[float] + list[float] Same as for type `float` but for a sequence of series. The returned metric list has length `len(series)` with the `float` metric for each input `series`. - List[np.ndarray] + list[np.ndarray] Same as for type `np.ndarray` but for a sequence of series. The returned metric list has length `len(series)` with the `np.ndarray` metrics for each input `series`. """ @@ -892,12 +893,12 @@ def residuals( show_warnings: bool = True, predict_likelihood_parameters: bool = False, enable_optimization: bool = True, - metric_kwargs: Optional[Dict[str, Any]] = None, - fit_kwargs: Optional[Dict[str, Any]] = None, - predict_kwargs: Optional[Dict[str, Any]] = None, + metric_kwargs: Optional[dict[str, Any]] = None, + fit_kwargs: Optional[dict[str, Any]] = None, + predict_kwargs: Optional[dict[str, Any]] = None, sample_weight: Optional[Union[TimeSeries, Sequence[TimeSeries], str]] = None, values_only: bool = False, - ) -> Union[TimeSeries, List[TimeSeries], List[List[TimeSeries]]]: + ) -> Union[TimeSeries, list[TimeSeries], list[list[TimeSeries]]]: """Compute the residuals that the model produced for historical forecasts on (potentially multiple) `series`. This function computes the difference (or one of Darts' "per time step" metrics) between the actual @@ -1039,10 +1040,10 @@ def residuals( TimeSeries Residual `TimeSeries` for a single `series` and `historical_forecasts` generated with `last_points_only=True`. - List[TimeSeries] + list[TimeSeries] A list of residual `TimeSeries` for a sequence (list) of `series` with `last_points_only=True`. The residual list has length `len(series)`. - List[List[TimeSeries]] + list[list[TimeSeries]] A list of lists of residual `TimeSeries` for a sequence of `series` with `last_points_only=False`. The outer residual list has length `len(series)`. The inner lists consist of the residuals from all possible series-specific historical forecasts. @@ -1114,7 +1115,7 @@ def _calibrate_forecasts( verbose: bool = False, show_warnings: bool = True, predict_likelihood_parameters: bool = False, - ) -> Union[TimeSeries, List[TimeSeries], List[List[TimeSeries]]]: + ) -> Union[TimeSeries, list[TimeSeries], list[list[TimeSeries]]]: """Generate calibrated historical forecasts. In general the workflow of the models to produce one calibrated forecast/prediction per step in the horizon @@ -1467,7 +1468,7 @@ def load(path: Union[str, os.PathLike, BinaryIO]) -> "ConformalModel": @abstractmethod def _calibrate_interval( self, residuals: np.ndarray - ) -> Tuple[np.ndarray, np.ndarray]: + ) -> tuple[np.ndarray, np.ndarray]: """Computes the lower and upper calibrated forecast intervals based on residuals. Parameters @@ -1478,7 +1479,7 @@ def _calibrate_interval( pass @abstractmethod - def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray]): + def _apply_interval(self, pred: np.ndarray, q_hat: tuple[np.ndarray, np.ndarray]): """Applies the calibrated interval to the predicted quantiles. Returns an array with `len(quantiles)` conformalized quantile predictions (lower quantiles, model forecast, upper quantiles) per component. @@ -1488,12 +1489,12 @@ def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray] @property @abstractmethod - def _residuals_metric(self) -> Tuple[METRIC_TYPE, Optional[dict]]: + def _residuals_metric(self) -> tuple[METRIC_TYPE, Optional[dict]]: """Gives the "per time step" metric and optional metric kwargs used to compute residuals / non-conformity scores.""" pass - def _cp_component_names(self, input_series) -> List[str]: + def _cp_component_names(self, input_series) -> list[str]: """Gives the component names for generated forecasts.""" return likelihood_component_names( input_series.components, quantile_names(self.quantiles) @@ -1515,7 +1516,7 @@ def _model_encoder_settings(self): @property def extreme_lags( self, - ) -> Tuple[ + ) -> tuple[ Optional[int], Optional[int], Optional[int], @@ -1588,7 +1589,7 @@ class ConformalNaiveModel(ConformalModel): def __init__( self, model: GlobalForecastingModel, - quantiles: List[float], + quantiles: list[float], symmetric: bool = True, cal_length: Optional[int] = None, num_samples: int = 500, @@ -1679,7 +1680,7 @@ def __init__( def _calibrate_interval( self, residuals: np.ndarray - ) -> Tuple[np.ndarray, np.ndarray]: + ) -> tuple[np.ndarray, np.ndarray]: def q_hat_from_residuals(residuals_): # compute quantiles of shape (forecast horizon, n components, n quantile intervals) return np.quantile( @@ -1702,7 +1703,7 @@ def q_hat_from_residuals(residuals_): n_comps = residuals.shape[1] return -q_hat[:, :n_comps, :], q_hat[:, n_comps:, ::-1] - def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray]): + def _apply_interval(self, pred: np.ndarray, q_hat: tuple[np.ndarray, np.ndarray]): # convert stochastic predictions to median if pred.shape[2] != 1: pred = np.expand_dims(np.quantile(pred, 0.5, axis=2), -1) @@ -1712,7 +1713,7 @@ def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray] return pred.reshape(len(pred), -1) @property - def _residuals_metric(self) -> Tuple[METRIC_TYPE, Optional[dict]]: + def _residuals_metric(self) -> tuple[METRIC_TYPE, Optional[dict]]: return (metrics.ae if self.symmetric else metrics.err), None @@ -1720,7 +1721,7 @@ class ConformalQRModel(ConformalModel): def __init__( self, model: GlobalForecastingModel, - quantiles: List[float], + quantiles: list[float], symmetric: bool = True, cal_length: Optional[int] = None, num_samples: int = 500, @@ -1822,7 +1823,7 @@ def __init__( def _calibrate_interval( self, residuals: np.ndarray - ) -> Tuple[np.ndarray, np.ndarray]: + ) -> tuple[np.ndarray, np.ndarray]: n_comps = residuals.shape[1] // ( len(self.interval_range) * (1 + int(not self.symmetric)) ) @@ -1856,7 +1857,7 @@ def q_hat_from_residuals(residuals_): q_hat_hi = q_hat_from_residuals(residuals[:, half_idx:]) return -q_hat_lo, q_hat_hi[:, :, ::-1] - def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray]): + def _apply_interval(self, pred: np.ndarray, q_hat: tuple[np.ndarray, np.ndarray]): # get quantile predictions with shape (n times, n components, n quantiles) pred = np.quantile(pred, self.quantiles, axis=2).transpose((1, 2, 0)) # shape (forecast horizon, n components, n quantiles) @@ -1872,7 +1873,7 @@ def _apply_interval(self, pred: np.ndarray, q_hat: Tuple[np.ndarray, np.ndarray] return pred.reshape(len(pred), -1) @property - def _residuals_metric(self) -> Tuple[METRIC_TYPE, Optional[dict]]: + def _residuals_metric(self) -> tuple[METRIC_TYPE, Optional[dict]]: return metrics.incs_qr, { "q_interval": self.q_interval, "symmetric": self.symmetric, diff --git a/examples/23-Conformal-Prediction-examples.ipynb b/examples/23-Conformal-Prediction-examples.ipynb index 153b95d9e1..10573d8b43 100644 --- a/examples/23-Conformal-Prediction-examples.ipynb +++ b/examples/23-Conformal-Prediction-examples.ipynb @@ -72,19 +72,12 @@ "%load_ext autoreload\n", "%autoreload 2\n", "%matplotlib inline\n", - "import numpy as np\n", - "import pandas as pd\n", "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", "\n", - "from darts import TimeSeries, concatenate\n", - "from darts.models import (\n", - " ConformalNaiveModel,\n", - " ConformalQRModel,\n", - " LightGBMModel,\n", - " LinearRegressionModel,\n", - ")\n", - "from darts import metrics\n", - "from darts.datasets import ElectricityConsumptionZurichDataset" + "from darts import concatenate, metrics\n", + "from darts.datasets import ElectricityConsumptionZurichDataset\n", + "from darts.models import ConformalNaiveModel, LinearRegressionModel" ] }, { @@ -219,7 +212,7 @@ "model.fit(ts_energy_train)\n", "pred = model.predict(horizon)\n", "\n", - "ts_energy_train[-2*horizon:].plot(label=\"training\")\n", + "ts_energy_train[-2 * horizon :].plot(label=\"training\")\n", "ts_energy_val[:horizon].plot(label=\"validation\")\n", "pred.plot(label=\"forecast\")" ] @@ -364,7 +357,7 @@ ], "source": [ "quantiles = [0.05, 0.1, 0.5, 0.9, 0.95]\n", - "cp_model = ConformalNaiveModel(model=model, quantiles=quantiles, cal_length=7*horizon)\n", + "cp_model = ConformalNaiveModel(model=model, quantiles=quantiles, cal_length=7 * horizon)\n", "pred_params = {\"predict_likelihood_parameters\": True}\n", "# pred_params = {\"num_samples\": 500}\n", "\n", @@ -375,7 +368,7 @@ " last_points_only=False,\n", " retrain=False,\n", " verbose=True,\n", - " **pred_params\n", + " **pred_params,\n", ")\n", "cp_hist_fc = concatenate(cp_hist_fc)\n", "\n", @@ -422,6 +415,7 @@ " bt_df.index = [\"Interval Width\", \"Interval Coverage\"]\n", " return bt_df\n", "\n", + "\n", "print(compute_backtest(cp_hist_fc))" ] }, @@ -479,6 +473,7 @@ " )\n", " return residuals\n", "\n", + "\n", "coverage = compute_residuals(cp_hist_fc, metric=metrics.iw)\n", "coverage[:end_ts].plot()" ] @@ -567,7 +562,9 @@ } ], "source": [ - "coverage.window_transform(transforms={\"function\": \"mean\", \"mode\": \"rolling\", \"window\": 2*7*24}).plot()" + "coverage.window_transform(\n", + " transforms={\"function\": \"mean\", \"mode\": \"rolling\", \"window\": 2 * 7 * 24}\n", + ").plot()" ] }, { @@ -652,12 +649,14 @@ " last_points_only=False,\n", " retrain=False,\n", " verbose=True,\n", - " **pred_params\n", + " **pred_params,\n", ")\n", "cp_hist_fc = concatenate(cp_hist_fc)\n", "print(compute_backtest(cp_hist_fc))\n", "coverage = compute_residuals(cp_hist_fc, metric=metrics.ic)\n", - "coverage.window_transform(transforms={\"function\": \"mean\", \"mode\": \"rolling\", \"window\": 2*7*24}).plot()" + "coverage.window_transform(\n", + " transforms={\"function\": \"mean\", \"mode\": \"rolling\", \"window\": 2 * 7 * 24}\n", + ").plot()" ] }, { @@ -731,10 +730,10 @@ "horizon = 24\n", "\n", "model = LinearRegressionModel(\n", - " lags=input_length, \n", - " lags_future_covariates=(input_length, horizon), \n", + " lags=input_length,\n", + " lags_future_covariates=(input_length, horizon),\n", " output_chunk_length=horizon,\n", - " add_encoders={\"cyclic\": {\"future\": [\"dayofweek\"]}}\n", + " add_encoders={\"cyclic\": {\"future\": [\"dayofweek\"]}},\n", ")\n", "model.fit(ts_energy_train)\n", "hist_fc = model.historical_forecasts(\n", @@ -836,12 +835,14 @@ " last_points_only=False,\n", " retrain=False,\n", " verbose=True,\n", - " **pred_params\n", + " **pred_params,\n", ")\n", "cp_hist_fc = concatenate(cp_hist_fc)\n", "print(compute_backtest(cp_hist_fc))\n", "coverage = compute_residuals(cp_hist_fc, metric=metrics.ic)\n", - "coverage.window_transform(transforms={\"function\": \"mean\", \"mode\": \"rolling\", \"window\": 2*7*24}).plot()" + "coverage.window_transform(\n", + " transforms={\"function\": \"mean\", \"mode\": \"rolling\", \"window\": 2 * 7 * 24}\n", + ").plot()" ] }, { @@ -873,4858 +874,7 @@ }, "widgets": { "application/vnd.jupyter.widget-state+json": { - "state": { - "000eae68dd4a48de9de0019ae7bf5734": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_e59c7f2a15014da59c6781ccac26a36e", - "IPY_MODEL_2befe7be21cb42fb8e8fa564346c22b6", - "IPY_MODEL_2bb628242e764232a5d4d973d2917588" - ], - "layout": "IPY_MODEL_ed806c4e08384cd09eca536a92ea4055" - } - }, - "01d5e57d11024dfb84fd6e6aff24894e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "01f0742d352a4dc69ef1a8988c73e5ea": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "01f17d372087468dbfba867b610db337": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_eebe728bdc824b8d83d3e73653063c3e", - "max": 1, - "style": "IPY_MODEL_e255bc9adb1f45c7bb3b7beb958eeee2", - "value": 1 - } - }, - "0240077fbccd479aa50f3edbe55ed78a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "0306df6cb7d84b69a900b096325e3c58": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "03bbceffa51b42b29f29f18b33b7cf9b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "040491ab03ac47229a116a53e99975a3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_c338c2806f9b4c59be2cf11be848b737", - "IPY_MODEL_aa0c0897f1254968927e8c44c28045e4", - "IPY_MODEL_732d6aecb5e9436cae6b7d11e74e73f0" - ], - "layout": "IPY_MODEL_3477381b8f9f4d3fbb29eb28db3da885" - } - }, - "040ccd63278c4421b91fd587727168f5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "0421915453f14d8c96a2b86cb33e62c5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "043cfd8c94c743939207ce6de3310b1a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "046f29bba4e140f09f33b6014c0bd0b6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "047eceaff8694fa392bff90945d70257": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_6035f11ae5f84cf6bec60ad9c1073262", - "style": "IPY_MODEL_dd92365d08204e5686869c4a807533f9", - "value": " 1/1 [00:00<00:00, 20.37it/s]" - } - }, - "04d59a50ffe04b85b80598c7e2b57135": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_ba9168075b7748cc862a53aac42fa94f", - "style": "IPY_MODEL_f368bd9c4a154647a9e8f94071f07a5c", - "value": "historical forecasts: 100%" - } - }, - "04df748240d64691b812efcacc96ff0c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_cd062bb62bc44b029b0b7f537c9e80bb", - "max": 1, - "style": "IPY_MODEL_9cfda695597845b98cc6a3aa522ac996", - "value": 1 - } - }, - "059de4716a1f45ac8dbc46b096ec4750": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_bee653ba243f4978a1c04d238eab8fa7", - "max": 1, - "style": "IPY_MODEL_64927e6d576b492a8bad3b99be3f6cb8", - "value": 1 - } - }, - "05bb1d7bfdf3415481e9f1df4224ed37": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_e4970bf9dbe540a1bb723533bb4845a3", - "max": 1, - "style": "IPY_MODEL_845fde0f6aaf414c971753e986df164d", - "value": 1 - } - }, - "05c74684fefd4feead8200aa3279d44a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "06ffd0eb0e3e43b6b58b37772a97005e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "076c5f1e4f374f02b0d4bc2a896ebc9b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "07c8b47b400d4bb0bf49660ef67030e3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "08847aa1cf33464bae2d031792a32afd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "0a57142b423e4d9a9522d1d4b015200f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "0a7929a3761943cdb0b6f76a1378a770": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "0b440daae6124fc48d2943d66d5c1fed": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "0bd92d81827341b7b61071fde691c1ec": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "0c612d221a5e47ae820dc01623277090": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "0c63269791d74b169276650cd0f77c8c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_368b744a3b8343529f719a299a599d26", - "IPY_MODEL_c19cfd2aecdb448682d202167cdd5c24", - "IPY_MODEL_899e5f3019db40c6a916e4fd2ebbc167" - ], - "layout": "IPY_MODEL_7535919f0fe44867b3f88f6950a0e02c" - } - }, - "0c8ceabd9a0b467cb5a4089ceae0d539": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "0d87a7f460e340d0919d70f295333b5f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_06ffd0eb0e3e43b6b58b37772a97005e", - "style": "IPY_MODEL_2326fdd999cb4ad8b83dd69ee34fc422", - "value": "conformal forecasts: 100%" - } - }, - "0dab5325b93647bb8e3bfa4c49e19f64": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "0dad4efb53224d3d97bd90b95382b769": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "0e0af2ade6094764bc916676e1af5e80": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "0e197b702eaf48ab92dfee241fc2b8c4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_1a2c5914783e4a11aefaf46f3618bacb", - "style": "IPY_MODEL_f811d597cb524f47ba9f0360f16017f5", - "value": " 83/83 [00:00<00:00, 1011.93it/s]" - } - }, - "0e31654f8c764ac78b4052e6cee6215f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_9f760a7781994e3a9b5f5139a3649e7f", - "style": "IPY_MODEL_53213e54fc374ad78d07a29042fdd915", - "value": "conformal forecasts: 100%" - } - }, - "0e6a1e32b9644a5a8bba1bdc128db7fa": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_795a16731e3d43c9ae2e0a747cc7c0f3", - "IPY_MODEL_bc86551b3d85486881de18be47d5af76", - "IPY_MODEL_b2f28eacf0d64fd2971d1828b894b301" - ], - "layout": "IPY_MODEL_7250965f21ae43a69a1d98ca58567e2a" - } - }, - "0f451514f3bf4d7c99e96765097e6ac9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "10494a41766f4ce68ca53cf723e1aa86": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_7a099adc59f5476b8c0cc7a262b0de60", - "style": "IPY_MODEL_74bf110923b0411f9c0334f73351f811", - "value": " 83/83 [00:00<00:00, 2198.37it/s]" - } - }, - "10593fd6999c4ee49af36a48808a7c3f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_bfc521d8860f4ddb8a4af396e4c77eac", - "style": "IPY_MODEL_a8103984268d48c4bf00bcdd5fd3e9d0", - "value": " 1/1 [00:00<00:00,  1.66it/s]" - } - }, - "109a2735813c4372b555b09378ea30df": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "10eebeb049d447fe94271b11d718c427": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_9515d34e06034b68b022512acfe4fd3c", - "IPY_MODEL_ebdfe712edde49789dd7d52f0befe396", - "IPY_MODEL_a2287fe10489492dabad7e1452191210" - ], - "layout": "IPY_MODEL_623b3074379244328182141e5fa74e34" - } - }, - "1196b368df1f479390e20b63d8931d66": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_cb8ce9f130714ae8991950d01a06563c", - "style": "IPY_MODEL_5897c039193a40cd931eb499778b03e9", - "value": "historical forecasts: 100%" - } - }, - "1198e4c854054721a80343ce90dc9f13": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "124f380daa3949669ac7a1f287bdd4d9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_d47d46397ae3483fa9b7513524cd9c26", - "max": 1, - "style": "IPY_MODEL_0b440daae6124fc48d2943d66d5c1fed", - "value": 1 - } - }, - "12a3d12426384d6f92e3d41f284512a7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "12ee64ee1422425abe1989cb3805f13b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "1379a78defaa4a3490d97bcdb3dad9c5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_04d59a50ffe04b85b80598c7e2b57135", - "IPY_MODEL_2c14965e02e84b8f8b5ce1ebf0db3829", - "IPY_MODEL_047eceaff8694fa392bff90945d70257" - ], - "layout": "IPY_MODEL_b744fe458c384f20b529bd35ad049379" - } - }, - "141204ffe29e4aecb7fd9bf6fc38defd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "14658617a4924363897e3308e532d1d0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "1502d0c150ac4cbf8c4a5cbfc5ac6498": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_3ea83c4bb2114bf2b3e894aaf526396f", - "style": "IPY_MODEL_3e633b73496748a2929afe11951e7d23", - "value": "historical forecasts: 100%" - } - }, - "153a0a6dd62b432aa5934b7ed69540b6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "1613368a8a32450683b6764795d2d82a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "1659698c03d04d9490cfeeaf8230ca46": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_a6a3a9736ddb4f0686cb3e03f367cd70", - "max": 83, - "style": "IPY_MODEL_8c96e5f964f84fa28ddc6baa1aa6e5b0", - "value": 83 - } - }, - "16ad072807e04d9889b1d02f6ae7cc61": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "173133b58e6d418fa0e1ef54b1812baf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "17fb8acd00c045949dadf73f4945716d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "18ef9f7b83f647dfa9a466df55454b61": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "19493d5de029407bbb41c52af930e5ae": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "19e131628522434aa1b582521619b899": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "1a2c5914783e4a11aefaf46f3618bacb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "1a3540097a8d4b55b591f60e0a2ebae6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "1ae34bb8d5cc4cfcbdd34df3ee303a99": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "1b0c9c892ac04932ad13ca8476a311a1": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "1ba3db9ff95d4fb9aa934eaf9185a014": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "1bf4f18f6f724dffac72495bd9bc9770": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "1c23955e971c44789df8e177e26d958f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "1d755a09f64143f592d192a739b489bb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "1e7de43343e4481ea039fa9f4acfb319": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_f53cad6f60b247f1be1de43552d434e0", - "IPY_MODEL_1659698c03d04d9490cfeeaf8230ca46", - "IPY_MODEL_274ef89082c3493e9ce402612873abcc" - ], - "layout": "IPY_MODEL_6fda16224e8448fcb99eb62bf8ad44f0" - } - }, - "1eed59df3b1f4a4cb7e84e590f255c16": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "1f594807859c463bab1926755138fd37": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_1ba3db9ff95d4fb9aa934eaf9185a014", - "max": 1, - "style": "IPY_MODEL_7d330695d1b446d8a84cb59c3532df6f", - "value": 1 - } - }, - "1f748aec2d6643d9bc218a12c1a40ca3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_f213ff856269417595488428ff121a7d", - "max": 83, - "style": "IPY_MODEL_0f451514f3bf4d7c99e96765097e6ac9", - "value": 83 - } - }, - "1fe635120d3f46a8837df02c0a213a62": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "2035ee22bc854ef4b4750d7ae9673c66": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_a9327c21915540fa880fd9301c940154", - "IPY_MODEL_4f1aec86643b4fdf965cb1842095b9dc", - "IPY_MODEL_6d87f3b130034941b50f65ad8880b9ca" - ], - "layout": "IPY_MODEL_de74f152deac4e9b971c16da1a037230" - } - }, - "2046a0b74b96401ea580af6919e3196f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "20641e1e311b44ba8bf413a659980bff": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_f6824305140b41f99cc8154b960f4756", - "style": "IPY_MODEL_6dbf6aa796b64a2eb21e15c6e4a4612b", - "value": "historical forecasts: 100%" - } - }, - "211294bbf7b14ddea19697e702febdee": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "212b9c00c3344080af23937485f3df0e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "219600708b874d5bbca0d74c0af559a2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_1613368a8a32450683b6764795d2d82a", - "max": 1, - "style": "IPY_MODEL_7441cbc2533b4f15bbeb2781ffc022ad", - "value": 1 - } - }, - "22518f27f5c74454b6c67d4654bddaab": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_27c5cc8b1437495e854a130839625469", - "style": "IPY_MODEL_2e61715974b24b20b2760e2b1096d50f", - "value": "historical forecasts: 100%" - } - }, - "22739443669f4b8aaa9b97fb6464a66a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "2276400232ec423a89585db4b7d35528": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "230a646d8ba545e884a3de401d1e877b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "2326fdd999cb4ad8b83dd69ee34fc422": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "235eaf7f33b54235bcaa7b816d06231b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "23b66ce21def4202b81cd71184794d66": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "23da17d76627430ea96fdd8c29c54d0f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "23f1daafe1af4de7b075602a3d5a0a09": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "24038457afab4ecea846ed35d003885f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "24b1c032ac794a688ca4276964462482": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_2b97e20265f34b398fe405653fbaf081", - "IPY_MODEL_d50293e756534cafb0685cb12f0828be", - "IPY_MODEL_f26b7671b02748218c0b7744f5c1e9e4" - ], - "layout": "IPY_MODEL_b11aa1aa2cf6498b9b06060603da02e8" - } - }, - "250785cc51164f87a82343860a229f05": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_19493d5de029407bbb41c52af930e5ae", - "max": 1, - "style": "IPY_MODEL_cb7adc044ead45179cfb2f1949b5a3d2", - "value": 1 - } - }, - "25355f22e2c842d7a429abecea14e204": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "2560238b81d34069b1aca0f34618c838": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "257c42d542c74462885387125e64c0ff": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "25f34c9a655e4d2c8062d3802ce5e1f9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "261f9b19a1d24e3d8ff1b1675bcd68a0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "270f4ebb672a466fb6d8ae14fed37bec": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_63e2a552172340c0ac090f009cb3d638", - "IPY_MODEL_ea0100ef3d834ff3bd144727fbfbed00", - "IPY_MODEL_5dd608e79c98467a87ee0709981ee3fe" - ], - "layout": "IPY_MODEL_796fd5ff8ff24089809d8be1746a0806" - } - }, - "274ef89082c3493e9ce402612873abcc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_6905754d916346a0a8c7433065b5fc0b", - "style": "IPY_MODEL_9bb7c28f043843a5b99e16371c4839d8", - "value": " 83/83 [00:00<00:00, 2343.45it/s]" - } - }, - "27c5cc8b1437495e854a130839625469": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "292cb8e0ed0a4439b9137748d6918dd9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "2a6e83d3c47c4ee9a7d7e487f3ecbcce": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_b1f95aa0033d4ae8ac59b609d3411603", - "IPY_MODEL_059de4716a1f45ac8dbc46b096ec4750", - "IPY_MODEL_6fc0fd0ad9844b489bb70f73397f0b17" - ], - "layout": "IPY_MODEL_b9b393b01a0d44ad8d930360b1fc271f" - } - }, - "2ae871fd255b4838bec89c213decbb42": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_53d1140e674d4a38b7de1f783fd19547", - "style": "IPY_MODEL_dc23ee0d3935449c9af3f760e62a9f4f", - "value": " 1/1 [00:00<00:00,  1.55it/s]" - } - }, - "2b1d91c674694226bc54f51a7aa100f7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_0240077fbccd479aa50f3edbe55ed78a", - "max": 83, - "style": "IPY_MODEL_faa70ef2bf3143b391c8772f732b850f", - "value": 83 - } - }, - "2b97e20265f34b398fe405653fbaf081": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_c8731dbdce1e488aa822f99b115447b0", - "style": "IPY_MODEL_d3dc2db6215a4091bcbde9ee6b600679", - "value": "conformal forecasts: 100%" - } - }, - "2bb628242e764232a5d4d973d2917588": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_3ec928e2915245728d9a25f44e9469ad", - "style": "IPY_MODEL_84709d2adb67470a83cda9886910bb0a", - "value": " 1/1 [00:00<00:00, 18.88it/s]" - } - }, - "2befe7be21cb42fb8e8fa564346c22b6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_ae432b41f0364812ba8adedf7c83ee83", - "max": 1, - "style": "IPY_MODEL_dbd653a803a3401b8fea29371d2dde11", - "value": 1 - } - }, - "2c0015847be14191b060e16b67806be0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_75f77ea66cf446b9807943b97aabffb3", - "IPY_MODEL_34493bfc92ba4c6f8c63b9c744dfe94f", - "IPY_MODEL_2ae871fd255b4838bec89c213decbb42" - ], - "layout": "IPY_MODEL_c9b8bff68668414e86c1bd4b02efc80d" - } - }, - "2c14965e02e84b8f8b5ce1ebf0db3829": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_82affe409ce84ba78bbddd55bbe38780", - "max": 1, - "style": "IPY_MODEL_a962a7ed08bf40938edd9e40b3ac9fd7", - "value": 1 - } - }, - "2cb324ef035d4c5d83a3631da5fb5d9d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "2cd25b364fb544e5ab1a22ad45a0d049": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_8215748aa4004ba2872b47e2228d8d11", - "style": "IPY_MODEL_0c8ceabd9a0b467cb5a4089ceae0d539", - "value": " 1/1 [00:00<00:00,  1.18it/s]" - } - }, - "2d337bf0c89243b7ba20f61106f3230c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "2d649a44f76a4611a3ed2c7dd32ef8f9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "2d85df4a054b4ff5b603d374049e666d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "2deb970d485a4da680cc308119207024": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "2e61715974b24b20b2760e2b1096d50f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "2ec12472a3f24df29ec9a18e40d86dad": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_33876a7eefa64245b1e4ef0f0681c725", - "IPY_MODEL_462fa37a482442d8b1267bd69416fbaf", - "IPY_MODEL_ee46c46710634a5685104c15de0c964f" - ], - "layout": "IPY_MODEL_1b0c9c892ac04932ad13ca8476a311a1" - } - }, - "2ed16635c1524403af097afdc06c7996": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "2f287b35ac2446cfb9a6f6bb4deeb12a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "2f4bffd21f934bb0b8d2e0d999f57340": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "2f5b115cbfa147ad92ca2734feb947b3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "301c290b5980464394dfc90b36d62850": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "305e929eac2e4f3f9a6e8e7533b8ce71": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "30adc481cd3b4756a5c1ba7ed3e12960": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_6bc055499c8d44eaa998484b874265b4", - "style": "IPY_MODEL_8d21d5cbb1f844109553e732e4d0d2ee", - "value": " 1/1 [00:00<00:00, 22.98it/s]" - } - }, - "311f5c64eb3d4283b948e0ad7252e7bc": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "322f0f9516f8408dbcc3e99fbe3da110": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "326836d4a47a4de9bb61bae9cda583bd": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "32ab3a13da6149ba8c500e680932f880": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "32bc6b70169643b5a0e2507bfbdb31ce": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_a7f79f22f8b1404d9e74ca8a18ba78ed", - "max": 90, - "style": "IPY_MODEL_6090139006db4d7084a9075257ca4766", - "value": 90 - } - }, - "32e69ae21de84b95b493a8bc78074c57": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_c49c04387eb542a89828fe439d796972", - "max": 1, - "style": "IPY_MODEL_211294bbf7b14ddea19697e702febdee", - "value": 1 - } - }, - "33876a7eefa64245b1e4ef0f0681c725": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_14658617a4924363897e3308e532d1d0", - "style": "IPY_MODEL_b1f6895c944e46af81fae5303d8ce45a", - "value": "historical forecasts: 100%" - } - }, - "33907617ee4941f494cb94741e4d6f99": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "34493bfc92ba4c6f8c63b9c744dfe94f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_5d0e73b96ceb4190b1ec9a4c1977cc9c", - "max": 1, - "style": "IPY_MODEL_b752afd9189244fbaf2ec82d757076dc", - "value": 1 - } - }, - "3477381b8f9f4d3fbb29eb28db3da885": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "34c1994eb7c24ec2913cc52b3176129d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_fcc152f4e20b4f73b1bb5a77576981ef", - "style": "IPY_MODEL_c0ac6b3f6e9a45d78e48d4d8c0b6445a", - "value": " 90/90 [00:00<00:00, 1569.13it/s]" - } - }, - "3512e1c0bbc44af19e5b444331605abe": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_f8b53993f91344a8b886fdc375a4a735", - "max": 83, - "style": "IPY_MODEL_fd964e19deb345ddaad2e933436fa26f", - "value": 83 - } - }, - "3601d652dd854e709addd69a199be5a8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "368b744a3b8343529f719a299a599d26": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_aaacb910c5164088884c07409b51c89a", - "style": "IPY_MODEL_07c8b47b400d4bb0bf49660ef67030e3", - "value": "historical forecasts: 100%" - } - }, - "36f02e5e15a24438ae05dd9140ba939b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "379bf7e41dfd497da9a40b3acaaf5737": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_b0f6b402165849a3b966321b698572d3", - "max": 1, - "style": "IPY_MODEL_17fb8acd00c045949dadf73f4945716d", - "value": 1 - } - }, - "37b1858f5ffa41ad9b5eb8b4f9e64092": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "37c96fba45e6423c948ac7529447ad66": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_305e929eac2e4f3f9a6e8e7533b8ce71", - "style": "IPY_MODEL_0bd92d81827341b7b61071fde691c1ec", - "value": " 1/1 [00:00<00:00, 23.37it/s]" - } - }, - "3bcbe2a9faf149d085a2fbaca0a7751a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_8dd1cc54fc2941059cd6b903fe43aad6", - "IPY_MODEL_fd53235aadcb460e8833a5db5881e1fa", - "IPY_MODEL_91d36af966e543968a2cc9560215c61b" - ], - "layout": "IPY_MODEL_2f5b115cbfa147ad92ca2734feb947b3" - } - }, - "3c5759cde1b64149b0d9b7d56c86d793": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "3c9e0cf48e054f4fbbbc5247ff0c3639": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "3cfb7897b42b465ea0988fb553e0a33d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_292cb8e0ed0a4439b9137748d6918dd9", - "style": "IPY_MODEL_91bbd89729f14e00bb2d5efb1661e958", - "value": " 1/1 [00:00<00:00,  1.66it/s]" - } - }, - "3e065117698d4aeaa591cc86a053ef90": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "3e0ad78978d641cead7a3d5cec0b806f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_ccc1b69935ba4b0885aa0ed7aec51478", - "style": "IPY_MODEL_7781b195d2ef48619537ff65c73d9e7f", - "value": " 1/1 [00:00<00:00,  1.63it/s]" - } - }, - "3e633b73496748a2929afe11951e7d23": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "3e919c8f0f774d069b98b346a3b358ea": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "3ea83c4bb2114bf2b3e894aaf526396f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "3ec928e2915245728d9a25f44e9469ad": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "3f02cc78934e4373afc3826c24c274b3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_19e131628522434aa1b582521619b899", - "style": "IPY_MODEL_efebc254756c4ce78f387ab227e7b8b4", - "value": "conformal forecasts: 100%" - } - }, - "3f242fc075dc4411875f05c60d1e0ed1": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "3fb431fd7f0a42afb89b4b612ad4284f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "40ff67a292944c4180f383705a6451fe": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "414a39bb1bed486186b0f468cede8872": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "41fe671c972044a898d41d7ec53e4319": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "4206d5b6d7fb4b1182b0d2e26500153e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_0306df6cb7d84b69a900b096325e3c58", - "max": 83, - "style": "IPY_MODEL_b99336648ff64c27972a10828806758c", - "value": 83 - } - }, - "4325a523e06c471cb7b250b2188bce7e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_ebbd993a55504c4099e1c386119933b5", - "max": 1, - "style": "IPY_MODEL_afaabeefd0024f3fb85c4dfb4b44bc89", - "value": 1 - } - }, - "432a73bb9dc54a01b2ad97cfbba08421": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "437e70bdf4c546de8be110f2d75ce345": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "44d7cf0fea2a40b295cd216b84c4cafd": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "44fbf9f904d846788c28443dca138b67": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_8b1e97708b2948688b721438d4fa6fb5", - "IPY_MODEL_e031820d407d499ea2405ce253fc057f", - "IPY_MODEL_9e1f438a9019494f9c2dd373035124f3" - ], - "layout": "IPY_MODEL_b0288164929046f3b8b6db935d05af29" - } - }, - "4525b5e09cfd49bda31ba97ad829afb1": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "45262e41a91c407c8c570f6871eab490": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "46139ccb65664027b96b01562fc5c349": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "462fa37a482442d8b1267bd69416fbaf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_5e101868de1046b8b62381adb3c3dfbc", - "max": 1, - "style": "IPY_MODEL_bfad31e3f8b44cbe84f9e22cef8f16d5", - "value": 1 - } - }, - "4694711f2b354a7ab34d1c57214ef250": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_840526fab74640ad9fb903b7eaff6628", - "max": 90, - "style": "IPY_MODEL_a9b5007ef99242ca8fe3ba02f732dca0", - "value": 90 - } - }, - "472f3d1718d74e7caa9e10091678d596": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_52251431d1864acda4a6e2f4f473a57e", - "style": "IPY_MODEL_ffbaf5a647c64b3eb80fc6fd53b729db", - "value": "historical forecasts: 100%" - } - }, - "476c01e6ec4b44e8a93209f0f00bba59": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "4a7db6f8a70d46d8b9191bf0a803b983": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_043cfd8c94c743939207ce6de3310b1a", - "max": 1, - "style": "IPY_MODEL_4be8f2787cdc48e1bbe8da79b36ca600", - "value": 1 - } - }, - "4ae5477607814e759a563de4b1331600": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "4ba07ab9e8574ac59d960d91db2ea913": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "4bd616ad7e314fd2ac8dbb4d7b2ae09e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_1fe635120d3f46a8837df02c0a213a62", - "style": "IPY_MODEL_e296745a4b7e4ac4a1c13c202fa7f5da", - "value": "conformal forecasts: 100%" - } - }, - "4be8f2787cdc48e1bbe8da79b36ca600": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "4c2bc5a5590c4e2bb2ab52e990d1bf99": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "4cca89ba9f2c43fd8111d045791363fb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "4e28e97800ae432fa2d6b03a8ee8d595": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "4f0523494f124771979bf2a5827e05ab": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "4f1aec86643b4fdf965cb1842095b9dc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_5f7e1456e0444578bdd9a07111080d3f", - "max": 83, - "style": "IPY_MODEL_d54fb00e03764a48b3566a1268fb47c5", - "value": 83 - } - }, - "4f573d1f19e54eea82824dbdddb30f64": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_b9756643d3b049bcb9412b2098dd94ce", - "max": 83, - "style": "IPY_MODEL_87b0d0c627c842c9a5aedcfa2681c869", - "value": 83 - } - }, - "4fa4679a9a1c47e9a854241b579d4b91": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "4fbf852739d646889fe2262b0aeb72c4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "50568d5ef90946f68f676e0fd4cdd682": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "5088008902e84fbfb8f6d37b4c2cbdd9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "508a4417af3a47a699908a2490599606": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "513d435a3d45489d828109795204dce8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_cb5e336c581c4689a13f94570be87e9b", - "style": "IPY_MODEL_631dbb196b294e878c24421efdffcda0", - "value": "conformal forecasts: 100%" - } - }, - "52251431d1864acda4a6e2f4f473a57e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "525c3f5999a3415d8f93036f993a3e47": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5289dd553cf944dd92b8bd9144884ce0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "53213e54fc374ad78d07a29042fdd915": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "53d1140e674d4a38b7de1f783fd19547": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "53e25a3cd02a4692991d103f05b9a83b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_e5e4088f450b469dbf5f68c83e4b533a", - "IPY_MODEL_b9b7f924a5bc4866a48329163128da5c", - "IPY_MODEL_f69eb4bb0a8249d0b6e21ea39430534e" - ], - "layout": "IPY_MODEL_05c74684fefd4feead8200aa3279d44a" - } - }, - "54022decbd5f4ef6938f066cbe40b1fa": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "54210ce290fd41e0b926777e99db6ad4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "544d62d2555b422a90b6743a59554577": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_57b0ac8c8fc64b9cbd829bd4743d6603", - "IPY_MODEL_4325a523e06c471cb7b250b2188bce7e", - "IPY_MODEL_10593fd6999c4ee49af36a48808a7c3f" - ], - "layout": "IPY_MODEL_a3dd8f7a6639424da780a4145c719a0b" - } - }, - "54b1a444e38e434ba761b494f87f9ee2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "55ba47206b5245ada90924272ce3e811": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_bcbe92d4a6a44d79b4611b0bbbd09201", - "IPY_MODEL_32bc6b70169643b5a0e2507bfbdb31ce", - "IPY_MODEL_34c1994eb7c24ec2913cc52b3176129d" - ], - "layout": "IPY_MODEL_d6607d1a2f1a4c7189d088e42030b8fb" - } - }, - "565326362f7b45dfa8b2baf217fcd3b7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "56a0609fde2e4d9581e3082ea60031d5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_e1637d15aec14d1aacf6d22613784ae0", - "IPY_MODEL_250785cc51164f87a82343860a229f05", - "IPY_MODEL_6babfb5b36d1493f91ef984478a73ea8" - ], - "layout": "IPY_MODEL_9de09ecfb8014c6da02f689efa1387ee" - } - }, - "56eea1d0dd824d4eb6cc9a7d15b8e6b0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "57b0ac8c8fc64b9cbd829bd4743d6603": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_b5720bcdfff54d14bcc822cfda5be8bc", - "style": "IPY_MODEL_2ed16635c1524403af097afdc06c7996", - "value": "historical forecasts: 100%" - } - }, - "5897c039193a40cd931eb499778b03e9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5925fe560d2948c38ba3e3b9f6c15af3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "5b1c2a7907f34ac9ae2f7c4485156a1b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "5b4d64f43263413ba2c79548dbb37f01": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5d0e73b96ceb4190b1ec9a4c1977cc9c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "5d7ae906654d4f6dae1bb9e77e3829f8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5dd608e79c98467a87ee0709981ee3fe": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_40ff67a292944c4180f383705a6451fe", - "style": "IPY_MODEL_0e0af2ade6094764bc916676e1af5e80", - "value": " 1/1 [00:00<00:00,  1.63it/s]" - } - }, - "5e101868de1046b8b62381adb3c3dfbc": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "5e180f874b2a4f93b8f7c31b21ae9eb1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5f16a9df375d4159abbaaeaf59159ca7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "5f77b26770a2405bb251b70ff69b1cd7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_212b9c00c3344080af23937485f3df0e", - "max": 1, - "style": "IPY_MODEL_141204ffe29e4aecb7fd9bf6fc38defd", - "value": 1 - } - }, - "5f7e1456e0444578bdd9a07111080d3f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "6035f11ae5f84cf6bec60ad9c1073262": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "6090139006db4d7084a9075257ca4766": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "612f3fadf8ca4dcea11971849451ccb8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_841ab83792014d00b01434b3c79e3693", - "IPY_MODEL_04df748240d64691b812efcacc96ff0c", - "IPY_MODEL_d8535ee2a0244c61a3da7018918dcbee" - ], - "layout": "IPY_MODEL_3f242fc075dc4411875f05c60d1e0ed1" - } - }, - "61c97b7313e4447eaf89bdd81d6cb4d4": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "623b3074379244328182141e5fa74e34": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "62d36383dc9c4c7cb8ca3d1819eb8d07": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "631dbb196b294e878c24421efdffcda0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "6379bf0cc2ff4b46b753cfed14a79ef6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "63e2a552172340c0ac090f009cb3d638": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_23da17d76627430ea96fdd8c29c54d0f", - "style": "IPY_MODEL_898bb97a346543358e50d59e6c095602", - "value": "historical forecasts: 100%" - } - }, - "6483342185ae47b5bbea96cc595a5d0c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "64927e6d576b492a8bad3b99be3f6cb8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "652bcd47f1164b6184b29ea04c8cd3a6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "6545d0e29edc41b6aa96c99a7a3758e7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_61c97b7313e4447eaf89bdd81d6cb4d4", - "style": "IPY_MODEL_0a7929a3761943cdb0b6f76a1378a770", - "value": " 83/83 [00:00<00:00, 990.50it/s]" - } - }, - "670a5c507c29421b8a2c3bbdde9ce167": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "67af7d7a9139469c9db4fedc3703f0ed": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_f5df6035927f4bba8069fd186a551766", - "style": "IPY_MODEL_2d649a44f76a4611a3ed2c7dd32ef8f9", - "value": " 83/83 [00:00<00:00, 2400.98it/s]" - } - }, - "67ea3d7d6553408cb6afe960e6de69e8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "67f3053228884ef2a44a1d35896a1a8e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "68622042951c4ffd9a61517d04976b24": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "6905754d916346a0a8c7433065b5fc0b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "693df426b0d143f4b4aeee620952501d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "69ad518c8cd448d6a9dadf77f1373081": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "6a157bebd1204d338bd847917da2f137": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "6babfb5b36d1493f91ef984478a73ea8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_7f37ab59131c4af498b9041538640106", - "style": "IPY_MODEL_56eea1d0dd824d4eb6cc9a7d15b8e6b0", - "value": " 1/1 [00:00<00:00, 20.76it/s]" - } - }, - "6bc055499c8d44eaa998484b874265b4": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "6c1fd804027844888daa6a511581df36": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_4f0523494f124771979bf2a5827e05ab", - "style": "IPY_MODEL_70114d35d5ce4f959da1d46de1010b4b", - "value": "conformal forecasts: 100%" - } - }, - "6c8a160968c34bd2a9bfc18c2d6ac10f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_d39a633ad0c942319077c077187c6e19", - "IPY_MODEL_a2cd5068203045c38dda1d8af182f54b", - "IPY_MODEL_37c96fba45e6423c948ac7529447ad66" - ], - "layout": "IPY_MODEL_df526894bdb2487fb057540ecb8225cf" - } - }, - "6d7b914053794b2abfef977380b970b3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_20641e1e311b44ba8bf413a659980bff", - "IPY_MODEL_902e81612a4e40bbabe7b310578f812e", - "IPY_MODEL_eb143183e36f4f169215aac3028e0371" - ], - "layout": "IPY_MODEL_18ef9f7b83f647dfa9a466df55454b61" - } - }, - "6d87f3b130034941b50f65ad8880b9ca": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_d2776168f8064f4eb719b384021f6d4e", - "style": "IPY_MODEL_91a3a2a5e8424a2aa0cf6315550d848e", - "value": " 83/83 [00:00<00:00, 2204.98it/s]" - } - }, - "6d9af8c43625462abc2fd451f95fdf49": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_4bd616ad7e314fd2ac8dbb4d7b2ae09e", - "IPY_MODEL_fe87ea92075043068c113e956db6ba07", - "IPY_MODEL_bf7d1073aae5463f9dfd5c0d9988fdbf" - ], - "layout": "IPY_MODEL_a66de86cad5b449a909e3efbf4e8ed13" - } - }, - "6dbf6aa796b64a2eb21e15c6e4a4612b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "6e93ce66abe24cdf8228d9d511c3a977": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "6f962983ef944dfca8f7c825f35f3dab": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "6fc0fd0ad9844b489bb70f73397f0b17": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_7f88ac533c1d4a96b42591ae29ea04d7", - "style": "IPY_MODEL_735bc631b77d42a5922fd725d7a2762b", - "value": " 1/1 [00:00<00:00, 16.88it/s]" - } - }, - "6fda16224e8448fcb99eb62bf8ad44f0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "70114d35d5ce4f959da1d46de1010b4b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "709f6c77118e4e26bc7c4d017aceacb8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_6c1fd804027844888daa6a511581df36", - "IPY_MODEL_ccf98993b99a46f58ffa5c94a6a7b5dd", - "IPY_MODEL_b22c7e7cdfa0482fa4ee1c48eab38229" - ], - "layout": "IPY_MODEL_89bd65761a6142899b2a1c281cd7e5ce" - } - }, - "70c5c9cb78ec4b31b44b4f3ba74bbcc1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_afd80a018d354240b3d4f95832c60ee9", - "max": 1, - "style": "IPY_MODEL_8b27fabded3e47cfb1d7d11fde136d01", - "value": 1 - } - }, - "70f1c6ff27bf40978710cc9466d1da4d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "7250965f21ae43a69a1d98ca58567e2a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "728ed0839786489ca6f92e73ada17589": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "729b953ed9e9446687261f2fb8486153": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_03bbceffa51b42b29f29f18b33b7cf9b", - "style": "IPY_MODEL_5b4d64f43263413ba2c79548dbb37f01", - "value": "conformal forecasts: 100%" - } - }, - "7320833d710048d8a51498937d2a147c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "732d6aecb5e9436cae6b7d11e74e73f0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_98bb361809744bcab7585a5feeedf66f", - "style": "IPY_MODEL_8dbd230b8e6946f1bc3cc3d402155217", - "value": " 1/1 [00:00<00:00,  5.26it/s]" - } - }, - "73561c3527ae470b82ebab5e7d327177": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "735bc631b77d42a5922fd725d7a2762b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "73f352a5f24249b4a58229eee190878b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_a15bdbadf5de4764b2d0fd2434294ce1", - "style": "IPY_MODEL_7320833d710048d8a51498937d2a147c", - "value": "historical forecasts: 100%" - } - }, - "7403967ab01146d7a5e34beed855cd30": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_793cc64d66354b989931bfe354c99a1b", - "IPY_MODEL_1f748aec2d6643d9bc218a12c1a40ca3", - "IPY_MODEL_6545d0e29edc41b6aa96c99a7a3758e7" - ], - "layout": "IPY_MODEL_728ed0839786489ca6f92e73ada17589" - } - }, - "742bc4322c50468c83abad02ba4960ff": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "7441cbc2533b4f15bbeb2781ffc022ad": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "74775bb9d32f476abe383b6078555e7d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "74b75bd7fb934ead9aff9df5910e3ea0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_0d87a7f460e340d0919d70f295333b5f", - "IPY_MODEL_4f573d1f19e54eea82824dbdddb30f64", - "IPY_MODEL_764c69b6637c43378561b246d341a0c6" - ], - "layout": "IPY_MODEL_68622042951c4ffd9a61517d04976b24" - } - }, - "74bf110923b0411f9c0334f73351f811": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7535919f0fe44867b3f88f6950a0e02c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "7567f733a742484c840995ec070be624": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_d264237f2c674838a836964118610259", - "style": "IPY_MODEL_f1b240b33bab43baa8264d49f64a5228", - "value": " 1/1 [00:00<00:00, 18.66it/s]" - } - }, - "75e3b57272894a87be6bc335902681d9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "75f77ea66cf446b9807943b97aabffb3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_e7b71ab74d78424391a70f63d91c2f24", - "style": "IPY_MODEL_e48628240b6244259953b5e55a14d49e", - "value": "historical forecasts: 100%" - } - }, - "764c69b6637c43378561b246d341a0c6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_bd91a1c604a6492da715f6f1a586fabb", - "style": "IPY_MODEL_a293c2b365144076875e6ee3f8e5d3eb", - "value": " 83/83 [00:00<00:00, 2344.91it/s]" - } - }, - "7699561eac114a9690c653859f16a854": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "7781b195d2ef48619537ff65c73d9e7f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "78c6148423dd4b349ef3a2ca3fc6aa8d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_d8d062164169456889eb8bfacbfdd71a", - "IPY_MODEL_5f77b26770a2405bb251b70ff69b1cd7", - "IPY_MODEL_946da6d1818840a98776152dbd4287f9" - ], - "layout": "IPY_MODEL_301c290b5980464394dfc90b36d62850" - } - }, - "793cc64d66354b989931bfe354c99a1b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_d83c06173bc04e019722046ef7f79ed7", - "style": "IPY_MODEL_46139ccb65664027b96b01562fc5c349", - "value": "conformal forecasts: 100%" - } - }, - "795a16731e3d43c9ae2e0a747cc7c0f3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_9384a2180dcc4a1f91173ac25655e6b5", - "style": "IPY_MODEL_7975d48378094f068528fdc769aaef64", - "value": "historical forecasts: 100%" - } - }, - "796fd5ff8ff24089809d8be1746a0806": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "7975d48378094f068528fdc769aaef64": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7a099adc59f5476b8c0cc7a262b0de60": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "7a73d4da7a264f21ab453f714846e070": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_261f9b19a1d24e3d8ff1b1675bcd68a0", - "style": "IPY_MODEL_99f09b6a5e28462f85fb18cceeab9ae7", - "value": "historical forecasts: 100%" - } - }, - "7d330695d1b446d8a84cb59c3532df6f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "7e4d4bc33350416ba73dd248009df0ba": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "7e9509e25dd442bc804c6c5233429f44": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "7f37ab59131c4af498b9041538640106": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "7f88ac533c1d4a96b42591ae29ea04d7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "7fa801a85335427aaf80f351fa36ceeb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_8bd46b7ca53441939a2d4b0228192d03", - "IPY_MODEL_05bb1d7bfdf3415481e9f1df4224ed37", - "IPY_MODEL_ba79b76577fa4acab6c23eec93294596" - ], - "layout": "IPY_MODEL_1bf4f18f6f724dffac72495bd9bc9770" - } - }, - "8030add04f054264bbc1a923f8d2dca8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "8215748aa4004ba2872b47e2228d8d11": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "82affe409ce84ba78bbddd55bbe38780": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "83369f3092dc485582a191ac1bac8b8d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "83496947ae6443cba9788f8878b9a694": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_4cca89ba9f2c43fd8111d045791363fb", - "style": "IPY_MODEL_1d755a09f64143f592d192a739b489bb", - "value": " 1/1 [00:00<00:00, 24.72it/s]" - } - }, - "840526fab74640ad9fb903b7eaff6628": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "841ab83792014d00b01434b3c79e3693": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_3fb431fd7f0a42afb89b4b612ad4284f", - "style": "IPY_MODEL_2560238b81d34069b1aca0f34618c838", - "value": "historical forecasts: 100%" - } - }, - "845fde0f6aaf414c971753e986df164d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "84709d2adb67470a83cda9886910bb0a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "84713ec1aeaa46ca9ac78cd443a3d894": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "850bb57c7b4749de9facfe3ea3fe96ba": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "860b3b5ee9ab4a0c8cf3abfd4c4e2855": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_437e70bdf4c546de8be110f2d75ce345", - "max": 90, - "style": "IPY_MODEL_9741f5b0fc444fc09cfa7e78e16ef321", - "value": 90 - } - }, - "87646aaecef0455db20f363d89052333": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_3f02cc78934e4373afc3826c24c274b3", - "IPY_MODEL_2b1d91c674694226bc54f51a7aa100f7", - "IPY_MODEL_f798c5364ee14f88a149aaef1f644d7b" - ], - "layout": "IPY_MODEL_2f287b35ac2446cfb9a6f6bb4deeb12a" - } - }, - "87b0d0c627c842c9a5aedcfa2681c869": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "898bb97a346543358e50d59e6c095602": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "899e5f3019db40c6a916e4fd2ebbc167": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_076c5f1e4f374f02b0d4bc2a896ebc9b", - "style": "IPY_MODEL_08847aa1cf33464bae2d031792a32afd", - "value": " 1/1 [00:00<00:00,  9.48it/s]" - } - }, - "89bd65761a6142899b2a1c281cd7e5ce": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "8a11e7fac7914714baabd804abb353f3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8b1e97708b2948688b721438d4fa6fb5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_eb657554be5c4c3abe749168b88d2c02", - "style": "IPY_MODEL_62d36383dc9c4c7cb8ca3d1819eb8d07", - "value": "historical forecasts: 100%" - } - }, - "8b27fabded3e47cfb1d7d11fde136d01": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "8b3f824fa5534af697e19ead204e023d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8b717975ac3e473bb9a1c13f129ecd47": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_fa52ed03da0b45f497a2af01ae1d3949", - "IPY_MODEL_379bf7e41dfd497da9a40b3acaaf5737", - "IPY_MODEL_a6da7e9b85ec46cd8f2413244aafe861" - ], - "layout": "IPY_MODEL_ee40878b24224d7fb97734e9bae9db94" - } - }, - "8bd46b7ca53441939a2d4b0228192d03": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_9ceb5dbe6fe04e6dbd35da3b67bafbae", - "style": "IPY_MODEL_22739443669f4b8aaa9b97fb6464a66a", - "value": "historical forecasts: 100%" - } - }, - "8c96e5f964f84fa28ddc6baa1aa6e5b0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "8d21d5cbb1f844109553e732e4d0d2ee": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8dbd230b8e6946f1bc3cc3d402155217": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8dd1cc54fc2941059cd6b903fe43aad6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_67ea3d7d6553408cb6afe960e6de69e8", - "style": "IPY_MODEL_54210ce290fd41e0b926777e99db6ad4", - "value": "conformal forecasts: 100%" - } - }, - "8e78016e2b8440dbae46714e4c9d4f6b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8ec4fb1806d64869801257a182c9e4b5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "902e81612a4e40bbabe7b310578f812e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_5f16a9df375d4159abbaaeaf59159ca7", - "max": 1, - "style": "IPY_MODEL_5289dd553cf944dd92b8bd9144884ce0", - "value": 1 - } - }, - "910d6de1b997490d806f1ebb239c7bb3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_98ab70a918fc41d2933875696b76e54d", - "IPY_MODEL_860b3b5ee9ab4a0c8cf3abfd4c4e2855", - "IPY_MODEL_fe11cb18fec149efbd505aba6eecf608" - ], - "layout": "IPY_MODEL_9ae66c6f9b48415ea8d62813fb3075d6" - } - }, - "917b0eca17b7420183c7c21c5d150ee0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "91a3a2a5e8424a2aa0cf6315550d848e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "91bbd89729f14e00bb2d5efb1661e958": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "91d36af966e543968a2cc9560215c61b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_2cb324ef035d4c5d83a3631da5fb5d9d", - "style": "IPY_MODEL_525c3f5999a3415d8f93036f993a3e47", - "value": " 83/83 [00:00<00:00, 2280.54it/s]" - } - }, - "91ed5710d5274e12bae407b8b5635135": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "92eda515424946559a80f6904bca9c0d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "9384a2180dcc4a1f91173ac25655e6b5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "946da6d1818840a98776152dbd4287f9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_44d7cf0fea2a40b295cd216b84c4cafd", - "style": "IPY_MODEL_9938c360824449779f385657b5cf6782", - "value": " 1/1 [00:00<00:00, 21.47it/s]" - } - }, - "9515d34e06034b68b022512acfe4fd3c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_e653368295814c3c9d75fcbb64d6807a", - "style": "IPY_MODEL_2d85df4a054b4ff5b603d374049e666d", - "value": "historical forecasts: 100%" - } - }, - "955091278b384f15bd0f09df7b2fad90": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "957bf3a80e324e7cb06f43ff73d2b082": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_22518f27f5c74454b6c67d4654bddaab", - "IPY_MODEL_cbdc9496536042ce95524ba428356936", - "IPY_MODEL_7567f733a742484c840995ec070be624" - ], - "layout": "IPY_MODEL_8030add04f054264bbc1a923f8d2dca8" - } - }, - "96c6e9b9dcf1415dbfc7620ff9a244dc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_1196b368df1f479390e20b63d8931d66", - "IPY_MODEL_32e69ae21de84b95b493a8bc78074c57", - "IPY_MODEL_3cfb7897b42b465ea0988fb553e0a33d" - ], - "layout": "IPY_MODEL_a7672520293b4d76b8b1af1803bcee3c" - } - }, - "9741f5b0fc444fc09cfa7e78e16ef321": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "97fde8c05aae43f19c8c10293bceccb5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_7a73d4da7a264f21ab453f714846e070", - "IPY_MODEL_01f17d372087468dbfba867b610db337", - "IPY_MODEL_b52d4d49f25a47a8a64269bdf02eee84" - ], - "layout": "IPY_MODEL_4c2bc5a5590c4e2bb2ab52e990d1bf99" - } - }, - "9860c4c09b1b4a1d97224884855b5121": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_e4484c147e9c414b9c65db55fd443fd0", - "IPY_MODEL_4206d5b6d7fb4b1182b0d2e26500153e", - "IPY_MODEL_10494a41766f4ce68ca53cf723e1aa86" - ], - "layout": "IPY_MODEL_dc5fcb67874041e993fc0aabb3e91fda" - } - }, - "98ab70a918fc41d2933875696b76e54d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_2046a0b74b96401ea580af6919e3196f", - "style": "IPY_MODEL_e1e1c8cbce574d3aa94a497409a83182", - "value": "conformal forecasts: 100%" - } - }, - "98bb361809744bcab7585a5feeedf66f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "9938c360824449779f385657b5cf6782": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "99f09b6a5e28462f85fb18cceeab9ae7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "9ae66c6f9b48415ea8d62813fb3075d6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "9b1cdee9eaab4d118dd6c531567ebd77": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_45262e41a91c407c8c570f6871eab490", - "style": "IPY_MODEL_ae85c72d450e4f18a6ec84159bcb6fee", - "value": "historical forecasts: 100%" - } - }, - "9b7b8a83c663466db8f62694e1d700d6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_8ec4fb1806d64869801257a182c9e4b5", - "style": "IPY_MODEL_1198e4c854054721a80343ce90dc9f13", - "value": " 1/1 [00:00<00:00,  1.56it/s]" - } - }, - "9bb7c28f043843a5b99e16371c4839d8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "9c9ff8962659417b8adb0e202493c8a3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "9ceb5dbe6fe04e6dbd35da3b67bafbae": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "9cfda695597845b98cc6a3aa522ac996": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "9d555c8eb2fd45be84a549d8113e0d33": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "9dd71a7b9b224b879309dc6157c2eac0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "9de09ecfb8014c6da02f689efa1387ee": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "9e1f438a9019494f9c2dd373035124f3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_4ae5477607814e759a563de4b1331600", - "style": "IPY_MODEL_6379bf0cc2ff4b46b753cfed14a79ef6", - "value": " 1/1 [00:00<00:00,  1.66it/s]" - } - }, - "9f168bfac8494e21b1f4313873d4f21b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "9f760a7781994e3a9b5f5139a3649e7f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "a146177985ed494cb17ffd84fb84694f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_73f352a5f24249b4a58229eee190878b", - "IPY_MODEL_219600708b874d5bbca0d74c0af559a2", - "IPY_MODEL_dd73c82169344c49b5da881e77dd0b61" - ], - "layout": "IPY_MODEL_fcc82951e7914c43a2dd0eeb86217932" - } - }, - "a15790c4dec9419ca2660da05768820f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "a15bdbadf5de4764b2d0fd2434294ce1": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "a2287fe10489492dabad7e1452191210": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_e7343679126049a6b9f1da6e4d7f23e8", - "style": "IPY_MODEL_8e78016e2b8440dbae46714e4c9d4f6b", - "value": " 1/1 [00:00<00:00,  1.38it/s]" - } - }, - "a293c2b365144076875e6ee3f8e5d3eb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "a2cd5068203045c38dda1d8af182f54b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_cda24b6b1f4b4b9894f0716fe889a811", - "max": 1, - "style": "IPY_MODEL_173133b58e6d418fa0e1ef54b1812baf", - "value": 1 - } - }, - "a3dd8f7a6639424da780a4145c719a0b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "a45d38c972a64d50b240149d27939337": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "a511c6d154114dc6b3663dffcc784cfa": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "a62e54a301c04cbda985d5dd318f1f2d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "a66de86cad5b449a909e3efbf4e8ed13": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "a6a3a9736ddb4f0686cb3e03f367cd70": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "a6da7e9b85ec46cd8f2413244aafe861": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_5b1c2a7907f34ac9ae2f7c4485156a1b", - "style": "IPY_MODEL_040ccd63278c4421b91fd587727168f5", - "value": " 1/1 [00:00<00:00, 17.62it/s]" - } - }, - "a6fada1e0d11459c88db982a79eb6cdd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_2276400232ec423a89585db4b7d35528", - "max": 76, - "style": "IPY_MODEL_109a2735813c4372b555b09378ea30df", - "value": 76 - } - }, - "a7672520293b4d76b8b1af1803bcee3c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "a7f79f22f8b1404d9e74ca8a18ba78ed": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "a8103984268d48c4bf00bcdd5fd3e9d0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "a9327c21915540fa880fd9301c940154": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_cef7816bccc34465a7e7b7ec13f16c52", - "style": "IPY_MODEL_fa927bc8de7e4699bb1ae478419f3370", - "value": "conformal forecasts: 100%" - } - }, - "a962a7ed08bf40938edd9e40b3ac9fd7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "a9b5007ef99242ca8fe3ba02f732dca0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "aa0c0897f1254968927e8c44c28045e4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_16ad072807e04d9889b1d02f6ae7cc61", - "max": 1, - "style": "IPY_MODEL_a45d38c972a64d50b240149d27939337", - "value": 1 - } - }, - "aa574b4b08754fb093a7bba7c210c224": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "aa98949899604246aeda7cc0c6bc8d41": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_a511c6d154114dc6b3663dffcc784cfa", - "max": 1, - "style": "IPY_MODEL_6e93ce66abe24cdf8228d9d511c3a977", - "value": 1 - } - }, - "aaacb910c5164088884c07409b51c89a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "aac800df192c4a398e4a9260faf14f76": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "aacb794925ba4998b154efba03f017cb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_9b1cdee9eaab4d118dd6c531567ebd77", - "IPY_MODEL_e93bc0fb80dc4d0d83477ed4eb81ac63", - "IPY_MODEL_d7e62f9fd3ec47c5a89edcecf75fe67e" - ], - "layout": "IPY_MODEL_e40111a7cf8b4da191ffd1952c405eff" - } - }, - "ab09faee5d684e708d10a76e3059f402": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "ae1efd5ad9a9404bb18e730ccac9d2b1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ae3436ccca8c4317aa7da1dc330dad97": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ae432b41f0364812ba8adedf7c83ee83": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "ae85c72d450e4f18a6ec84159bcb6fee": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "aeb9d6c8ba114b2aa7c26c7f566ba11d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "aeeb3c88151b4bc9a684562193ef713c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_0c612d221a5e47ae820dc01623277090", - "style": "IPY_MODEL_230a646d8ba545e884a3de401d1e877b", - "value": " 1/1 [00:00<00:00,  1.25it/s]" - } - }, - "af32588550d74c13ab923434afefc9b7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "afaabeefd0024f3fb85c4dfb4b44bc89": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "afd80a018d354240b3d4f95832c60ee9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "b0288164929046f3b8b6db935d05af29": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "b0f6b402165849a3b966321b698572d3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "b11aa1aa2cf6498b9b06060603da02e8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "b195cff54aa84446967972b8ecac888a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "b1b5a081744846fea5f49d9983f2a2ee": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_d64cce733220426ab43bb20bd313307a", - "IPY_MODEL_ce7dc129d13943b4a21d7febdbe469f6", - "IPY_MODEL_e1a3b8f19ffc47f58d23de259c2e49a1" - ], - "layout": "IPY_MODEL_f493e4ff28694bdeb324d42f8b631624" - } - }, - "b1c727a12bb64e0d9d402223e5dd18c5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_472f3d1718d74e7caa9e10091678d596", - "IPY_MODEL_4a7db6f8a70d46d8b9191bf0a803b983", - "IPY_MODEL_fab0c9fa40a54ccfb1d91b9747c9e434" - ], - "layout": "IPY_MODEL_01d5e57d11024dfb84fd6e6aff24894e" - } - }, - "b1f6895c944e46af81fae5303d8ce45a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b1f95aa0033d4ae8ac59b609d3411603": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_742bc4322c50468c83abad02ba4960ff", - "style": "IPY_MODEL_8b3f824fa5534af697e19ead204e023d", - "value": "historical forecasts: 100%" - } - }, - "b22c7e7cdfa0482fa4ee1c48eab38229": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_3e065117698d4aeaa591cc86a053ef90", - "style": "IPY_MODEL_f8116c7518a847f0b0e0c818b79fea6a", - "value": " 90/90 [00:00<00:00, 1599.75it/s]" - } - }, - "b27da71036894d49a6654bfc5729eaed": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_92eda515424946559a80f6904bca9c0d", - "style": "IPY_MODEL_2deb970d485a4da680cc308119207024", - "value": "historical forecasts: 100%" - } - }, - "b2f28eacf0d64fd2971d1828b894b301": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_9f168bfac8494e21b1f4313873d4f21b", - "style": "IPY_MODEL_b6c6808fc8dc4c1c9594f5387c749eb7", - "value": " 1/1 [00:00<00:00, 20.25it/s]" - } - }, - "b335382757dd4f2985142a9e33db3cf7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_4e28e97800ae432fa2d6b03a8ee8d595", - "style": "IPY_MODEL_d0c992e4d28043d68c9ea2e00e45e9a3", - "value": "historical forecasts: 100%" - } - }, - "b52d4d49f25a47a8a64269bdf02eee84": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_74775bb9d32f476abe383b6078555e7d", - "style": "IPY_MODEL_5d7ae906654d4f6dae1bb9e77e3829f8", - "value": " 1/1 [00:00<00:00, 22.57it/s]" - } - }, - "b5720bcdfff54d14bcc822cfda5be8bc": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "b6c6808fc8dc4c1c9594f5387c749eb7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b744fe458c384f20b529bd35ad049379": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "b752afd9189244fbaf2ec82d757076dc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "b94428b9240949288d3f5b6d9c53385a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b9756643d3b049bcb9412b2098dd94ce": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "b99336648ff64c27972a10828806758c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "b9b393b01a0d44ad8d930360b1fc271f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "b9b7f924a5bc4866a48329163128da5c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_1c23955e971c44789df8e177e26d958f", - "max": 90, - "style": "IPY_MODEL_0a57142b423e4d9a9522d1d4b015200f", - "value": 90 - } - }, - "ba79b76577fa4acab6c23eec93294596": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_0dad4efb53224d3d97bd90b95382b769", - "style": "IPY_MODEL_5088008902e84fbfb8f6d37b4c2cbdd9", - "value": " 1/1 [00:00<00:00,  1.43it/s]" - } - }, - "ba8715e3f29147e7bca4cfdaeaabfa57": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "ba9168075b7748cc862a53aac42fa94f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "bc86551b3d85486881de18be47d5af76": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_7699561eac114a9690c653859f16a854", - "max": 1, - "style": "IPY_MODEL_54b1a444e38e434ba761b494f87f9ee2", - "value": 1 - } - }, - "bcbe92d4a6a44d79b4611b0bbbd09201": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_6a157bebd1204d338bd847917da2f137", - "style": "IPY_MODEL_693df426b0d143f4b4aeee620952501d", - "value": "conformal forecasts: 100%" - } - }, - "bd4384c207ba4748a640d1cd8921785e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "bd91a1c604a6492da715f6f1a586fabb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "bee653ba243f4978a1c04d238eab8fa7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "bf7d1073aae5463f9dfd5c0d9988fdbf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_e4d33cfa33764128bb1679f340e42d4f", - "style": "IPY_MODEL_f3443f898d8e4541b2e6b8b45e29da3f", - "value": " 83/83 [00:00<00:00, 2354.14it/s]" - } - }, - "bfad31e3f8b44cbe84f9e22cef8f16d5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "bfc521d8860f4ddb8a4af396e4c77eac": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "c0ac6b3f6e9a45d78e48d4d8c0b6445a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "c0e40037fb5c4d908d88f5c5f2e9e42b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_b27da71036894d49a6654bfc5729eaed", - "IPY_MODEL_124f380daa3949669ac7a1f287bdd4d9", - "IPY_MODEL_ea25232ab9f94343a1f9c0d5169d0a15" - ], - "layout": "IPY_MODEL_d9247af3d40c44b5a14a224d4373481d" - } - }, - "c19cfd2aecdb448682d202167cdd5c24": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_3e919c8f0f774d069b98b346a3b358ea", - "max": 1, - "style": "IPY_MODEL_fbd07f9a78044cc78e6ca1383f0a99bd", - "value": 1 - } - }, - "c338c2806f9b4c59be2cf11be848b737": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_1ae34bb8d5cc4cfcbdd34df3ee303a99", - "style": "IPY_MODEL_efa8d685606d40e09f8f1a5823bf1c79", - "value": "historical forecasts: 100%" - } - }, - "c3fb520d60af4c6188730a9be8415050": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "c49c04387eb542a89828fe439d796972": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "c6a5ccdbc8e24f2d8831d5cf761eddf1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_b335382757dd4f2985142a9e33db3cf7", - "IPY_MODEL_ff070d6c97f244e6ae46cd864c88c614", - "IPY_MODEL_30adc481cd3b4756a5c1ba7ed3e12960" - ], - "layout": "IPY_MODEL_9dd71a7b9b224b879309dc6157c2eac0" - } - }, - "c72226a3db38408386368ab0becac56d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_23f1daafe1af4de7b075602a3d5a0a09", - "max": 1, - "style": "IPY_MODEL_153a0a6dd62b432aa5934b7ed69540b6", - "value": 1 - } - }, - "c748f293ef5c45698b4d59e3f13ec4c2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_f034d20c3f2e4e3e98734132ab1803de", - "IPY_MODEL_70c5c9cb78ec4b31b44b4f3ba74bbcc1", - "IPY_MODEL_2cd25b364fb544e5ab1a22ad45a0d049" - ], - "layout": "IPY_MODEL_37b1858f5ffa41ad9b5eb8b4f9e64092" - } - }, - "c86e03a2f87247798bc8f72f8e213c72": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "c8731dbdce1e488aa822f99b115447b0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "c8d61ddf5df64e3fa3a2ed71cbbd1c14": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_41fe671c972044a898d41d7ec53e4319", - "max": 83, - "style": "IPY_MODEL_670a5c507c29421b8a2c3bbdde9ce167", - "value": 83 - } - }, - "c9b8bff68668414e86c1bd4b02efc80d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "cb5e336c581c4689a13f94570be87e9b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "cb7adc044ead45179cfb2f1949b5a3d2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "cb8ce9f130714ae8991950d01a06563c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "cbdc9496536042ce95524ba428356936": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_25f34c9a655e4d2c8062d3802ce5e1f9", - "max": 1, - "style": "IPY_MODEL_ce51fefbc7c94f83af5c367e2de93f4f", - "value": 1 - } - }, - "ccc1b69935ba4b0885aa0ed7aec51478": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "ccf98993b99a46f58ffa5c94a6a7b5dd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_c86e03a2f87247798bc8f72f8e213c72", - "max": 90, - "style": "IPY_MODEL_fe2ae6e302f849be8a4d5006270fdea1", - "value": 90 - } - }, - "cd03113757ac49ffba8e6569cd606de4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_0e31654f8c764ac78b4052e6cee6215f", - "IPY_MODEL_3512e1c0bbc44af19e5b444331605abe", - "IPY_MODEL_0e197b702eaf48ab92dfee241fc2b8c4" - ], - "layout": "IPY_MODEL_aac800df192c4a398e4a9260faf14f76" - } - }, - "cd062bb62bc44b029b0b7f537c9e80bb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "cd1f8088982342ddbe58b3c3df5d42b1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_513d435a3d45489d828109795204dce8", - "IPY_MODEL_4694711f2b354a7ab34d1c57214ef250", - "IPY_MODEL_e73baf7b8a7d4f72b6d7aa24f7c653e2" - ], - "layout": "IPY_MODEL_36f02e5e15a24438ae05dd9140ba939b" - } - }, - "cda24b6b1f4b4b9894f0716fe889a811": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "ce51fefbc7c94f83af5c367e2de93f4f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "ce7dc129d13943b4a21d7febdbe469f6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_33907617ee4941f494cb94741e4d6f99", - "max": 1, - "style": "IPY_MODEL_aeb9d6c8ba114b2aa7c26c7f566ba11d", - "value": 1 - } - }, - "ced449477e7b4b04897e3423b2b10d65": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "cef7816bccc34465a7e7b7ec13f16c52": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "d0c992e4d28043d68c9ea2e00e45e9a3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "d130eda4991c4b39b38236f896e9a579": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_ed9b67ad897c47ca8a0fa18cf7077018", - "IPY_MODEL_aa98949899604246aeda7cc0c6bc8d41", - "IPY_MODEL_9b7b8a83c663466db8f62694e1d700d6" - ], - "layout": "IPY_MODEL_046f29bba4e140f09f33b6014c0bd0b6" - } - }, - "d264237f2c674838a836964118610259": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "d2776168f8064f4eb719b384021f6d4e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "d39a633ad0c942319077c077187c6e19": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_25355f22e2c842d7a429abecea14e204", - "style": "IPY_MODEL_3601d652dd854e709addd69a199be5a8", - "value": "historical forecasts: 100%" - } - }, - "d3dc2db6215a4091bcbde9ee6b600679": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "d47d46397ae3483fa9b7513524cd9c26": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "d50293e756534cafb0685cb12f0828be": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_ced449477e7b4b04897e3423b2b10d65", - "max": 62, - "style": "IPY_MODEL_83369f3092dc485582a191ac1bac8b8d", - "value": 62 - } - }, - "d53eb0bdd13e4749803dd43e50dfa10f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_fc89f10b682346b1bbda76b1421f50f8", - "IPY_MODEL_a6fada1e0d11459c88db982a79eb6cdd", - "IPY_MODEL_ee220e8d7a7f47b2810904a754232b33" - ], - "layout": "IPY_MODEL_23b66ce21def4202b81cd71184794d66" - } - }, - "d54fb00e03764a48b3566a1268fb47c5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "d5907c2c1c7940458460f086ac7f5adf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "d64cce733220426ab43bb20bd313307a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_12ee64ee1422425abe1989cb3805f13b", - "style": "IPY_MODEL_432a73bb9dc54a01b2ad97cfbba08421", - "value": "historical forecasts: 100%" - } - }, - "d6607d1a2f1a4c7189d088e42030b8fb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "d66ecfd08ab34af3b82755827f6e3474": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_565326362f7b45dfa8b2baf217fcd3b7", - "style": "IPY_MODEL_414a39bb1bed486186b0f468cede8872", - "value": "historical forecasts: 100%" - } - }, - "d7729ffa74b94ceab27ffce5e1ba671d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_652bcd47f1164b6184b29ea04c8cd3a6", - "style": "IPY_MODEL_4fbf852739d646889fe2262b0aeb72c4", - "value": "historical forecasts: 100%" - } - }, - "d7e62f9fd3ec47c5a89edcecf75fe67e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_efa5676aaf87433c86dfc3062ca16316", - "style": "IPY_MODEL_8a11e7fac7914714baabd804abb353f3", - "value": " 1/1 [00:00<00:00, 22.51it/s]" - } - }, - "d83c06173bc04e019722046ef7f79ed7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "d8535ee2a0244c61a3da7018918dcbee": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_b195cff54aa84446967972b8ecac888a", - "style": "IPY_MODEL_01f0742d352a4dc69ef1a8988c73e5ea", - "value": " 1/1 [00:00<00:00, 27.55it/s]" - } - }, - "d8d062164169456889eb8bfacbfdd71a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_24038457afab4ecea846ed35d003885f", - "style": "IPY_MODEL_ecd2712c2d4d4d16aae8da29d9011607", - "value": "historical forecasts: 100%" - } - }, - "d9247af3d40c44b5a14a224d4373481d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "daff091b192b4574a5f509431bb1ba82": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "dbd653a803a3401b8fea29371d2dde11": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "dc23ee0d3935449c9af3f760e62a9f4f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "dc5fcb67874041e993fc0aabb3e91fda": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "dd73c82169344c49b5da881e77dd0b61": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_fc6179df9b8d43f99b5acf28116b6c39", - "style": "IPY_MODEL_f3a3ab8bfeac4afeba5095b6804a519b", - "value": " 1/1 [00:00<00:00,  1.73it/s]" - } - }, - "dd92365d08204e5686869c4a807533f9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "de74f152deac4e9b971c16da1a037230": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "df526894bdb2487fb057540ecb8225cf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "df621b30e8494e78999c738510add577": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "e031820d407d499ea2405ce253fc057f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_e13eba8e1f4644c3a5b47edd16e5c692", - "max": 1, - "style": "IPY_MODEL_f36f7b2a368a4d9eb46132521f01f9d7", - "value": 1 - } - }, - "e13eba8e1f4644c3a5b47edd16e5c692": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "e1637d15aec14d1aacf6d22613784ae0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_7e4d4bc33350416ba73dd248009df0ba", - "style": "IPY_MODEL_3c9e0cf48e054f4fbbbc5247ff0c3639", - "value": "historical forecasts: 100%" - } - }, - "e1a3b8f19ffc47f58d23de259c2e49a1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_7e9509e25dd442bc804c6c5233429f44", - "style": "IPY_MODEL_235eaf7f33b54235bcaa7b816d06231b", - "value": " 1/1 [00:00<00:00,  1.62it/s]" - } - }, - "e1e1c8cbce574d3aa94a497409a83182": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "e255bc9adb1f45c7bb3b7beb958eeee2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "e296745a4b7e4ac4a1c13c202fa7f5da": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "e40111a7cf8b4da191ffd1952c405eff": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "e4484c147e9c414b9c65db55fd443fd0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_a15790c4dec9419ca2660da05768820f", - "style": "IPY_MODEL_ae3436ccca8c4317aa7da1dc330dad97", - "value": "conformal forecasts: 100%" - } - }, - "e48628240b6244259953b5e55a14d49e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "e4970bf9dbe540a1bb723533bb4845a3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "e4d33cfa33764128bb1679f340e42d4f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "e59c7f2a15014da59c6781ccac26a36e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_aa574b4b08754fb093a7bba7c210c224", - "style": "IPY_MODEL_c3fb520d60af4c6188730a9be8415050", - "value": "historical forecasts: 100%" - } - }, - "e5a2dab9bf0e49cb9b51d25c39d16cb9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_d66ecfd08ab34af3b82755827f6e3474", - "IPY_MODEL_c72226a3db38408386368ab0becac56d", - "IPY_MODEL_3e0ad78978d641cead7a3d5cec0b806f" - ], - "layout": "IPY_MODEL_1eed59df3b1f4a4cb7e84e590f255c16" - } - }, - "e5e4088f450b469dbf5f68c83e4b533a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_fffb7937e50e4c85a531d39c8225f956", - "style": "IPY_MODEL_5e180f874b2a4f93b8f7c31b21ae9eb1", - "value": "conformal forecasts: 100%" - } - }, - "e64a6409d08844ae82860d97a4964a64": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_75e3b57272894a87be6bc335902681d9", - "max": 1, - "style": "IPY_MODEL_67f3053228884ef2a44a1d35896a1a8e", - "value": 1 - } - }, - "e653368295814c3c9d75fcbb64d6807a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "e7343679126049a6b9f1da6e4d7f23e8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "e73baf7b8a7d4f72b6d7aa24f7c653e2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_2d337bf0c89243b7ba20f61106f3230c", - "style": "IPY_MODEL_bd4384c207ba4748a640d1cd8921785e", - "value": " 90/90 [00:00<00:00, 1542.45it/s]" - } - }, - "e7b71ab74d78424391a70f63d91c2f24": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "e93bc0fb80dc4d0d83477ed4eb81ac63": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_4525b5e09cfd49bda31ba97ad829afb1", - "max": 1, - "style": "IPY_MODEL_50568d5ef90946f68f676e0fd4cdd682", - "value": 1 - } - }, - "ea0100ef3d834ff3bd144727fbfbed00": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_efccdc70aea34a059ead5d089b26280f", - "max": 1, - "style": "IPY_MODEL_84713ec1aeaa46ca9ac78cd443a3d894", - "value": 1 - } - }, - "ea25232ab9f94343a1f9c0d5169d0a15": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_850bb57c7b4749de9facfe3ea3fe96ba", - "style": "IPY_MODEL_4ba07ab9e8574ac59d960d91db2ea913", - "value": " 1/1 [00:00<00:00,  1.61it/s]" - } - }, - "eb143183e36f4f169215aac3028e0371": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_70f1c6ff27bf40978710cc9466d1da4d", - "style": "IPY_MODEL_32ab3a13da6149ba8c500e680932f880", - "value": " 1/1 [00:00<00:00,  1.39it/s]" - } - }, - "eb657554be5c4c3abe749168b88d2c02": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "ebbd993a55504c4099e1c386119933b5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "ebdfe712edde49789dd7d52f0befe396": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_0dab5325b93647bb8e3bfa4c49e19f64", - "max": 1, - "style": "IPY_MODEL_ee7b3c424b9c4023b77de5409dd3b3f8", - "value": 1 - } - }, - "ec394383bb404e73ba01278096576f95": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_d7729ffa74b94ceab27ffce5e1ba671d", - "IPY_MODEL_1f594807859c463bab1926755138fd37", - "IPY_MODEL_83496947ae6443cba9788f8878b9a694" - ], - "layout": "IPY_MODEL_2f4bffd21f934bb0b8d2e0d999f57340" - } - }, - "ecd2712c2d4d4d16aae8da29d9011607": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ed806c4e08384cd09eca536a92ea4055": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "ed9b67ad897c47ca8a0fa18cf7077018": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_9c9ff8962659417b8adb0e202493c8a3", - "style": "IPY_MODEL_508a4417af3a47a699908a2490599606", - "value": "historical forecasts: 100%" - } - }, - "ee220e8d7a7f47b2810904a754232b33": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_4fa4679a9a1c47e9a854241b579d4b91", - "style": "IPY_MODEL_917b0eca17b7420183c7c21c5d150ee0", - "value": " 76/76 [00:00<00:00, 2170.18it/s]" - } - }, - "ee40878b24224d7fb97734e9bae9db94": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "ee46c46710634a5685104c15de0c964f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_12a3d12426384d6f92e3d41f284512a7", - "style": "IPY_MODEL_3c5759cde1b64149b0d9b7d56c86d793", - "value": " 1/1 [00:00<00:00,  1.63it/s]" - } - }, - "ee56ca1e4b5f42fa831b085e2a6c87d5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "ee7b3c424b9c4023b77de5409dd3b3f8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "eebe728bdc824b8d83d3e73653063c3e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "efa5676aaf87433c86dfc3062ca16316": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "efa8d685606d40e09f8f1a5823bf1c79": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "efccdc70aea34a059ead5d089b26280f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "efebc254756c4ce78f387ab227e7b8b4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "f034d20c3f2e4e3e98734132ab1803de": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_a62e54a301c04cbda985d5dd318f1f2d", - "style": "IPY_MODEL_ae1efd5ad9a9404bb18e730ccac9d2b1", - "value": "historical forecasts: 100%" - } - }, - "f1b240b33bab43baa8264d49f64a5228": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "f213ff856269417595488428ff121a7d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "f26b7671b02748218c0b7744f5c1e9e4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_df621b30e8494e78999c738510add577", - "style": "IPY_MODEL_91ed5710d5274e12bae407b8b5635135", - "value": " 62/62 [00:00<00:00, 1329.59it/s]" - } - }, - "f3443f898d8e4541b2e6b8b45e29da3f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "f368bd9c4a154647a9e8f94071f07a5c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "f36f7b2a368a4d9eb46132521f01f9d7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "f3a3ab8bfeac4afeba5095b6804a519b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "f493e4ff28694bdeb324d42f8b631624": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "f53cad6f60b247f1be1de43552d434e0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_ee56ca1e4b5f42fa831b085e2a6c87d5", - "style": "IPY_MODEL_b94428b9240949288d3f5b6d9c53385a", - "value": "conformal forecasts: 100%" - } - }, - "f5df6035927f4bba8069fd186a551766": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "f6824305140b41f99cc8154b960f4756": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "f69eb4bb0a8249d0b6e21ea39430534e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_476c01e6ec4b44e8a93209f0f00bba59", - "style": "IPY_MODEL_73561c3527ae470b82ebab5e7d327177", - "value": " 90/90 [00:00<00:00, 1576.93it/s]" - } - }, - "f798c5364ee14f88a149aaef1f644d7b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_257c42d542c74462885387125e64c0ff", - "style": "IPY_MODEL_daff091b192b4574a5f509431bb1ba82", - "value": " 83/83 [00:00<00:00, 2336.58it/s]" - } - }, - "f8116c7518a847f0b0e0c818b79fea6a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "f811d597cb524f47ba9f0360f16017f5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "f8b53993f91344a8b886fdc375a4a735": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "fa52ed03da0b45f497a2af01ae1d3949": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_9d555c8eb2fd45be84a549d8113e0d33", - "style": "IPY_MODEL_0421915453f14d8c96a2b86cb33e62c5", - "value": "historical forecasts: 100%" - } - }, - "fa927bc8de7e4699bb1ae478419f3370": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "faa70ef2bf3143b391c8772f732b850f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "fab0c9fa40a54ccfb1d91b9747c9e434": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_5925fe560d2948c38ba3e3b9f6c15af3", - "style": "IPY_MODEL_d5907c2c1c7940458460f086ac7f5adf", - "value": " 1/1 [00:00<00:00,  1.73it/s]" - } - }, - "fbd07f9a78044cc78e6ca1383f0a99bd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "fc6179df9b8d43f99b5acf28116b6c39": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "fc89f10b682346b1bbda76b1421f50f8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_ba8715e3f29147e7bca4cfdaeaabfa57", - "style": "IPY_MODEL_69ad518c8cd448d6a9dadf77f1373081", - "value": "conformal forecasts: 100%" - } - }, - "fcc152f4e20b4f73b1bb5a77576981ef": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "fcc82951e7914c43a2dd0eeb86217932": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "fd53235aadcb460e8833a5db5881e1fa": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_326836d4a47a4de9bb61bae9cda583bd", - "max": 83, - "style": "IPY_MODEL_6483342185ae47b5bbea96cc595a5d0c", - "value": 83 - } - }, - "fd964e19deb345ddaad2e933436fa26f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "fe11cb18fec149efbd505aba6eecf608": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_1a3540097a8d4b55b591f60e0a2ebae6", - "style": "IPY_MODEL_af32588550d74c13ab923434afefc9b7", - "value": " 90/90 [00:00<00:00, 1563.77it/s]" - } - }, - "fe2ae6e302f849be8a4d5006270fdea1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "fe87ea92075043068c113e956db6ba07": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_ab09faee5d684e708d10a76e3059f402", - "max": 83, - "style": "IPY_MODEL_6f962983ef944dfca8f7c825f35f3dab", - "value": 83 - } - }, - "ff070d6c97f244e6ae46cd864c88c614": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_955091278b384f15bd0f09df7b2fad90", - "max": 1, - "style": "IPY_MODEL_54022decbd5f4ef6938f066cbe40b1fa", - "value": 1 - } - }, - "ff15cca20d5644328684a1cfc846a3aa": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_1502d0c150ac4cbf8c4a5cbfc5ac6498", - "IPY_MODEL_e64a6409d08844ae82860d97a4964a64", - "IPY_MODEL_aeeb3c88151b4bc9a684562193ef713c" - ], - "layout": "IPY_MODEL_322f0f9516f8408dbcc3e99fbe3da110" - } - }, - "ff4ab42fd56d443ea79e6f319a197ada": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_729b953ed9e9446687261f2fb8486153", - "IPY_MODEL_c8d61ddf5df64e3fa3a2ed71cbbd1c14", - "IPY_MODEL_67af7d7a9139469c9db4fedc3703f0ed" - ], - "layout": "IPY_MODEL_311f5c64eb3d4283b948e0ad7252e7bc" - } - }, - "ffbaf5a647c64b3eb80fc6fd53b729db": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "fffb7937e50e4c85a531d39c8225f956": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - } - }, + "state": {}, "version_major": 2, "version_minor": 0 } From a321a374740910fb28d06d64ba5b9dc259d4a7ae Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sun, 17 Nov 2024 12:25:46 +0100 Subject: [PATCH 59/78] improve stride handling --- darts/models/forecasting/conformal_models.py | 109 +++++++++++------- .../forecasting/test_conformal_model.py | 43 ++++++- .../forecasting/test_historical_forecasts.py | 4 +- darts/utils/historical_forecasts/utils.py | 30 ++++- 4 files changed, 139 insertions(+), 47 deletions(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index 33ffb766d2..989010c98c 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -27,6 +27,7 @@ from darts.utils import _build_tqdm_iterator, _with_sanity_checks from darts.utils.historical_forecasts.utils import ( _adjust_historical_forecasts_time_index, + _conformal_historical_forecasts_general_checks, ) from darts.utils.timeseries_generation import _build_forecast_series from darts.utils.ts_utils import ( @@ -60,9 +61,9 @@ def __init__( quantiles: list[float], symmetric: bool = True, cal_length: Optional[int] = None, + cal_stride: int = 1, num_samples: int = 500, random_state: Optional[int] = None, - stride_cal: bool = False, ): """Base Conformal Prediction Model. @@ -80,16 +81,15 @@ def __init__( fitted before. In general the workflow of the models to produce one calibrated forecast/prediction is as follows: - - Extract a calibration set: The number of calibration examples from the most recent past to use for one - conformal prediction can be defined at model creation with parameter `cal_length`. If `stride_cal` is `True`, - then the same `stride` from the forecasting methods is applied to the calibration set, and more calibration - examples are required (`cal_length * stride` historical forecasts that were generated with `stride=1`). + - Extract a calibration set: The number of calibration examples (forecast errors) from the most recent past to + use for one conformal prediction can be defined at model creation with parameter `cal_length`. Requires a + minimum of `cal_stride * (cal_length or 1)` calibration examples before the (first) conformal forecast. To make your life simpler, we support two modes: - Automatic extraction of the calibration set from the past of your input series (`series`, `past_covariates`, ...). This is the default mode and our predict/forecasting/backtest/.... API is identical to any other forecasting model - Supply a fixed calibration set with parameters `cal_series`, `cal_past_covariates`, ... . - - Generate historical forecasts on the calibration set (using the forecasting model) + - Generate historical forecasts on the calibration set (using the forecasting model) with a stride `cal_stride`. - Compute the errors/non-conformity scores (specific to each conformal model) on these historical forecasts - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model creation with parameter `quantiles`). @@ -116,14 +116,14 @@ def __init__( cal_length The number of past forecast residuals/errors to consider as calibration input for each conformal forecast. If `None`, considers all past residuals. + cal_stride + Whether to apply the same historical forecast `stride` to the non-conformity scores of the calibration set. num_samples Number of times a prediction is sampled from the underlying `model` if it is probabilistic. Uses `1` for deterministic models. This is different to the `num_samples` produced by the conformal model which can be set in downstream forecasting tasks. random_state Control the randomness of probabilistic conformal forecasts (sample generation) across different runs. - stride_cal - Whether to apply the same historical forecast `stride` to the non-conformity scores of the calibration set. """ if not isinstance(model, GlobalForecastingModel) or not model._fit_called: raise_log( @@ -131,6 +131,16 @@ def __init__( logger=logger, ) _check_quantiles(quantiles) + + if cal_length is not None and cal_length < 1: + raise_log( + ValueError("`cal_length` must be `>=1` or `None`."), logger=logger + ) + if cal_stride is not None and cal_stride < 1: + raise_log(ValueError("`cal_stride` must be `>=1`."), logger=logger) + if num_samples is not None and num_samples < 1: + raise_log(ValueError("`num_samples` must be `>=1`."), logger=logger) + super().__init__(add_encoders=None) # quantiles and interval setup @@ -160,7 +170,7 @@ def __init__( # model setup self.model = model self.cal_length = cal_length - self.stride_cal = stride_cal + self.cal_stride = cal_stride self.num_samples = num_samples if model.supports_probabilistic_prediction else 1 self._likelihood = "quantile" self._fit_called = True @@ -223,7 +233,6 @@ def predict( cal_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, cal_past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, cal_future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - stride: int = 1, num_samples: int = 1, verbose: bool = False, predict_likelihood_parameters: bool = False, @@ -243,15 +252,16 @@ def predict( `predict_likelihood_parameters=False`, and `num_samples>>1` to the forecast method. Under the hood, the simplified workflow to produce one calibrated forecast/prediction for every step in the - horizon `n` is as follows: + horizon `n` is as follows (note: `cal_length` and `cal_stride` can be set at model creation): - - Extract a calibration set: The number of calibration examples from the most recent past to use for one - conformal prediction can be defined at model creation with parameter `cal_length`. To make your life simpler, - we support two modes: + - Extract a calibration set: The number of calibration examples (forecast errors) from the most recent past to + use for one conformal prediction can be defined at model creation with parameter `cal_length`. Requires a + minimum of `cal_stride * (cal_length or 1)` calibration examples before the (first) conformal forecast. + To make your life simpler, we support two modes: - Automatic extraction of the calibration set from the past of your input series (`series`, `past_covariates`, ...). This is the default mode. - Supply a fixed calibration set with parameters `cal_series`, `cal_past_covariates`, ... . - - Generate historical forecasts on the calibration set (using the forecasting model) + - Generate historical forecasts on the calibration set (using the forecasting model) with a stride `cal_stride`. - Compute the errors/non-conformity scores (specific to each conformal model) on these historical forecasts - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model creation with parameter `quantiles`). @@ -282,9 +292,6 @@ def predict( cal_future_covariates Optionally, a future covariates series for every input time series in `series` to use for calibration instead of `future_covariates`. - stride - The number of time steps between two consecutive predictions (and non-conformity scores) of the - calibration set. Right-bound by the first time step of the generated forecast. num_samples Number of times a prediction is sampled from the calibrated quantile predictions using linear interpolation in-between the quantiles. For larger values, the sample distribution approximates the @@ -393,7 +400,7 @@ def predict( cal_forecasts=cal_hfcs, num_samples=num_samples, forecast_horizon=n, - stride=stride, + stride=self.cal_stride, overlap_end=True, last_points_only=False, verbose=verbose, @@ -406,7 +413,10 @@ def predict( else: return [cp[0] for cp in cal_preds] - @_with_sanity_checks("_historical_forecasts_sanity_checks") + @_with_sanity_checks( + "_historical_forecasts_sanity_checks", + "_conformal_historical_forecasts_sanity_checks", + ) def historical_forecasts( self, series: Union[TimeSeries, Sequence[TimeSeries]], @@ -515,7 +525,8 @@ def historical_forecasts( If set to ``'value'``, `start` corresponds to the index value/label of the first predicted point. Will raise an error if the value is not in `series`' index. Default: ``'value'``. stride - The number of time steps between two consecutive predictions. + The number of time steps between two consecutive predictions. Must be a round-multiple of `cal_stride` + (set at model creation) and `>=cal_stride`. retrain Currently ignored by conformal models. overlap_end @@ -1137,7 +1148,7 @@ def _calibrate_forecasts( forecasting model's predictions. """ # TODO: add proper handling of `cal_stride` > 1 - # cal_stride = stride if self.stride_cal else 1 + # cal_stride = stride if self.cal_stride else 1 cal_length = self.cal_length metric, metric_kwargs = self._residuals_metric residuals = self.model.residuals( @@ -1500,6 +1511,27 @@ def _cp_component_names(self, input_series) -> list[str]: input_series.components, quantile_names(self.quantiles) ) + def _conformal_historical_forecasts_sanity_checks( + self, *args: Any, **kwargs: Any + ) -> None: + """Sanity checks for the historical_forecasts function + + Parameters + ---------- + args + The args parameter(s) provided to the historical_forecasts function. + kwargs + The kwargs parameter(s) provided to the historical_forecasts function. + + Raises + ------ + ValueError + when a check on the parameter does not pass. + """ + # parse args and kwargs + series = args[0] + _conformal_historical_forecasts_general_checks(self, series, kwargs) + @property def output_chunk_length(self) -> Optional[int]: # conformal models can predict any horizon if the calibration set is large enough @@ -1592,9 +1624,9 @@ def __init__( quantiles: list[float], symmetric: bool = True, cal_length: Optional[int] = None, + cal_stride: int = 1, num_samples: int = 500, random_state: Optional[int] = None, - stride_cal: bool = False, ): """Naive Conformal Prediction Model. @@ -1623,16 +1655,15 @@ def __init__( fitted before. In general the workflow of the models to produce one calibrated forecast/prediction is as follows: - - Extract a calibration set: The number of calibration examples from the most recent past to use for one - conformal prediction can be defined at model creation with parameter `cal_length`. If `stride_cal` is `True`, - then the same `stride` from the forecasting methods is applied to the calibration set, and more calibration - examples are required (`cal_length * stride` historical forecasts that were generated with `stride=1`). + - Extract a calibration set: The number of calibration examples (forecast errors) from the most recent past to + use for one conformal prediction can be defined at model creation with parameter `cal_length`. Requires a + minimum of `cal_stride * (cal_length or 1)` calibration examples before the (first) conformal forecast. To make your life simpler, we support two modes: - Automatic extraction of the calibration set from the past of your input series (`series`, `past_covariates`, ...). This is the default mode and our predict/forecasting/backtest/.... API is identical to any other forecasting model - Supply a fixed calibration set with parameters `cal_series`, `cal_past_covariates`, ... . - - Generate historical forecasts on the calibration set (using the forecasting model) + - Generate historical forecasts on the calibration set (using the forecasting model) with a stride `cal_stride`. - Compute the errors/non-conformity scores (as defined above) on these historical forecasts - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model creation with parameter `quantiles`). @@ -1659,14 +1690,14 @@ def __init__( cal_length The number of past forecast residuals/errors to consider as calibration input for each conformal forecast. If `None`, considers all past residuals. + cal_stride + Whether to apply the same historical forecast `stride` to the non-conformity scores of the calibration set. num_samples Number of times a prediction is sampled from the underlying `model` if it is probabilistic. Uses `1` for deterministic models. This is different to the `num_samples` produced by the conformal model which can be set in downstream forecasting tasks. random_state Control the randomness of probabilistic conformal forecasts (sample generation) across different runs. - stride_cal - Whether to apply the same historical forecast `stride` to the non-conformity scores of the calibration set. """ super().__init__( model=model, @@ -1675,7 +1706,7 @@ def __init__( cal_length=cal_length, num_samples=num_samples, random_state=random_state, - stride_cal=stride_cal, + cal_stride=cal_stride, ) def _calibrate_interval( @@ -1724,9 +1755,9 @@ def __init__( quantiles: list[float], symmetric: bool = True, cal_length: Optional[int] = None, + cal_stride: int = 1, num_samples: int = 500, random_state: Optional[int] = None, - stride_cal: bool = False, ): """Conformalized Quantile Regression Model. @@ -1757,16 +1788,16 @@ def __init__( fitted before. In general the workflow of the models to produce one calibrated forecast/prediction is as follows: - - Extract a calibration set: The number of calibration examples from the most recent past to use for one - conformal prediction can be defined at model creation with parameter `cal_length`. If `stride_cal` is `True`, - then the same `stride` from the forecasting methods is applied to the calibration set, and more calibration - examples are required (`cal_length * stride` historical forecasts that were generated with `stride=1`). + - Extract a calibration set: The number of calibration examples (forecast errors) from the most recent past to + use for one conformal prediction can be defined at model creation with parameter `cal_length`. Requires a + minimum of `cal_stride * (cal_length or 1)` calibration examples before the (first) conformal forecast. To make your life simpler, we support two modes: - Automatic extraction of the calibration set from the past of your input series (`series`, `past_covariates`, ...). This is the default mode and our predict/forecasting/backtest/.... API is identical to any other forecasting model - Supply a fixed calibration set with parameters `cal_series`, `cal_past_covariates`, ... . - Generate historical forecasts (quantile predictions) on the calibration set (using the forecasting model) + with a stride `cal_stride`. - Compute the errors/non-conformity scores (as defined above) on these historical quantile predictions - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model creation with parameter `quantiles`). @@ -1794,14 +1825,14 @@ def __init__( cal_length The number of past forecast residuals/errors to consider as calibration input for each conformal forecast. If `None`, considers all past residuals. + cal_stride + Whether to apply the same historical forecast `stride` to the non-conformity scores of the calibration set. num_samples Number of times a prediction is sampled from the underlying `model` if it is probabilistic. Uses `1` for deterministic models. This is different to the `num_samples` produced by the conformal model which can be set in downstream forecasting tasks. random_state Control the randomness of probabilistic conformal forecasts (sample generation) across different runs. - stride_cal - Whether to apply the same historical forecast `stride` to the non-conformity scores of the calibration set. """ if not model.supports_probabilistic_prediction: raise_log( @@ -1818,7 +1849,7 @@ def __init__( cal_length=cal_length, num_samples=num_samples, random_state=random_state, - stride_cal=stride_cal, + cal_stride=cal_stride, ) def _calibrate_interval( diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 10acaa8b1e..1a6f8a2d0c 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -170,6 +170,43 @@ def test_model_construction_naive(self): ConformalNaiveModel(model=global_model, quantiles=[-0.1, 0.5, 1.1]) assert str(exc.value) == "All provided quantiles must be between 0 and 1." + # `cal_length` must be `>=1` or `None` + with pytest.raises(ValueError) as exc: + ConformalNaiveModel(model=global_model, quantiles=q, cal_length=0) + assert str(exc.value) == "`cal_length` must be `>=1` or `None`." + + # `cal_stride` must be `>=1` + with pytest.raises(ValueError) as exc: + ConformalNaiveModel(model=global_model, quantiles=q, cal_stride=0) + assert str(exc.value) == "`cal_stride` must be `>=1`." + + # `num_samples` must be `>=1` + with pytest.raises(ValueError) as exc: + ConformalNaiveModel(model=global_model, quantiles=q, num_samples=0) + assert str(exc.value) == "`num_samples` must be `>=1`." + + def test_model_hfc_stride_checks(self): + series = self.ts_pass_train + model = LinearRegressionModel(**regr_kwargs).fit(series) + cp_model = ConformalNaiveModel(model=model, quantiles=q, cal_stride=2) + + expected_error_start = ( + "The provided `stride` parameter must be a round-multiple of " + "`cal_stride=2` and `>=cal_stride`." + ) + # `stride` must be >= `cal_stride` + with pytest.raises(ValueError) as exc: + cp_model.historical_forecasts(series=series, stride=1) + assert str(exc.value).startswith(expected_error_start) + + # `stride` must be a round multiple of `cal_stride` + with pytest.raises(ValueError) as exc: + cp_model.historical_forecasts(series=series, stride=3) + assert str(exc.value).startswith(expected_error_start) + + # valid stride + _ = cp_model.historical_forecasts(series=series, stride=4) + def test_model_construction_cqr(self): model_det = train_model(self.ts_pass_train, model_type="regression") model_prob_q = train_model( @@ -357,9 +394,9 @@ def test_multi_ts(self, config): n=self.horizon, series=[self.ts_pass_train, self.ts_pass_train_1], ) - assert ( - len(pred_list) == 2 - ), f"Model {model_cls} did not return a list of prediction" + assert len(pred_list) == 2, ( + f"Model {model_cls} did not return a list of prediction" + ) for pred, pred_fc in zip(pred_list, pred_fc_list): assert pred.n_components == self.ts_pass_train.n_components * 3 assert pred_fc.time_index.equals(pred.time_index) diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index 42c22e5319..7240831516 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -3300,7 +3300,7 @@ def test_conformal_historical_forecast_start(self, caplog, config): stride, ocs, ) = config - # TODO: adjust this test (the input length of `series_val`), once `stride_cal` has been properly implemented + # TODO: adjust this test (the input length of `series_val`), once `cal_stride` has been properly implemented q = [0.1, 0.5, 0.9] pred_lklp = {"num_samples": 1, "predict_likelihood_parameters": True} # compute minimum series length to generate n forecasts @@ -3359,7 +3359,7 @@ def test_conformal_historical_forecast_start(self, caplog, config): # compute conformal historical forecasts (starting at first possible conformal forecast) model = ConformalNaiveModel( - forecasting_model, quantiles=q, cal_length=cal_length, stride_cal=stride > 1 + forecasting_model, quantiles=q, cal_length=cal_length, cal_stride=stride ) with caplog.at_level(logging.WARNING): hist_fct = model.historical_forecasts( diff --git a/darts/utils/historical_forecasts/utils.py b/darts/utils/historical_forecasts/utils.py index 89465a3289..8d6bc18c3b 100644 --- a/darts/utils/historical_forecasts/utils.py +++ b/darts/utils/historical_forecasts/utils.py @@ -32,9 +32,6 @@ def _historical_forecasts_general_checks(model, series, kwargs): The forecasting model. series Either series when called from ForecastingModel, or target_series if called from RegressionModel - signature_params - A dictionary of the signature parameters of the calling method, to get the default values - Typically would be signature(self.backtest).parameters kwargs Params specified by the caller of backtest(), they take precedence over the arguments' default values """ @@ -214,6 +211,33 @@ def _historical_forecasts_general_checks(model, series, kwargs): ) +def _conformal_historical_forecasts_general_checks(model, series, kwargs): + """ + Performs checks for `ConformalModel.historical_forecasts()`. + + Parameters + ---------- + model + The forecasting model. + series + Either series when called from ForecastingModel, or target_series if called from RegressionModel + kwargs + Params specified by the caller of backtest(), they take precedence over the arguments' default values + """ + # parse kwargs + n = SimpleNamespace(**kwargs) + + # check stride + if n.stride < model.cal_stride or n.stride % model.cal_stride > 0: + raise_log( + ValueError( + f"The provided `stride` parameter must be a round-multiple of `cal_stride={model.cal_stride}` " + f"and `>=cal_stride`. Received `stride={n.stride}`" + ), + logger, + ) + + def _historical_forecasts_sanitize_kwargs( model, fit_kwargs: Optional[dict[str, Any]], From 70555dc21eb4c01bfcc377f87f6eb65880885f07 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Wed, 20 Nov 2024 09:41:21 +0100 Subject: [PATCH 60/78] remove optional input calibration set --- darts/models/forecasting/conformal_models.py | 359 ++++-------------- .../forecasting/test_conformal_model.py | 309 +-------------- .../forecasting/test_historical_forecasts.py | 65 +--- 3 files changed, 92 insertions(+), 641 deletions(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index 989010c98c..d5c0823266 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -84,11 +84,8 @@ def __init__( - Extract a calibration set: The number of calibration examples (forecast errors) from the most recent past to use for one conformal prediction can be defined at model creation with parameter `cal_length`. Requires a minimum of `cal_stride * (cal_length or 1)` calibration examples before the (first) conformal forecast. - To make your life simpler, we support two modes: - - Automatic extraction of the calibration set from the past of your input series (`series`, - `past_covariates`, ...). This is the default mode and our predict/forecasting/backtest/.... API is - identical to any other forecasting model - - Supply a fixed calibration set with parameters `cal_series`, `cal_past_covariates`, ... . + To make your life simpler, it applies automatic extraction of the calibration set from the past of your input + series (`series`, `past_covariates`, ...). - Generate historical forecasts on the calibration set (using the forecasting model) with a stride `cal_stride`. - Compute the errors/non-conformity scores (specific to each conformal model) on these historical forecasts - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model @@ -230,9 +227,6 @@ def predict( series: Union[TimeSeries, Sequence[TimeSeries]] = None, past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - cal_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - cal_past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - cal_future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, num_samples: int = 1, verbose: bool = False, predict_likelihood_parameters: bool = False, @@ -257,10 +251,8 @@ def predict( - Extract a calibration set: The number of calibration examples (forecast errors) from the most recent past to use for one conformal prediction can be defined at model creation with parameter `cal_length`. Requires a minimum of `cal_stride * (cal_length or 1)` calibration examples before the (first) conformal forecast. - To make your life simpler, we support two modes: - - Automatic extraction of the calibration set from the past of your input series (`series`, - `past_covariates`, ...). This is the default mode. - - Supply a fixed calibration set with parameters `cal_series`, `cal_past_covariates`, ... . + To make your life simpler, it applies automatic extraction of the calibration set from the past of your input + series (`series`, `past_covariates`, ...). - Generate historical forecasts on the calibration set (using the forecasting model) with a stride `cal_stride`. - Compute the errors/non-conformity scores (specific to each conformal model) on these historical forecasts - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model @@ -274,24 +266,15 @@ def predict( Forecast horizon - the number of time steps after the end of the series for which to produce predictions. series A series or sequence of series, representing the history of the target series whose future is to be - predicted. If `cal_series` is `None`, will use the past of this series for calibration. + predicted. Will use the past of this series for calibration. past_covariates Optionally, a (sequence of) past-observed covariate time series for every input time series in `series`. - Their dimension must match that of the past covariates used for training. If `cal_series` is `None`, will - use this series for calibration. + Their dimension must match that of the past covariates used for training. Will use this series for + calibration. future_covariates Optionally, a (sequence of) future-known covariate time series for every input time series in `series`. - Their dimension must match that of the past covariates used for training. If `cal_series` is `None`, will - use this series for calibration. - cal_series - Optionally, a (sequence of) target series for every input time series in `series` to use for calibration - instead of `series`. - cal_past_covariates - Optionally, a (sequence of) past covariates series for every input time series in `series` to use for - calibration instead of `past_covariates`. - cal_future_covariates - Optionally, a future covariates series for every input time series in `series` to use for calibration - instead of `future_covariates`. + Their dimension must match that of the past covariates used for training. Will use this series for + calibration. num_samples Number of times a prediction is sampled from the calibrated quantile predictions using linear interpolation in-between the quantiles. For larger values, the sample distribution approximates the @@ -347,26 +330,8 @@ def predict( show_warnings, ) - # if a calibration set is given, use it. Otherwise, use past of input as calibration - if cal_series is None: - cal_series = series - cal_past_covariates = past_covariates - cal_future_covariates = future_covariates - - cal_series = series2seq(cal_series) - if len(cal_series) != len(series): - raise_log( - ValueError( - f"Mismatch between number of `cal_series` ({len(cal_series)}) " - f"and number of `series` ({len(series)})." - ), - logger=logger, - ) - cal_past_covariates = series2seq(cal_past_covariates) - cal_future_covariates = series2seq(cal_future_covariates) - - # generate model forecast to calibrate - preds = self.model.predict( + # call predict to verify that all series have required input times + _ = self.model.predict( n=n, series=series, past_covariates=past_covariates, @@ -376,14 +341,12 @@ def predict( predict_likelihood_parameters=False, show_warnings=show_warnings, ) - # convert to multi series case with `last_points_only=False` - preds = [[pred] for pred in preds] # generate all possible forecasts for calibration cal_hfcs = self.model.historical_forecasts( - series=cal_series, - past_covariates=cal_past_covariates, - future_covariates=cal_future_covariates, + series=series, + past_covariates=past_covariates, + future_covariates=future_covariates, num_samples=self.num_samples, forecast_horizon=n, retrain=False, @@ -395,10 +358,10 @@ def predict( ) cal_preds = self._calibrate_forecasts( series=series, - forecasts=preds, - cal_series=cal_series, - cal_forecasts=cal_hfcs, + forecasts=cal_hfcs, num_samples=num_samples, + start="end", # uses last hist fc (output of `predict()`) + start_format="position", forecast_horizon=n, stride=self.cal_stride, overlap_end=True, @@ -422,9 +385,6 @@ def historical_forecasts( series: Union[TimeSeries, Sequence[TimeSeries]], past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - cal_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - cal_past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - cal_future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, forecast_horizon: int = 1, num_samples: int = 1, train_length: Optional[int] = None, @@ -458,8 +418,6 @@ def historical_forecasts( using a fixed-length `cal_length` (the start point can also be configured with `start` and `start_format`). The next forecast of length `forecast_horizon` is then calibrated on this calibration set. Subsequently, the end of the calibration set is moved forward by `stride` time steps, and the process is repeated. - You can also use a fixed calibration set to calibrate all forecasts equally by passing `cal_series`, and - optional `cal_past_covariates` and `cal_future_covariates`. By default, with `last_points_only=True`, this method returns a single time series (or a sequence of time series) composed of the last point from each calibrated historical forecast. This time series will thus have a @@ -470,25 +428,16 @@ def historical_forecasts( Parameters ---------- series - A (sequence of) target time series used to successively compute the historical forecasts. If `cal_series` - is `None`, will use the past of this series for calibration. + A (sequence of) target time series used to successively compute the historical forecasts. Will use the past + of this series for calibration. past_covariates Optionally, a (sequence of) past-observed covariate time series for every input time series in `series`. - Their dimension must match that of the past covariates used for training. If `cal_series` is `None`, will - use this series for calibration. + Their dimension must match that of the past covariates used for training. Will use this series for + calibration. future_covariates Optionally, a (sequence of) future-known covariate time series for every input time series in `series`. - Their dimension must match that of the past covariates used for training. If `cal_series` is `None`, will - use this series for calibration. - cal_series - Optionally, a (sequence of) target series for every input time series in `series` to use as a fixed - calibration set instead of `series`. - cal_past_covariates - Optionally, a (sequence of) past covariates series for every input time series in `series` to use as a fixed - calibration set instead of `past_covariates`. - cal_future_covariates - Optionally, a future covariates series for every input time series in `series` to use as a fixed - calibration set instead of `future_covariates`. + Their dimension must match that of the past covariates used for training. Will use this series for + calibration. forecast_horizon The forecast horizon for the predictions. num_samples @@ -575,19 +524,6 @@ def historical_forecasts( past_covariates = series2seq(past_covariates) future_covariates = series2seq(future_covariates) - if cal_series is not None: - cal_series = series2seq(cal_series) - if len(cal_series) != len(series): - raise_log( - ValueError( - f"Mismatch between number of `cal_series` ({len(cal_series)}) " - f"and number of `series` ({len(series)})." - ), - logger=logger, - ) - cal_past_covariates = series2seq(cal_past_covariates) - cal_future_covariates = series2seq(cal_future_covariates) - # generate all possible forecasts (overlap_end=True) to have enough residuals hfcs = self.model.historical_forecasts( series=series, @@ -605,31 +541,9 @@ def historical_forecasts( fit_kwargs=fit_kwargs, predict_kwargs=predict_kwargs, ) - # optionally, generate calibration forecasts - if cal_series is None: - cal_hfcs = None - else: - cal_hfcs = self.model.historical_forecasts( - series=cal_series, - past_covariates=cal_past_covariates, - future_covariates=cal_future_covariates, - num_samples=self.num_samples, - forecast_horizon=forecast_horizon, - retrain=False, - overlap_end=True, - last_points_only=last_points_only, - verbose=verbose, - show_warnings=show_warnings, - predict_likelihood_parameters=False, - enable_optimization=enable_optimization, - fit_kwargs=fit_kwargs, - predict_kwargs=predict_kwargs, - ) calibrated_forecasts = self._calibrate_forecasts( series=series, forecasts=hfcs, - cal_series=cal_series, - cal_forecasts=cal_hfcs, num_samples=num_samples, start=start, start_format=start_format, @@ -652,9 +566,6 @@ def backtest( series: Union[TimeSeries, Sequence[TimeSeries]], past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - cal_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - cal_past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - cal_future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, historical_forecasts: Optional[ Union[TimeSeries, Sequence[TimeSeries], Sequence[Sequence[TimeSeries]]] ] = None, @@ -703,25 +614,16 @@ def backtest( Parameters ---------- series - A (sequence of) target time series used to successively compute the historical forecasts. If `cal_series` - is `None`, will use the past of this series for calibration. + A (sequence of) target time series used to successively compute the historical forecasts. Will use the past + of this series for calibration. past_covariates Optionally, a (sequence of) past-observed covariate time series for every input time series in `series`. - Their dimension must match that of the past covariates used for training. If `cal_series` is `None`, will - use this series for calibration. + Their dimension must match that of the past covariates used for training. Will use this series for + calibration. future_covariates Optionally, a (sequence of) future-known covariate time series for every input time series in `series`. - Their dimension must match that of the past covariates used for training. If `cal_series` is `None`, will - use this series for calibration. - cal_series - Optionally, a (sequence of) target series for every input time series in `series` to use as a fixed - calibration set instead of `series`. - cal_past_covariates - Optionally, a (sequence of) past covariates series for every input time series in `series` to use as a fixed - calibration set instead of `past_covariates`. - cal_future_covariates - Optionally, a future covariates series for every input time series in `series` to use as a fixed - calibration set instead of `future_covariates`. + Their dimension must match that of the past covariates used for training. Will use this series for + calibration. historical_forecasts Optionally, the (or a sequence of / a sequence of sequences of) historical forecasts time series to be evaluated. Corresponds to the output of :meth:`historical_forecasts() @@ -831,32 +733,10 @@ def backtest( Same as for type `np.ndarray` but for a sequence of series. The returned metric list has length `len(series)` with the `np.ndarray` metrics for each input `series`. """ - historical_forecasts = historical_forecasts or self.historical_forecasts( + return super().backtest( series=series, past_covariates=past_covariates, future_covariates=future_covariates, - cal_series=cal_series, - cal_past_covariates=cal_past_covariates, - cal_future_covariates=cal_future_covariates, - num_samples=num_samples, - train_length=train_length, - start=start, - start_format=start_format, - forecast_horizon=forecast_horizon, - stride=stride, - retrain=retrain, - last_points_only=last_points_only, - verbose=verbose, - show_warnings=show_warnings, - predict_likelihood_parameters=predict_likelihood_parameters, - enable_optimization=enable_optimization, - fit_kwargs=fit_kwargs, - predict_kwargs=predict_kwargs, - overlap_end=overlap_end, - sample_weight=sample_weight, - ) - return super().backtest( - series=series, historical_forecasts=historical_forecasts, forecast_horizon=forecast_horizon, num_samples=num_samples, @@ -884,9 +764,6 @@ def residuals( series: Union[TimeSeries, Sequence[TimeSeries]], past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - cal_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - cal_past_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - cal_future_covariates: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, historical_forecasts: Optional[ Union[TimeSeries, Sequence[TimeSeries], Sequence[Sequence[TimeSeries]]] ] = None, @@ -945,25 +822,16 @@ def residuals( Parameters ---------- series - A (sequence of) target time series used to successively compute the historical forecasts. If `cal_series` - is `None`, will use the past of this series for calibration. + A (sequence of) target time series used to successively compute the historical forecasts. Will use the past + of this series for calibration. past_covariates Optionally, a (sequence of) past-observed covariate time series for every input time series in `series`. - Their dimension must match that of the past covariates used for training. If `cal_series` is `None`, will - use this series for calibration. + Their dimension must match that of the past covariates used for training. Will use this series for + calibration. future_covariates Optionally, a (sequence of) future-known covariate time series for every input time series in `series`. - Their dimension must match that of the past covariates used for training. If `cal_series` is `None`, will - use this series for calibration. - cal_series - Optionally, a (sequence of) target series for every input time series in `series` to use as a fixed - calibration set instead of `series`. - cal_past_covariates - Optionally, a (sequence of) past covariates series for every input time series in `series` to use as a fixed - calibration set instead of `past_covariates`. - cal_future_covariates - Optionally, a future covariates series for every input time series in `series` to use as a fixed - calibration set instead of `future_covariates`. + Their dimension must match that of the past covariates used for training. Will use this series for + calibration. historical_forecasts Optionally, the (or a sequence of / a sequence of sequences of) historical forecasts time series to be evaluated. Corresponds to the output of :meth:`historical_forecasts() @@ -1059,32 +927,10 @@ def residuals( The outer residual list has length `len(series)`. The inner lists consist of the residuals from all possible series-specific historical forecasts. """ - historical_forecasts = historical_forecasts or self.historical_forecasts( + return super().residuals( series=series, past_covariates=past_covariates, future_covariates=future_covariates, - cal_series=cal_series, - cal_past_covariates=cal_past_covariates, - cal_future_covariates=cal_future_covariates, - num_samples=num_samples, - train_length=train_length, - start=start, - start_format=start_format, - forecast_horizon=forecast_horizon, - stride=stride, - retrain=retrain, - last_points_only=last_points_only, - verbose=verbose, - show_warnings=show_warnings, - predict_likelihood_parameters=predict_likelihood_parameters, - enable_optimization=enable_optimization, - fit_kwargs=fit_kwargs, - predict_kwargs=predict_kwargs, - overlap_end=overlap_end, - sample_weight=sample_weight, - ) - return super().residuals( - series=series, historical_forecasts=historical_forecasts, forecast_horizon=forecast_horizon, num_samples=num_samples, @@ -1112,12 +958,8 @@ def _calibrate_forecasts( self, series: Sequence[TimeSeries], forecasts: Union[Sequence[Sequence[TimeSeries]], Sequence[TimeSeries]], - cal_series: Optional[Sequence[TimeSeries]] = None, - cal_forecasts: Optional[ - Union[Sequence[Sequence[TimeSeries]], Sequence[TimeSeries]] - ] = None, num_samples: int = 1, - start: Optional[Union[pd.Timestamp, float, int]] = None, + start: Optional[Union[pd.Timestamp, float, int, str]] = None, start_format: Literal["position", "value"] = "value", forecast_horizon: int = 1, stride: int = 1, @@ -1132,15 +974,11 @@ def _calibrate_forecasts( In general the workflow of the models to produce one calibrated forecast/prediction per step in the horizon is as follows: - - Generate historical forecasts for `series` and optional calibration set (`cal_series`) (using the forecasting - model) + - Generate historical forecasts for `series` (using the forecasting model) - Extract a calibration set: The forecasts from the most recent past to use as calibration for one conformal prediction. The number of examples to use can be defined at model creation with parameter - `cal_length`. We support two modes: - - Automatic extraction of the calibration set from the past of your input series (`series`, - `past_covariates`, ...). This is the default mode and our predict/forecasting/backtest/.... API is - identical to any other forecasting model - - Supply a fixed calibration set with parameters `cal_series`, `cal_past_covariates`, ... . + `cal_length`. It automatically extracts the calibration set from the past of your input series (`series`, + `past_covariates`, ...). - Compute the errors/non-conformity scores (specific to each conformal model) on these historical forecasts - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model creation with parameter `quantiles`). @@ -1152,9 +990,9 @@ def _calibrate_forecasts( cal_length = self.cal_length metric, metric_kwargs = self._residuals_metric residuals = self.model.residuals( - series=series if cal_series is None else cal_series, - historical_forecasts=forecasts if cal_series is None else cal_forecasts, - overlap_end=overlap_end if cal_series is None else True, + series=series, + historical_forecasts=forecasts, + overlap_end=overlap_end, last_points_only=last_points_only, verbose=verbose, show_warnings=show_warnings, @@ -1194,32 +1032,20 @@ def _calibrate_forecasts( min_n_cal += forecast_horizon - 1 # determine first forecast index for conformal prediction - if cal_series is None: - # we need at least one residual per point in the horizon prior to the first conformal forecast - first_idx_train = forecast_horizon + self.output_chunk_shift - # plus some additional examples based on `cal_length` - if cal_length is not None: - first_idx_train += cal_length - 1 - # check if later we need to drop some residuals without useful information (unknown residuals) - if overlap_end: - delta_end = n_steps_between( - end=last_hfc.end_time(), - start=series_.end_time(), - freq=series_.freq, - ) - else: - delta_end = 0 - else: - # calibration set is decoupled from `series` forecasts; we can start with the first forecast - first_idx_train = 0 - # check if we need to drop some residuals without useful information - cal_series_ = cal_series[series_idx] - cal_last_hfc = cal_forecasts[series_idx][-1] + # we need at least one residual per point in the horizon prior to the first conformal forecast + first_idx_train = forecast_horizon + self.output_chunk_shift + # plus some additional examples based on `cal_length` + if cal_length is not None: + first_idx_train += cal_length - 1 + # check if later we need to drop some residuals without useful information (unknown residuals) + if overlap_end: delta_end = n_steps_between( - end=cal_last_hfc.end_time(), - start=cal_series_.end_time(), - freq=cal_series_.freq, + end=last_hfc.end_time(), + start=series_.end_time(), + freq=series_.freq, ) + else: + delta_end = 0 # drop residuals without useful information last_res_idx = None @@ -1231,7 +1057,7 @@ def _calibrate_forecasts( # useful residual information only up until the forecast # starting at the last time step in `series` last_res_idx = -(delta_end - forecast_horizon + 1) - if last_res_idx is None and cal_series is None: + if last_res_idx is None: # drop at least the one residuals/forecast from the end, since we can only use prior residuals last_res_idx = -(self.output_chunk_shift + 1) # with last points only, ignore the last `horizon` residuals to avoid look-ahead bias @@ -1242,11 +1068,10 @@ def _calibrate_forecasts( res = res[:last_res_idx] if first_idx_train >= len(s_hfcs) or len(res) < min_n_cal: - set_name = "" if cal_series is None else "cal_" raise_log( ValueError( "Could not build the minimum required calibration input with the provided " - f"`{set_name}series` and `{set_name}*_covariates` at series index: {series_idx}. " + f"`series` and `*_covariates` at series index: {series_idx}. " f"Expected to generate at least `{min_n_cal}` calibration forecasts with known residuals " f"before the first conformal forecast, but could only generate `{len(res)}`." ), @@ -1254,7 +1079,10 @@ def _calibrate_forecasts( ) # adjust first index based on `start` first_idx_start = 0 - if start is not None: + if start is not None and start == "end": + # start at the last forecast + first_idx_start = len(s_hfcs) - 1 + elif start is not None: # adjust forecastable index in case of output shift or `last_points_only=True` adjust_idx = ( self.output_chunk_shift @@ -1320,41 +1148,26 @@ def _calibrate_forecasts( res = np.concatenate(res_, axis=2).T # get the last forecast index based on the residual examples - if cal_series is None: - last_fc_idx = res.shape[2] + ( - forecast_horizon + self.output_chunk_shift + last_fc_idx = res.shape[2] + (forecast_horizon + self.output_chunk_shift) + + def conformal_predict(idx_, pred_vals_): + # get the last residual index for calibration, `cal_end` is exclusive + # to avoid look-ahead bias, use only residuals from before the historical forecast start point; + # for `last_points_only=True`, the last residual historically available at the forecasting + # point is `forecast_horizon + self.output_chunk_shift - 1` steps before. The same applies to + # `last_points_only=False` thanks to the residual rearrangement + cal_end = ( + first_fc_idx + + idx_ * stride + - (forecast_horizon + self.output_chunk_shift - 1) ) - else: - last_fc_idx = len(s_hfcs) + # first residual index is shifted back by the horizon to get `cal_length` points for + # the last point in the horizon + cal_start = cal_end - cal_length if cal_length is not None else None - q_hat = None - # with a calibration set, the calibrated interval is constant across all forecasts - if cal_series is not None: - if cal_length is not None: - res = res[:, :, -cal_length:] - q_hat = self._calibrate_interval(res) + cal_res = res[:, :, cal_start:cal_end] + q_hat_ = self._calibrate_interval(cal_res) - def conformal_predict(idx_, pred_vals_): - if cal_series is None: - # get the last residual index for calibration, `cal_end` is exclusive - # to avoid look-ahead bias, use only residuals from before the historical forecast start point; - # for `last_points_only=True`, the last residual historically available at the forecasting - # point is `forecast_horizon + self.output_chunk_shift - 1` steps before. The same applies to - # `last_points_only=False` thanks to the residual rearrangement - cal_end = ( - first_fc_idx - + idx_ * stride - - (forecast_horizon + self.output_chunk_shift - 1) - ) - # first residual index is shifted back by the horizon to get `cal_length` points for - # the last point in the horizon - cal_start = cal_end - cal_length if cal_length is not None else None - - cal_res = res[:, :, cal_start:cal_end] - q_hat_ = self._calibrate_interval(cal_res) - else: - # with a calibration set, use a constant q_hat - q_hat_ = q_hat vals = self._apply_interval(pred_vals_, q_hat_) if not predict_likelihood_parameters: vals = sample_from_quantiles( @@ -1658,11 +1471,8 @@ def __init__( - Extract a calibration set: The number of calibration examples (forecast errors) from the most recent past to use for one conformal prediction can be defined at model creation with parameter `cal_length`. Requires a minimum of `cal_stride * (cal_length or 1)` calibration examples before the (first) conformal forecast. - To make your life simpler, we support two modes: - - Automatic extraction of the calibration set from the past of your input series (`series`, - `past_covariates`, ...). This is the default mode and our predict/forecasting/backtest/.... API is - identical to any other forecasting model - - Supply a fixed calibration set with parameters `cal_series`, `cal_past_covariates`, ... . + To make your life simpler, it applies automatic extraction of the calibration set from the past of your input + series (`series`, `past_covariates`, ...). - Generate historical forecasts on the calibration set (using the forecasting model) with a stride `cal_stride`. - Compute the errors/non-conformity scores (as defined above) on these historical forecasts - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model @@ -1791,11 +1601,8 @@ def __init__( - Extract a calibration set: The number of calibration examples (forecast errors) from the most recent past to use for one conformal prediction can be defined at model creation with parameter `cal_length`. Requires a minimum of `cal_stride * (cal_length or 1)` calibration examples before the (first) conformal forecast. - To make your life simpler, we support two modes: - - Automatic extraction of the calibration set from the past of your input series (`series`, - `past_covariates`, ...). This is the default mode and our predict/forecasting/backtest/.... API is - identical to any other forecasting model - - Supply a fixed calibration set with parameters `cal_series`, `cal_past_covariates`, ... . + To make your life simpler, it applies automatic extraction of the calibration set from the past of your input + series (`series`, `past_covariates`, ...). - Generate historical forecasts (quantile predictions) on the calibration set (using the forecasting model) with a stride `cal_stride`. - Compute the errors/non-conformity scores (as defined above) on these historical quantile predictions diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 1a6f8a2d0c..90a9d30ce0 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -328,12 +328,6 @@ def test_single_ts(self, config): pred1 = model.predict(n=1, **pred_lklp) assert not pred1 == pred - # giving the same series as calibration set must give the same results - pred_cal = model.predict( - n=self.horizon, cal_series=self.ts_pass_train, **pred_lklp - ) - np.testing.assert_array_almost_equal(pred.all_values(), pred_cal.all_values()) - # wrong dimension with pytest.raises(ValueError): model.predict( @@ -371,19 +365,6 @@ def test_multi_ts(self, config): pred[fc_columns].all_values(), pred_fc.all_values() ) - # using a calibration series also requires an input series - with pytest.raises(ValueError): - # when model is fit from >1 series, one must provide a series in argument - model.predict(n=1, cal_series=self.ts_pass_train, **pred_lklp) - # giving the same series as calibration set must give the same results - pred_cal = model.predict( - n=self.horizon, - series=self.ts_pass_train, - cal_series=self.ts_pass_train, - **pred_lklp, - ) - np.testing.assert_array_almost_equal(pred.all_values(), pred_cal.all_values()) - # check prediction for several time series pred_list = model.predict( n=self.horizon, @@ -406,66 +387,6 @@ def test_multi_ts(self, config): pred[fc_columns].all_values(), ) - # using a calibration series requires to have same number of series as target - with pytest.raises(ValueError) as exc: - # when model is fit from >1 series, one must provide a series in argument - model.predict( - n=1, - series=[self.ts_pass_train, self.ts_pass_val], - cal_series=self.ts_pass_train, - **pred_lklp, - ) - assert ( - str(exc.value) - == "Mismatch between number of `cal_series` (1) and number of `series` (2)." - ) - # using a calibration series requires to have same number of series as target - with pytest.raises(ValueError) as exc: - # when model is fit from >1 series, one must provide a series in argument - model.predict( - n=1, - series=[self.ts_pass_train, self.ts_pass_val], - cal_series=[self.ts_pass_train] * 3, - **pred_lklp, - ) - assert ( - str(exc.value) - == "Mismatch between number of `cal_series` (3) and number of `series` (2)." - ) - - # giving the same series as calibration set must give the same results - pred_cal_list = model.predict( - n=self.horizon, - series=[self.ts_pass_train, self.ts_pass_train_1], - cal_series=[self.ts_pass_train, self.ts_pass_train_1], - **pred_lklp, - ) - for pred, pred_cal in zip(pred_list, pred_cal_list): - np.testing.assert_array_almost_equal( - pred.all_values(), pred_cal.all_values() - ) - - # using copies of the same series as calibration set must give the same interval widths for - # each target series - pred_cal_list = model.predict( - n=self.horizon, - series=[self.ts_pass_train, self.ts_pass_train_1], - cal_series=[self.ts_pass_train, self.ts_pass_train], - **pred_lklp, - ) - - pred_0_vals = pred_cal_list[0].all_values() - pred_1_vals = pred_cal_list[1].all_values() - - # lower range - np.testing.assert_array_almost_equal( - pred_0_vals[:, 1] - pred_0_vals[:, 0], pred_1_vals[:, 1] - pred_1_vals[:, 0] - ) - # upper range - np.testing.assert_array_almost_equal( - pred_0_vals[:, 2] - pred_0_vals[:, 1], pred_1_vals[:, 2] - pred_1_vals[:, 1] - ) - # wrong dimension with pytest.raises(ValueError): model.predict( @@ -748,11 +669,6 @@ def test_output_chunk_shift(self): pred[fc_columns].all_values(), pred_fc.all_values() ) - pred_cal = model.predict(n=1, cal_series=self.ts_pass_train, **pred_lklp) - assert pred_fc.time_index.equals(pred_cal.time_index) - # the center forecasts must be equal to the forecasting model forecast - np.testing.assert_array_almost_equal(pred_cal.all_values(), pred.all_values()) - @pytest.mark.parametrize( "config", list( @@ -820,9 +736,6 @@ def test_conformal_model_predict_accuracy(self, config): ) pred_fc_list = model.model.predict(n, series=series, **pred_kwargs) pred_cal_list = model.predict(n, series=series, **pred_lklp) - pred_cal_list_with_cal = model.predict( - n, series=series, cal_series=series, **pred_lklp - ) if issubclass(model_cls, ConformalNaiveModel): metric = ae if symmetric else err @@ -847,10 +760,9 @@ def test_conformal_model_predict_accuracy(self, config): pred_fc_list = [pred_fc_list] pred_cal_list = [pred_cal_list] residuals_list = [residuals_list] - pred_cal_list_with_cal = [pred_cal_list_with_cal] - for pred_fc, pred_cal, pred_cal_with_cal, residuals in zip( - pred_fc_list, pred_cal_list, pred_cal_list_with_cal, residuals_list + for pred_fc, pred_cal, residuals in zip( + pred_fc_list, pred_cal_list, residuals_list ): residuals = np.concatenate(residuals[:-1], axis=2) @@ -865,7 +777,6 @@ def test_conformal_model_predict_accuracy(self, config): cal_length=cal_length, ) self.helper_compare_preds(pred_cal, pred_vals_expected, model_type) - self.helper_compare_preds(pred_cal_with_cal, pred_vals_expected, model_type) @pytest.mark.parametrize( "config", @@ -886,11 +797,9 @@ def test_naive_conformal_model_historical_forecasts(self, config): - single and multiple series - with and without output shift - with and without training length - - with and without covariates in the forecast and calibration sets. + - with and without covariates """ n, is_univar, is_single, ocs, cal_length, use_covs, quantiles = config - n_q = len(quantiles) - half_idx = n_q // 2 if ocs and n > OUT_LEN: # auto-regression not allowed with ocs return @@ -900,9 +809,6 @@ def test_naive_conformal_model_historical_forecasts(self, config): # for covariates, we check that shorter & longer covariates in the calibration set give expected results covs_kwargs = {} - cal_covs_kwargs_overlap = {} - cal_covs_kwargs_short = {} - cal_covs_kwargs_exact = {} if use_covs: model_params["lags_past_covariates"] = regr_kwargs["lags"] past_covs = series @@ -913,20 +819,6 @@ def test_naive_conformal_model_historical_forecasts(self, config): else: past_covs = [pc.append_values(append_vals) for pc in past_covs] covs_kwargs["past_covariates"] = past_covs - # produces examples with all points in `overlap_end=True` (last example has no useful information) - cal_covs_kwargs_overlap["cal_past_covariates"] = past_covs - # produces one example less (drops the one with unuseful information) - cal_covs_kwargs_exact["cal_past_covariates"] = ( - past_covs[: -(1 + ocs)] - if is_single - else [pc[: -(1 + ocs)] for pc in past_covs] - ) - # produces another example less (drops the last one which contains useful information) - cal_covs_kwargs_short["cal_past_covariates"] = ( - past_covs[: -(2 + ocs)] - if is_single - else [pc[: -(2 + ocs)] for pc in past_covs] - ) # forecasts from forecasting model model_fc = train_model(series, model_params=model_params, **covs_kwargs) @@ -954,7 +846,6 @@ def test_naive_conformal_model_historical_forecasts(self, config): model = ConformalNaiveModel( model=model_fc, quantiles=quantiles, cal_length=cal_length ) - # without calibration set hfc_conf_list = model.historical_forecasts( series=series, forecast_horizon=n, @@ -964,27 +855,13 @@ def test_naive_conformal_model_historical_forecasts(self, config): **covs_kwargs, **pred_lklp, ) - # with calibration set and covariates that can generate all calibration forecasts in the overlap - hfc_conf_list_with_cal = model.historical_forecasts( - series=series, - forecast_horizon=n, - overlap_end=True, - last_points_only=False, - stride=1, - cal_series=series, - **covs_kwargs, - **cal_covs_kwargs_overlap, - **pred_lklp, - ) if is_single: hfc_conf_list = [hfc_conf_list] residuals_list = [residuals_list] - hfc_conf_list_with_cal = [hfc_conf_list_with_cal] hfc_fc_list = [hfc_fc_list] - # validate computed conformal intervals that did not use a calibration set - # conformal models start later since they need past residuals as input + # validate computed conformal intervals; conformal models start later since they need past residuals as input first_fc_idx = len(hfc_fc_list[0]) - len(hfc_conf_list[0]) for hfc_fc, hfc_conf, hfc_residuals in zip( hfc_fc_list, hfc_conf_list, residuals_list @@ -1011,73 +888,6 @@ def test_naive_conformal_model_historical_forecasts(self, config): pred_cal.all_values(), pred_vals_expected ) - # validate computed conformal intervals that used a calibration set - for hfc_conf_with_cal, hfc_conf in zip(hfc_conf_list_with_cal, hfc_conf_list): - # last forecast with calibration set must be equal to the last without calibration set - # (since calibration set is the same series) - assert hfc_conf_with_cal[-1] == hfc_conf[-1] - hfc_0_vals = hfc_conf_with_cal[0].all_values() - for hfc_i in hfc_conf_with_cal[1:]: - hfc_i_vals = hfc_i.all_values() - for q_idx in range(n_q): - np.testing.assert_array_almost_equal( - hfc_0_vals[:, half_idx::n_q] - hfc_0_vals[:, q_idx::n_q], - hfc_i_vals[:, half_idx::n_q] - hfc_i_vals[:, q_idx::n_q], - ) - - if use_covs: - # `cal_covs_kwargs_exact` will not compute the last example in overlap_end (this one has anyways no - # useful information). Result is expected to be identical to the case when using `cal_covs_kwargs_overlap` - hfc_conf_list_with_cal_exact = model.historical_forecasts( - series=series, - forecast_horizon=n, - overlap_end=True, - last_points_only=False, - stride=1, - cal_series=series, - **covs_kwargs, - **cal_covs_kwargs_exact, - **pred_lklp, - ) - - # `cal_covs_kwargs_short` will compute example less that contains useful information - hfc_conf_list_with_cal_short = model.historical_forecasts( - series=series, - forecast_horizon=n, - overlap_end=True, - last_points_only=False, - stride=1, - cal_series=series, - **covs_kwargs, - **cal_covs_kwargs_short, - **pred_lklp, - ) - if is_single: - hfc_conf_list_with_cal_exact = [hfc_conf_list_with_cal_exact] - hfc_conf_list_with_cal_short = [hfc_conf_list_with_cal_short] - - # must match - assert len(hfc_conf_list_with_cal_exact) == len( - hfc_conf_list_with_cal_short - ) - for hfc_cal_exact, hfc_cal in zip( - hfc_conf_list_with_cal_exact, hfc_conf_list_with_cal - ): - assert len(hfc_cal_exact) == len(hfc_cal) - for hfc_cal_exact_, hfc_cal_ in zip(hfc_cal_exact, hfc_cal): - assert hfc_cal_exact_.time_index.equals(hfc_cal_.time_index) - assert hfc_cal_exact_.columns.equals(hfc_cal_.columns) - np.testing.assert_array_almost_equal( - hfc_cal_exact_.all_values(), hfc_cal_.all_values() - ) - - # second last forecast with shorter calibration set (that has one example less) must be equal to the - # second last without calibration set - for hfc_conf_with_cal, hfc_conf in zip( - hfc_conf_list_with_cal_short, hfc_conf_list - ): - assert hfc_conf_with_cal[-2] == hfc_conf[-2] - # checking that last points only is equal to the last forecasted point hfc_lpo_list = model.historical_forecasts( series=series, @@ -1088,29 +898,13 @@ def test_naive_conformal_model_historical_forecasts(self, config): **covs_kwargs, **pred_lklp, ) - hfc_lpo_list_with_cal = model.historical_forecasts( - series=series, - forecast_horizon=n, - overlap_end=True, - last_points_only=True, - stride=1, - cal_series=series, - **covs_kwargs, - **cal_covs_kwargs_overlap, - **pred_lklp, - ) if is_single: hfc_lpo_list = [hfc_lpo_list] - hfc_lpo_list_with_cal = [hfc_lpo_list_with_cal] for hfc_lpo, hfc_conf in zip(hfc_lpo_list, hfc_conf_list): hfc_conf_lpo = concatenate([hfc[-1:] for hfc in hfc_conf], axis=0) assert hfc_lpo == hfc_conf_lpo - for hfc_lpo, hfc_conf in zip(hfc_lpo_list_with_cal, hfc_conf_list_with_cal): - hfc_conf_lpo = concatenate([hfc[-1:] for hfc in hfc_conf], axis=0) - assert hfc_lpo == hfc_conf_lpo - def test_probabilistic_historical_forecast(self): """Checks correctness of naive conformal historical forecast from probabilistic fc model compared to deterministic one, @@ -1316,10 +1110,8 @@ def test_too_short_input_predict(self, config): model_params = {"output_chunk_shift": ocs} covs_kwargs = {} - cal_covs_kwargs = {} covs_kwargs_train = {} covs_kwargs_too_short = {} - cal_covs_kwargs_short = {} if use_covs: model_params["lags_past_covariates"] = regr_kwargs["lags"] covs_kwargs_train["past_covariates"] = series_train @@ -1330,9 +1122,6 @@ def test_too_short_input_predict(self, config): past_covs = past_covs.append_values([1.0] * (n - OUT_LEN)) covs_kwargs["past_covariates"] = past_covs covs_kwargs_too_short["past_covariates"] = past_covs[:-1] - # giving covs in calibration set requires one calibration example less - cal_covs_kwargs["cal_past_covariates"] = past_covs[: -(1 + ocs)] - cal_covs_kwargs_short["cal_past_covariates"] = past_covs[: -(2 + ocs)] model = ConformalNaiveModel( train_model( @@ -1346,18 +1135,14 @@ def test_too_short_input_predict(self, config): # prediction works with long enough input preds1 = model.predict(n=n, series=series, **covs_kwargs) assert not np.isnan(preds1.all_values()).any().any() - preds2 = model.predict( - n=n, series=series, **covs_kwargs, cal_series=series, **cal_covs_kwargs - ) - assert not np.isnan(preds2.all_values()).any().any() + # series too short: without covariates, make `series` shorter. Otherwise, use the shorter covariates series_ = series[:-1] if not use_covs else series - with pytest.raises(ValueError) as exc: _ = model.predict(n=n, series=series_, **covs_kwargs_too_short) if not use_covs: assert str(exc.value).startswith( - "Could not build the minimum required calibration input with the provided `cal_series`" + "Could not build the minimum required calibration input with the provided `series`" ) else: # if `past_covariates` are too short, then it raises error from the forecasting_model.predict() @@ -1365,24 +1150,6 @@ def test_too_short_input_predict(self, config): "The `past_covariates` at list/sequence index 0 are not long enough." ) - with pytest.raises(ValueError) as exc: - _ = model.predict( - n=n, - series=series, - cal_series=series_, - **covs_kwargs, - **cal_covs_kwargs_short, - ) - if not use_covs or n > 1: - assert str(exc.value).startswith( - "Could not build the minimum required calibration input with the provided `cal_series`" - ) - else: - # if `cal_past_covariates` are too short and `horizon=1`, then it raises error from the forecasting model - assert str(exc.value).startswith( - "Cannot build a single input for prediction with the provided model" - ) - @pytest.mark.parametrize( "config", itertools.product( @@ -1419,25 +1186,10 @@ def test_too_short_input_hfc(self, config): series_train = [tg.linear_timeseries(length=icl + ocl + ocs)] * 2 series = tg.linear_timeseries(length=min_len_val_series) - # define cal series to get the minimum required cal set - if overlap_end: - # with overlap_end `series` has the exact length to generate one forecast after the end of the input series - # Therefore, `series` has already the minimum length for one calibrated forecast - cal_series = series - else: - # without overlap_end, we use a shorter input, since the last forecast is within the input series - # (it generates more residuals with useful information than the minimum requirements) - cal_series = series[:-horizon_ocs] - - series_with_cal = series[: -(horizon_ocs + add_cal_length)] - model_params = {"output_chunk_shift": ocs} covs_kwargs_train = {} covs_kwargs = {} - covs_with_cal_kwargs = {} - cal_covs_kwargs = {} covs_kwargs_short = {} - cal_covs_kwargs_short = {} if use_covs: model_params["lags_past_covariates"] = regr_kwargs["lags"] covs_kwargs_train["past_covariates"] = series_train @@ -1448,30 +1200,15 @@ def test_too_short_input_hfc(self, config): else: past_covs = series - # calibration set is always generated internally with `overlap_end=True` - # make shorter to not compute residuals without useful information - cal_past_covs = cal_series[: -(1 + ocs)] - - # last_points_only requires `horizon` residuals less - if last_points_only: - cal_past_covs = cal_past_covs[: (-(n - 1) or None)] - # for auto-regression, we require longer past covariates if n > OUT_LEN: past_covs = past_covs.append_values([1.0] * (n - OUT_LEN)) - cal_past_covs = cal_past_covs.append_values([1.0] * (n - OUT_LEN)) # covariates lengths to generate exactly one forecast covs_kwargs["past_covariates"] = past_covs - # giving a calibration set requires fewer forecasts - covs_with_cal_kwargs["past_covariates"] = past_covs[:-horizon_ocs] - cal_covs_kwargs["cal_past_covariates"] = cal_past_covs # use too short covariates to check that errors are raised covs_kwargs_short["past_covariates"] = covs_kwargs["past_covariates"][:-1] - cal_covs_kwargs_short["cal_past_covariates"] = cal_covs_kwargs[ - "cal_past_covariates" - ][:-1] model = ConformalNaiveModel( train_model( @@ -1494,26 +1231,15 @@ def test_too_short_input_hfc(self, config): **covs_kwargs, **hfc_kwargs, ) - hfcs_cal = model.historical_forecasts( - series=series_with_cal, - cal_series=cal_series, - **covs_with_cal_kwargs, - **cal_covs_kwargs, - **hfc_kwargs, - ) if last_points_only: hfcs = [hfcs] - hfcs_cal = [hfcs_cal] - assert len(hfcs) == len(hfcs_cal) == 1 - for hfc, hfc_cal in zip(hfcs, hfcs_cal): + assert len(hfcs) == 1 + for hfc in hfcs: assert not np.isnan(hfc.all_values()).any().any() - assert not np.isnan(hfc_cal.all_values()).any().any() # input too short: without covariates, make `series` shorter. Otherwise, use the shorter covariates series_ = series[:-1] if not use_covs else series - cal_series_ = cal_series[:-1] if not use_covs else cal_series - with pytest.raises(ValueError) as exc: _ = model.historical_forecasts( series=series_, @@ -1524,25 +1250,6 @@ def test_too_short_input_hfc(self, config): "Could not build the minimum required calibration input with the provided `series` and `*_covariates`" ) - with pytest.raises(ValueError) as exc: - _ = model.historical_forecasts( - series=series_with_cal, - cal_series=cal_series_, - **covs_with_cal_kwargs, - **cal_covs_kwargs_short, - **hfc_kwargs, - ) - if (not use_covs or n > 1 or (cal_length or 1) > 1) and not ( - last_points_only and use_covs and cal_length is None - ): - assert str(exc.value).startswith( - "Could not build the minimum required calibration input with the provided `cal_series`" - ) - else: - assert str(exc.value).startswith( - "Cannot build a single input for prediction with the provided model" - ) - @pytest.mark.parametrize("quantiles", [[0.1, 0.5, 0.9], [0.1, 0.3, 0.5, 0.7, 0.9]]) def test_backtest_and_residuals(self, quantiles): """Residuals and backtest are already tested for quantile, and interval metrics based on stochastic or quantile diff --git a/darts/tests/models/forecasting/test_historical_forecasts.py b/darts/tests/models/forecasting/test_historical_forecasts.py index 7240831516..0b5f5f1faf 100644 --- a/darts/tests/models/forecasting/test_historical_forecasts.py +++ b/darts/tests/models/forecasting/test_historical_forecasts.py @@ -3157,15 +3157,6 @@ def test_conformal_historical_start_cal_length(self, config): .with_columns_renamed(series_val.columns, "test_col"), ] - # compute regular historical forecasts - hist_fct_all = forecasting_model.historical_forecasts( - series=series_val, - retrain=False, - start=start, - start_format=start_format, - last_points_only=last_points_only, - forecast_horizon=horizon, - ) # compute conformal historical forecasts (skips some of the first forecasts to get minimum required cal set) model = ConformalNaiveModel( forecasting_model, quantiles=q, cal_length=cal_length @@ -3179,34 +3170,17 @@ def test_conformal_historical_start_cal_length(self, config): forecast_horizon=horizon, **pred_lklp, ) - # using a calibration series should not skip any forecasts - hist_fct_cal = model.historical_forecasts( - series=series_val, - cal_series=series_val, - retrain=False, - start=start, - start_format=start_format, - last_points_only=last_points_only, - forecast_horizon=horizon, - **pred_lklp, - ) if not isinstance(series_val, list): series_val = [series_val] hist_fct = [hist_fct] - hist_fct_all = [hist_fct_all] - hist_fct_cal = [hist_fct_cal] for idx, ( series, hfc, - hfc_all, - hfc_cal, - ) in enumerate(zip(series_val, hist_fct, hist_fct_all, hist_fct_cal)): + ) in enumerate(zip(series_val, hist_fct)): if not isinstance(hfc, list): hfc = [hfc] - hfc_all = [hfc_all] - hfc_cal = [hfc_cal] # multi series: second series is shifted by one time step (+/- idx); # start_format = "value" requires a shift @@ -3253,30 +3227,6 @@ def test_conformal_historical_start_cal_length(self, config): assert hfc_.columns.tolist() == cols_excpected assert len(hfc_) == n_pred_points_expected - # with a calibration set, we can calibrate all possible historical forecasts from base forecasting model - assert len(hfc_cal) == len(hfc_all) - for hfc_all_, hfc_cal_ in zip(hfc_all, hfc_cal): - assert hfc_all_.start_time() == hfc_cal_.start_time() - assert len(hfc_all_) == len(hfc_cal_) - assert hfc_all_.freq == hfc_cal_.freq - - # the center forecast must be equal to the forecasting model's forecast - np.testing.assert_array_almost_equal( - hfc_all_.all_values(), hfc_cal_.all_values()[:, 1:2] - ) - - # check that with a calibration set, all prediction intervals have the same width - vals_cal_0 = hfc_cal[0].values() - vals_cal_i = hfc_cal_.values() - np.testing.assert_array_almost_equal( - vals_cal_0[:, 0] - vals_cal_0[:, 1], - vals_cal_i[:, 0] - vals_cal_i[:, 1], - ) - np.testing.assert_array_almost_equal( - vals_cal_0[:, 1] - vals_cal_0[:, 2], - vals_cal_i[:, 1] - vals_cal_i[:, 2], - ) - @pytest.mark.parametrize( "config", list( @@ -3382,16 +3332,3 @@ def test_conformal_historical_forecast_start(self, caplog, config): assert too_early_warn_exp in caplog.text caplog.clear() assert hist_fct_too_early == hist_fct - - # using a calibration series should not skip any forecasts - hist_fct_cal = model.historical_forecasts( - start=start, - cal_series=series_val[:-horizon_ocs], - **hfc_params, - **pred_lklp, - ) - assert len(hist_fct_all) == len(hist_fct_cal) - assert hist_fct_all[0].start_time() == hist_fct_cal[0].start_time() - - # cal_series yields same calibration set on the last hist fc - assert hist_fct[-1] == hist_fct_cal[-1] From b0099322af913061977b4bf9e20e22f1c94a5819 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Wed, 20 Nov 2024 15:30:35 +0100 Subject: [PATCH 61/78] use cal stride --- darts/models/forecasting/conformal_models.py | 68 +++++++++++++++----- 1 file changed, 51 insertions(+), 17 deletions(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index d5c0823266..b66a0d9744 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -342,18 +342,45 @@ def predict( show_warnings=show_warnings, ) - # generate all possible forecasts for calibration + # generate only the required forecasts for calibration (including the last forecast which is the output of + # `predict()`) + horizon_ocs = n + self.output_chunk_shift + if self.cal_length is not None: + # we only need `cal_length` forecasts with stride `cal_stride` before the `predict()` start point; + # the last valid calibration forecast must start at least `horizon_ocs` before `predict()` start + add_steps = ( + (horizon_ocs // self.cal_stride) + + int(horizon_ocs % self.cal_stride > 0) + - 1 + ) + start = -self.cal_stride * (self.cal_length + add_steps) + start_format = "position" + elif self.cal_stride > 1: + # we need all forecasts with stride `cal_stride` before the `predict()` start point + max_len_series = max(len(series_) for series_ in series) + start = -self.cal_stride * ( + (max_len_series // self.cal_stride) + + int(max_len_series % self.cal_stride > 0) + ) + start_format = "position" + else: + # we need all possible forecasts with `cal_stride=1` + start, start_format = None, "value" + cal_hfcs = self.model.historical_forecasts( series=series, past_covariates=past_covariates, future_covariates=future_covariates, - num_samples=self.num_samples, forecast_horizon=n, + num_samples=self.num_samples, + start=start, + start_format=start_format, + stride=self.cal_stride, retrain=False, overlap_end=True, last_points_only=False, verbose=verbose, - show_warnings=show_warnings, + show_warnings=False, predict_likelihood_parameters=False, ) cal_preds = self._calibrate_forecasts( @@ -986,7 +1013,7 @@ def _calibrate_forecasts( forecasting model's predictions. """ # TODO: add proper handling of `cal_stride` > 1 - # cal_stride = stride if self.cal_stride else 1 + cal_stride = self.cal_stride cal_length = self.cal_length metric, metric_kwargs = self._residuals_metric residuals = self.model.residuals( @@ -1029,7 +1056,11 @@ def _calibrate_forecasts( # `last_points_only=False` requires additional examples to use most recent information # from all steps in the horizon if not last_points_only: - min_n_cal += forecast_horizon - 1 + min_n_cal += ( + (forecast_horizon // cal_stride) + + int(forecast_horizon % cal_stride > 0) + - 1 + ) # determine first forecast index for conformal prediction # we need at least one residual per point in the horizon prior to the first conformal forecast @@ -1047,22 +1078,25 @@ def _calibrate_forecasts( else: delta_end = 0 - # drop residuals without useful information - last_res_idx = None + # ignore residuals without useful information if last_points_only and delta_end > 0: - # useful residual information only up until the forecast - # ending at the last time step in `series` - last_res_idx = -delta_end + # useful residual information only up until the forecast ending at the last time step in `series` + ignore_n_residuals = delta_end elif not last_points_only and delta_end >= forecast_horizon: - # useful residual information only up until the forecast - # starting at the last time step in `series` - last_res_idx = -(delta_end - forecast_horizon + 1) - if last_res_idx is None: - # drop at least the one residuals/forecast from the end, since we can only use prior residuals - last_res_idx = -(self.output_chunk_shift + 1) + # useful residual information only up until the forecast starting at the last time step in `series` + ignore_n_residuals = delta_end - forecast_horizon + 1 + else: + # ignore at least the one residuals/forecast from the end, since we can only use prior residuals + ignore_n_residuals = self.output_chunk_shift + 1 # with last points only, ignore the last `horizon` residuals to avoid look-ahead bias if last_points_only: - last_res_idx -= forecast_horizon - 1 + ignore_n_residuals += forecast_horizon - 1 + + # get the last index respecting `cal_stride` + last_res_idx = -( + (ignore_n_residuals // cal_stride) + + int(ignore_n_residuals % cal_stride > 0) + ) if last_res_idx is not None: res = res[:last_res_idx] From d11eeb36d6ba94b3b3aa602a2dbfbe17e1e4ea0b Mon Sep 17 00:00:00 2001 From: dennisbader Date: Wed, 20 Nov 2024 17:06:53 +0100 Subject: [PATCH 62/78] make predict work with cal_stride --- darts/models/forecasting/conformal_models.py | 49 ++++++++++---------- 1 file changed, 25 insertions(+), 24 deletions(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index b66a0d9744..e91de79fcf 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -6,6 +6,7 @@ """ import copy +import math import os from abc import ABC, abstractmethod from collections.abc import Sequence @@ -348,20 +349,13 @@ def predict( if self.cal_length is not None: # we only need `cal_length` forecasts with stride `cal_stride` before the `predict()` start point; # the last valid calibration forecast must start at least `horizon_ocs` before `predict()` start - add_steps = ( - (horizon_ocs // self.cal_stride) - + int(horizon_ocs % self.cal_stride > 0) - - 1 - ) + add_steps = math.ceil(horizon_ocs / self.cal_stride) - 1 start = -self.cal_stride * (self.cal_length + add_steps) start_format = "position" elif self.cal_stride > 1: # we need all forecasts with stride `cal_stride` before the `predict()` start point max_len_series = max(len(series_) for series_ in series) - start = -self.cal_stride * ( - (max_len_series // self.cal_stride) - + int(max_len_series % self.cal_stride > 0) - ) + start = -self.cal_stride * math.ceil(max_len_series / self.cal_stride) start_format = "position" else: # we need all possible forecasts with `cal_stride=1` @@ -1056,15 +1050,13 @@ def _calibrate_forecasts( # `last_points_only=False` requires additional examples to use most recent information # from all steps in the horizon if not last_points_only: - min_n_cal += ( - (forecast_horizon // cal_stride) - + int(forecast_horizon % cal_stride > 0) - - 1 - ) + min_n_cal += math.ceil(forecast_horizon / cal_stride) - 1 # determine first forecast index for conformal prediction # we need at least one residual per point in the horizon prior to the first conformal forecast - first_idx_train = forecast_horizon + self.output_chunk_shift + first_idx_train = math.ceil( + (forecast_horizon + self.output_chunk_shift) / cal_stride + ) # plus some additional examples based on `cal_length` if cal_length is not None: first_idx_train += cal_length - 1 @@ -1093,10 +1085,7 @@ def _calibrate_forecasts( ignore_n_residuals += forecast_horizon - 1 # get the last index respecting `cal_stride` - last_res_idx = -( - (ignore_n_residuals // cal_stride) - + int(ignore_n_residuals % cal_stride > 0) - ) + last_res_idx = -math.ceil(ignore_n_residuals / cal_stride) if last_res_idx is not None: res = res[:last_res_idx] @@ -1111,6 +1100,7 @@ def _calibrate_forecasts( ), logger=logger, ) + # adjust first index based on `start` first_idx_start = 0 if start is not None and start == "end": @@ -1177,12 +1167,18 @@ def _calibrate_forecasts( # ``` res_ = [] for irr in range(forecast_horizon - 1, -1, -1): - res_end_idx = -(forecast_horizon - (irr + 1)) - res_.append(res[irr : res_end_idx or None, abs(res_end_idx)]) + idx_fc_start = math.floor(irr / cal_stride) + idx_fc_end = -( + math.ceil(forecast_horizon / cal_stride) - (idx_fc_start + 1) + ) + idx_horizon = forecast_horizon - (irr + 1) + res_.append(res[idx_fc_start : idx_fc_end or None, idx_horizon]) res = np.concatenate(res_, axis=2).T # get the last forecast index based on the residual examples - last_fc_idx = res.shape[2] + (forecast_horizon + self.output_chunk_shift) + last_fc_idx = res.shape[2] + math.ceil( + (forecast_horizon + self.output_chunk_shift) / cal_stride + ) def conformal_predict(idx_, pred_vals_): # get the last residual index for calibration, `cal_end` is exclusive @@ -1192,8 +1188,13 @@ def conformal_predict(idx_, pred_vals_): # `last_points_only=False` thanks to the residual rearrangement cal_end = ( first_fc_idx - + idx_ * stride - - (forecast_horizon + self.output_chunk_shift - 1) + + idx_ * math.ceil(stride / cal_stride) + - ( + math.ceil( + (forecast_horizon + self.output_chunk_shift) / cal_stride + ) + - 1 + ) ) # first residual index is shifted back by the horizon to get `cal_length` points for # the last point in the horizon From 1be41e7bb346750292d10056363a6a6dc7834e6a Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 21 Nov 2024 09:29:23 +0100 Subject: [PATCH 63/78] add cal stride to historical forecasts --- darts/models/forecasting/conformal_models.py | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index e91de79fcf..ad4ff7e664 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -545,7 +545,24 @@ def historical_forecasts( past_covariates = series2seq(past_covariates) future_covariates = series2seq(future_covariates) - # generate all possible forecasts (overlap_end=True) to have enough residuals + # TODO: Implement start for hfc + # # generate only the required forecasts (if `start` is given, we have to start earlier to satisfy the + # # calibration set requirements) + # horizon_ocs = n + self.output_chunk_shift + # if self.cal_length is not None: + # # we only need `cal_length` forecasts with stride `cal_stride` before the `predict()` start point; + # # the last valid calibration forecast must start at least `horizon_ocs` before `predict()` start + # add_steps = math.ceil(horizon_ocs / self.cal_stride) - 1 + # start = -self.cal_stride * (self.cal_length + add_steps) + # start_format = "position" + # elif self.cal_stride > 1: + # # we need all forecasts with stride `cal_stride` before the `predict()` start point + # max_len_series = max(len(series_) for series_ in series) + # start = -self.cal_stride * math.ceil(max_len_series / self.cal_stride) + # start_format = "position" + # else: + # # we need all possible forecasts with `cal_stride=1` + # start, start_format = None, "value" hfcs = self.model.historical_forecasts( series=series, past_covariates=past_covariates, From 8f8451ee0a781945f8908c9aca1a961a61c06871 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 22 Nov 2024 13:14:12 +0100 Subject: [PATCH 64/78] hist fc optimized cal set selection --- darts/models/forecasting/conformal_models.py | 183 ++++++++++-------- darts/models/forecasting/forecasting_model.py | 5 +- darts/utils/historical_forecasts/utils.py | 97 ++++++---- 3 files changed, 169 insertions(+), 116 deletions(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index ad4ff7e664..7070220307 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -28,7 +28,6 @@ from darts.utils import _build_tqdm_iterator, _with_sanity_checks from darts.utils.historical_forecasts.utils import ( _adjust_historical_forecasts_time_index, - _conformal_historical_forecasts_general_checks, ) from darts.utils.timeseries_generation import _build_forecast_series from darts.utils.ts_utils import ( @@ -54,6 +53,65 @@ logger = get_logger(__name__) +def _get_calibration_hfc_start( + series: Sequence[TimeSeries], + horizon: int, + output_chunk_shift: int, + cal_length: Optional[int], + cal_stride: int, + start: Optional[Union[pd.Timestamp, int, Literal["end"]]], + start_format: Literal["position", "value"], +) -> tuple[Optional[Union[int, pd.Timestamp]], Literal["position", "value"]]: + """Find the calibration start point (CSP) (for historical forecasts on calibration set). + + - If `start=None`, the CSP is also `None` (all possible hfcs). + - If `start="end"` (when calling `predict()`), returns the CSP as a positional index relative to the end of the + series (<0). + - Otherwise (when calling `historical_forecasts()`), the CSP is the start value (`start_format="value"`) or start + position (`start_format="position"`) adjusted by the positions computed for the case above. + + If this function is called from `historical_forecasts`, the sanity checks guarantee the following: + + - `start` cannot be a `float` + - when `start_format='value'`, all `series` have the same frequency + """ + if start is None: + return start, start_format + + horizon_ocs = horizon + output_chunk_shift + if cal_length is not None: + # we only need `cal_length` forecasts with stride `cal_stride` before the `predict()` start point; + # the last valid calibration forecast must start at least `horizon_ocs` before `predict()` start + add_steps = math.ceil(horizon_ocs / cal_stride) - 1 + start_idx_rel = -cal_stride * (cal_length + add_steps) + cal_start_format = "position" + elif cal_stride > 1: + # we need all forecasts with stride `cal_stride` before the `predict()` start point + max_len_series = max(len(series_) for series_ in series) + start_idx_rel = -cal_stride * math.ceil(max_len_series / cal_stride) + cal_start_format = "position" + else: + # we need all possible forecasts with `cal_stride=1` + start_idx_rel, cal_start_format = None, "value" + + if start == "end": + # `predict()` is relative to the end + return start_idx_rel, cal_start_format + + # `historical_forecasts()` is relative to `start` + start_is_position = isinstance(start, (int, np.int64)) and ( + start_format == "position" or series[0]._has_datetime_index + ) + cal_start_format = start_format + if start_idx_rel is None: + cal_start = start_idx_rel + elif start_is_position: + cal_start = start + start_idx_rel + else: + cal_start = start + start_idx_rel * series[0].freq + return cal_start, cal_start_format + + class ConformalModel(GlobalForecastingModel, ABC): @random_method def __init__( @@ -345,21 +403,15 @@ def predict( # generate only the required forecasts for calibration (including the last forecast which is the output of # `predict()`) - horizon_ocs = n + self.output_chunk_shift - if self.cal_length is not None: - # we only need `cal_length` forecasts with stride `cal_stride` before the `predict()` start point; - # the last valid calibration forecast must start at least `horizon_ocs` before `predict()` start - add_steps = math.ceil(horizon_ocs / self.cal_stride) - 1 - start = -self.cal_stride * (self.cal_length + add_steps) - start_format = "position" - elif self.cal_stride > 1: - # we need all forecasts with stride `cal_stride` before the `predict()` start point - max_len_series = max(len(series_) for series_ in series) - start = -self.cal_stride * math.ceil(max_len_series / self.cal_stride) - start_format = "position" - else: - # we need all possible forecasts with `cal_stride=1` - start, start_format = None, "value" + cal_start, cal_start_format = _get_calibration_hfc_start( + series=series, + horizon=n, + output_chunk_shift=self.output_chunk_shift, + cal_length=self.cal_length, + cal_stride=self.cal_stride, + start="end", + start_format="position", + ) cal_hfcs = self.model.historical_forecasts( series=series, @@ -367,8 +419,8 @@ def predict( future_covariates=future_covariates, forecast_horizon=n, num_samples=self.num_samples, - start=start, - start_format=start_format, + start=cal_start, + start_format=cal_start_format, stride=self.cal_stride, retrain=False, overlap_end=True, @@ -397,10 +449,7 @@ def predict( else: return [cp[0] for cp in cal_preds] - @_with_sanity_checks( - "_historical_forecasts_sanity_checks", - "_conformal_historical_forecasts_sanity_checks", - ) + @_with_sanity_checks("_historical_forecasts_sanity_checks") def historical_forecasts( self, series: Union[TimeSeries, Sequence[TimeSeries]], @@ -409,7 +458,7 @@ def historical_forecasts( forecast_horizon: int = 1, num_samples: int = 1, train_length: Optional[int] = None, - start: Optional[Union[pd.Timestamp, float, int]] = None, + start: Optional[Union[pd.Timestamp, int]] = None, start_format: Literal["position", "value"] = "value", stride: int = 1, retrain: Union[bool, int, Callable[..., bool]] = True, @@ -469,8 +518,7 @@ def historical_forecasts( Currently ignored by conformal models. start Optionally, the first point in time at which a prediction is computed. This parameter supports: - ``float``, ``int``, ``pandas.Timestamp``, and ``None``. - If a ``float``, it is the proportion of the time series that should lie before the first prediction point. + ``int``, ``pandas.Timestamp``, and ``None``. If an ``int``, it is either the index position of the first prediction point for `series` with a `pd.DatetimeIndex`, or the index value for `series` with a `pd.RangeIndex`. The latter can be changed to the index position with `start_format="position"`. @@ -545,35 +593,31 @@ def historical_forecasts( past_covariates = series2seq(past_covariates) future_covariates = series2seq(future_covariates) - # TODO: Implement start for hfc - # # generate only the required forecasts (if `start` is given, we have to start earlier to satisfy the - # # calibration set requirements) - # horizon_ocs = n + self.output_chunk_shift - # if self.cal_length is not None: - # # we only need `cal_length` forecasts with stride `cal_stride` before the `predict()` start point; - # # the last valid calibration forecast must start at least `horizon_ocs` before `predict()` start - # add_steps = math.ceil(horizon_ocs / self.cal_stride) - 1 - # start = -self.cal_stride * (self.cal_length + add_steps) - # start_format = "position" - # elif self.cal_stride > 1: - # # we need all forecasts with stride `cal_stride` before the `predict()` start point - # max_len_series = max(len(series_) for series_ in series) - # start = -self.cal_stride * math.ceil(max_len_series / self.cal_stride) - # start_format = "position" - # else: - # # we need all possible forecasts with `cal_stride=1` - # start, start_format = None, "value" + # generate only the required forecasts (if `start` is given, we have to start earlier to satisfy the + # calibration set requirements) + cal_start, cal_start_format = _get_calibration_hfc_start( + series=series, + horizon=forecast_horizon, + output_chunk_shift=self.output_chunk_shift, + cal_length=self.cal_length, + cal_stride=self.cal_stride, + start=start, + start_format=start_format, + ) hfcs = self.model.historical_forecasts( series=series, past_covariates=past_covariates, future_covariates=future_covariates, - num_samples=self.num_samples, forecast_horizon=forecast_horizon, + num_samples=self.num_samples, + start=cal_start, + start_format=cal_start_format, + stride=self.cal_stride, retrain=False, overlap_end=overlap_end, last_points_only=last_points_only, verbose=verbose, - show_warnings=show_warnings, + show_warnings=False, predict_likelihood_parameters=False, enable_optimization=enable_optimization, fit_kwargs=fit_kwargs, @@ -610,7 +654,7 @@ def backtest( forecast_horizon: int = 1, num_samples: int = 1, train_length: Optional[int] = None, - start: Optional[Union[pd.Timestamp, float, int]] = None, + start: Optional[Union[pd.Timestamp, int]] = None, start_format: Literal["position", "value"] = "value", stride: int = 1, retrain: Union[bool, int, Callable[..., bool]] = True, @@ -679,8 +723,7 @@ def backtest( Currently ignored by conformal models. start Optionally, the first point in time at which a prediction is computed. This parameter supports: - ``float``, ``int``, ``pandas.Timestamp``, and ``None``. - If a ``float``, it is the proportion of the time series that should lie before the first prediction point. + ``int``, ``pandas.Timestamp``, and ``None``. If an ``int``, it is either the index position of the first prediction point for `series` with a `pd.DatetimeIndex`, or the index value for `series` with a `pd.RangeIndex`. The latter can be changed to the index position with `start_format="position"`. @@ -808,7 +851,7 @@ def residuals( forecast_horizon: int = 1, num_samples: int = 1, train_length: Optional[int] = None, - start: Optional[Union[pd.Timestamp, float, int]] = None, + start: Optional[Union[pd.Timestamp, int]] = None, start_format: Literal["position", "value"] = "value", stride: int = 1, retrain: Union[bool, int, Callable[..., bool]] = True, @@ -887,8 +930,7 @@ def residuals( Currently ignored by conformal models. start Optionally, the first point in time at which a prediction is computed. This parameter supports: - ``float``, ``int``, ``pandas.Timestamp``, and ``None``. - If a ``float``, it is the proportion of the time series that should lie before the first prediction point. + ``int``, ``pandas.Timestamp``, and ``None``. If an ``int``, it is either the index position of the first prediction point for `series` with a `pd.DatetimeIndex`, or the index value for `series` with a `pd.RangeIndex`. The latter can be changed to the index position with `start_format="position"`. @@ -997,7 +1039,7 @@ def _calibrate_forecasts( series: Sequence[TimeSeries], forecasts: Union[Sequence[Sequence[TimeSeries]], Sequence[TimeSeries]], num_samples: int = 1, - start: Optional[Union[pd.Timestamp, float, int, str]] = None, + start: Optional[Union[pd.Timestamp, int, str]] = None, start_format: Literal["position", "value"] = "value", forecast_horizon: int = 1, stride: int = 1, @@ -1133,7 +1175,6 @@ def _calibrate_forecasts( s_hfcs[first_idx_train].start_time() - adjust_idx, s_hfcs[-1].start_time() - adjust_idx, ) - # TODO: add proper start handling with `cal_stride>1` # adjust forecastable index based on start, assuming hfcs were generated with `stride=1` first_idx_start, _ = _adjust_historical_forecasts_time_index( series=series_, @@ -1150,6 +1191,9 @@ def _calibrate_forecasts( s_hfcs[0].start_time(), freq=series_.freq, ) + # TODO: add proper start handling with `cal_stride>1` + # adjust by stride + first_idx_start = math.ceil(first_idx_start / cal_stride) # get final first index first_fc_idx = max([first_idx_train, first_idx_start]) @@ -1197,6 +1241,9 @@ def _calibrate_forecasts( (forecast_horizon + self.output_chunk_shift) / cal_stride ) + # forecasts are stridden, so stride must be relative + rel_stride = math.ceil(stride / cal_stride) + def conformal_predict(idx_, pred_vals_): # get the last residual index for calibration, `cal_end` is exclusive # to avoid look-ahead bias, use only residuals from before the historical forecast start point; @@ -1205,7 +1252,7 @@ def conformal_predict(idx_, pred_vals_): # `last_points_only=False` thanks to the residual rearrangement cal_end = ( first_fc_idx - + idx_ * math.ceil(stride / cal_stride) + + idx_ * rel_stride - ( math.ceil( (forecast_horizon + self.output_chunk_shift) / cal_stride @@ -1231,10 +1278,10 @@ def conformal_predict(idx_, pred_vals_): # for each forecast, compute calibrated quantile intervals based on past residuals if last_points_only: inner_iterator = enumerate( - s_hfcs.all_values(copy=False)[first_fc_idx:last_fc_idx:stride] + s_hfcs.all_values(copy=False)[first_fc_idx:last_fc_idx:rel_stride] ) else: - inner_iterator = enumerate(s_hfcs[first_fc_idx:last_fc_idx:stride]) + inner_iterator = enumerate(s_hfcs[first_fc_idx:last_fc_idx:rel_stride]) comp_names_out = ( self._cp_component_names(series_) if predict_likelihood_parameters @@ -1245,7 +1292,7 @@ def conformal_predict(idx_, pred_vals_): inner_iterator = _build_tqdm_iterator( inner_iterator, verbose, - total=(last_fc_idx - 1 - first_fc_idx) // stride + 1, + total=(last_fc_idx - 1 - first_fc_idx) // rel_stride + 1, desc="conformal forecasts", ) @@ -1376,26 +1423,8 @@ def _cp_component_names(self, input_series) -> list[str]: input_series.components, quantile_names(self.quantiles) ) - def _conformal_historical_forecasts_sanity_checks( - self, *args: Any, **kwargs: Any - ) -> None: - """Sanity checks for the historical_forecasts function - - Parameters - ---------- - args - The args parameter(s) provided to the historical_forecasts function. - kwargs - The kwargs parameter(s) provided to the historical_forecasts function. - - Raises - ------ - ValueError - when a check on the parameter does not pass. - """ - # parse args and kwargs - series = args[0] - _conformal_historical_forecasts_general_checks(self, series, kwargs) + def _historical_forecasts_sanity_checks(self, *args: Any, **kwargs: Any) -> None: + super()._historical_forecasts_sanity_checks(*args, **kwargs, is_conformal=True) @property def output_chunk_length(self) -> Optional[int]: diff --git a/darts/models/forecasting/forecasting_model.py b/darts/models/forecasting/forecasting_model.py index 315be3c9e8..56b85df32c 100644 --- a/darts/models/forecasting/forecasting_model.py +++ b/darts/models/forecasting/forecasting_model.py @@ -607,7 +607,10 @@ def _historical_forecasts_sanity_checks(self, *args: Any, **kwargs: Any) -> None """ # parse args and kwargs series = args[0] - _historical_forecasts_general_checks(self, series, kwargs) + is_conformal = kwargs.get("is_conformal", False) + _historical_forecasts_general_checks( + self, series, kwargs, is_conformal=is_conformal + ) def _get_last_prediction_time( self, diff --git a/darts/utils/historical_forecasts/utils.py b/darts/utils/historical_forecasts/utils.py index 8d6bc18c3b..6cf6856d73 100644 --- a/darts/utils/historical_forecasts/utils.py +++ b/darts/utils/historical_forecasts/utils.py @@ -22,7 +22,9 @@ ] -def _historical_forecasts_general_checks(model, series, kwargs): +def _historical_forecasts_general_checks( + model, series, kwargs, is_conformal: bool = False +): """ Performs checks common to ForecastingModel and RegressionModel backtest() methods @@ -52,6 +54,18 @@ def _historical_forecasts_general_checks(model, series, kwargs): logger, ) + # check stride for ConformalModel + if is_conformal and ( + n.stride < model.cal_stride or n.stride % model.cal_stride > 0 + ): + raise_log( + ValueError( + f"The provided `stride` parameter must be a round-multiple of `cal_stride={model.cal_stride}` " + f"and `>=cal_stride`. Received `stride={n.stride}`" + ), + logger, + ) + series = series2seq(series) if n.start is not None: @@ -77,13 +91,23 @@ def _historical_forecasts_general_checks(model, series, kwargs): ), logger, ) - if isinstance(n.start, float) and not 0.0 <= n.start <= 1.0: - raise_log( - ValueError("if `start` is a float, must be between 0.0 and 1.0."), - logger, - ) + if isinstance(n.start, float): + if is_conformal: + raise_log( + ValueError( + "`start` of type float is not supported for `ConformalModel`." + ), + logger, + ) + if not 0.0 <= n.start <= 1.0: + raise_log( + ValueError("if `start` is a float, must be between 0.0 and 1.0."), + logger, + ) + series_freq = None for idx, series_ in enumerate(series): + start_is_value = False # check specifically for int and Timestamp as error by `get_timestamp_at_point` is too generic if isinstance(n.start, pd.Timestamp): if not series_._has_datetime_index: @@ -101,6 +125,7 @@ def _historical_forecasts_general_checks(model, series, kwargs): ), logger, ) + start_is_value = True elif isinstance(n.start, (int, np.int64)): if n.start_format == "position" or series_.has_datetime_index: if n.start >= len(series_): @@ -111,13 +136,32 @@ def _historical_forecasts_general_checks(model, series, kwargs): ), logger, ) - elif n.start > series_.time_index[-1]: # format "value" and range index + else: + if ( + n.start > series_.time_index[-1] + ): # format "value" and range index + raise_log( + ValueError( + f"`start` time `{n.start}` is larger than the last index `{series_.time_index[-1]}` " + f"for series at index: {idx}." + ), + logger, + ) + start_is_value = True + + # `ConformalModel` with `start_format='value'` requires all series to have the same frequency + if is_conformal and start_is_value: + if series_freq is None: + series_freq = series_.freq + + if series_freq != series_.freq: raise_log( ValueError( - f"`start` time `{n.start}` is larger than the last index `{series_.time_index[-1]}` " - f"for series at index: {idx}." + f"Found mismatching `series` time index frequencies `{series_freq}` and `{series_.freq}`. " + f"`start_format='value'` with `ConformalModel` is only supported if all series in " + f"`series` have the same frequency." ), - logger, + logger=logger, ) # find valid start position relative to the series start time, otherwise raise an error @@ -211,33 +255,6 @@ def _historical_forecasts_general_checks(model, series, kwargs): ) -def _conformal_historical_forecasts_general_checks(model, series, kwargs): - """ - Performs checks for `ConformalModel.historical_forecasts()`. - - Parameters - ---------- - model - The forecasting model. - series - Either series when called from ForecastingModel, or target_series if called from RegressionModel - kwargs - Params specified by the caller of backtest(), they take precedence over the arguments' default values - """ - # parse kwargs - n = SimpleNamespace(**kwargs) - - # check stride - if n.stride < model.cal_stride or n.stride % model.cal_stride > 0: - raise_log( - ValueError( - f"The provided `stride` parameter must be a round-multiple of `cal_stride={model.cal_stride}` " - f"and `>=cal_stride`. Received `stride={n.stride}`" - ), - logger, - ) - - def _historical_forecasts_sanitize_kwargs( model, fit_kwargs: Optional[dict[str, Any]], @@ -428,8 +445,12 @@ def _check_start( if isinstance(start, float): # fraction of series start = series.get_index_at_point(start) - else: + elif start >= 0: + # start >= 0 is relative to the start start = series.start_time() + start * series.freq + else: + # start < 0 is relative to the end + start = series.end_time() + (start + 1) * series.freq else: start_format_msg = "time " ref_msg = "" if not is_historical_forecast else "historical forecastable " From a909a2656def99fcb0fb82ded45b948431532363 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Tue, 26 Nov 2024 13:55:47 +0100 Subject: [PATCH 65/78] add hist fc start test with different strides --- darts/models/forecasting/conformal_models.py | 124 +++++++++--------- .../test_historical_forecasts.py | 69 +++++----- 2 files changed, 102 insertions(+), 91 deletions(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index deedf4f1d5..32f8ba87e7 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -55,65 +55,6 @@ logger = get_logger(__name__) -def _get_calibration_hfc_start( - series: Sequence[TimeSeries], - horizon: int, - output_chunk_shift: int, - cal_length: Optional[int], - cal_stride: int, - start: Optional[Union[pd.Timestamp, int, Literal["end"]]], - start_format: Literal["position", "value"], -) -> tuple[Optional[Union[int, pd.Timestamp]], Literal["position", "value"]]: - """Find the calibration start point (CSP) (for historical forecasts on calibration set). - - - If `start=None`, the CSP is also `None` (all possible hfcs). - - If `start="end"` (when calling `predict()`), returns the CSP as a positional index relative to the end of the - series (<0). - - Otherwise (when calling `historical_forecasts()`), the CSP is the start value (`start_format="value"`) or start - position (`start_format="position"`) adjusted by the positions computed for the case above. - - If this function is called from `historical_forecasts`, the sanity checks guarantee the following: - - - `start` cannot be a `float` - - when `start_format='value'`, all `series` have the same frequency - """ - if start is None: - return start, start_format - - horizon_ocs = horizon + output_chunk_shift - if cal_length is not None: - # we only need `cal_length` forecasts with stride `cal_stride` before the `predict()` start point; - # the last valid calibration forecast must start at least `horizon_ocs` before `predict()` start - add_steps = math.ceil(horizon_ocs / cal_stride) - 1 - start_idx_rel = -cal_stride * (cal_length + add_steps) - cal_start_format = "position" - elif cal_stride > 1: - # we need all forecasts with stride `cal_stride` before the `predict()` start point - max_len_series = max(len(series_) for series_ in series) - start_idx_rel = -cal_stride * math.ceil(max_len_series / cal_stride) - cal_start_format = "position" - else: - # we need all possible forecasts with `cal_stride=1` - start_idx_rel, cal_start_format = None, "value" - - if start == "end": - # `predict()` is relative to the end - return start_idx_rel, cal_start_format - - # `historical_forecasts()` is relative to `start` - start_is_position = isinstance(start, (int, np.int64)) and ( - start_format == "position" or series[0]._has_datetime_index - ) - cal_start_format = start_format - if start_idx_rel is None: - cal_start = start_idx_rel - elif start_is_position: - cal_start = start + start_idx_rel - else: - cal_start = start + start_idx_rel * series[0].freq - return cal_start, cal_start_format - - class ConformalModel(GlobalForecastingModel, ABC): @random_method def __init__( @@ -1114,7 +1055,6 @@ def _calibrate_forecasts( - Compute the conformal prediction: Add the calibrated intervals to (or adjust the existing intervals of) the forecasting model's predictions. """ - # TODO: add proper handling of `cal_stride` > 1 cal_stride = self.cal_stride cal_length = self.cal_length metric, metric_kwargs = self._residuals_metric @@ -1240,7 +1180,6 @@ def _calibrate_forecasts( s_hfcs[0].start_time(), freq=series_.freq, ) - # TODO: add proper start handling with `cal_stride>1` # adjust by stride first_idx_start = math.ceil(first_idx_start / cal_stride) @@ -1846,3 +1785,66 @@ def _residuals_metric(self) -> tuple[METRIC_TYPE, Optional[dict]]: "q_interval": self.q_interval, "symmetric": self.symmetric, } + + +def _get_calibration_hfc_start( + series: Sequence[TimeSeries], + horizon: int, + output_chunk_shift: int, + cal_length: Optional[int], + cal_stride: int, + start: Optional[Union[pd.Timestamp, int, Literal["end"]]], + start_format: Literal["position", "value"], +) -> tuple[Optional[Union[int, pd.Timestamp]], Literal["position", "value"]]: + """Find the calibration start point (CSP) (for historical forecasts on calibration set). + + - If `start=None`, the CSP is also `None` (all possible hfcs). + - If `start="end"` (when calling `predict()`), returns the CSP as a positional index relative to the end of the + series (<0). + - Otherwise (when calling `historical_forecasts()`), the CSP is the start value (`start_format="value"`) or start + position (`start_format="position"`) adjusted by the positions computed for the case above. + + If this function is called from `historical_forecasts`, the sanity checks guarantee the following: + + - `start` cannot be a `float` + - when `start_format='value'`, all `series` have the same frequency + """ + if start is None: + return start, start_format + + horizon_ocs = horizon + output_chunk_shift + if cal_length is not None: + # we only need `cal_length` forecasts with stride `cal_stride` before the `predict()` start point; + # the last valid calibration forecast must start at least `horizon_ocs` before `predict()` start + add_steps = math.ceil(horizon_ocs / cal_stride) - 1 + start_idx_rel = -cal_stride * (cal_length + add_steps) + cal_start_format = "position" + elif cal_stride > 1: + # we need all forecasts with stride `cal_stride` before the `predict()` start point + max_len_series = max(len(series_) for series_ in series) + start_idx_rel = -cal_stride * math.ceil(max_len_series / cal_stride) + cal_start_format = "position" + else: + # we need all possible forecasts with `cal_stride=1` + start_idx_rel, cal_start_format = None, "value" + + if start == "end": + # `predict()` is relative to the end + return start_idx_rel, cal_start_format + + # `historical_forecasts()` is relative to `start` + start_is_position = isinstance(start, (int, np.int64)) and ( + start_format == "position" or series[0]._has_datetime_index + ) + cal_start_format = start_format + if start_idx_rel is None: + cal_start = start_idx_rel + elif start_is_position: + cal_start = start + start_idx_rel + # if start switches sign, it would be relative to the end; + # correct it to be positive (relative to beginning) + if cal_start < 0 < start: + cal_start += math.ceil(abs(cal_start) / cal_stride) * cal_stride + else: + cal_start = start + start_idx_rel * series[0].freq + return cal_start, cal_start_format diff --git a/darts/tests/utils/historical_forecasts/test_historical_forecasts.py b/darts/tests/utils/historical_forecasts/test_historical_forecasts.py index cea24e4268..833cbdc7d2 100644 --- a/darts/tests/utils/historical_forecasts/test_historical_forecasts.py +++ b/darts/tests/utils/historical_forecasts/test_historical_forecasts.py @@ -1,5 +1,6 @@ import itertools import logging +import math from copy import deepcopy from itertools import product from typing import Optional @@ -3663,44 +3664,46 @@ def test_conformal_historical_start_cal_length(self, config): @pytest.mark.parametrize( "config", - list( - itertools.product( - [False, True], # last points only - [None, 2], # cal length - ["value", "position"], # start format - [1, 2], # stride - [0, 1], # output chunk shift - ) + itertools.product( + [False, True], # last points only + [None, 2], # cal length + ["value", "position"], # start format + [2, 4], # stride + [1, 2], # cal stride + [0, 1], # output chunk shift ), ) - def test_conformal_historical_forecast_start(self, caplog, config): + def test_conformal_historical_forecast_start_stride(self, caplog, config): """Tests naive conformal model with `start` being the first forecastable index is identical to a start - before forecastable index (including stride). + before forecastable index (including stride, cal stride). """ ( last_points_only, cal_length, start_format, stride, + cal_stride, ocs, ) = config - # TODO: adjust this test (the input length of `series_val`), once `cal_stride` has been properly implemented q = [0.1, 0.5, 0.9] pred_lklp = {"num_samples": 1, "predict_likelihood_parameters": True} # compute minimum series length to generate n forecasts icl = 3 ocl = 5 horizon = 2 - horizon_ocs = horizon + ocs - add_cal_length = cal_length - 1 if cal_length is not None else 0 - min_len_val_series = icl + 2 * horizon_ocs + add_cal_length + + # the position of the first conformal forecast start point without look-ahead bias; assuming min cal_length=1 + horizon_ocs = math.ceil((horizon + ocs) / cal_stride) * cal_stride + # adjust by the number of calibration examples + add_cal_length = cal_stride * (cal_length - 1) if cal_length is not None else 0 + # the minimum series length is the sum of the above, plus the length of one forecast (horizon + ocs) + min_len_val_series = icl + horizon_ocs + add_cal_length + horizon + ocs n_forecasts = 3 # to get `n_forecasts` with `stride`, we need more points n_forecasts_stride = stride * n_forecasts - int(1 % stride > 0) # get train and val series of that length - series_train, series_val = ( - self.ts_pass_train[:10], - self.ts_pass_val[: min_len_val_series + n_forecasts_stride - 1], + series = tg.linear_timeseries( + length=min_len_val_series + n_forecasts_stride - 1 ) # first train the ForecastingModel @@ -3709,23 +3712,25 @@ def test_conformal_historical_forecast_start(self, caplog, config): output_chunk_length=ocl, output_chunk_shift=ocs, ) - forecasting_model.fit(series_train) + forecasting_model.fit(series) # optionally compute the start as a positional index start_position = icl + horizon_ocs + add_cal_length if start_format == "value": - start = series_val.time_index[start_position] - start_too_early = series_val.time_index[start_position - stride] + start = series.time_index[start_position] + start_too_early = series.time_index[start_position - 1] + start_too_early_stride = series.time_index[start_position - stride] else: start = start_position - start_too_early = start_position - stride - start_first_fc = series_val.time_index[start_position] + series_val.freq * ( - horizon_ocs - 1 if last_points_only else ocs + start_too_early = start_position - 1 + start_too_early_stride = start_position - stride + start_first_fc = series.time_index[start_position] + series.freq * ( + horizon + ocs - 1 if last_points_only else ocs ) too_early_warn_exp = "is before the first predictable/trainable historical" hfc_params = { - "series": series_val, + "series": series, "retrain": False, "start_format": start_format, "stride": stride, @@ -3737,13 +3742,13 @@ def test_conformal_historical_forecast_start(self, caplog, config): assert len(hist_fct_all) == n_forecasts assert hist_fct_all[0].start_time() == start_first_fc assert ( - hist_fct_all[1].start_time() - stride * series_val.freq + hist_fct_all[1].start_time() - stride * series.freq == hist_fct_all[0].start_time() ) # compute conformal historical forecasts (starting at first possible conformal forecast) model = ConformalNaiveModel( - forecasting_model, quantiles=q, cal_length=cal_length, cal_stride=stride + forecasting_model, quantiles=q, cal_length=cal_length, cal_stride=cal_stride ) with caplog.at_level(logging.WARNING): hist_fct = model.historical_forecasts( @@ -3754,15 +3759,19 @@ def test_conformal_historical_forecast_start(self, caplog, config): assert len(hist_fct) == len(hist_fct_all) assert hist_fct_all[0].start_time() == hist_fct[0].start_time() assert ( - hist_fct[1].start_time() - stride * series_val.freq - == hist_fct[0].start_time() + hist_fct[1].start_time() - stride * series.freq == hist_fct[0].start_time() ) - # start one earlier raises warning but still starts at same time + # start one earlier gives warning with caplog.at_level(logging.WARNING): - hist_fct_too_early = model.historical_forecasts( + _ = model.historical_forecasts( start=start_too_early, **hfc_params, **pred_lklp ) assert too_early_warn_exp in caplog.text caplog.clear() + + # starting stride before first valid start, gives identical results + hist_fct_too_early = model.historical_forecasts( + start=start_too_early_stride, **hfc_params, **pred_lklp + ) assert hist_fct_too_early == hist_fct From de93de1e6c35898fee97dd6ac206e2d1869d0061 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Tue, 26 Nov 2024 15:07:59 +0100 Subject: [PATCH 66/78] improve comments --- darts/models/forecasting/conformal_models.py | 116 +++++++++---------- 1 file changed, 52 insertions(+), 64 deletions(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index 32f8ba87e7..5623730f22 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -1102,12 +1102,13 @@ def _calibrate_forecasts( # determine first forecast index for conformal prediction # we need at least one residual per point in the horizon prior to the first conformal forecast - first_idx_train = math.ceil( - (forecast_horizon + self.output_chunk_shift) / cal_stride - ) + horizon_ocs = forecast_horizon + self.output_chunk_shift + first_idx_train = math.ceil(horizon_ocs / cal_stride) + # plus some additional examples based on `cal_length` if cal_length is not None: first_idx_train += cal_length - 1 + # check if later we need to drop some residuals without useful information (unknown residuals) if overlap_end: delta_end = n_steps_between( @@ -1126,7 +1127,7 @@ def _calibrate_forecasts( # useful residual information only up until the forecast starting at the last time step in `series` ignore_n_residuals = delta_end - forecast_horizon + 1 else: - # ignore at least the one residuals/forecast from the end, since we can only use prior residuals + # ignore at least one forecast residuals from the end, since we can only use prior residuals ignore_n_residuals = self.output_chunk_shift + 1 # with last points only, ignore the last `horizon` residuals to avoid look-ahead bias if last_points_only: @@ -1134,9 +1135,8 @@ def _calibrate_forecasts( # get the last index respecting `cal_stride` last_res_idx = -math.ceil(ignore_n_residuals / cal_stride) - - if last_res_idx is not None: - res = res[:last_res_idx] + # get only useful residuals + res = res[:last_res_idx] if first_idx_train >= len(s_hfcs) or len(res) < min_n_cal: raise_log( @@ -1151,32 +1151,40 @@ def _calibrate_forecasts( # adjust first index based on `start` first_idx_start = 0 - if start is not None and start == "end": - # start at the last forecast + if start == "end": + # called from `predict()`; start at the last forecast first_idx_start = len(s_hfcs) - 1 elif start is not None: - # adjust forecastable index in case of output shift or `last_points_only=True` + # called from `historical_forecasts()`: use user-defined start + # the conformal forecastable index ranges from the start of the first valid historical + # forecast until the start of the last historical forecast + historical_forecasts_time_index = ( + s_hfcs[first_idx_train].start_time(), + s_hfcs[-1].start_time(), + ) + # adjust forecast start points in case of output shift or `last_points_only=True` adjust_idx = ( self.output_chunk_shift + int(last_points_only) * (forecast_horizon - 1) ) * series_.freq - historical_forecastable_index = ( - s_hfcs[first_idx_train].start_time() - adjust_idx, - s_hfcs[-1].start_time() - adjust_idx, + historical_forecasts_time_index = ( + historical_forecasts_time_index[0] - adjust_idx, + historical_forecasts_time_index[1] - adjust_idx, ) - # adjust forecastable index based on start, assuming hfcs were generated with `stride=1` - first_idx_start, _ = _adjust_historical_forecasts_time_index( + + # adjust forecastable times based on user start, assuming hfcs were generated with `stride=1` + first_start_time, _ = _adjust_historical_forecasts_time_index( series=series_, series_idx=series_idx, start=start, start_format=start_format, stride=stride, - historical_forecasts_time_index=historical_forecastable_index, + historical_forecasts_time_index=historical_forecasts_time_index, show_warnings=show_warnings, ) # find position relative to start first_idx_start = n_steps_between( - first_idx_start + adjust_idx, + first_start_time + adjust_idx, s_hfcs[0].start_time(), freq=series_.freq, ) @@ -1185,77 +1193,56 @@ def _calibrate_forecasts( # get final first index first_fc_idx = max([first_idx_train, first_idx_start]) - # bring into shape (forecasting steps, n components, n samples * n examples) + # bring `res` from shape (forecasting steps, n components, n past residuals) into + # shape (forecasting steps, n components, n past residuals) if last_points_only: - # -> (1, n components, n samples * n examples) - res = res.T + # -> (1, n components, n samples * n past residuals) + res = res.transpose(2, 1, 0) else: - res = np.array(res) - # -> (forecast horizon, n components, n samples * n examples) # rearrange the residuals to avoid look-ahead bias and to have the same number of examples per # point in the horizon. We want the most recent residuals in the past for each step in the horizon. - # Meaning that to conformalize any forecast at some time `t` with `horizon=n`: - # - for `horizon=1` of that forecast calibrate with residuals from all 1-step forecasts up until - # forecast time `t-1` - # - for `horizon=n` of that forecast calibrate with residuals from all n-step forecasts up until - # forecast time `t-n` - # The rearranged residuals will look as follows, where `res_ti_cj_hk` is the - # residuals at time `ti` for component `cj` at forecasted step/horizon `hk`. - # ``` - # [ # forecast horizon - # [ # components - # [res_t0_c0_h1, ...] # residuals at different times - # [..., res_tn_cn_h1], - # ], - # ..., - # [ - # [res_t0_c0_hn, ...], - # [..., res_tn_cn_hn], - # ], - # ] - # ``` + res = np.array(res) + + # go through each step in the horizon, use all useful information from the end (most recent values), + # and skip information at beginning (most distant past); + # -> (forecast horizon, n components, n past residuals) res_ = [] - for irr in range(forecast_horizon - 1, -1, -1): - idx_fc_start = math.floor(irr / cal_stride) + for idx_horizon in range(forecast_horizon): + n = idx_horizon + 1 + # ignore residuals at beginning + idx_fc_start = math.floor((forecast_horizon - n) / cal_stride) + # keep as many residuals as possible from end idx_fc_end = -( math.ceil(forecast_horizon / cal_stride) - (idx_fc_start + 1) ) - idx_horizon = forecast_horizon - (irr + 1) res_.append(res[idx_fc_start : idx_fc_end or None, idx_horizon]) res = np.concatenate(res_, axis=2).T - # get the last forecast index based on the residual examples - last_fc_idx = res.shape[2] + math.ceil( - (forecast_horizon + self.output_chunk_shift) / cal_stride - ) + # get the last conformal forecast index (exclusive) based on the residual examples + last_fc_idx = res.shape[2] + math.ceil(horizon_ocs / cal_stride) # forecasts are stridden, so stride must be relative rel_stride = math.ceil(stride / cal_stride) def conformal_predict(idx_, pred_vals_): # get the last residual index for calibration, `cal_end` is exclusive - # to avoid look-ahead bias, use only residuals from before the historical forecast start point; + # to avoid look-ahead bias, use only residuals from before the conformal forecast start point; # for `last_points_only=True`, the last residual historically available at the forecasting - # point is `forecast_horizon + self.output_chunk_shift - 1` steps before. The same applies to - # `last_points_only=False` thanks to the residual rearrangement + # point is `horizon_ocs - 1` steps before. The same applies to `last_points_only=False` thanks to + # the residual rearrangement cal_end = ( first_fc_idx + idx_ * rel_stride - - ( - math.ceil( - (forecast_horizon + self.output_chunk_shift) / cal_stride - ) - - 1 - ) + - (math.ceil(horizon_ocs / cal_stride) - 1) ) - # first residual index is shifted back by the horizon to get `cal_length` points for - # the last point in the horizon + # optionally, use only `cal_length` residuals cal_start = cal_end - cal_length if cal_length is not None else None - cal_res = res[:, :, cal_start:cal_end] - q_hat_ = self._calibrate_interval(cal_res) - + # calibrate and apply interval to the forecasts + q_hat_ = self._calibrate_interval(res[:, :, cal_start:cal_end]) vals = self._apply_interval(pred_vals_, q_hat_) + + # optionally, generate samples from the intervals if not predict_likelihood_parameters: vals = sample_from_quantiles( vals, self.quantiles, num_samples=num_samples @@ -1270,13 +1257,14 @@ def conformal_predict(idx_, pred_vals_): ) else: inner_iterator = enumerate(s_hfcs[first_fc_idx:last_fc_idx:rel_stride]) + comp_names_out = ( self._cp_component_names(series_) if predict_likelihood_parameters else None ) if len(series) == 1: - # Only use progress bar if there's no outer loop + # only use progress bar if there's no outer loop inner_iterator = _build_tqdm_iterator( inner_iterator, verbose, From c6d8c16b21ea2f725a72668cbb384a5b92daf922 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 6 Dec 2024 15:24:46 +0100 Subject: [PATCH 67/78] add more tests --- darts/models/forecasting/conformal_models.py | 3 +- .../forecasting/test_conformal_model.py | 107 ++++++++++++++++++ 2 files changed, 109 insertions(+), 1 deletion(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index 5623730f22..df8d8634a7 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -1800,6 +1800,7 @@ def _get_calibration_hfc_start( if start is None: return start, start_format + cal_start_format: Literal["position", "value"] horizon_ocs = horizon + output_chunk_shift if cal_length is not None: # we only need `cal_length` forecasts with stride `cal_stride` before the `predict()` start point; @@ -1831,7 +1832,7 @@ def _get_calibration_hfc_start( cal_start = start + start_idx_rel # if start switches sign, it would be relative to the end; # correct it to be positive (relative to beginning) - if cal_start < 0 < start: + if cal_start < 0 <= start: cal_start += math.ceil(abs(cal_start) / cal_stride) * cal_stride else: cal_start = start + start_idx_rel * series[0].freq diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 90a9d30ce0..53ac6d1168 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -16,9 +16,11 @@ NaiveSeasonal, NLinearModel, ) +from darts.models.forecasting.conformal_models import _get_calibration_hfc_start from darts.models.forecasting.forecasting_model import ForecastingModel from darts.tests.conftest import TORCH_AVAILABLE, tfm_kwargs from darts.utils import timeseries_generation as tg +from darts.utils.timeseries_generation import linear_timeseries from darts.utils.utils import ( likelihood_component_names, quantile_interval_names, @@ -1356,3 +1358,108 @@ def test_predict_probabilistic_equals_quantile(self): vals_q, model_type="regression_prob", ) + + @pytest.mark.parametrize( + "config", + [ + # (cal_length, cal_stride, (start_expected, start_format_expected)) + (None, 1, (None, "value")), + (None, 2, (-4, "position")), + (None, 3, (-6, "position")), + (None, 4, (-4, "position")), + (1, 1, (-3, "position")), + (1, 2, (-4, "position")), + (1, 3, (-3, "position")), + (1, 4, (-4, "position")), + ], + ) + def test_calibration_hfc_start_predict(self, config): + """Test calibration historical forecast start point when calling `predict()` ("end" position).""" + cal_length, cal_stride, start_expected = config + series = linear_timeseries(length=4) + horizon = 2 + output_chunk_shift = 1 + assert ( + _get_calibration_hfc_start( + series=[series], + horizon=horizon, + output_chunk_shift=output_chunk_shift, + cal_length=cal_length, + cal_stride=cal_stride, + start="end", + start_format="position", + ) + == start_expected + ) + + @pytest.mark.parametrize( + "config", + [ + # (cal_length, cal_stride, start, start_expected) + (None, 1, None, None), + (None, 1, 1, None), + (1, 1, -1, -4), + (1, 1, 0, 0), + (1, 2, 0, 0), + (1, 3, 0, 0), + (1, 1, 1, 0), + (1, 2, 1, 1), + (1, 3, 1, 1), + (1, 1, -1, -4), + (1, 2, -1, -5), + (1, 3, -1, -4), + ], + ) + def test_calibration_hfc_start_position_hist_fc(self, config): + """Test calibration historical forecast start point when calling `historical_forecasts()` + with start format "position".""" + cal_length, cal_stride, start, start_expected = config + series = linear_timeseries(length=4) + horizon = 2 + output_chunk_shift = 1 + assert _get_calibration_hfc_start( + series=[series], + horizon=horizon, + output_chunk_shift=output_chunk_shift, + cal_length=cal_length, + cal_stride=cal_stride, + start=start, + start_format="position", + ) == (start_expected, "position") + + @pytest.mark.parametrize( + "config", + [ + # (cal_length, cal_stride, start, start_expected) + (None, 1, None, None), + (None, 1, "2020-01-11", None), + (1, 1, "2020-01-09", "2020-01-06"), # start before series start + (1, 1, "2020-01-10", "2020-01-07"), + (1, 2, "2020-01-10", "2020-01-06"), + (1, 3, "2020-01-10", "2020-01-07"), + (2, 1, "2020-01-09", "2020-01-05"), + (2, 1, "2020-01-10", "2020-01-06"), + (2, 2, "2020-01-10", "2020-01-04"), + (2, 3, "2020-01-10", "2020-01-04"), + ], + ) + def test_calibration_hfc_start_value_hist_fc(self, config): + """Test calibration historical forecast start point when calling `historical_forecasts()` + with start format "value".""" + cal_length, cal_stride, start, start_expected = config + if start is not None: + start = pd.Timestamp(start) + if start_expected is not None: + start_expected = pd.Timestamp(start_expected) + series = linear_timeseries(length=4, start=pd.Timestamp("2020-01-10"), freq="d") + horizon = 2 + output_chunk_shift = 1 + assert _get_calibration_hfc_start( + series=[series], + horizon=horizon, + output_chunk_shift=output_chunk_shift, + cal_length=cal_length, + cal_stride=cal_stride, + start=start, + start_format="value", + ) == (start_expected, "value") From 3e002485416ad5788f2c286a051663255a4bbe5d Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sun, 8 Dec 2024 19:30:04 +0100 Subject: [PATCH 68/78] stridden conformal model tests --- .../forecasting/test_conformal_model.py | 183 +++++++++++++++++- 1 file changed, 174 insertions(+), 9 deletions(-) diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 53ac6d1168..983dd48af6 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -1,5 +1,6 @@ import copy import itertools +import math import os import numpy as np @@ -19,6 +20,7 @@ from darts.models.forecasting.conformal_models import _get_calibration_hfc_start from darts.models.forecasting.forecasting_model import ForecastingModel from darts.tests.conftest import TORCH_AVAILABLE, tfm_kwargs +from darts.utils import n_steps_between from darts.utils import timeseries_generation as tg from darts.utils.timeseries_generation import linear_timeseries from darts.utils.utils import ( @@ -907,6 +909,159 @@ def test_naive_conformal_model_historical_forecasts(self, config): hfc_conf_lpo = concatenate([hfc[-1:] for hfc in hfc_conf], axis=0) assert hfc_lpo == hfc_conf_lpo + @pytest.mark.parametrize( + "config", + itertools.product( + [1, 3, 5], # horizon + [0, 1], # output chunk shift + [None, 1], # cal length, + [1, 2], # cal stride + [False, True], # use start + ), + ) + def test_stridden_conformal_model(self, config): + """Checks correctness of naive conformal model historical forecasts for: + - different horizons (smaller, equal and larger the OCL) + - uni and multivariate series + - single and multiple series + - with and without output shift + - with and without training length + - with and without covariates + """ + is_univar, is_single = True, False + n, ocs, cal_length, cal_stride, use_start = config + if ocs and n > OUT_LEN: + # auto-regression not allowed with ocs + return + + series = self.helper_prepare_series(is_univar, is_single) + # shift second series ahead to cover the non overlapping multi series case + series = [series[0], series[1].shift(120)] + model_params = {"output_chunk_shift": ocs} + + # forecasts from forecasting model + model_fc = train_model(series, model_params=model_params) + hfc_fc_list = model_fc.historical_forecasts( + series, + retrain=False, + forecast_horizon=n, + overlap_end=True, + last_points_only=False, + stride=cal_stride, + ) + # residuals to compute the conformal intervals + residuals_list = model_fc.residuals( + series, + historical_forecasts=hfc_fc_list, + overlap_end=True, + last_points_only=False, + values_only=True, + metric=ae, # absolute error + ) + + # conformal forecasts + model = ConformalNaiveModel( + model=model_fc, + quantiles=q, + cal_length=cal_length, + cal_stride=cal_stride, + ) + # the expected positional index of the first conformal forecast + # index = (skip n + ocs points (relative to cal_stride) to avoid look-ahead bias) + (number of cal examples) + first_fc_idx = math.ceil((n + ocs) / cal_stride) + ( + cal_length - 1 if cal_length else 0 + ) + first_start = n_steps_between( + hfc_fc_list[0][first_fc_idx].start_time() - ocs * series[0].freq, + series[0].start_time(), + freq=series[0].freq, + ) + + hfc_conf_list = model.historical_forecasts( + series=series, + forecast_horizon=n, + overlap_end=True, + last_points_only=False, + start=first_start if use_start else None, + start_format="position" if use_start else "value", + stride=cal_stride, + **pred_lklp, + ) + + # also, skip some residuals from output chunk shift + ignore_ocs = math.ceil(ocs / cal_stride) if ocs >= cal_stride else 0 + for hfc_fc, hfc_conf, hfc_residuals in zip( + hfc_fc_list, hfc_conf_list, residuals_list + ): + for idx, (pred_fc, pred_cal) in enumerate( + zip(hfc_fc[first_fc_idx:], hfc_conf) + ): + residuals = np.concatenate( + hfc_residuals[: first_fc_idx - ignore_ocs + idx], axis=2 + ) + pred_vals = pred_fc.all_values() + pred_vals_expected = self.helper_compute_pred_cal( + residuals, + pred_vals, + n, + q, + cal_length=cal_length, + model_type="regression", + symmetric=True, + cal_stride=cal_stride, + ) + assert pred_fc.time_index.equals(pred_cal.time_index) + np.testing.assert_array_almost_equal( + pred_cal.all_values(), pred_vals_expected + ) + + # check that with a round-multiple of `cal_stride` we get identical forecasts + assert model.historical_forecasts( + series=series, + forecast_horizon=n, + overlap_end=True, + last_points_only=False, + start=first_start if use_start else None, + start_format="position" if use_start else "value", + stride=2 * cal_stride, + **pred_lklp, + ) == [hfc[::2] for hfc in hfc_conf_list] + + # checking that last points only is equal to the last forecasted point + hfc_lpo_list = model.historical_forecasts( + series=series, + forecast_horizon=n, + overlap_end=True, + last_points_only=True, + stride=cal_stride, + **pred_lklp, + ) + for hfc_lpo, hfc_conf in zip(hfc_lpo_list, hfc_conf_list): + hfc_conf_lpo = concatenate( + [hfc[-1::cal_stride] for hfc in hfc_conf], axis=0 + ) + assert hfc_lpo == hfc_conf_lpo + + # checking that predict gives the same results as last historical forecast + preds = model.predict( + series=series, + n=n, + **pred_lklp, + ) + hfcs_conf_end = model.historical_forecasts( + series=series, + forecast_horizon=n, + overlap_end=True, + last_points_only=False, + start=-cal_stride, + start_format="position", + stride=cal_stride, + **pred_lklp, + ) + hfcs_conf_end = [hfc[-1] for hfc in hfcs_conf_end] + for pred, last_hfc in zip(preds, hfcs_conf_end): + assert pred == last_hfc + def test_probabilistic_historical_forecast(self): """Checks correctness of naive conformal historical forecast from probabilistic fc model compared to deterministic one, @@ -952,7 +1107,8 @@ def helper_prepare_series(self, is_univar, is_single): series = [series, series + 5] return series - def helper_compare_preds(self, cp_pred, pred_expected, model_type, tol_rel=0.1): + @staticmethod + def helper_compare_preds(cp_pred, pred_expected, model_type, tol_rel=0.1): if isinstance(cp_pred, TimeSeries): cp_pred = cp_pred.all_values(copy=False) if model_type == "regression": @@ -965,7 +1121,14 @@ def helper_compare_preds(self, cp_pred, pred_expected, model_type, tol_rel=0.1): @staticmethod def helper_compute_pred_cal( - residuals, pred_vals, n, quantiles, model_type, symmetric, cal_length=None + residuals, + pred_vals, + horizon, + quantiles, + model_type, + symmetric, + cal_length=None, + cal_stride=1, ): """Generates expected prediction results for naive conformal model from: @@ -999,13 +1162,15 @@ def helper_compute_pred_cal( q_hats = [] # compute the quantile `alpha` of all past residuals (absolute "per time step" errors between historical # forecasts and the target series) - for idx in range(n): - res_end = residuals.shape[2] - idx - if cal_length: - res_start = res_end - cal_length - else: - res_start = n - (idx + 1) - res_n = residuals[idx][:, res_start:res_end] + for idx_horizon in range(horizon): + n = idx_horizon + 1 + # ignore residuals at beginning + idx_fc_start = math.floor((horizon - n) / cal_stride) + # keep as many residuals as possible from end + idx_fc_end = -(math.ceil(horizon / cal_stride) - (idx_fc_start + 1)) + res_n = residuals[idx_horizon, :, idx_fc_start : idx_fc_end or None] + if cal_length is not None: + res_n = res_n[:, -cal_length:] if is_naive and symmetric: # identical correction for upper and lower bounds # metric is `ae()` From 966f25ff034a93a9f916c236ae17260bd516af57 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Mon, 9 Dec 2024 17:57:11 +0100 Subject: [PATCH 69/78] apply suggestions from pr review --- darts/metrics/metrics.py | 358 +++++++++--------- darts/models/forecasting/conformal_models.py | 13 +- darts/models/forecasting/forecasting_model.py | 7 +- .../forecasting/test_conformal_model.py | 22 +- .../test_historical_forecasts.py | 166 ++++---- darts/utils/utils.py | 5 +- 6 files changed, 269 insertions(+), 302 deletions(-) diff --git a/darts/metrics/metrics.py b/darts/metrics/metrics.py index 63c7b4ac2a..6a14f0bfb8 100644 --- a/darts/metrics/metrics.py +++ b/darts/metrics/metrics.py @@ -703,10 +703,10 @@ def err( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray @@ -714,9 +714,9 @@ def err( and component reductions, and shape (n time steps, n quantiles) without time but component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. - - single uni/multivariate series and at least `time_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. + - a single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of `component_reduction=None` or `time_reduction=None`. list[float] @@ -791,18 +791,18 @@ def merr( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, and shape (n quantiles,) with component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -882,10 +882,10 @@ def ae( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray @@ -893,9 +893,9 @@ def ae( and component reductions, and shape (n time steps, n quantiles) without time but component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. - - single uni/multivariate series and at least `time_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. + - a single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of `component_reduction=None` or `time_reduction=None`. list[float] @@ -970,18 +970,18 @@ def mae( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, and shape (n quantiles,) with component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -1084,10 +1084,10 @@ def ase( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray @@ -1095,9 +1095,9 @@ def ase( and component reductions, and shape (n time steps, n quantiles) without time but component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. - - single uni/multivariate series and at least `time_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. + - a single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of `component_reduction=None` or `time_reduction=None`. list[float] @@ -1198,18 +1198,18 @@ def mase( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, and shape (n quantiles,) with component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -1295,10 +1295,10 @@ def se( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray @@ -1306,9 +1306,9 @@ def se( and component reductions, and shape (n time steps, n quantiles) without time but component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. - - single uni/multivariate series and at least `time_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. + - a single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of `component_reduction=None` or `time_reduction=None`. list[float] @@ -1383,18 +1383,18 @@ def mse( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, and shape (n quantiles,) with component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -1497,10 +1497,10 @@ def sse( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray @@ -1508,9 +1508,9 @@ def sse( and component reductions, and shape (n time steps, n quantiles) without time but component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. - - single uni/multivariate series and at least `time_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. + - a single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of `component_reduction=None` or `time_reduction=None`. list[float] @@ -1611,18 +1611,18 @@ def msse( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, and shape (n quantiles,) with component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -1702,18 +1702,18 @@ def rmse( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, and shape (n quantiles,) with component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -1809,18 +1809,18 @@ def rmsse( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, and shape (n quantiles,) with component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -1905,10 +1905,10 @@ def sle( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray @@ -1916,9 +1916,9 @@ def sle( and component reductions, and shape (n time steps, n quantiles) without time but component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. - - single uni/multivariate series and at least `time_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. + - a single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of `component_reduction=None` or `time_reduction=None`. list[float] @@ -1996,18 +1996,18 @@ def rmsle( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, and shape (n quantiles,) with component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -2097,10 +2097,10 @@ def ape( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray @@ -2108,9 +2108,9 @@ def ape( and component reductions, and shape (n time steps, n quantiles) without time but component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. - - single uni/multivariate series and at least `time_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. + - a single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of `component_reduction=None` or `time_reduction=None`. list[float] @@ -2200,18 +2200,18 @@ def mape( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, and shape (n quantiles,) with component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -2301,10 +2301,10 @@ def sape( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray @@ -2312,9 +2312,9 @@ def sape( and component reductions, and shape (n time steps, n quantiles) without time but component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. - - single uni/multivariate series and at least `time_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. + - a single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of `component_reduction=None` or `time_reduction=None`. list[float] @@ -2407,18 +2407,18 @@ def smape( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, and shape (n quantiles,) with component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -2499,18 +2499,18 @@ def ope( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, and shape (n quantiles,) with component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -2606,10 +2606,10 @@ def arre( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray @@ -2617,9 +2617,9 @@ def arre( and component reductions, and shape (n time steps, n quantiles) without time but component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. - - single uni/multivariate series and at least `time_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. + - a single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of `component_reduction=None` or `time_reduction=None`. list[float] @@ -2710,13 +2710,13 @@ def marre( float A single metric score for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components,) without component reduction. For: - - single multivariate series and at least `component_reduction=None`. + - a single multivariate series and at least `component_reduction=None`. - sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -2794,18 +2794,18 @@ def r2_score( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, and shape (n quantiles,) with component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -2888,18 +2888,18 @@ def coefficient_of_variation( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, and shape (n quantiles,) with component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -2979,18 +2979,18 @@ def dtw_metric( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, and shape (n quantiles,) with component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -3068,18 +3068,18 @@ def qr( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, and shape (n quantiles,) with component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -3184,10 +3184,10 @@ def ql( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray @@ -3195,9 +3195,9 @@ def ql( and component reductions, and shape (n time steps, n quantiles) without time but component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. - - single uni/multivariate series and at least `time_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. + - a single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of `component_reduction=None` or `time_reduction=None`. list[float] @@ -3281,18 +3281,18 @@ def mql( Returns ------- float - A single metric score for (with `len(q) <= 1`): + A single metric score (when `len(q) <= 1`) for: - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n quantiles,) without component reduction, and shape (n quantiles,) with component reduction and `len(q) > 1`. For: - - the input from the `float` return case above but with `len(q) > 1`. - - single multivariate series and at least `component_reduction=None`. + - the same input arguments that result in the `float` return case from above but with `len(q) > 1`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -3350,7 +3350,7 @@ def iw( For time series that are overlapping in time without having the same time index, setting `True` will consider the values only over their common time interval (intersection in time). q_interval - The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence tuples + The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence of tuples (multiple intervals) with elements (low quantile, high quantile). q Quantiles `q` not supported by this metric; use `q_interval` instead. @@ -3382,8 +3382,8 @@ def iw( float A single metric score for (with `len(q_interval) <= 1`): - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray @@ -3392,8 +3392,8 @@ def iw( `len(q_interval) > 1`. For: - the input from the `float` return case above but with `len(q_interval) > 1`. - - single multivariate series and at least `component_reduction=None`. - - single uni/multivariate series and at least `time_reduction=None`. + - a single multivariate series and at least `component_reduction=None`. + - a single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of `component_reduction=None` or `time_reduction=None`. list[float] @@ -3451,7 +3451,7 @@ def miw( For time series that are overlapping in time without having the same time index, setting `True` will consider the values only over their common time interval (intersection in time). q_interval - The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence tuples + The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence of tuples (multiple intervals) with elements (low quantile, high quantile). q Quantiles `q` not supported by this metric; use `q_interval` instead. @@ -3478,8 +3478,8 @@ def miw( float A single metric score for (with `len(q_interval) <= 1`): - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n q intervals,) without component reduction, @@ -3487,7 +3487,7 @@ def miw( For: - the input from the `float` return case above but with `len(q_interval) > 1`. - - single multivariate series and at least `component_reduction=None`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -3552,7 +3552,7 @@ def iws( For time series that are overlapping in time without having the same time index, setting `True` will consider the values only over their common time interval (intersection in time). q_interval - The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence tuples + The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence of tuples (multiple intervals) with elements (low quantile, high quantile). q Quantiles `q` not supported by this metric; use `q_interval` instead. @@ -3584,8 +3584,8 @@ def iws( float A single metric score for (with `len(q_interval) <= 1`): - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray @@ -3594,8 +3594,8 @@ def iws( `len(q_interval) > 1`. For: - the input from the `float` return case above but with `len(q_interval) > 1`. - - single multivariate series and at least `component_reduction=None`. - - single uni/multivariate series and at least `time_reduction=None`. + - a single multivariate series and at least `component_reduction=None`. + - a single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of `component_reduction=None` or `time_reduction=None`. list[float] @@ -3672,7 +3672,7 @@ def miws( For time series that are overlapping in time without having the same time index, setting `True` will consider the values only over their common time interval (intersection in time). q_interval - The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence tuples + The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence of tuples (multiple intervals) with elements (low quantile, high quantile). q Quantiles `q` not supported by this metric; use `q_interval` instead. @@ -3699,8 +3699,8 @@ def miws( float A single metric score for (with `len(q_interval) <= 1`): - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n q intervals,) without component reduction, @@ -3708,7 +3708,7 @@ def miws( For: - the input from the `float` return case above but with `len(q_interval) > 1`. - - single multivariate series and at least `component_reduction=None`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -3776,7 +3776,7 @@ def ic( For time series that are overlapping in time without having the same time index, setting `True` will consider the values only over their common time interval (intersection in time). q_interval - The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence tuples + The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence of tuples (multiple intervals) with elements (low quantile, high quantile). q Quantiles `q` not supported by this metric; use `q_interval` instead. @@ -3808,8 +3808,8 @@ def ic( float A single metric score for (with `len(q_interval) <= 1`): - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray @@ -3818,8 +3818,8 @@ def ic( `len(q_interval) > 1`. For: - the input from the `float` return case above but with `len(q_interval) > 1`. - - single multivariate series and at least `component_reduction=None`. - - single uni/multivariate series and at least `time_reduction=None`. + - a single multivariate series and at least `component_reduction=None`. + - a single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of `component_reduction=None` or `time_reduction=None`. list[float] @@ -3875,7 +3875,7 @@ def mic( For time series that are overlapping in time without having the same time index, setting `True` will consider the values only over their common time interval (intersection in time). q_interval - The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence tuples + The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence of tuples (multiple intervals) with elements (low quantile, high quantile). q Quantiles `q` not supported by this metric; use `q_interval` instead. @@ -3902,8 +3902,8 @@ def mic( float A single metric score for (with `len(q_interval) <= 1`): - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n q intervals,) without component reduction, @@ -3911,7 +3911,7 @@ def mic( For: - the input from the `float` return case above but with `len(q_interval) > 1`. - - single multivariate series and at least `component_reduction=None`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. @@ -3971,7 +3971,7 @@ def incs_qr( For time series that are overlapping in time without having the same time index, setting `True` will consider the values only over their common time interval (intersection in time). q_interval - The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence tuples + The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence of tuples (multiple intervals) with elements (low quantile, high quantile). symmetric Whether to return symmetric non-conformity scores. If `False`, returns asymmetric scores (individual scores @@ -4006,8 +4006,8 @@ def incs_qr( float A single metric score for (with `len(q_interval) <= 1`): - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction`, `component_reduction` and `time_reduction`. np.ndarray @@ -4016,8 +4016,8 @@ def incs_qr( `len(q_interval) > 1`. For: - the input from the `float` return case above but with `len(q_interval) > 1`. - - single multivariate series and at least `component_reduction=None`. - - single uni/multivariate series and at least `time_reduction=None`. + - a single multivariate series and at least `component_reduction=None`. + - a single uni/multivariate series and at least `time_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and at least one of `component_reduction=None` or `time_reduction=None`. list[float] @@ -4077,7 +4077,7 @@ def mincs_qr( For time series that are overlapping in time without having the same time index, setting `True` will consider the values only over their common time interval (intersection in time). q_interval - The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence tuples + The quantile interval(s) to compute the metric on. Must be a tuple (single interval) or sequence of tuples (multiple intervals) with elements (low quantile, high quantile). symmetric Whether to return symmetric non-conformity scores. If `False`, returns asymmetric scores (individual scores @@ -4107,8 +4107,8 @@ def mincs_qr( float A single metric score for (with `len(q_interval) <= 1`): - - single univariate series. - - single multivariate series with `component_reduction`. + - a single univariate series. + - a single multivariate series with `component_reduction`. - a sequence (list) of uni/multivariate series with `series_reduction` and `component_reduction`. np.ndarray A numpy array of metric scores. The array has shape (n components * n q intervals,) without component reduction, @@ -4116,7 +4116,7 @@ def mincs_qr( For: - the input from the `float` return case above but with `len(q_interval) > 1`. - - single multivariate series and at least `component_reduction=None`. + - a single multivariate series and at least `component_reduction=None`. - a sequence of uni/multivariate series including `series_reduction` and `component_reduction=None`. list[float] Same as for type `float` but for a sequence of series. diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index df8d8634a7..c5b5815b16 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -152,12 +152,9 @@ def __init__( ) ] self.interval_range = np.array([ - q_high - q_low - for q_high, q_low in zip( - self.quantiles[self.idx_median + 1 :][::-1], - self.quantiles[: self.idx_median], - ) + q_high - q_low for q_low, q_high in self.q_interval ]) + if symmetric: # symmetric considers both tails together self.interval_range_sym = copy.deepcopy(self.interval_range) @@ -238,7 +235,7 @@ def predict( end of the `series`. It is important that the input series for prediction correspond to a calibration set - a set different to the - series that the underlying forecasting `model` was trained one. + series that the underlying forecasting `model` was trained on. Since it is a probabilistic model, you can generate forecasts in two ways: @@ -1121,10 +1118,10 @@ def _calibrate_forecasts( # ignore residuals without useful information if last_points_only and delta_end > 0: - # useful residual information only up until the forecast ending at the last time step in `series` + # useful residual information only up until the forecast *ending* at the last time step in `series` ignore_n_residuals = delta_end elif not last_points_only and delta_end >= forecast_horizon: - # useful residual information only up until the forecast starting at the last time step in `series` + # useful residual information only up until the forecast *starting* at the last time step in `series` ignore_n_residuals = delta_end - forecast_horizon + 1 else: # ignore at least one forecast residuals from the end, since we can only use prior residuals diff --git a/darts/models/forecasting/forecasting_model.py b/darts/models/forecasting/forecasting_model.py index aa8dc3a101..459f705575 100644 --- a/darts/models/forecasting/forecasting_model.py +++ b/darts/models/forecasting/forecasting_model.py @@ -675,7 +675,8 @@ def historical_forecasts( There are two main modes for this method: - Re-training Mode (Default, `retrain=True`): The model is re-trained at each step of the simulation, and - generates a forecast using the updated model. + generates a forecast using the updated model. In case of multiple series, the model is re-trained on each + series independently (global training is not yet supported). - Pre-trained Mode (`retrain=False`): The forecasts are generated at each step of the simulation without re-training. It is only supported for pre-trained global forecasting models. This mode is significantly faster as it skips the re-training step. @@ -1520,7 +1521,7 @@ def backtest( # remember input series type series_seq_type = get_series_seq_type(series) - # validate historical forecasts and covert to multiple series with multiple forecasts case + # validate historical forecasts and convert to multiple series with multiple forecasts case series, historical_forecasts = _process_historical_forecast_for_backtest( series=series, historical_forecasts=historical_forecasts, @@ -2205,7 +2206,7 @@ def residuals( # remember input series type series_seq_type = get_series_seq_type(series) - # validate historical forecasts and covert to multiple series with multiple forecasts case + # validate historical forecasts and convert to multiple series with multiple forecasts case series, historical_forecasts = _process_historical_forecast_for_backtest( series=series, historical_forecasts=historical_forecasts, diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 983dd48af6..64424df55e 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -314,7 +314,9 @@ def test_single_ts(self, config): **kwargs, ) pred = model.predict(n=self.horizon, **pred_lklp) - assert pred.n_components == self.ts_pass_train.n_components * 3 + assert pred.n_components == self.ts_pass_train.n_components * len( + kwargs["quantiles"] + ) assert not np.isnan(pred.all_values()).any().any() pred_fc = model.model.predict(n=self.horizon) @@ -329,8 +331,8 @@ def test_single_ts(self, config): assert pred.static_covariates is None # using a different `n`, gives different results, since we can generate more residuals for the horizon - pred1 = model.predict(n=1, **pred_lklp) - assert not pred1 == pred + pred1 = model.predict(n=self.horizon - 1, **pred_lklp) + assert not pred1 == pred[: len(pred1)] # wrong dimension with pytest.raises(ValueError): @@ -356,7 +358,9 @@ def test_multi_ts(self, config): model.predict(n=1) pred = model.predict(n=self.horizon, series=self.ts_pass_train, **pred_lklp) - assert pred.n_components == self.ts_pass_train.n_components * 3 + assert pred.n_components == self.ts_pass_train.n_components * len( + kwargs["quantiles"] + ) assert not np.isnan(pred.all_values()).any().any() # the center forecasts must be equal to the forecasting model forecast @@ -383,7 +387,9 @@ def test_multi_ts(self, config): f"Model {model_cls} did not return a list of prediction" ) for pred, pred_fc in zip(pred_list, pred_fc_list): - assert pred.n_components == self.ts_pass_train.n_components * 3 + assert pred.n_components == self.ts_pass_train.n_components * len( + kwargs["quantiles"] + ) assert pred_fc.time_index.equals(pred.time_index) assert not np.isnan(pred.all_values()).any().any() np.testing.assert_array_almost_equal( @@ -527,7 +533,7 @@ def test_covariates(self, config): with pytest.raises(ValueError): covs = cov_kwargs_train[cov_name] covs = {cov_name: covs.stack(covs)} - _ = model.predict(n=OUT_LEN + 1, **covs, **pred_lklp) + _ = model.predict(n=OUT_LEN, **covs, **pred_lklp) # with past covariates from train we can predict up until output_chunk_length pred1 = model.predict(n=OUT_LEN, **pred_lklp) pred2 = model.predict(n=OUT_LEN, series=self.ts_pass_train, **pred_lklp) @@ -551,7 +557,7 @@ def test_covariates(self, config): with pytest.raises(ValueError): covs = cov_kwargs_notrain[cov_name] covs = {cov_name: covs.stack(covs)} - _ = model.predict(n=OUT_LEN + 1, **covs, **pred_lklp) + _ = model.predict(n=OUT_LEN, **covs, **pred_lklp) pred1 = model.predict(n=OUT_LEN, **cov_kwargs_notrain, **pred_lklp) pred2 = model.predict( n=OUT_LEN, series=self.ts_pass_train, **cov_kwargs_notrain, **pred_lklp @@ -1506,7 +1512,7 @@ def test_predict_probabilistic_equals_quantile(self): model = ConformalNaiveModel(model=train_model(series), quantiles=quantiles) # direct quantile predictions pred_quantiles = model.predict(n=3, series=series, **pred_lklp) - # smapled predictions + # sampled predictions pred_samples = model.predict(n=3, series=series, num_samples=500) for pred_q, pred_s in zip(pred_quantiles, pred_samples): assert pred_q.n_samples == 1 diff --git a/darts/tests/utils/historical_forecasts/test_historical_forecasts.py b/darts/tests/utils/historical_forecasts/test_historical_forecasts.py index 833cbdc7d2..c48d16df1e 100644 --- a/darts/tests/utils/historical_forecasts/test_historical_forecasts.py +++ b/darts/tests/utils/historical_forecasts/test_historical_forecasts.py @@ -3332,39 +3332,26 @@ def test_conformal_historical_forecasts(self, config): min_len_val_series = icl + horizon_ocs + int(not overlap_end) * horizon_ocs n_forecasts = 3 # get train and val series of that length - series_train, series_val = ( - self.ts_pass_train[:10], - self.ts_pass_val[: min_len_val_series + n_forecasts - 1], - ) + series = self.ts_pass_val[: min_len_val_series + n_forecasts - 1] if use_int_idx: - series_train = TimeSeries.from_values( - series_train.all_values(), columns=series_train.columns - ) - series_val = TimeSeries.from_times_and_values( - values=series_val.all_values(), - times=pd.RangeIndex( - start=series_train.end_time() + series_train.freq, - stop=series_train.end_time() - + (len(series_val) + 1) * series_train.freq, - step=series_train.freq, - ), - columns=series_train.columns, + series = TimeSeries.from_values( + values=series.all_values(), + columns=series.columns, ) # check that too short input raises error - series_val_too_short = series_val[:-n_forecasts] + series_too_short = series[:-n_forecasts] # optionally, generate covariates if use_covs: pc = tg.gaussian_timeseries( - start=series_train.start_time(), - end=series_val.end_time() + max(0, horizon - ocl) * series_train.freq, - freq=series_train.freq, + start=series.start_time(), + end=series.end_time() + max(0, horizon - ocl) * series.freq, + freq=series.freq, ) fc = tg.gaussian_timeseries( - start=series_train.start_time(), - end=series_val.end_time() - + (max(ocl, horizon) + ocs) * series_train.freq, - freq=series_train.freq, + start=series.start_time(), + end=series.end_time() + (max(ocl, horizon) + ocs) * series.freq, + freq=series.freq, ) else: pc, fc = None, None @@ -3378,15 +3365,13 @@ def test_conformal_historical_forecasts(self, config): forecasting_model = LinearRegressionModel( lags=icl, output_chunk_length=ocl, output_chunk_shift=ocs, **model_kwargs ) - forecasting_model.fit(series_train, past_covariates=pc, future_covariates=fc) + forecasting_model.fit(series, past_covariates=pc, future_covariates=fc) # add an offset and rename columns in second series to make sure that conformal hist fc works as expected if use_multi_series: - series_val = [ - series_val, - (series_val + 10) - .shift(1) - .with_columns_renamed(series_val.columns, "test_col"), + series = [ + series, + (series + 10).shift(1).with_columns_renamed(series.columns, "test_col"), ] pc = [pc, pc.shift(1)] if pc is not None else None fc = [fc, fc.shift(1)] if fc is not None else None @@ -3394,65 +3379,57 @@ def test_conformal_historical_forecasts(self, config): # conformal model model = ConformalNaiveModel(forecasting_model, quantiles=q) + hfc_kwargs = dict( + { + "retrain": False, + "last_points_only": last_points_only, + "overlap_end": overlap_end, + "stride": stride, + "forecast_horizon": horizon, + }, + **pred_lklp, + ) # cannot perform auto regression with output chunk shift if ocs and horizon > ocl: with pytest.raises(ValueError) as exc: _ = model.historical_forecasts( - series=series_val_too_short, + series=series, past_covariates=pc, future_covariates=fc, - retrain=False, - last_points_only=last_points_only, - overlap_end=overlap_end, - stride=stride, - forecast_horizon=horizon, - **pred_lklp, + **hfc_kwargs, ) assert str(exc.value).startswith("Cannot perform auto-regression") return # compute conformal historical forecasts hist_fct = model.historical_forecasts( - series=series_val, - past_covariates=pc, - future_covariates=fc, - retrain=False, - last_points_only=last_points_only, - overlap_end=overlap_end, - stride=stride, - forecast_horizon=horizon, - **pred_lklp, + series=series, past_covariates=pc, future_covariates=fc, **hfc_kwargs ) # raises error with too short target series with pytest.raises(ValueError) as exc: _ = model.historical_forecasts( - series=series_val_too_short, + series=series_too_short, past_covariates=pc, future_covariates=fc, - retrain=False, - last_points_only=last_points_only, - overlap_end=overlap_end, - stride=stride, - forecast_horizon=horizon, - **pred_lklp, + **hfc_kwargs, ) assert str(exc.value).startswith( "Could not build the minimum required calibration input with the provided `series`" ) - if not isinstance(series_val, list): - series_val = [series_val] + if not isinstance(series, list): + series = [series] hist_fct = [hist_fct] for ( - series, + series_, hfc, - ) in zip(series_val, hist_fct): + ) in zip(series, hist_fct): if not isinstance(hfc, list): hfc = [hfc] n_preds_with_overlap = ( - len(series) + len(series_) - icl # input for first prediction - horizon_ocs # skip first forecasts to avoid look-ahead bias + 1 # minimum one forecast @@ -3462,27 +3439,29 @@ def test_conformal_historical_forecasts(self, config): # where each forecast contains the predictions over the entire horizon n_pred_series_expected = n_preds_with_overlap n_pred_points_expected = horizon - first_ts_expected = series.time_index[icl] + series.freq * ( + first_ts_expected = series_.time_index[icl] + series_.freq * ( horizon_ocs + ocs ) - last_ts_expected = series.end_time() + series.freq * horizon_ocs + last_ts_expected = series_.end_time() + series_.freq * horizon_ocs # no overlapping means less predictions if not overlap_end: n_pred_series_expected -= horizon_ocs - last_ts_expected -= series.freq * horizon_ocs else: # last points only = True gives one contiguous time series per input series # with only predictions from the last point in the horizon n_pred_series_expected = 1 n_pred_points_expected = n_preds_with_overlap - first_ts_expected = series.time_index[icl] + series.freq * ( + first_ts_expected = series_.time_index[icl] + series_.freq * ( horizon_ocs + ocs + horizon - 1 ) - last_ts_expected = series.end_time() + series.freq * horizon_ocs + last_ts_expected = series_.end_time() + series_.freq * horizon_ocs # no overlapping means less predictions if not overlap_end: n_pred_points_expected -= horizon_ocs - last_ts_expected -= series.freq * horizon_ocs + + # no overlapping means less predictions + if not overlap_end: + last_ts_expected -= series_.freq * horizon_ocs # adapt based on stride if stride > 1: @@ -3498,7 +3477,7 @@ def test_conformal_historical_forecasts(self, config): last_ts_expected = hfc[-1].end_time() cols_excpected = likelihood_component_names( - series.columns, quantile_names(q) + series_.columns, quantile_names(q) ) # check length match between optimized and default hist fc assert len(hfc) == n_pred_series_expected @@ -3546,24 +3525,12 @@ def test_conformal_historical_start_cal_length(self, config): min_len_val_series = icl + 2 * horizon_ocs + add_cal_length + add_start n_forecasts = 3 # get train and val series of that length - series_train, series_val = ( - self.ts_pass_train[:10], - self.ts_pass_val[: min_len_val_series + n_forecasts - 1], - ) + series = self.ts_pass_val[: min_len_val_series + n_forecasts - 1] if use_int_idx: - series_train = TimeSeries.from_values( - series_train.all_values(), columns=series_train.columns - ) - series_val = TimeSeries.from_times_and_values( - values=series_val.all_values(), - times=pd.RangeIndex( - start=series_train.end_time() + series_train.freq, - stop=series_train.end_time() - + (len(series_val) + 1) * series_train.freq, - step=series_train.freq, - ), - columns=series_train.columns, + series = TimeSeries.from_values( + values=series.all_values(), + columns=series.columns, ) # first train the ForecastingModel @@ -3572,24 +3539,22 @@ def test_conformal_historical_start_cal_length(self, config): output_chunk_length=ocl, output_chunk_shift=ocs, ) - forecasting_model.fit(series_train) + forecasting_model.fit(series) # optionally compute the start as a positional index start_position = icl + horizon_ocs + add_cal_length + add_start start = None if use_start: if start_format == "value": - start = series_val.time_index[start_position] + start = series.time_index[start_position] else: start = start_position # add an offset and rename columns in second series to make sure that conformal hist fc works as expected if use_multi_series: - series_val = [ - series_val, - (series_val + 10) - .shift(1) - .with_columns_renamed(series_val.columns, "test_col"), + series = [ + series, + (series + 10).shift(1).with_columns_renamed(series.columns, "test_col"), ] # compute conformal historical forecasts (skips some of the first forecasts to get minimum required cal set) @@ -3597,23 +3562,24 @@ def test_conformal_historical_start_cal_length(self, config): forecasting_model, quantiles=q, cal_length=cal_length ) hist_fct = model.historical_forecasts( - series=series_val, + series=series, retrain=False, start=start, start_format=start_format, last_points_only=last_points_only, forecast_horizon=horizon, + overlap_end=False, **pred_lklp, ) - if not isinstance(series_val, list): - series_val = [series_val] + if not isinstance(series, list): + series = [series] hist_fct = [hist_fct] for idx, ( - series, + series_, hfc, - ) in enumerate(zip(series_val, hist_fct)): + ) in enumerate(zip(series, hist_fct)): if not isinstance(hfc, list): hfc = [hfc] @@ -3622,7 +3588,7 @@ def test_conformal_historical_start_cal_length(self, config): add_start_series_2 = idx * int(use_start) * int(start_format == "value") n_preds_without_overlap = ( - len(series) + len(series_) - icl # input for first prediction - horizon_ocs # skip first forecasts to avoid look-ahead bias - horizon_ocs # cannot compute with `overlap_end=False` @@ -3635,22 +3601,22 @@ def test_conformal_historical_start_cal_length(self, config): n_pred_series_expected = n_preds_without_overlap n_pred_points_expected = horizon # seconds series is shifted by one time step (- idx) - first_ts_expected = series.time_index[ + first_ts_expected = series_.time_index[ start_position - add_start_series_2 + ocs ] - last_ts_expected = series.end_time() + last_ts_expected = series_.end_time() else: n_pred_series_expected = 1 n_pred_points_expected = n_preds_without_overlap # seconds series is shifted by one time step (- idx) first_ts_expected = ( - series.time_index[start_position - add_start_series_2] - + (horizon_ocs - 1) * series.freq + series_.time_index[start_position - add_start_series_2] + + (horizon_ocs - 1) * series_.freq ) - last_ts_expected = series.end_time() + last_ts_expected = series_.end_time() cols_excpected = likelihood_component_names( - series.columns, quantile_names(q) + series_.columns, quantile_names(q) ) # check historical forecasts dimensions assert len(hfc) == n_pred_series_expected diff --git a/darts/utils/utils.py b/darts/utils/utils.py index 450f7e00e9..1ce2955a6a 100644 --- a/darts/utils/utils.py +++ b/darts/utils/utils.py @@ -283,10 +283,7 @@ def _is_method(func: Callable[..., Any]) -> bool: true if `func` is a method, false otherwise. """ spec = signature(func) - if len(spec.parameters) > 0: - if list(spec.parameters.keys())[0] == "self": - return True - return False + return len(spec.parameters) > 0 and list(spec.parameters.keys())[0] == "self" def _check_quantiles(quantiles): From f28c2e18ad07790e221f169cab31468fff44da95 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Tue, 10 Dec 2024 11:40:32 +0100 Subject: [PATCH 70/78] update docs --- darts/models/forecasting/conformal_models.py | 130 ++++++++++-------- .../forecasting/test_conformal_model.py | 4 +- 2 files changed, 74 insertions(+), 60 deletions(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index c5b5815b16..dd37454ddf 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -64,13 +64,13 @@ def __init__( symmetric: bool = True, cal_length: Optional[int] = None, cal_stride: int = 1, - num_samples: int = 500, + cal_num_samples: int = 500, random_state: Optional[int] = None, ): """Base Conformal Prediction Model. - Base class for any probabilistic conformal model. A conformal model calibrates the predictions from any - pre-trained global forecasting model. It does not have to be trained, and can generated calibrated forecasts + Base class for any conformal prediction model. A conformal model calibrates the predictions from any + pre-trained global forecasting model. It does not have to be trained, and can generate calibrated forecasts directly using the underlying trained forecasting model. Since it is a probabilistic model, you can generate forecasts in two ways (when calling `predict()`, `historical_forecasts()`, ...): @@ -83,11 +83,11 @@ def __init__( fitted before. In general the workflow of the models to produce one calibrated forecast/prediction is as follows: - - Extract a calibration set: The number of calibration examples (forecast errors) from the most recent past to - use for one conformal prediction can be defined at model creation with parameter `cal_length`. Requires a - minimum of `cal_stride * (cal_length or 1)` calibration examples before the (first) conformal forecast. - To make your life simpler, it applies automatic extraction of the calibration set from the past of your input - series (`series`, `past_covariates`, ...). + - Extract a calibration set: The calibration set for each conformal forecast is automatically extracted from + the past of your input series relative to the forecast start point. The number of calibration examples + (forecast errors / non-conformity scores) to use for per conformal forecast can be defined at model creation + with parameter `cal_length`. Note that when using `cal_stride>1`, a longer history is required since + the calibration examples are generated with stridden historical forecasts. - Generate historical forecasts on the calibration set (using the forecasting model) with a stride `cal_stride`. - Compute the errors/non-conformity scores (specific to each conformal model) on these historical forecasts - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model @@ -104,7 +104,8 @@ def __init__( Parameters ---------- model - A pre-trained global forecasting model. + A pre-trained global forecasting model. See the list of models + `here `_. quantiles A list of quantiles centered around the median `q=0.5` to use. For example quantiles [0.1, 0.2, 0.5, 0.8 0.9] correspond to two intervals with (0.9 - 0.1) = 80%, and (0.8 - 0.2) 60% coverage @@ -113,14 +114,17 @@ def __init__( Whether to use symmetric non-conformity scores. If `False`, uses asymmetric scores (individual scores for lower- and upper quantile interval bounds). cal_length - The number of past forecast residuals/errors to consider as calibration input for each conformal forecast. - If `None`, considers all past residuals. + The number of past forecast errors / non-conformity scores to use as calibration for each conformal + forecast (and each step in the horizon). If `None`, considers all scores. cal_stride - Whether to apply the same historical forecast `stride` to the non-conformity scores of the calibration set. - num_samples - Number of times a prediction is sampled from the underlying `model` if it is probabilistic. Uses `1` for - deterministic models. This is different to the `num_samples` produced by the conformal model which can be - set in downstream forecasting tasks. + The stride to apply when computing the historical forecasts and non-conformity scores on the calibration + set. The actual conformal forecasts can have a different stride given with parameter `stride` in downstream + tasks (e.g. historical forecasts, backtest, ...) + cal_num_samples + The number of samples to generate for each calibration forecast (if `model` is a probabilistic forecasting + model). The non-conformity scores are computed on the quantile values of these forecasts (using quantiles + `quantiles`). Uses `1` for deterministic models. The actual conformal forecasts can have a different number + of samples given with parameter `num_samples` in downstream tasks (e.g. predict, historical forecasts, ...). random_state Control the randomness of probabilistic conformal forecasts (sample generation) across different runs. """ @@ -135,10 +139,10 @@ def __init__( raise_log( ValueError("`cal_length` must be `>=1` or `None`."), logger=logger ) - if cal_stride is not None and cal_stride < 1: + if cal_stride < 1: raise_log(ValueError("`cal_stride` must be `>=1`."), logger=logger) - if num_samples is not None and num_samples < 1: - raise_log(ValueError("`num_samples` must be `>=1`."), logger=logger) + if cal_num_samples < 1: + raise_log(ValueError("`cal_num_samples` must be `>=1`."), logger=logger) super().__init__(add_encoders=None) @@ -167,7 +171,9 @@ def __init__( self.model = model self.cal_length = cal_length self.cal_stride = cal_stride - self.num_samples = num_samples if model.supports_probabilistic_prediction else 1 + self.cal_num_samples = ( + cal_num_samples if model.supports_probabilistic_prediction else 1 + ) self._likelihood = "quantile" self._fit_called = True @@ -247,11 +253,11 @@ def predict( Under the hood, the simplified workflow to produce one calibrated forecast/prediction for every step in the horizon `n` is as follows (note: `cal_length` and `cal_stride` can be set at model creation): - - Extract a calibration set: The number of calibration examples (forecast errors) from the most recent past to - use for one conformal prediction can be defined at model creation with parameter `cal_length`. Requires a - minimum of `cal_stride * (cal_length or 1)` calibration examples before the (first) conformal forecast. - To make your life simpler, it applies automatic extraction of the calibration set from the past of your input - series (`series`, `past_covariates`, ...). + - Extract a calibration set: The calibration set for each conformal forecast is automatically extracted from + the past of your input series relative to the forecast start point. The number of calibration examples + (forecast errors / non-conformity scores) to use for per conformal forecast can be defined at model creation + with parameter `cal_length`. Note that when using `cal_stride>1`, a longer history is required since + the calibration examples are generated with stridden historical forecasts. - Generate historical forecasts on the calibration set (using the forecasting model) with a stride `cal_stride`. - Compute the errors/non-conformity scores (specific to each conformal model) on these historical forecasts - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model @@ -335,7 +341,7 @@ def predict( series=series, past_covariates=past_covariates, future_covariates=future_covariates, - num_samples=self.num_samples, + num_samples=self.cal_num_samples, verbose=verbose, predict_likelihood_parameters=False, show_warnings=show_warnings, @@ -358,7 +364,7 @@ def predict( past_covariates=past_covariates, future_covariates=future_covariates, forecast_horizon=n, - num_samples=self.num_samples, + num_samples=self.cal_num_samples, start=cal_start, start_format=cal_start_format, stride=self.cal_stride, @@ -563,7 +569,7 @@ def historical_forecasts( past_covariates=past_covariates, future_covariates=future_covariates, forecast_horizon=forecast_horizon, - num_samples=self.num_samples, + num_samples=self.cal_num_samples, start=cal_start, start_format=cal_start_format, stride=self.cal_stride, @@ -1492,7 +1498,7 @@ def __init__( symmetric: bool = True, cal_length: Optional[int] = None, cal_stride: int = 1, - num_samples: int = 500, + cal_num_samples: int = 500, random_state: Optional[int] = None, ): """Naive Conformal Prediction Model. @@ -1522,11 +1528,11 @@ def __init__( fitted before. In general the workflow of the models to produce one calibrated forecast/prediction is as follows: - - Extract a calibration set: The number of calibration examples (forecast errors) from the most recent past to - use for one conformal prediction can be defined at model creation with parameter `cal_length`. Requires a - minimum of `cal_stride * (cal_length or 1)` calibration examples before the (first) conformal forecast. - To make your life simpler, it applies automatic extraction of the calibration set from the past of your input - series (`series`, `past_covariates`, ...). + - Extract a calibration set: The calibration set for each conformal forecast is automatically extracted from + the past of your input series relative to the forecast start point. The number of calibration examples + (forecast errors / non-conformity scores) to use for per conformal forecast can be defined at model creation + with parameter `cal_length`. Note that when using `cal_stride>1`, a longer history is required since + the calibration examples are generated with stridden historical forecasts. - Generate historical forecasts on the calibration set (using the forecasting model) with a stride `cal_stride`. - Compute the errors/non-conformity scores (as defined above) on these historical forecasts - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model @@ -1542,7 +1548,8 @@ def __init__( Parameters ---------- model - A pre-trained global forecasting model. + A pre-trained global forecasting model. See the list of models + `here `_. quantiles A list of quantiles centered around the median `q=0.5` to use. For example quantiles [0.1, 0.2, 0.5, 0.8 0.9] correspond to two intervals with (0.9 - 0.1) = 80%, and (0.8 - 0.2) 60% coverage @@ -1552,14 +1559,17 @@ def __init__( :func:`~darts.metrics.metrics.ae`) to compute the non-conformity scores. If `False`, uses metric `-err()` (see :func:`~darts.metrics.metrics.err`) for the lower, and `err()` for the upper quantile interval bound. cal_length - The number of past forecast residuals/errors to consider as calibration input for each conformal forecast. - If `None`, considers all past residuals. + The number of past forecast errors / non-conformity scores to use as calibration for each conformal + forecast (and each step in the horizon). If `None`, considers all scores. cal_stride - Whether to apply the same historical forecast `stride` to the non-conformity scores of the calibration set. - num_samples - Number of times a prediction is sampled from the underlying `model` if it is probabilistic. Uses `1` for - deterministic models. This is different to the `num_samples` produced by the conformal model which can be - set in downstream forecasting tasks. + The stride to apply when computing the historical forecasts and non-conformity scores on the calibration + set. The actual conformal forecasts can have a different stride given with parameter `stride` in downstream + tasks (e.g. historical forecasts, backtest, ...) + cal_num_samples + The number of samples to generate for each calibration forecast (if `model` is a probabilistic forecasting + model). The non-conformity scores are computed on the quantile values of these forecasts (using quantiles + `quantiles`). Uses `1` for deterministic models. The actual conformal forecasts can have a different number + of samples given with parameter `num_samples` in downstream tasks (e.g. predict, historical forecasts, ...). random_state Control the randomness of probabilistic conformal forecasts (sample generation) across different runs. """ @@ -1568,7 +1578,7 @@ def __init__( quantiles=quantiles, symmetric=symmetric, cal_length=cal_length, - num_samples=num_samples, + cal_num_samples=cal_num_samples, random_state=random_state, cal_stride=cal_stride, ) @@ -1620,7 +1630,7 @@ def __init__( symmetric: bool = True, cal_length: Optional[int] = None, cal_stride: int = 1, - num_samples: int = 500, + cal_num_samples: int = 500, random_state: Optional[int] = None, ): """Conformalized Quantile Regression Model. @@ -1652,11 +1662,11 @@ def __init__( fitted before. In general the workflow of the models to produce one calibrated forecast/prediction is as follows: - - Extract a calibration set: The number of calibration examples (forecast errors) from the most recent past to - use for one conformal prediction can be defined at model creation with parameter `cal_length`. Requires a - minimum of `cal_stride * (cal_length or 1)` calibration examples before the (first) conformal forecast. - To make your life simpler, it applies automatic extraction of the calibration set from the past of your input - series (`series`, `past_covariates`, ...). + - Extract a calibration set: The calibration set for each conformal forecast is automatically extracted from + the past of your input series relative to the forecast start point. The number of calibration examples + (forecast errors / non-conformity scores) to use for per conformal forecast can be defined at model creation + with parameter `cal_length`. Note that when using `cal_stride>1`, a longer history is required since + the calibration examples are generated with stridden historical forecasts. - Generate historical forecasts (quantile predictions) on the calibration set (using the forecasting model) with a stride `cal_stride`. - Compute the errors/non-conformity scores (as defined above) on these historical quantile predictions @@ -1673,7 +1683,8 @@ def __init__( Parameters ---------- model - A pre-trained probabilistic global forecasting model using a `likelihood`. + A pre-trained global forecasting model. See the list of models + `here `_. quantiles A list of quantiles centered around the median `q=0.5` to use. For example quantiles [0.1, 0.2, 0.5, 0.8 0.9] correspond to two intervals with (0.9 - 0.1) = 80%, and (0.8 - 0.2) 60% coverage @@ -1684,14 +1695,17 @@ def __init__( scores. If `False`, uses asymmetric metric `incs_qr(..., symmetric=False)` with individual scores for the lower- and upper quantile interval bounds. cal_length - The number of past forecast residuals/errors to consider as calibration input for each conformal forecast. - If `None`, considers all past residuals. + The number of past forecast errors / non-conformity scores to use as calibration for each conformal + forecast (and each step in the horizon). If `None`, considers all scores. cal_stride - Whether to apply the same historical forecast `stride` to the non-conformity scores of the calibration set. - num_samples - Number of times a prediction is sampled from the underlying `model` if it is probabilistic. Uses `1` for - deterministic models. This is different to the `num_samples` produced by the conformal model which can be - set in downstream forecasting tasks. + The stride to apply when computing the historical forecasts and non-conformity scores on the calibration + set. The actual conformal forecasts can have a different stride given with parameter `stride` in downstream + tasks (e.g. historical forecasts, backtest, ...) + cal_num_samples + The number of samples to generate for each calibration forecast (if `model` is a probabilistic forecasting + model). The non-conformity scores are computed on the quantile values of these forecasts (using quantiles + `quantiles`). Uses `1` for deterministic models. The actual conformal forecasts can have a different number + of samples given with parameter `num_samples` in downstream tasks (e.g. predict, historical forecasts, ...). random_state Control the randomness of probabilistic conformal forecasts (sample generation) across different runs. """ @@ -1708,7 +1722,7 @@ def __init__( quantiles=quantiles, symmetric=symmetric, cal_length=cal_length, - num_samples=num_samples, + cal_num_samples=cal_num_samples, random_state=random_state, cal_stride=cal_stride, ) diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 64424df55e..9b24dcf0f5 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -186,8 +186,8 @@ def test_model_construction_naive(self): # `num_samples` must be `>=1` with pytest.raises(ValueError) as exc: - ConformalNaiveModel(model=global_model, quantiles=q, num_samples=0) - assert str(exc.value) == "`num_samples` must be `>=1`." + ConformalNaiveModel(model=global_model, quantiles=q, cal_num_samples=0) + assert str(exc.value) == "`cal_num_samples` must be `>=1`." def test_model_hfc_stride_checks(self): series = self.ts_pass_train From 2e125956aafa1dcc508f90b9c67194a6884e5b49 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sat, 14 Dec 2024 22:48:22 +0100 Subject: [PATCH 71/78] cleanup --- darts/metrics/metrics.py | 8 +- darts/models/__init__.py | 15 ++-- darts/models/forecasting/conformal_models.py | 84 ++++++++++--------- .../forecasting/test_conformal_model.py | 60 +++++++++---- .../test_historical_forecasts.py | 3 +- .../utils/historical_forecasts/test_utils.py | 2 + 6 files changed, 101 insertions(+), 71 deletions(-) diff --git a/darts/metrics/metrics.py b/darts/metrics/metrics.py index 6a14f0bfb8..911c3f4f7e 100644 --- a/darts/metrics/metrics.py +++ b/darts/metrics/metrics.py @@ -3326,9 +3326,9 @@ def iw( n_jobs: int = 1, verbose: bool = False, ) -> METRIC_OUTPUT_TYPE: - """Interval Width (IL). + """Interval Width (IW). - IL gives the length / width of predicted quantile intervals. + IL gives the width / length of predicted quantile intervals. For the true series :math:`y` and predicted stochastic or quantile series :math:`\\hat{y}` of length :math:`T`, it is computed per component/column, quantile interval :math:`(q_l,q_h)`, and time step @@ -3427,9 +3427,9 @@ def miw( n_jobs: int = 1, verbose: bool = False, ) -> METRIC_OUTPUT_TYPE: - """Mean Interval Width (MIL). + """Mean Interval Width (MIW). - MIL gives the time-aggregated length / width of predicted quantile intervals. + MIW gives the time-aggregated width / length of predicted quantile intervals. For the true series :math:`y` and predicted stochastic or quantile series :math:`\\hat{y}` of length :math:`T`, it is computed per component/column, quantile interval :math:`(q_l,q_h)`, and time step diff --git a/darts/models/__init__.py b/darts/models/__init__.py index f4218c4ea8..1ea802be3a 100644 --- a/darts/models/__init__.py +++ b/darts/models/__init__.py @@ -20,10 +20,16 @@ from darts.models.forecasting.auto_arima import AutoARIMA from darts.models.forecasting.baselines import ( NaiveDrift, + NaiveEnsembleModel, NaiveMean, NaiveMovingAverage, NaiveSeasonal, ) +from darts.models.forecasting.conformal_models import ( + ConformalNaiveModel, + ConformalQRModel, +) +from darts.models.forecasting.ensemble_model import EnsembleModel from darts.models.forecasting.exponential_smoothing import ExponentialSmoothing from darts.models.forecasting.fft import FFT from darts.models.forecasting.kalman_forecaster import KalmanForecaster @@ -108,20 +114,11 @@ except ImportError: XGBModel = NotImportedModule(module_name="XGBoost") -# Conformal Prediction # Filtering from darts.models.filtering.gaussian_process_filter import GaussianProcessFilter from darts.models.filtering.kalman_filter import KalmanFilter from darts.models.filtering.moving_average_filter import MovingAverageFilter -# Ensembling -from darts.models.forecasting.baselines import NaiveEnsembleModel -from darts.models.forecasting.conformal_models import ( - ConformalNaiveModel, - ConformalQRModel, -) -from darts.models.forecasting.ensemble_model import EnsembleModel - __all__ = [ "LightGBMModel", "ARIMA", diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index dd37454ddf..ab13cc5b59 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -85,21 +85,21 @@ def __init__( - Extract a calibration set: The calibration set for each conformal forecast is automatically extracted from the past of your input series relative to the forecast start point. The number of calibration examples - (forecast errors / non-conformity scores) to use for per conformal forecast can be defined at model creation + (forecast errors / non-conformity scores) to consider can be defined at model creation with parameter `cal_length`. Note that when using `cal_stride>1`, a longer history is required since the calibration examples are generated with stridden historical forecasts. - Generate historical forecasts on the calibration set (using the forecasting model) with a stride `cal_stride`. - Compute the errors/non-conformity scores (specific to each conformal model) on these historical forecasts - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model creation with parameter `quantiles`). - - Compute the conformal prediction: Add the calibrated intervals to (or adjust the existing intervals of) the - forecasting model's predictions. + - Compute the conformal prediction: Using these quantile values, add calibrated intervals to (or adjust the + existing intervals of) the forecasting model's predictions. Some notes: - - When computing historical_forecasts(), backtest(), residuals(), ... the above is applied for each forecast - (the forecasting model's historical forecasts are only generated once for efficiency). - - For multi-horizon forecasts, the above is applied for each step in the horizon separately + - When computing `historical_forecasts()`, `backtest()`, `residuals()`, ... the above is applied for each + forecast (the forecasting model's historical forecasts are only generated once for efficiency). + - For multi-horizon forecasts, the above is applied for each step in the horizon separately. Parameters ---------- @@ -211,6 +211,8 @@ def fit( be used by some models as an input. The covariate(s) may or may not be multivariate, but if multiple covariates are provided they must have the same number of components. If `future_covariates` is provided, it must contain the same number of series as `series`. + **kwargs + Optional keyword arguments that will passed to the underlying forecasting model's `fit()` method. Returns ------- @@ -236,6 +238,7 @@ def predict( verbose: bool = False, predict_likelihood_parameters: bool = False, show_warnings: bool = True, + **kwargs, ) -> Union[TimeSeries, Sequence[TimeSeries]]: """Forecasts calibrated quantile intervals (or samples from calibrated intervals) for `n` time steps after the end of the `series`. @@ -255,15 +258,15 @@ def predict( - Extract a calibration set: The calibration set for each conformal forecast is automatically extracted from the past of your input series relative to the forecast start point. The number of calibration examples - (forecast errors / non-conformity scores) to use for per conformal forecast can be defined at model creation + (forecast errors / non-conformity scores) to consider can be defined at model creation with parameter `cal_length`. Note that when using `cal_stride>1`, a longer history is required since the calibration examples are generated with stridden historical forecasts. - Generate historical forecasts on the calibration set (using the forecasting model) with a stride `cal_stride`. - Compute the errors/non-conformity scores (specific to each conformal model) on these historical forecasts - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model creation with parameter `quantiles`). - - Compute the conformal prediction: Add the calibrated intervals to (or adjust the existing intervals of) the - forecasting model's predictions. + - Compute the conformal prediction: Using these quantile values, add calibrated intervals to (or adjust the + existing intervals of) the forecasting model's predictions. Parameters ---------- @@ -290,6 +293,9 @@ def predict( If set to `True`, generates the quantile predictions directly. Only supported with `num_samples = 1`. show_warnings Whether to show warnings related auto-regression and past covariates usage. + **kwargs + Optional keyword arguments that will passed to the underlying forecasting model's `predict()` and + `historical_forecasts()` methods. Returns ------- @@ -345,6 +351,7 @@ def predict( verbose=verbose, predict_likelihood_parameters=False, show_warnings=show_warnings, + **kwargs, ) # generate only the required forecasts for calibration (including the last forecast which is the output of @@ -374,6 +381,7 @@ def predict( verbose=verbose, show_warnings=False, predict_likelihood_parameters=False, + predict_kwargs=kwargs, ) cal_preds = self._calibrate_forecasts( series=series, @@ -434,15 +442,16 @@ def historical_forecasts( forecasting model (see :meth:`ForecastingModel.historical_forecasts() ` for more info). Then it repeatedly builds a calibration set by either expanding from the beginning of the historical forecasts or by - using a fixed-length `cal_length` (the start point can also be configured with `start` and `start_format`). + using a fixed-length moving window with length `cal_length` (the start point can also be configured with + `start` and `start_format`). The next forecast of length `forecast_horizon` is then calibrated on this calibration set. Subsequently, the end of the calibration set is moved forward by `stride` time steps, and the process is repeated. By default, with `last_points_only=True`, this method returns a single time series (or a sequence of time - series) composed of the last point from each calibrated historical forecast. This time series will thus have a - frequency of `series.freq * stride`. - If `last_points_only=False`, it will instead return a list (or a sequence of lists) of the full calibrate - historical forecast series each with frequency `series.freq`. + series when `series` is also a sequence of series) composed of the last point from each calibrated historical + forecast. This time series will thus have a frequency of `series.freq * stride`. + If `last_points_only=False`, it will instead return a list (or a sequence of lists) with all calibrated + historical forecasts of length `forecast_horizon` and frequency `series.freq`. Parameters ---------- @@ -1047,16 +1056,16 @@ def _calibrate_forecasts( In general the workflow of the models to produce one calibrated forecast/prediction per step in the horizon is as follows: - - Generate historical forecasts for `series` (using the forecasting model) - - Extract a calibration set: The forecasts from the most recent past to use as calibration - for one conformal prediction. The number of examples to use can be defined at model creation with parameter - `cal_length`. It automatically extracts the calibration set from the past of your input series (`series`, - `past_covariates`, ...). + - Generate historical forecasts for `series` with stride `cal_stride` (using the forecasting model) + - Extract a calibration set: The forecasts from the most recent past to use as calibration for one conformal + prediction. The number of examples to use can be defined at model creation with parameter `cal_length`. It + automatically extracts the calibration set from the past of your input series (`series`, `past_covariates`, + ...). - Compute the errors/non-conformity scores (specific to each conformal model) on these historical forecasts - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model creation with parameter `quantiles`). - - Compute the conformal prediction: Add the calibrated intervals to (or adjust the existing intervals of) the - forecasting model's predictions. + - Compute the conformal prediction: Using these quantile values, add calibrated intervals to (or adjust the + existing intervals of) the forecasting model's predictions. """ cal_stride = self.cal_stride cal_length = self.cal_length @@ -1290,7 +1299,7 @@ def conformal_predict(idx_, pred_vals_): freq=series_.freq * stride, name=series_._time_index.name, ), - with_static_covs=False, + with_static_covs=not predict_likelihood_parameters, with_hierarchy=False, ) else: @@ -1302,7 +1311,7 @@ def conformal_predict(idx_, pred_vals_): input_series=series_, custom_columns=comp_names_out, time_index=pred._time_index, - with_static_covs=False, + with_static_covs=not predict_likelihood_parameters, with_hierarchy=False, ) cp_preds.append(cp_pred) @@ -1378,7 +1387,6 @@ def _calibrate_interval( residuals The residuals are expected to have shape (horizon, n components, n historical forecasts * n samples) """ - pass @abstractmethod def _apply_interval(self, pred: np.ndarray, q_hat: tuple[np.ndarray, np.ndarray]): @@ -1387,14 +1395,12 @@ def _apply_interval(self, pred: np.ndarray, q_hat: tuple[np.ndarray, np.ndarray] E.g. output is `(target1_q1, target1_pred, target1_q2, target2_q1, ...)` """ - pass @property @abstractmethod def _residuals_metric(self) -> tuple[METRIC_TYPE, Optional[dict]]: """Gives the "per time step" metric and optional metric kwargs used to compute residuals / non-conformity scores.""" - pass def _cp_component_names(self, input_series) -> list[str]: """Gives the component names for generated forecasts.""" @@ -1530,20 +1536,21 @@ def __init__( - Extract a calibration set: The calibration set for each conformal forecast is automatically extracted from the past of your input series relative to the forecast start point. The number of calibration examples - (forecast errors / non-conformity scores) to use for per conformal forecast can be defined at model creation + (forecast errors / non-conformity scores) to consider can be defined at model creation with parameter `cal_length`. Note that when using `cal_stride>1`, a longer history is required since the calibration examples are generated with stridden historical forecasts. - Generate historical forecasts on the calibration set (using the forecasting model) with a stride `cal_stride`. - Compute the errors/non-conformity scores (as defined above) on these historical forecasts - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model creation with parameter `quantiles`). - - Compute the conformal prediction: Add the calibrated intervals to the forecasting model's predictions. + - Compute the conformal prediction: Using these quantile values, add calibrated intervals to the forecasting + model's predictions. Some notes: - - When computing historical_forecasts(), backtest(), residuals(), ... the above is applied for each forecast - (the forecasting model's historical forecasts are only generated once for efficiency). - - For multi-horizon forecasts, the above is applied for each step in the horizon separately + - When computing `historical_forecasts()`, `backtest()`, `residuals()`, ... the above is applied for each + forecast (the forecasting model's historical forecasts are only generated once for efficiency). + - For multi-horizon forecasts, the above is applied for each step in the horizon separately. Parameters ---------- @@ -1664,7 +1671,7 @@ def __init__( - Extract a calibration set: The calibration set for each conformal forecast is automatically extracted from the past of your input series relative to the forecast start point. The number of calibration examples - (forecast errors / non-conformity scores) to use for per conformal forecast can be defined at model creation + (forecast errors / non-conformity scores) to consider can be defined at model creation with parameter `cal_length`. Note that when using `cal_stride>1`, a longer history is required since the calibration examples are generated with stridden historical forecasts. - Generate historical forecasts (quantile predictions) on the calibration set (using the forecasting model) @@ -1672,13 +1679,14 @@ def __init__( - Compute the errors/non-conformity scores (as defined above) on these historical quantile predictions - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model creation with parameter `quantiles`). - - Compute the conformal prediction: Calibrate the predicted quantiles from the forecasting model's predictions. + - Compute the conformal prediction: Using these quantile values, calibrate the predicted quantiles from the + forecasting model's predictions. Some notes: - - When computing historical_forecasts(), backtest(), residuals(), ... the above is applied for each forecast - (the forecasting model's historical forecasts are only generated once for efficiency). - - For multi-horizon forecasts, the above is applied for each step in the horizon separately + - When computing `historical_forecasts()`, `backtest()`, `residuals()`, ... the above is applied for each + forecast (the forecasting model's historical forecasts are only generated once for efficiency). + - For multi-horizon forecasts, the above is applied for each step in the horizon separately. Parameters ---------- @@ -1712,7 +1720,7 @@ def __init__( if not model.supports_probabilistic_prediction: raise_log( ValueError( - "`model` must must support probabilistic forecasting. Consider using a `likelihood` at " + "`model` must support probabilistic forecasting. Consider using a `likelihood` at " "forecasting model creation, or use another conformal model." ), logger=logger, @@ -1755,7 +1763,7 @@ def q_hat_from_residuals(residuals_): return -q_hat, q_hat[:, :, ::-1] else: # asymmetric has two nc-score per interval (for lower and upper quantiles, from metric - # `incs_qe(symmetric=False)`) + # `incs_qr(symmetric=False)`) # lower and upper residuals are concatenated along axis=1; # residuals shape (horizon, n components * n intervals * 2, n past forecasts) half_idx = residuals.shape[1] // 2 diff --git a/darts/tests/models/forecasting/test_conformal_model.py b/darts/tests/models/forecasting/test_conformal_model.py index 9b24dcf0f5..2797d35231 100644 --- a/darts/tests/models/forecasting/test_conformal_model.py +++ b/darts/tests/models/forecasting/test_conformal_model.py @@ -86,7 +86,7 @@ class TestConformalModel: Tests all general model behavior for Naive Conformal Model with symmetric non-conformity score. Additionally, checks correctness of predictions for: - ConformalNaiveModel with symmetric & asymmetric non-conformity scores - - ConformaQRlModel with symmetric & asymmetric non-conformity scores + - ConformalQRModel with symmetric & asymmetric non-conformity scores """ np.random.seed(42) @@ -155,7 +155,8 @@ def test_model_construction_naive(self): # pre-trained local model should work global_model.fit(series) - _ = ConformalNaiveModel(model=global_model, quantiles=q) + model = ConformalNaiveModel(model=global_model, quantiles=q) + assert model.likelihood == "quantile" # non-centered quantiles with pytest.raises(ValueError) as exc: @@ -226,13 +227,26 @@ def test_model_construction_cqr(self): with pytest.raises(ValueError) as exc: ConformalQRModel(model=model_det, quantiles=q) assert str(exc.value).startswith( - "`model` must must support probabilistic forecasting." + "`model` must support probabilistic forecasting." ) # probabilistic model works _ = ConformalQRModel(model=model_prob_q, quantiles=q) # works also with different likelihood _ = ConformalQRModel(model=model_prob_poisson, quantiles=q) + def test_unsupported_properties(self): + """Tests only here for coverage, maybe at some point we support these properties.""" + model = ConformalNaiveModel(train_model(self.ts_pass_train), quantiles=q) + unsupported_properties = [ + "_model_encoder_settings", + "extreme_lags", + "min_train_series_length", + "min_train_samples", + ] + for prop in unsupported_properties: + with pytest.raises(NotImplementedError): + getattr(model, prop) + @pytest.mark.parametrize("config", models_cls_kwargs_errs) def test_save_model_parameters(self, config): # model creation parameters were saved before. check if re-created model has same params as original @@ -304,6 +318,16 @@ def test_save_load_model(self, tmpdir_fn, config): loaded_model = model_cls.load(p) assert model_prediction == loaded_model.predict(5, **pred_kwargs) + def test_fit(self): + model = ConformalNaiveModel(train_model(self.ts_pass_train), quantiles=q) + assert model.model._fit_called + + # check kwargs will be passed to `model.model.fit()` + assert model.supports_sample_weight + model.model._fit_called = False + model.fit(self.ts_pass_train, sample_weight="linear") + assert model.model._fit_called + @pytest.mark.parametrize("config", models_cls_kwargs_errs) def test_single_ts(self, config): model_cls, kwargs, model_type = config @@ -589,9 +613,11 @@ def test_use_static_covariates(self, config, ts): train_model(ts, model_type=model_type, quantiles=kwargs["quantiles"]), **kwargs, ) + assert model.considers_static_covariates + assert model.supports_static_covariates assert model.uses_static_covariates pred = model.predict(OUT_LEN) - assert pred.static_covariates is None + assert pred.static_covariates.equals(ts.static_covariates) @pytest.mark.parametrize( "config", @@ -681,20 +707,18 @@ def test_output_chunk_shift(self): @pytest.mark.parametrize( "config", - list( - itertools.product( - [1, 3, 5], # horizon - [True, False], # univariate series - [True, False], # single series - [q, [0.2, 0.3, 0.5, 0.7, 0.8]], - [ - (ConformalNaiveModel, "regression"), - (ConformalNaiveModel, "regression_prob"), - (ConformalQRModel, "regression_qr"), - ], # model type - [True, False], # symmetric non-conformity score - [None, 1], # train length - ) + itertools.product( + [1, 3, 5], # horizon + [True, False], # univariate series + [True, False], # single series + [q, [0.2, 0.3, 0.5, 0.7, 0.8]], + [ + (ConformalNaiveModel, "regression"), + (ConformalNaiveModel, "regression_prob"), + (ConformalQRModel, "regression_qr"), + ], # model type + [True, False], # symmetric non-conformity score + [None, 1], # train length ), ) def test_conformal_model_predict_accuracy(self, config): diff --git a/darts/tests/utils/historical_forecasts/test_historical_forecasts.py b/darts/tests/utils/historical_forecasts/test_historical_forecasts.py index c48d16df1e..1f739f9599 100644 --- a/darts/tests/utils/historical_forecasts/test_historical_forecasts.py +++ b/darts/tests/utils/historical_forecasts/test_historical_forecasts.py @@ -3502,8 +3502,7 @@ def test_conformal_historical_forecasts(self, config): ), ) def test_conformal_historical_start_cal_length(self, config): - """Tests naive conformal model with start, train length, calibration set, and center forecasts against - the forecasting model's forecast.""" + """Tests naive conformal model historical forecasts without `cal_stride`.""" ( last_points_only, cal_length, diff --git a/darts/tests/utils/historical_forecasts/test_utils.py b/darts/tests/utils/historical_forecasts/test_utils.py index fdb14ed1a5..7554d807e7 100644 --- a/darts/tests/utils/historical_forecasts/test_utils.py +++ b/darts/tests/utils/historical_forecasts/test_utils.py @@ -102,10 +102,12 @@ def test_historical_forecasts_check_start(self): (True, 0.9, "position"), (True, 0, "position"), (True, 0, "value"), + (True, -1, "position"), (False, pd.Timestamp("2000-01-01"), "value"), (False, 0.9, "value"), (False, 0.9, "position"), (False, 0, "position"), + (False, -1, "position"), ], ) def test_historical_forecasts_check_start_invalid(self, config): From 68afe91fcff3306a64e401d5a6c94b0772ec1a66 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sat, 14 Dec 2024 23:01:02 +0100 Subject: [PATCH 72/78] update changelog --- CHANGELOG.md | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2428a90127..ef48068d0d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,8 +11,16 @@ but cannot always guarantee backwards compatibility. Changes that may **break co **Improved** -- Improvements to `ForecastingModel`: Improved `start` handling for historical forecasts, backtest, residuals, and gridsearch. If `start` is not within the trainable / forecastable points, uses the closest valid start point that is a round multiple of `stride` ahead of start. Raises a ValueError, if no valid start point exists. This guarantees that all historical forecasts are `n * stride` points away from start, and will simplify many downstream tasks. [#2560](https://github.com/unit8co/darts/issues/2560) by [Dennis Bader](https://github.com/dennisbader). -- Added `data_transformers` argument to `historical_forecasts`, `backtest`, `residuals`, and `gridsearch` that allow to automatically apply `DataTransformer` and/or `Pipeline` to the input series without data-leakage (fit on historic window of input series, transform the input series, and inverse transform the forecasts). [#2529](https://github.com/unit8co/darts/pull/2529) by [Antoine Madrona](https://github.com/madtoinou) and [Jan Fidor](https://github.com/JanFidor) +- 🚀🚀 Introducing Conformal Prediction to Darts: Add calibrated intervals to your model forecasts with the first two conformal prediction models. + - `ConformalNaiveModel`: WIP + - `ConformalQRModel`: WIP +- Improvements to `ForecastingModel`: + - 🚀🚀 Added `data_transformers` argument to `historical_forecasts`, `backtest`, `residuals`, and `gridsearch` that allow to automatically apply `DataTransformer` and/or `Pipeline` to the input series without data-leakage (fit on historic window of input series, transform the input series, and inverse transform the forecasts). [#2529](https://github.com/unit8co/darts/pull/2529) by [Antoine Madrona](https://github.com/madtoinou) and [Jan Fidor](https://github.com/JanFidor) + - Improved `start` handling for historical forecasts, backtest, residuals, and gridsearch. If `start` is not within the trainable / forecastable points, uses the closest valid start point that is a round multiple of `stride` ahead of start. Raises a ValueError, if no valid start point exists. This guarantees that all historical forecasts are `n * stride` points away from start, and will simplify many downstream tasks. [#2560](https://github.com/unit8co/darts/issues/2560) by [Dennis Bader](https://github.com/dennisbader). +- Improvements to Metrics: Added three new quantile interval metrics (plus their aggregated versions): + - Interval Winkler Score `iws()`, and Mean Interval Winkler Scores `miws()` (time-aggregated) ([source](https://otexts.com/fpp3/distaccuracy.html)) + - Interval Coverage `ic()` (binary if observation is within the quantile interval), and Mean Interval Covarage `mic()` (time-aggregated) + - Interval Non-Conformity Score for Quantile Regression `incs_qr()`, and Mean ... `mincs_qr()` (time-aggregated) ([source](https://arxiv.org/pdf/1905.03222)) - Added `series_idx` argument to `DataTransformer` that allows users to use only a subset of the transformers when `global_fit=False` and severals series are used. [#2529](https://github.com/unit8co/darts/pull/2529) by [Antoine Madrona](https://github.com/madtoinou) - Updated the Documentation URL of `Statsforecast` models. [#2610](https://github.com/unit8co/darts/pull/2610) by [He Weilin](https://github.com/cnhwl). From b8b911b75391e6929f2e577fb2ef5f5011af5146 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sun, 15 Dec 2024 12:14:56 +0100 Subject: [PATCH 73/78] update changelog --- CHANGELOG.md | 26 ++++++++++++++++++-------- 1 file changed, 18 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ef48068d0d..7978b38ca1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,15 +11,25 @@ but cannot always guarantee backwards compatibility. Changes that may **break co **Improved** -- 🚀🚀 Introducing Conformal Prediction to Darts: Add calibrated intervals to your model forecasts with the first two conformal prediction models. - - `ConformalNaiveModel`: WIP - - `ConformalQRModel`: WIP -- Improvements to `ForecastingModel`: - - 🚀🚀 Added `data_transformers` argument to `historical_forecasts`, `backtest`, `residuals`, and `gridsearch` that allow to automatically apply `DataTransformer` and/or `Pipeline` to the input series without data-leakage (fit on historic window of input series, transform the input series, and inverse transform the forecasts). [#2529](https://github.com/unit8co/darts/pull/2529) by [Antoine Madrona](https://github.com/madtoinou) and [Jan Fidor](https://github.com/JanFidor) - - Improved `start` handling for historical forecasts, backtest, residuals, and gridsearch. If `start` is not within the trainable / forecastable points, uses the closest valid start point that is a round multiple of `stride` ahead of start. Raises a ValueError, if no valid start point exists. This guarantees that all historical forecasts are `n * stride` points away from start, and will simplify many downstream tasks. [#2560](https://github.com/unit8co/darts/issues/2560) by [Dennis Bader](https://github.com/dennisbader). -- Improvements to Metrics: Added three new quantile interval metrics (plus their aggregated versions): +- 🚀🚀 Introducing Conformal Prediction to Darts: Add calibrated prediction intervals to any pre-trained global forecasting model with our first two conformal prediction models : [#2552](https://github.com/unit8co/darts/pull/2552) by [Dennis Bader](https://github.com/dennisbader). + - `ConformalNaiveModel`: It uses past point forecast errors to produce calibrated forecast intervals with a specified coverage probability. + - `ConformalQRModel`: It combines quantile regression (or any probabilistic model) with conformal prediction techniques. It adjusts quantile estimates (using non-conformity scores `metrics.incs_qr()`) to generate calibrated prediction intervals with a specified coverage probability. + - Both models offer the following support: + - use any pre-trained global forecasting model as the base forecaster + - uni and multivariate forecasts + - single and multiple series forecasts + - single and multi-horizon forecasts + - generate a single or multiple calibrated prediction intervals + - direct quantile value predictions (interval bounds) or sampled predictions from these quantile values + - covariates based on the underlying forecasting model + - Check out this [example notebook](https://unit8co.github.io/darts/examples/23-Conformal-Prediction-examples.html) for more information! +- Improvements to `ForecastingModel.historical_forecasts()`, `backtest()`, `residuals()`, and `gridsearch()`: + - 🚀🚀 Added support for data transformers and pipelines. Use argument `data_transformers` to automatically apply any `DataTransformer` and/or `Pipeline` to the input series without data-leakage (fit on historic window of input series, transform the input series, and inverse transform the forecasts). [#2529](https://github.com/unit8co/darts/pull/2529) by [Antoine Madrona](https://github.com/madtoinou) and [Jan Fidor](https://github.com/JanFidor) + - Improved `start` handling. If `start` is not within the trainable / forecastable points, uses the closest valid start point that is a round multiple of `stride` ahead of start. Raises a ValueError, if no valid start point exists. This guarantees that all historical forecasts are `n * stride` points away from start, and will simplify many downstream tasks. [#2560](https://github.com/unit8co/darts/issues/2560) by [Dennis Bader](https://github.com/dennisbader). + - Added support for `overlap_end=True` to `residuals()`. This computes historical forecasts and residuals that can extend further than the end of the target series. Guarantees that all returned residual values have the same length per forecast (the last residuals will contain missing values, if the forecasts extended further into the future than the end of the target series). [#2552](https://github.com/unit8co/darts/pull/2552) by [Dennis Bader](https://github.com/dennisbader). +- Improvements to `metrics`: Added three new quantile interval metrics (plus their aggregated versions) : [#2552](https://github.com/unit8co/darts/pull/2552) by [Dennis Bader](https://github.com/dennisbader). - Interval Winkler Score `iws()`, and Mean Interval Winkler Scores `miws()` (time-aggregated) ([source](https://otexts.com/fpp3/distaccuracy.html)) - - Interval Coverage `ic()` (binary if observation is within the quantile interval), and Mean Interval Covarage `mic()` (time-aggregated) + - Interval Coverage `ic()` (binary if observation is within the quantile interval), and Mean Interval Coverage `mic()` (time-aggregated) - Interval Non-Conformity Score for Quantile Regression `incs_qr()`, and Mean ... `mincs_qr()` (time-aggregated) ([source](https://arxiv.org/pdf/1905.03222)) - Added `series_idx` argument to `DataTransformer` that allows users to use only a subset of the transformers when `global_fit=False` and severals series are used. [#2529](https://github.com/unit8co/darts/pull/2529) by [Antoine Madrona](https://github.com/madtoinou) - Updated the Documentation URL of `Statsforecast` models. [#2610](https://github.com/unit8co/darts/pull/2610) by [He Weilin](https://github.com/cnhwl). From 45ec32dc831624ab1d68f95458e3fee840503ce5 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 19 Dec 2024 11:43:42 +0100 Subject: [PATCH 74/78] update example notebook --- .../23-Conformal-Prediction-examples.ipynb | 1493 +++++++++++------ 1 file changed, 978 insertions(+), 515 deletions(-) diff --git a/examples/23-Conformal-Prediction-examples.ipynb b/examples/23-Conformal-Prediction-examples.ipynb index 10573d8b43..9b4ba3fee0 100644 --- a/examples/23-Conformal-Prediction-examples.ipynb +++ b/examples/23-Conformal-Prediction-examples.ipynb @@ -7,17 +7,7 @@ "source": [ "# Conformal Prediction Models\n", "\n", - "The following is a in depth demonstration of the regression models in Darts - from basic to advanced features, including:\n", - "\n", - "- Darts' regression models\n", - "- lags and lagged data extraction\n", - "- covariates usage\n", - "- parameters output_chunk_length in relation with multi_models\n", - "- one-shot and auto-regressive predictions\n", - "- multi output support\n", - "- probablistic forecasting\n", - "- explainability\n", - "- and more" + "The following is a demonstration of the conformal prediciton models in Darts." ] }, { @@ -25,32 +15,12 @@ "execution_count": 2, "id": "3ef9bc25-7b86-4de5-80e9-6eff27025b44", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# fix python path if working locally\n", "from utils import fix_pythonpath_if_working_locally\n", "\n", - "fix_pythonpath_if_working_locally()\n", - "\n", - "# activate javascript\n", - "from shap import initjs\n", - "\n", - "initjs()" + "fix_pythonpath_if_working_locally()" ] }, { @@ -58,21 +28,11 @@ "execution_count": 3, "id": "9d9d76e9-5753-4762-a1cb-c8c61d0313d2", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "%load_ext autoreload\n", "%autoreload 2\n", "%matplotlib inline\n", - "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "\n", "from darts import concatenate, metrics\n", @@ -82,105 +42,142 @@ }, { "cell_type": "markdown", - "id": "eacf6328-6b51-43e9-8b44-214f5df15684", + "id": "6ec264e9-af99-4d88-9fcc-1e71db03b294", "metadata": {}, "source": [ - "### Input Dataset\n", - "For this notebook, we use the Electricity Consumption Dataset from households in Zurich, Switzerland.\n", + "## Conformal Prediction for Time Series Forecasting\n", + "\n", + "*Conformal prediction is a technique for constructing prediction intervals that try to achieve valid coverage in finite samples, without making distributional assumptions.* [(source)](https://arxiv.org/pdf/1905.03222)\n", "\n", - "The dataset has a quarter-hourly frequency (15 Min time intervals), but we resample it to hourly \n", - "frequency to keep things simple.\n", + "In other words: If we want a prediction interval that includes 80% of all actual values over some period of time, then a conformal model attempts to generate such intervals that actually have 80% of points inside.\n", "\n", - "**Target series** (the series we want to forecast):\n", - "- **Value_NE5**: Electricity consumption by households on grid level 5 (in kWh).\n", + "There are different techniques to perform conformal prediction. In Darts, we currently use **Split Conformal Prediciton [(SCP, Lei\n", + "et al., 2018)](https://www.stat.cmu.edu/~ryantibs/papers/conformal.pdf)** (with some nice adaptions) due to its simplicity and efficiency. \n", + "\n", + "### Split Conformal Prediction\n", + "SCP adds calibrated prediction intervals with a specified confidence level to a base model's forecasts. It involves splitting the data into a training (+ optional validation) set and a calibration (+ test) set. The model is trained on the training set, and the calibration set is used to compute the prediction intervals to ensure they contain the true values with the desired probability.\n", "\n", - "**Covariates** (external data to help improve forecasts):\n", - "The dataset also comes with weather measurements that we can use as covariates. For simplicity, we use:\n", - "- **T [°C]**: Measured temperature\n", - "- **StrGlo [W/m2]**: Measured solar irradation\n", - "- **RainDur [min]**: Measured raining duration" + "#### Advantages\n", + "\n", + "- **Valid Coverage**: Provides valid prediction intervals that are guaranteed to contain the true value with a specified confidence level on finite samples.\n", + "- **Model-agnostic**: Can be applied to any predictive model:\n", + " - Either adds calibrated prediction intervals to point forecasting models\n", + " - Or calibrates the predicted intervals in case of probabilistic forecasting models\n", + "- **Distribution-free**: No distributional assumptions about the data except that the errors on the calibration set are exchangeable (e.g. we don't need to assume that our data is normally distributed and then fit a model with a `GaussianLikelihood`).\n", + "- **Efficient**: Split Conformal Prediciton is very efficient since it does not require model re-training.\n", + "- **Interpretable**: The method is interpretable due its simplicity.\n", + "- **Useful Applications**: It's used to provide more reliable and informative predictions to help decision making in several industry. See this [article on conformal prediction](https://medium.com/@data-overload/conformal-prediction-a-critic-to-predictive-models-27501dcc76d4)\n", + "\n", + "#### Disadvantages\n", + "\n", + "- **Requires a Calibration Set**: Conformal prediction requires another data / hold-out set that is used solely to compute the calibrated prediction intervals. This can be inefficient for small datasets.\n", + "- **Exchangeability of Calibration Data (*)**: The accuracy of the prediction intervals depends on the representativeness of the calibration data (or rather the forecast errors produced on the calibration set). The coverage is not guaranteed anymore if there is a **distribution shift** in forecast errors (e.g. series with a trend but forecasting model is not able to predict the trend).\n", + "- **Conservativeness (*)**: May produce wider intervals than necessary, leading to conservative predictions.\n", + "\n", + "(*) Darts conformal models have some parameters to control the extraction of the calibration set for more adaptiveness." ] }, { - "cell_type": "code", - "execution_count": 5, - "id": "ea0d05f6-03cc-4422-afed-36acb2b94fa7", + "cell_type": "markdown", + "id": "d5dc6eb5-2eeb-4495-9074-1a44ac9154ab", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/dennisbader/miniconda3/envs/darts310/lib/python3.10/site-packages/xarray/groupers.py:403: FutureWarning: 'H' is deprecated and will be removed in a future version, please use 'h' instead.\n", - " self.index_grouper = pd.Grouper(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ - "ts_energy = ElectricityConsumptionZurichDataset().load()\n", + "## Darts Conformal Models\n", + "\n", + "Darts' conformal models add calibrated prediciton intervals to the forecasts of any **pre-trained global forecasting model**. \n", + "There is no need to train the conformal models themselves (e.g. no `fit()` requried) and you can directly call `predict()` or `historical_forecasts()`. Behind the hood, Darts will automatically extract the calibration set from the past of your input series and use it to generate the calibrated prediction intervals (see [here](#Workflow-behind-the-hood) for more detail).\n", + "\n", + "> **Important**: The `series` passed to the forecast methods **should not have any overlap** with the series used to **train** the forecasting model, since this will lead to overly optimistic prediction intervals.\n", + "\n", + "### Direct Interval Bound Predictions or Sampled Predictions\n", + "Conformal models are probabilistic, so you can forecast in two ways (when calling `predict()`, `historical_forecasts()`, ...):\n", + "\n", + "- Forecast the calibrated quantile interval bounds directly (example [here](https://unit8co.github.io/darts/quickstart/00-quickstart.html#Direct-Parameter-Predicitons)).\n", + " - `predict(..., predict_likelihood_parameters=True)`\n", + "- Generate stochastic forecasts by sampling from these calibrated quantile intervals (examples [here](https://unit8co.github.io/darts/quickstart/00-quickstart.html#Probabilistic-Sample-Predictions)):\n", + " - `predict(..., num_samples=1000)`\n", + "\n", + "### Model support\n", + "\n", + "All conformal models in Darts support:\n", + "\n", + "- any **pre-trained global forecasting model** as the base forecaster (you can find a list [here](https://unit8co.github.io/darts/#forecasting-models))\n", + "- **uni-** and **multivariate** forecasts (single / multi-columns)\n", + "- **single** and **multiple series** forecasts\n", + "- **single** and **multi-horizon** forecasts\n", + "- generate a **single** or **multiple calibrated prediction intervals**\n", + "- **direct quantile value** predictions (interval bounds) or **sampled predictions** from these quantile values\n", + "- **any covariates** based on the underlying forecasting model\n", + "\n", + "### Workflow behind the hood\n", + "\n", + "In general the workflow of the models to produce one calibrated forecast/prediction is as follows (using `predict()`):\n", "\n", - "# extract values recorded between 2017 and 2019\n", - "start_date = pd.Timestamp(\"2017-01-01\")\n", - "end_date = pd.Timestamp(\"2019-01-31\")\n", - "ts_energy = ts_energy[start_date:end_date]\n", + "- **Extract a calibration set**: The calibration set for each conformal forecast is automatically extracted from\n", + " the past of your input series relative to the forecast start point. The number of calibration examples\n", + " (forecast errors / non-conformity scores) to consider can be defined at model creation\n", + " with parameter `cal_length`. Note that when using `cal_stride>1`, a longer history is required since\n", + " the calibration examples are generated with stridden historical forecasts.\n", + "- Generate **historical forecasts** on the calibration set (using the forecasting model) with a stride `cal_stride`.\n", + "- Compute the **errors/non-conformity scores** (specific to each conformal model) on these historical forecasts\n", + "- Compute the **quantile values** from the errors / non-conformity scores (using our desired quantiles set at model\n", + " creation with parameter `quantiles`).\n", + "- Compute the conformal prediction: Using these quantile values, add **calibrated intervals** to (or adjust the\n", + " existing intervals of) the forecasting model's predictions.\n", "\n", - "# resample to hourly frequency\n", - "ts_energy = ts_energy.resample(freq=\"H\")\n", + "For **multi-horizon forecasts**, the above is applied for each step in the horizon separately.\n", "\n", - "# extract temperature, solar irradiation and rain duration\n", - "ts_weather = ts_energy[[\"T [°C]\", \"StrGlo [W/m2]\", \"RainDur [min]\"]]\n", + "When computing `historical_forecasts()`, `backtest()`, `residuals()`, ... the above is applied for each forecast (the forecasting model's historical forecasts are only generated once for efficiency).\n", "\n", - "# extract households energy consumption\n", - "ts_energy = ts_energy[\"Value_NE5\"]\n", "\n", - "# create train and validation splits\n", - "validation_cutoff = pd.Timestamp(\"2018-10-31\")\n", - "ts_energy_train, ts_energy_val = ts_energy.split_after(validation_cutoff)\n", + "### Available Conformal Models\n", "\n", - "ts_energy.plot()\n", - "plt.show()\n", + "At the time of writing (Darts version 0.32.0), we have two conformal models:\n", "\n", - "ts_weather.plot()\n", - "plt.show()" + "#### `ConformalNaiveModel`\n", + "\n", + "Adds calibrated intervals around the median forecast from **any pre-trained global forecasting model**. It supports two symmetry modes:\n", + "\n", + "- `symmetric=True`:\n", + " - The lower and upper interval bounds are calibrated with the same magnitude.\n", + " - Non-conformity scores: uses the [absolute error `ae()`](https://unit8co.github.io/darts/generated_api/darts.metrics.metrics.html#darts.metrics.metrics.ae) to compute the non-conformity scores on the calibration set.\n", + "- `symmetric=False`\n", + " - The lower and upper interval bounds are calibrated separately.\n", + " - Non-conformity scores: uses the [error `err()`](https://unit8co.github.io/darts/generated_api/darts.metrics.metrics.html#darts.metrics.metrics.err) to compute the\n", + " non-conformity scores on the calibration set for the upper bounds, and `-err()` for the lower bounds.\n", + "\n", + "#### `ConformalQRModel` (Conformalized Quantile Regression Model)\n", + "\n", + "Calibrates the quantile predictions from a **pre-trained probabilistic global forecasting model**. It supports two symmetry modes:\n", + "\n", + "- `symmetric=True`:\n", + " - The lower and upper quantile predictions are calibrated with the same magnitude.\n", + " - Non-conformity scores: uses the [Non-Conformity Score for Quantile Regression `incs_qr(symmetric=True)`](https://unit8co.github.io/darts/generated_api/darts.metrics.metrics.html#darts.metrics.metrics.incs_qr) on the calibration set.\n", + "- `symmetric=False`\n", + " - The lower and upper quantile predictions are calibrated separately.\n", + " - Non-conformity scores: uses the [Asymmetric Non-Conformity Score for Quantile Regression `incs_qr(symmetric=False)`](https://unit8co.github.io/darts/generated_api/darts.metrics.metrics.html#darts.metrics.metrics.incs_qr) for the upper and lower bound on the calibration set." ] }, { "cell_type": "markdown", - "id": "4fefe4e3-1fee-4f52-a2d9-5b2d24d928d3", + "id": "eacf6328-6b51-43e9-8b44-214f5df15684", "metadata": {}, "source": [ - "## Darts Conformal Prediction Models\n", + "### Input Dataset\n", + "For this notebook, we use the Electricity Consumption Dataset from households in Zurich, Switzerland.\n", "\n", - "*Conformal prediction is a technique for constructing prediction intervals that try to achieve valid coverage in finite samples, without making distributional assumptions.* [(source)](https://arxiv.org/pdf/1905.03222)\n", + "The dataset has a quarter-hourly frequency (15 Min time intervals), but we resample it to hourly frequency to keep things simple.\n", + "\n", + "To keep it simple, we will not use any covariates and only concentrate on the electricty consumption as the target we want to predict. The conformal model's covariate support and API is identical to the base-forecaster.\n", "\n", - "In other words: If we want a prediction interval that includes 80% of all actual values over some period of time, then a conformal model tries to build such an interval with actually has 80% of points inside.\n", - "... WIP" + "**Target series** (the series we want to forecast):\n", + "- **Value_NE5**: Electricity consumption by households on grid level 5 (in kWh)." ] }, { "cell_type": "code", - "execution_count": 85, - "id": "6a3f3753-b7db-448c-942a-9db51390b1b9", + "execution_count": 4, + "id": "90b31843-8f60-4dd8-b6e4-87206d67e585", "metadata": {}, "outputs": [ { @@ -189,13 +186,13 @@ "" ] }, - "execution_count": 85, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -205,68 +202,71 @@ } ], "source": [ - "input_length = 24\n", - "horizon = 24\n", + "series = ElectricityConsumptionZurichDataset().load()\n", "\n", - "model = LinearRegressionModel(lags=input_length, output_chunk_length=horizon)\n", - "model.fit(ts_energy_train)\n", - "pred = model.predict(horizon)\n", + "# extract target and resample to hourly frequency\n", + "series = series[\"Value_NE5\"].resample(freq=\"h\")\n", "\n", - "ts_energy_train[-2 * horizon :].plot(label=\"training\")\n", - "ts_energy_val[:horizon].plot(label=\"validation\")\n", - "pred.plot(label=\"forecast\")" - ] - }, - { - "cell_type": "markdown", - "id": "f58cf17c-fb1a-4f3f-bd0a-bb2445c84a04", - "metadata": {}, - "source": [ - "### Hist fc over validation series" + "# plot 2 weeks of hourly consumption\n", + "series[: 2 * 7 * 24].plot()" ] }, { "cell_type": "code", - "execution_count": 86, - "id": "788660a0-b879-435b-8fbd-235436c0f3d8", + "execution_count": 5, + "id": "29a5b91e-543f-46e0-8dbd-12da2f09522f", "metadata": {}, "outputs": [ { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "000eae68dd4a48de9de0019ae7bf5734", - "version_major": 2, - "version_minor": 0 - }, + "image/png": "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", "text/plain": [ - "historical forecasts: 0%| | 0/1 [00:00" ] }, "metadata": {}, "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2527.8057652310067\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 86, - "metadata": {}, - "output_type": "execute_result" - }, + } + ], + "source": [ + "train_start = pd.Timestamp(\"2015-01-01\")\n", + "cal_start = pd.Timestamp(\"2016-01-01\")\n", + "test_start = pd.Timestamp(\"2017-01-01\")\n", + "test_end = pd.Timestamp(\"2018-01-01\")\n", + "\n", + "train = series[train_start : cal_start - series.freq]\n", + "cal = series[cal_start : test_start - series.freq]\n", + "test = series[test_start:test_end]\n", + "\n", + "train.plot(label=\"train\")\n", + "cal.plot(label=\"val\")\n", + "test.plot(label=\"test\");" + ] + }, + { + "cell_type": "markdown", + "id": "dc15b191-ef84-4cf7-86e1-4cd3385ecd11", + "metadata": {}, + "source": [ + "### Train the base forecaster\n", + "\n", + "Let's use a `LinearRegressionModel` as our base forecasting model. We'll configure it to use the last 24 hours as lookback to forecast the next 24 hours.\n", + "\n", + "- train it on the `train` set\n", + "- forecast the next 24 hours after the end of the `cal` set" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8a9952be-a6c4-4da1-aabe-70c8f019b222", + "metadata": {}, + "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -274,42 +274,52 @@ } ], "source": [ - "hist_fc = model.historical_forecasts(\n", - " series=ts_energy_val,\n", - " forecast_horizon=horizon,\n", - " stride=horizon,\n", - " last_points_only=False,\n", - " retrain=False,\n", - " verbose=True,\n", - ")\n", - "hist_fc = concatenate(hist_fc)\n", - "print(metrics.mae(ts_energy_val, hist_fc))\n", + "input_length = 7 * 24\n", + "horizon = 7 * 24\n", "\n", - "fig, ax = plt.subplots(figsize=(12, 6))\n", - "end_ts = ts_energy_val.start_time() + 2 * 7 * horizon * ts_energy_val.freq\n", - "ts_energy_val[:end_ts].plot()\n", - "hist_fc[:end_ts].plot()" + "# train the model\n", + "model = LinearRegressionModel(lags=input_length, output_chunk_length=horizon)\n", + "model.fit(train)\n", + "\n", + "# forecast and plot\n", + "pred = model.predict(n=horizon, series=cal)\n", + "series[pred.start_time() - 3 * 24 * series.freq : pred.end_time()].plot(label=\"actual\")\n", + "pred.plot(label=\"pred\");" ] }, { "cell_type": "markdown", - "id": "14573b68-537c-4916-a9b5-a4eb7bb84400", + "id": "f8a80d6b-2818-4079-b39a-1848a2f049c1", "metadata": {}, "source": [ - "### Point Forecasts Are not so good\n", - "No idea about uncertainty. Can we do better?" + "We can clearly see that the forecasts are off. But we have no estiamte of the uncertainty." + ] + }, + { + "cell_type": "markdown", + "id": "8e5bbfe1-2e10-4675-844d-d965c0371ca3", + "metadata": {}, + "source": [ + "### Apply Conformal Prediction\n", + "\n", + "Now let's apply conformal prediciton to quantify the uncertainty. We use the symmetric (default) naive model including the quantile levels we want to forecast. Let's:\n", + "\n", + "- we don't need to train / fit the conformal model\n", + "- we should supply a `series` to `predict()` that does not have an overlap with the series used to train the model. In our case `cal` has no overlap with `train`.\n", + "\n", + "Let's add the 90% (quantiles 0.05 - 0.95) and 80% (0.10 - 0.90) prediction intervals." ] }, { "cell_type": "code", - "execution_count": 37, - "id": "f47c68a5-922f-4e36-b10a-ea34162c0250", + "execution_count": 9, + "id": "358f91ad-770d-4389-bf95-53004d8ec93f", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "10eebeb049d447fe94271b11d718c427", + "model_id": "38ce5c256b1c4436886a2cba707e07a0", "version_major": 2, "version_minor": 0 }, @@ -323,12 +333,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "74b75bd7fb934ead9aff9df5910e3ea0", + "model_id": "9da79419a6c84b06bd57b07e843cea12", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "conformal forecasts: 0%| | 0/83 [00:00" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -356,188 +356,192 @@ } ], "source": [ - "quantiles = [0.05, 0.1, 0.5, 0.9, 0.95]\n", - "cp_model = ConformalNaiveModel(model=model, quantiles=quantiles, cal_length=7 * horizon)\n", - "pred_params = {\"predict_likelihood_parameters\": True}\n", - "# pred_params = {\"num_samples\": 500}\n", + "quantiles = [0.05, 0.15, 0.50, 0.85, 0.95]\n", + "pred_kwargs = {\"predict_likelihood_parameters\": True, \"verbose\": True}\n", "\n", - "cp_hist_fc = cp_model.historical_forecasts(\n", - " series=ts_energy_val,\n", - " forecast_horizon=horizon,\n", - " stride=horizon,\n", - " last_points_only=False,\n", - " retrain=False,\n", - " verbose=True,\n", - " **pred_params,\n", + "\n", + "cp_model = ConformalNaiveModel(\n", + " model=model,\n", + " quantiles=quantiles,\n", + " symmetric=True, # default, whether to\n", + " cal_stride=1, # default, stride to apply to historical forecasts on calibration set\n", ")\n", - "cp_hist_fc = concatenate(cp_hist_fc)\n", "\n", - "fig, ax = plt.subplots(figsize=(12, 6))\n", - "ts_energy_val[:end_ts].plot()\n", - "cp_hist_fc[:end_ts].plot()" - ] - }, - { - "cell_type": "markdown", - "id": "1e854774-bbfe-4ff3-b0c8-3734973724c9", - "metadata": {}, - "source": [ - "### What's the overall coverage?" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "845ce322-e5de-45fa-9d7c-f3bddbd1f0a3", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " q0.05-q0.95 q0.1-q0.9\n", - "Interval Width 10054.736762 6305.233124\n", - "Interval Coverage 0.851908 0.719880\n" - ] - } - ], - "source": [ - "def compute_backtest(forecasts):\n", - " bt = cp_model.backtest(\n", - " series=ts_energy_val,\n", - " historical_forecasts=forecasts,\n", - " last_points_only=True,\n", - " metric=[metrics.miw, metrics.mic],\n", - " metric_kwargs={\"q_interval\": cp_model.q_interval},\n", - " )\n", - " bt_df = pd.DataFrame(bt).T\n", - " bt_df.columns = [\"q0.05-q0.95\", \"q0.1-q0.9\"]\n", - " bt_df.index = [\"Interval Width\", \"Interval Coverage\"]\n", - " return bt_df\n", - "\n", - "\n", - "print(compute_backtest(cp_hist_fc))" + "pred = cp_model.predict(n=horizon, series=cal, **pred_kwargs)\n", + "series[pred.start_time() - 3 * 24 * series.freq : pred.end_time()].plot(label=\"actual\")\n", + "pred.plot(label=\"pred\");" ] }, { "cell_type": "markdown", - "id": "8fb59539-b8a5-40ef-90c8-f1e429e3d656", + "id": "3897a238-4543-4542-895f-e2e62dda32bc", "metadata": {}, "source": [ - "Ideally we should be at 90% and 80% overall coverage" + "Great, we can see the two added prediction intervals. Most of the actuals seem to be within the 90% interval.\n", + "Let's look at how to evaluate this forecast.\n", + "\n", + "> **Note about computational time**: In this case the time to produce the conformal forecast is dominated by the historical forecasts (4 seconds) on the calibration set. Behind the hood the model computed a backtest over an entire year (generating and evaluating more than 200k predictions; 8'760 1-day forecasts using 24 dedicated linear models (one for each horizon)). The performance can be greatly improved by adjusting `cal_length` and `cal_stride` at conformal model creation (more on that later)." ] }, { "cell_type": "markdown", - "id": "910cf6a7-df6b-4ac3-a17c-78949c974949", + "id": "80001270-a5af-4514-83ac-5c392b10bf37", "metadata": {}, "source": [ - "### What's the interval width over time?" + "### Evaluate Conformal Prediction\n", + "\n", + "Darts has dedicated metrics for prediction intervals. You can find them on [our metrics page](https://unit8co.github.io/darts/generated_api/darts.metrics.html) under the *Quantile interval metrics*\n", + "\n", + "- `(m)ic`: (Mean) Interval Coverage\n", + "- `(m)iw`: (Mean) Interval Width\n", + "- `(m)iws`: (Mean) Interval Winkler Score\n", + "- `(m)incs_qr`: (Mean) Interval Non-Conformity Score for Quantile Regression\n", + "\n", + "Let's check the mean interval coverage (the ratio of actual values being within each interval) and the interval width:" ] }, { "cell_type": "code", - "execution_count": 71, - "id": "4fce24be-58dd-4e09-96c2-0e6185b7e34a", + "execution_count": 10, + "id": "9470a0bc-0ac9-407b-9749-0d6ce19e4d7d", "metadata": {}, "outputs": [ { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IntervalPredicted Coverage
00.90.85
10.70.58
\n", + "
" + ], "text/plain": [ - "" + " Interval Predicted Coverage\n", + "0 0.9 0.85\n", + "1 0.7 0.58" ] }, - "execution_count": 71, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "def compute_residuals(forecasts, metric=metrics.ic):\n", - " residuals = cp_model.residuals(\n", - " series=ts_energy_val,\n", - " historical_forecasts=forecasts,\n", - " last_points_only=True,\n", - " metric=metric,\n", - " metric_kwargs={\"q_interval\": cp_model.q_interval},\n", - " )\n", - " return residuals\n", - "\n", - "\n", - "coverage = compute_residuals(cp_hist_fc, metric=metrics.iw)\n", - "coverage[:end_ts].plot()" - ] - }, - { - "cell_type": "markdown", - "id": "1d59cf90-73f9-4661-8177-b31940d087d5", - "metadata": {}, - "source": [ - "Very nice to see increasing intervals for increasing forecast horizon (model was trained to predict 24 steps, we also use a stride of 24) -> thats why we see these ramps" + "q_interval = cp_model.q_interval # [(0.05, 0.95), (0.10, 0.90)]\n", + "q_range = cp_model.interval_range # [0.9, 0.8]\n", + "\n", + "\n", + "def compute_metric(pred_, metric=metrics.mic, name=\"Coverage\"):\n", + " mic = metric(series, pred_, q_interval=q_interval)\n", + " return pd.DataFrame({\"Interval\": q_range, f\"Predicted {name}\": mic}).round(2)\n", + "\n", + "\n", + "compute_metric(pred)" ] }, { "cell_type": "markdown", - "id": "a7acf71f-de84-47e7-9295-4790a06e3588", + "id": "bb765655-53f4-41a2-83cd-96c87c88fc26", "metadata": {}, "source": [ - "### What's the coverage over time?" + "Okay that doesn't look great for the coverage of the 0.8 interval. But we only looked at 1 example. How does it perform on the entire test set?" ] }, { "cell_type": "code", - "execution_count": 72, - "id": "bc4f6fa7-45cb-4b1c-9ec6-769253bafe60", - "metadata": {}, + "execution_count": 12, + "id": "23567754-d132-47d8-aa1c-33a048ff0d28", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, "outputs": [ { "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8afff452de3e444f8459f9769e2c564f", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "" + "historical forecasts: 0%| | 0/1 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" + "ename": "OutOfBoundsDatetime", + "evalue": "Cannot generate range with start=1452211200000000000 and periods=2891280", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mOutOfBoundsDatetime\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[12], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m cal_test \u001b[38;5;241m=\u001b[39m concatenate([cal, test], axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n\u001b[0;32m----> 2\u001b[0m hfcs \u001b[38;5;241m=\u001b[39m \u001b[43mcp_model\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhistorical_forecasts\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43mseries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcal_test\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43mforecast_horizon\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhorizon\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m#start=test.start_time(),\u001b[39;49;00m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mlast_points_only\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[43m \u001b[49m\u001b[43mstride\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhorizon\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 8\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mpred_kwargs\u001b[49m\n\u001b[1;32m 9\u001b[0m \u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/projects/unit8/darts/darts/utils/utils.py:234\u001b[0m, in \u001b[0;36m_with_sanity_checks..decorator..sanitized_method\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 231\u001b[0m only_args\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mself\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 233\u001b[0m \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, sanity_check_method)(\u001b[38;5;241m*\u001b[39monly_args\u001b[38;5;241m.\u001b[39mvalues(), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39monly_kwargs)\n\u001b[0;32m--> 234\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mmethod_to_sanitize\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43monly_args\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvalues\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43monly_kwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/projects/unit8/darts/darts/models/forecasting/conformal_models.py:576\u001b[0m, in \u001b[0;36mConformalModel.historical_forecasts\u001b[0;34m(self, series, past_covariates, future_covariates, forecast_horizon, num_samples, train_length, start, start_format, stride, retrain, overlap_end, last_points_only, verbose, show_warnings, predict_likelihood_parameters, enable_optimization, data_transformers, fit_kwargs, predict_kwargs, sample_weight)\u001b[0m\n\u001b[1;32m 565\u001b[0m \u001b[38;5;66;03m# generate only the required forecasts (if `start` is given, we have to start earlier to satisfy the\u001b[39;00m\n\u001b[1;32m 566\u001b[0m \u001b[38;5;66;03m# calibration set requirements)\u001b[39;00m\n\u001b[1;32m 567\u001b[0m cal_start, cal_start_format \u001b[38;5;241m=\u001b[39m _get_calibration_hfc_start(\n\u001b[1;32m 568\u001b[0m series\u001b[38;5;241m=\u001b[39mseries,\n\u001b[1;32m 569\u001b[0m horizon\u001b[38;5;241m=\u001b[39mforecast_horizon,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 574\u001b[0m start_format\u001b[38;5;241m=\u001b[39mstart_format,\n\u001b[1;32m 575\u001b[0m )\n\u001b[0;32m--> 576\u001b[0m hfcs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhistorical_forecasts\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 577\u001b[0m \u001b[43m \u001b[49m\u001b[43mseries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mseries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 578\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_covariates\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_covariates\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 579\u001b[0m \u001b[43m \u001b[49m\u001b[43mfuture_covariates\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfuture_covariates\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 580\u001b[0m \u001b[43m \u001b[49m\u001b[43mforecast_horizon\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mforecast_horizon\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 581\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_samples\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcal_num_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 582\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcal_start\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 583\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart_format\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcal_start_format\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 584\u001b[0m \u001b[43m \u001b[49m\u001b[43mstride\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcal_stride\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 585\u001b[0m \u001b[43m \u001b[49m\u001b[43mretrain\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 586\u001b[0m \u001b[43m \u001b[49m\u001b[43moverlap_end\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moverlap_end\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 587\u001b[0m \u001b[43m \u001b[49m\u001b[43mlast_points_only\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlast_points_only\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 588\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 589\u001b[0m \u001b[43m \u001b[49m\u001b[43mshow_warnings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 590\u001b[0m \u001b[43m \u001b[49m\u001b[43mpredict_likelihood_parameters\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 591\u001b[0m \u001b[43m \u001b[49m\u001b[43menable_optimization\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43menable_optimization\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 592\u001b[0m \u001b[43m \u001b[49m\u001b[43mdata_transformers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata_transformers\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 593\u001b[0m \u001b[43m \u001b[49m\u001b[43mfit_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfit_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 594\u001b[0m \u001b[43m \u001b[49m\u001b[43mpredict_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpredict_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 595\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 596\u001b[0m calibrated_forecasts \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_calibrate_forecasts(\n\u001b[1;32m 597\u001b[0m series\u001b[38;5;241m=\u001b[39mseries,\n\u001b[1;32m 598\u001b[0m forecasts\u001b[38;5;241m=\u001b[39mhfcs,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 608\u001b[0m predict_likelihood_parameters\u001b[38;5;241m=\u001b[39mpredict_likelihood_parameters,\n\u001b[1;32m 609\u001b[0m )\n\u001b[1;32m 610\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m (\n\u001b[1;32m 611\u001b[0m calibrated_forecasts[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 612\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m called_with_single_series\n\u001b[1;32m 613\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m calibrated_forecasts\n\u001b[1;32m 614\u001b[0m )\n", + "File \u001b[0;32m~/projects/unit8/darts/darts/utils/utils.py:234\u001b[0m, in \u001b[0;36m_with_sanity_checks..decorator..sanitized_method\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 231\u001b[0m only_args\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mself\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 233\u001b[0m \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, sanity_check_method)(\u001b[38;5;241m*\u001b[39monly_args\u001b[38;5;241m.\u001b[39mvalues(), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39monly_kwargs)\n\u001b[0;32m--> 234\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mmethod_to_sanitize\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43monly_args\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvalues\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43monly_kwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/projects/unit8/darts/darts/models/forecasting/forecasting_model.py:969\u001b[0m, in \u001b[0;36mForecastingModel.historical_forecasts\u001b[0;34m(self, series, past_covariates, future_covariates, forecast_horizon, num_samples, train_length, start, start_format, stride, retrain, overlap_end, last_points_only, verbose, show_warnings, predict_likelihood_parameters, enable_optimization, data_transformers, fit_kwargs, predict_kwargs, sample_weight)\u001b[0m\n\u001b[1;32m 952\u001b[0m fit_kwargs, predict_kwargs \u001b[38;5;241m=\u001b[39m _historical_forecasts_sanitize_kwargs(\n\u001b[1;32m 953\u001b[0m model\u001b[38;5;241m=\u001b[39mmodel,\n\u001b[1;32m 954\u001b[0m fit_kwargs\u001b[38;5;241m=\u001b[39mfit_kwargs,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 957\u001b[0m show_warnings\u001b[38;5;241m=\u001b[39mshow_warnings,\n\u001b[1;32m 958\u001b[0m )\n\u001b[1;32m 960\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[1;32m 961\u001b[0m enable_optimization\n\u001b[1;32m 962\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m model\u001b[38;5;241m.\u001b[39msupports_optimized_historical_forecasts\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 967\u001b[0m )\n\u001b[1;32m 968\u001b[0m ):\n\u001b[0;32m--> 969\u001b[0m forecasts \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_optimized_historical_forecasts\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 970\u001b[0m \u001b[43m \u001b[49m\u001b[43mseries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mseries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 971\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_covariates\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_covariates\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 972\u001b[0m \u001b[43m \u001b[49m\u001b[43mfuture_covariates\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfuture_covariates\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 973\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_samples\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 974\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstart\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 975\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart_format\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstart_format\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 976\u001b[0m \u001b[43m \u001b[49m\u001b[43mforecast_horizon\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mforecast_horizon\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 977\u001b[0m \u001b[43m \u001b[49m\u001b[43mstride\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstride\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 978\u001b[0m \u001b[43m \u001b[49m\u001b[43moverlap_end\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moverlap_end\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 979\u001b[0m \u001b[43m \u001b[49m\u001b[43mlast_points_only\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlast_points_only\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 980\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 981\u001b[0m \u001b[43m \u001b[49m\u001b[43mshow_warnings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mshow_warnings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 982\u001b[0m \u001b[43m \u001b[49m\u001b[43mpredict_likelihood_parameters\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpredict_likelihood_parameters\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 983\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mpredict_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 984\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 986\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _apply_inverse_data_transformers(\n\u001b[1;32m 987\u001b[0m series\u001b[38;5;241m=\u001b[39mseries, forecasts\u001b[38;5;241m=\u001b[39mforecasts, data_transformers\u001b[38;5;241m=\u001b[39mdata_transformers\n\u001b[1;32m 988\u001b[0m )\n\u001b[1;32m 990\u001b[0m sequence_type_in \u001b[38;5;241m=\u001b[39m get_series_seq_type(series)\n", + "File \u001b[0;32m~/projects/unit8/darts/darts/models/forecasting/regression_model.py:1373\u001b[0m, in \u001b[0;36mRegressionModel._optimized_historical_forecasts\u001b[0;34m(self, series, past_covariates, future_covariates, num_samples, start, start_format, forecast_horizon, stride, overlap_end, last_points_only, verbose, show_warnings, predict_likelihood_parameters, **kwargs)\u001b[0m\n\u001b[1;32m 1356\u001b[0m hfc \u001b[38;5;241m=\u001b[39m _optimized_historical_forecasts_last_points_only(\n\u001b[1;32m 1357\u001b[0m model\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 1358\u001b[0m series\u001b[38;5;241m=\u001b[39mseries,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1370\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[1;32m 1371\u001b[0m )\n\u001b[1;32m 1372\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1373\u001b[0m hfc \u001b[38;5;241m=\u001b[39m \u001b[43m_optimized_historical_forecasts_all_points\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1374\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1375\u001b[0m \u001b[43m \u001b[49m\u001b[43mseries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mseries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1376\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_covariates\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_covariates\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1377\u001b[0m \u001b[43m \u001b[49m\u001b[43mfuture_covariates\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfuture_covariates\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1378\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_samples\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1379\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstart\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1380\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart_format\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstart_format\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1381\u001b[0m \u001b[43m \u001b[49m\u001b[43mforecast_horizon\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mforecast_horizon\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1382\u001b[0m \u001b[43m \u001b[49m\u001b[43mstride\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstride\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1383\u001b[0m \u001b[43m \u001b[49m\u001b[43moverlap_end\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moverlap_end\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1384\u001b[0m \u001b[43m \u001b[49m\u001b[43mshow_warnings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mshow_warnings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1385\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1386\u001b[0m \u001b[43m \u001b[49m\u001b[43mpredict_likelihood_parameters\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpredict_likelihood_parameters\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1387\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1388\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1389\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m series2seq(hfc, seq_type_out\u001b[38;5;241m=\u001b[39mseries_seq_type)\n", + "File \u001b[0;32m~/projects/unit8/darts/darts/utils/historical_forecasts/optimized_historical_forecasts_regression.py:347\u001b[0m, in \u001b[0;36m_optimized_historical_forecasts_all_points\u001b[0;34m(model, series, past_covariates, future_covariates, num_samples, start, start_format, forecast_horizon, stride, overlap_end, show_warnings, verbose, predict_likelihood_parameters, **kwargs)\u001b[0m\n\u001b[1;32m 344\u001b[0m forecast \u001b[38;5;241m=\u001b[39m forecast[::stride, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m0\u001b[39m, :, :, :]\n\u001b[1;32m 346\u001b[0m \u001b[38;5;66;03m# TODO: check if faster to create in the loop\u001b[39;00m\n\u001b[0;32m--> 347\u001b[0m new_times \u001b[38;5;241m=\u001b[39m \u001b[43mgenerate_index\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 348\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhist_fct_start\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moutput_chunk_shift\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mseries_\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfreq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 349\u001b[0m \u001b[43m \u001b[49m\u001b[43mlength\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mforecast_horizon\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mstride\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mforecast\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 350\u001b[0m \u001b[43m \u001b[49m\u001b[43mfreq\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfreq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 351\u001b[0m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mseries_\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtime_index\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 352\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 354\u001b[0m forecasts_ \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 355\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx_ftc, step_fct \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(\n\u001b[1;32m 356\u001b[0m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m0\u001b[39m, forecast\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m*\u001b[39m stride, stride)\n\u001b[1;32m 357\u001b[0m ):\n", + "File \u001b[0;32m~/projects/unit8/darts/darts/utils/utils.py:568\u001b[0m, in \u001b[0;36mgenerate_index\u001b[0;34m(start, end, length, freq, name)\u001b[0m\n\u001b[1;32m 566\u001b[0m freq \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mD\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m freq \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m freq\n\u001b[1;32m 567\u001b[0m freq \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mtseries\u001b[38;5;241m.\u001b[39mfrequencies\u001b[38;5;241m.\u001b[39mto_offset(freq) \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(freq, \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;28;01melse\u001b[39;00m freq\n\u001b[0;32m--> 568\u001b[0m index \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdate_range\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 569\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstart\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 570\u001b[0m \u001b[43m \u001b[49m\u001b[43mend\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mend\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 571\u001b[0m \u001b[43m \u001b[49m\u001b[43mperiods\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlength\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 572\u001b[0m \u001b[43m \u001b[49m\u001b[43mfreq\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfreq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 573\u001b[0m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 574\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 575\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m freq\u001b[38;5;241m.\u001b[39mn \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 576\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m start \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m freq\u001b[38;5;241m.\u001b[39mis_on_offset(start):\n\u001b[1;32m 577\u001b[0m \u001b[38;5;66;03m# for anchored negative frequencies, and `start` does not intersect with `freq`:\u001b[39;00m\n\u001b[1;32m 578\u001b[0m \u001b[38;5;66;03m# pandas (v2.2.1) generates an index that starts one step before `start` -> remove this step\u001b[39;00m\n", + "File \u001b[0;32m~/miniconda3/envs/darts310/lib/python3.10/site-packages/pandas/core/indexes/datetimes.py:1008\u001b[0m, in \u001b[0;36mdate_range\u001b[0;34m(start, end, periods, freq, tz, normalize, name, inclusive, unit, **kwargs)\u001b[0m\n\u001b[1;32m 1005\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m freq \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m com\u001b[38;5;241m.\u001b[39many_none(periods, start, end):\n\u001b[1;32m 1006\u001b[0m freq \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mD\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m-> 1008\u001b[0m dtarr \u001b[38;5;241m=\u001b[39m \u001b[43mDatetimeArray\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_generate_range\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1009\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstart\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1010\u001b[0m \u001b[43m \u001b[49m\u001b[43mend\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mend\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1011\u001b[0m \u001b[43m \u001b[49m\u001b[43mperiods\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mperiods\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1012\u001b[0m \u001b[43m \u001b[49m\u001b[43mfreq\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfreq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1013\u001b[0m \u001b[43m \u001b[49m\u001b[43mtz\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtz\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1014\u001b[0m \u001b[43m \u001b[49m\u001b[43mnormalize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnormalize\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1015\u001b[0m \u001b[43m \u001b[49m\u001b[43minclusive\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minclusive\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1016\u001b[0m \u001b[43m \u001b[49m\u001b[43munit\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43munit\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1017\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1018\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1019\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m DatetimeIndex\u001b[38;5;241m.\u001b[39m_simple_new(dtarr, name\u001b[38;5;241m=\u001b[39mname)\n", + "File \u001b[0;32m~/miniconda3/envs/darts310/lib/python3.10/site-packages/pandas/core/arrays/datetimes.py:463\u001b[0m, in \u001b[0;36mDatetimeArray._generate_range\u001b[0;34m(cls, start, end, periods, freq, tz, normalize, ambiguous, nonexistent, inclusive, unit)\u001b[0m\n\u001b[1;32m 460\u001b[0m end \u001b[38;5;241m=\u001b[39m end\u001b[38;5;241m.\u001b[39mtz_localize(\u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m 462\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(freq, Tick):\n\u001b[0;32m--> 463\u001b[0m i8values \u001b[38;5;241m=\u001b[39m \u001b[43mgenerate_regular_range\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstart\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mend\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mperiods\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfreq\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43munit\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43munit\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 464\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 465\u001b[0m xdr \u001b[38;5;241m=\u001b[39m _generate_range(\n\u001b[1;32m 466\u001b[0m start\u001b[38;5;241m=\u001b[39mstart, end\u001b[38;5;241m=\u001b[39mend, periods\u001b[38;5;241m=\u001b[39mperiods, offset\u001b[38;5;241m=\u001b[39mfreq, unit\u001b[38;5;241m=\u001b[39munit\n\u001b[1;32m 467\u001b[0m )\n", + "File \u001b[0;32m~/miniconda3/envs/darts310/lib/python3.10/site-packages/pandas/core/arrays/_ranges.py:75\u001b[0m, in \u001b[0;36mgenerate_regular_range\u001b[0;34m(start, end, periods, freq, unit)\u001b[0m\n\u001b[1;32m 73\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m istart \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m periods \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 74\u001b[0m b \u001b[38;5;241m=\u001b[39m istart\n\u001b[0;32m---> 75\u001b[0m e \u001b[38;5;241m=\u001b[39m \u001b[43m_generate_range_overflow_safe\u001b[49m\u001b[43m(\u001b[49m\u001b[43mb\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mperiods\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstride\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mside\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstart\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 76\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m iend \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m periods \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 77\u001b[0m e \u001b[38;5;241m=\u001b[39m iend \u001b[38;5;241m+\u001b[39m stride\n", + "File \u001b[0;32m~/miniconda3/envs/darts310/lib/python3.10/site-packages/pandas/core/arrays/_ranges.py:146\u001b[0m, in \u001b[0;36m_generate_range_overflow_safe\u001b[0;34m(endpoint, periods, stride, side)\u001b[0m\n\u001b[1;32m 140\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _generate_range_overflow_safe_signed(endpoint, periods, stride, side)\n\u001b[1;32m 142\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m (endpoint \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m side \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstart\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m stride \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m (\n\u001b[1;32m 143\u001b[0m endpoint \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;241m<\u001b[39m stride \u001b[38;5;129;01mand\u001b[39;00m side \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mend\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 144\u001b[0m ):\n\u001b[1;32m 145\u001b[0m \u001b[38;5;66;03m# no chance of not-overflowing\u001b[39;00m\n\u001b[0;32m--> 146\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m OutOfBoundsDatetime(msg)\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m side \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mend\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m endpoint \u001b[38;5;241m-\u001b[39m stride \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m i64max \u001b[38;5;241m<\u001b[39m endpoint:\n\u001b[1;32m 149\u001b[0m \u001b[38;5;66;03m# in _generate_regular_range we added `stride` thereby overflowing\u001b[39;00m\n\u001b[1;32m 150\u001b[0m \u001b[38;5;66;03m# the bounds. Adjust to fix this.\u001b[39;00m\n\u001b[1;32m 151\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _generate_range_overflow_safe(\n\u001b[1;32m 152\u001b[0m endpoint \u001b[38;5;241m-\u001b[39m stride, periods \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m, stride, side\n\u001b[1;32m 153\u001b[0m )\n", + "\u001b[0;31mOutOfBoundsDatetime\u001b[0m: Cannot generate range with start=1452211200000000000 and periods=2891280" + ] } ], "source": [ - "coverage = compute_residuals(cp_hist_fc, metric=metrics.ic)\n", - "coverage.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "3c845961-d07f-45f3-9a22-aa4dedf32b82", - "metadata": {}, - "source": [ - "# Not very informative, how about a windowed aggregation?" + "cal_test = concatenate([cal, test], axis=0)\n", + "hfcs = cp_model.historical_forecasts(\n", + " series=cal_test,\n", + " forecast_horizon=horizon,\n", + " start=test.start_time(),\n", + " last_points_only=False,\n", + " stride=horizon,\n", + " **pred_kwargs,\n", + ")" ] }, { "cell_type": "code", - "execution_count": 73, - "id": "29409d44-e5bd-484c-8ec6-54e61bcc6535", + "execution_count": 41, + "id": "4ebd1965-686f-4773-b964-f4a6aa619a3e", "metadata": {}, "outputs": [ { @@ -546,13 +550,13 @@ "" ] }, - "execution_count": 73, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -562,163 +566,58 @@ } ], "source": [ - "coverage.window_transform(\n", - " transforms={\"function\": \"mean\", \"mode\": \"rolling\", \"window\": 2 * 7 * 24}\n", - ").plot()" - ] - }, - { - "cell_type": "markdown", - "id": "2f794816-60da-4b43-8c15-39dc4c7af75d", - "metadata": {}, - "source": [ - "Not too bad. What about an expanding calibration length?" + "test[hfcs.start_time() :: horizon].plot()\n", + "hfcs.plot()" ] }, { "cell_type": "code", - "execution_count": 79, - "id": "ee3e7121-7091-42fa-a595-22f49384bff1", + "execution_count": 42, + "id": "73bf5226-e09b-447d-991d-f6efd71cbb7d", "metadata": {}, "outputs": [ { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "2ec12472a3f24df29ec9a18e40d86dad", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "historical forecasts: 0%| | 0/1 [00:00" - ] - }, - "execution_count": 79, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "cp_model = ConformalNaiveModel(model=model, quantiles=quantiles, cal_length=None)\n", - "\n", - "cp_hist_fc = cp_model.historical_forecasts(\n", - " series=ts_energy_val,\n", - " forecast_horizon=horizon,\n", - " stride=horizon,\n", - " last_points_only=False,\n", - " retrain=False,\n", - " verbose=True,\n", - " **pred_params,\n", - ")\n", - "cp_hist_fc = concatenate(cp_hist_fc)\n", - "print(compute_backtest(cp_hist_fc))\n", - "coverage = compute_residuals(cp_hist_fc, metric=metrics.ic)\n", - "coverage.window_transform(\n", - " transforms={\"function\": \"mean\", \"mode\": \"rolling\", \"window\": 2 * 7 * 24}\n", - ").plot()" - ] - }, - { - "cell_type": "markdown", - "id": "d6067bce-628e-44af-b9b5-7463597d5aac", - "metadata": {}, - "source": [ - "Okay we're getting closer. Also, interesting to see the coverage drop for the smaller interval, but not for the large one.\n", - "This is (for the lower) because the calibration set is expanding, and our calibration cannot react to distribution shifts quickly anymore." - ] - }, - { - "cell_type": "markdown", - "id": "795afb75-e70e-4a58-aa28-500279d221fe", - "metadata": {}, - "source": [ - "### Improving the underlying forecasting model\n", - "Let's add the day of the week to our forecasting model, see if it gets more accuracte, and what the influence is on our conformal model." + "cp_model.backtest(\n", + " cal_test,\n", + " historical_forecasts=hfcs,\n", + " last_points_only=True,\n", + " metric=[metrics.mic, metrics.miw],\n", + " metric_kwargs={\"q_interval\": q_interval},\n", + ")" ] }, { "cell_type": "code", - "execution_count": 88, - "id": "19e9ca2b-b4e2-4c09-8a88-b084a92b0712", + "execution_count": 52, + "id": "da696430-0bea-4adf-8bb4-5315e4a18ca1", "metadata": {}, "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "957bf3a80e324e7cb06f43ff73d2b082", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "historical forecasts: 0%| | 0/1 [00:00" ] }, - "execution_count": 88, + "execution_count": 52, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -726,51 +625,45 @@ } ], "source": [ - "input_length = 24\n", - "horizon = 24\n", - "\n", - "model = LinearRegressionModel(\n", - " lags=input_length,\n", - " lags_future_covariates=(input_length, horizon),\n", - " output_chunk_length=horizon,\n", - " add_encoders={\"cyclic\": {\"future\": [\"dayofweek\"]}},\n", - ")\n", - "model.fit(ts_energy_train)\n", - "hist_fc = model.historical_forecasts(\n", - " series=ts_energy_val,\n", - " forecast_horizon=horizon,\n", - " stride=horizon,\n", - " last_points_only=False,\n", - " retrain=False,\n", - " verbose=True,\n", - ")\n", - "hist_fc = concatenate(hist_fc)\n", - "print(metrics.mae(ts_energy_val, hist_fc))\n", - "\n", - "fig, ax = plt.subplots(figsize=(12, 6))\n", - "end_ts = ts_energy_val.start_time() + 2 * 7 * horizon * ts_energy_val.freq\n", - "ts_energy_val[:end_ts].plot()\n", - "hist_fc[:end_ts].plot()" + "cp_model.residuals(\n", + " cal_test,\n", + " historical_forecasts=hfcs,\n", + " last_points_only=True,\n", + " metric=metrics.ic,\n", + " metric_kwargs={\"q_interval\": q_interval},\n", + ").window_transform(\n", + " transforms={\"function\": \"mean\", \"mode\": \"rolling\", \"window\": 30}\n", + ").plot()" ] }, { - "cell_type": "markdown", - "id": "cd75baab-45b5-4314-bc7f-cbc4a0934e25", + "cell_type": "code", + "execution_count": null, + "id": "9dc2c2e3-77ed-45ad-bd9a-4c8cb43c7e47", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93341487-6325-4901-a5fc-f86e26e122f4", "metadata": {}, + "outputs": [], "source": [ - "Forecast error is lower with the new model. And the conformal model?" + "cp_model" ] }, { "cell_type": "code", - "execution_count": 94, - "id": "0a297b7e-36be-4da7-96a1-3c37561b7e57", + "execution_count": 53, + "id": "c6189382-1357-444e-91b0-206e0a14a386", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "544d62d2555b422a90b6743a59554577", + "model_id": "5b88126a4a734eb2a30972372010c510", "version_major": 2, "version_minor": 0 }, @@ -784,39 +677,20 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "55ba47206b5245ada90924272ce3e811", + "model_id": "6ac66c014bbf411ca36cc230ae777239", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "conformal forecasts: 0%| | 0/90 [00:00" - ] - }, - "execution_count": 94, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -826,32 +700,40 @@ } ], "source": [ - "cp_model = ConformalNaiveModel(model=model, quantiles=quantiles, cal_length=None)\n", + "quantiles = [0.05, 0.1, 0.5, 0.9, 0.95]\n", + "cp_model = ConformalNaiveModel(\n", + " model=model, quantiles=quantiles, cal_stride=7 * 24, cal_length=52\n", + ")\n", "\n", - "cp_hist_fc = cp_model.historical_forecasts(\n", - " series=ts_energy_val,\n", - " forecast_horizon=horizon,\n", - " stride=horizon,\n", - " last_points_only=False,\n", - " retrain=False,\n", + "pred = cp_model.historical_forecasts(\n", + " n=horizon,\n", + " series=concatenate([cal, test], axis=0),\n", + " cal_stride=24,\n", " verbose=True,\n", - " **pred_params,\n", + " predict_likelihood_parameters=True,\n", ")\n", - "cp_hist_fc = concatenate(cp_hist_fc)\n", - "print(compute_backtest(cp_hist_fc))\n", - "coverage = compute_residuals(cp_hist_fc, metric=metrics.ic)\n", - "coverage.window_transform(\n", - " transforms={\"function\": \"mean\", \"mode\": \"rolling\", \"window\": 2 * 7 * 24}\n", - ").plot()" + "series[pred.start_time() - 3 * 24 * series.freq : pred.end_time()].plot(label=\"actual\")\n", + "pred.plot(label=\"pred\");" ] }, { "cell_type": "markdown", - "id": "b221557f-f4ee-4488-b137-b43743546f00", + "id": "05fc7f3a-b84b-4f1f-9dae-f31e791d7fed", "metadata": {}, "source": [ - "Lower interval widths shile almost having the same coverage, nice. ...WIP" + "## Sources\n", + "\n", + "(1) Lei, J., G’Sell, M., Rinaldo, A., Tibshirani, R. J., and Wasserman, L. (2018). Distribution-Free Predictive Inference\n", + "for Regression. Journal of the American Statistical Association, 113(523):1094–1111." ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "af06f43a-db6c-4c72-b116-bdb0d7e2af95", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -870,11 +752,592 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.15" + "version": "3.10.16" }, "widgets": { "application/vnd.jupyter.widget-state+json": { - "state": {}, + "state": { + "0315f3b861154f7ea31e69b8327b1403": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_da0ea0405a89477fa56f452a60194789", + "IPY_MODEL_8a8d50f3a88c4f29b0e2b5eba86adc9d", + "IPY_MODEL_c3e21021a388404ab7bcbb10ab2f8963" + ], + "layout": "IPY_MODEL_7bf5adea7d914c67b2a9a95867c43d9b" + } + }, + "03caca835e154a0b85c3d0008f127866": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_fe3caca7e6ec473981fd126defc803a3", + "style": "IPY_MODEL_6e5b45695f4a4815bf289251628e5539", + "value": " 1/1 [00:04<00:00,  4.06s/it]" + } + }, + "058d4c250d464958b05c09ee2ed499eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_90d1e145713c433e8ca195e10b428ea6", + "style": "IPY_MODEL_3b55aac6712e491ebb0e37ec0c9f6c87", + "value": "historical forecasts:   0%" + } + }, + "10b8d7ecf0284f41a16d82235a8b21a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_d5dd3401a8f64245a33dd517e5784bd4", + "style": "IPY_MODEL_62822d972503475595e6ea6263ea290d", + "value": " 0/1 [00:00<?, ?it/s]" + } + }, + "11943bf241664740bd1053f67dbe8564": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "1296f2037fee46fd83348c7d2fa1c87e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "137fc19c91bf4b64b7a515453093b66a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_11943bf241664740bd1053f67dbe8564", + "style": "IPY_MODEL_b6b5a49421334963a4955f739ef9a31d", + "value": "historical forecasts:   0%" + } + }, + "1c4f38597cc545539de6e0ee478bbcb1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "1e2c668e9cef4f67b636126ce872cde2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "209a43c2798f4069a7f056fced6fee77": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "22c2a074ea454b7ab79cf043a9008d98": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "2d73109fc900495e82b057f0f6cb9604": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "3130234afc9a4c21bc9896ca209199b1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "32539f19f91e41a5ba6b273a2a64cf5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_137fc19c91bf4b64b7a515453093b66a", + "IPY_MODEL_6035795ca3c440dba5118015de4b973d", + "IPY_MODEL_10b8d7ecf0284f41a16d82235a8b21a9" + ], + "layout": "IPY_MODEL_dda9eec3a6684099a1d5c87206f7614d" + } + }, + "3277bf058d534088a1986ccec9f28e5e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_5ddfbdb6966a452e9a74e802235e3446", + "style": "IPY_MODEL_b686cede79d24eb2b99fb9312d8c8c3b", + "value": "conformal forecasts: 100%" + } + }, + "33dee21d622c47a6a936ffa4f83e3534": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "danger", + "layout": "IPY_MODEL_559e83fe281142638a7675f4f0c8294c", + "max": 1, + "style": "IPY_MODEL_c46f1ffc6c064902a87133dfbf7d94cb" + } + }, + "38ce5c256b1c4436886a2cba707e07a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_8c4f3e5fe95d4967bcb9b032ddd7cdc8", + "IPY_MODEL_e7aee37700254593be130f114d7c1539", + "IPY_MODEL_03caca835e154a0b85c3d0008f127866" + ], + "layout": "IPY_MODEL_d394490469e5468591e0f3f5ec3c0316" + } + }, + "3b55aac6712e491ebb0e37ec0c9f6c87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "47bbcbd7d54248249477c3bdaecf2011": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "4c1f0d94db0344529a8449b44be3f18f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_dc59909465b540e29b432f2916688fd7", + "max": 1, + "style": "IPY_MODEL_991cd91551ee45858cccbbfab649e07d", + "value": 1 + } + }, + "4e828a795e26409482288d4523bb48b2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_9a469e862e5542c1bdccbdbc2191dc3f", + "style": "IPY_MODEL_99c1229b14c345a2b5bb831e99f5991a", + "value": " 0/1 [00:00<?, ?it/s]" + } + }, + "522a06e4c65c4bed8f437ae91e073555": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_2d73109fc900495e82b057f0f6cb9604", + "max": 1, + "style": "IPY_MODEL_22c2a074ea454b7ab79cf043a9008d98", + "value": 1 + } + }, + "52ab2d9d95e34e5f8da0260cd59978dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "559e83fe281142638a7675f4f0c8294c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "5c613752ead44de8bca546b0df625c7f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "5ddfbdb6966a452e9a74e802235e3446": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "6035795ca3c440dba5118015de4b973d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "danger", + "layout": "IPY_MODEL_957e3a42996d4fa5ade679f5e013888f", + "max": 1, + "style": "IPY_MODEL_7c7458c42e614d4c818641a190289ac2" + } + }, + "62822d972503475595e6ea6263ea290d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6e5b45695f4a4815bf289251628e5539": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "70db0b349be64e1a81ff96489f3bdd08": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_7a561d8b38a54be58362655deabbc3e7", + "style": "IPY_MODEL_a73503ffc6014fafb6bfae8be9b5dc9d", + "value": " 1/1 [00:00<00:00, 51.18it/s]" + } + }, + "7a561d8b38a54be58362655deabbc3e7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "7bf5adea7d914c67b2a9a95867c43d9b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "7c7458c42e614d4c818641a190289ac2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "8568f2ee147147cb8f4bbc549ba340f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8808260dc5614e889700e6ae856bf905": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "8a8d50f3a88c4f29b0e2b5eba86adc9d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_47bbcbd7d54248249477c3bdaecf2011", + "max": 1, + "style": "IPY_MODEL_1296f2037fee46fd83348c7d2fa1c87e", + "value": 1 + } + }, + "8afff452de3e444f8459f9769e2c564f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_058d4c250d464958b05c09ee2ed499eb", + "IPY_MODEL_33dee21d622c47a6a936ffa4f83e3534", + "IPY_MODEL_4e828a795e26409482288d4523bb48b2" + ], + "layout": "IPY_MODEL_8808260dc5614e889700e6ae856bf905" + } + }, + "8c4f3e5fe95d4967bcb9b032ddd7cdc8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_b68282625b71498aa81ec2653ec4d57f", + "style": "IPY_MODEL_908523b4798d426ab7d534985d19e93c", + "value": "historical forecasts: 100%" + } + }, + "908523b4798d426ab7d534985d19e93c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "90d1e145713c433e8ca195e10b428ea6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "957e3a42996d4fa5ade679f5e013888f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "991cd91551ee45858cccbbfab649e07d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "99c1229b14c345a2b5bb831e99f5991a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "9a469e862e5542c1bdccbdbc2191dc3f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "9da79419a6c84b06bd57b07e843cea12": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_c324252091684b009e1943267ece0ae4", + "IPY_MODEL_522a06e4c65c4bed8f437ae91e073555", + "IPY_MODEL_70db0b349be64e1a81ff96489f3bdd08" + ], + "layout": "IPY_MODEL_e02393c0493747bfa22633199b7e56ea" + } + }, + "a73503ffc6014fafb6bfae8be9b5dc9d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b06eae10c3b84586bbf9c2ecab1f350a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b68282625b71498aa81ec2653ec4d57f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b686cede79d24eb2b99fb9312d8c8c3b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b6b5a49421334963a4955f739ef9a31d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c324252091684b009e1943267ece0ae4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_209a43c2798f4069a7f056fced6fee77", + "style": "IPY_MODEL_d8e32bbb4aaa406eab210f07e0d385b2", + "value": "conformal forecasts: 100%" + } + }, + "c3e21021a388404ab7bcbb10ab2f8963": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_5c613752ead44de8bca546b0df625c7f", + "style": "IPY_MODEL_1e2c668e9cef4f67b636126ce872cde2", + "value": " 1/1 [00:04<00:00,  4.06s/it]" + } + }, + "c46f1ffc6c064902a87133dfbf7d94cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "d394490469e5468591e0f3f5ec3c0316": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "d40df78c6c98420a9d64c0e118211cd1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d47be6489e08407ba64475239b2dc30a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "d5dd3401a8f64245a33dd517e5784bd4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "d8e32bbb4aaa406eab210f07e0d385b2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "da0ea0405a89477fa56f452a60194789": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_b06eae10c3b84586bbf9c2ecab1f350a", + "style": "IPY_MODEL_d40df78c6c98420a9d64c0e118211cd1", + "value": "historical forecasts: 100%" + } + }, + "dc59909465b540e29b432f2916688fd7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "dda9eec3a6684099a1d5c87206f7614d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "ddd1815131d246bab164c6d4d41e51ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_3277bf058d534088a1986ccec9f28e5e", + "IPY_MODEL_4c1f0d94db0344529a8449b44be3f18f", + "IPY_MODEL_e457294c8d0a4424b640aa2b8bbd61a7" + ], + "layout": "IPY_MODEL_3130234afc9a4c21bc9896ca209199b1" + } + }, + "e02393c0493747bfa22633199b7e56ea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "e457294c8d0a4424b640aa2b8bbd61a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_d47be6489e08407ba64475239b2dc30a", + "style": "IPY_MODEL_8568f2ee147147cb8f4bbc549ba340f0", + "value": " 1/1 [00:00<00:00, 43.37it/s]" + } + }, + "e7aee37700254593be130f114d7c1539": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_52ab2d9d95e34e5f8da0260cd59978dc", + "max": 1, + "style": "IPY_MODEL_1c4f38597cc545539de6e0ee478bbcb1", + "value": 1 + } + }, + "fe3caca7e6ec473981fd126defc803a3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + } + }, "version_major": 2, "version_minor": 0 } From 0a80d2334757a63bb3b889d65e1f6e60b789bcec Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 20 Dec 2024 17:11:46 +0100 Subject: [PATCH 75/78] add conformal prediction notebook --- .github/workflows/merge.yml | 2 +- docs/source/examples.rst | 9 + .../23-Conformal-Prediction-examples.ipynb | 2580 +++++++++++++---- 3 files changed, 2094 insertions(+), 497 deletions(-) diff --git a/.github/workflows/merge.yml b/.github/workflows/merge.yml index e3dd873956..b74cd0a26f 100644 --- a/.github/workflows/merge.yml +++ b/.github/workflows/merge.yml @@ -80,7 +80,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - example-name: [00-quickstart.ipynb, 01-multi-time-series-and-covariates.ipynb, 02-data-processing.ipynb, 03-FFT-examples.ipynb, 04-RNN-examples.ipynb, 05-TCN-examples.ipynb, 06-Transformer-examples.ipynb, 07-NBEATS-examples.ipynb, 08-DeepAR-examples.ipynb, 09-DeepTCN-examples.ipynb, 10-Kalman-filter-examples.ipynb, 11-GP-filter-examples.ipynb, 12-Dynamic-Time-Warping-example.ipynb, 13-TFT-examples.ipynb, 15-static-covariates.ipynb, 16-hierarchical-reconciliation.ipynb, 18-TiDE-examples.ipynb, 19-EnsembleModel-examples.ipynb, 20-RegressionModel-examples.ipynb, 21-TSMixer-examples.ipynb, 22-anomaly-detection-examples.ipynb] + example-name: [00-quickstart.ipynb, 01-multi-time-series-and-covariates.ipynb, 02-data-processing.ipynb, 03-FFT-examples.ipynb, 04-RNN-examples.ipynb, 05-TCN-examples.ipynb, 06-Transformer-examples.ipynb, 07-NBEATS-examples.ipynb, 08-DeepAR-examples.ipynb, 09-DeepTCN-examples.ipynb, 10-Kalman-filter-examples.ipynb, 11-GP-filter-examples.ipynb, 12-Dynamic-Time-Warping-example.ipynb, 13-TFT-examples.ipynb, 15-static-covariates.ipynb, 16-hierarchical-reconciliation.ipynb, 18-TiDE-examples.ipynb, 19-EnsembleModel-examples.ipynb, 20-RegressionModel-examples.ipynb, 21-TSMixer-examples.ipynb, 22-anomaly-detection-examples.ipynb, 23-Conformal-Prediction-examples.ipynb] steps: - name: "Clone repository" uses: actions/checkout@v4 diff --git a/docs/source/examples.rst b/docs/source/examples.rst index fe68dd1e1a..4efe4c1b53 100644 --- a/docs/source/examples.rst +++ b/docs/source/examples.rst @@ -86,6 +86,15 @@ Regression models example notebook: examples/20-RegressionModel-examples.ipynb +Conformal Prediction +================= + +Conformal prediction example notebook: + +.. toctree:: + :maxdepth: 1 + + examples/23-Conformal-Prediction-examples.ipynb Fast Fourier Transform ====================== diff --git a/examples/23-Conformal-Prediction-examples.ipynb b/examples/23-Conformal-Prediction-examples.ipynb index 9b4ba3fee0..59ae686263 100644 --- a/examples/23-Conformal-Prediction-examples.ipynb +++ b/examples/23-Conformal-Prediction-examples.ipynb @@ -7,12 +7,22 @@ "source": [ "# Conformal Prediction Models\n", "\n", - "The following is a demonstration of the conformal prediciton models in Darts." + "The following is a demonstration of the conformal prediction models in Darts.\n", + "\n", + "TLDR;\n", + "\n", + "- Conformal prediction in Darts constructs valid prediction intervals without distributional assumptions.\n", + "- We use Split Conformal Prediction (SCP) due to its simplicity and efficiency.\n", + "- You can apply conformal prediction to any pre-trained global forecasting model.\n", + "- To improve your experience, our conformal models automatically extract the relevant calibration data from your input series required to generate the interval.\n", + "- We offer useful features to configure the extraction and make your conformal models more adaptive and efficient (`cal_length`, `cal_stride`).\n", + "- Conformal prediction supports all use cases (uni- and multivariate, single and multiple series, and single and multi-horizon forecasts, providing direct quantile value predictions or sampled predictions).\n", + "- We'll demonstrate how to use and evaluate conformal prediction on four examples using real-world data." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "3ef9bc25-7b86-4de5-80e9-6eff27025b44", "metadata": {}, "outputs": [], @@ -25,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "9d9d76e9-5753-4762-a1cb-c8c61d0313d2", "metadata": {}, "outputs": [], @@ -33,11 +43,13 @@ "%load_ext autoreload\n", "%autoreload 2\n", "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", "import pandas as pd\n", "\n", "from darts import concatenate, metrics\n", "from darts.datasets import ElectricityConsumptionZurichDataset\n", - "from darts.models import ConformalNaiveModel, LinearRegressionModel" + "from darts.models import ConformalNaiveModel, ConformalQRModel, LinearRegressionModel" ] }, { @@ -51,7 +63,7 @@ "\n", "In other words: If we want a prediction interval that includes 80% of all actual values over some period of time, then a conformal model attempts to generate such intervals that actually have 80% of points inside.\n", "\n", - "There are different techniques to perform conformal prediction. In Darts, we currently use **Split Conformal Prediciton [(SCP, Lei\n", + "There are different techniques to perform conformal prediction. In Darts, we currently use **Split Conformal Prediction [(SCP, Lei\n", "et al., 2018)](https://www.stat.cmu.edu/~ryantibs/papers/conformal.pdf)** (with some nice adaptions) due to its simplicity and efficiency. \n", "\n", "### Split Conformal Prediction\n", @@ -64,9 +76,9 @@ " - Either adds calibrated prediction intervals to point forecasting models\n", " - Or calibrates the predicted intervals in case of probabilistic forecasting models\n", "- **Distribution-free**: No distributional assumptions about the data except that the errors on the calibration set are exchangeable (e.g. we don't need to assume that our data is normally distributed and then fit a model with a `GaussianLikelihood`).\n", - "- **Efficient**: Split Conformal Prediciton is very efficient since it does not require model re-training.\n", - "- **Interpretable**: The method is interpretable due its simplicity.\n", - "- **Useful Applications**: It's used to provide more reliable and informative predictions to help decision making in several industry. See this [article on conformal prediction](https://medium.com/@data-overload/conformal-prediction-a-critic-to-predictive-models-27501dcc76d4)\n", + "- **Efficient**: Split Conformal Prediction is efficient since it does not require model re-training.\n", + "- **Interpretable**: The method is interpretable due to its simplicity.\n", + "- **Useful Applications**: It's used to provide more reliable and informative predictions to help decision-making in several industries. See this [article on conformal prediction](https://medium.com/@data-overload/conformal-prediction-a-critic-to-predictive-models-27501dcc76d4)\n", "\n", "#### Disadvantages\n", "\n", @@ -74,7 +86,7 @@ "- **Exchangeability of Calibration Data (*)**: The accuracy of the prediction intervals depends on the representativeness of the calibration data (or rather the forecast errors produced on the calibration set). The coverage is not guaranteed anymore if there is a **distribution shift** in forecast errors (e.g. series with a trend but forecasting model is not able to predict the trend).\n", "- **Conservativeness (*)**: May produce wider intervals than necessary, leading to conservative predictions.\n", "\n", - "(*) Darts conformal models have some parameters to control the extraction of the calibration set for more adaptiveness." + "(*) Darts conformal models have some parameters to control the extraction of the calibration set for more adaptiveness (see more infos [here](#Darts'-features-to-make-your-Conformal-Models-more-adaptive))." ] }, { @@ -84,19 +96,11 @@ "source": [ "## Darts Conformal Models\n", "\n", - "Darts' conformal models add calibrated prediciton intervals to the forecasts of any **pre-trained global forecasting model**. \n", - "There is no need to train the conformal models themselves (e.g. no `fit()` requried) and you can directly call `predict()` or `historical_forecasts()`. Behind the hood, Darts will automatically extract the calibration set from the past of your input series and use it to generate the calibrated prediction intervals (see [here](#Workflow-behind-the-hood) for more detail).\n", + "Darts' conformal models add calibrated prediction intervals to the forecasts of any **pre-trained global forecasting model**. \n", + "There is no need to train the conformal models themselves (e.g. no `fit()` required) and you can directly call `predict()` or `historical_forecasts()`. Behind the hood, Darts will automatically extract the calibration set from the past of your input series and use it to generate the calibrated prediction intervals (see [here](#Workflow-behind-the-hood) for more detail).\n", "\n", "> **Important**: The `series` passed to the forecast methods **should not have any overlap** with the series used to **train** the forecasting model, since this will lead to overly optimistic prediction intervals.\n", "\n", - "### Direct Interval Bound Predictions or Sampled Predictions\n", - "Conformal models are probabilistic, so you can forecast in two ways (when calling `predict()`, `historical_forecasts()`, ...):\n", - "\n", - "- Forecast the calibrated quantile interval bounds directly (example [here](https://unit8co.github.io/darts/quickstart/00-quickstart.html#Direct-Parameter-Predicitons)).\n", - " - `predict(..., predict_likelihood_parameters=True)`\n", - "- Generate stochastic forecasts by sampling from these calibrated quantile intervals (examples [here](https://unit8co.github.io/darts/quickstart/00-quickstart.html#Probabilistic-Sample-Predictions)):\n", - " - `predict(..., num_samples=1000)`\n", - "\n", "### Model support\n", "\n", "All conformal models in Darts support:\n", @@ -109,12 +113,22 @@ "- **direct quantile value** predictions (interval bounds) or **sampled predictions** from these quantile values\n", "- **any covariates** based on the underlying forecasting model\n", "\n", + "### Direct Interval Predictions or Sampled Predictions\n", + "Conformal models are probabilistic, so you can forecast in two ways (when calling `predict()`, `historical_forecasts()`, ...):\n", + "\n", + "- Forecast the calibrated quantile interval bounds directly (example [here](https://unit8co.github.io/darts/quickstart/00-quickstart.html#Direct-Parameter-Predicitons)).\n", + " - `predict(..., predict_likelihood_parameters=True)`\n", + "- Generate stochastic forecasts by sampling from these calibrated quantile intervals (examples [here](https://unit8co.github.io/darts/quickstart/00-quickstart.html#Probabilistic-Sample-Predictions)):\n", + " - `predict(..., num_samples=1000)`\n", + "\n", "### Workflow behind the hood\n", "\n", - "In general the workflow of the models to produce one calibrated forecast/prediction is as follows (using `predict()`):\n", + "> Note: `cal_length` and `cal_stride` will be further explained [below](#Darts'-features-to-make-your-Conformal-Models-more-adaptive).\n", + "\n", + "In general, the workflow of the models to produce one calibrated forecast/prediction is as follows (using `predict()`):\n", "\n", "- **Extract a calibration set**: The calibration set for each conformal forecast is automatically extracted from\n", - " the past of your input series relative to the forecast start point. The number of calibration examples\n", + " the most recent past of your input series relative to the forecast start point. The number of calibration examples\n", " (forecast errors / non-conformity scores) to consider can be defined at model creation\n", " with parameter `cal_length`. Note that when using `cal_stride>1`, a longer history is required since\n", " the calibration examples are generated with stridden historical forecasts.\n", @@ -129,14 +143,13 @@ "\n", "When computing `historical_forecasts()`, `backtest()`, `residuals()`, ... the above is applied for each forecast (the forecasting model's historical forecasts are only generated once for efficiency).\n", "\n", - "\n", "### Available Conformal Models\n", "\n", "At the time of writing (Darts version 0.32.0), we have two conformal models:\n", "\n", "#### `ConformalNaiveModel`\n", "\n", - "Adds calibrated intervals around the median forecast from **any pre-trained global forecasting model**. It supports two symmetry modes:\n", + "Adds calibrated intervals around the median forecast of **any pre-trained global forecasting model**. It supports two symmetry modes:\n", "\n", "- `symmetric=True`:\n", " - The lower and upper interval bounds are calibrated with the same magnitude.\n", @@ -148,14 +161,33 @@ "\n", "#### `ConformalQRModel` (Conformalized Quantile Regression Model)\n", "\n", - "Calibrates the quantile predictions from a **pre-trained probabilistic global forecasting model**. It supports two symmetry modes:\n", + "Calibrates the quantile predictions of a **pre-trained probabilistic global forecasting model**. It supports two symmetry modes:\n", "\n", "- `symmetric=True`:\n", " - The lower and upper quantile predictions are calibrated with the same magnitude.\n", " - Non-conformity scores: uses the [Non-Conformity Score for Quantile Regression `incs_qr(symmetric=True)`](https://unit8co.github.io/darts/generated_api/darts.metrics.metrics.html#darts.metrics.metrics.incs_qr) on the calibration set.\n", "- `symmetric=False`\n", " - The lower and upper quantile predictions are calibrated separately.\n", - " - Non-conformity scores: uses the [Asymmetric Non-Conformity Score for Quantile Regression `incs_qr(symmetric=False)`](https://unit8co.github.io/darts/generated_api/darts.metrics.metrics.html#darts.metrics.metrics.incs_qr) for the upper and lower bound on the calibration set." + " - Non-conformity scores: uses the [Asymmetric Non-Conformity Score for Quantile Regression `incs_qr(symmetric=False)`](https://unit8co.github.io/darts/generated_api/darts.metrics.metrics.html#darts.metrics.metrics.incs_qr) for the upper and lower bound on the calibration set.\n", + "\n", + "### Darts' features to make your Conformal Models more adaptive\n", + "\n", + "As mentioned in [Split Conformal Prediction - Disadvantages](#Disadvantages), the calibration set has a large impact on the effectiveness of our conformal prediction technique.\n", + "\n", + "We implemented some cool features to make our automatic extraction of the calibration set even more powerful for you.\n", + "\n", + "All our conformal models have the following two parameters at model creation:\n", + "\n", + "- `cal_length`: The number of non-conformity scores (NCS) in the most recent past to use as calibration for each conformal forecast (and each step in the horizon).\n", + " - If `None` acts as an expanding window mode\n", + " - If `>=1` uses a moving fixed-length window mode\n", + " - Benefits:\n", + " - Using `cal_length` makes your model react more quickly to distribution shifts in NCS.\n", + " - Using `cal_length` reduces the computational cost to perform the calibration.\n", + " - Caution: Use large enough values to have enough example for calibration.\n", + "- `cal_stride`: (default=1) The stride (number of time steps between two consecutive forecasts) to apply when computing the historical forecasts and non-conformity scores on the calibration set.\n", + " - This is useful if we want to run our models on a scheduled basis (e.g. once every 24 hours) and are only interested in the NCS that were produced on this schedule.\n", + " - Caution: `cal_stride>1` requires a longer `series` history (roughly `cal_length * stride` points)." ] }, { @@ -163,12 +195,21 @@ "id": "eacf6328-6b51-43e9-8b44-214f5df15684", "metadata": {}, "source": [ + "## Examples:\n", + "\n", + "We will show four examples:\n", + "\n", + "1) How to perform conformal prediction and compare different models based on the quantified uncertainty. For simplicity, we will use a single step horizon `n=1`.\n", + "2) How to perform multistep horizon conformal forecasts\n", + "3) How to perform multistep horizon conformal forecasts on a scheduled basis\n", + "4) An example of conformalized quantile regression.\n", + "\n", "### Input Dataset\n", - "For this notebook, we use the Electricity Consumption Dataset from households in Zurich, Switzerland.\n", + "For both examples, we use the Electricity Consumption Dataset from households in Zurich, Switzerland.\n", "\n", "The dataset has a quarter-hourly frequency (15 Min time intervals), but we resample it to hourly frequency to keep things simple.\n", "\n", - "To keep it simple, we will not use any covariates and only concentrate on the electricty consumption as the target we want to predict. The conformal model's covariate support and API is identical to the base-forecaster.\n", + "To keep it simple, we will not use any covariates and only concentrate on the electricity consumption as the target we want to predict. The conformal model's covariate support and API is identical to the base-forecaster.\n", "\n", "**Target series** (the series we want to forecast):\n", "- **Value_NE5**: Electricity consumption by households on grid level 5 (in kWh)." @@ -176,23 +217,13 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "90b31843-8f60-4dd8-b6e4-87206d67e585", "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkYAAAHECAYAAADcTeUiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADTlklEQVR4nOydeXgTxf/H35v0TlsopVDOQimnXOUUFRAQxQKicqmgHIIoeICgIj9BUEAQEU9AkcODL+CBRxUQECmogIAICFQoZymUo6UtTdOmTeb3R9ztbK7uJrvZpJ3X8/CwzbEzu9mdfc/785kZjhBCwGAwGAwGg8GATusKMBgMBoPBYPgLTBgxGAwGg8Fg/AcTRgwGg8FgMBj/wYQRg8FgMBgMxn8wYcRgMBgMBoPxH0wYMRgMBoPBYPwHE0YMBoPBYDAY/8GEEYPBYDAYDMZ/MGHEYDAYDAaD8R9MGDEAABzHSfq3c+dOrasq4vjx45g9ezbOnTundVVEzJ49GxzHaVL22LFj0a9fP+Hvc+fOuf1NZ8+eLXx29OjRaNSokWp127Rpk6g8qdjXUwr8ca9Zs0Z47Y8//sDs2bORl5cnuw5SSE1NxcCBA1G7dm2EhISgRo0a6NOnD9auXYvS0lJVygxk3N2/al+LAPDLL78gMjISWVlZqpbjiv/973945513NCmbZ+nSpaJ7hAGAMBiEkD179oj+paSkkPDwcIfX8/Pzta6qiK+++ooAIL/++qvWVRGRmZlJ9uzZ4/Ny//rrL6LT6cj+/fuF186ePUsAkGeeecbh99yzZw/JzMwUPjtq1CiSkJCgWv0mTZpEPGl27OspheLiYrJnzx5y9epV4bVFixYRAOTs2bOy6+AOq9VKRo8eTQCQlJQU8sUXX5C0tDTyww8/kClTppDo6GjyzjvvKFpmZcDd/ZuRkUH++usv1evQq1cv8thjj6lejjP69++v6v0mhVtuuYX07NlT0zr4G0FaijKG/3DrrbeK/o6Li4NOp3N43VOKiooQERGhyL78Gf4469evj/r16/u8/AULFqBLly7o1KmTw3sNGzZU7Pf0BYQQFBcXIzw83KN6h4aG+ux4Fy1ahDVr1mDOnDmYNWuW6L2BAwfixRdfREZGhk/qUllo0qSJT8qZNGkShg8fjrlz56JBgwY+KdMTLBYLysrKEBoaqnVVKj9aKzOGfzJq1ChiMBhEr33wwQeke/fuJC4ujkRERJDWrVuThQsXErPZLPpcz549yS233ELS0tJIt27dSHh4OBk+fDghxOakDB48mERGRpJq1aqRRx55hPz5558EAFm9erVoP/v37ycDBw4kMTExJDQ0lLRv355s2LBBeH/16tUEgMM/+/3QXL16lYwfP57Ur1+fhISEkJo1a5LbbruNbNu2TfS5bdu2kd69e5OoqCgSHh5ObrvtNrJ9+3bRZ1599VUCgBw8eJAMHjyYVK9encTHx4ves2f9+vXk1ltvJREREcRgMJC7777boVd8+vRpMnz4cFKnTh0SEhJCatWqRXr37k0OHTrk8rgIISQ7O5sEBweTDz/8UPQ67xgtWrTI7fcJce4YWa1W8uGHH5J27dqRsLAwUr16dTJ48GBy+vRph+9v3ryZ9O7dm0RHR5Pw8HDSokULMn/+fGHfzn4v3r0BQCZNmkSWLVtGWrRoQYKDg8myZcuE91599VVRWRcvXhR+y+DgYFKnTh0yePBgkp2dLTpu/nrgfxP7f7/++isZO3YsiYmJIUaj0eGYevXqRVq1auXynJnNZlKjRg3SokULYrVaKzzHhBCSk5NDnnrqKVK3bl0SHBxMGjduTGbMmEGKi4tFn+PPyWeffUZatGhBwsPDSdu2bUlqaqroc1Ku64SEBDJq1CiHuvTs2VPkGPz6668EAFm7di158cUXSXx8PDEYDGTAgAEkOzubFBQUkPHjx5PY2FgSGxtLRo8eTW7evOm03suXLydNmzYlISEhpGXLlmTdunXCZyq6f51diyaTiUyfPp00atSIBAcHk7p165KJEyeSGzduiD6XkJBA+vfvTzZv3kySk5NJWFgYad68OVm5cqXD8ZeUlJBq1aqRmTNnOrznjIrapWvXrpH69euTbt26idrGY8eOkYiICDJy5EjhvDs7fkLKr92FCxeS119/nTRq1Ijo9XqyefNmYjKZyPPPP0/atWtHoqOjSUxMDLn11lvJd99951BXi8VC3nvvPeHerVatGunatSv5/vvvhfNkX77WDpY/wIQRwynOhNGUKVPIsmXLyJYtW8iOHTvIkiVLSM2aNcmYMWNEn+vZsyepUaMGadCgAXn//ffJr7/+StLS0khhYSFJSkoiNWrUIB9++CH5+eefyZQpU0jjxo0dBM2OHTtISEgI6d69O9mwYQPZsmWLEKrgP3f16lUyf/58AoB8+OGHQmiIDp3Yc88995C4uDjy8ccfk507d5LvvvuOzJo1i6xfv174zOeff044jiP3338/2bhxI0lNTSUDBgwger1eJI74B21CQgJ56aWXyLZt24TGyZkwmjdvHuE4jowdO5b8+OOPZOPGjaRbt27EYDCQY8eOCZ9r3rw5SUpKIp9//jlJS0sj33zzDZk6dWqF4cLPPvuMACDHjx8XvU43sqWlpQ7/aJw9jMaPH0+Cg4PJ1KlTyZYtW8j//vc/0qJFC1K7dm1BhBBCyCeffEI4jiN33nkn+d///ke2b99Oli5dSiZOnEgIsYVGhgwZQgCIQnm8GABA6tWrR9q2bUv+97//kR07dpB//vlHeI8WRhcvXiR16tQhNWvWJG+//TbZvn072bBhAxk7diw5ceKE6Lj56yUzM5M888wzBADZuHGjKDx8+PBhAoCsWLFCdOzHjh0Tri9X/PHHHwQAeemll9z+Pjwmk4m0bduWGAwG8tZbb5GtW7eSmTNnkqCgIJKSkiL6LADSqFEj0qVLF/Lll1+STZs2kTvvvJMEBQWJhKmU61quMEpISCCjR48mW7ZsIcuXLyeRkZGkV69epG/fvmTatGlk69atZOHChUSv15NnnnnGod4NGjQgrVq1IuvWrSM//PAD6devHwFAvvrqK0JIxfev/bVotVrJPffcQ4KCgsjMmTPJ1q1byVtvvUUMBgNJTk4WicqEhARSv3590qpVK/LZZ5+Rn3/+mQwdOpQAIGlpaQ7n4N577yUdOnSo8LeT0i4RQshvv/1GgoKCyJQpUwghhBiNRtKqVSvSokULUlhYSAixXVu33347iY+PF90PhJRfu/Xq1SO9evUiX3/9Ndm6dSs5e/YsycvLI6NHjyaff/452bFjB9myZQuZNm0a0el05NNPPxXV99FHHyUcx5Fx48aR77//nmzevJnMmzePvPvuu4QQW+g9MTGRJCcnC+X7Inzp7zBhxHCKM2FEY7FYSGlpKfnss8+IXq8nubm5wnt8T+iXX34RfefDDz8kAMjmzZtFr0+YMMGhYWnRogVJTk52eHAPGDCA1KlTh1gsFkKI/ByjyMhIMnnyZJfvG41GUqNGDTJw4ECH423Xrh3p0qWL8BovfmbNmuWwH3thdOHCBRIUFOTwALl58yaJj48nw4YNI4QQcv36dQLAo3yUp556ioSHhzu4Fnwj6+rf7t27hc/aP4z27NlDAJDFixeL9pmZmUnCw8PJiy++KBxHdHQ0ueOOO9y6Ju5yjACQatWqia4l+j1aGI0dO5YEBwc7iEBnx01fV+5yjHr27Enat28veu2pp54i0dHRDo4Izfr16wkAsnz5cpefoVm+fDkBQL788kvR6wsXLiQAyNatW4XXAJDatWuTgoIC4bXs7Gyi0+nIG2+8IbxW0XVNiHxhZH8PTJ48mQAgzz77rOj1+++/n9SoUUP0GgASHh4uEs5lZWWkRYsWJCkpSXjN3f1rfy1u2bKFACBvvvmm6HMbNmwgAMjHH38sOtawsDBy/vx54TWTyURq1KhBJkyY4FDW//3f/xGdTieIFldIbZcIKf89v/32WzJq1CgSHh5Ojhw5Ivqeqxwj/tpt0qSJgyNvT1lZGSktLSWPP/44SU5OFl7ftWsXAUD+7//+z+33WY6RI2xUGkMyhw4dwn333YfY2Fjo9XoEBwfjscceg8ViwcmTJ0WfjYmJQe/evUWvpaWlISoqSjRiCgAefvhh0d8ZGRlIT0/HiBEjAABlZWXCv5SUFFy+fBn//vuvR8fQpUsXrFmzBnPnzsXevXsdRgr98ccfyM3NxahRo0TlWq1W9OvXD/v374fRaBR9Z/DgwRWW+/PPP6OsrAyPPfaYaL9hYWHo2bOnMNqvRo0aaNKkCRYtWoS3334bhw4dgtVqlXRsly5dQlxcnMvRcM899xz279/v8K99+/Yu9/njjz+C4ziMHDlSVO/4+Hi0a9dOqPcff/yBgoICTJw40avReL1790ZMTEyFn9u8eTN69eqFli1belyWPc899xz+/vtv/P777wCAgoICfP755xg1ahQiIyMVK2fHjh0wGAwYMmSI6PXRo0cDsI2UounVqxeioqKEv2vXro1atWrh/PnzwmsVXdeeMGDAANHf/Lnu37+/w+u5ubkoLCwUvd6nTx/Url1b+Fuv12P48OHIyMjAxYsXZddnx44dAMrPE8/QoUNhMBgczlv79u3RsGFD4e+wsDA0a9ZMdN54atWqBavViuzsbJfly22XXnjhBfTv3x8PP/wwPv30U7z//vto06aNrGO+7777EBwc7PD6V199hdtvvx2RkZEICgpCcHAwVq5ciRMnTgif2bx5MwBbDhVDHkwYMSRx4cIFdO/eHVlZWXj33Xexe/du7N+/Hx9++CEAwGQyiT5fp04dh33k5OSIGkoe+9euXLkCAJg2bRqCg4NF/yZOnAgAuH79ukfHsWHDBowaNQqffPIJunXrhho1auCxxx4TGkS+7CFDhjiUvXDhQhBCkJubW+Gx2sPvt3Pnzg773bBhg3A8HMfhl19+wT333IM333wTHTp0QFxcHJ599lncvHnTbRkmkwlhYWEu369fvz46derk8M/dQ//KlSsghKB27doO9d67d69Q72vXrglleIOUc8mXp3Ry+6BBg9CoUSPhml6zZg2MRmOFDxb+4Xv27FlJ5eTk5CA+Pt5BQNaqVQtBQUHIyckRvR4bG+uwj9DQUNE9V9F17Qk1atQQ/R0SEuL29eLiYtHr8fHxDvvkX7M/Rink5OQgKCgIcXFxotc5jkN8fLxH542Hv2+cvccjt13iOA6jR49GcXEx4uPj8eijj0o80nKc3Q8bN27EsGHDUK9ePXzxxRfYs2cP9u/fj7Fjx4p+g2vXrkGv1zv9HRjuYaPSGJL47rvvYDQasXHjRiQkJAiv//33304/78w1iI2NxZ9//unwun3jXbNmTQDAyy+/jAcffNDp/ps3by616g77fuedd/DOO+/gwoUL+OGHHzB9+nRcvXoVW7ZsEcp+//33XY5oshdyUhwSfr9ff/216Pw5IyEhAStXrgQAnDx5El9++SVmz54Ns9mM5cuXuy3jr7/+qrAucqhZsyY4jsPu3budjobhX+MfVp44ATRS3aa4uDivy7JHp9Nh0qRJmDFjBhYvXoylS5eiT58+FV5rnTp1Qo0aNfD999/jjTfeqPAYYmNjsW/fPhBCRJ+9evUqysrKhGtFDhVd14Dt4V9SUuLw3evXr3tUZkU4E2X8a85ES0XExsairKwM165dE4kjQgiys7PRuXNnj+vKd3bcnQe57dLly5cxadIktG/fHseOHcO0adPw3nvvyaqXs2vpiy++QOPGjbFhwwbR+/a/bVxcHCwWC7KzsyV3OBg2mGPEkAR/A9IPR0IIVqxYIXkfPXv2xM2bNwWLl2f9+vWiv5s3b46mTZvi8OHDTh2OTp06CaEFvj7uenquaNiwIZ5++mn07dtXEBS33347qlevjuPHj7ssm+8hy+Gee+5BUFAQTp8+7XK/zmjWrBleeeUVtGnTpkLR06JFC+Tk5CA/P192/VwxYMAAEEKQlZXltM58aOC2225DtWrVsHz5chBCXO7Pm9+L5t5778Wvv/4qO6RaUfnjxo1DSEgIRowYgX///RdPP/10hfsMDg7GSy+9hPT0dLz++utOP3P16lUhRNenTx8UFhbiu+++E33ms88+E973BmfXNQA0atQIR44cEX325MmTHoelK+KXX34RXBbANtx8w4YNaNKkieD2ybke+PPyxRdfiF7/5ptvYDQavTpvZ86cQWxsrFNHm0dOu2SxWPDwww+D4zhs3rwZb7zxBt5//31s3LhRtE9XDpY7OI5DSEiISBRlZ2fj+++/F33u3nvvBQAsW7bM7f48qUNlhzlGDEn07dsXISEhePjhh/Hiiy+iuLgYy5Ytw40bNyTvY9SoUViyZAlGjhyJuXPnIikpCZs3b8bPP/8MwNZj5/noo49w77334p577sHo0aNRr1495Obm4sSJE/jrr7/w1VdfAQBat24NAPj4448RFRWFsLAwNG7c2GmPND8/H7169cIjjzyCFi1aICoqCvv378eWLVuEHmBkZCTef/99jBo1Crm5uRgyZAhq1aqFa9eu4fDhw7h27VqFDY0zGjVqhNdeew3/93//hzNnzqBfv36IiYnBlStX8Oeff8JgMGDOnDk4cuQInn76aQwdOhRNmzZFSEgIduzYgSNHjmD69Oluy7jzzjtBCMG+fftw9913O7x/4cIF7N271+H1uLg4l3PG3H777XjiiScwZswYHDhwAD169IDBYMDly5fx22+/oU2bNnjqqacQGRmJxYsXY9y4cbjrrrswfvx41K5dGxkZGTh8+DA++OADABCE1MKFC3HvvfdCr9ejbdu2ssXma6+9hs2bN6NHjx6YMWMG2rRpg7y8PGzZsgXPP/88WrRo4fR7fPnvvvsuRo0aheDgYDRv3lx4oFWvXh2PPfYYli1bhoSEBAwcOFBSfV544QWcOHECr776Kv7880888sgjaNCgAfLz87Fr1y58/PHHmDNnDm6//XY89thj+PDDDzFq1CicO3cObdq0wW+//Yb58+cjJSUFd911l6xzIeW6BoBHH30UI0eOxMSJEzF48GCcP38eb775pkNoSilq1qyJ3r17Y+bMmTAYDFi6dCnS09NFHSE592/fvn1xzz334KWXXkJBQQFuv/12HDlyBK+++iqSk5M9ClXx7N27Fz179qzQ7ZPaLr366qvYvXs3tm7divj4eEydOhVpaWl4/PHHkZycjMaNGwOwXY8bN27EsmXL0LFjR+h0OpedJJ4BAwZg48aNmDhxIoYMGYLMzEy8/vrrqFOnDk6dOiV8rnv37nj00Ucxd+5cXLlyBQMGDEBoaCgOHTqEiIgIPPPMM0Id1q9fjw0bNiAxMRFhYWGyc6EqHdrlfTP8GWej0lJTU4X5MOrVq0deeOEFsnnzZodRJfw8Rs64cOECefDBB0lkZCSJiooigwcPJps2bSIAhLk1eA4fPkyGDRtGatWqRYKDg0l8fDzp3bu3w+ifd955hzRu3Jjo9Xq38xgVFxeTJ598krRt21aYZ6d58+bk1VdfdZi/Ji0tjfTv35/UqFGDBAcHk3r16pH+/fsLQ40JKR95du3aNYeyXM1j9N1335FevXqR6OhoEhoaShISEsiQIUOEaQCuXLlCRo8eTVq0aEEMBgOJjIwkbdu2JUuWLCFlZWVOj4vHYrGQRo0aCcPjeSoalTZixAjhs65mvl61ahXp2rUrMRgMJDw8nDRp0oQ89thj5MCBA6LPbdq0ifTs2ZMYDAYSERFBWrVqRRYuXCi8X1JSQsaNG0fi4uIIx3FO5zFyBpzMY5SZmUnGjh1L4uPjhTlthg0bRq5cuSI6bvvr4eWXXyZ169YlOp3O6YionTt3EgBkwYIFTuviju+//57079+fxMXFkaCgIBITE0N69epFli9fTkpKSoTP5eTkkCeffJLUqVOHBAUFkYSEBPLyyy+7nMfIHnqEmdTr2mq1kjfffJMkJiaSsLAw0qlTJ7Jjxw6Xo9Loa52Q8nmH6FnVCXF+H/D1Xrp0KWnSpAkJDg4mLVq0IGvXrnU4Flf3r6t5jF566SWSkJAgzF311FNPuZzHyB77YyXENo0EAPLNN984fN4ZFbVLW7duJTqdzuF6zcnJIQ0bNiSdO3cWroXc3FwyZMgQUr16deF+IKTiuccWLFhAGjVqREJDQ0nLli3JihUrnLY5FouFLFmyhLRu3ZqEhISQatWqkW7duonmwTp37hy5++67SVRUFJvH6D84Qtz43gyGD5g/fz5eeeUVXLhwQZPZoisTixcvxrx585CVlYXw8HCtqxOQTJ06FcuWLUNmZqZHuTAMW7hn0qRJglPoz8ycOROfffYZTp8+jaAgFkRhsFAaw8fwDWWLFi1QWlqKHTt24L333sPIkSOZKFIA/mH04YcfYtq0aVpXJ6DYu3cvTp48iaVLl2LChAlMFFUB8vLy8OGHH+L9999nooghwK4Ehk+JiIjAkiVLcO7cOZSUlKBhw4Z46aWX8Morr2hdtUpBWFgYPv/8cxw6dEjrqgQc3bp1Q0REBAYMGIC5c+dqXR2GDzh79ixefvllPPLII1pXheFHsFAag8FgMBgMxn+w4foMBoPBYDAY/8GEEYPBYDAYDMZ/MGHEYDAYDAaD8R9MGDEYDAaDwWD8BxNGfoLVasXZs2clr6Re2ajqxw+wcwCwc1DVjx9g56CqHz+g/TlgwojBYDAYDAbjP5gwYjAYDAaDwfgPJowYDAaDwWAw/oMJIwaDwWAwGIz/YMKIwWAwGAwG4z+YMGIwGAwGg8H4DyaMGAwGg8FgMP6DCSMGg8FgMBiM/2DCiMFgMBgMBuM/mDBiMBgMBoPB+A8mjBgMBoPBYDD+gwkjBoPBYDAYjP9gwojhNXfeeScmT56sdTUYDAaDwfAaJoyqOAMHDsRdd93l9L09e/aA4zj89ddfPq6Ve2bPng2O4/Dkk0+KXv/777/BcRzOnTsHADh37hw4jnP6b+/evQCAnTt3On0/PT3d14fFYDAYDD8gSMvC582bh127dqG4uBjx8fF4+umn0b17d8yfPx+bN28WPmc2m3HbbbdhyZIlAIBOnTohLCwMHMcBAMaMGYOxY8cCAIqLizFv3jykpaUhKioKzzzzDPr16yfsKzU1FcuWLYPRaETv3r0xY8YMBAcH+/Co/YvHH38cDz74IM6fP4+EhATRe6tWrUL79u3RoUMHjWrnmrCwMKxcuRLPP/88mjVr5vaz27dvxy233CJ6LTY2VvT3v//+i+joaOHvuLg45SrLYDAYlZy9e/fi2rVr6N+/P3S6wPZcNK39iBEjkJqairS0NMyaNQszZ85EQUEBZsyYgd27dwv/kpKS0LNnT9F3v/vuO+F9XhQBwEcffYT8/Hxs2rQJ8+fPx4IFC3D+/HkAQEZGBpYsWYK33noLP/30Ey5duoSVK1f69Jj9jQEDBqBWrVpYs2aN6PWioiJs2LAB999/Px5++GHUr18fERERaNOmDdatW+d2nxzH4bvvvhO9Vr16dVEZWVlZGD58OGJiYhAbG4v7778fFy9elFzv5s2bo1evXnjllVcq/GxsbCzi4+NF/+zFcK1atUTv6/V6yXVhMBiMqsyZM2dwxx134L777sOkSZNACNG6Sl6hqWPUqFEjYZvjOJjNZly/fl3Ucz979izOnj3rMtxjz6ZNm7B48WJERkaiXbt26NGjB7Zu3Yrx48djy5Yt6Nu3L1q1agUAGDduHObOnesQkuExm80wm82i14KCghASEiLzSCvGarWK/vcVOp0Ojz76KNasWYNXXnlFcOE2bNgAs9mMsWPHYv369XjhhRcQHR2NTZs24dFHH0WjRo3QtWtXYT+EEFHdrVarw7HwrxUVFaFXr1644447sHPnTgQFBWHu3LkYPXo0jh49irCwMLd15m+6+fPno2vXrti3bx86d+4sOod0+c7qQtcJAJKTk1FcXIxWrVphxowZ6NWrl5zTqAhaXQP+RFU/B1X9+AF2DgLx+Pfs2QOLxQIAWL58OVq1aoVJkyZ5vD+1zoFUJ0tTYQQACxYsQGpqKkpKStCzZ08kJiaK3t+8eTPuuOMOREZGil4fOXIkOI5D165dMXnyZFSvXh0FBQXIyclBUlKS8LlmzZrh2LFjAGyqtlu3bsJ7TZs2RVZWFoqLi50+jFevXo0VK1aIXhs6dCiGDRsm+fjuu+8+XL9+XfLnlaBmzZr44YcfJH/+nnvuwVtvvYUNGzYI52f58uW4++67UVZWhiFDhgifHThwIL799lusWrUK8fHxAGzhy4KCAsGZA4Br166J/rZarcjJycH58+fx5ZdfwmKxiITY7Nmz0b59e3z99dfo3r272/rm5eXBbDYjNjYWKSkpmDJlCtauXYvLly8DsLlRHMchKysLAHD77bc73BCHDx+GXq8HIQTz589H69atYTab8e2336Jv375Yt24dunTpIvkcKklmZqYm5foTVf0cVPXjB9g5CKTjP378uOjvd999FwMGDPB6v0qfg8aNG0v6nObCaPr06XjhhRdw4MABZGRkOLz/888/O4x4WrFiBdq0aYObN29i4cKFeO211/D222+jqKgIer1eJHIMBgOKiooAACaTCQaDQXiPF1smk8mpMBozZgxGjBghek2uY3Tjxg1kZ2dL/rwS6PV6h3whdyQkJOC2227Dpk2b8NBDD+H06dPYv38/tmzZgvr162PhwoX48ssvkZWVhZKSEpSUlKBmzZpCGWFhYYiOjhaVGRcXJ/pbp9MhNjYWCQkJOH/+PM6fP4+2bduK6lFSUoKCgoIK6169enWEhIQgISEBb7/9Nm655Rb8+++/qFOnDgCgXr16SEhIEJyl9evXo2XLlqJ98AI8ISFB5A498MADyMvLwxdffIGhQ4dKPodKYLVakZmZiQYNGgR8jN5Tqvo5qOrHD7BzEIjHX1JSIvo7Oztb1jPIHq3PgebCCLA9yLt27Yp169YhMTFRcC0OHz6MgoIC3H777aLPJycnAwBiYmIwbdo09O/fH6WlpYiIiIDFYhE5QEajEREREQCA8PBwGI1GYT+FhYXC684ICQnxOmzGuypSsFgsiuS2xMfHy76YHn/8cTz99NNYunQpPv30UyQkJKBv375YtGgR3nnnHbzzzjto06YNDAYDJk+ejNLSUlEZHMcJf/Mju+j3+c/rdDoQQtCxY0esXbtWeN9qtSIrKwvt27evsO68y6TT6dC0aVOMHz8eM2bMEPLF+HL4/SQkJFSYoE3TrVs3fPHFF5o1SnTdqypV/RxU9eMH2DkIpOPn3Xoeo9EIo9GIqKgor/ar1TnwC2HEY7VaRQm4W7ZsQZ8+fdyKE/6kEUIQHR2N2NhYZGRkoHXr1gCAkydPCu5AYmKiyJU6deoU6tWrV2FOizccOHBA0uesVqswMkyLC2HYsGF47rnn8L///Q+ffvopxo8fD47jsHv3bgwaNAgjR44U6nnq1CkHB4YmLi5OdKOcOnVKcO0AoEOHDtiwYQNq1aol5JNZrVYEBwejWrVqsus+a9YsNGnSBOvXr5f9XWccOnRIcJ8YDAaD4R57YQQAly5dQvPmzTWojfdoJkeLioqwefNmFBUVoaysDL/88gsOHjwouEFlZWXYtm2baKg9AJw+fRonT56ExWJBQUEBFi9ejK5duwriKSUlBZ988gmMRiOOHj2KXbt2oW/fvgCAfv36Yfv27UhPT0dhYSFWrVqFe++917cH7qdERkZi+PDhmDFjBi5duoTRo0cDAJKSkrBt2zb88ccfOHHiBCZMmFBhaLB379744IMP8Ndff+HAgQN48sknRaPARowYgZo1a2LQoEHYvXs3zp49i7S0NLz22muyRqbx1K5dG88//zzee+89p+/n5OQgOztb9K+4uBgA8M477+C7777DqVOncOzYMbz88sv45ptv8PTTT8uuB4PBYFRFnAkjZ68FCpoJI47j8P333yMlJQV9+vTB6tWrMXfuXCFxeu/evQgNDXWYQyc3NxfTp09Hz549MXToUOh0OsyePVt4f8KECYiMjES/fv0wffp0TJ8+XRj9lpSUhMmTJ2PKlClISUlB7dq1RUP9qzqPP/44bty4gbvuugsNGzYEAMycORMdOnTAPffcgzvvvBPx8fG4//773e5n8eLFaNCgAXr06IFHHnkE06ZNE8KZABAREYFdu3ahYcOGePDBB9GyZUuMGzcOxcXFohGJcnjhhRccEvR57rrrLtSpU0f0j59OwGw2Y9q0aWjbti26d++O3377DT/99BMefPBBj+rBYDAYVY1Lly5Jei1Q4EigTzhQSdA6lKY1Vf34AXYOAHYOqvrxA+wcBNrxFxUViQY18bz11luYOnWqR/vU+hz4/1lnMBgMBoPhl9AhM3qwUSA7RkwYMfyOyMhIl/92796tdfUYDAaD8R+0MOrYsaPT1wMNvxqVxmAAtsVgXVGvXj3fVYTBYDAYbqGdoY4dO+Knn34CwIQRg6Eo9MzlDAaDwfBfaAGUlJSEqKgo3Lx5k4XSGAwGg8FgVD1oYcSP+rV/PdBgwojBYDAYDIZH0AKobt26qFu3LgDg5s2bwuoSgQYTRgwGg8FgMDyCDpnRjhEQuK4RE0YMBoPBYDA8ghc/oaGhqF69uuAYAYE7ZJ8JIwaD4TFlZWVaV4HBYGgIL4zq1KkDjuOYY8RgMKomhBAMHToUUVFRWLdundbVYTAYGlBSUoLc3FwAEJwi2jFiwojBYFQZ0tLS8PXXX6O4uNjjaf8ZDEZgYz8ijf4fYKE0BoNRhfjwww+F7cuXL8NoNGpYG21ZvHgx7r77bvzzzz9aV4XB8CkVCSPmGDEYjCrBpUuX8O2334peO3DggEa10ZbMzExMmzYN27Ztw4gRI7SuDqMKYTabceedd6Jp06Y4c+aMJnVwJoxY8jWDwahybN68GRaLRfTanj17NKqNtvz777/C9pEjRzSsCUMLCCGYM2cOHnnkEZ///rt27UJaWhoyMjKwbNkyn5bNYz+HEQBERUXBYDA4vB9IMGHEYDBkkZOT4/DaypUrA3YyN284e/as6G+z2axRTRha8Oeff2L27NlYt24d2rdvj/Xr1/us7Ly8PGFbK1FuP4cRDy+SmGPEYDCqBAUFBQ6vZWRkoFatWppZ+lpx6tQp0d8ZGRma1IMQokm5VZ0///xT2CaE4JlnnoHVavVJ2XRHRCth5CyURm8XFBQEZP4hE0YMBkMWtDBq0KCBsG0ymfDDDz9oUSUQQnD9+nWfl2svhE6cOOHT8gsKCjBx4kRERUVhypQpPi2bARw6dEj09/Xr1/H333/7pGxacGRnZ+Pq1as+KZfGlTAK9CH7TBgxGAxZ0MLo448/RqNGjYS/nYXZ1IYQgrvvvhu1atXCihUrfFq2lsKotLQUt956K5YtWwaj0Yh33nkH58+f91n5DDgVQb/88otPyrYPXR89etQn5dLwobLg4GDExsYKrwf6yDQmjBgMhixoYdS2bVt8+eWXwt85OTn4888/cePGDVXrcPPmTRw6dAiEEGRlZWH79u0ghOCJJ55QtVwaq9WqqTA6duyYQ3n/+9//fFZ+VcdsNuPYsWMAAJ2u/FG6fft2n5RvH6I6fPiwT8ql4UVPfHy86BwwYcRgMKoUtDCKjo4W9RSXLVuGrl27olOnTqolIlssFnTs2BEdOnTAokWLcOXKFVXKqYjLly/DZDKJXvOlMLpw4YLDa2vXrmX5Rj4iPT1duMaHDRuGevXqAQB2796NkpIS1cu3F0a+zjMihAgOca1atUTvBfqQfSaMGIwAw2g04tNPP0V6erom5fPCiOM4GAwG1KhRw+EzZ86cwb59+1QpPysrS0h6fumll3Dx4kXR+74aGeYs0To9Pd1hKgO1yMzMdHjt2LFjmoRUqiJ0GC05ORl9+vQBYMu1++uvv1Qv3z6U5mthZDKZhETzqKgo0Xu8SAS0CfF5CxNGDEaAMXPmTIwePRq9evVycCx8AS+MoqOjwXEcqlWrBr1e7/A5Zw9uJSgqKhL9/dlnn/mkXHuczXRtMpl8NjKNdoweeOABYfv777/3SflVHVqItG/fHrfccovwt71YVwN7x+jYsWM+XdT55s2bwra9MOrcubMwl9E333yD4uJin9VLCZgwYjACjCVLlgCwjUTZsWOHz8unhRFgc45iYmIcPkdPfqgk9sJo48aNor/PnTunSrk0FosFH3zwgfD3gAEDhG37kUpqQQujSZMmCds//fSTT8qv6tCjIBs2bOjz8JG9Y2Q2m/H+++9j2bJlPhEidPmRkZGi9wwGAx588EEAQH5+PjZt2qR6fZSECSMGI4CZP38+Jk2apJoIcYa9MAIgyjPiUSvfxl4Y2eOLkVlffvmlEMrs3r07JkyYILynhTC67bbb0Lp1awC2uXWuXbvmkzpUZfLz84Xt6OhokTDKyspSvXxn8wM9//zzmDhxIj755BPVy3fnGAHAo48+Kmx//vnnqtdHSZgwYjACjNDQUGH7jz/+wNKlS9GjRw+fhHAsFovQINPCyFmekVo5UBUJI184RvSDZ/bs2UhOThb+9pUw4kOGcXFxCA8PR//+/QHYkmK3bNnikzpUZewHIdB5NVo4RjTz58/3afn2jhEA9O7dG3FxcQBsy5cEEkwYMRgBhrOw1dWrV3HfffepnvhL9xIrcoxOnjypSn38QRjxQ5AjIyPRq1cv1K1bV3gI8NMIqElZWZngSjRs2BAABGEEAGvWrGGj01SGF0Y6nQ4Gg8HnoTR3M0rbjxJTg4ocI71eL+Rd5ebmipYw8XeYMGIwAgxnS3IAttDV8ePHfVZ2RY5RSUmJw1piSuAPwojvLUdFRYHjOHAcJ7hG169fVz2UcunSJWFEEC+MunXrhsTERADAjh07cNddd+Gzzz5jAkkl7AchREVFCc6JLx2jmjVrOrwXFBTks/IB544RADRp0kTYPn36tOp1UgomjBiMAKKsrMytMFB7CL8rYeTMMVKrPv4gjPjeMv1A8GU4jR55xy/LEhQUJAqh7NixA6NGjdIkQb8qwOcY0feBLxdP5R0jZ6KEnlTx+vXr+OyzzxSf76sixwhgwojBYPgAujECgJEjR2L16tXC30wY2RJf1ZzLiBAi9Ja1EkZ04jXvGAG2iQa7du0q+qxW811VdpwNQuDzjG7evCncq7/99hs++OADxRdT5fdnMBjw/PPPi967cuWK4CiOGTMGo0aNwtChQxUtnzlGDAbDL6CFybBhw/D555+jc+fOwmtaCSNnoTRAndXmKxJGVqtV1VF6ZrNZmC+G7ilr7RgBtqkTvv/+e3Tq1El4TYv16yo7paWlwhxizhwjwOYaXb9+HXfffTeeeeYZvPnmm4qVb7VaRY7Riy++iLFjxwrvWywW5OTkgBCCH3/8EYBtRm4lYY4Rg8HwC5wJk6SkJGGCRbWXpJDrGGkhjADni3sqBf1AoHvKSUlJwt9qCyN6LTr7HJPatWvjvffeE/5mwkh56PugWrVqwra9MNq1a5cgoF577TXFyqcndjUYDKhduzZWrlwpEkfZ2dnIzs4WfY93kZSAOUYMBsMvcNZLCw0NFZJu//33X0UbP3vs527h0coxCg4OFrYTEhKEbTWFEf1AoHvKOp0O7dq1A2CbSyk3N1e1OtBhGX6GYRpaqDJhpDyuOgj2wkita8CVKImPjxe2L1++7HD/SelUSEWKY1S9enWhbWDCiMFgqIKrBrlFixYAbA2fmssRSHWMOnbsCMCWC6P0gpp047569WoEBwcjLCwM69evF173lTCy7ynT4TQ168CEkba4ug/ouYxGjhzp4BIpJZRc/f60MMrOzhbWFORxN/eRXKQ4RkC5a3Tx4kWfLK6rBJoKo3nz5uGee+5Bz549MXz4cCEGmpqaiq5du6J79+7CP9oSPHbsGB5++GHcfvvteOKJJ0QZ+MXFxZg5cyZ69OiB/v37O0x0lpqaipSUFPTs2RNz5sxBaWmpbw6WwVCAioQRoG6ekdQco6ZNmwKwJSorPWSfFkadOnVCVlYWMjMzceutt6JOnToAbKJErWHqrkJpgO/yjOgHo7OHUvXq1cFxHAAmjNRASigNcFy3T6lQNy1KaGHEX/+ATRjZO0ZKCiMpjhFQLozUaAvUQlNhNGLECKSmpiItLQ2zZs3CzJkzhQuuS5cu2L17t/CPV8JmsxkvvvgiHnroIezYsQOtW7fGrFmzhH1+9NFHwtos8+fPx4IFC4QlAjIyMrBkyRK89dZb+Omnn3Dp0iWsXLnS9wfOYHiIK2HSsmVLYVvNuWukOkZJSUnCttLhNFoYRUREIC4uTsizad++PQBbz3zHjh24//77sXTpUkXLdxVKo8sHoOoK6xU5Rnq9XpgIlAkj5XEVUu7UqROaNWvm8ntKCSNXwph2jF566SW88cYbou9p6RgBwJkzZxQrX000FUaNGjVCSEgIANtoCrPZLFqYzxkHDx5EeHg4Bg0ahNDQUIwfPx7Hjx8XXKNNmzbhiSeeQGRkJNq1a4cePXpg69atAIAtW7agb9++aNWqFSIjIzFu3Dhs3rxZ3YNkMBTElTDp16+f0DitXbsWq1at8mn5kZGRwszLixcv9qkwoqGFyV133YXvv/8ezz77bIXtihzcOUatW7dGeHg4AGD79u149tln8eSTT4qSZZWgImEElItVJoyUx9V9EBoaiqNHjzoMn+dRagJWV44RLYwq+p63uLsPaAIxAVv96TErYMGCBUhNTUVJSQl69uyJxMREHDt2DIcPH0afPn1Qo0YNDB8+HEOGDAFgU5x0oxseHo769evjzJkzMBgMyMnJEb3frFkzHDt2TPhut27dhPeaNm2KrKwsFBcXIywszKFuZrPZYT6UoKAgQcwpCZ8wq2birD9T1Y8fkHYO6J5qZGSk8NnatWvjo48+wogRIwAAs2bNwsiRI0XJyUrgqnwA+P7773HlyhXEx8fj999/F17PyMiQ/LtKOQe0MAoLCxN91n4OH8A2dPnMmTMuE8TlQj8UDQaDqPygoCB0794dW7duxdWrV/H+++8DsC3yOnLkyAr3LfU+4IURx3EIDQ11+vnY2FicOnUK+fn5MJvNPpkNWQkCoS2gl7ewvw+CgoLQr18/vP322w7fO378eIXHJeX4aVFCX4MVLQVSUFCg2HnlRVZYWBh0Op3L/TZu3FjYltoWqHUN6HTSvCDN75Tp06fjhRdewIEDB4SeZYcOHbB+/XrEx8fj+PHjmDZtGmJjY9GrVy+YTCaHHpLBYIDJZEJRURH0er1I5BgMBqEhtf8ur3JNJpNTYbR69WqsWLFC9NrQoUMxbNgwZQ7eCfYx6apGVT9+wP05oBOri4qKRCvJd+vWDX379sW2bduEMPG9996raN2uXr0qbOfn5ztdyf78+fOihW6PHj0qe8V7d+eAHqp+5coVIZcGAG655RZ06dIFf/75p+g7hw4dEtYy8xZ6csWSkhKHY+vYsaPgUvNs3LgR3bt3l1xGRfcBfw7Cw8NF9aHhnSsAOHz4sNOlI/wZf24L6HNuNpsdrgFXAkXOveDu+Ol9OLsGXXH27FnZ96Ir+GvQYDC43SfdFvzzzz+yylf6GqBFmjs0F0aALR7etWtXrFu3DomJiSJXp3Xr1njooYfw66+/olevXggPD3eYQdRoNCI8PBwRERGwWCwiB8hoNAp2u/13ecVLNyA0Y8aMEXrgPGo6RpmZmWjQoIFkVVuZqOrHD0g7B7QIaNasmWiIOgBMnToV27ZtAwBMmjQJ48ePx1tvveXW6pYDnbvUvHlzl/dCw4YNYTAYYDQacfnyZYd6ukLKOeAnV4yIiECjRo0c3l+3bh2Sk5NFzo7ZbJZch4qgjzkhIcFhv0OHDnXI7ahWrZqk8qXeB7yTHRkZ6XK/9evXF7YjIiIUO361CYS2gK5XkyZNJJ/bK1euoGHDhqL72B4px0935OvXry8q/6677sL27dtdfk+p66C4uBiALZTobp8NGjRAWFgYiouLJbcFWl8DfiGMeKxWq9OhxvRFlJiYiG+//Vb422Qy4eLFi0hMTER0dDRiY2ORkZGB1q1bA7Ct8M3P8ZKYmCjKdzh16hTq1avn1C0CbA2gGiLIHTqdzm8bA19Q1Y8fcH8OaAu9WrVqDp/r27cvkpKShOt8xYoVaNGihcucB7nQozhDQ0PdNvCNGzcW9RDl/K7uzgHvAEdERDj9TGJiIvbt24cZM2YIbUVWVpZi1xXduYqOjnbYLz+XEc3FixcVO366DgaDweXnaIfoxo0bAXdf+XNbQN+H1atXl1xPi8WCsrIykYviCnfHT+es2V+D33zzDbZt24Y+ffrg888/x8svvyxcL0VFRYqdU/4cREVFud2nTqdDYmIijh8/LiRfS62DVteAZlddUVERNm/ejKKiIpSVleGXX37BwYMHkZycjD/++EOw6dLT07FhwwbBhu7YsSNMJhNSU1NhNpuxcuVKtGrVShimmJKSgk8++QRGoxFHjx7Frl270LdvXwC2BNXt27cjPT0dhYWFWLVqleKhBgZDTVwlffLodDrMmzdP9No///yjWPm8MAoKCnIrioBy29psNiu6qCYtjFzRokULkWuj5NxO7kalAbbfYOLEiaLXlA4JuFtAlIfNZaQerobr03z55ZcAbJOQ3nLLLcLrSiRAu0q+BmztwuDBg1G9enU888wzWLt2raJlA7Z2gJ+TSIobzSdgl5SU+GSBXW/RTBjxa/qkpKSgT58+WL16NebOnYukpCTs27cPw4YNQ/fu3TFjxgw89thjgrgJCQnBm2++ibVr16JXr144fPiwaBKtCRMmIDIyEv369cP06dMxffp0wW5PSkrC5MmTMWXKFKSkpKB27dqiKdQZDH+HbpBdzR0ybNgwURxfySGyvDCSktRNx/OVrIMUYQSIJ9tTUhhJGY2zaNEirF+/XgjTZ2ZmKjaFgtVqFRwDVyPSACaM1MTVcH2aIUOG4JdffsFff/2FVq1aCa8rsZhsRfNY0dDvKyWMKuoc2BNoI9M0C6WFh4dj+fLlTt+bMmUKpkyZ4vK7t9xyi2iWW5qwsDDMnTvX5XcHDhyIgQMHyqssg+En8MIoIiLC7Sijhg0bombNmrh+/bpmwogPYQO2pM8ePXooUgepwigyMhLVq1dHXl6eao6Rq4dSREQEhg8fjtWrV+Pnn39GcXExcnJyFEmApkflMWGkDRU5t4Ct89+7d28AyosTd46RPWoLIzmOEWATRj179lSkHmrhnwFcBoPhFL5BdtUY0/COjZJT8XvqGCk1421paako+boi+ATkixcvKubYyOktN2zYUNhWKpwm9aHIhJF68PehXq+XdB3Sv5MSjpG7ubzsUUMYSZ31mifQHCMmjBiMAEKOMOIdG0KIYkN0tRZGch4IQLkwKikpUUwcSJ3YDrCNyOFxNaxeLlImdwSYMFIT+j6sKNcOUF6c0PPrVZTI7Q+OEX0f0Et4+StMGDEYAQIhRHgoyxFGgHI5PoEqjADl8oz4h4Jer6/woUQ/EJRyjJgw0h4+x0iKWwIo7xjRo0MruhfpOmrlGNEh5EC4FpkwYjACBJPJBIvFAkBaY2Sf46MEcoRRZGSk0CBWRmEUFRVVoVugpTCiZ/pWalV3hg1+Dh8p1yCgrmNU0b1Il00LGm+Q6xjR16KSy/OoBRNGDEaAwDfGgOtJSWm0doyActcoKytLkTwnb4SRUsKEf7jIDSGoIYzc1SE8PFz4neglLBjewwsTqfeBlo5RSEiI8BmlHCM5oTy+DrzLzRwjBoOhGHRjJGXiUX8SRoQQRRwbucKIXppBqQaZdowqgp4yQKncCqmOEcdxiImJASBeRoXhPfx9IHUCYPp3UkKc0MJISh14Aa3kPEY8UtuCQFrUmAkjBiNAkCuM6tevLwzpV1oYSV2Q1H72ZW+RK4yqV68ubCvhmhBChIeLFMcoIiJCCLfRdfcGOUO1mTBSHqvVKoS0pYoC+lrxtWNEl6+UMOJHhgLS2wJeGOXm5vr1AsEAE0YMRsAgtzEMCgoShIkSvTRCiGzHiH8wA5VDGBUVFQnD/qUII47jhCWH6GUcvEGqYwSUn/+bN2+KHmYMz/HELVHTMdJCGHlyDvi2yGq1+n1olwkjBiNAkOsYAeXCQImGiO8lA9IbQ1qYVAZhJHfGX6A8H4zOEfMGOcKIPn56tmaG58gNYwHqOkZ6vV5y+YWFhYrM5+WNYwT4fwI2E0YMRoDgjTC6efOmSNh4gie9RNoxUsqx4dFaGFUkSnh4YaSlYwSwcJpS+INjRCd/S5lHiRfxhBBFrkNaGMl1jAD/zzNiwojBCBC8EUaAeBkDT/BWGGnhGEVGRgqrcyshjOiRdVJG4wDwi1AawISRUsgZKs+jlmPkiWOlxJB9ui1gjhGDwdAMT4SJko6J1uUDYnEhZcoCjuOEOighDDw5B2o6RhXlOTFhpDyehNLUyjHyRJgpUb4njlEgTTjKhBGDESB46xhpIYyUfjB7cg74OighzLwVRkrkd3gyKg1gcxkphSfXgFqOkVbCyBPHiIXSGAyG4ngiCqpVqyZsa+0YaSWM6AR0b4WJN8KIHtXnDZ4mXzPHSBk8CaWFhYUJuUCVzTFioTQGg6EZge4YaeXY8OfAarV6/VDwRhgByoTTWI6RtngSSuM4ThAnSjhGcmfepjtISrg13gzXV6oOasKEEYMRIHjr2Hg7XNuT8unVx7V2jABtxCGffA1oK4xYKE0ZPLkGgPLfSgvHSOmlaZhjxGAw/IJAFAU6nU7orWrtGClRB0/cArUcI47jKkxAZ46R8ngqjJR0jOSOSmvYsKGwff78ecXKB1jyNYPB0JBAFEZ0HaqqY6SWMKKXG3EFyzFSHk+uQUBbxyghIUHYvnDhgtfle+IYhYeHC1NsMMeIwWAoQiCKAkA8KkyL5GetzwEtjJSY/ZqfS4kO0bmCOUbK461jZDabvU7ClyuM6tevL2xr5RgBgbOQLBNGDEaAEIij0oByYVJWVuZ1GCEQhZHSOUb8dSDlGoiKilJ0gkuG9zlGgHfhNIvFIizCKucajI+PB6CdYwSUz8CtRDhRTZgwYjAChEAUBYCyrkUgumZKh9J4x0jKzNs6nU7RUCbD81CaUnMZeXof8nlGly9fFh2DJ3gywSNQLg7pxZj9ESaMGIwAwVtRoMWoNPs6aD2XUmUQRnIcI0DZHC+GMo6RN3lGnpbP5xkRQnDx4kWPy7evgxzHiM8xslqtXoszNWHCiMEIEDwRRmFhYcJnmWNUNYURnePFh2AYnuNtjhGgnGMkx7FScmSap44Rvb4hve6hv8GEEYMRIHgiCui1wrwVBZ42hloLEyVHZvlD8rWnwkiJCS4Z3o9KA7R1jADv84y8dYwAJowYDIYCeNogKjWPEHOMtE++tlqtgkCVkmMEsJFpSuNPjpEnOUaAso6Rp8LInxOwmTBiMAIET3uqvDDIz8/3KpTiD8JI62VJtA6leSsMmTDynkDNMaKFkbezX3taB+YYMRgMRfFWGBFCcPPmTY/L99axArxPAPfkHERERECv1ytefqAII+YYKYun9yEtCry5Djy5BgGxQPamHQCUcYyYMGIwGF7jrTACvBMGSvSUvW0M+TpwHCeInYqgl87wNscnEB0jtl6asmjtlniafK3UPEr2dWCOEYPB0AwlHBtvHoz+JIzklA+U5/l4K0y0Tr7m5zACWI6RVmgtCrSeYBJgjhGDwfATAnViOSUTLuWOyOLhxYkWwkjJ5GuWY6Q9SoTStBBGtED3VpSw4foMBsMvUGKYsNbCSCvHSEth5E+hNCaMvEfr+8DT8nU6nVAHJUNp/JIzUmDCiMFgKEqgCiMlQ2n+5BhJrYNawsiTUBrLMfIerR0bT8sHyu9FpUJpwcHB4DhO8veYMGIwGIri6WgUpUJZ/hBK89YxMpvNsFgsXpcvpw5KCiM6x4g5RtoQqKPSAOWEEX8fyMkvAgJHGMk7KoWZN28edu3aheLiYsTHx+Ppp59G9+7dkZqainXr1uHixYuIiYnBo48+iiFDhgjf69SpE8LCwgSlOmbMGIwdOxaALblx3rx5SEtLQ1RUFJ555hn069dP+G5qaiqWLVsGo9GI3r17Y8aMGbIvLgZDC5QYjaJFT1XJxtBTx4jO8ykpKRHVSQ7e5hh5m3zNQmnao/V94Gk7ACjvGDFhpAIjRozACy+8gJCQEBw7dgyTJk3CDz/8ALPZjJdffhktW7bE+fPn8dRTTyExMREdOnQQvvvdd9+hZs2aDvv86KOPkJ+fj02bNuH06dN47rnn0LJlSyQkJCAjIwNLlizBBx98gIYNG2Lq1KlYuXIlnnzySV8eNoPhEYEaStPpdAgLC0NxcbHmOUaArbfuS2GkdY4RPSqRCSPv8Sdh5KljxK9uLycM5qwOcssPFGGkaSitUaNGws3NcRzMZjOuX7+OwYMHo02bNggKCkKTJk3QpUsXHD9+XNI+N23ahCeeeAKRkZFo164devToga1btwIAtmzZgr59+6JVq1aIjIzEuHHjsHnzZtWOj8FQEk8tdK2FEQDFkz49zTECvBMn/jQqTWqOUVBQEKKiogCwHCMlUCKkrZUw4utACPHqWmSOkcosWLAAqampKCkpQc+ePZGYmCh632Kx4NixY0hJSRG9PnLkSHAch65du2Ly5MmoXr06CgoKkJOTg6SkJOFzzZo1w7FjxwAAZ86cQbdu3YT3mjZtiqysLBQXF4saLx6z2Sy6CQDbhSC3UZYCv1RDVV39uqofP1DxOeCvRZ1OB47jJJ8r+touLCz0+BzT94Jer5e1H4PBgNzcXBQVFbn9ntRzEBwcLKt8+hwYjUafnwPeMTOZTF4dP/0wk3MOYmJicPPmTdy4ccPv7zF/bwvoayAoKMij+9DdfVDR8dN5ZnLKB8TC5ObNm06fe1KgHSM55dMdFHf3oVrXgNQRdJKE0YoVK2RXYPz48ZI+N336dLzwwgs4cOAAMjIyHN5ftmwZ4uLiRIJmxYoVaNOmDW7evImFCxfitddew9tvv42ioiLo9XrRj20wGARlajKZRL1nfn4Xk8nk9AJZvXq1w7EPHToUw4YNk3RsnuDtGjaBTlU/fsD1OeDdluDgYFmLQNLT/2dnZ3u8gGRubq6wff36dVn74Xu2hYWFkr7n7BwQQoSeqtVqlVU+nXB9+vRpjzs3BQUFwnZ2drZoPhd3hIaGori4GAUFBR4fPwBkZWUJ20ajUfI54Nu9Gzdu4Ny5cx6HUHyJv7YFtOt29epVyeKCEAKdTger1YobN25U+Nu5Ov7s7GxhW+r1xEP/7idPnvTYtaHFmZzy6VCulDZE6WugcePGkj4nSRh9/PHHsm8kqcIIsPW8unbtinXr1iExMVEQQV9//TV27NiBVatWicpPTk4GYOsFTZs2Df3790dpaSkiIiJgsVhEDpDRaBRUcnh4uMjK5xfyo1UszZgxYzBixAjRa2o6RpmZmWjQoIGseSEqC1X9+AHp5yA0NBQJCQmS90svA6LX62V9l4Z+ADRs2FDWfvg8F5PJ5PZ77s4B3VOPioqSVT6dj1ijRg2PzwEdOkhMTBQlNrsjIiIC+fn5sFgsHh8/IM4Xql27tuTjqFWrFk6cOAGz2YxatWp5nGPlC/y9LaDDV40aNUKDBg0kfzciIgKFhYVur4OKjp8PiwJAfHy8rGs5Li5O2K5evbrH9wHv5ISHh8vaB33dEUI8PgdqIzmUFhERgebNm1f4ufT0dI9jl1arFRcvXgQAbN26VXBs6Jlb7eFPGiEE0dHRiI2NRUZGBlq3bg3Apor58FxiYqLIlTp16hTq1avnUvGHhISoIoLcodPp/LIx8BVV/fgB1+eAHpEl5xzRDWlRUZHH55d2R0JDQ2Xth3csysrKYLFYKsyNcHYOaNcnODjY44nlSkpKfH4O6HmUpHzH1TVAlx8WFia5fFrAFRQUiGZD91f8tS3w9DcAyoWRlPvQ1fHT94Hc+5D+3aVei86gc4zULF+ra0CyMEpMTMRHH31U4efGjBkj5PS4o6ioCGlpaejZsydCQkKQlpaGgwcP4tlnn8XevXuxaNEiLF26FHXr1hV97/Tp07BYLGjSpAmMRiMWL16Mrl27CgImJSUFn3zyCebNm4czZ85g165dWLNmDQCgX79+mDBhAh544AHUr18fq1atwr333iv1FDAYmkLn18jBn5I++TrQzodUPB2VB2ibfE2Xr8U8RoDjkH37dpUhHSXuA61HpQHeDYSgJ3iUg5LLkqiJJGE0YMAA1K9fX9IOb7/9djRq1KjCz3Ech++//x4LFy4EIQQNGjTA3LlzkZSUhEWLFqGgoECYmwgA7r33XsyYMQO5ubl44403cPXqVRgMBnTp0gWzZ88WPjdhwgTMnTsX/fr1Q3R0NKZPny7UJykpCZMnT8aUKVOEeYzoMhgMf8bTEVn+MCrNvg6eCCNvyldKGHk6IokWRt4Mk/ZUHLK5jJSDCSPPJ3hUcuoONZF0VK+++qrkHY4bN07S58LDw7F8+XKn77lzpjp37oyNGze6fD8sLAxz5851+f7AgQMxcOBASXVkMPwJTyc39AdhpIRr5U+OkVyLny/farWitLTU4xC9p+eATkdgQ/a9w5vrkBZGngpkfxBGnjpGgO0cVAphZA+fGJWbmwtCiOg9ehJGBoOhHJ4KI71ej9DQUJSUlPiFMPK0Dko5Rt7MPu3pxHb2s18rIYykzmMEMMdISZS4D7wRyEosCQJ4fh9aLBbhuS/XMQJs54CfusNfkX1U//zzD/7v//4Ply9fdniP4zjs27dPkYoxGAwxnuYYAbbGqKSkxC8sfE/r4M1SCEpNsqjUjL/R0dEele9pjhFdHj19A0M+nrqGgON14IkwUmJJEL58T6CTzz0VRt6U7wtkp3svWLAAly5dAiHE6T8Gg6E8hBCPHSNAmTWS/CmUplWOkafCiBYm9FxIcvE0jKPksiRVHW/uQyXuA61Dad6UDwSGMJIt986dO4egoCA899xzSExMhF6vV6NeDAaDgh6iG4jCSOsGWWlhJPc3oHN8vAllMWGkPZ6KY6ByCCOlHCOz2YyysjKP9qE2smuUmJgIk8mEhx56SI36MBgMJ3iT8Akos1aZPzlGWidfyz1+pZKfPc0xYsJIObwRRkoMVw/kXD/7OphMJtE8a/6C7FDa1KlTkZ2dja+++kqYOZrBYKiLt8KInmCRbtjkoGRuhTflA4GXfE0nP3sjjDzNMWLCSDmqeihNKccI8N9wmqSj6tKli8NrixYtwqJFi0SvseRrBkMdvMmvARwbRHezybvCm56yEg2yN+JQ6+RrNRwjJoy0QetQmtaj0pR0jPxVGEnq9rlKtGbJ1wyGb/BmJAqgbIMYiLkV/hRKYzlGgY0/3QdazGnGHKP/kDPBI4PBUB6lcoyAwBVGLMeI5Rj5AyyUVi6MKqtjJHlJEAaDoR1K5RgB3jfInvQStbbwK4swYjlG2qN1B0FrYUSX761j5M1gEDWRfFT9+/dHhw4d0K5dOyQnJ6NJkyZq1ovBYFAonWPkCYH8QFAi+Zqe8Ver5GsWStOeQL4PgoODERwcjNLSUr9wjLwZCKEmkoXR1atX8fPPP+Pnn38GAERFRaF9+/ZITk5G+/bt0bJlSzanEYOhEoGeY6SEY6V18rU3DyQWSqscEEIEYeBtKE2L6xCw3Yt5eXmaOUZKDYRQE8lH9eCDD+LQoUM4d+4cCCEoKCjA7t27sXv3bgC2m7RNmzZYunSpapVlMKoqSuYYedtT9baXqEUoLTg4GDqdDlarVZMHUnR0NDiOAyFEk+TroKAgBAUFoayszG8fRoGAP4zIUiKs7o0w8jb52n7dQH9E8lG9/PLLAID8/HwcOnRI+Pfvv//CarWiuLgYBw4cUK2iDEZVRskco0ANpXlzDjiOQ3h4OIxGoybCSKfTITo6Gvn5+YrkGHEcJ9uhDwsLQ2FhIRNGXuAPwkgJxwjQbrh+pRJGPNWqVcOdd96Jli1bomXLlvj999+xbds20ZIFDAZDWQI9x0jpRWQ9nXXYG2Hk7W9QvXp1r4URPSKK4zhZ3w0PD2fCyEv8ybkFtFmrjDlGFOfOnRNcor///hvZ2dkAbDHXkJAQtG3bFh06dFCtogxGVSbQHaPQ0FAhlKTFBI9AeZ6Np42xtw+kmJgYnD9/Hnl5eSCEyBY2QPk5kJNfxMMfPxNGnuNPjpFer/foGuKFSWlpKaxWq+xZ7JljRDF06FDhR4iIiMCtt96KDh06oH379mjdurVfLgTHYFQWvE2+9rZBtlqtsFqtADxrDDmOQ0REBIxGo6aOEaBd0iufgG02m1FcXCxKiJaKN3PoMGHkPUoKIy06KIBYmJSUlMi+Dplj5ISYmBgMGjQIHTt2RLt27UQHyWAw1EFrx8jbBwLgfSjLW3HIt1VaCyPANvu1J8KIzzFiwkgb/Gk+MSWEkScC3dvh+oEwQlLWqLS///4bZ8+exZo1a7BmzRrodDo0b95ccI6Sk5MRHR2tZn0ZjCqJ1jlGSgkjwPPG0NtzwJdfUlLidQjBk4ei/ZD9unXryt6HEo5RaWkpLBYLm17FA7y9DyIjI4VtTxdh9+YaALx3bJQcrh/wjhE/Kq2goEDIM/r777+Rnp6OEydOYO3atWwRWQZDJbR2jLztJQLah7LsJ3mkwxq+KF+JuYyUyDECbL8B/ZBmSEOJa5DPtfNUGCntGMnF27agUgkjnujoaPTs2RPNmjVDUlIS9uzZg+3bt7NRaQyGimid9OlvjpE3jgmgjTBSYvZrJRwjgAkjT/H2GtTpdDAYDCgsLAxYYcQcI4pz587hr7/+EkamXb16VXiPnyafwWCog7cJj0qG0jwdaEGHsjwZlaWkY+SJOFM6x8gTlMgxAvw3t8PfUaKDoLUw8nZ5HJZ8TUGPSqOFUK1atYRlQdhwfQZDHWhHVgthpEQozdukT297694uRaC1MLJYLMJ1wISRNighjCIjI3HlypVK4RixUBpsgqhBgwZITk4W/tWrV0+tujEYjP+ghYknSbPeDhP2tpcIOD6Y5QqjQHeMoqKihG1PHop0+UrkGDHk420CPlCegO1t8rU/5Bh50hYEwnUo+ajeeOMNJCcnIzY21uVn8vLyRL0iBoOhDLRj5Ikw0ul0CAsLQ3FxsUc5RmoII7komWOkhTDydqi21sfPUCakzAujkpISlJaWyr6W+HuROUbqIXm86l133YXY2Fi88cYbTt/Pzs7G448/rljFGAxGOUoIE2/WSPIHYaT0qDRfl+9tOJPPLwKUST5nyEeJkDKd9O7Nvejpfai1Y1SphBHPxo0bsXDhQtFr586dw+OPP47MzEzFKsZgMMrx1jECKpcwCkTHyNuRgcwx0h5vQ9qAd3MZWa1WIcdXCWGkxX0QFBQkzCFWaYRRWFgYvvnmGyxatAgA8M8//2DcuHG4evUq6tSpo3gFGQyG9sLI2+RvwPueorcTPGr9QPDWMaKPn+UYaYMS94E3wsgf7kNvO0kcxwl18FdhJPuoPvzwQzz77LP46quvcO3aNezbtw9FRUVo2rQp3nvvPTXqyGBUeZRwbOhVteUOl/c3xygQk6+9TYBXMpTGhJFnKO0Yyb0OlLgPtZ7gka9DUVGR3woj2Y5R27Zt8dFHH6FatWrYuXMnioqK0LlzZ3zyySeoWbOmGnVkMKo8SjpGFotF5D5IwR+EkdahJCWXZfE2lFZZ16jyd7R2jPxBGCk5p5m/CiNJR7VixQqH1zp16oTt27cjIiICrVu3xtq1awEA48ePV7aGDAZDkQbZPpQjJxzjD8Koqidf078Bc4y0QQnHiL4OAlEYKTmnmb9eh5LO7Mcff+zUduc4DiaTCWvWrBFeY8KIwVAepRvkoqIi1KhRw6Py/cEx8uQcaC3MgoODodfrYbFYNJkygQkj7/Enx8jTdsAfHKNKkWMUHx8ve/p+BoOhHEqE0rzJcfEHYUTP3+JJe6T1qDiO42AwGFBQUOC1Y+TJNeBt8jlD+1Fp/uYYVWlhlJqaqkrh8+bNw65du1BcXIz4+Hg8/fTT6N69OwBgzZo1+OKLL2C1WjFo0CA8++yzQmN47NgxzJ07FxcuXMAtt9yCOXPmCCPiiouLMW/ePKSlpSEqKgrPPPMM+vXrJzqWZcuWwWg0onfv3pgxY4bHdiCD4SuUnMcICOykTyUmttPCMQJs4lQJYcQcI21Q4j4I9FFpStwHfB0sFgvKyso8Pha1kJR8XVhYKPkEFhcXS/6xR4wYgdTUVKSlpWHWrFmYOXMmCgoK8Ntvv+Hrr7/GmjVr8OWXX+K3337DDz/8AMBmp7/44ot46KGHsGPHDrRu3RqzZs0S9vnRRx8hPz8fmzZtwvz587FgwQKcP38eAJCRkYElS5bgrbfewk8//YRLly5h5cqVkurKYGiJksnXQGA7Rv6Q4+StOPUklObtQ5EJI+9R4j5kjpH/T/IoSRj16tULEydOlLTDp556Cn369JH02UaNGgmWNMdxMJvNuH79OjZt2oQhQ4agfv36qFmzJkaOHInNmzcDAA4ePIjw8HAMGjQIoaGhGD9+PI4fP47Lly8DADZt2oQnnngCkZGRaNeuHXr06IGtW7cCALZs2YK+ffuiVatWiIyMxLhx44T9Mhj+jNLCSO6DubIJI62STrWcZJMJI+/R2jHyB1GihGPk77OwSz6zZrMZ2dnZkj7Hz8wphQULFiA1NRUlJSXo2bMnEhMTcfbsWaSkpAifadasGT788EMAwJkzZ5CUlCS8Fx4ejvr16+PMmTMwGAzIyckRvd+sWTMcO3ZM+G63bt2E95o2bYqsrCwUFxeLLhb6WOyHNQcFBXm8eKA7rFar6P+qRlU/fsD9OaAbI51O59F5ohujmzdvytqHfeKzJ+XTo+CKioqc7sPdOaCFkVrlu4P+DTw9B3yeV3FxMcrKyoQZgHncHT/9G3hyDXh7/L7Cn9sCWph4eh/SuX7O7kOp14Cn1yD9/DKZTF7dB56eA/paNBqNDgNB1LoG7O83V0gWRidPnsR9993ncYVcMX36dLzwwgs4cOAAMjIyANhuWlpVGwwGoYdrMplEPV/+fZPJhKKiIuj1epHIcfddvgyTyeRUGK1evdphqoKhQ4di2LBh3hyyW6r6sipV/fgB5+egoKBA2L5y5Yro/pAK3TO7cOGCEGKWAt0pKigokPVdnvz8fGH7ypUrbvfh7Bzw9ec4zqPyc3Nzhe2cnBzZ+8jJyfHq+4C4YU5PT3doy3icHT/vigM2p0GL+vsSf2wLrl27Jmzn5uZ6dA7pezk7O9vlPpwd/4ULF4Rtk8nkUfnXr18Xtm/cuCF7H/R9fPXqVY+MAtoBP336tEsBpPQ10LhxY0mfkyyM5LhAckeM6PV6dO3aFevWrUNiYiIiIiJEFqPRaBRUdnh4uIMNbTQaER4ejoiICFgsFpED5O67fBl0T5pmzJgxGDFihOg1NR2jzMxMNGjQQLKqrUxU9eMH3J8DWrg3bNgQCQkJsvffoEED0f7k7KN69erCdq1atTwqn34wBwcHO92HlOsgNDTUo/LpXirHcbL3Qff069Wr51Ed6J5xbGwsateuLXrf3fHT361Zs6bs8mkx7cnx+wp/bguio6OF7Tp16nh0Du2PyX4f7o7/xo0bwnb16tU9Kj8mJkbY9uQ6oJ9/CQkJqF+/vuw6xMbGirblnANfIEkY8YnPamO1WnHx4kU0btwYGRkZuOOOOwDY3KrExEQAQGJiIr799lvhOyaTCRcvXkRiYiKio6MRGxuLjIwMtG7d2ul3eVcKAE6dOoV69eo5dYsA2wWghghyh06n87vGwJdU9eMHnJ8DuocVHBzs0TmKiooStouLi2Xtg+7ReVo+7Y6UlJS43Yezc0CH0rwtX+7xA+LfIDQ01KM60OLEXR2cHb+3vwF9/CaTye/vM39sC5S4D2lxZTQaZV0DtEHhi/vQGUrcB7QZYTabZZ0DXyCpxDp16sj+VxFFRUXYvHkzioqKUFZWhl9++QUHDx5EcnIyUlJS8M033yArKwvXr1/H2rVrce+99wIAOnbsCJPJhNTUVJjNZqxcuRKtWrUSykxJScEnn3wCo9GIo0ePYteuXejbty8AoF+/fti+fTvS09NRWFiIVatWCftlMPwZNo+R9snXSo5KA3z/G4SHhwtuviej4hjKz0CvRfK1t6vbKznBo6d1UBvNJg/gOA7ff/89Fi5cCEIIGjRogLlz5yIpKQlJSUk4deoUHnvsMVitVtx///1CflNISAjefPNNvP7661iwYAFatWqF1157TdjvhAkTMHfuXPTr1w/R0dGYPn06GjVqBABISkrC5MmTMWXKFGEeo7Fjx2px+AyGLNRYEkQO/iCM+AbZ0/L5HrbVavVKmHlTB6XEqSfimOM4REREwGg0ejQqjqHMBI8hISEIDg5GaWmpJvchv7q9p4u4KrkkCMCEkYjw8HAsX77c5ftjxozBmDFjnL53yy23YP369U7fCwsLw9y5c13ud+DAgRg4cKC8yjIYGqP0kiCBKIy8dYw4jhPyDL0VRt4O1we0mTLBYDAwYeQFSnRQAFtI9caNG5osCQJ4t7q9kovIAv4pjPwrgMtgMJyidChNi4eytzNPeyuM6DpoNcGjN46Rkq4hE0aeoZQw4XPNtAilAd4tyeEPbYHaMGHEYAQAlWFJEDpZVG5jSAjxekkQoLynqlUozR8cI4AJI09RSph4KoyUcqy8EUZVIceICSMGIwCoDEuC8KEsQH5jSI/I8uaB4Gn5gDKhNC1zjIDya8CTif0YytyHgFgYyZkKx58cI29GjPm7MPLozP7555/Yv38/cnJyRD8qx3GidcsYDIYyKJ18rYVbAcDjHB8lywe0XysN0Eac2g/ZdzXBJMM5SgsT3gmVKrT9QRjx94E3zm2lE0YrV67ERx995PA6IYQJIwZDJZRwC+jGSIuHMuC5MFG6/OLiYqHN8mUdvBGnSohje8eKCSN5KBXKokWF2WzWTBiVlpbCYrHIalOUzPUDKokw+uabb0AIQVBQEGrUqOGVnchgMKShhIWv0+kQERGBoqIizYSRp8nPSgsjwNYgu5r1vqI6aB1K08KxYiiXfE1PHGw2myULVCVHpfEUFxfLEshK5vrx5fsbsu8uo9GImJgYfPnll6JlAhgMhnrQwsibmWD5tQOrqmNkPxpGjjBSOpSmZfI1wISRJyjlGNkLI6mocR/IFUbezidmX36lGJXWvXt3BAUFiZYXYDAY6sI3iHq9XvZahDR8g1RSUuJR+YAywqikpERW8q9ajpEcAn2CR4AJI29RyzGSitKj0gDP7wOWY0TRokUL/PLLLxg/fjzuvvtuh1W+BwwYoFjlGAyGDb5B9DZ0zS+kqrUw4usg1bFRo3wtXCtvhInWs58zKq9jJAelHaNKIYzeffddcByHf/75B//884/oPY7jmDBiMFRAiYRHwL+EkZxQlhJhLGfly4GvgzfDlFkoLbBRwzGir2055TPHSD08OrOu5l2QMx8Dg8GQTmV0jOQIE63Lp+vgTfks+TqwYY6RMo4Rffxy2yJfIPvI9u/fr0Y9GAyGG/gG2VvHiG+QSktLYbVaJTsfaiU/S0Xr8uk6eNNTVsoxYjlG2qCUY2Q/XN/X5SvhGHlzH/IdNEDe8fsKj4+spKQEZ86cAQAkJiaKDpTBYCgLnXztDfYNEt1ASinf2zoo4RhpNUxYiZ5yaGgoOI4DIYQ5RgEIc4yUmeCRbocqhWMEAKtWrcLq1auFAwoNDcXjjz+O0aNHK1k3BoPxH0qH0gBbg+SJMFKqQZbTIFaWUBrHcQgNDUVxcbHsBwJLvtYeNipNmfvA30NpsjMIf/jhByxbtkyYOZYQguLiYixduhQ//vijGnVkMKo8SoXSPO2pad1T9Sdh5E1PGdA2z8ubUB5DuetQa8fIU+eUECK0RUo5RpUilPbll18CAO68807cc889AICff/4ZO3fuxPr169moNAZDBdQIpWkhjLQuX4lRaf4wMpDlGGmDUovIBuqoNDWEoT86RrKP7OzZs6hbty4WLVokvHbXXXfhvvvuw9mzZxWtHIPBsKFWKE0qlaVBViL52h+EEQulaUNlcYyUuA+9cYx0Oh2CgoJQVlbml8JIdihNr9ejpKREdIL4g2PrpjEY6qD0QxlgjlGghdJYjpH2qLWIrFS0HpWm1HxiQPl9UClCac2aNcORI0fwxBNPoFevXuA4Djt27MCNGzfQtm1bNerIYFR51HCMArWnqtWSIP4USmPCSBvo38CbNQurumME2O4Do9Hol46R7DP76KOPYtq0aaKZrwkh4DgOjz32mOIVZDAYys9jBASWY+QPM1+zUBpDjfswkEalKekY8efAH4WRbMnbs2dPzJkzB7Vr1xZGpcXHx2POnDno0aOHGnVkMKo8Widfa90gV8ZQmsViEZ1XqeUDLPlaK5S6DyuDY8RCaXakpKQgJSUFN27cAADExMQoWikGgyGmsiRf0+UHqjBSMs/LbDb7dCFdvV6P0NBQlJSUMGHkAVo7RloLI9ox0irXzhdIOrPZ2dkIDg5GbGwssrOznb7PEx8fr1ztGAwGAP+ax8ib3AqtJ3j0dFSaxWIR1oJU+jeQKoyUcu0MBgMTRh6ihmNUFYfrA/4dSpN0ZAMHDkSbNm2watUqDBw4EBzHOf0cx3HYt2+fohVkMKo6VqtVeChr7RgFBQW5vP/llq9F0qenyddKJ53yaCEOIyIikJuby4SRB/iTY6T1qDSl7oNKE0rjG2kGg6E+Sk0qBygjjLxBa8dIibXa/MG18+Y64POMmDCSj1KOkRLD9QPdMbLPtfOn6X4kHdny5cuFm2n58uWqVojBYIjxp4eyksIokHKM1Ji/BdBGHNLCiB9RzJCG1o6RPw2CUNo5jYiI8Gp/SiLpzHbs2FHY5jgOBoMBzZs3F33GbDbDarUqWzsGg1GpHCOtRYESjpFWoTQlc4z4/ZWWlooe0gz3VPVRaWoM1wf8TxjJzqKcMGECFi5c6PT1nj17KlIpBoNRTmUSRlo7RsHBwYJDEqihNI7jvEqAZ0P2PUep+yBQhZFaHQR/yzPy/O6yw2QysdwjBkMF1BgJAnjWIGstCrytA8dxgmuk9VIIgGfnwFtxTPfMi4qKvNpXVUOpaTP8SRgFWkjZF0g+sieffFLYPnPmjOhvk8mE06dPIyoqStnaMRgM5hhBWXEYHh6OoqKigAulKfUb0OFEf3sg+TtqOEaeDtf3pi0ICgqCXq+HxWLRzDHydBZ+XyD51z148CA4jgPHcTAajTh48KDDZ7p06aJo5RgMhnK5JYD2D2WtlwQByoVBoIXSlEr89VScMrRPvlbyOgwLC4PRaPQL59TfQmmSj2zAgAEAgB9//BExMTG4/fbbhffCwsKQkJCAQYMGKV9DBqOKo1QvEdBeGPmLYwQEXghB69+Aof1wfSU7SZ4II3/oIPgCyUf26quvAgAOHDiAFi1aCH8zGAx1qUyhNK1zjIByYVBVQ2lMGHlOZXKMvM21Y6E0itTUVADA+fPnkZGRAQBo0qQJGjVqJGs/ZrMZb7zxBvbt2wej0YjmzZvjxRdfRFJSEubPn4/NmzeLPnvbbbdhyZIlAIBOnTohLCxMGF0yZswYjB07FoDtR543bx7S0tIQFRWFZ555Bv369RPVf9myZTAajejduzdmzJjh9Q/MYKiJP/TSlHooBwUFQafTwWq1apbbQD8QpM7j40+/gbfimAkjz6ksw/WB8uvAHxyjgA2l8RQWFuK1117Dzp07Ra/37NkTs2bNkpyAbbFYUK9ePaxevRo1a9bEunXrMHXqVHz//feYMWMGZsyYIXx2xIgRDlMBfPfdd6hZs6bDfj/66CPk5+dj06ZNOH36NJ577jm0bNkSCQkJyMjIwJIlS/DBBx+gYcOGmDp1KlauXClKJGcw/I3K5BhxHIfQ0FCYTCbNQ2mA7RzQQsEVLJTGoJfmqQyOkSfCSI0lQQD/c4xkD9efP38+fv31VxBCRP/S0tLwxhtvSN5PeHg4xo0bh9q1a0Ov12P48OG4dOkS8vLyRJ87e/Yszp49i7vuukvSfjdt2oQnnngCkZGRaNeuHXr06IGtW7cCALZs2YK+ffuiVatWiIyMxLhx40TOFIPhj1QmYQSUN8hahdI8meTRH0JpLPlaW5S8D5UQRt7MZQVo7xhVqlDa7t27wXEcRo0ahXvuuQcA8PPPP2PNmjXYvXu3xxU5cuQIatSogerVq4te37x5M+644w5ERkaKXh85ciQ4jkPXrl0xefJkVK9eHQUFBcjJyUFSUpLwuWbNmuHYsWMAbNMMdOvWTXivadOmyMrKQnFxsdNeo9lsdrhog4KCVJkplp81vKrOHl7Vjx9wfQ7oa1Cv13t1juiHenFxsaR9EUJED2VvfyNeGDgr39U5oHuqfCjOU+h73Wg0olq1ahV+x1e/gbv7gBan3pRPC7OioiK/u+f8tS2wdw29qR8trEpLS31+DQDl94HFYoHZbJYkdJS8D+jnqJz7wBukiknZwigiIgLx8fGYNGmS8FpSUhJ+/fVXFBYWyt0dAFt4bv78+Zg4caLDez///DMmT54sem3FihVo06YNbt68iYULF+K1117D22+/jaKiIuj1elHDZzAYhEnMTCaTaNZXXmyZTCanwmj16tVYsWKF6LWhQ4di2LBhHh2nFDIzM1XbdyBQ1Y8fcDwHFy9eFLaLiopw/vx5j/edm5srbOfl5UnaF91LLCsr86p8oLyn6e5Y7M/BjRs3hO1r1655VQe6sc3IyJA0jwz9GxiNRq/KLygoELazs7Od7svZfcA/lKxWq1fl0+10VlaW17+nWvhbW0DPEm42mxW5D8rKynDz5k3J1wDvcOr1eq/LpydkPnnypOjZ6IorV64I2/n5+V7VgT6frq5Dpa+Bxo0bS/qcbGH0wAMPYMOGDbhx4wZiYmIAADk5Obh+/ToeffRRubtDSUkJpk6dijvuuMNhuP/hw4dRUFAgmhoAAJKTkwEAMTExmDZtGvr374/S0lJEREQIE1bxQsdoNAozvYaHh4t+DL6BoK11mjFjxmDEiBGi19R0jDIzM9GgQQOvLdJApKofP+D6HFy7dk3YjomJQUJCgsdl1KhRQ9jW6/WS9kVb7ZGRkV6VD5QvSVFaWuqwL1fngL5HGzRo4FUdYmNjRdtS9nXixAlhu2bNml6VX79+fWE7IiJCtC939wEv6MLDw70qv27dusK2Er+n0vhrW5Cfny9sK3HegoODUVZWBo7jJF8D/N/BwcFel09HZ2rVquU0Z9ce2l2Nj4/3qg61a9cWtqOioiSfA18gWxhdvnwZZrMZQ4YMQceOHcFxHA4cOABCCC5evIg5c+YAsCVZzpo1y+2+ysrKMGPGDMTFxTm4QoAtJ6hPnz5uhQh/0gghiI6ORmxsLDIyMtC6dWsANiWcmJgIAEhMTBRG0gHAqVOnUK9ePZfJlyEhIT5fYFGn0/lVY+BrqvrxA47ngHY4+FFdnkILDLPZLGlfSpYPiHOMXO3L/hzQ+R0hISFe1YFeEsNdHWjocxAcHKz6b+DsPqDDmb4+fi3wt7ZA6fsgJCQEJpNJ1jVAh9K8Ld+TtoB2j729D+nyy8rKJJ8DXyC7xE2bNqG0tBQFBQXYuXMnfv31VxQUFKCoqAg//fQTfvrpJ/z444/48ccfK9zXvHnzUFJSgtmzZzsMmS0rK8O2bdtEQ+0B4PTp0zh58iQsFgsKCgqwePFidO3aVRAwKSkp+OSTT2A0GnH06FHs2rULffv2BQD069cP27dvR3p6OgoLC7Fq1Srce++9ck8Bg+FTlEz6pPNbpCY8KplwCYiFkdT1FbVOvmaj0hhK3wf8M0uLNQsBz64DfxiE4Atkn93k5GRJ835UxOXLl5GamorQ0FD06tVLeP29995DcnIy9u7di9DQUHTo0EH0vdzcXLzxxhu4evUqDAYDunTpgtmzZwvvT5gwAXPnzkW/fv0QHR2N6dOnC3MsJSUlYfLkyZgyZYowjxE//xGD4a8oOdstP1y+pKREM2FkP38J/bcr1FgSBNBmVJqno3GYMNIWJTsogHfCSInyPbkOlLwPK9WotI8//liRguvUqYMDBw64fP+OO+7ATz/95PB6586dsXHjRpffCwsLw9y5c12+P3DgQAwcOFBeZRkMDVFySRAAmgsj+wZZijDS2jHSeoJHeg4dNsGjNjDHSPv7wFf4TwCXwWA4RemeKt8g+YNjpEUdtO4pe3L8Sq+RxcOEkXSU/A2AcmEkZVSkfR20EkZqTfAY8DNfd+nSxeV7HMdh3759XlWIwWCIUUuY+ItjJLcOSi0JAmg/waPUB4LWwpChvHNb1R2jShVKk5osyWAwlEGt3Iaq6hgFYiiNCSPtUdox4gV2oAojlnxN8eqrr4r+LiwsxK+//oq///4bTz31lGIVYzAYNpRukAPdMaqKo9KUdCuYMPIMtRyjsrIyWK1WWcPlK0PydaUKpQ0YMMDhtaFDh+Lhhx/GyZMnFakUg8EoR43ka4A5RoD2oTTmGAUOauUYATbBIWcQgj90UCqzY6RI8jXHceA4Dr///rsSu2MwGBRqJV/br9HkCqWFmdaOkdbls+TrwEQtxwiQn2vmD8nXLMeI4sknnxT9bbVakZWVhWvXriEuLk6xijEYDBtqhdIAW4PsauZ3HjUdo6oYStPr9dDr9bBYLMwxCiDUdIykCiOtR6VpPQjBV8g+uwcPHgTHcU6TsIcMGaJIpRgMRjlqhdIAbYQRXZ4WOTZah9IA229QVFSkyfHzy0lYrVYmjGSgpmMkZcg+PZeVEveh1h0Efw6lyT6y/v37O8x8XaNGDXTu3Bm33nqrYhVjMBg21AqlAdIaJH9yjPR6vdcz72s9Kg3wThgpMft5WFgYioqKmDCSgVoTPALSHBN/GwSh1QzwvkD22aWX32AwGOqjdfKzPzhGfE+1MvSUAfkJ8EqHcZgwko/SHRRaWMgVRmxUmrrIPrLCwkIUFhaievXqCAsLwy+//IJDhw6hadOmGDRokBp1ZDCqNMwxUjbplBZGWvSUAe1HBvIPRSaMpMMcI+0HIfgK2aPS5s6di/vuuw/nzp3Drl27MH36dHz55ZeYN28ePv30UzXqyAhQvvjiCzRr1gzLli3TuioBjZpJn4HiGKk1GkfLUBpQeYTR33//jfPnzyuyL39F6+RrNVxDHi2WBNHr9cLcTQEvjE6cOIGoqCi0aNECO3bsAMdx6NSpEwghThd9ZVRNioqK8Oijj+LUqVOYNGmS1tUJaNRMvtZaGMntqSrh1gRiKE2tMIoSwuinn35CcnIymjdvjqysLK/3569oPVzfn+5DperA3wf+FkqTLYyuX7+O2rVrAwAyMjLQvHlzLF26FAkJCcjOzla8gozA5KuvvhK2CSGiG4ohD6VDaXIbRDWnC9DCMQoJCRESuLUclQZUDsdo4MCBAGzHsmHDBq/3569o7RipKYwC5T7wFbKFUUhICAoLC1FSUoILFy6gcePGAGwnydvRIozAhxCC3bt3Y/To0aLXb9y4oU2FKgFKN8iRkZHCdmFhYYWf96eeqhLlcxwnuEZah9KsVqukToNaYZTS0lLRvuVCCBFN3eJvPX8l0Xq4vtLXoMFgELaLiookfUdp51Tuuo2+QrYwaty4MbKzs9G3b18UFxejdevWAICrV68KThKj6rJu3Tr06NHD4fXr169rUJvKgdINcnR0tLBdUFAgq/zKIIyAcnEoRRgC6oXSAO3Dmd48lM6ePSv6uzJHDfzJMVKiHZDbQbKvA3OMKMaOHYugoCCYTCbUq1cPKSkp+Oeff1BQUCCIJEbVZcuWLU5fz8nJ8XFNKg9Kh9K0FkYRERHCttFolPQdtYTRzZs3ZZUPKPtAAOQLI62Gajtj165dor8zMzM93pe/o/Rv4M1wfaVGZ/JRHk86CFIWva0If80xkn1277jjDmzatAnZ2dlITExESEgIGjdujG+//RbVqlVTo46MAIJeSHjw4MH45ptvADBh5A1KN4j0faqFMKItfK2EUVRUFADPesqVzTFiwkgaWjtGSpev0+lgMBhQWFgou4OgVOoMfx/427QRHp3d6tWro3r16sLfBoNB1Ngxqg5WqxW7du3CxYsXUadOHaSnpwMAGjZsiL59+wrCiIXSPEdNxyg/P7/Czyv9UKYtfK2FUUlJCUpLSyt0gbQOpfnDUG1n/Pnnn6K/K7MwUjPHSAtxDNjuRX5uQikoOdEqUH4fFhUVoaysTLH9eovsWphMJqxZswb79+936gJ8//33ilSM4f+kpaVh4sSJOH78uMN7zZs3R2xsrPC3Lx2jPXv24MKFCxg6dKgidq/WKP1Q1DqURneitG6QAVs4rUaNGm4/r3QoTa5r5q+O0ZUrVxz+NpvNood+ZUHp+5AOKUtJflZLGAHynVOlyo+JiRG28/PzRc8MLZF9dPPnz8fPP/8MAA4LybJRaVUHQggeeeQRXLp0yen7zZs3R82aNYW/fSWMTp8+jV69eqGkpAR//vknFi9e7JNy1aSyJV/7QyiNdq3kCqPKEM5UQhhZrVbk5uaKXiOE4NKlS2jUqJE31fNL1Ex+1kIcA/JDynwHRYnOAQBR5CkvLy9whdHvv/8OAGjRogUSEhL8xvpi+JaTJ0+6FEWAo2Pkq1Da5s2bBVv67bffxqBBg5yOkgsklA6l+cNDmeM4EEIkPRCsViusVqti5QOOjlFFKB1K80ac+kvydV5envC70GRmZlZ6YaSFc6r0NQCUizOz2SzJ6VO6g2IvjPwF2UcXEhKCunXr4rPPPlOjPowA4bfffhO233jjDZw5cwYrVqwQXmvWrJkmoTT7ZNCpU6di//79PilbLdQMpUnJMaJFgRINMsdxiIyMxM2bNyUJI6WPHxALI7kPJSV6y3KFkT/mGLnq7FTWPCOlOyhazydmXwej0VihMFLaMaJDaf40153sBIwHHngAeXl5LJm2ikMLozvuuAN333236H21c4xmz56NuLg4jBkzBmfOnAFQPrkkzV9//eV3Ix7konRPkRYFct0KpRpEvrcsN4SgVPlyHSOlH0pahzOVEEb0PV2nTh1h+//+7//w/PPPY9WqVZ5X0A/RehCCGh0ET8UZc4zsyMrKQklJCYYMGYLOnTuLTizHcZg1a5aiFWT4J7wACQ0NRefOnR1u7AYNGkCn0wmjHpQURoQQLFy4EMXFxVizZg0+//xz9O7dGyaTyWGCOavVimPHjqFjx46Kle9rlO6pBgcHIyIiAkVFRZIeykouHMnDCyOtesqBHErzF2FEd47bt2+Py5cvAwDOnTuHJUuWALBNCNyrVy8vauo/KC1MvAmlqZVrJ7UOauUY+QuyHaPNmzfDYrHAaDQiLS0NP/30E3766Sf8+OOP+PHHH9WoI8PPuHz5Mk6fPg0A6Ny5M0JDQ1GjRg0MHjwYADBkyBBhNBjvGinpMBYWFooac4vFgm3btolcLDqZ9siRI4qVrQVqNIj8g1mLhzLguWOk9QNBp9MpMtKxMuQY0ff0nXfeKXrI8WzatMmjffsjlTH5Wq5jpPToUPqa8adQmuyjS05OZqPPqjh///23sN2tWzdhe+3atXjxxReRnJwsvBYbG4vz588jNzcXhBBFrh36BmrYsCHy8/MdcmWefvppvPbaawACXxgp7RgBtgdzdna27BwjpXqKfINcUlICi8Xi9rj8wTFSOoRQ2Ryjxo0b4/fff8cvv/wCo9GIl19+GQCwc+dO4TMffPABUlNTsXDhQrRv396jMrWksq1Z6E0d1Mgx8ifHSPbZ/fjjj9WoByOAoMNV9OiT0NBQdOnSRfRZfsi+xWJBfn6+016lXOghwvfccw/ef/99ZGVlYdu2bVi6dCmSk5MxceJEJozcQDtGFQlWNR0jwNZbpoWCL8r3NPlaK2Hkj8nXdHi8Zs2aaNWqFVq1agUA+N///oejR4/iwIEDmD9/Pm699VY888wzAGxzHdGdq0BBacfIm7mslGoH5N4HajpGAS2MeA4ePIgTJ04AAFq1aoUOHTooVimGf0NP6lbRwsH2Q/aVEEa0Y1SjRg2EhoYiMTEREyZMwIQJE4T34uPjkZ2djcOHDyvmVmmBGsKAH7LPD5mne47uylc6xwjQXhjJyTFS6vi1dozoyQWlzmFjD+0Y0XOWAbbQ2tGjRwHYkrFpDh8+7FF5WqO0OA0NDYVer4fFYpElSpQqH9DeMao0obSSkhJMmzYN+/btE73etWtXLF68uFLOeMoQ46kwysnJQVJSktfl0zcQbcXa07ZtW2RnZyMnJwfZ2dmikTOBhJqOEWB7MLsTRmo0yHIST/0px8gfQmlKXANK9NRpYWQ/Md+dd96J999/36P9+itK/wYcx8FgMKCgoEC2MFLqOStHGFksFmFSZzVmvvYnx0h2FuEnn3yCvXv3ghAi+rdv3z6sXLlSjToy/Aw6lBYfH+/2s3FxccK2/fIBnkKH0twJo3bt2gnbBw8eVKRsLVBjmK6cuYx84Ri5Qw1hpnWOEV2+FuvVKTF/TEXCyJ3YDkTUHC4vJZSmZq4fULEwUqN8erLZgBZG27Ztg06nw/PPP4+tW7di69atmDJlCgAIS4UwKjdyHKP69esL2xcvXlSkfPtQmis6d+4sbNsvdhlIqJFbIGf2a7UtfDnCSKt5jJQOpen1ekEcapFjpERPnc8xioqKEi2KC9juy59//hn33nuvx3X0N9SceVquY6SGMKroPlCj/KCgIKEO/hRKky2Mrly5goSEBDz88MOIiYlBTEwMHnnkETRq1EgxR4Dh3/C/c3h4eIW9QjWEkVTHqGvXrsK2feg3kPBFKM0d/uQYqSGMtEi+BrSdMkGJ3A7eMXK1vtVtt92GtWvXOn3PZDJ5VKaWqOEYyZm2ojI6RkB5Gx7QjlFERASuXLmCa9euCa9dvXoVV65cETV2FWE2mzFnzhykpKSgZ8+eeOKJJ5CRkQEASE1NRdeuXdG9e3fhHx2+OXbsGB5++GHcfvvteOKJJ4SJxQDbCIuZM2eiR48e6N+/P7Zs2SIqNzU1VShzzpw5oh+bIQ1eGMXHx1eY0NygQQNhW6mlAqQ6Rg0aNBBCfX/++afTdZ0CAbVDaVo4RnJyjLTuKQOVTxhVq1ZNuHc9eSBZLBahg2KfeE0TExMjSvTm8aeHoFTUdIxKS0thNpvdfrayCiNepPvTNSFbGHXo0AFFRUUYMmQIJk+ejClTpmDo0KEwmUyi+WsqwmKxoF69eli9ejV27NiBHj16YOrUqcL7Xbp0we7du4V//APObDbjxRdfxEMPPYQdO3agdevWotm2P/roI+Tn52PTpk2YP38+FixYgPPnzwMAMjIysGTJErz11lv46aefcOnSJZYXJZPS0lLBQq8ojAaoH0pz5xhxHCdMH5CXl4dTp04pUr6vUaNBDtQcIyUtfH7IuhahNMBxygR3KH0N6HQ6oXxPHCN6AVl3wgiwOcv2+FPYRCpazyNECyctnFO1hVFxcbHfLN8kWxg9+eSTwnICf/zxB37//XcUFRUhPDwcTz31lOT9hIeHY9y4cahduzb0ej2GDx+OS5cuVagaDx48iPDwcAwaNAihoaEYP348jh8/LrhGmzZtwhNPPIHIyEi0a9cOPXr0wNatWwEAW7ZsQd++fdGqVStERkZi3Lhx2Lx5s9xTUKW5evWqsC1FGEVFRQn5LEo5RlJDaUDlCKepEUqr6jlGQPlDQWvHiJ8ywR1q/Ab8veOJSHE3VN+ekSNHOrwWiMJIjfvQ0w6CFqPS1A6lAf7jGsm+w5o0aYJPP/0Ua9aswfHjxwHY5jEaPXq0aLI/uRw5cgQ1atQQ1OPhw4fRp08f1KhRA8OHD8eQIUMAAGfOnBEN+Q4PD0f9+vVx5swZGAwGhyHhzZo1w7Fjx4Tv0jM1N23aFFlZWSguLhZNeMZjNpsd7M2goCBVpiTge1/+Hu6hw5a1atWSVN/69esjPz8fFy9ehMVicRp+k3P8fKOq1+sRGRnp9jt0Avb+/fudNtL+gqtzQPdUOY5T5BqhG8T8/Hy3+6QbRL1er0j5tItQWFjocOx0GSUlJcJ2UFCQYvdIVFQUrl27hps3b1a4T1oYKVk+T15eHiIiIlxeA3Q7pFQd6BCGq/vSFYcOHRK269ev77Y+M2fOxKFDh7Br1y7htZycHJff8de2kP4NdDqdIvWjhVFBQQGsVquka0Cp+5AOc1Z0H6h1H9KdtNzcXNFzRelrQOpyPh51PRo1aoTZs2d78lWnFBYWYv78+Zg4cSIAW7hu/fr1iI+Px/HjxzFt2jTExsaiV69eMJlMDrlMBoMBJpMJRUVF0Ov1IpFjMBhQVFQEAA7f5R8OJpPJqTBavXo1VqxYIXpt6NChGDZsmDIH7gSlXBW1oGeRDgsLE8KU7uB7lCUlJTh06JDLZE1A2vHzrlV0dDQuXLjg9rN0DtJff/0lqb5aY38O6J7cpUuXFOmt8fcEAFy4cMHteaEdlcuXL4u+6yl07zgrK8uhfPocZGVlib6n1G/Ij6S6efNmhfvkxaHValWsfNp1SE9PFwlQ+2uAdkmvX7+uSB14cVpaWor09HSnuUCuoNfFbNGiRYX1WbNmDT799FPMmTMHgC2toaLv+FtbSLsZ165dc/rMkAv94M/IyBD9BvbHT7t0N27cUOQaoMvPzc11u0/6vZKSEtXuA7rTpPQ10LhxY0mfkyyMDh48iB9//BG33XYb+vbtK3pv27Zt+OOPPzBgwADZq5iXlJRg6tSpuOOOOzBo0CAAQL169YT3W7dujYceegi//vorevXqhfDwcAfL0Wg0Ijw8HBEREbBYLCIHyGg0Cheb/Xf5B46zGDgAjBkzBiNGjBC9pqZjlJmZKaxK76/QuRDNmzdHQkJChd9JSkpCWlqa8Lez78g5fv5BXbNmzQrLT0hIQM2aNXH9+nWcPXtWUn21wtU5oEMnTZo0UWQGb9qFys/Pd3te6PITExMVmZ+GbqCCgoKE8p2dA9pqj4uLU+w35EWz2WxG3bp1XQpOq9UqXPcGg0Gx8ukJRyMjI5GQkODyGqAfwg0bNlSkDnQoPDo6WtTuVgQ/L5her8cDDzwg6ZpITEwUtvV6vctj8Ne2kG73GzVqJMqf9BT6GoiKinJ7DdCiqV69eopdhwaDAUajEWaz2e0+7XM7lSq/YcOGwnZoaKjbc+ArJAuj9evXIy0tDaNGjXJ4r1mzZpgxYwYKCwtlCaOysjLMmDEDcXFxmDx5ssvP0Q+CxMREfPvtt8LfJpMJFy9eRGJiIqKjoxEbG4uMjAy0bt0aAHDy5EnhhkxMTBRGvgHAqVOnUK9ePZfKPyQkxOczeSu1erda0KMR4+PjJdWVvvAvXbqETp06ufxsRcfPr7kG2G5OKeW3atUKu3btwuXLl5Gfn19hXpLW2J8D3knQ6/WK5TY0btwYQUFBKCsrw+nTp92eR1pEhYSEKL66fFFRkcM+6XNA53YoVT4gDmUZjUaXIxztk26VKp8OIRQWFor2a38N0HUIDQ1VpA708ebn54tGkLojOzsb6enpAGyhanfLudDQTnF+fn6Fx+BvbaEavwF9DdrfB764BgCbKDcajQ7XoD1q3Yd0e1xQUOD2HPgKySWeOHECsbGxTvOIEhISEBcXJ+QcSWXevHkoKSnB7NmzReLnjz/+ENRpeno6NmzYgO7duwMAOnbsCJPJhNTUVJjNZqxcuRKtWrUSlHdKSgo++eQTGI1GHD16FLt27RIcrn79+mH79u1IT09HYWEhVq1aVakmIPMFciZ35KF7Vt5ao/n5+ULvXarA4Re2BCCs7xdIqJH4S7s0GRkZbkdFVcZRaYD0SR7VKt/TKRPUWKdKTtIr7f7eeeedkr+nxGzbWkLn+CjVYZZzH6gxKg0ovw+0HpUGBGDydW5urtseRVRUlKyH3uXLl5GamorQ0FD06tVLeP29997Dvn378Oqrr6K4uBhxcXF47LHHBHETEhKCN998E6+//joWLFiAVq1aCauoA8CECRMwd+5c9OvXD9HR0Zg+fbog5pKSkoQpBoxGI3r37o2xY8dKrjMDOHfunLBdt25dSd+hrxtvh+xLncOIhhZGx48fx2233eZVHXyNGkPFAdv9cPr0aRQWFuLatWuoVauW2/IB6cmLFRFIwkiNYdqA9sLIU6FCJ17zHVY1y/MX/GkeISUjGVJn3/aFMPKX60LyXW4wGHDx4kUUFBQ4WKf5+fnIzMyUNcFjnTp1cODAAafvJScnC8uMOOOWW27B+vXrnb4XFhaGuXPnuvzuwIEDMXDgQMn1ZIj5559/ANjysqSOQqSFES2sPEHOUH0ee2EUaKjhGAG2fCWejIwMl8KILl+J/CbAP4SR1HWaKqsw8vSBRNdVqmsMMGHkDH+YtoK/DktKSmAymVzm3Fal4fqSu38tW7ZEaWkpXnnlFdHD6caNG5g5cyZKS0vRsmVLVSrJ8A+Kiopw+vRpADZxKtU9aNy4sfBA9XaSRU8cI/q6DMRQmpqOEQ//uzqDFwZKlq/1zNeA9AZZa2EGqBNG8fSBRD/A5XSG/dEZkIMa14E/3Af0Qt90Dqmvyg/oUNr999+PPXv2YO/evRg4cCAaNmwIjuNw/vx5lJaWguM4PPDAA2rWlaExJ06cEHJR+OR2KfAjDc6dO4dTp06BEOKx80DnN0gdFVKnTh1Uq1YN+fn5wpxWgYSvHCNX8A2ikuWHhIQIyd9a9ZSlNshqOUb0xIjuHkiAOmEUTx0c+veSM0IxLCwMYWFhKC4uDkhhxItTvV6vaOIzj1bCiHaKr127Jhos44vy/VEYSf51e/fujQEDBoAQArPZjNOnTyMjIwNmsxmEEAwYMECUK8SofPBhNECeMAJsIxcBmw1f0UPAFVarFZ9//jkAW+N0//33S/oex3FCfTMzM/3m5pOKGo4NIHaM3AkjNcrnOE7yApq+cIzcPajVEkZSe+qAfyVf0w9wOY4R4J8LhkpFDefWH0LK9HVIr2zgq/L9McQqS/a++uqrmDFjBlq2bInQ0FCEhISgZcuW+L//+z/RemWMyok3wqhp06bC9smTJz0qPy0tTUjwv+eee2TlN7Rt21bYpiepDATUcGwA8VxC7kJpapXPh0Kzs7PdjorTuqeqdQhDrToo4Rh5Koz85QEoBzWEkdZrpQHah9IiIyMFB85fBLPslu6BBx5gIbMqihKOEWDLM7rjjjtkl//VV18J24899pis77Zr107YPnLkCHr06CG7fK1QyzEKDw9HvXr1kJWVhTNnzvi8/KZNm+Ls2bPIz8+XPCquMjlGkZGRCA0NRUlJiSxhpFQdvHWMgoODZYf1+HNuNBpRUlIizD4eCKgtjLRYKw3QXhjpdDpUq1YNN27c8Bth5D+zZzH8Hj4/p1q1apKH6vPQjpGnCdiXLl0StuUKG1oYHT582KPytUItxwYoz9O6fv26qOHzRfm0WP73339dfk5rx0gtYcRxnPBQkiqMlBwZ6K1j5MkM6PRIVnrYfyDA/wZKihJ6ZCK95Ie78gH1coy0CKUB/uckMmHEkERZWZkwB1HTpk1lN870Q9DTUBq9RpecdZ0Am8PF1znQQmlqOTaAbfZywLbUi6uHs1rlN2/eXNh2d01oPX+Kmg8EXhhdv35dUjhRyfLDwsKEhzw/m7wUeMdIbhgNEE8I+csvv8j+vpbwoSylr0FeFFTUYdQ6pKvmfUAvaOzuPvAVTBgxJHHjxg3hgnUV8nBHQkKC0Nv21DEymUzCtlxhFBkZKYzCOnr0qGh6e39HTceIF0aAbdJVX5YvVSxrPVxfLccIKH8olZWVua2DGg9loHySS3cTXNrjjWPUu3dvYXvHjh2yv68laohTjuOE++DChQuiNs5V+UrXwZ+EkcViqTCk6AuYMGJIIicnR9imhxlLJSgoSFizzl2irzt4x0iv13t0Y/IJ2CaTyeM6+Bqr1SqsgK2mYwTYkqCdoZZjpHUoLTw8XNifFjlGgPyHktbCiBAiPLg8cYwaN24sLEXz+++/o7i4WPY+tEKt34C+D6RMm8FxnGJrJgLiNey0DqUB/hFOY8KokpOZmYnXX3/d6/ARHf/2RBgB5Q9ho9HotmfkCv47ct0iHnoG7EARRmo+lAFpwkgtx6hhw4ZC8q0WjhHHcZKGj/silAZIE0ZKL2otVxiVlJQIbqsnjhHHcejTp4+wrz/++EP2PrRCrd9AqnOqlmsYFBQkjBDV2jEC/GNkGhNGlRhCCAYPHoxZs2ZJnvPHFbQwonsYcqBnqvakV8A7Rq6mrK8I+9W9AwE1FnCl0dIx0ul0QlJ+RkaG6FhpfNEgV3XHqLi42OX5p/FmqD5Pt27dhO309HSP9qEFagkTuSFlpYUZUJ4ewYSRDUWE0dChQ9GlSxd07dpVid0xFGLnzp3Yv38/AODs2bNeWZRKOEa0MKFDc1Lx1jGSswSDv6DGMG2aioSRxWIRcsvUKJ9PwC4tLXW5jp4vLPyCggKXeWdVQRgB0lwjeq4dTxwjQNwOVLRGnL9ACFF12goeKcJIjQ4Sfx0WFha6dPN9FUrzh7ZZEWFECBH+MfyDvXv34t577xW9dvbsWY/3p4Qwoh0jer09qXjrGNG9EuYY2ahIGKldPp93BkAY9WiPr3qqrq4JfwqlKV0+PVxcijBSwjGiOyiBIozUvA/8SRgBrq9DX92H/pBjpEj3Z9iwYX6h8hg2fvjhBwwaNMjh9bNnz6JDhw4e7VNrx4gQwhwjFRwbevZwZ8JI7fL9qUHOy8tzujCxrxwjKYmvajpGUkSKEo4RLcbUFEYWi0WxJGW1JlcEbOexbt26uHTpkt8II2frpVWlUJpiwojhP7iaH8RVqEIKWjtGpaWlQqiDOUbKER4eLiywq4VjRF9Lria403o0DAullaOEY6S2MLJYLEhJScHevXuxceNG9OnTRxhN56mYU2s5Dp5mzZrh0qVLuH79usvrUE1hJGWSRxZKYwQ0/HpiADB//nxh259CaXIdI2/mMOLxt16JFNR2bACgTp06ACoOpVUFx8jX5Us5fjXzW7zJMfJXYfTrr79i69atKCgowOjRo5GZmYkOHTqgevXq2LBhg0f7VPMaAByXTHKGWsnfgPYdlIAMpXXp0kXSzjiOw759+7yqEMN7Lly4AMA26mfkyJGYMWMGAO+EES1knIUbpECH0uQ6RvSs1546RoEYSlNbmAC2PKP09HQUFhaisLBQ1KtW+4GgdYOstWNUvXp1BAUFoaysTBNh6I1j5K+hNPoZdPHiRXTr1g1ZWVkAgEWLFmH48OGy9+lLYXTy5EmnC2SrOSqNvg+0yLXzN2EkyTGik6sr+sfQHl4Y1a1bF/Xr10dYWBgAZRyjmJgYjx8O3oTSvFkOhIcWRoESSlO7QQbECdhXrlwRvcccI3XPAcdxQofBlYuqZn6LFqG08PBwIfdHDWH022+/if7mRREAHDx4ULTmolT8wTFSM5SmtXNKd5orWjPOF0i6y1999VW168HwkIKCAqSlpaF3794wGAwwmUzCA6Zhw4bgOA6NGjVCeno6zp07B0KIR4tQ8herp2E0wLvkazqU5qljFBQUBIPBAKPRyBwjCvtlQfilUwD1Q3n+5Bhp8UAAbOfgypUrmhy/FsP1OY5DdHQ0bty4obgwunTpkoMwsufHH3/EE088IWu/aopTQNpcRr4SRhXlOKlRh5o1a0Kn08FqtTp0zrRAUks3YMAAtevB8ABCCO677z6kpaWhXbt2WL58OX7//Xfh/QYNGgCwTcOfnp4Ok8mEK1euiB6EUigtLRUeGp5O7gho7xgBtgbAaDQyx4iCbhTtH1RqJ19HR0cjODgYpaWlFS5iq0Yd6GvS1WrvaotT/p4ymUxO55BR8xrQYrg+X67Swujll1/GggULnL4XFxcnXF8//PCDbGGkdvJ148aNodfrYbFYnDpG9HxildEx0uv1qFmzJq5eveoXwkhy8nVaWhr+/vtv4e/CwkLROjfbt2/H+vXrFa0cwz3bt29HWloaAODw4cPo1q0bpk2bJrzPD7ls1KiR8JonI9NoEeONYxQeHi6E9bRIvgbKw2nMMSqHfsDRAhRQ3zHiOE64pipyTHQ6HXQ6ZceLdO3aVXCNNmzY4HStKl8JI8D5feErx8hXw/WBckGmpDD6/PPPXb735ptvom7dugBso3btr/OKULuDEhISgsaNGwOwOUb2aSlql+8PzimfV3XlyhXN03IktzLTpk3De++9J/zdq1cvTJw4Ufh77dq1ePvtt5WtHcMt9IgzZ/DCiJ5Ez5OV7ZUYkcbDPwS0SL4GyntGRqNRdKP7K75wjGihab+ytdqOEVCeZ3Tt2jWnDaKaIYTIyEhMmTIFgK1X7sxx8GUCupbCyNeOEWDr8ChxH5aWlopyiUJDQ0X1e+CBB4TIR3FxMbZv3y57/zxq3Qf8RI9Go9FhyLzajpXWjhFQLozMZrPmjj4brh+gHDt2DDt37hT+djaRGS+M6MVTjx8/LrssJYURH7rIycmR1StQyjFyFzbyR3ztGNkLI19MF8BfU2azWeRI2NdBrfKfffZZ4Rw4e2D60jFy5pqp+VDUIscIkB/Cqwg6obpevXo4duwYfvjhB/Ts2RNr1qxBtWrVMHDgQOEzqampsvavdo4RIM4zsh8oo7YoMRgMwjNEa2EEuJ/s1BcwYRSg8GugAcDChQuRlZWFyZMniz7D5xh5K4xod8ebHCP6+yUlJS7X5HGGUo5RoA3Z90VP1V0ozZeOEeB8ZJqajhFguybq1asHwPk1UVVCaVo4RoAyHRR+JC5gW7uzSZMm6N27N3bu3IlRo0YBAPr06SO0HampqbBarZL3r7ZjAwBJSUnCNj0XHaC+MOM4Tug0+oMw0jrPiAmjAOXo0aPCdvv27VG7dm088MADos/wjlHDhg0Fl+XYsWOyy6IbLrpB8wRPE7DVcIy0tmul4AvHyF0ozZeOEeDcMVFbGAHinBdf53cEaihNKcdIaWHkbDkLwNahuuuuuwDYHrwHDhyQvH9fdFDoPB9396HagzCYMJIpjP79918MGjRIWIeL/vvff/9VpYIM59DCqG3btgCAbt26iT7DixCdTie4RmfOnJHl1ADqCSM5CdjMMWKOkZrCiL8u+KUjaHzpGDnrLKjpFtC/va9mvgbUFUa8U+6M/v37C9u7d++WvH9f34f2bbSvhZG7XD+16hCwobTS0lJcunRJiOeazWbh70BIZK1MHDlyBICtt8lfUMHBwVi8eDHCw8Mxc+ZM0XxFvDAihMgWsXSDSfcwPcHT2a+ZY1T5c4wA7R0jwPG60DrHSM0Hkk6nE+5pOY6RTqcTRph6grvz7Ql06MmVYwQAt956q7D9559/St6/L3KMtBZGvGNltVqdXgtqjg4F/MsxknyXJycnezQxIEN56Lke2rZtK/pdnn/+eTz33HMOydh0ntGxY8fQvn17yeUp6RjRD0Fna3O5IpAdo/z8fGzfvh133323bGFZlUalAf4hjAoKCoScI7p8QP1JLn0dSgNsnZ2bN2/KGq5vMBi8eh5oEUoDgFtuuQXh4eEwmUyiPM2K8EWOEX0f2ju3vijffmSafVuv9n1IL2QbMMLo448/VrMeDBk4C6PROBuhdssttwjbchOwlXSM6DmV5CxRooZjpKYwIoTg6NGjqFGjBgYMGIDDhw+jXbt22LNnjyxhV9nnMQLEwkDrUBrg3jFSow5aJl8DkOUY8Z/xJr8IUE8YBQcHix6w9gQFBaFDhw74/fffcfbsWVy/fl3SSNuqFEoDbG2jvcBU+z70J8eIJV8HILQwatOmjaTvtGzZUth2NeW8K5R0jPhJzAB5wkjpeYwAdUNpn332Gdq1a4cGDRrg8OHDAGyTcNITcEqhKjhGderUEbadrWOlhWNEo7Y4rV69uuC+OBNGarsFvDAqLCx0O4UGIUQQrt5O26GUMDp58iRatmwptIkNGjSoMMxDL4ou1TXyJ2GkViivok6jLx2jgMoxYvgH9AzkUoURHRqQE8IClHWMPBVGSs98DajrGH355ZdOX1+6dCnS09Ml70frHCNflE8ny9oPUwZ87xjZP6jVds30er1ofi97fOUYWa1WdOvWDZcvX3b6uYKCApSUlACA09Xf5aCUMFq+fLnofpJSr86dOwvbnggjX+QYuXNufeUY2aP2fRgcHCzcB8wxYsjm4MGDAGyNtFRhFBYWJjT+ci86JR2jmJgYYR9nzpyR/D2lHCN6SKzc2belQghxaHDpOu/atUvyvnzh2NB106JBjoyMFH4Xe2FECIHFYlG1fEB68rVadeDDaVoKIwDYt28f1q1b5/RzdC/eX4SRfSeDngvIFbRj9Ouvv0oqx9fOrT+E0uzxRQeFXhZES5gwCjCMRqOQI9SmTRtZI0P4i85Tx0in03nl1gC2icT4JUouXLggeui4QynHqKKh4Upw4cIFYd/169fHr7/+KppRed++fZL35YscH47jhHOqhWMElCfMXrx4URBCgG8eCIC2oTSgXBjl5+c7jPBV+xw0adJE9LeraTToh5W7PB4pKCWM6KRrjuPw8MMPV/idxMREQUClpaWJlhJxhS+Sn7XOMapovTRfCqOioiKHtsiXMGEUYPz999/CjK0dO3aU9V3+ort586asRRT5hisqKkqRkYl8OM1iseDixYuSvqOkY8Qnp6sVx6bdotGjR+POO+9EcnKy8FCVI4x84VYA5Y2yFo4RUC6MSktLRSPTfFW+1ORrtYUR4PhQUjuM8/LLL+POO+8U/nb1QKKFkT84RoQQIRyfmJiIq1ev4t57763wexzHYeTIkcI+XDlkNL64DoODg4V92wsjLUal2eMLYfTss8/i448/xrfffqtqR6wiNBNGZrMZc+bMQUpKCnr27IknnnhCWNk6NTUVjzzyCHr06IFBgwbh66+/Fn23U6dOuOOOO9C9e3d0794dq1atEt4rLi7GzJkz0aNHD/Tv3x9btmwRfTc1NVUoc86cOQE3/xIfRgNs50EO8fHxwrYcq5J3jLzNL+LxJM+Ibii8EUY6nU5wjXwhjPh8hvDwcGEE4fHjxyU/DHzhGAHlwkgrx4jOM6JzXPzBMfJFHaQKIzXKj4uLw7vvviv87UoY0feLt46RErl+V69eFYR88+bNZSWEjxgxQtj+4osvKvy8L3KMgHI3XOscoxs3bji87wth9MADD2D8+PG47777EBoaqlo5FaGZMLJYLKhXrx5Wr16NHTt2oEePHpg6dSoAm2h6+eWXsWPHDrz99tv4+OOP8ddff4m+/91332H37t3YvXs3xo4dK7z+0UcfIT8/H5s2bcL8+fOxYMECnD9/HgCQkZGBJUuW4K233sJPP/2ES5cuYeXKlb47aAWgFz+UK4w8HQ7JPyi8zS/i8UQY8Q1FUFCQ1zcm36hfvXpV1kK2UnEmjIDy3AZCiEjgusNXjpGrUJqvHSNAPDJNC8dIi1AaXb79Qrq+HhHlC8coMjJSuOakusb20DmKfHheKklJScK9efjwYafzZ9H46jrkf4fi4mKX5VfWUWn+hGZeVXh4OMaNGyf8PXz4cLz77rvIy8vD4MGDhdebNGmCLl264Pjx4+jQoUOF+920aRMWL16MyMhItGvXDj169MDWrVsxfvx4bNmyBX379hUmOxw3bhzmzp2LJ5980um+zGazyMIEbA2jGhcmHx5ztbBhSUkJ+vfvLyQLBgcHo1WrVrIWQqQbs8uXL0v6rsViERrKqKgoWeW5gp7L6PTp07BarRUeP+8YRUREeF0H3jEym83Iy8sTPZTkQAjBsmXLsGnTJpjNZsyaNQt5eXnYuXMnAFt+Ue3atYX6du7cGcuXLwcA/PHHH+jZs6dof87OAX396XQ6Rc6/M+hQmsViEUKmdIOsZvn169cXti9duiSUw4+CAmz3nlrl0/Py5OXlicrxxTmg3djCwkKX14Ber1elfDpX0Wg0Oi2Dzk2sWbOm1/VISEjAiRMncOHCBdE1V1FbwMNHGABbZ0tufTp27Ch0Yv7991/RckX20NehWr8BIL4P6TJ8cR/QHd/c3FyHMmhhpNbx80i9BuQidcZu7YJ4dhw5cgQ1atQQqVbA9mA+duwYUlJSRK+PHDkSHMeha9eumDx5MqpXr46CggLk5OSIRiY0a9ZMWDj1zJkzovXEmjZtiqysLBQXFztNYl69ejVWrFghem3o0KEYNmyYt4frEmfDlQFg27ZtohEUnTt3lp1ETfd2jx8/Lmn2a7r3HBwcLLhv3kBbpEeOHBHt09Xx8/UICQnxug507/jQoUMiB0sO+/fvxzPPPCP8nZ6eLlpnaOTIkaK60uV8/vnnePjhh53mbNHngE6Ezc3NVeT8O4NvMAghOHnypHA/0OGTGzduqFY+3Qu9dOmScA7oxNjS0lLVyqev86tXr4rKoaeruHz5sipJobQrZTQaRdcAfZ/n5+ercg7oY8zJyXFaxrlz54RtJX6LWrVq4cSJEyguLsbBgwdFAyMA120Bz6FDh4TtyMhI2fWhQ2979uxB3bp1XX6WdpTUvA/pHCNX10BBQYEq5dMC/OLFi6Iy7Duvah2/PRVdA3KR2tb7hTAqLCzE/PnzMXHiRIf3li1bhri4OJGgWbFiBdq0aYObN29i4cKFeO211/D222+jqKgIer1eJHIMBoMQhjGZTKKHIt9LNJlMToXRmDFjRLFoQF3HKDMz0+UEZfSF2KFDB3zzzTey4/z0JI9lZWVISEio8Du0zR0XFyfpOxVRp04dBAUFoaysDOfOnUNCQkKFx8/3VqKioryuA31zBAcHe7y/H3/8UfQ3/RB/8MEHMXfuXJHwSUhIQLdu3bBnzx78+++/uHbtmijU5uwc0CPw6tWrp8j5dwbdW65Zs6aQ80I7GXXr1lWtfPo8Xbp0STgHtFtTrVo11cqnR8KZzWZRObRoS0xM9GrxVFfQOVZGo1F0DdC/QZ06dVQ5B/TxW61Wp2XQIb4OHTp4nQPSvHlzpKWlOZRZUVvAQ0+30aVLF9nnhR62f+PGDbffp+/DBg0aqHYd8saA2WxGnTp1hGcN7ebUrl1btfJjYmJw48YN5OXlicqgHavIyEjVyueReg2ohebCqKSkBFOnTsUdd9yBQYMGid77+uuvsWPHDqxatUrUcCYnJwOw/YjTpk1D//79UVpaioiICFgsFpEDZDQahYs6PDxc1Nvjb3RXybwhISGqJto5w9UCfXSO1caNG0WJ1FKhe0RXrlyRdMHRjWG1atUUuUjDwsKE2WrT09NRWloqPHxcHT8vbsPDw72uAx1SvH79usf7o4cK2/PUU085XZpl3Lhx2LNnDwBg5cqV6Nq1q8Nn6HNAP7BCQkJUayToUJLJZBLKoZ0MNcuvX7++EKa6fPmycA58dfw6nQ6RkZEoLCxEQUGBqBxfnAP7HCP6GqDLDw0NVaV8nU6H0NBQlJSUwGg0Oi2DzzGqVq2aVwMgeOiQemZmpmiBV75O7o6Vzk9s0qSJ7PPSokULYfvUqVNuv++L3wAQu9n0c8xX5deuXRs3btxweD7Q92FwcLDPxIpaC9ZWWK7PS6QoKyvDjBkzEBcXh8mTJ4ve27p1K1avXo0PPvjAIbxGQ4cAoqOjERsbK4o9nzx5UkjMS0xMFL136tQp1KtXz6tVon0BnawbGxvrdpFEd3iSfK3krNc0/AitsrKyCmeCJoSIcoy8Ramp593Zybx4t2fYsGGCCFm9erXDoAJ7fJX06WpZEF8lfwcFBQlLg9BhA18dP1AuTrQYlUY7Au6Sr7UYEcXD3yveJl7z0K6DJ6EZPrQXGxvr0cCQRo0aCZ2XU6dOuf2sL4bLA66T4H11H/C/rdFo1KR8f0FTYTRv3jyUlJRg9uzZIkdo7969WLRoEd555x2HuO/p06dx8uRJWCwWFBQUYPHixejatavQYKSkpOCTTz6B0WjE0aNHsWvXLvTt2xcA0K9fP2zfvh3p6ekoLCzEqlWrJM17oTUXL14UJgzs2LGjx3MJeSKM6IeEGsIIsOUZuYNOBHQnkqWitjBKSEgQDb+miYyMxJQpUwDYRMewYcOwceNGl6PjfDVc3tVyBL6aLgAoFyauyle7QeYfrq7mMeI4TrXeK31vaTUy0NWUDYDNveDbAm+H6vN4I4wIIYKAppc7kkNwcLDQaT516pTbEaq+/g0A18JITXHs6hnBhJGPuHz5MlJTU3Ho0CH06tVLmJPo0KFDWL16NQoKCjB27Fjh9fnz5wOwPSSnT5+Onj17YujQodDpdJg9e7aw3wkTJiAyMhL9+vXD9OnTMX36dMGyTUpKwuTJkzFlyhSkpKSgdu3aoqH+/go9tFvupI40oaGhgrCQmrhNO0ZKDdcH5AkjOmSlRGxbbWFU0ejJV155RfjM6dOnMXjwYLz33ntOP6t1g+wrx4iuQ1FRkfCQ0sIxKiwsFIUO+HOgpjD0d2Gk5HIgPN4Io7y8PMHF8aY+TZs2BWA75oceekiUYE7ja9cO0KaDwISRDc1yjOrUqYMDBw44fe+jjz5y+b3OnTtj48aNLt8PCwvD3LlzXb4/cOBADBw4UHpF/QBaGEmZssAdtWvXRl5eHrKzs0EIqdB9UjuUBkBYGdsVdKPpL8KouLhYaDhuvfVW7N27V3ivot8oJCQEX375JVJSUnDy5EkAtnw6eoQbj68cI1ehNF86RvyDmRCC4uJiGAwGTRwjwHbd850IX8zfYj9cn0YLYWTfNig5uSMPPQhDrjBSak6lZs2aYdOmTQBsCz+XlpY6fb5o3UFhwsi3sCVB/ICsrCxcunTJpZVLx79pQeEJvLAwGo1uk4d5lFxAlqZOnTpCuOnw4cNuP0s3mp7mV9EoIYzoc0cnkQK2xrYimjRpgvT0dOGc/vnnnw7LAADaNMh0T1ULxwgofyhoJYzo694XjhFdtr1j4+v8FovF4rAiAN1BUiKcDdjmA+JH42kljOgEbMC2qKyzdriq5RgB2uX6+QNMGPkBb7zxBho0aIB27drhgQcecJh1lF4iwdN4Og897cHu3bsr/LxajhHHccJEm9nZ2Q69ZBqlQ2kGg0FwSDwVRvYu1pw5cwDYztFdd90laR8cx2Ho0KEAbA0v7TrxaJFj5CqUprZj5My10iKUBvheGPmDY+TKNQSUW6vQHv5+zs/Pd7l4rTPoh7YnI3R5hg0bJhoZmpeX5zQRW4vfgD7nvhJmrpaNYsKI4XNOnDgBwNYg/vDDDw6LGvKNQFRUlNdzqHTv3l3Y/u233yr8vFqOESCeu8XdCtdKh9KActdIztIo7ur04osv4tNPP8WuXbvczqBrDz379a5duxze17pB9mWD6My10soxohOwfRFKMxgMQuhK61Aa4F4YKTEylIeeZNbZ9e8KpRyjmJgY7N27V5R+4WyRZ1/lGPmTY8SEEUNTevXqJZoygF4DCCh3jPjhzN5w6623CkNUtXSMAPEyEFKEEcdxou94Ax+Sy8nJqXCdJHd1AmzCKCwsDI899pik2cRpaGHET3ZHU5UcI61DaVo6RhzHCdM4aJ187awOagkj2l3dtm2b5O8puW4bAJFrVJEwqiqhNCaMGJryyiuv4O+//xb+pmebNhqNgjhRQhgZDAYhOfj48eMYNWqUW1GipmNEixx3C0nyIqRu3bqK3ZR0gnRFcwnZU1paiu3btwt/e+NiNWzYUPi+s4VltQ6jaOUYaZ1jRDtGvhBGdPnuhJGv3Ar7uYzUEkY9e/YUfldPhZE3oTQeegZ6fxFGrpxbNa8BOv+SCSOG5tC5Q7RQofOLlBBGgDic9tlnnwn5Mc5Qq0EEXB8zjclkEuZwUnIaeloYSV3pnueFF14Q8oEaNGggKdnaHXxIsbCw0GHRYq3nMWKOke9WFecdWX/PMVKyHYiMjBTyHjMyMkSzWbuDzjFSwjGqVq2akIj9999/O6xu76scH61D2mFhYcJ9QAsjXx2/v8CEkZ8QEREhXJC0e0ILIyV6RgDw6KOPiv52N/M03UAoPUO4lFCa0onXPPR8UHIco88++wzvvvsuAFsDsX79eq8bCnqUjxazLgPaW/iu6lBVRqUB5cKIHy7Po/U1AKjbQeIn4AWADRs2SPoO/9DW6XSixWC9gR8MUlZW5hBe538DvV7v8QS7UvCH+5AXmswxYvgFvPDJysoSGka6Z6SUY9S+fXvRRU8vxmgPvXig0sKIdoxchdKUHqrP07x5c6GBl+oYnT17Fk888YTw94cffojbbrvN67rExMQI2/bCSAvHiHYsqtKoNK1DabwwIoRo8lDUShgNHjxYEBsLFy502x7x8O1XXFyc0zUJPYHOoaRzK4Hy30DttTNd/Qa+dGx4YXTz5k1hChEmjBiawQsjs9ks9FjUCKUBtlgy79i4a4jUdIzi4+OFRs2VY0QLOG+nKqDR6/VCovTZs2clNcabN28WhOK4ceMwfvx4Reoi1TFS88FMh5GcjcgCKv+oNK1DafYTTPJoMYeOr3KMAKBly5YYNWoUANtw+TfffNPlZ69cuYKHH34YmZmZAJSbhRuQNmWCFveAfX3oBZ/VIC4uTtjmn0NMGDE0gw6V8UJBLWEEQBhWnpub63JySV4I6HQ6xR/Mer1eOCZ3OUY83k5VYA+dZ/T1119X+Hl6fpMRI0YoVg8pjpHaq0y7EkZa5Rj503B9XztGgHNhBlROxwgAXn/9dcE12rlzp8vPLV68GOvXrxf+VlIY0YLD3jHixana16CrPC96bjv6XlUDOjTJzy3FhBFDM+ibnA8tqZFjxMPPPF1SUuJyRW3eMVLaLeLhXaArV644JB4DYmGkdB3uu+8+Yfv5558XludwRUZGhrDNr7GkBLRjZL+AqS97qrx75w+OEf9Q8OXM284cI6vVKixg7EthRD+YfeUauku+pu9DNYRR/fr1XSaf09hPMaJkmyAllKbFPQCUCyODwaB6HWhhxBwjhubQjhDvoKiRY8RDT0ToKpTEC6PQ0FBFy+ahE7CdzUJNh/KUnHEXsCV98osIG41GIanaFbxjFB4eruhvIcUxUvuhzHGc09XlaWGiVC6HK/wx+dqXwqwiYRQUFKRJ4i+gvmMElDs27oSRfcehU6dOipXvbzlG9Hngj1tttwhwLozo31+tZ4E/wYSRH+HOMQoJCZE1o7IUpAgjPpSmlmNECyNaBPKo6RgBEE1V4G4+p7KyMmHizaSkJEXDWv7gGAHljS5t2/ONc1hYmKoPZcD5g1nt39++fP535X8HX4YSXeUYafFQdpdjpHQHhaciYUQIEQ3nHz16NCZNmqR4+c7q4MspG/gy6CVS+HtSqXXq3OFMGNHnXclBMP4KE0Z+hLsco/j4eMUfTHIcI7VDaYDz5TnUdIwA94t30mRmZgqNY1JSkqJ18AfHCChvdPPz84WcM34OKaVWVHeHs1AO/XBQumNgD+2aOXOMtM4x0iqMA/iHY5SdnS20BykpKVi9erWQDqAE7hwjX+UYcRznsFxRaWmp8HtoJYxOnz4tvNakSRPV66A1TBj5EbQw4h2jGzduAICiDQAPvU9XCzjyjpFa9in9sLMXBYDYMVBDGLl7GNDQiddK5hcB7kel8Q9mXzpGpaWlKC4uhtVq9akwcvZb0NelGveAPfbhRF+G8ioKpWmV+AuUCyO9Xq9aPXhhVFpa6jTfkF4qKTExUfHy/SHHCCi/165duwar1SpykX0hjOj7jBdGfH4lx3Fo3Lix6nXQGiaM/Ihq1aoJDfO///6L0tJS4cGo9IgswD8cIzpmbt8Y0eWrVQe9Xi+IPn8URnR+idrYj0zLzc0VEo/pIbxq4SyU42thxJ8DrR0j2jXhr0u1Qlg8UhyjiIgI1UKqdCjL2WAQOpyjxsPZ1fm3WCxCB03tofJAuTAqKyvDjRs3RKFtrR2j+vXrqx7S9geYMPIjOI5DmzZtANhmfKZzbtRoFCsSRlarVei5qeUY0aEsZxa62o4RUP5AcCeM6BFpaobS7HOMtHCM+HrwbhHge8fIXhgFBQUpvlafM/gyTCaTqGPC18EXZQPlwsxisfjMtZOSY6RWGA0Qiw5n96LawsjVcH26s+KL5Gf7hVzpNkGL5OsbN24Iz4eqEEYDmDDyO3hhBIgXM1SjQapIGNF2tlaOkS+Sb6UIo3///VfYVtoxioyMFJJ+/ckxokcJ+kIYhYSECCPf7ENpNWrUUD35G3AUJ1pNMMk/DHNycgTXTsk5e5wh1TFSi4ocI61Cab4WJvbCyNeOEZ0Afv369SqXXwQwYeR30MKIX6gUUKdBqijHSO0wFiAvlKalY3T06FEAtoapbt26ipav0+mEBk/L5Gv6t8jLyxMJI1+E0jiOc/gt+OvSF2E0wHEuI186Rs6EET0gQW1hRN9f/iiMtAql0cLIF64l3Qm5evWqz4URx3GCa2QvjJR2y/0VJoz8DH9yjOh10vwhlOYLx8jZDOC5ublCMnzbtm1VcS5cCSNfJn3aTxvga8cIKL/OjUYjzGazcE34ShjZz35dlYSRTqcTzj99LxJCfC6MnLUFvDCqUaOGKgLFVSjN144Rfa9p4RgB5eG0nJwc5hgxtKd169bCttqOEZ3b4kwYVTXHyGq1isQgz5EjR4Tttm3bqlIH/rcoKCgQiTOtHCMtcowAsUj1deI14OgY0eFkXwojXiD7UhgBcJiuALB1kPhrUkvHiE8EVnqiW57Q0FDhN/anUJqvywfKhVFxcbGo/WPCiKEJ1apVQ6NGjQCIR8So0SCFh4cLYkMrxygiIkLIK3GXYxQUFKTag8ld0ikAHD58WNhWSxjxPUGLxSL0lgkhsFgsALRJvtbCMeJ/i6KiIk2EkX2OET3pp9rhxLCwMOF35l0CXwsj/jqkXQq1lwPhcZd8XVZWJtybaoWzOI5zuiyJ1snXWjpGAPDHH38I20wYMTSDDqfxqNUg8Q8crXKM6En13DlGag4RrWguI7rH1K5dO1XqQLt3/NxVvgzjAO6FkS9yjIDy36K4uFjkWGnhGOXn5/s0v4LjONEkm4DvhRF//Ddv3hREuS8mdwTcO0a0UKFzgZSG3zcLpZULo8zMTABA3bp1feZYaQ0TRn6Is965Wg0Sn2eUm5vrkF/jC2EElDc27nKM1JzDRaow4jgOt9xyiyp1oBs8viH09cKN/iCM6Oucb5AB7RwjNadpcAb/G2gtjIByceCL5UAA98KIdm3UTIDm66ClMKpZs6aQx6hF8jVfB3tatWrlk7L9ASaM/BBnPSK1hVFJSYnIMudf41Fz4UC6l2qPLxwjdzP+WiwW/PPPPwBsw/TVmGgTEDd4/uAY5eXlCY5NVFSU6pML8tDn98KFC8K2VsnXvk48pSeYJIRoFkoDygW6Fo6R/X1Itw2+cIyMRqMwTYKvR6UFBQUJ7bI/OEY8TBgxNMXZja/Wg8ndyDRfOUZ8Y2M2mx2Sn7V2jPLy8oTzoMbcKTx0KM3fHCNfuUWA+MGrhTCyF4e8YxQeHq5a0q+z8i0WC4xGoyCM9Hq96mvF0eUD5YLAH0JpvnKM6LaXbwu0SH7mr/fz588LHSVflt+yZUtJr1VWmDDyQ3zpGLmby8jXjhHgOPMzL4y0yjGi/1ZzOQB7pwIQCyNfLiIL2K4FXij7KvEa0N4xolcO//bbbwXHKDExUZiEU03o6yAvL08QRrVr1/ZJ+YHgGPkilEaXqaUwAoDffvsNgK0N9tVyHN27d3f4rZljxNAULUJpgHaOkSthRAgRxJlWjpGvhJGz3A5f9ZJ5wsPDBQHGhw8B7YTR+fPnhW1fCaOkpCT07NkTAHDy5ElBnPpqYjtamAwfPhyXLl0C4JswGhAYjpEvQmmA8/vQV8KoV69eDq/5KowG2Nr73r17i15jjhFDU6qaMHLmltiX7w/CSK38IsD5A0mLGW/5etBlOxslqRbx8fHCdnp6urDtK2EEAM8//7zDa74apkxfB/Qw6aoujHzlGDmb/drXOUYA8Pjjj+OHH35wGKHmS1JSUkR/+zKkrjVMGPkh/iKMtAil0b0zXwkzfxBGzsShFkmX9j3iqKgoPPfccz4pGwBGjhzp9OHji/wangEDBqBZs2ai13zlGLlyJHz1QPbXUJqWjhF/P4aFhSEkJES1smk4jkP//v2x5P/bu/OoKOv9geNvZB0GUCRjExXXUm8umVIipEAhhnpyyUpNzSVpw4v9NDpdd01v5bF7SzkueK+n3TYxxHLJNK2u5lYdQ5S8gKLiAs6ww/z+gHmaR0Hpd5jnmZ/zeZ3TaXxm+S7MPPOZz3d5Vq5UjvXv31+Tsq3i4+OV22FhYZqWrTcJjByQo8wx0nsozXaVnDNljKxfAnoERvfee6/q3y+99JKmvxRDQ0NZtGiR6lhwcLBmX0hQd2mM9957T3Xs+kDJXhoLjCIiIjQvX+uMke1r65UxutkcIz328Hn88ceZPHkyXl5ezJw5U9Oyw8PDmTt3Lp06dWLt2rWalq03+8/oFH+as2WMmjKUdrtnjBxhKA0gPT2de++9l4yMDMLDw5k9e7Ym5dpKTEzE1dWVLVu2UFFRoWnGyuree+/lwIEDzJw5k44dO/Lggw9qUm5DX/orVqxgxowZmpSvZ2Dk6uqKt7c3paWlDpExun4oTY/AyMXFhQ0bNrB+/Xq7XKPxVpYtW8ayZcs0L1dvEhg5IEcJjPTIGNn+MnSmjJGjDKUZjUbmzJnDnDlzNCmvMTNnzuTZZ5/VtQ4REREcPnxY0zKv/zvHxMTw0ksv6VK+9f2n1SVBoC5jU1pa6hBzjK5du0Ztba0SlOm567MeQZEz020orbKykgULFpCQkEB0dDTTp09X7TK7ceNGYmNjGTJkCKtWrVLtyvzLL7/w+OOPM3DgQKZPn865c+eU+8rLy3n11VeJiopi2LBhZGVlqcrNyMhQylywYIFqSbSjcLZ9jJoylKZVxuj6E7IeGSPrl4AegZHQ1/VfvuHh4bqVr3XGCP4YytJrVZrt56yoqAiz2ax89zjL5TCEjoFRTU0NoaGhpKens2vXLqKiokhJSQHq9m3YvHkzGzdu5KOPPmLfvn1s2bIFqAuo/ud//odx48axa9cuevbsyd/+9jflddPS0iguLiYzM5OlS5fy2muvKct+c3JyWLlyJa+//jpffvklZ8+eZf369do3/hb0yhjptY+RrEqr28DR2kY9M0ZCX9d/+VovKK2VhjJGhYWFyjF7bllh+/o3G0qzZ8YoJCREuX327Fld9jAS+tNtKM1gMDB16lTl34899hirVq3i6tWrZGZmMnr0aNq2bQvUrVTZtm0bI0aM4NChQxgMBkaMGAHAtGnTiI2N5dy5cwQHB5OZmckbb7yBj48PvXr1Iioqiq+++opp06aRlZVFXFycslHV1KlTWbx4Mc8880yDdaysrKSyslJ1zM3NzS4TQa3bz9fW1t4QBLi4uODu7q48pjl5enpiMBgoKyvj8uXLqjJsMzYeHh52KR/UgWBxcbFSju3J0cvLy27l2/a3yWRSlWN7/TaDwWC3OkDdCb+srEzpA9sdb/38/OxatqOw/Rw4o+t/FLVr107TvjAajbi4uGCxWCguLqampoYdO3YAde//u+++2671sQZGFRUVVFZWKuda26E0Hx8fu9XBdnfzgoIC1WfQ19dXk7+Fs38GwH590NRNUh1mjtGxY8do3bo1rVq1Ijc3V7WHQteuXXn77bcBOH36tGrprMFgoG3btpw+fRqj0cilS5dU93ft2pVffvlFee7999+v3NelSxcKCgooLy9vcKgmPT39htn4Y8aMYezYsc3T6AZYL5xpNBqVwMBgMKh2AW5uLVu2pKysjIsXL6o21SsqKlJuX758WXVfc7INPgoLC5VybC8iWl5ebrfybU9+RUVFqnJsh2mvXbtmtzrAH1nBq1evcubMGU3LdjS2f3tncn2mxGAwaP53NxqNmEwmioqK2LlzJwUFBUDdcnF776Xj6uqq3P7tt9+U7JD1XOTm5kZhYaHd5txUVVUpgWFubi6//fabcp+Li4umfwtn/QzYau4+aOrQtEMERiaTiaVLl5KUlATUjS/bpmyNRqMy5lxWVnbDkIbRaKSsrIzS0lJcXV1VQc7Nnmsto6ysrMHAaPLkyTz55JOqY/bMGOXl5REWFkaLFi3w8/NTTpJGo5H27ds3e5lWbdq0obCwkOLiYlU5ttfnCg8Pt1sdbK8TZjablXJs3wPBwcF2K9928zyLxaIqx/YXRqdOnez6dwgICCA3NxeTyURYWJgqW9mzZ09NLguit+s/B87m+o0cIyIiVMM7WmjdujUmkwmz2azaAX348OF2ff+D+uKlLVu2VC7RYh3W9/Pzs/vw4p133sn58+e5dOmS6nshLCzM7u0H+QyA/n2g+5m2oqKClJQUIiMjleExb29vVRbBbDYrv6YNBkOD80AMBgPe3t7U1NSoMkA3e661jMbmr3h4eGi6fwrUfRG3aNECX19fJWPg7e1t1zeHdZ5ReXk55eXlSn/ZzjGyZx1atWqFr68v165do6CgQCnHNjAwGAx2K9/62rW1tZjNZlU5tpNAfX197fp3sM5hsFgslJaWKnM8fHx8NH8f6s36OXA21/9ACwkJ0bwfrO/D4uJivvrqK+V4fHy83etiO8eppKREKc86x8jen0Go20vr/PnznDt3jr179yrHw8PDNf1bOOtnwJZefaBrr1dXV5OamkqbNm1ITk5WjoeHh6tWqGVnZytXNu/YsaPqvrKyMvLz8+nYsSN+fn4EBAQ0+bknT54kNDRUswvz/Rm2cw3sOfEY1Js82q5M02ryNfyxs2peXp6yCkSr5fouLi5KJlGvydegnlRaUlKiBEYy8dq5WN8HPj4+unwpWAOj8vJydu7cCdQFC1pcK8s2Y2Q7lG+dY6TFDuDWDF1NTQ1paWlA3Rf0sGHD7F62cAy6BkZLliyhoqKC+fPnq8aMExIS+OSTTygoKKCoqIh3332XoUOHAnUbr5WVlZGRkUFlZSXr16+ne/fuyqS5hIQE1q1bh9ls5vjx43z77bfExcUBdb94duzYwYkTJzCZTGzYsEF5XUdjGxjZew+Lxpbsa7VcH+pOvNYyravjtFquDzhEYHT9UmnrihgJjJzLv/71L5KSklTZCi3Zvt+qq6sBGDhwoCZ76TS0E391dbVyLrDnUn0r67kI/lghGhkZ6VTXCnN2ug2lnTt3joyMDDw9PVVXEn7rrbeIjIzk5MmTTJw4kdraWkaOHMnw4cOBuuGtFStWsGjRIl577TW6d+/OwoULlefPmDGDxYsXEx8fj5+fH3PnzlXGpDt37kxycjKzZs3CbDYzZMgQpkyZomm7m8o2EKipqbFrWY0FRnpkjADy8/O54447NFuuD44RGNn+Gi4qKlKG8SQwci69evVi+PDhug2jNLQsXavrdDUUGGm1uaNVQ3O6Ro4cafdyhePQLTAKDg7m4MGDjd4/efJkJk+e3OB9PXr04IMPPmjwPi8vLxYvXtzo6yYmJpKYmPjnKqsD29UZWgZGtnsZ2QYmWgZGeXl59O7dW7OhNLh1YOTh4aGajG4Ptl9ItqsQJTASWrrrrrtuOHbfffdpUnZDw/pabe5oZZsxspLAyLk498wuB2a7AsmazrYX23H9ixcvKretgZG7u7sqULMH25NRfn6+qnyw/1Ca9YRr3T/FynZloL3ZBka2y4JlYzmhpTFjxqj+3aJFC/r27atJ2bbnIkfJGA0YMEDzHciFviQwclBaZoysG2mCOlNhHUqzd7YIbswYgXaTr6Hx4UQtAyPbX8OSMRJ66datmypr5Onpafcdr61sM0bWydda7XptdX3G6PHHH7d7mcKxSGDkoLQMjGz3Bfn999+V29aMjRar9myDMz0yRg3NbQDHyBhJYCS0ZrsoRathNGj4c2i7Ok2Lz8L1GSN7bugrHJMERg5Ky8DIuokaqAMjyRhJYCSc05w5c7jzzjtxdXVl/vz5mpXb0Ofw5MmTyjHr1iv2FBAQoJwThw0bprpMiHAOum/wKBqmZWBkMBgICgpSXY4DtM0Y+fr64uPjg8lkajBjpOVeTtZfqpWVlcr8Li0CI9thAttLEUhgJLQWGBjI6dOnuXbtGkFBQZqV6+7ujp+fHyUlJcrn0DYw6tKli93r4OLiQmZmJllZWUyYMMHu5QnHI4GRg7JdAaXF/iEdOnSgsLCQs2fPUlFRgaenp6aBEdSlsLOzs8nPz8disahWiOkRGGm5VB8an2StxcZ6QlzPaDRq8r6/3h133EFJSYkyhKZ1YAR1K5979OihSVnC8chQmoN69dVXlX1MNm3aZPfybK8BZJ34q+VQGqD8Mi0vL6eoqEg5Mbq4uNg9a+IIgVF4eLiqHgDTp0/ngQcesHvZQjgK62fgypUr1NTUkJ2drRy3HWoTwl4kY+SgOnbsyE8//cTVq1eJioqye3nXT8Bu27atpsNIgGosPz8/XwmMWrdubfftAhqa26B1YOTl5cXnn3/Ol19+yb59+xg1ahQvvviiJhlDIRyF9bNosVg4d+6cMrSuVbZICAmMHFivXr00K8s2MDpz5oxq346GNjyzB9vAKC8vTwmMbPc2sRdHyBhBXV8vWbLE6S8eKZyX7Wfxxx9/VG5LYCS0ImdfAdyYMbL+SgP1Unp7sp3keerUKWVjNy2uUdRQYGQymZRjesy1EMIZ2f4QOnDggHJbAiOhFQmMBKCeY6RXYGSbMTpy5IhyW4uMkSMMpQkh1D9SXn/9deW2BEZCKxIYCUAdGJ0+fdrpAiNvb29l9V1DQ2la7fwrhLO7fgGCVdeuXTWuiXBWEhgJoC4wsAZA1iXzVnoMpR07dky5rUVgBH+ckPWcYySEs2to5VlMTAy9e/fWvjLCKUlgJBTdunUD6gKDo0ePKse1Cox8fHwa3MtHj8DIYrGodsCWC7kKoY3o6GglQ/vUU09x7Ngxvv76a1mQIDQjq9KEomvXruzcuROAffv2AXU7cGu5821YWBjFxcWqY1oFRtZfqpWVlZSWllJQUKDcd/31k4QQ9hEUFMQ333zDnXfeqbpUkBBakRBcKKwZI1vBwcF230PIVkPZKa0zRlCXNbINjLTaskAIUfcjRT5zQi8SGAlFQ5MbtRpGu1l5EhgJIYTQigRGQuEIgVFDqXOth9IALl68qARG/v7+eHt7a1IHIYQQ+pI5RkLRoUMH3N3dqaqqUo5pHRjZ7rhtpVVgZLuR5IQJE7hw4QIg2SIhhHAmkjESCldXVzp37qw6pvXkx9jYWNW1wdzc3PDz89Ok7MTERCVrZA2KQAIjIYRwJhIYCZU+ffoot0NCQnj00Uc1LT8wMFB1Nfnq6mrNLqLapUsXjh8/fsM+KhIYCSGE85DASKgsXryYqVOn8uabb5Kdna26hppWRowYoXmZViEhIURERKiOSWAkhBDOQwIjoRIeHs7atWuZNWuWbrs9Dx8+XLlte6kSrfTv31/1bwmMhBDCeUhgJBxOt27dmDVrFm3btuXtt9/WvHwJjIQQwnlJYCQc0ptvvkleXh7Dhg3TvOz77rtP9W8JjIQQwnlIYCTEda7fHkACIyGEcB4SGAnRgJdffhmA3r17q/Y3EkIIcXuTwEiIBixatIgffviBffv2abZdgBBCCP3JztdCNMDV1fWGSdhCCCFuf5IxEkIIIYSoJ4GREEIIIUQ9CYyEEEIIIepJYCSEEEIIUU/XyddpaWns2LGD33//ncWLF/Pwww8DsHTpUrZt26Y8rrKykgceeICVK1cC0K9fP7y8vJTVQpMnT2bKlCkAlJeXs2TJEvbs2YOvry/PP/888fHxymtlZGSwevVqzGYzQ4YMITU1FXd3d62aLIQQQggHpmtgFBYWRkpKCmvWrFEdT01NJTU1Vfn3k08+SXR0tOoxn3/++Q0b8UFdsFVcXExmZianTp3ixRdf5O6776Z9+/bk5OSwcuVK/vnPf9KuXTtSUlJYv349zzzzjH0aKIQQQoj/V3QdSktISCAiIgIPD49GH5Obm0tubi6xsbFNes3MzEymT5+Oj48PvXr1Iioqiq+++gqArKws4uLi6N69Oz4+PkydOlWVmRJCCCGEc3P4fYy2bdtGZGQkPj4+quPjx4/HxcWFAQMGkJycTKtWrSgpKeHSpUt07txZeVzXrl355ZdfADh9+jT333+/cl+XLl0oKCigvLwcLy+vG8qurKyksrJSdczNze2mgdz/VW1trer/zsbZ2w/SByB94OztB+kDZ28/2K8PWrRoWi7I4QOj7du3k5ycrDq2du1a/vKXv3Dt2jWWL1/OwoULefPNNyktLcXV1VUV5BiNRkpLSwEoKyvDaDQq91mDrbKysgYDo/T0dNauXas6NmbMGMaOHdtczbtBXl6e3V77/wNnbz9IH4D0gbO3H6QPnL390Px9EB4e3qTHOXRgdPToUUpKShg4cKDqeJ8+fQDw9/dn9uzZDBs2jKqqKry9vampqVFlgMxmM97e3gAYDAbMZrPyOiaTSTnekMmTJ/Pkk0+qjtkzY5SXl0dYWFiTo9rbibO3H6QPQPrA2dsP0gfO3n7Qvw8cOjDKysoiJibmpoGItdMsFgt+fn4EBASQk5NDz549AcjOzqZjx44AdOzYkZycHOW5J0+eJDQ0tMFsEYCHh4ddgqCbadGihdN+GEDaD9IHIH3g7O0H6QNnbz/o1we69np1dTUVFRVYLBbltnVMsbq6mq+//lq11B7g1KlTZGdnU1NTQ0lJCW+88QYDBgxQApiEhATWrVuH2Wzm+PHjfPvtt8TFxQEQHx/Pjh07OHHiBCaTiQ0bNjB06FBtGy2EEEIIh6Vrxmjx4sVs3boVgMOHDzNv3jzWrFlDv379+P777/H09KRv376q51y+fJlly5Zx4cIFjEYj/fv3Z/78+cr9M2bMYPHixcTHx+Pn58fcuXPp0KEDAJ07dyY5OZlZs2Yp+xhZ9z8SQgghhHCxWCwWvSsh6sZUz5w5Q/v27Z0yfers7QfpA5A+cPb2g/SBs7cf9O8DCYyEEEIIIeo5ZzgqhBBCCNEACYyEEEIIIepJYCSEEEIIUU8CIyGEEEKIehIYCSGEEELUk8BICCGEEKKeBEZCCCGEEPUkMBJCCCGEqCeBkRBCCCFEPQmMhBBCCCHqSWCkocTERI4fP653NRzClStXePHFFxk4cCCPPvooP/74IwDffPMNo0aNIjo6mocffpg333yTmpoanWvb/Bprf0ZGBgMGDGDQoEHKf4WFhTrX1j4a64OlS5eq2j9gwABmzZqlc23to7E+KC8vZ8mSJcTFxfHQQw+xadMmnWtqH2lpaYwZM4b77ruP7du3K8d/+uknpk2bRmRkJM8//7yONbSvxtrvLOdBaLwP9DwXSmAkdLF8+XLatGnDzp07eeGFF5g7dy4lJSV0796ddevWsWfPHj7++GNycnL47LPP9K5us2us/QD9+/dn7969yn9BQUE619Y+GuuD1NRUVfs7d+5MdHS03tW1i8b6YP369Zw9e5bPPvuMf//733z66accOHBA7+o2u7CwMFJSUujRo4fquJeXF6NGjWLSpEn6VEwjjbXfWc6D0HgfgH7nQgmMdHDs2DEmTpxIdHQ0jzzyCB988IFyX1paGn/729+YM2cOUVFRTJo0iXPnzulY2+ZXWlrKnj17eOaZZ/Dy8uLBBx+kU6dOfPvtt9x55534+/urHl9QUKBTTe3jZu13Fk3tg9zcXHJzc4mNjdWppvZzsz44cOAATzzxBD4+PgQFBTF8+HC+/PJLvavc7BISEoiIiMDDw0N1vHv37sTHxxMYGKhTzbTRWPud4Txo1Vgf6EkCIx24ubmRmprK7t27WbFiBatXr+bEiRPK/bt372bcuHHs2rWLdu3asXbtWh1r2/z++9//4uPjwx133KEc69KlC6dPnwbgyJEjREdHM2TIEHJychgxYoReVbWLW7X/6NGjxMTEMGbMGDZv3qxXNe3qVn1gtW3bNiIjI/Hx8dG6inZ3qz6wWCzKcYvFckPfiNvb7X4ebAq9zoVumpUkFN27d1fdHjhwIEePHuWuu+4CICIigj59+gDw0EMPkZaWpks97aWsrAyj0ag6ZjQaMZlMAPTu3Zs9e/ZQUFDA1q1b8fX11aOadnOz9vft25cPPviAoKAgfv31V2bPnk1AQACDBw/Wqbb2cav3gNX27dtJTk7WsGbauVkfRERE8P7779OrVy+uXbvG1q1bdaql0Mvtfh68FT3PhZIx0sGpU6dISkoiNjaW6Ohodu/eTXFxsXK/bQrVy8uL0tJSPappNwaDAbPZrDpmNpsxGAyqY6GhoXTq1Ik33nhDy+rZ3c3aHxoaSkhICC1atKBnz56MGzeO3bt361RT+2nKe+Do0aOUlJQwcOBArauniZv1wdNPP01ISAijR4/mhRdeICYmhjZt2uhUU6Gn2/U8eCt6ngslMNLBihUr6N27N1u3bmXPnj0MHjxYlTa/3bVr1w6TyURRUZFy7OTJk3Ts2PGGx1osFvLz87Wsnt39mfa7uLhoWTXNNKUPsrKyiImJcai5B83pZn1gMBh45ZVX2L59O5s3b8bFxUWVaRbO5XY8D/5ZWp4LJTDSQWlpKT4+Pnh6enL48GG+++47vaukKW9vb6KiokhLS6O8vJw9e/Zw6tQpoqKi2LFjh7IkMy8vj40bN9KvXz+da9y8btb+/fv3c+XKFQBOnDjBhx9+yKBBg3SucfO7WR8AVFdX8/XXXxMfH69zTe3nZn1w/vx5ioqKqKmp4fvvvycjI4MnnnhC7yo3u+rqaioqKrBYLMrt2tpaamtrqaiooLq6WnX7dtNY+53hPGjVWB/oeS50sThTqkJniYmJLFu2jNLSUpYsWcKVK1cYMGAAXl5etG3blhkzZpCWlsalS5dITU0F4ODBgyxbtoxPPvlE59o3rytXrjBv3jwOHTpEYGAgc+bMYcCAAWzYsIHNmzdTUlJCy5YtiY2NJSkpCU9PT72r3Kwaa//KlSvJzMykvLycNm3aMHbsWMaNG6d3de2isT4A2LdvH8uWLSMjI4MWLW7f32+N9cHBgweZN28eV69epUOHDsyePVuZd3g7mT9//g3zp9asWQPAM888ozr+yCOPMH/+fK2qponG2n/s2DGnOA9C432wd+9e3c6FEhhpKCYmhvT0dNq1a6d3VYQQQgjRgNv3p5iDOXjwIADBwcE610QIIYQQjZHl+hpYsmQJ33//Pa+88gru7u56V0cIIYQQjZChNCGEEEKIejKUJoQQQghRTwIjIYQQQoh6EhgJIYQQQtSTwEgIIYQQop4ERkII3R08eJB+/frRr18/zp49q3d1hBD1KisrWbBgAQkJCURHRzN9+nRycnKU+zdu3EhsbCxDhgxh1apVyuWtqqureemllxg6dCj9+vVTXfoG6jZ2vP/++xk0aBCDBg1i7NixN61HWloaS5cubf4GNkCW6wsh7CoxMZFz587d9DGDBg2iZ8+eAA5zbbSDBw8quy9v2bKFkJAQnWskhPZqamoIDQ0lPT2dO+64g/fff5+UlBS++OIL9u3bx+bNm9m4cSNeXl7MnDmTDh06MGLECAD69u3LxIkTmTx5coOvPWPGDCZNmqRha5pGAiMhhF1169aNgIAAAC5cuMCFCxcA6Nq1qxIERUdHM3LkSL2qKIRohMFgYOrUqcq/H3vsMVatWsXVq1fJzMxk9OjRtG3bFoDx48ezbds2RowYgZubG48//rhd6lRbW8ucOXM4cuQINTU13HfffaSmptKyZUvOnj3L6NGjeemll5TLy7zwwgsMGzasya8vgZEQwq5ef/115XZaWhpr165VjluzMNahNPgjO2O9hlJwcDAzZsxg9erVmEwmhg8fzrPPPsvbb7/Nli1b8PX1ZdKkSYwePVop5+LFi7zzzjscOHCAq1evEhgYSGJiIpMmTcLNre60d/z4cd555x2ys7MpLS3F39+fbt26kZKSwpdffqnUE2D48OHAH9fr2rRpE9u2baOwsBCz2Yyfnx+9e/fmueeeo3379gBkZGSwYMECAF577TU2bNjAmTNnuPfee1mwYAHffPMN69ato7y8nLi4OGbPnq3UzdoXycnJ/Prrr+zduxcvLy9GjRrFjBkzNL3SuBC2jh07RuvWrWnVqhW5ubkkJCQo93Xt2pW33367ya+1adMmNm3aRPv27Xnuuefo27dvk587ePBgFi5cSE1NDS+//DLr1q0jJSUFgKqqKs6cOcPWrVs5dOgQc+bMISYmBi8vrya9tswxEkI4tKKiIl577TXc3d0xm828//77TJgwgS1btuDj40NhYSErVqwgNzcXgKtXrzJp0iQyMjIoKysjPDycwsJC1qxZw5IlS4C6X5zJycn85z//wc3NjfDwcKqqqti7dy+FhYUEBgYSHh6u1KFr16707NlT+WV86NAh8vLyCAgIoEOHDpSUlLB7926SkpKoqKi4oQ3z5s2jsrKSyspK9u/fz/Tp01m+fDmenp4UFxezefNmvvjiixue984773D48GF8fX25cuUK69at48MPP7RHNwtxSyaTiaVLl5KUlARAaWkpPj4+yv1Go5HS0tImvda4ceP47LPPyMrKYsyYMcyaNYvCwsImPbdFixYkJCRgMBjw8fHhiSee4MiRI8r9FouFqVOn4u7uTkREBB4eHuTn5ze5nZIxEkI4tKqqKlavXs0999xDYmIi58+fJy8vj08//RR/f39iY2OpqKjg0KFDhIeH89FHH3H+/HkCAgL44IMP8Pf355tvvmH27Nls3bqVKVOm4OvrS3FxMQDp6elK5urUqVP4+/vTr18/2rZtq8wxss1uATz//PO0b99eyfD88MMPPPvss5w/f56jR4/Sv39/VRumTJnC008/zauvvsq2bdvIzc1l0aJFDB06lKlTp3LkyBEOHjzIqFGjVM/r0aMHq1evBmDmzJkcPnyY9PR0za4yLoRVRUUFKSkpREZGKnOIvL29MZlMymPMZjPe3t5Ner277rpLuT106FAyMzP54YcfGDFiBGPHjlXmJX788ccEBQWpnltdXc2qVavYvXs3165dw2Kx0KpVK+V+Dw8PVcDm5eVFWVlZk9sqgZEQwqFZh6kAgoKCOH/+PJ06dVICFX9/fwoLC7l8+TIAv/zyCwCXLl0iLi5O9VoWi4Wff/6ZoUOHcs8993Ds2DFGjx5NWFgYnTp1IjIykvj4+FvWqbCwkKVLl5KTk0NpaSm2V1a6ePHiDY+PiooC1BeRHjRoEAChoaEcOXJEqb+tmJgYJfiKiYnh8OHDXLp0iStXruDv73/LegrRHKqrq0lNTaVNmzYkJycrx8PDw8nJySEyMhKA7OxsOnbs+H8qw3Z4+KOPPrrpY7OyspQfCW3atOHAgQPNumJNAiMhhEMzGo3KbVdX1xuOWU+o1uDE+n+j0agaDrOyzjN45513yMrK4ujRo+Tm5rJz506++uorioqKmDhxYqP1yc/PZ/bs2VRVVWE0Grn77ruprq4mOzsbqBuma6wN1voDyi/a6+svhKNZsmQJFRUVLF++XBXAJCQksHz5cuLi4vD09OTdd9/lySefVO6vrKxU3tdVVVVUVFTg6ekJwM6dO3nggQdwd3dn165dHD16lLlz5zapPmazGQ8PD3x9fbl69SqbNm1qxtZKYCSEuM306NGD/fv34+rqytKlS5XMktlsZvfu3QwePBiLxcKxY8dITExUVsMtXLiQLVu2cPjwYSZOnKiaqGmbhv/tt9+oqqoC4B//+Af33HMP27dv55VXXmn2tuzcuVOZVL5r1y4AAgICJFskNHPu3DkyMjLw9PRk8ODByvG33nqLyMhITp48ycSJE6mtrWXkyJHKQgWAUaNGKUNiiYmJQN1CC4D33nuPhQsX4uLiQvv27fn73/9+yy0xrEHZsGHD+O6774iLiyMwMJCRI0c269w7CYyEELeVsWPH8sUXX3DhwgVGjRpFeHg4ZrOZ8+fPU11dzSOPPEJNTQ1JSUkYjUYCAwNxcXFRJm937twZgLZt2+Lm5kZ1dTVJSUkEBwczfvx4OnfujKurKzU1NTz//PMEBQVx6dIlu7TlxIkTJCYm4uLiomxz8NRTT9mlLCEaEhwcrAQzDZk8eXKj+xRlZGQ0+rz169f/qXqUlZXh5+cH1GVb33rrLdX948ePByAkJIT9+/c3uR4NkVVpQojbir+/P+np6SQmJtKyZUtOnTpFRUUFffr04a9//StQN6Q1atQoQkJCuHDhAvn5+QQHBzNhwgSmTZsGQKtWrZg9ezaBgYFcvnyZn3/+mUuXLtGhQwdeffVVQkNDqa6uplWrVspqt+aWlJREv379MJlMtGzZkilTpsjEa+F0TCYTBw4cUE3YticXiwxsCyGEQ7HuYzRv3jxlCEIIZ3T48GFSUlJ48MEHSU1NVRYj2JMMpQkhhBDCIfXp00eZX6cVGUoTQgghhKgnQ2lCCCGEEPUkYySEEEIIUU8CIyGEEEKIehIYCSGEEELUk8BICCGEEKKeBEZCCCGEEPUkMBJCCCGEqCeBkRBCCCFEPQmMhBBCCCHqSWAkhBBCCFHvfwFFAt3ctAXalwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -202,24 +233,34 @@ } ], "source": [ - "series = ElectricityConsumptionZurichDataset().load()\n", + "series = ElectricityConsumptionZurichDataset().load().astype(np.float32)\n", "\n", "# extract target and resample to hourly frequency\n", "series = series[\"Value_NE5\"].resample(freq=\"h\")\n", "\n", "# plot 2 weeks of hourly consumption\n", - "series[: 2 * 7 * 24].plot()" + "ax = series[: 2 * 7 * 24].plot()\n", + "ax.set_ylabel(\"El. Consuption [kWh]\")\n", + "ax.set_title(\"Target series (Electricity Consumption) extract\");" + ] + }, + { + "cell_type": "markdown", + "id": "ab445a33-9a50-4695-8de4-09bcc007f787", + "metadata": {}, + "source": [ + "Extract a train, calibration and test set. Note that `cal` does not overlap with the training set `train`." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "29a5b91e-543f-46e0-8dbd-12da2f09522f", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -238,33 +279,46 @@ "cal = series[cal_start : test_start - series.freq]\n", "test = series[test_start:test_end]\n", "\n", - "train.plot(label=\"train\")\n", + "ax = train.plot(label=\"train\")\n", "cal.plot(label=\"val\")\n", - "test.plot(label=\"test\");" + "test.plot(label=\"test\")\n", + "\n", + "ax.set_ylabel(\"El. Consuption [kWh]\")\n", + "ax.set_title(\"Dataset splits\");" ] }, { "cell_type": "markdown", - "id": "dc15b191-ef84-4cf7-86e1-4cd3385ecd11", + "id": "cd792a32-744a-4815-86d9-d3d7b3677859", "metadata": {}, "source": [ - "### Train the base forecaster\n", + "### Example 1: Compare different models on single step horizon forecasts\n", + "\n", + "Let's see how we can use conformal prediction in Darts. We'll show how to:\n", + "\n", + "- use conformal prediction (predict and historical forecasts)\n", + "- evaluate the prediction intervals (simple prediction and backtest).\n", + "- compare two different base forecasting models using conformal prediction.\n", + "\n", + "To demonstrate the process, we focus first only on one base forecasting model.\n", "\n", - "Let's use a `LinearRegressionModel` as our base forecasting model. We'll configure it to use the last 24 hours as lookback to forecast the next 24 hours.\n", + "#### Train the base forecaster\n", + "\n", + "Let's use a `LinearRegressionModel` as our base forecasting model. We configure it to use the last two hours as lookback to forecast the next hour (single step horizon; multi horizon will be covered in Example 2).\n", "\n", "- train it on the `train` set\n", - "- forecast the next 24 hours after the end of the `cal` set" + "- forecast the next hour after the end of the `cal` set" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "id": "8a9952be-a6c4-4da1-aabe-70c8f019b222", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -274,17 +328,21 @@ } ], "source": [ - "input_length = 7 * 24\n", - "horizon = 7 * 24\n", + "horizon = 1\n", "\n", "# train the model\n", - "model = LinearRegressionModel(lags=input_length, output_chunk_length=horizon)\n", + "model = LinearRegressionModel(lags=2, output_chunk_length=horizon)\n", "model.fit(train)\n", "\n", - "# forecast and plot\n", + "# forecast\n", "pred = model.predict(n=horizon, series=cal)\n", - "series[pred.start_time() - 3 * 24 * series.freq : pred.end_time()].plot(label=\"actual\")\n", - "pred.plot(label=\"pred\");" + "\n", + "# plot\n", + "ax = series[pred.start_time() - 7 * 24 * series.freq : pred.end_time()].plot(\n", + " label=\"actual\"\n", + ")\n", + "pred.plot(label=\"pred\")\n", + "ax.set_title(\"First 1-step point prediction\");" ] }, { @@ -292,7 +350,7 @@ "id": "f8a80d6b-2818-4079-b39a-1848a2f049c1", "metadata": {}, "source": [ - "We can clearly see that the forecasts are off. But we have no estiamte of the uncertainty." + "Great, we have our single step forecast. But without knowing the actual target value at that time, we wouldn't have any estimate of the uncertainty." ] }, { @@ -300,26 +358,31 @@ "id": "8e5bbfe1-2e10-4675-844d-d965c0371ca3", "metadata": {}, "source": [ - "### Apply Conformal Prediction\n", + "#### Apply Conformal Prediction\n", "\n", - "Now let's apply conformal prediciton to quantify the uncertainty. We use the symmetric (default) naive model including the quantile levels we want to forecast. Let's:\n", + "Now let's apply conformal prediction to quantify the uncertainty. We use the symmetric (default) naive model, including the quantile levels we want to forecast. Also:\n", "\n", "- we don't need to train / fit the conformal model\n", "- we should supply a `series` to `predict()` that does not have an overlap with the series used to train the model. In our case `cal` has no overlap with `train`.\n", + "- the API is identical to Darts' forecasting models.\n", "\n", - "Let's add the 90% (quantiles 0.05 - 0.95) and 80% (0.10 - 0.90) prediction intervals." + "Let's configure the conformal model:\n", + "- add a 90% quantile interval (quantiles 0.05 - 0.95) (`quantiles`).\n", + "- consider only the last 4 weeks of non-conformity scores to calibrate the prediction intervals (`cal_length`).\n", + "\n", + "> Note: you can add any number of intervals, e.g. `[0.10, 0.20, 0.50, 0.80, 0.90]` would add the 80% (0.10 - 0.90) and 60% (0.20 - 0.80) intervals" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "id": "358f91ad-770d-4389-bf95-53004d8ec93f", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "38ce5c256b1c4436886a2cba707e07a0", + "model_id": "d89437eb2ec14fa997bdc230faa8e1e5", "version_major": 2, "version_minor": 0 }, @@ -333,7 +396,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9da79419a6c84b06bd57b07e843cea12", + "model_id": "4450f86af0634a8399b4c67f46a44a6f", "version_major": 2, "version_minor": 0 }, @@ -346,7 +409,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -356,20 +419,22 @@ } ], "source": [ - "quantiles = [0.05, 0.15, 0.50, 0.85, 0.95]\n", + "quantiles = [0.05, 0.50, 0.95]\n", + "four_weeks = 4 * 7 * 24\n", "pred_kwargs = {\"predict_likelihood_parameters\": True, \"verbose\": True}\n", "\n", + "# create conformal model\n", + "cp_model = ConformalNaiveModel(model=model, quantiles=quantiles, cal_length=four_weeks)\n", "\n", - "cp_model = ConformalNaiveModel(\n", - " model=model,\n", - " quantiles=quantiles,\n", - " symmetric=True, # default, whether to\n", - " cal_stride=1, # default, stride to apply to historical forecasts on calibration set\n", - ")\n", - "\n", + "# conformal forecast\n", "pred = cp_model.predict(n=horizon, series=cal, **pred_kwargs)\n", - "series[pred.start_time() - 3 * 24 * series.freq : pred.end_time()].plot(label=\"actual\")\n", - "pred.plot(label=\"pred\");" + "\n", + "# plot\n", + "ax = series[pred.start_time() - 7 * 24 * series.freq : pred.end_time()].plot(\n", + " label=\"actual\"\n", + ")\n", + "pred.plot(label=\"cp\")\n", + "ax.set_title(\"First 1-step conformal prediction\");" ] }, { @@ -377,10 +442,8 @@ "id": "3897a238-4543-4542-895f-e2e62dda32bc", "metadata": {}, "source": [ - "Great, we can see the two added prediction intervals. Most of the actuals seem to be within the 90% interval.\n", - "Let's look at how to evaluate this forecast.\n", - "\n", - "> **Note about computational time**: In this case the time to produce the conformal forecast is dominated by the historical forecasts (4 seconds) on the calibration set. Behind the hood the model computed a backtest over an entire year (generating and evaluating more than 200k predictions; 8'760 1-day forecasts using 24 dedicated linear models (one for each horizon)). The performance can be greatly improved by adjusting `cal_length` and `cal_stride` at conformal model creation (more on that later)." + "Great, we can see the added prediction interval (turquoise, dark blue) around the base model's forecast (purple).\n", + "It's clear that the predicted interval contains the actual value. Let's look at how to evaluate this forecast." ] }, { @@ -388,21 +451,23 @@ "id": "80001270-a5af-4514-83ac-5c392b10bf37", "metadata": {}, "source": [ - "### Evaluate Conformal Prediction\n", + "#### Evaluate Conformal Prediction\n", "\n", - "Darts has dedicated metrics for prediction intervals. You can find them on [our metrics page](https://unit8co.github.io/darts/generated_api/darts.metrics.html) under the *Quantile interval metrics*\n", + "Darts has dedicated metrics for prediction intervals. You can find them on [our metrics page](https://unit8co.github.io/darts/generated_api/darts.metrics.html) under the *Quantile interval metrics*. You can use them as standalone metrics or for backtesting.\n", "\n", "- `(m)ic`: (Mean) Interval Coverage\n", "- `(m)iw`: (Mean) Interval Width\n", "- `(m)iws`: (Mean) Interval Winkler Score\n", "- `(m)incs_qr`: (Mean) Interval Non-Conformity Score for Quantile Regression\n", "\n", - "Let's check the mean interval coverage (the ratio of actual values being within each interval) and the interval width:" + "> Note: for `backtest()` use the (m)ean metrics such as `mic()`, and for `residuals()` the per-time step metrics such as `ic()`.\n", + "\n", + "Let's check the interval coverage (the ratio of actual values being within each interval) and the interval width:" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "id": "9470a0bc-0ac9-407b-9749-0d6ce19e4d7d", "metadata": {}, "outputs": [ @@ -428,46 +493,43 @@ " \n", " \n", " Interval\n", - " Predicted Coverage\n", + " Coverage\n", + " Width\n", " \n", " \n", " \n", " \n", " 0\n", " 0.9\n", - " 0.85\n", - " \n", - " \n", - " 1\n", - " 0.7\n", - " 0.58\n", + " 1.0\n", + " 3321.12\n", " \n", " \n", "\n", "" ], "text/plain": [ - " Interval Predicted Coverage\n", - "0 0.9 0.85\n", - "1 0.7 0.58" + " Interval Coverage Width\n", + "0 0.9 1.0 3321.12" ] }, - "execution_count": 10, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "q_interval = cp_model.q_interval # [(0.05, 0.95), (0.10, 0.90)]\n", - "q_range = cp_model.interval_range # [0.9, 0.8]\n", + "q_interval = cp_model.q_interval # [(0.05, 0.95)]\n", + "q_range = cp_model.interval_range # [0.9]\n", "\n", "\n", - "def compute_metric(pred_, metric=metrics.mic, name=\"Coverage\"):\n", - " mic = metric(series, pred_, q_interval=q_interval)\n", - " return pd.DataFrame({\"Interval\": q_range, f\"Predicted {name}\": mic}).round(2)\n", + "def compute_metrics(pred_):\n", + " mic = metrics.mic(series, pred_, q_interval=q_interval)\n", + " miw = metrics.miw(series, pred_, q_interval=q_interval)\n", + " return pd.DataFrame({\"Interval\": q_range, \"Coverage\": mic, \"Width\": miw}).round(2)\n", "\n", "\n", - "compute_metric(pred)" + "compute_metrics(pred)" ] }, { @@ -475,24 +537,19 @@ "id": "bb765655-53f4-41a2-83cd-96c87c88fc26", "metadata": {}, "source": [ - "Okay that doesn't look great for the coverage of the 0.8 interval. But we only looked at 1 example. How does it perform on the entire test set?" + "Okay, we see an interval width of 3.3 MWh, and a coverage of 100%. We would expect a coverage of 90% (on finite samples). But so far we've only looked at 1 example. How does it perform on the entire test set?" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "id": "23567754-d132-47d8-aa1c-33a048ff0d28", - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, + "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8afff452de3e444f8459f9769e2c564f", + "model_id": "0643a2e4c65b46c4967e73a5286e76cf", "version_major": 2, "version_minor": 0 }, @@ -504,61 +561,44 @@ "output_type": "display_data" }, { - "ename": "OutOfBoundsDatetime", - "evalue": "Cannot generate range with start=1452211200000000000 and periods=2891280", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mOutOfBoundsDatetime\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[12], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m cal_test \u001b[38;5;241m=\u001b[39m concatenate([cal, test], axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n\u001b[0;32m----> 2\u001b[0m hfcs \u001b[38;5;241m=\u001b[39m \u001b[43mcp_model\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhistorical_forecasts\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43mseries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcal_test\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43mforecast_horizon\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhorizon\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m#start=test.start_time(),\u001b[39;49;00m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mlast_points_only\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[43m \u001b[49m\u001b[43mstride\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhorizon\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 8\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mpred_kwargs\u001b[49m\n\u001b[1;32m 9\u001b[0m \u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/projects/unit8/darts/darts/utils/utils.py:234\u001b[0m, in \u001b[0;36m_with_sanity_checks..decorator..sanitized_method\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 231\u001b[0m only_args\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mself\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 233\u001b[0m \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, sanity_check_method)(\u001b[38;5;241m*\u001b[39monly_args\u001b[38;5;241m.\u001b[39mvalues(), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39monly_kwargs)\n\u001b[0;32m--> 234\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mmethod_to_sanitize\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43monly_args\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvalues\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43monly_kwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/projects/unit8/darts/darts/models/forecasting/conformal_models.py:576\u001b[0m, in \u001b[0;36mConformalModel.historical_forecasts\u001b[0;34m(self, series, past_covariates, future_covariates, forecast_horizon, num_samples, train_length, start, start_format, stride, retrain, overlap_end, last_points_only, verbose, show_warnings, predict_likelihood_parameters, enable_optimization, data_transformers, fit_kwargs, predict_kwargs, sample_weight)\u001b[0m\n\u001b[1;32m 565\u001b[0m \u001b[38;5;66;03m# generate only the required forecasts (if `start` is given, we have to start earlier to satisfy the\u001b[39;00m\n\u001b[1;32m 566\u001b[0m \u001b[38;5;66;03m# calibration set requirements)\u001b[39;00m\n\u001b[1;32m 567\u001b[0m cal_start, cal_start_format \u001b[38;5;241m=\u001b[39m _get_calibration_hfc_start(\n\u001b[1;32m 568\u001b[0m series\u001b[38;5;241m=\u001b[39mseries,\n\u001b[1;32m 569\u001b[0m horizon\u001b[38;5;241m=\u001b[39mforecast_horizon,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 574\u001b[0m start_format\u001b[38;5;241m=\u001b[39mstart_format,\n\u001b[1;32m 575\u001b[0m )\n\u001b[0;32m--> 576\u001b[0m hfcs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhistorical_forecasts\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 577\u001b[0m \u001b[43m \u001b[49m\u001b[43mseries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mseries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 578\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_covariates\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_covariates\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 579\u001b[0m \u001b[43m \u001b[49m\u001b[43mfuture_covariates\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfuture_covariates\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 580\u001b[0m \u001b[43m \u001b[49m\u001b[43mforecast_horizon\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mforecast_horizon\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 581\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_samples\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcal_num_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 582\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcal_start\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 583\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart_format\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcal_start_format\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 584\u001b[0m \u001b[43m \u001b[49m\u001b[43mstride\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcal_stride\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 585\u001b[0m \u001b[43m \u001b[49m\u001b[43mretrain\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 586\u001b[0m \u001b[43m \u001b[49m\u001b[43moverlap_end\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moverlap_end\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 587\u001b[0m \u001b[43m \u001b[49m\u001b[43mlast_points_only\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlast_points_only\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 588\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 589\u001b[0m \u001b[43m \u001b[49m\u001b[43mshow_warnings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 590\u001b[0m \u001b[43m \u001b[49m\u001b[43mpredict_likelihood_parameters\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 591\u001b[0m \u001b[43m \u001b[49m\u001b[43menable_optimization\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43menable_optimization\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 592\u001b[0m \u001b[43m \u001b[49m\u001b[43mdata_transformers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata_transformers\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 593\u001b[0m \u001b[43m \u001b[49m\u001b[43mfit_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfit_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 594\u001b[0m \u001b[43m \u001b[49m\u001b[43mpredict_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpredict_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 595\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 596\u001b[0m calibrated_forecasts \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_calibrate_forecasts(\n\u001b[1;32m 597\u001b[0m series\u001b[38;5;241m=\u001b[39mseries,\n\u001b[1;32m 598\u001b[0m forecasts\u001b[38;5;241m=\u001b[39mhfcs,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 608\u001b[0m predict_likelihood_parameters\u001b[38;5;241m=\u001b[39mpredict_likelihood_parameters,\n\u001b[1;32m 609\u001b[0m )\n\u001b[1;32m 610\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m (\n\u001b[1;32m 611\u001b[0m calibrated_forecasts[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 612\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m called_with_single_series\n\u001b[1;32m 613\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m calibrated_forecasts\n\u001b[1;32m 614\u001b[0m )\n", - "File \u001b[0;32m~/projects/unit8/darts/darts/utils/utils.py:234\u001b[0m, in \u001b[0;36m_with_sanity_checks..decorator..sanitized_method\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 231\u001b[0m only_args\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mself\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 233\u001b[0m \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, sanity_check_method)(\u001b[38;5;241m*\u001b[39monly_args\u001b[38;5;241m.\u001b[39mvalues(), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39monly_kwargs)\n\u001b[0;32m--> 234\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mmethod_to_sanitize\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43monly_args\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvalues\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43monly_kwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/projects/unit8/darts/darts/models/forecasting/forecasting_model.py:969\u001b[0m, in \u001b[0;36mForecastingModel.historical_forecasts\u001b[0;34m(self, series, past_covariates, future_covariates, forecast_horizon, num_samples, train_length, start, start_format, stride, retrain, overlap_end, last_points_only, verbose, show_warnings, predict_likelihood_parameters, enable_optimization, data_transformers, fit_kwargs, predict_kwargs, sample_weight)\u001b[0m\n\u001b[1;32m 952\u001b[0m fit_kwargs, predict_kwargs \u001b[38;5;241m=\u001b[39m _historical_forecasts_sanitize_kwargs(\n\u001b[1;32m 953\u001b[0m model\u001b[38;5;241m=\u001b[39mmodel,\n\u001b[1;32m 954\u001b[0m fit_kwargs\u001b[38;5;241m=\u001b[39mfit_kwargs,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 957\u001b[0m show_warnings\u001b[38;5;241m=\u001b[39mshow_warnings,\n\u001b[1;32m 958\u001b[0m )\n\u001b[1;32m 960\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[1;32m 961\u001b[0m enable_optimization\n\u001b[1;32m 962\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m model\u001b[38;5;241m.\u001b[39msupports_optimized_historical_forecasts\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 967\u001b[0m )\n\u001b[1;32m 968\u001b[0m ):\n\u001b[0;32m--> 969\u001b[0m forecasts \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_optimized_historical_forecasts\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 970\u001b[0m \u001b[43m \u001b[49m\u001b[43mseries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mseries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 971\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_covariates\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_covariates\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 972\u001b[0m \u001b[43m \u001b[49m\u001b[43mfuture_covariates\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfuture_covariates\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 973\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_samples\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 974\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstart\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 975\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart_format\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstart_format\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 976\u001b[0m \u001b[43m \u001b[49m\u001b[43mforecast_horizon\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mforecast_horizon\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 977\u001b[0m \u001b[43m \u001b[49m\u001b[43mstride\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstride\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 978\u001b[0m \u001b[43m \u001b[49m\u001b[43moverlap_end\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moverlap_end\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 979\u001b[0m \u001b[43m \u001b[49m\u001b[43mlast_points_only\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlast_points_only\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 980\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 981\u001b[0m \u001b[43m \u001b[49m\u001b[43mshow_warnings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mshow_warnings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 982\u001b[0m \u001b[43m \u001b[49m\u001b[43mpredict_likelihood_parameters\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpredict_likelihood_parameters\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 983\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mpredict_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 984\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 986\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _apply_inverse_data_transformers(\n\u001b[1;32m 987\u001b[0m series\u001b[38;5;241m=\u001b[39mseries, forecasts\u001b[38;5;241m=\u001b[39mforecasts, data_transformers\u001b[38;5;241m=\u001b[39mdata_transformers\n\u001b[1;32m 988\u001b[0m )\n\u001b[1;32m 990\u001b[0m sequence_type_in \u001b[38;5;241m=\u001b[39m get_series_seq_type(series)\n", - "File \u001b[0;32m~/projects/unit8/darts/darts/models/forecasting/regression_model.py:1373\u001b[0m, in \u001b[0;36mRegressionModel._optimized_historical_forecasts\u001b[0;34m(self, series, past_covariates, future_covariates, num_samples, start, start_format, forecast_horizon, stride, overlap_end, last_points_only, verbose, show_warnings, predict_likelihood_parameters, **kwargs)\u001b[0m\n\u001b[1;32m 1356\u001b[0m hfc \u001b[38;5;241m=\u001b[39m _optimized_historical_forecasts_last_points_only(\n\u001b[1;32m 1357\u001b[0m model\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 1358\u001b[0m series\u001b[38;5;241m=\u001b[39mseries,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1370\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[1;32m 1371\u001b[0m )\n\u001b[1;32m 1372\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1373\u001b[0m hfc \u001b[38;5;241m=\u001b[39m \u001b[43m_optimized_historical_forecasts_all_points\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1374\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1375\u001b[0m \u001b[43m \u001b[49m\u001b[43mseries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mseries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1376\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_covariates\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_covariates\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1377\u001b[0m \u001b[43m \u001b[49m\u001b[43mfuture_covariates\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfuture_covariates\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1378\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_samples\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1379\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstart\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1380\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart_format\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstart_format\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1381\u001b[0m \u001b[43m \u001b[49m\u001b[43mforecast_horizon\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mforecast_horizon\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1382\u001b[0m \u001b[43m \u001b[49m\u001b[43mstride\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstride\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1383\u001b[0m \u001b[43m \u001b[49m\u001b[43moverlap_end\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moverlap_end\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1384\u001b[0m \u001b[43m \u001b[49m\u001b[43mshow_warnings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mshow_warnings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1385\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1386\u001b[0m \u001b[43m \u001b[49m\u001b[43mpredict_likelihood_parameters\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpredict_likelihood_parameters\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1387\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1388\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1389\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m series2seq(hfc, seq_type_out\u001b[38;5;241m=\u001b[39mseries_seq_type)\n", - "File \u001b[0;32m~/projects/unit8/darts/darts/utils/historical_forecasts/optimized_historical_forecasts_regression.py:347\u001b[0m, in \u001b[0;36m_optimized_historical_forecasts_all_points\u001b[0;34m(model, series, past_covariates, future_covariates, num_samples, start, start_format, forecast_horizon, stride, overlap_end, show_warnings, verbose, predict_likelihood_parameters, **kwargs)\u001b[0m\n\u001b[1;32m 344\u001b[0m forecast \u001b[38;5;241m=\u001b[39m forecast[::stride, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m0\u001b[39m, :, :, :]\n\u001b[1;32m 346\u001b[0m \u001b[38;5;66;03m# TODO: check if faster to create in the loop\u001b[39;00m\n\u001b[0;32m--> 347\u001b[0m new_times \u001b[38;5;241m=\u001b[39m \u001b[43mgenerate_index\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 348\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhist_fct_start\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moutput_chunk_shift\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mseries_\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfreq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 349\u001b[0m \u001b[43m \u001b[49m\u001b[43mlength\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mforecast_horizon\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mstride\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mforecast\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 350\u001b[0m \u001b[43m \u001b[49m\u001b[43mfreq\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfreq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 351\u001b[0m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mseries_\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtime_index\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 352\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 354\u001b[0m forecasts_ \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 355\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx_ftc, step_fct \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(\n\u001b[1;32m 356\u001b[0m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m0\u001b[39m, forecast\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m*\u001b[39m stride, stride)\n\u001b[1;32m 357\u001b[0m ):\n", - "File \u001b[0;32m~/projects/unit8/darts/darts/utils/utils.py:568\u001b[0m, in \u001b[0;36mgenerate_index\u001b[0;34m(start, end, length, freq, name)\u001b[0m\n\u001b[1;32m 566\u001b[0m freq \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mD\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m freq \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m freq\n\u001b[1;32m 567\u001b[0m freq \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mtseries\u001b[38;5;241m.\u001b[39mfrequencies\u001b[38;5;241m.\u001b[39mto_offset(freq) \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(freq, \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;28;01melse\u001b[39;00m freq\n\u001b[0;32m--> 568\u001b[0m index \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdate_range\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 569\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstart\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 570\u001b[0m \u001b[43m \u001b[49m\u001b[43mend\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mend\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 571\u001b[0m \u001b[43m \u001b[49m\u001b[43mperiods\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlength\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 572\u001b[0m \u001b[43m \u001b[49m\u001b[43mfreq\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfreq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 573\u001b[0m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 574\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 575\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m freq\u001b[38;5;241m.\u001b[39mn \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 576\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m start \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m freq\u001b[38;5;241m.\u001b[39mis_on_offset(start):\n\u001b[1;32m 577\u001b[0m \u001b[38;5;66;03m# for anchored negative frequencies, and `start` does not intersect with `freq`:\u001b[39;00m\n\u001b[1;32m 578\u001b[0m \u001b[38;5;66;03m# pandas (v2.2.1) generates an index that starts one step before `start` -> remove this step\u001b[39;00m\n", - "File \u001b[0;32m~/miniconda3/envs/darts310/lib/python3.10/site-packages/pandas/core/indexes/datetimes.py:1008\u001b[0m, in \u001b[0;36mdate_range\u001b[0;34m(start, end, periods, freq, tz, normalize, name, inclusive, unit, **kwargs)\u001b[0m\n\u001b[1;32m 1005\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m freq \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m com\u001b[38;5;241m.\u001b[39many_none(periods, start, end):\n\u001b[1;32m 1006\u001b[0m freq \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mD\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m-> 1008\u001b[0m dtarr \u001b[38;5;241m=\u001b[39m \u001b[43mDatetimeArray\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_generate_range\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1009\u001b[0m \u001b[43m \u001b[49m\u001b[43mstart\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstart\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1010\u001b[0m \u001b[43m \u001b[49m\u001b[43mend\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mend\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1011\u001b[0m \u001b[43m \u001b[49m\u001b[43mperiods\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mperiods\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1012\u001b[0m \u001b[43m \u001b[49m\u001b[43mfreq\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfreq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1013\u001b[0m \u001b[43m \u001b[49m\u001b[43mtz\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtz\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1014\u001b[0m \u001b[43m \u001b[49m\u001b[43mnormalize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnormalize\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1015\u001b[0m \u001b[43m \u001b[49m\u001b[43minclusive\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minclusive\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1016\u001b[0m \u001b[43m \u001b[49m\u001b[43munit\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43munit\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1017\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1018\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1019\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m DatetimeIndex\u001b[38;5;241m.\u001b[39m_simple_new(dtarr, name\u001b[38;5;241m=\u001b[39mname)\n", - "File \u001b[0;32m~/miniconda3/envs/darts310/lib/python3.10/site-packages/pandas/core/arrays/datetimes.py:463\u001b[0m, in \u001b[0;36mDatetimeArray._generate_range\u001b[0;34m(cls, start, end, periods, freq, tz, normalize, ambiguous, nonexistent, inclusive, unit)\u001b[0m\n\u001b[1;32m 460\u001b[0m end \u001b[38;5;241m=\u001b[39m end\u001b[38;5;241m.\u001b[39mtz_localize(\u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m 462\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(freq, Tick):\n\u001b[0;32m--> 463\u001b[0m i8values \u001b[38;5;241m=\u001b[39m \u001b[43mgenerate_regular_range\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstart\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mend\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mperiods\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfreq\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43munit\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43munit\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 464\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 465\u001b[0m xdr \u001b[38;5;241m=\u001b[39m _generate_range(\n\u001b[1;32m 466\u001b[0m start\u001b[38;5;241m=\u001b[39mstart, end\u001b[38;5;241m=\u001b[39mend, periods\u001b[38;5;241m=\u001b[39mperiods, offset\u001b[38;5;241m=\u001b[39mfreq, unit\u001b[38;5;241m=\u001b[39munit\n\u001b[1;32m 467\u001b[0m )\n", - "File \u001b[0;32m~/miniconda3/envs/darts310/lib/python3.10/site-packages/pandas/core/arrays/_ranges.py:75\u001b[0m, in \u001b[0;36mgenerate_regular_range\u001b[0;34m(start, end, periods, freq, unit)\u001b[0m\n\u001b[1;32m 73\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m istart \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m periods \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 74\u001b[0m b \u001b[38;5;241m=\u001b[39m istart\n\u001b[0;32m---> 75\u001b[0m e \u001b[38;5;241m=\u001b[39m \u001b[43m_generate_range_overflow_safe\u001b[49m\u001b[43m(\u001b[49m\u001b[43mb\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mperiods\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstride\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mside\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstart\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 76\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m iend \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m periods \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 77\u001b[0m e \u001b[38;5;241m=\u001b[39m iend \u001b[38;5;241m+\u001b[39m stride\n", - "File \u001b[0;32m~/miniconda3/envs/darts310/lib/python3.10/site-packages/pandas/core/arrays/_ranges.py:146\u001b[0m, in \u001b[0;36m_generate_range_overflow_safe\u001b[0;34m(endpoint, periods, stride, side)\u001b[0m\n\u001b[1;32m 140\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _generate_range_overflow_safe_signed(endpoint, periods, stride, side)\n\u001b[1;32m 142\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m (endpoint \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m side \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstart\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m stride \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m (\n\u001b[1;32m 143\u001b[0m endpoint \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;241m<\u001b[39m stride \u001b[38;5;129;01mand\u001b[39;00m side \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mend\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 144\u001b[0m ):\n\u001b[1;32m 145\u001b[0m \u001b[38;5;66;03m# no chance of not-overflowing\u001b[39;00m\n\u001b[0;32m--> 146\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m OutOfBoundsDatetime(msg)\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m side \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mend\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m endpoint \u001b[38;5;241m-\u001b[39m stride \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m i64max \u001b[38;5;241m<\u001b[39m endpoint:\n\u001b[1;32m 149\u001b[0m \u001b[38;5;66;03m# in _generate_regular_range we added `stride` thereby overflowing\u001b[39;00m\n\u001b[1;32m 150\u001b[0m \u001b[38;5;66;03m# the bounds. Adjust to fix this.\u001b[39;00m\n\u001b[1;32m 151\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _generate_range_overflow_safe(\n\u001b[1;32m 152\u001b[0m endpoint \u001b[38;5;241m-\u001b[39m stride, periods \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m, stride, side\n\u001b[1;32m 153\u001b[0m )\n", - "\u001b[0;31mOutOfBoundsDatetime\u001b[0m: Cannot generate range with start=1452211200000000000 and periods=2891280" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "66c5a4b34ced44deaa32f461d4d1091e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "conformal forecasts: 0%| | 0/8761 [00:00" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -566,58 +606,144 @@ } ], "source": [ - "test[hfcs.start_time() :: horizon].plot()\n", - "hfcs.plot()" + "def plot_historical_forecasts(hfcs_):\n", + " fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(16, 4.3))\n", + " test[: 2 * 7 * 24].plot(ax=ax1)\n", + " hfcs_[: 2 * 7 * 24].plot(ax=ax1)\n", + " ax1.set_title(\"Predictions on the first two weeks\")\n", + " ax1.legend(loc=\"lower center\", bbox_to_anchor=(0.5, -0.25), ncol=4, fontsize=9)\n", + "\n", + " test.plot(ax=ax2)\n", + " hfcs_.plot(ax=ax2, lw=0.2)\n", + " ax2.set_title(\"Predictions on the entire test set\")\n", + " ax2.legend(loc=\"lower center\", bbox_to_anchor=(0.5, -0.25), ncol=4, fontsize=9)\n", + "\n", + "\n", + "plot_historical_forecasts(hfcs)" + ] + }, + { + "cell_type": "markdown", + "id": "10b8f9f4-a1f8-42c5-96dd-294440290fca", + "metadata": {}, + "source": [ + "Nice, we just performed a one-year simulation of applying conformal prediction in under 1 second! The intervals also seem to be well calibrated.\n", + "Let's find out by computing the metrics on all historical forecasts (backtest)." ] }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 10, "id": "73bf5226-e09b-447d-991d-f6efd71cbb7d", "metadata": {}, "outputs": [ { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IntervalCoverageWidth
00.90.9016092908.944092
\n", + "
" + ], "text/plain": [ - "array([8.68493151e-01, 7.84759801e+03])" + " Interval Coverage Width\n", + "0 0.9 0.901609 2908.944092" ] }, - "execution_count": 42, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "cp_model.backtest(\n", + "bt = cp_model.backtest(\n", " cal_test,\n", " historical_forecasts=hfcs,\n", " last_points_only=True,\n", " metric=[metrics.mic, metrics.miw],\n", " metric_kwargs={\"q_interval\": q_interval},\n", - ")" + ")\n", + "bt = pd.DataFrame({\"Interval\": q_range, \"Coverage\": bt[0], \"Width\": bt[1]})\n", + "bt" + ] + }, + { + "cell_type": "markdown", + "id": "36eb467d-adbd-4538-9b11-a2bd4927bd9b", + "metadata": {}, + "source": [ + "Great! Our interval indeed covers 90% of all actual values. The mean width / uncertainty range is just under 3MWh.\n", + "\n", + "It would also be interesting to see how the coverage and widths behaved over time.\n", + "\n", + "The coverage metric `ic()` gives a binary value for each time step (whether the interval contains the actual). To get the coverage ratios over some period of time, we compute the moving average with a window of 4 weeks." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "fc72247b-8e34-4a43-b82d-f9f096c9bd37", + "metadata": {}, + "outputs": [], + "source": [ + "def compute_moving_average_metrics(hfcs_, metric=metrics.ic):\n", + " \"\"\"Computes the moving 4-week average of a specific time-dependent metric.\"\"\"\n", + " # compute metric on each time step\n", + " residuals = cp_model.residuals(\n", + " cal_test,\n", + " historical_forecasts=hfcs_,\n", + " last_points_only=True,\n", + " metric=metric,\n", + " metric_kwargs={\"q_interval\": q_interval},\n", + " )\n", + "\n", + " # let's apply a moving average to the residuals with a winodow of 4 weeks\n", + " windowed_residuals = residuals.window_transform(\n", + " transforms={\"function\": \"mean\", \"mode\": \"rolling\", \"window\": four_weeks}\n", + " )\n", + " return windowed_residuals" ] }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 12, "id": "da696430-0bea-4adf-8bb4-5315e4a18ca1", "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "" - ] - }, - "execution_count": 52, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -625,45 +751,54 @@ } ], "source": [ - "cp_model.residuals(\n", - " cal_test,\n", - " historical_forecasts=hfcs,\n", - " last_points_only=True,\n", - " metric=metrics.ic,\n", - " metric_kwargs={\"q_interval\": q_interval},\n", - ").window_transform(\n", - " transforms={\"function\": \"mean\", \"mode\": \"rolling\", \"window\": 30}\n", - ").plot()" + "covs = compute_moving_average_metrics(hfcs, metrics.ic)\n", + "widths = compute_moving_average_metrics(hfcs, metrics.iw)\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(12, 4.3))\n", + "covs.plot(ax=ax1, label=\"coverages\")\n", + "ax1.set_ylabel(\"Ratio covered [-]\")\n", + "ax1.set_title(\"Moving 4-week average of Interval Coverages\")\n", + "\n", + "widths.plot(ax=ax2, label=\"widths\")\n", + "ax2.set_ylabel(\"Width [kWh]\")\n", + "ax2.set_title(\"Moving 4-week average of Interval Widths\");" ] }, { - "cell_type": "code", - "execution_count": null, - "id": "9dc2c2e3-77ed-45ad-bd9a-4c8cb43c7e47", + "cell_type": "markdown", + "id": "62f26595-5286-4c6b-9191-cf6535971e47", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "Also here, the coverage looks stable around 90% over the entire year -> the conformal model is valid.\n", + "\n", + "The interval widths range from 2.5 - 3.5 MWh. The adaptivity/responsiveness of the widths to changes in model performance is mainly controlled by the value of `cal_length`." + ] }, { - "cell_type": "code", - "execution_count": null, - "id": "93341487-6325-4901-a5fc-f86e26e122f4", + "cell_type": "markdown", + "id": "c4888c37-8cde-4c70-a807-f0f74e3536e3", "metadata": {}, - "outputs": [], "source": [ - "cp_model" + "#### Comparison with another model\n", + "\n", + "Okay now let's compare the uncertainty of our first model with a more powerful regression model.\n", + "\n", + "- Use the last week (7*24) of consumption as lookback window\n", + "- Also use a cyclic encoding of the hour of the day and day of week as a future covariate\n", + "\n", + "The process is exactly the same as for the first model, so we won't go into any detail." ] }, { "cell_type": "code", - "execution_count": 53, - "id": "c6189382-1357-444e-91b0-206e0a14a386", + "execution_count": 13, + "id": "6ca89f61-3da1-4e89-86a0-edee7474ee3f", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5b88126a4a734eb2a30972372010c510", + "model_id": "6f1d228446304cadacfc27e9ca1be4ef", "version_major": 2, "version_minor": 0 }, @@ -677,12 +812,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6ac66c014bbf411ca36cc230ae777239", + "model_id": "134beb5cda3e43c09b5488830abc7440", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "conformal forecasts: 0%| | 0/1 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IntervalCoverageWidth
00.90.8984131662.243896
\n", + "" + ], "text/plain": [ - "
" + " Interval Coverage Width\n", + "0 0.9 0.898413 1662.243896" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] }, "metadata": {}, @@ -700,139 +881,1555 @@ } ], "source": [ - "quantiles = [0.05, 0.1, 0.5, 0.9, 0.95]\n", - "cp_model = ConformalNaiveModel(\n", - " model=model, quantiles=quantiles, cal_stride=7 * 24, cal_length=52\n", + "add_encoders = {\"cyclic\": {\"future\": [\"hour\", \"dayofweek\"]}}\n", + "input_length = 7 * 24\n", + "model2 = LinearRegressionModel(\n", + " lags=input_length,\n", + " lags_future_covariates=(input_length, 1),\n", + " output_chunk_length=1,\n", + " add_encoders=add_encoders,\n", + ")\n", + "model2.fit(train)\n", + "\n", + "cp_model2 = ConformalNaiveModel(\n", + " model=model2, quantiles=quantiles, cal_length=four_weeks\n", + ")\n", + "hfcs2 = cp_model2.historical_forecasts(\n", + " series=cal_test,\n", + " forecast_horizon=horizon,\n", + " start=test.start_time(),\n", + " last_points_only=True,\n", + " stride=horizon,\n", + " **pred_kwargs,\n", ")\n", + "plot_historical_forecasts(hfcs2)\n", "\n", - "pred = cp_model.historical_forecasts(\n", - " n=horizon,\n", - " series=concatenate([cal, test], axis=0),\n", - " cal_stride=24,\n", - " verbose=True,\n", - " predict_likelihood_parameters=True,\n", + "bt2 = cp_model.backtest(\n", + " cal_test,\n", + " historical_forecasts=hfcs2,\n", + " last_points_only=True,\n", + " metric=[metrics.mic, metrics.miw],\n", + " metric_kwargs={\"q_interval\": q_interval},\n", ")\n", - "series[pred.start_time() - 3 * 24 * series.freq : pred.end_time()].plot(label=\"actual\")\n", - "pred.plot(label=\"pred\");" + "bt2 = pd.DataFrame({\"Interval\": q_range, \"Coverage\": bt2[0], \"Width\": bt2[1]})\n", + "bt2" ] }, { "cell_type": "markdown", - "id": "05fc7f3a-b84b-4f1f-9dae-f31e791d7fed", + "id": "027d41cc-7f43-414e-bc7e-9658fadc5851", "metadata": {}, "source": [ - "## Sources\n", - "\n", - "(1) Lei, J., G’Sell, M., Rinaldo, A., Tibshirani, R. J., and Wasserman, L. (2018). Distribution-Free Predictive Inference\n", - "for Regression. Journal of the American Statistical Association, 113(523):1094–1111." + "Nice! We achieve again 90% coverage, but our average **interval width decreased from 2.9 MWh to 1.7 MWh!**\n", + "Finally, let's also look at the metrics over time and compare our two models." ] }, { "cell_type": "code", - "execution_count": null, - "id": "af06f43a-db6c-4c72-b116-bdb0d7e2af95", + "execution_count": 14, + "id": "aa8a446d-5d58-4b5a-a7fb-2d2c33069909", "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IntervalCoverageWidth
Model 10.90.9022908.944
Model 20.90.8981662.244
\n", + "
" + ], + "text/plain": [ + " Interval Coverage Width\n", + "Model 1 0.9 0.902 2908.944\n", + "Model 2 0.9 0.898 1662.244" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+UAAAGdCAYAAAB0LdIPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD/10lEQVR4nOzddVhU2RvA8e/QJQZ2odida6yBHdiurYvdXWvn2q27uja6tquu3YXtz9bFWrsLEyWEOb8/ZrkyAjooMCjv53l4mBtz73vO3Jm5Z07plFIKIYQQQgghhBBCxDoLcwcghBBCCCGEEELEV1IoF0IIIYQQQgghzEQK5UIIIYQQQgghhJlIoVwIIYQQQgghhDATKZQLIYQQQgghhBBmIoVyIYQQQgghhBDCTKRQLoQQQgghhBBCmIkUyoUQQgghhBBCCDORQrkQQgghhBBCCGEmUij/QosWLUKn06HT6di/f3+47UopMmfOjE6no0yZMjEai06nY/jw4TF6DlM8fvwYFxcXdDoda9asMXc4UbJ///5vMu7v1W+//UbmzJmxsbFBp9Px8uXLCPcLfR+ePHkyyud49+4dw4cPj/D9GxfdunULnU7HokWLTNr/8ePH9O/fnzx58uDk5ISdnR1ZsmShe/fu/PvvvzEbrBACkHuFiMi9gogucq8Qnin3Ck+fPsXCwoKOHTuG29a9e3d0Oh0DBgwIt61169ZYWlry4sULwPTPlND8v3XrlrZu1qxZEcYYn99jVuYO4FuXIEECFixYEO7L1Nvbm+vXr5MgQYIYj+Ho0aOkTZs2xs/zOZ07d8bOzs7cYYhv3NmzZ+nWrRtt2rShefPmWFlZxcj76N27d4wYMQIgxm+GY9v//vc/qlevjlKKLl26ULx4cWxsbLhy5QpLly6lSJEi2peqECLmyb3CB3KvIKKD3Ct8uWTJkpErVy727dsXbtv+/ftxdHSMdFv+/PlJnDgx8HWfKbNmzSJp0qS0aNHii57/PZKa8q/UsGFD1q5dy+vXr43WL1iwgOLFi5M+ffoYj6FYsWJm/6Jdu3YtO3bsYOzYsWaNQ4C/v7+5Q/gqPj4+ALRt25aSJUtSrFgxLC0tzRyV6d6/f09wcLDZzv/69Wtq1aqFnZ0dZ86cYdiwYVSqVIkyZcrQvn17Dh48yLx588wW36f4+/ujlDJ3GEJEO7lXMJB7hbhD7hXMy9z3CmXLluXKlSs8evRIW/f8+XMuXLhAx44dOXXqFG/evNG23bt3jxs3blC2bFltXVz4TPmeSKH8KzVu3BiAFStWaOtevXrF2rVradWqVYTPef78OZ06dSJNmjTY2Njg5ubGoEGDCAwM1PYpUKAApUqVCvfckJAQ0qRJQ926dbV1HzcfCW0msm/fPjp27EjSpElxcXGhbt26PHjwwOh4gYGB9O7dm5QpU+Lg4EDp0qU5deoUGTJkMPnXq+fPn9O5c2dGjx4dpRuL169fY2VlxcSJE7V1z549w8LCgoQJExp9WHXr1o1kyZIZ3bDv3r2b8uXL4+zsjIODAyVKlGDPnj3hzvPvv//SpEkTkidPjq2tLTly5GDmzJkmxVe5cmVSpEjB//73v0j3CwgIoHfv3uTPn5+ECROSJEkSihcvzoYNG4z2i8prGhQUxKhRo8iePTu2trYkS5aMli1b8vTpU6PnZsiQgerVq7Nu3ToKFCiAnZ2d9ovuzJkzKV26NMmTJ8fR0ZE8efIwYcIE3r9/b3QMpRRjxozB1dUVOzs7ChcuzK5duyhTpky4X4Vfv35Nnz59yJgxIzY2NqRJk4YePXrw9u3bz+YnwMKFC8mXLx92dnYkSZKEOnXqcOnSJW17mTJlaNasGQBFixZFp9NF+VfUFi1a4OTkxLVr1/Dw8MDJyYl06dLRu3dv7T1269YtkiVLBsCIESO05qVhz2XKdRPazGrJkiX07t2bNGnSYGtri4+PDzqdjgULFoSLb9u2beh0OjZu3AjAtWvXaNmyJVmyZMHBwYE0adJQo0YNLly4EKV0h5o3bx6PHj1iwoQJkX5Z1qtXz2h548aNFC9eHAcHBxIkSEDFihU5evSotn39+vXodLoI319//PEHOp2O8+fPa+tOnjxJzZo1SZIkCXZ2dhQoUIDVq1cbPS/0c2rnzp20atWKZMmS4eDgQGBgYJTyxMfHh0qVKuHg4ECyZMno3LkzW7ZsibC5sCmfGU+fPqVdu3akS5dOe++VKFGC3bt3R5zhQphA7hXkXkHuFeReIS7dK4QWrsN+T3p7e2NlZUWfPn0AOHjwoLYttOY8bKE8oubrx44do0SJEtjZ2ZE6dWoGDBgQ7lrKkCEDPj4+eHt7a3maIUMGo33ev3/PoEGDSJ06Nc7OzlSoUIErV64Y7XPmzBmqV6+u5X3q1KmpVq0a9+7d+6I8MTslvoiXl5cC1IkTJ9TPP/+sihQpom37448/lKOjo3r9+rXKlSuXcnd317b5+/urvHnzKkdHRzVp0iS1c+dONWTIEGVlZaU8PDy0/aZPn64AdfXqVaPzbt26VQFq48aN2jpADRs2LFxsbm5uqmvXrmrHjh1q/vz5KnHixKps2bJGx2vcuLGysLBQ/fv3Vzt37lTTpk1T6dKlUwkTJlTNmzc3KS+aNm2qihUrpkJCQtS+ffsUoP766y+TnlusWDFVqVIlbXnlypXKzs5O6XQ6dfjwYW19jhw5VIMGDbTlJUuWKJ1Op2rXrq3WrVunNm3apKpXr64sLS3V7t27tf18fHxUwoQJVZ48edSff/6pdu7cqXr37q0sLCzU8OHDtf0+jvvu3bsqT548Klu2bOr69eufTMPLly9VixYt1JIlS9TevXvV9u3bVZ8+fZSFhYVavHixtp+pr2lISIiqUqWKcnR0VCNGjFC7du1S8+fPV2nSpFE5c+ZU7969057r6uqqUqVKpdzc3NTChQvVvn371P/+9z+llFI9e/ZUf/zxh9q+fbvau3evmjp1qkqaNKlq2bKl0fkHDBigANWuXTu1fft2NW/ePJU+fXqVKlUqo2v37du3Kn/+/Cpp0qRqypQpavfu3Wr69OkqYcKEqly5ckqv138yn8aMGaMA1bhxY7Vlyxb1559/Kjc3N5UwYUItT3x8fNTgwYMVoLy8vNTRo0fVtWvXIj1m2PdhqObNmysbGxuVI0cONWnSJLV79241dOhQpdPp1IgRI5RSSgUEBKjt27crQLVu3VodPXrU6FxRvW7SpEmj6tWrpzZu3Kg2b96sfH19VYECBVSJEiXCxdygQQOVPHly9f79e6WUUt7e3qp3795qzZo1ytvbW/3999+qdu3ayt7eXl2+fFl73s2bN7V8+ZRKlSopS0tL5efn98n9Qi1btkwBqlKlSmr9+vVq1apVqlChQsrGxkYdPHhQKaXU+/fvVfLkyVXTpk3DPb9IkSKqYMGC2vLevXuVjY2NKlWqlFq1apXavn27atGiRbjYQ1+7NGnSqHbt2qlt27apNWvWqODgYJPz5MGDB8rFxUWlT59eLVq0SG3dulX9/PPPKkOGDApQ+/bt0/Y19TOjcuXKKlmyZGru3Llq//79av369Wro0KFq5cqVJuWnEGHJvcIHcq8g9wpyrxB37hV8fX2VhYWFateunbaua9euqnjx4koppYoWLar69u2rbWvZsqWytLRUr1690tZ9/Jni4+OjHBwcVM6cOdWKFSvUhg0bVOXKlVX69OkVoG7evKmUUur06dPKzc1NFShQQMvT06dPG+VVhgwZVNOmTdWWLVvUihUrVPr06VWWLFlUcHCwUkopPz8/5eLiogoXLqxWr16tvL291apVq1SHDh3UxYsXP5n2uEoK5V8o7Bs89AL6559/lFJK/fDDD6pFixZKKRXui3b27NkKUKtXrzY63vjx4xWgdu7cqZRS6tmzZ8rGxkYNHDjQaL8GDRqoFClSaG9SpSL/ou3UqZPRcydMmKAA9fDhQ6WU4c0DqH79+hntt2LFCgWY9EW7efNmZW1trS5cuKCUCv+F9TmDBw9W9vb2KiAgQCmlVJs2bVSVKlVU3rx5tQ/F+/fvK0DNnTtXKWX4wE+SJImqUaOG0bFCQkJUvnz5jG56KleurNKmTWv0IaKUUl26dFF2dnbq+fPn4eI+c+aMSp06tSpVqpTy9fU1KR1hBQcHq/fv36vWrVurAgUKaOtNfU1D83/t2rVG+504cUIBatasWdo6V1dXZWlpqa5cufLJmEJCQtT79+/Vn3/+qSwtLbV0P3/+XNna2qqGDRsa7X/06FEFGF27Y8eOVRYWFkZfakoptWbNGgWorVu3Rnr+Fy9eKHt7e6ObSaWUunPnjrK1tVVNmjTR1kX05RmZyL5oI3qPeXh4qGzZsmnLT58+DffeCRXV66Z06dLhjjFjxgwFGL02ofndu3fvSNMUHBysgoKCVJYsWVTPnj219aZ+0WbPnl2lTJnyk/uECgkJUalTp1Z58uRRISEh2vo3b96o5MmTqx9//FFb16tXL2Vvb69evnyprbt48aIC1G+//WZ0/gIFChh9RimlVPXq1VWqVKm084S+dp6enp+NM7I86du3r9LpdMrHx8do/8qVKxsVyqPymeHk5KR69Ojx2ZiEMIXcKxjIvUJ4cq8QntwrGMTGvYJSSuXPn19lzZpVW86TJ4/q37+/UkqpX375RRUuXFjbljFjRqP3jFLhP1MaNmyo7O3t1aNHj4zizJ49u1GhXKnwn3mhQvPq42tg9erVClBHjx5VSil18uRJBaj169d/Np3fCmm+Hg3c3d3JlCkTCxcu5MKFC5w4cSLS5mh79+7F0dExXPPR0KYwoU2qXFxcqFGjBosXL0av1wPw4sULNmzYgKenJ1ZWnx+jr2bNmkbLefPmBeD27duAoZkKQIMGDYz2q1evnknHf/XqFe3bt6dfv37kzp37k/sGBwcb/an/mpaVL18ef39/jhw5AhiamVWsWJEKFSqwa9cubR1AhQoVADhy5AjPnz+nefPmRsfU6/VUqVKFEydO8PbtWwICAtizZw916tTBwcHBaF8PDw8CAgI4duyYUZw7duygVKlSlC5dml27dpEkSZLP5gPAX3/9RYkSJXBycsLKygpra2sWLFhg1NzK1Nd08+bNJEqUiBo1ahjFnD9/flKmTBmuSW7evHnJmjVruJjOnDlDzZo1cXFxwdLSEmtrazw9PQkJCeHq1auAoZlRYGBguGugWLFi4ZoSbd68mdy5c5M/f36juCpXrhzpyMKhjh49ir+/f7jmZenSpaNcuXIRNiX8Gjqdjho1ahity5s3r3btf8qXXDc//fRTuOM0bdoUW1tbo9FFV6xYQWBgIC1bttTWBQcHM2bMGHLmzImNjQ1WVlbY2Njw77//Gl0/MeHKlSs8ePCAn3/+GQuLD18HTk5O/PTTTxw7dox3794B0KpVK/z9/Vm1apW2n5eXF7a2tjRp0gQwNK+7fPkyTZs21dIWNu8ePnwYrvlZRHlnap54e3uTO3ducubMafT80KbCoUz9zAAoUqQIixYtYtSoURw7dixcszshvpTcK8i9gtwryL3Cx8x5r1C2bFmuXr3KgwcP8PX15Z9//tG6Iri7u3PmzBlevXrFnTt3uHnzplHT9Yjs27eP8uXLkyJFCm2dpaUlDRs2jHJsn/tcypw5M4kTJ6Zfv37Mnj2bixcvRvkccY0UyqOBTqejZcuWLF26lNmzZ5M1a9YI+wMB+Pr6kjJlSnQ6ndH65MmTY2Vlha+vr7auVatW3L9/X/vCCX2TmtpvxsXFxWjZ1tYW+DC4R+i5wr55AKysrMI9NyKDBg3C2tqaLl268PLlS16+fImfnx9gGK3y5cuXKKW4desW1tbWRn+hX/I//vgjDg4O7N69m2vXrnHr1i3ti/b48eP4+fmxe/du3NzcyJgxI2CYTgUMNwQfH3f8+PEopXj+/Dm+vr4EBwfz22+/hdvPw8MDMPRLC2v9+vX4+/vTsWNHLb8+Z926dTRo0IA0adKwdOlSjh49qt1sBQQEGO1rymv6+PFjXr58iY2NTbi4Hz16FC7mVKlShYvpzp07lCpVivv37zN9+nQOHjzIiRMntH5On7sGIlr3+PFjzp8/Hy6mBAkSoJQKF1dYoeeJKNbUqVMbXffRwcHBIdzovra2tuFej4h8yXUTUbqSJElCzZo1+fPPPwkJCQEMfTiLFClCrly5tP169erFkCFDqF27Nps2beL48eOcOHGCfPnyfdFAPOnTp+fp06cm9d373Oui1+u1Udpz5crFDz/8gJeXF2Do37h06VJq1aql3ZCGvjf79OkTLu86deoEmJZ3puaJr6+vydcufP4zA2DVqlU0b96c+fPnU7x4cZIkSYKnp6fRYDhCfAm5V5B7BblXkHuFj5nrXgGM+5Xv378fS0tLSpQoAUDJkiUBQ7/yiPqTRyT0c+tjEa37nM99LiVMmBBvb2/y58/PwIEDyZUrF6lTp2bYsGHf7I/pMiVaNGnRogVDhw5l9uzZjB49OtL9XFxcOH78OEopoy/bJ0+eEBwcTNKkSbV1lStXJnXq1Hh5eVG5cmW8vLwoWrRouFqhLxV6wT9+/Jg0adJo64ODg0364Pvnn3+4detWhG+25s2bA4Zfd1OnTs2JEyeMtmfLlg0AGxsbSpYsye7du0mbNi0pU6YkT548uLm5AYYPij179lC9enXtuaF59Ntvv1GsWLEIY0uRIgXBwcFYWlry888/07lz5wj3C/3yDjV16lRWrVpF1apV+fvvv6lUqdJn82Hp0qVkzJiRVatWGb2mYQfjCWXKaxo62M727dsjPN/HU358fNMGhhuGt2/fsm7dOlxdXbX1Z8+eNdov7DXwsUePHhn9Ap40aVLs7e1ZuHBhhHGFvXY/Fnqehw8fhtv24MGDTz43tiVOnDjK101ErwFAy5Yt+euvv9i1axfp06fnxIkT/PHHH0b7LF26FE9PT8aMGWO0/tmzZyRKlCjK8VeuXJmdO3eyadMmGjVq9Ml9P/e6WFhYaFOfhKanU6dOXLp0iRs3bvDw4UOjX/JDX8cBAwYYDUYUVuh7P1REeWdqnri4uER67YZl6mdG6L7Tpk1j2rRp3Llzh40bN9K/f3+ePHkS6XtSCFPJvYIxuVeQe4WIziP3CjF/rwBQunRpLC0t2b9/P7a2thQsWBAnJycAnJ2dyZ8/P/v27eP58+dYWVlpBfbIuLi4RPgDdkz9qJ0nTx5WrlyJUorz58+zaNEiRo4cib29Pf3794+Rc8YkKZRHkzRp0tC3b18uX76sfclEpHz58qxevZr169dTp04dbf2ff/6pbQ8V+mafNm0aBw8e5OTJk8yZMyfaYi5dujRgqBkqWLCgtn7NmjUmTdMwbdo0Xr58abTu7Nmz9OzZk+HDh+Pu7q410SpcuHCkx6lQoQIDBgwgQYIEWrMzR0dHihUrxm+//caDBw+09QAlSpQgUaJEXLx4kS5dukR6XBsbG8qWLcuZM2fImzcvNjY2n02TnZ0d69ato1mzZtSsWZNVq1ZRq1atTz5Hp9NhY2Nj9GH76NGjcCOqgmmvafXq1Vm5ciUhISEULVr0szFHFhNg9Au+UircVFhFixbF1taWVatWGRWijh07xu3bt42+aKtXr86YMWNwcXEJ90XzOcWLF8fe3p6lS5dSv359bf29e/fYu3dvuCaaseHjX11DOTg4RPm6iUylSpVIkyYNXl5epE+fHjs7u3BNq3U6Xbiali1btnD//n0yZ84c5XO2bt2aiRMn8ssvv1CqVCmjm+hQ69ato27dumTLlo00adKwfPly+vTpo103b9++Ze3atdqI7KEaN25Mr169WLRoETdu3CBNmjRGN6PZsmUjS5YsnDt3LtyNQ1SYmifu7u5MmjSJixcvGt2srly50ui5pn5mfCx9+vR06dKFPXv2cPjw4S9MjRAfyL2CgdwrGMi9gjG5V4i9ewUw1DYXKFBAK5SH1vCHcnd3Z9++fbx48YIiRYpoBfbIlC1blo0bN/L48WPth+6QkBCjbm+hbG1to21aPp1OR758+Zg6dSqLFi3i9OnT0XLc2CaF8mg0bty4z+7j6enJzJkzad68Obdu3SJPnjwcOnSIMWPG4OHhYfSFAoYmTOPHj6dJkybY29t/Ub+MyOTKlYvGjRszefJkLC0tKVeuHD4+PkyePJmECRMa9TGNSP78+T957I+nyIhM+fLlCQkJYc+ePSxevFhbX6FCBYYNG4ZOp6NcuXLaeicnJ3777TeaN2/O8+fPqVevHsmTJ+fp06ecO3eOp0+far8wTp8+nZIlS1KqVCk6duxIhgwZePPmDdeuXWPTpk3s3bs3XDzW1tasWLGCNm3aUK9ePf78889wH45hhU4z0qlTJ+rVq8fdu3f59ddfSZUqFf/++2+4/T/3mjZq1Ihly5bh4eFB9+7dKVKkCNbW1ty7d499+/ZRq1Yto5u0iFSsWBEbGxsaN27ML7/8QkBAAH/88YfWFDlUkiRJ6NWrF2PHjiVx4sTUqVOHe/fuMWLECFKlSmV0DfTo0YO1a9dSunRpevbsSd68edHr9dy5c4edO3fSu3fvSG8MEiVKxJAhQxg4cCCenp40btwYX19fRowYgZ2dHcOGDftkemJCggQJcHV1ZcOGDZQvX54kSZKQNGlSMmTI8EXXTUQsLS3x9PRkypQpODs7U7duXRImTGi0T/Xq1Vm0aBHZs2cnb968nDp1iokTJ37x3J8JEyZkw4YNVK9enQIFCtClSxeKFy+u9T1bunQp586do27dulhYWDBhwgSaNm1K9erVad++PYGBgUycOJGXL1+G+0xLlCgRderUYdGiRbx8+ZI+ffqE+5yYM2cOVatWpXLlyrRo0YI0adLw/PlzLl26xOnTp/nrr78+mwZT86RHjx4sXLiQqlWrMnLkSFKkSMHy5cu5fPkygBabqZ8Zr169omzZsjRp0oTs2bOTIEECTpw4wfbt2yOt+RciquRewfjYcq8g9wqh5F4h9u4VQpUtW5aJEyei0+kYP3680TZ3d3emTp2KUkobK+ZTBg8ezMaNGylXrhxDhw7FwcGBmTNnRtidLrSWe9WqVbi5uWFnZ0eePHlMjnvz5s3MmjWL2rVr4+bmhlKKdevW8fLlSypWrGjyceKU2B9b7vtg6qiPEY0u6Ovrqzp06KBSpUqlrKyslKurqxowYIA2qujHfvzxRwVEOB2RUpGPqPpxbKEjGoadJiggIED16tVLJU+eXNnZ2alixYqpo0ePqoQJExqN5miqqI6oqpRSer1eJU2aVAHq/v372vrDhw8rwGi6pbC8vb1VtWrVVJIkSZS1tbVKkyaNqlatWrhz37x5U7Vq1UqlSZNGWVtbq2TJkqkff/xRjRo16pNx6/V61a1bN2VhYaHmzZv3yTSMGzdOZciQQdna2qocOXKoefPmqWHDhqnI3mKfe03fv3+vJk2apPLly6fs7OyUk5OTyp49u2rfvr36999/tf1cXV1VtWrVIjzGpk2btOenSZNG9e3bV23bti3cNaDX69WoUaNU2rRplY2NjcqbN6/avHmzypcvn6pTp47RMf38/NTgwYNVtmzZlI2NjTYVSM+ePY1G24zM/PnzVd68ebXn1qpVK9zI2dExoqqjo2O4fSN6PXbv3q0KFCigbG1tw40i/KXXzceuXr2qAAWoXbt2hdv+4sUL1bp1a5U8eXLl4OCgSpYsqQ4ePKjc3d2NPjuiMqKqUko9evRI9evXT+XKlUs5ODgoW1tblTlzZtW+fXttBORQ69evV0WLFlV2dnbK0dFRlS9f3miaobB27typpefjKXtCnTt3TpvOxdraWqVMmVKVK1dOzZ49W9vnU6+zqXmilFL//POPqlChgrKzs1NJkiRRrVu3VosXL1aAOnfunNG+n/vMCAgIUB06dFB58+ZVzs7Oyt7eXmXLlk0NGzZMvX379rN5LsTH5F4hYnKvIPcKnyL3CrF3rxA61d7H050pZRgF3sLCItKYPv5MUcrwfixWrJiytbVVKVOmVH379lVz584NN/r6rVu3VKVKlVSCBAkUoFxdXZVSkefVx+m6fPmyaty4scqUKZOyt7dXCRMmVEWKFFGLFi0yKd1xkU6p/4a2FOI/R44coUSJEixbtkwbVVnELzdv3iR79uwMGzaMgQMHmjscIaKkXbt2rFixAl9f369qUiiEiJzcKwi5VxAi+kihPJ7btWsXR48epVChQtjb23Pu3DnGjRtHwoQJOX/+fLhRKcX359y5c6xYsYIff/wRZ2dnrly5woQJE3j9+jX//PNPhKOtChFXjBw5ktSpU+Pm5oafnx+bN29m/vz5DB48mJEjR5o7PCG+C3KvIOReQYiYJX3K4zlnZ2d27tzJtGnTePPmDUmTJqVq1aqMHTtWvmTjCUdHR06ePMmCBQt4+fIlCRMmpEyZMowePVq+ZEWcZ21tzcSJE7l37x7BwcFkyZKFKVOm0L17d3OHJsR3Q+4VhNwrCBGzpKZcCCGEEEIIIYQwk08PmSmEEEIIIYQQQogYI4VyIYQQQgghhBDCTKRQLoQQQgghhBBCmIkUyoUQQgghhBBCCDORQnkU6fV6bt68iV6vN3cosSq+pjtUfE8/SB6A5IGkP36nPz6Jr691fE13WPE9D+J7+kHyIL6nH8yTB1IoF0IIIYQQQgghzEQK5UIIIYQQQgghhJlIoVwIIYQQUTZ69GgqV66Mu7s7DRs25ODBgwBs2rSJokWLUqpUKe3v0aNH2vN8fHxo3LgxJUqUoF27djx8+FDbFhAQwJAhQyhdujTVqlVj+/btsZ4uIYQQIrZZmTsAIYQQQnx7mjZtSt++fbGxscHHx4fOnTuzceNGAIoUKcJvv/0W7jlBQUH88ssvtGvXjipVqjBnzhyGDh3KvHnzAJgzZw6vXr1i69atXL9+ne7du5MjRw5cXV1jNW1CCCFEbJJCuRBCCCGiLEOGDNpjnU5HUFAQz549++RzTp06hb29PbVq1QKgbdu2VKhQgYcPH5IqVSq2bt3K5MmTcXJyIl++fJQuXZqdO3fStm3bcMcKCgoiKCjIaJ2VlRU2NjZfnbbQwX3i20BH8TXdYcX3PIjv6QfJg/iefoj+PLCw+HzjdCmUCyGEEOKLjBs3jk2bNhEYGIi7uztubm74+Phw7tw5ypcvT5IkSWjYsCH16tUD4MaNG2TOnFl7vr29PWnTpuXGjRs4Ojri6+trtD1r1qz4+PhEeG4vLy+thj1U/fr1adCgQbSl7+7du9F2rG9JfE13WPE9D+J7+kHyIL6nH6IvDzJmzPjZfaRQLoQQQogv0r9/f/r27cvJkye5du0aAAULFmTlypWkTJmSixcv0qdPH1xcXChbtiz+/v44OjoaHcPR0RF/f3/evXuHpaUldnZ2RtvevXsX4blbtmxJ06ZNjdZFZ0353bt3SZcunUk1HN+L+JrusOJ7HsT39IPkQXxPP5gnD6RQLoQQQogvZmlpSdGiRVmxYgVubm4UL15c25Y7d24aNWrEvn37KFu2LPb29rx9+9bo+W/fvsXe3h4HBwdCQkIICAjQCuZv377FwcEhwvPa2NhESwH8UywsLOLlTWl8TXdY8T0P4nv6QfIgvqcfYjcP4ndOCyGEECJa6PV67t27F269TqfTHru5uWk16gD+/v7cu3cPNzc3nJ2dcXFxMdp+9epV3NzcYjZwIYQQwsykUC6EEEKIKHn37h3btm3j3bt3BAcHs2fPHk6dOkWBAgU4cuQIL168AODy5cusWrWKUqVKAVCoUCH8/f3ZtGkTQUFBLFiwgJw5c5IqVSoAPDw8mD9/Pm/fvuXChQscOHCAihUrmi2dQgghRGwwa6F8zpw51K9fnx9++IEdO3ZEup/MWyqEEELEHTqdjg0bNuDh4UH58uXx8vJi1KhRZM6cmePHj9OgQQNKlSrFwIED8fT01ArWNjY2TJgwgWXLllG2bFnOnTvHyJEjteO2b98eJycnqlSpQv/+/enfv7/RKO9CCCHE98isfcrTpUtH7969mT179if3k3lLhRBCiLjD3t4+0u/unj170rNnz0ifmytXLlauXBnhNjs7O0aNGhUtMQohhBDfCrPWlHt4eFCsWLHPDtSydetW2rVrF27e0ti2bds2PDw8GD58OL6+vrF+fiGEEEKI+Mbf358RI0bQsmVLpk6dyvTp05k0aRLjxo1j0qRJXL161dwhChHrFi1aRKJEiT65z/Dhw8mfP/8n97l16xY6nY6zZ89GW2yxKUOGDEybNs3k/U3JE3OI86Ovv379OkrzlgIEBQURFBRktC46pkm5ePGi1sw+e/bs9OvX76uO9y3R6/VG/+Ob+J5+kDwAyQNJf/SnP76PbCvEp9y6dYudO3cyZcoUrly5Eul+/fv3Z8CAAYwcOdJoYEEhvmcNGzbEw8MjSs9p0aIFL1++ZP369TET1HeiR48e7Nu3j6tXr5IjR45Y+cEizhfKozpvKYCXlxfz5s0zWle/fn0aNGjwVbEcO3ZMe/zvv/9y+/btrzret+ju3bvmDsGs4nv6QfIAJA8k/dGX/owZM0bbsYT4nqxdu5bGjRvz/v37z+4bEhLCqFGjCA4OZsyYMVIwF/GCvb099vb25g7ju6SUol69ely7do0LFy7EyjnjfKE8qvOWArRs2ZKmTZsarYuOmvKOHTuyZs0aABIkSBCv+rTr9Xru3r1LunTp4mXNTnxPP0gegOSBpD9+p1+I2HLgwAGaNGliVCAvXLgwnTt3xtLSEisrK6ytrbGysuLo0aNMmDABgHHjxmFvb8/QoUPNFboQX2zTpk38/PPPPH/+HAsLC86ePUuBAgXo06cPEydOBAyDYb5+/ZoVK1awaNEievTowcuXL7VjjBs3jqlTp/Lu3TsaNGhAsmTJtG3Dhw9n8eLFwIepKvft26cNpnnjxg169uzJ8ePHcXV1Zf78+ZQoUQKA27dv06VLFw4dOkRQUBAZMmRg4sSJkdbUZ8iQgTZt2nD16lXWrVuHi4sLM2bM4Mcff6RNmzbs2bOHjBkz4uXlReHChbXnrV27lqFDh3Lt2jVSpUpF165d6d27t7b9yZMntG7dmt27d5MyZcoIxyB59eoVffv2Zf369QQEBFC4cGGmTp1Kvnz5TH4tpk+fzu3bt1m0aJEUykOFnbc0d+7cwOfnLbWxsfnqAnhEwv4apdPp4uVNmYWFRbxMd6j4nn6QPADJA0l//E6/EDHp7t271KtXT+uG2LBhQ7p27Urx4sUjfN/Vrl2bDBky0KlTJwCGDRuGi4sLnTt3jtW4RdxXuHBhHj16ZNK+ISEhWFpaRst5U6ZMycmTJz+7X+nSpXnz5g1nzpyhUKFCeHt7kzRpUry9vbV99u/fH+lAmqtXr2bYsGHMnDmTUqVKsWTJEmbMmKGVmfr06cOlS5d4/fo1Xl5eACRJkoQHDx4AMGjQICZNmkSmTJno1asXTZs25dq1a1hZWdG5c2eCgoI4cOAAjo6OXLx4EScnp0+mZ+rUqYwZM4YhQ4YwdepUfv75Z0qUKEGrVq2YOHEi/fr1w9PTEx8fH3Q6HadOnaJBgwYMHz6chg0bcuTIETp16oSLiwstWrQADM3v7969y969e7GxsaFbt248efJEO6dSimrVqpEkSRK2bt1KwoQJmTNnDuXLl+fq1askSZLks6+DuZi1UB4cHExISAhKKYKDgwkMDMTa2jrch27ovKWjR4/mxo0bHDhwgEWLFpkn6P8opcx6fiGEEEKI70lgYCB169bl6dOnAFSqVImlS5diZfXp29WOHTsSEBBAr169AOjVqxclSpSIk4M5CfN59OgR9+/fN3cYkUqYMCH58+dn//79FCpUSCuAjxgxgjdv3vD27VuuXr1KmTJlInz+tGnTaNWqFW3atAFg1KhR7N69m4CAAACcnJywt7cnMDCQlClThnt+nz59qFatGnq9nh49elC5cmWuXbtG9uzZuXPnDj/99BN58uQB+GTlaCgPDw/at28PwNChQ/njjz/44YcfqF+/PgD9+vWjePHiPH78mJQpUzJlyhTKly/PkCFDAMMYYhcvXmTixIm0aNGCq1evsm3bNo4dO0bRokUBWLBgATly5NDOuW/fPi5cuMCTJ0+wtbUFYNKkSaxfv541a9bQrl27z8ZtLmYtlI8aNYrNmzcDcObMGYYNG8bs2bN5+vQpXl5erF69GjA01Rg1ahRVqlTB2dnZbPOWSh8lIYQQQoiYMX78eK1GMWPGjKxYseKzBfJQPXv25O7du0ydOpWgoCB69erF3r17YzJc8Y2JqCAameiuKTdVmTJl2L9/P7169eLgwYOMGjWKtWvXcujQIV6+fEmKFCnInj17hM+9dOkSHTp0MFpXvHhx9u3bZ9K58+bNqz1Onjw5YGgunj17drp160bHjh3ZuXMnFSpU4KeffjLa/3PHS5EiBYBWqA+77smTJ6RMmZJLly5Rq1Yto2OUKFGCadOmERISwqVLl7CysjJq7p49e3ajEehPnTqFn58fLi4uRsfx9/fn+vXrpmSD2Zi1UD58+HCGDx8e4baqVatqj2XeUiGEEEKI79fTp08ZO3YsAJaWlqxduzbKTU3Hjh3Lpk2buHbtGvv27WPPnj2UL18+JsIV3yBTmpCDYfyQ27dv4+rqGutdlcqUKcOCBQs4d+4cFhYW5MyZE3d3d7y9vXnx4gXu7u4xdm5ra2vtcWhFZOhsI23atKFy5cps2bKFnTt3MnbsWCZPnkzXrl2jdLxPnUMpFa4CNGzL5NDHn6ok1ev1pEqViv3794fb9rnp48xNOsUJIYQQQgizWrJkidbMtlOnThQoUCDKx7C1tWXEiBHa8qBBg6S7ofimhPYrnzZtGu7u7uh0Otzd3dm/fz/79+//ZKE8R44cRjNFAeGWbWxsCAkJ+aLY0qVLR4cOHVi3bh29e/cON9PV18qZMyeHDh0yWnfkyBGyZs2KpaUlOXLkIDg42OjHlStXrhgNdFewYEEePXqElZUVmTNnNvpLmjRptMYb3aRQ/oXkQ14IIYQQ4usppVi4cKG2HDpo25do2LAhuXLlAuD48eNaN0khvgWh/cqXLl2q9R0vXbo0p0+f/mR/coDu3buzcOFCFi5cyNWrVxk2bBg+Pj5G+2TIkIHz589z5coVnj17ZtKUg2CYt3vHjh3cvHmT06dPs3fvXqO+3NGhd+/e7Nmzh19//ZWrV6+yePFifv/9d/r06QNAtmzZqFKlCm3btuX48eOcOnWKNm3aGA3EXaFCBYoXL07t2rXZsWMHt27d4siRIwwePNjklhIA165d4+LFizx69Ah/f3/Onj3L2bNntQEoY4IUyqNA+pQLIYQQ8cPDhw+ZNm0aN27cMHco371Tp05phYcSJUpE2mfWFJaWlvz666/a8vTp0786PiFiU9myZQkJCdEK4IkTJyZnzpwkS5bskwXhhg0bMnToUPr160ehQoW4ffs2HTt2NNqnbdu2ZMuWjcKFC5MsWTIOHz5sUkwhISF07tyZHDlyUKVKFbJly8asWbO+OI0RKViwIKtXr2blypXkzp2boUOHMnLkSG3kdQAvLy/SpUuHu7s7devWpV27dlr/dzCU1bZu3Urp0qVp1aoVWbNmpVGjRty6dUvrw26Kdu3aUb16debOncvVq1cpUKAABQoU0Eaqjwk6JVW+Jjt+/DjFihUDoGvXrsyYMcPMEcUec/aviQvie/pB8gAkDyT98Tv98Yler6dQoUKcPXuWvHnzcu7cOXOHFCvMdY136dKFmTNnAjBv3jxt9OgvpZQiS5Ys2sBON2/eNHmA4Pj+Po/v6QfJg/iefjBPHsTPnBZCCCGEiMTNmzc5e/YsAOfPnzeaB1dEr4CAAFasWAGAvb29Nl3S19DpdLRq1UpbDp2TWQgh4ioplEdB2Obrv/32G1WqVOH169dmjEgIIYQQ0e348eNGy6dOnTJTJN+/JUuW8Pz5cwDq1q1LwoQJo+W4zZs312q4Fi1apI3wLIQQcZEUyr/Cjh074lUTdiGEECI++LgfeUTz/B44cICWLVuydu3a2Arru6PX65k8ebK23KNHj2g7dpo0aahSpQoAd+7ckTnLhRBxmhTKv9L//vc/c4cghBBCiGh0584do+W5c+dy//59AHx8fOjVqxflypVj0aJF1KtXj5UrV5ojzG/e5s2buXLlCmCYn7lw4cLRevywTdgXLFgQrccWQojoJIXyr7Rp0yb++usvc4chhBBCiGjycde0V69e0aFDB5o0aULu3LmZOnWq0Vy/rVq14sWLF7Ed5jdNKcXo0aO15dBpj6JTjRo1tLmJ//77b3mNhBBxlhTKoyCyKdEaNGgQy5EIIYQQIqb4+flpj0P7JW/evFkbkOxj/v7+LFmyJFZi+17s2LFDa22YL18+PDw8ov0cNjY2NG3aFIDAwEBWr14d7ecQQojoIIXyaPLu3TtzhyBi2cyZM/nhhx9kXAEhhPiO+Pr6smXLFm150qRJ4fYpX74869ev559//tHWzZ07F5ll1jRKKUaOHKktDxkyJNKKj6/VvHlz7fGiRYti5BxCCPG1pFAeTS5dumTuEEQ0UEqh1+t5+PAhCxcu5IcffiB16tQkT56cEydO8O7dOzp27Ejjxo3p0qULJ0+epHv37uh0OiZOnMj79+/NnYRvnlJK+9PrDf8fP1cs3mb4L4QQMenq1atGy+3bt+eHH34AwNbWli1btrB7925q1apFrly5+PHHHwFDX/OwhXQRuUOHDnH06FEAcuXKRZ06dWLsXPnz5ydPnjwAHDt2TOvDLoQQcYmVuQP4XsTUL7zmopTiwTNInAAc7L6vtIWllOLKlSusW7eOQYMGfXLfhg0bfnL7L7/8gq2tLd26dYvOEL85z14qbKzB2dG06yYwSGFtBZduQ6txiv995vctdeD7vR6FEOaXK1cuo2UHBweOHz/OpUuXcHFxIUWKFEbbmzRpwpEjRwBYuXKlVgAUkRs3bpz2uF+/floXgZig0+lo3ry51md91apVDB06NMbOJ4QQX0JqyqPgUwXvrl27xmIkMevlG4WFuyLtTwrHSgrHSnp2/A/cmrviUBHuPfm2ayt9fX0pWbIkRYsWxcLCghw5cny2QG6q7t27R8txvjWr9ih0pfXoSutJVlORsKpi9J+fv07GLlXYVVBYllHkbv75AjnAuKXf9vUnhIjbnJ2dtdrv0Cm1dDodOXPmDFcgB6hXr55WqFy5cqU0Yf+MgwcPsnXrVgDSpUtHo0aNYvycYcf+kSnsxPdi0aJFJEqU6JP7DB8+nPz5839yn1u3bqHT6Th79my0xRabMmTIwLRp00ze35Q8MQcplEeTI0eOMGvWLHr37s1ff/1Fzpw5+fXXX80d1hcp0dn4huJdAHj8Yngc+B7S1VP4B35bNx1KKfbt24etrS1Jkybl8OHD0TKdXZYsWcJ9wRctWjRc88fv2cZDikYjwl8Pg+crqv2iZ9cJxcFzisAgwz7vAhQbDylS1NIzcG7Ur6NNR76ta+9LBb1XHL7w7b3XhPgebN68mT/++INly5Z9dt8UKVJQtmxZwDC/+fnz52M6vG+WXq+nd+/e2vKwYcOwtraO8fOmS5eOIkWKAHD+/HmuXbsW4+cUIqY1bNgwyvebLVq0oHbt2jET0Hfi3LlzNGnShBIlSuDo6EiOHDmYPn16jJ9Xmq9Ho86dOxstDx06VGvS/K1466+4eOvz+y3bBW2qx3g4Xy0oKIgOHTrg5eX12X1//vln6tevT6pUqfDz88PZ2RlHR0eyZs3K4sWLmTVrFi9evKB+/fp07dqVwMBAMmTIABhG59Xr9YBh7noPD4948aV/+5Gi1sDIC41bj8HWYx+2T+kCvX7/dCHTyiIE/fsXlEyzld/GNqfPb/68eP6Ek7fSA3DkH2j162Om9EhOogTfb1N22/If8qnSD4olg3UkTxz303vviWLNfnj2SpEiiY4Xb2DYQkNa+jaGrOl01CoJyRLF/bSI+CthwoRUrlz5s7VQoWrXrs2ePXsA2LJlC/ny5YvB6L5dq1ev5sSJEwDkzp2bFi1axNq5f/rpJ+3H+LVr19KvX79YO7cQMcHe3h57e3tzh/HdOXXqFMmSJWPKlCkULlyYY8eO0a5dOywtLenSpUuMnVdqymNY3rx5Wbx4sbnDMFmXaabVyu0+Gbdr75RS2NnZYWtr+9kCeYoUKXjx4gV//vknNWrUoHDhwpQpU4aCBQuSLVs2dDodnp6erFq1iitXrjBmzBhSpUqlFcgB9u7da3TM69evM2vWLKN1b94pxi9TbD8et/PucwIC0ZqqZ2gQtbREViBvUe4+j9br2DF4N8HeNuiPpODAXy3Jl9mCXdMdObkko9H+XruSkbia0n4I+V4opVi4xdAVIKydJ+CP9eaJyVRKKZLV0JOunqLn74rRS6DbdKUVyAEmroC2ExTJayreBXz5+8Df3z86QhYi2lSrVk17HHbkdvHBw4cPjQrCEydOxNLSMtbO/9NPP2mPpQm7iIs2bdpEokSJtHubs2fPotPp6Nu3r7ZP+/btady4MRBx8/Vx48aRIkUKEiRIQOvWrQkICNC2DR8+nMWLF7NhwwZ0Oh06nY79+/dr22/cuEHZsmVxcnLCw8NDG4wR4Pbt29SoUYPEiRPj6OhIrly5tG4oEcmQIQOjRo3C09MTJycnXF1d2bBhA0+fPqVWrVo4OTmRJ08eTp48afS8tWvXkitXLmxtbcmQIQOTJ0822v7kyRNq1KiBvb09GTNmjLA106tXr2jXrh3JkyfH2dmZcuXKce7cuUhj/VirVq2YPn06RYsWxc3NjWbNmtGyZUvWrVtn8jG+hBTKo+DjPuWFChX67HOuXr1KixYtmDdvXkyF9UWUUvx7N3zT2CcvPjyuVRJ2TNKROY1h+bdOT7Vtq/bC++C4W7g8ffo0gYGBEW4bMmQIZ86cQa/Xo9frefTokcm1IZFxd3fXBvoBwNaVzpMDqd77Gct2KvadVjhXUfSfo6jaV1Gsg56D5xS+rxT9Z+uxKquneEc9e099fZ4qpThz5gwXLlwgODj4q4/3sXT1I17fqTaoAxb479IxsaOO9jUhj5sJBzxflkUj0pPSxYLKlStHvt/dieFWWbqN+S5G0vUPVJy5qrCvqGg9PuJrYLjX1xVkY9L7YMM4FM9emf4cx0qKPM31PH8dtTRZWVnhkDA9Op0FS5Ys4d+7isYj9CzapqQvrzCbjBkzkjNnTgCOHj3KzZs3zRxR3OLv70/FihW5c+cOABUrVvz0530MyJQpk9aC4cSJE1osIv4o3FZP2p8+/5e+HvzYIw3p62HS/p/7K9zWtAqE0qVL8+bNG86cOQOAt7c3SZMmxdvbW9tn//79uLu7R/j81atXM2zYMEaPHs3JkydJlSqVUQVRnz59aNCgAVWqVOHhw4c8fPhQGz8DYNCgQfTp04fTp0+TMWNGmjZtqt1Hdu7cmcDAQA4cOMCFCxcYP348Tk5On0zP1KlTKVGiBGfOnKFatWr8/PPPeHp60qxZM06fPk3mzJnx9PTUvrtPnTpFgwYNaNSoERcuXGD48OEMGTLEaCrDFi1acOvWLfbu3cuaNWuYNWsWT5480bYrpahWrRqPHj1i69atnDp1ioIFC1K+fHmeP39u0usQkVevXpEkSZIvfr5JlDDZyZMnFWD4S9ZUteiz6cPyZ/50Op169eqVmjRpkho3bpxq0aKF+ueff5Sfn1+sxT9vk16V7Raiev4Woij14a9U5xB18rJePX6uN1qv1+u154aEhKjr128Ybd9zUv+Js8UOvV6vLC0tFaAWLFigrbewsFCk6aHIvUORfqiqWtVDrVu3Tr158+aLzhMSEqJu3LihQkJCtHVv3urVxkN6tXa/Xj15YciLa9euGV7z3NuM8ioqfz+PCoksDJPY29sbXXtv375Vp06dUvv27VOBgYFffNyQkBDlc+lmhDF3n258vYT1/r1e7TiuV4PnhaiMDcI8L91Ahc7K5PcQ6BRF7hifu/gLbfvcuXONXp+YENF18LUePtObfG0s3WHe91zY9I+df1vla/ZMbTmiV7UHftm1Hvr3OUePHlWlS5c2vNY5/vrw3NRdwx2r6cgQdedRzORTTLz+Im76ktd6zJgx2ufRgAEDYjC6mBNT1/iQIUO0vHF1dVV37tyJ1uObauTIkVocU6dOjXCf+P4+/57Tn6bu131Xfelfmrqm52XBggXVpEmTlFJK1a5dW40ePVrZ2Nio169fq4cPHypAXbp0SSmllJeXl0qYMKH23OLFi6sOHToYHa9o0aIqX7582nLz5s1VrVq1jPa5efOmAtT8+fOVUoZrYMeOHUbnypMnjxo+fLjJ6XB1dVXNmjXTlkNjHzJkiLbu6NGjClAPHz5USinVpEkTVbFiRaPj9O3bV+XMmVMppdSVK1cUoI4dO6Ztv3TpktH7ec+ePcrZ2VkFBAQYHSdTpkxqzpw5Simlhg0bZpQnEQn7Pjhy5IiytrZWO3fuNDn9X0Jqyr9E0gaQ/U8WHfegUr0RJj1FKUXChAnp06cP/fv3Z9GiReTOnRsnJyd0Oh2tW7eO9jAv31bYlNNrTY3bTlDsOwNTVxvvd/A8FG6rSFHLuJbp45YBb968Jn/qC9py+Z6GZrbHL8Zu7ZRSivnz59O7d2+Kl29LSI6tkKY3rVu3RpfgB3T5vNEXvglukyFxBXAdRkiOTdSpU+ezv+qZ6pGvIkEVRc0Bip+GGJrjeo7W4+bmxu7deyBxpS8+9pIdhhHwo+ry5cvodLpwTXsdHR0pVKgQZcuWxdbWlocPH35xbLceGw9DUa4gTOuqY1o3i0hnJ7Cy0lGpiI5BzYJIcr0IHLQ0/N0dAyrimvxy5cqhlOLJkyc8efIEpRRPnz5hw6AzcLpgmIM7Q6kQsM2g9ffR6XSkTp2aynV6sHzbkzhfe1p/WMTxLRui4+oy4zwdNF/x9wHF+oOKrUeV2VqrLFi2lwGL03LudmKq9VOsP/jRDufLfnidT+aCQ7Yflh/8Ee54Kcv/j/fv3/Py5Us2bdqEn58fer0eT09PrK2tKV6uJQd8kkKCopC07ocnZpoW7ljLdkH6+orbj0zPm1d+H2YPSFJNz5ELcfuaiStGjx5N5cqVcXd3p2HDhhw8aLgQNm3aRJMmTShdujS1atVizZo1Rs8rXLgwJUuWpFSpUpQqVYqFCxdq2wICAhgyZAilS5emWrVqbN++PVbT9DVatWqFlZXhM9LLy4uQkBAzRxQ3PHjwgEmTJgFgbW3N1q1bSZcunVliqVv3w+fHpk2bzBKDMJ+USSBNMhP+kkLKxMGkSWri/p/5SxmFCtYyZcqwf/9+lFIcPHiQWrVqkTt3bg4dOsS+fftIkSIF2bNnj/C5ly5donjx4kbrPl7+lLx582qPkydPDqDVQnfr1o1Ro0ZRokQJhg0bZtKAlmGPFzpzRdgpI0PXhZ7j0qVLlChRwugYJUqU4N9//yUkJIRLly5hZWVF4cKFte3Zs2c3au166tQp/Pz8cHFxwcnJSfu7efMm169fNykfwvLx8aFWrVoMHTqUihUrRvn5USEDvUWBVuhwm6Ctc8w2GBgGGAaGyZMnD40bNyZdunTUrFnT5GMvXLiQadOmkSBBAsBQ8AwJCdG+4KPq/lNFjp+//MbS0gLevHkDgK2tLcuXL6dly5aQvDlkW2i0b7EOin8WQ66MsTNw04QJE+g/YDCkag+Z5kJiDIXvMK/Lx3aeiNo57j5WrDtgeBz4HuqWBhXm/ipVnfB5u2QHLNmhgDJRO1kErt2HwhF/5hpZvXo1/fv3j1JTydSpU1OgQAFOnDgR5f58J65+GLRwZGsdQ5p//jWvWrXqJ2+sGzVqRM6cObl//z5FixalcuXKpE6dGoBkyZJp+yVNmpSaNWsS/KoaNfv5s/V/YQY3KXIdLlSBPIbzPAQe+sLOsdB0+D0WddqHp+fPn5zW0BxuPVQc+uh7LaET3F6tI6GTjpCQEDaNs6BGf8P1dvsR1B384dozvAaxF69er8ctc24o8Sbyna62g1cHPiz7Xzbefr0L3OgFxX3B0gGAx+8LY1MeCLECy2rQrAy8/q+kn7AM5N0T5VgzNFDsnwHu+T//mudv9SFPX7wxzECxZyqUKxS3rpe4pmnTpvTt2xcbGxt8fHzo3LkzGzduJCgoiAEDBpAjRw5u375Nx44dcXNzo2DBDz+orV+/nqRJk4Y75pw5c3j16hVbt27l+vXrdO/enRw5cuDq6hqbSfsiKVKkoHr16qxfv55Hjx7h7e1NuXLlzB2W2Q0dOlT7sbhTp05aM39zyJkzJxkzZuTmzZscOHCA169f4+zsbLZ4ROw6Oc+0uki9Xs/t2/dxdXXVpjuMLWXKlGHBggWcO3cOCwsLcubMibu7O97e3rx48SLSpuvRIexMCKH3S6H929u0aUPlypXZsmULO3fuZOzYsUyePPmTU0JHdLxPnUMpFe4+LWzFSujjT93L6fV6UqVKZdRXPlRUu6r++++//Pzzz7Rt25bBgwdH6blfQmrKv4TFh9rWBPaGX/b379/Pw4cPOXjwIJ06daJGjRpRrqELHe1bp7PEIm1XrFPUpXfvPlE6xoNnimcvDXOMf0629BDZZ03IYRecnZ1xdnbG1tbWUCAH8I14kINJK2OvZmnMmDFQ5C5kmhGl53n01ZOilp4tRz8d6/PXinI9FD1+M/z1m63I0gSytnJl0TbCDcL1SYH34cVuADwrvGHTaD/6NdHTpjr0bGAoVM37RUfQXh1j2334kPmhnSJlbT1TV7zF3z8gwkOfPXuWhg0bflHfxTNnzmBlZcWECRNMvk793sGGIx+u/RSJP7Gvnx9DhgxBp9N9skB+8eJFVqxYwZAhQ5g9ezYtW7bUCuSRsbS0ZEZPh/Ab8kRyHts0tJhdGQsLC0qUKIFOpyNHjhwMHjyYli1bUqdOHXQ6HU2aNOHRo0fRWrOu1yvuPg7f19nvnaLtBD0ZGxqvD9oDp3+/xbbNq9DpdFhZWTHz96mRHn/ogph93+n1itF/BpOlzjWs3N9jna4jFLkV+RPenIDHCyLcNHPmzA8LKgiOJAy/03+FdPLtB7uMgKVpBXLfLXDZE4KNO7WX6WZoURCZ248UTpX13HoUftui7VJb/jkZMmTAxsYGMNwkBQUF8ezZM3766Sfy5MmDlZUVmTJlokiRIly8eNGkY27dupV27drh5OREvnz5KF26NDt37ozJZESr0AGYAFasWGHGSOKGf/75RxtsNWHChAwZMsSs8eh0Om1QvuDgYHbt2mXWeIT4WGi/8mnTpuHu7o5Op8Pd3Z39+/d/sj85QI4cOTh27JjRuo+XbWxsvrgVT7p06ejQoQPr1q2jd+/e0T5eVs6cOTl06JDRuiNHjpA1a1YsLS3JkSMHwcHBRoPDXblyhZcvX2rLBQsW5NGjR1hZWZE5c2ajv4h+CI6Mj48PTZo0wdPTk9GjR3912kwhNeVfwvpDacTe1lCTHNmb5O7du+GaaRUsWBCdTsepU6eMd9ZZ8875Zyj0YVCGKSdgol5v0i91Pw3Wa7W7H7OwgGI5Yc9UHXa2Hwp/D58pWo4J4Oqd93Stfg8XizM0b94s8pOEvIHjruCQE/Js01Yv2gYhlzxp06YNpUuX/mysX+Lt27e0b9+e14EJwSZ5lJ+/7bjhf/V+iqI5Fbum6EjgYPxr2y9/6Jn4ifuo1uPDr9s+SUeVPpHcwN+fAvenAfDnQfhzGKRPn54LFy6E+3XehkfAh3Q9fg69/rCn1yw9HE3I32sWkyFDBvLkyYOlpSXDhg2LNE5/f3/s7OywsbHh/fv3AHTs2JE//jBuOtyvXz+GDBmCv7//J6+xxiP0rNwD8KGmvHQEM/4EBARQsGBBLl26FOmxihYtSunSpRk5ciR2dnaR7vcpmdLoeL8XrMuZWHCyTgZpenDkyDTA0NT/4w/ZFStWsGLFClKmTPlVTfxDhYQofuyk+N9/WfFra6hcxFCDH9E0cs7Bh7CxCf85sn1lfyjZI9Lz6ErrCd6nw9Iyemt1Hz9XpKytMPx2+9+IfVnmfPpJZz8MGDNs2DAGDBhgNCVkp06duHnzJnfu3MHHx4d+kzrilzZ8c3YAcv4NgXcj3DS7t44KheHAOUiT+AWVf/yvVdLTZZB5NqRqq+1brZ/i3lpIk+xD/vx7V5EoAZ+cPWDJDri/vwaezerh4eFBsmTJvrvR/qPDuHHj2LRpE4GBgbi7u+PmZjy6Y0hICD4+Pnh4eBitb9asGTqdjqJFi9KjRw8SJUrE69ev8fX1JXPmzNp+WbNmxcfHJ8JzBwUFERQUZLTOyspK+6Hga4S+1lF9zT08PHBycsLPz481a9YwY8aMb2pa1C9Nd2T69u2rHWvAgAEkTpzY7O8jDw8Pfv/9d8DQhL1OnTpG26M7D7418T39YN48SJAgAfnz52fp0qVMmzYNvV5PyZIlOX36NO/fv6d06dLh4gv937VrV1q2bEnBggUpWbIky5cvx8fHBzc3N20fV1dXduzYwaVLl3BxcSFhwoRGxwn9CxW63LNnT6pUqULWrFl58eIFe/fuJXv27J/MI6XCz5IT9vgfn7dnz54ULVqUkSNH0qBBA44ePcrvv//O77//jl6vJ0uWLFSuXJm2bdsye/ZsrKys6NWrF/b29tq5ypUrR/HixalduzZjx44lW7ZsPHjwgG3btlGrVi0KFy6sVZREFruPjw/ly5enZMmSdO/enQcPHgCGSqGwLTijwpRynBTKo8ra+FcW+89816ZNm5bdu3dToUIFevbsyZQpU4y2L137P35u3Q+CX0DB0xEeY+aSs+TN8IYbN24QEhJChQoVePnelQKtTSuQqAMRXwi+vr7kypqFFy8MQ673MnWGkKB7hr+Dlob+vP9ZsgOWLHHn9evXWjP86LJs2TKaNfvvx4IMY8Jtt7FWBL3X0bAcDPpZR96WhrzpUR+m/RX+eMcvgnMVxfZJULlIaPMZ9ckCeUSuLNORJW3k24e1S8GIj8rOd+7coW/fvpQqVYpbt27h5eXFjRs3wDo5FIugMKizgB9fUKdRRgg0jBY7YsQINm7cGG7XJUuW0LRpU61pz5s3b7h48SJ58+bF0tKSmTNn0qZNG6M+nEFBQcyePZtOnTpFmIbu00ML5MayRtAlMGHChOFukkNduHCB3LlzR7jtS1hZ6ejTSDFppfH6qkWhV0MdgW8fUn1Iyg8b3CZDyDt4NPeTx3306BEXL16MtImlXq9n3759pE+fnuDgYB4+fIi7u3u4rgAz/0YrkAMMWaAYEnElMig9r09H0g5dvYfDztRt0p21S0bz7KUiWU3j936htoqzC6O3UN5h1DUg0yf3yZniJl3L76Zjnz/A/yoODnZcuHAhXMEsrIwZM5IxY0bc3d3p1AnuPg4iff0Ivooc8xj+/uNgB3P76CiRBzKkMqQ1UxqAJFy/fp1Mmf6L9VoHo0I5QNqfFB7FFPN/MXw2RDpK/PlykPfD9IZ7L2Zg73/zKLu4uODr6wsYChoTJkTeXSY+6d+/P3379uXkyZNcu3Yt3PY//viDZMmSGfVrnDdvHnny5OHNmzeMHz+ekSNHMmXKFN69e4elpaXRj3WOjo68e/cuwnN7eXmFq6mpX78+DRo0iKbUGX5Yj6ry5cuzYcMGXr58ydKlS6lQoUK0xRNbviTdHzt8+LDWUip16tTUqlWL27dvf/Vxv1bGjBmxt7fH39+fzZs3c/PmzQhvmKMjD75l8T39YL48KFiwIKdPnyZLlizaeyZz5sw8efIEBwcHbZ2vr+9/Te0Ny8WKFaNLly7069ePwMBAqlSpQuPGjTl48KC2T+XKldm+fTs//PADb9++Zfny5aRNa7iRffjwIYkTGzeDfPz4Mbdv3+bly5d07NiRhw8fkiBBAkqXLk3//v0jfU8HBwfz/PnzcNufPn2qrbt//77ReV1cXPjtt9+YNm0ao0aNIlmyZPTo0YOyZctqzxk5ciT9+/enTJkyJE2alN69e3Pz5k2jc82aNYvJkyfTsmVLnj9/TtKkSSlSpAgeHh5aWoKCgiKNff78+Tx9+pQNGzawYcMGbX2aNGm0sVOiKmPGjJ/dR6fi+ihIcciZM2coWH4A5P4wL9+AZjCm3Zf1Aug/W8/45SbseKUlPPkTLBw+3ZfzIwmd4NlGHVZW4W/W9Xr9Z/sTe3h4MHHiRHLlygUYpkPIlCkTvXr1+rBTsUeGWshQfufgTEEWLlzIgwcPGDlyJGnSpGHkyJEfCtVfwKj/SJgfAno1gEmddZH2L/nnhiJPi09f4vkyG272i3YIv9+zTTpcEuroOFnP7A3G2wJ267C1MZz30i1FTk9F4ezg1V9HQkdIl8KwrXnz5vz555+mJBMSV4Wk9SBli4i3H4z4NQsICIhSbcz169eNaqPAcE2EzceAQEXlPooDEUztOKuXjo61P+yrlOLQoUMRtpIYNGgQv/76a4z1507soeeln+FxlrRw8c8P17zvK0XSGh+9rm9OGZpP3xkNL7Yxfvx4o7lzwfDBe+vWLcDw66afnx/du3c3mpbjA8O53r71w8HBgfOXn5CvnelNpHh3EU7l+fx+wPHjxylSpAg+NxW5mxuna0Z3HV1/ir48dvU4yx2/vJFun9tXR9sa0XO+oPeKPkMX8Pb1E1Ze/YV3geE/Uz/XGiAgIIAxY8bw66+/glNBKBCFgSQe/AHXuwIKsi2D5I3+O+hNuDUYnv4FfPjcqVix4jfVpDq29OjRg4YNG2oF8DVr1rB8+XIWLlwYaV++Z8+eUa1aNQ4dOoS/vz/lypXj0KFDWsF86dKl+Pj4MHbs2HDPjema8tCWblHtU7plyxZtTJnixYtz8ODBODeeRWS+Jt1hvXjxgqJFi2oDKy1evPir7gGiW506dbQfto8ePUqRIkW0bdGVB9+q+J5+kDyI7+mH6M8Dk44Ro2O7f2dOnz6tSFLTaJqDkYu+bOqdf258ehqkZgMvG6/78bXJUy94jgpRGw99Oq5cuXJ9cvqpDBkyaPvq9Xrl7++vbty4oe7cuaNsbGyMpoYLF4NDngiPGdkUKL6+vqpfv36qW7duav/+/RHne+hxnEsYnSsg8PP5v/24Xg2cG6LGLNGrDpNMn8Lild+HYz9/FaIqdHujKBWiqv0SooKDo/a6v379+sN0aab+fZRWQ97mCLdfo0aNohRLKF9f3w/HsUygDh8+om27di/i63Puqkvq1Zv36vXr1+rp06dq4MCBkcYfdsqKmPTyjV7NWKNXp69E/Jos2/np91rz0SHq4bMQ1apVqyi8PpaKYk+Nj5VxkkqWwlVR8r1p11heb7Vsg4/RcZs0aWI0jcebN2+Mtv/6669KKaWGDx+uHBJlMjpejmbRN32Nr6+vouBZ7dhz5sxXFLmtLe8/Exxt5/rYhoPhX685G0x/v4WEhKht27YZ8izfEdNei7CvrVXiiPdJ0VLbZ/r06TGW/m9Z165d1erVq5VSSu3YsUN5eHio+/fvf/I5vr6+qkiRItp0jZUqVVIXLlzQtg8ZMkTNnTs35oKOxNdMCxUUFKSyZcumXS+HDx+OgQij3+PHj9WqVavUsGHD1OnTpyOd5vJzLly4oIoUKaKlv0iRInFueq25c+dq8Q0dOtRo2/c8JZgp4nv6lZI8iO/pV8o8eSA15VFw5swZClYaAzlWaeuGNIcRrSKvqT1+UeF9FlpXA5eEOu4/VTQYpjjyT8TnqFoUlg7RcezcM6oNcjEtsCstGDpkEE8e/ovfnb/o1asHBQoUCLdbcHAwly9fJmnSpKRKlcpo27lz58iX70Mn4Zo1axo12QhtHuPq6srFixe5f/8+FStWxNLSCkpFMK3VsVTw/onRqlKlSnHggHGnd6WU6b9AZZwAaXtri+mSw501Ufv1SinF3tNw4Tr0/D3yS//pRh1JE314TcOm/2t+MZsxYwbTpk1Dp9Px/PlzevXqRbJkyQgODiZ37tyUKVMGMPSf37p1K0WKFCFLy7S8D/4Qi9WV2gQ/MUzlMm7cuHC1vFFRtmxZ9l/KAFnmgs6Seyufcf7qCzyGZgm/8+Vm8NS09v27d++mfPnyXxxXdPuxo56jEXdL1ei9daa/tmFrUz/n9VG4PRzsM4NDLnhzEl5shfdPjXYrXLgwJ06Er91t27Yt8+fP15ZDm10CkLiyUcudMe10XLun6N1IR84M4T+Tbt68ye3bt7GxscHV1ZU0adIYbff19cXNzY3XAU5Q1NBsTxd4k5BjbgSHwOYjikQ293EvkiZGfz1XSrHrBDx5CTVLgLNj1GsZx44dy8CBA8GlLuSMoA9LqOPp2bR2NtWrV+fy5cvs27efPuta8i7QOtyuExtsIJGdL56entFSG/ste/fuHd7e3ri7u2NjY4O3tzdDhw5l8eLFPHv2jCFDhjBr1iyyZDH+LLl+/TohISFkypSJt2/fMn78eN68ecOMGYaBO6dPn87NmzcZPXo0N27coGvXrixatIgMGTLEavq+9jN/8eLFtPiv60OvXr2YPHlyNEf4dfR6PRMmTMDLy4sXL15gZ2cXrqlu5syZyZUrF2XKlKFZs2aRDpL08OFDjh07xuXLl9mxYwfe3t7atqRJk3Ly5Mk4N3r+/fv3tSa7BQsWNBrjJ7q+779V8T39IHkQ39MP5skDKZRHwZkzZyhYeRJkX2K0vlRe8P4tfMF81R5FoxGG7O1QC35y11GxV+TZfWSWjuK5P/RvtixjwktzJDGEvA63evbs2WTPnp0nT56wdetW/ve//0U6+u379++xsrLi6tWrtGzZkoQJE7Ju3Tqjfn2RXZxXr16lVatWpMnZhNWXOxgdN4/zXzy+6c2Tix8GcipWrBgAr169on///jRvHkk/2o+l7QsZxxmtur5Sh1vqL28SGFET4GSJwOdPHckSGR/XnB9Qxy8qin3UtP7X1jpyu0HeTJicB3ceK+oMUoToYf4vOpzs4eatu3j0egWOuT795MtN4enKT+/zn61bt1K1alWT9o0tdx8r0tf/9Pupxo+wbNBb6tSpg7e3N8HBEfzYZJ2C1Lnb8MBppGknvt4NHhhGHW/evDmLFy+OdNdVq1ZF2Bf21atXn5zGw6rYDYKtjW947fU3WD/0BpUqVdLWeXp6smTJf59dOitI6A5WSciUvz6F8qRh9aHkYBe+L7jj+//hd9Twvv2WvqiVUrRt25arV69y8OBBMmfNw7UHduB3EkMFmcHUqVPp0aOH0XMj6q4S1vUV4JYmbqc/pvn7+9OzZ08uX76MUop06dLRunVrypYtS/v27Tl79qzRDxdVq1Zl4MCBnDhxgrFjx/LkyRMcHR0pUqQIPXv2JEkSw0S+AQEBjBo1Cm9vb5ydnenatStVqlSJ9fR97bX+4sULkidPTnBwMK6urty8eTNONWEfPXp0lKb4sba2xt3dncePH/P8+XPc3d2xtrbm8OHDEY4lAIbR+VeuXEnRokWjK+xoVbBgQc6cOQMYCumhM398S59zMSG+px8kD+J7+kEK5XHe2bNnKVBlOmQNP1rTkOYwsrXhRdPrFdfvQ9amn8/aOX10tKsZ8Rf1pBWKvn8YH8PaClb2u8G4KYs5sXsS6COeLstUM2fOjHSAr7A+d3GGhCisyn4ivZcaw7PVXx5okbtg+2GqrC514bceX/8mCQhU/HMTlDIMGpXEOeLXwtwfUJ8af+DSEh3ZXT99s/f8tcKl+he81f3OwJnCn93N3t6eyZMn8/PPP+Pk5PTZ/c0hJERx+ioUyAJvA+DuEyIcb6BLXUP/7CdPnnDt2jVKlixp2GCZkCSVfXn+xsQb62Op4f1j1qxZw08//aStjmg8h4/3+VjGjBm1Pu7hZJkPKVuGX//fWBTZs2fn8uXLYJ8V8h8Fq0Smxf+f6Z3f0q1hAi32b/2L+uHDh8yePZurV6/Stm3bCOeRVkpx+AL8vk5x/QGc/Giq9YJZ4dT8bzP9wjTRca1XrlxZG3vg5MmTFCpUKDpD/GJ+fn64urry/PlzAFKmTElwcDCZM2emdOnSWFtbc+jQIQ4fPhzxj5OfkTVrVjp27Ei7du1wcIhg+so4YujQoYYxKDAMPtimTRvg+/ic+xrxPf0geRDf0w9SKI/zzp49S4Gqf0CWiKfwUQcsWLBZ0WaCaVlavhDsmhJ503elFBbuhmPZ2oDfduNB2wICApg3bx63bt1i6dKlPHnyJMLjRGbMmDH07t3bpGaYplyctx+pSKcY0oW8Qh1J8slzBAQE8M8//9ClSxdtXsUECRLw5s0bo8HdFg3Q4VmFWK11iAsfUJHNj54yCdz+S8fNh7ByD3gUgx9yfMibCAc7M9VBa8Bw3pQpU/LXX3/h7e3NrVu3ePXqFe3atfsmRxYOFRCosK8YPm+OzdZRNKfusy1WZvbU0amOjqt3FXM2GApw+TJDy6o6bYTwiAQGBjJx4kRev35N+/btP4wcHomgoCCKFi3K2bNnAViwYAGtW7f+sEPmWZCqfcRPDnkLlo6fPP6nvN/74XMnLrwPYlvYz2Gj9ZHMaiG+D9Fxrc+dO5f27Q3vywEDBjBmTPiZQ8xh+vTpWuuQJk2asGzZMm1b2HQHBQVx7do1Fi9ezOLFi3n69ClWVlYopbR5jm1sbChSpAglS5YkX758ZMiQgaJFi8apVgGROX78uNZ6r3bt2vz9999A/PycCyu+px8kD+J7+kEK5XHe2bNnKVBtIWSaFuF2dcAi0oLTxy4v1ZEtffR/ac2fP5+2bY2nA0qWLBl+fn4MGDCApEmT4uzsTO3atXF0NP1G3dSL0++dYtE26Do9/GXV9SeY0d2Ctm3bsm3bNu7ff4Rtwsy4plB4e3uTMqVh+qo37xSjFite+BmaaS/dCX1mGY6XPgXc/iv2PyDiwgeUf6AikYci6P3n9101XEfD4Qq31JDDFbYcNd6eysUwX/anNM7QhRVL/sDR0ZHp06fTsmVLs+dBTIioG0PBrIa5sCObUzxU0F4d1hHMbhAbZsyYQffu3T+scC4FyZuGmw7sc6wtAnC2CyCbyznOPcrH2/eJAHCy9Wfwz0H08/wwPUpceB+Yw7KdihZjFcH//Ta4ZDA0qxR/0h8fRce1/uTJE1KlSoVerydr1qxcvnzZ7IXVJ0+ekDt3bp4+NYxp8fFUlZGlOzg4mDt37pA6dWr8/Pw4ePAgadOmJU+ePEZd3b4ler2elClT8vTpUxIkSICvry/W1tbx9nMuVHxPP0gexPf0gxTK47yzZ89SoNZacB0R4fYnG3Ukr/n57IzJGhZ/f386d+6Ml5cXW7ZswcPDI1qO+6UXZ6Veenad/LA87xcda70V24+H2ecHePQczl+P+Bi1S8H6/6YFbFcD5vSNn4Xyj5n6A9DH9N6G1hnHfBTFO364Xvs2hvKFdFhZGsZJsLGOO/3qY9rAuXrGLjV9/18awy9NDNPlmZuHhwfbtm37sCLfQXD+8ZPPaVoRlgyOvJVOZL7na8AU8T398Ul0vdZlypTRBj77uAAc2/R6PdWqVdPmDq9Xrx5//fVXuH3i0zXetGlTli839A07cOAApUqVind58LH4nn6QPIjv6Qfz5IFVrJzlO6HT6UBF3r9q8LzwBfKkCeHZqw/L99bG7E28vb09CxcuZOHChTF6HlNN66Yjl+eHfGkbQdP+nZ+ZTji0QA6G+bHFlwvZ/6EgViyXDr03TF0Nd58oBjTTkThB/MzfMe0sGNPOtB865nR/Qps6ybGwiBt5NXXqVFKmTMnz58+xsrJizKT81BgEV40HUuaclyHePG6x2/VDiPisbt26WqF87dq1Zi2UT5o0SSuQp0iRgpkzZ5otlriiUqVKWqF8586dlCpVyswRCSHiq/j588fXCH4V6aa5m8Kvm95Nx4stOqZ303F6vo40yeLXzXDODDo614meY9nagKVl/Mq/T7n9V9Tyom5pwhUkdTodvRrqmNrVIt4WyMOa2DHyPAjZr+PVVqhY0D8WI/q8bNmysXDhQtavX8+aNWvImsGJK8sseLNdx63VOl5t06EOWJA3k468maJeOy6E+HJ169bVHq9bt85scfj4+DBo0CDA8Lm/dOlSkidPbrZ44oqwM1SEDsonhBDmIIXyqLKwNXnXbj9B4wqQKIGObvV0FMgaP2+Gx7XXMbadIe1JnCPfr0Qe2DlZR4tIZtMqF37q9XgtfQpDYUsdsCB4n+Gx/y4dXgN0LOyvI3CPjkUDdCRNaOhDvqBf/Lz+oqJPYx3B+wx5Vyjbh/W7puiwsNDhFHcHEg7HyUGHa0rdF83xLYSIHmnTptWmBDt//nyk04fFJKUUXbt21UZS79ev3zc9QGd0SpUqFXny5AHgxIkT+Pp+ZrAVIYSIIVIojwKdTgc60wrlq4brmN7dQmqlMBQO+jczFBp9N1toBUl1wIKXW3X8NVLH7b90HJppQcUfdHgNsCBkv45mH37AJokz/NpG8jIyoS0I7Gx1tKiqo6WHDhtrHc2r6ni6yYIHf1uQSGrCTWJpaci7k/MsODxTx5kFOioUlrwTQnyZsNMdrl27NtbPv2bNGvbt2wcYplccNmxYrMcQl4XWliul2LNnj5mjEULEV1IojyoTasod7aFBObmJN0VCJx31yuhIn8I4vywsdCwZ/KHw7rvZgkLZJE9F7Poxj478WeS6E0J8OXMWyt+9e0fv3r215WnTpn2zo6XHlMqVK2uPpQm7EMJcpFAeVRaf/zI7Pltu4oUQQggBbm5u5M+fHzA0kY7NJuwLFy7k7l3DqI9VqlShRo0asXbub0XJkiW1Hyp27tyJTEokhDAHKZRH1WdqypMnhlwZpVAuhBBCCIPGjRtrj//4449YOader+e3337TlsePHy9d6iJgb29P6dKlAbh79y6XL182c0RCiPhICuVRYOhT/ulZ5I7+IV94QgghhPigVatW2NoaftRfuHAhfn5+MX7Offv2cfXqVQDKli1L3rx5Y/yc36qwTdh37dplxkiEEPGVFMqjzFJ7VKUoeA0wLoSnlxlGhBBCCBFG0qRJtdryly9f8vvvv8f4ORcsWKA97tixY4yf71smU6MJEZ5Sihs3bvDgwQOjdQEBAWaM6vslhfKoClNTPr6DYaRrj2KG5dL5wMpKasqFEEIIYaxfv35YWBhuuyZOnMjr169j7FzPnz/X5kV3cXGhZs2aMXau70GuXLlInTo1AN7e3gQGBpo5IiHMJzg4mEmTJpE2bVoyZcpEmjRpqFSpEs2bN8fNzQ17e3uSJElCixYtuHLlirnD/W5IoTyqdB9qyi3/y70/B+lYPFDHquFSIBdCCCFEeNmzZ6dJkyaAodA8adKkGDvXsmXLtIKlp6en1nReREyn02m15e/evePUqVNmjkgI81BK0a1bN2bNmsWjR4+09bt27eLPP//k1q1bALx48YLFixdTsGBBduzYYaZovy9SKI8CQ5/y8IVyl4Q6PKvoSOkihXIhhBBCRGzo0KFYWRla3I0fPz5GapmUUsyfP19bbt26dbSf43sUtgn7gQMHzBiJEOYzefJk5syZoy0XKlQIGxsbbdna2pr8+fPj5OQEGH7Eql27tvyQFQ2kUB5l4QvlQgghhBCfkyVLFm3e8KCgIBo1asS7d++i9RynTp3i/PnzABQtWpRcuXJF6/G/VxUqVNBGp9+7d6+ZoxEi9nl5edG3b19tefHixZw8eRJfX1/Onj3LmTNnePbsGWfOnOHevXvUqVMHgICAABo1asSbN2/MFfp3QYqVURWmT7mV5Sf2E0IIIYT4yJAhQ8iSJQsAZ8+epUOHDtE6N3bYAd7atGkTbcf93iVLlowSJUoAcO3aNekrK+KV2bNn06pVK225Z8+eNGvWDAAnJyfy5ctH/vz5cXZ2BiBhwoSsXLmSIkWKAIb3TOfOnWM/8O+IFMqjKmzzdSmUCyGEECIKHB0dWbduHY6OjgAsWbJEm088MDDwqwrob9++Zfny5dp5GjZs+PUBxyO1a9fWHm/cuNF8gQgRi+bPn280Q0O3bt3o0qXLZ59nY2PDihUrSJAgAWD4LFu9enWMxfm9k0J5FETWp1wIIYQQwlS5c+dm4cKF2nL37t1JkiQJdnZ2FCpUiOfPn3/RcZcuXaqN6t6wYUPtZlmYplatWtrjDRs2mDESIWLHuXPnaN++vbbcr18/pkyZonXl+Bw3NzejPui9evXCz88v2uOMD6RYGWUfCuXSfF0IIYQQX6JBgwYMHDhQW37x4gUAZ86coWvXrlE+XlBQENOmTdOWTanpEsYyZ85M7ty5ATh27BgPHz40c0RCxKwxY8ag1+sBw4+DY8eONblAHqpx48ZUq1YNgPv37zN69OhojzM+kEJ5VIXpUy415UIIIYT4Ur/++isdOnTA8qP+cMuXL49y8+mRI0dy+fJlAEqUKEGBAgWiLc74JLS2XCnFpk2bzByNEDHn/v37rFmzBoDkyZN/UYE81LRp07RR2idPnszVq1ejLc74QoqVURCu+brUlAshhBDiC1lYWPDHH3/w/v17lFIsWrRI29akSROOHj1q0nH++ecfxo0bB4CVlRXTp0+PiXDjhbBN2NevX2++QISIYcuXL9dqyTt06IC9vf0XHytz5szayO3v37+nW7du0TqAZXxg1kL5ixcv6N69OyVKlKBu3br873//i3C/+/fv07lzZ8qUKUPVqlXx8vKK5UjDkD7lQgghhIhGobVTnp6e2jRDb9++pWrVqnh7e3/yuUopOnfuTEhICACDBg2iUKFCMRvwd6xgwYKkSpUKgD179sg0T+K79ddff2mPQ0da/xoDBgwgXbp0AOzYsUMGS4wisxYrx48fT7JkydizZw/dunWjf//+2gAlYU2cOJE0adKwe/du5s+fz6pVqyItwMc43Ycskz7lQgghhIguOp2O5cuXU758eQBevXpFuXLlWLlyZaTPmTFjBgcOHAAgU6ZM9O/fP1Zi/V7pdDoqVqwIGPrpb9++3cwRCRH9bt26xYkTJwDInz+/Nk3j13B0dGTKlCnaco8ePfD39//q48YXVp/fJWa8e/cOb29vNm3ahJ2dHWXKlGHZsmUcOHCA6tWrG+378OFDmjVrhpWVFWnSpCF//vzcuHFDmxvvY0FBQQQFBRmts7Ky0vo6fCm9Xm/Up1yHQq+PH00zQpu3hP6Pb+J7+kHyACQPJP3Rn34LC2lyJYzZ2dmxYcMGateuze7du9Hr9TRr1gwHBwdq1qxptO+RI0fo1auXtvzbb79hZ2cX2yF/dypWrMiff/4JGJqw169f38wRCRG9QvuSA9F6ff/000+UL1+ePXv2cOvWLRYsWCCDTprIbIXyO3fu4OTkRNKkSbV1WbJk4caNG+H2rV+/Pjt27CBv3rw8evSICxcu0KZNm0iP7eXlxbx588Ido0GDBl8Vs2EUTltt+d692/Gutvzu3bvmDsGs4nv6QfIAJA8k/dGX/owZM0bbscT3w9HRke3bt9OpUyfmzp1LSEgItWrVok2bNowYMYLUqVPz6tUrPD09tR+J+vfvT9WqVc0c+fehSJEiJEqUiJcvX7JlyxaCgoK+umJHiLgkbNP1evXqRdtxdTodkyZN0gaanDJlCh06dMDKymxFzm+G2XLI398fR0dHo3WOjo4Rzm2XL18+1qxZQ6lSpQgJCaFdu3Zkzpw50mO3bNmSpk2bGq2Ljpryd+/ege6ltuyW0ZUvHKTwm6PX67l79y7p0qWLlzU78T39IHkAkgeS/vidfhG7LC0t+eOPP/Dz82P58uUAzJ8/n9WrV/PLL7+wZ88erl+/DkDx4sUZNWqUOcP9rlhbW+Ph4cHy5ct59eoV3t7eWpN2Ib51t2/f1roB582bl6xZs0br8fPnz0/lypXZsWMHN2/eZO3atTRs2DBaz/E9Mluh3N7enrdv3xqte/v2bbiR/0JCQujevTuenp7Uq1ePJ0+e0KNHD9zc3KhQoUKEx7axsYmRXzQtLCw+DPSmQrC0tI72c8R1FhYW8fpmNL6nHyQPQPJA0h+/0y9ij4WFBV5eXri6ujJr1ixevXrF69evGTx4sLZPkiRJWLp0abhp1cTXqVWrlvZjyPr166VQLr4ba9eu1R7HVNeMvn37smPHDgAmTJhAgwYNvni6tfjCbHcV6dOnx8/Pj2fPnmnr/v33X9zc3Iz2e/36NU+fPqVevXpYWVmROnVqypQpw6lTp2I7ZIPQPuUqxDznF0IIIeKA0aNHU7lyZdzd3WnYsCEHDx7Uti1atIgKFSpQrlw5pk+fbjQ1jo+PD40bN6ZEiRK0a9fuv65hBgEBAQwZMoTSpUtTrVo1GWQLQ0XDmDFjuH79Oi1btjTaljhxYv7+++9w907i61WuXBlbW0OXxQ0bNsTbsTTE9yds0/WYKpSXK1eOggULAnD69OnPziIhzFgod3BwoHTp0syZM4eAgAC8vb25fv06pUuXNtovceLEpEiRgvXr16PX63n8+DHe3t5kypQp1mM23FR8qCkXQggh4qumTZuyadMmvL29GTp0KEOGDOH169ccOnSINWvWsGjRIlavXs2hQ4e0qXGCgoL45ZdfaNSoEXv37iV37twMHTpUO+acOXN49eoVW7duZcyYMYwbN47bt2+bK4lxiouLCwsXLuTgwYP07duXoUOHcvHixXD3TSJ6JEiQQGuRef/+ffNVBgkRje7evcuxY8cAyJMnD9myZYuR8+h0Ovr06aMthx2VXUTMrL3u+/fvz7BhwyhfvjwpUqRg7NixODs7s23bNry8vFi9ejVgmDpt8uTJ2qiilSpV0ubxjE2G0ddDm4dJoVwIIUT8lSFDBu2xTqcjKCiIZ8+esXXrVurVq0fatGkBw/y327Zto1atWpw6dQp7e3tq1aoFQNu2balQoQIPHz4kVapUbN26lcmTJ+Pk5ES+fPkoXbo0O3fupG3btuHOH1MzrUDcnmngxx9/5Mcff9SWozPGuJzu2BI2D2rWrMmWLVsA+Pvvv+PF/O9yDXzfefDxAG8RpTG60l+3bl3Spk3LvXv32LRpE5cvX472/usxJbqvAVO6vJm1UJ44cWJmzJgRbn3VqlWNRhDNlSsXCxcujM3QImRUKFfB5g1GCCGEMLNx48axadMmAgMDcXd3x83NjZs3b+Lh4aHtkzVrVmbOnAnAjRs3jAZqtbe3J23atNy4cQNHR0d8fX2NtmfNmhUfH58Izx1TM62EFV9nGoiv6Q7r7t275M+fH51Oh1KKNWvWRPjj0PdKroHvMw+WLVumPS5evPgnWyJFR/qbNWvGuHHjAPj111+/uQEpo+saMGWmFRmfPgqUUtKnXAghhPhP//796du3LydPnuTatWuAYaYSJycnbR9HR0fD7CVEPvOKv78/7969w9LS0mie7bDP/VhMzbQC8Xek/fia7rDC5oGrqys//vgjhw8f5t9//yUwMPCbqen7UnINfL95cO/ePU6fPg0YKjzLly8f4X7Rmf6+ffvy+++/4+fnx99//83UqVONpsOOq8xxDUihPAoMTRikT7kQQggRytLSkqJFi7JixQrc3NxwcHAwmt707du3ODg4AJ+eecXBwYGQkBACAgK0gnnY534spmZaCSu+jrQfX9MdVmge1K5dm8OHDwOwceNGfvnlFzNHFjvkGvj+8uDvv//WHtevX/+zaYuO9CdJkoTWrVszffp0/P39mTt3rtHsEXFdbF4D38+VFgsMzddDs+z762cihBBCfCm9Xs+9e/fImDGjVmsOcPXqVW10cDc3N6Nt/v7+3Lt3Dzc3N5ydnXFxcYn0uUKYQ+j4BwDbtm0zYyRCfJ3YGHU9It26ddMKttOnTw/3w6wwkEJ5FBhqyv+bY09JoVwIIUT89O7dO7Zt28a7d+8IDg5mz549nDp1igIFCuDh4cHatWu5f/8+z549Y9myZdo4MYUKFcLf359NmzYRFBTEggULyJkzJ6lSpQLAw8OD+fPn8/btWy5cuMCBAwdkfmhhVlmyZNF+GDpy5IgUKMQ36f79+1qLj5w5c5IzZ85YO7ebm5s21sezZ8+YNWtWrJ37WyKF8igw9CkPzTL1yX2FEEKI75VOp2PDhg14eHhQvnx5vLy8GDVqFJkzZ6ZkyZLUrVsXT09P6tevT4kSJahZsyZgaHI+YcIEli1bRtmyZTl37hwjR47Ujtu+fXucnJyoUqUK/fv3p3///kajvAthDqFTowUFBXHw4EEzRyNE1K1du1Z7HJu15KGGDBmCTmeo2Jw4caJRFydhIH3Ko8CoplwK5UIIIeIpe3t7Zs+eHen2li1b0rJlywi35cqVi5UrV0a4zc7O7psbnVd8/ypWrMjcuXMB2L17N1WqVDFzREJEzfLly7XH5iiU58yZk4YNG7Jy5UqePn3K77//Tv/+/WM9jrhMasqjICQkBGzT/rckWSeEEEII8b0rW7asVsu3e/duM0cjRNRcu3aN48ePA5AvXz5y5cplljiGDRum9S2fOHEir1+/NksccZWULKPg3jPrDwu2qc0XiBBCCCGEiBUuLi4ULFgQgHPnzvH48WMzRySE6VasWKE9btKkidniyJ49O82aNQPg+fPnzJkzx2yxxEVSKI+CDf9Lae4QhBBCCCFELAs74ODevXvNGIkQplNKsWzZMm25cePGZowGBg0apD1evHixYbwuAUihPGrkwhFCCCGEiHdCB3sD2LVrlxkjEcJ0Z86c4cqVKwCULl2adOnSmTWerFmz8uOPPwLg4+MjAyeGIYXyKJFCuRBCCCFEfFOiRAns7OwAQ79yqeET34KwteRNmzY1YyQftG/fXns8bNgweS/9RwrlQgghhBBCfIKdnR2lSpUC4O7du1y9etXMEQnxaUFBQdqo69bW1tSrV8/MERk0adKEzJkzA7B//36jPu/xmRTKhRBCCCGE+Iyw/cplFHYR161du5ZHjx4BUKNGDZIkSWLmiAysrKwYP368ttylSxcePHhgxojiBimUR4k0rxBCCCGEiI+kX7n4lvz222/a465du5oxkvDq1q1Lo0aNAHjx4gVt27aN983YpVAuhBBCCCHEZ+TLl4+kSZMCsG/fPt6/f2/miISI2KlTpzh69CgAuXPnxt3d3cwRhff777+TMqVhZqutW7ca9X+Pj6RQLoQQQgghxGdYWFhoTdhfv37NkSNHzByREBH7/ffftcddu3ZFp9OZMZqIubi4MHfuXG156NChBAUFmTEi85JCeZTE72YVQgghhBDxmYeHh/Z469atZoxEiIj5+vpqg6clSpQozoy6HpEaNWpQqVIlAG7evImXl5eZIzIfKZRHRTzv6yCEEEIIEZ9VqVJFq3XcsmWLmaMRIjwvLy8CAwMBaNmyJY6OjmaO6NNGjRqlPf7111/x9/c3YzTmI4XyKLC3tzN3CEIIIYQQwkySJk1K0aJFAfDx8eH27dtmjkiID/R6PbNnz9aWO3ToYMZoTPPDDz9Qq1YtAO7fv8/MmTPNHJF5SKE8ClKnTmXuEIQQQgghhBlVq1ZNe7xt2zYzRhJ3PH78mDVr1tCrVy9q1qxJyZIlqVKlCkOHDuX169fmDi/e2LVrF9evXwcMU/hlzZrVzBGZZtSoUVoLlDFjxvDy5UvzBmQGVqbsFNVfWXQ6HX/88ccXBSSEEEIIIURc5eHhwZAhQwDYsGHDN1EbGROUUhw+fJj58+ezZMkS9Hp9uH127NjBkiVL2L17N5kyZTJDlPHLrFmztMedOnUyYyRRkzt3bjw9PVm8eDEvXrxg4sSJjB492txhxSqTCuWnTp1Cp9OZPH9cXBzhTwghhBBCiK9VoEAB0qdPz507d9i9ezfPnj3TpkqLD5RSrFixgmHDhnHt2rXP7n/r1i2qV6/O0aNHSZQoUcwHGE/dvn2bzZs3A5A2bVqqV69u5oiiZvjw4axYsYKgoCCmTZtGhw4dSJcunbnDijUmFcoBkiVLprX3/5QNGzbw9OnTrwpKCCGEEEKIuEin09GoUSMmTJhAcHAwa9asiVe15UOGDAlXi+ns7Ezbtm0pW7Ys+fLlI3ny5Pz777/Ur1+fS5cucfnyZfr06cP8+fPNFPX3b+7cuVprhfbt22NlZXIxL07IkCEDHTt2ZPr06bx7947u3buzbt06c4cVa0x+tVKkSEG7du0+u9+RI0e+20K5NAAQQgghhBCNGzdmwoQJACxdujTeFMr//vtvowJ5mTJlaN26NXXq1Ak3yneuXLnYsmUL+fPn5/Xr1yxYsIBWrVrx448/xnbY372goCDtBw8rKyvatGlj5oi+TGht+ZMnT/j7779ZtWoVDRs2NHdYscKkgd6GDRtGq1atTDpgmzZtGDp06FcFFVdJoVwIIYQQQuTLl4+cOXMCcPjwYc6ePWvegGLBwYMH8fT01JbHjx/Pvn37aNasWaTTbmXMmNFoyquOHTsSHBwc47HGN5s2beLJkycA1K5dm5QpU5o5oi+TKFEipk2bpi23b9+eFy9emC+gWGRSobx69eqULFnSpAOWLFnym+vDIIQQQgghhKl0Oh2dO3fWlmfMmBFr53748CG7d+9m7969vHv3LsbPFxwczMiRIylbtix+fn4ANGrUiL59+5r0/I4dO1KgQAEAzp8/z/Tp02Ms1vhq7ty52mNTWjbHZY0aNaJRo0YAvHr1yqiQ/j37qinR+vbta1I/8++FVJQLIYQQQggAT09PbeCyZcuWaTWVMcXPz48uXbqQPn16KlasSPny5cmUKRPe3t4xds5///2XkiVLMmzYMEJCQgCoVKkSCxcuNHlgZysrK2bPnq3tP2jQIM6fPx9jMcc3N2/eZOfOnYChZUL58uXNHNHX0el0jB07VusTP23atHhRW/5VhfJnz57x8OHD6IpFCCGEEEKIb4KTk5PWdzcoKIjZs2fH2LnevHlDlSpVmDlzplHz70ePHlGpUiXWrl0bredTSjFnzhzy58/P8ePHAbCwsGDIkCFs3rwZe3v7KB2vSJEidO3aFYDAwEAaNmyo1bqLrxO2lrxt27ZYWHxV8S5OyJAhAy1btgTg9evX8aJ1xbf/qgkhhBBCCGEGXbp00QpBU6dO5fnz59F+jkuXLlGsWDEOHz4MgKOjI506dSJ//vyA4QeB+vXr07lzZ+7fv/9V5/r333+ZOnUqWbJkoUOHDlrz+MyZM3P48GFGjhyJtbX1Fx17/PjxWsyXL1/+bsegik3v3r3TCuXW1tZaQfZ7MHDgQKPa8pcvX5o3oBj2VYVyU+ct/17I/OtCCCGEECKUq6urNvjZy5cvo72gee7cOYoWLcrFixcBSJIkCQcPHmTmzJmcOHGC5s2bA4Z78lmzZpErVy5OnDgRpXO8f/+e1atXU6pUKbJnz85vv/3GzZs3te3t27fnzJkzFCtW7KvSYmdnx6pVq7CzswNg+vTp/PPPP191zPhuyZIl2g9BjRo1+mYHeItIhgwZtOv71atX331t+VcVyr/nkdaFEEIIIYT4nF9//VVrzj1z5ky2bdsWLcd9/vw5derU4c2bNwDkzp2bI0eOaIOmWVlZ4eXlxfjx43FwcAAMhZdKlSpx7Nixzx4/JCSExYsXkyVLFho2bMihQ4e0bRYWFlSqVInt27cze/ZsnJycoiVNWbNmZfDgwQDo9XpGjBgRLceNj/R6vdEgaD169DBbLDElbG15TLVEiSu+qlAe30Zal4pyIYQQQggRVtq0aRkzZoy23KBBA/bu3ftVx1RK0apVK63GunDhwhw7doxs2bIZ7afT6fjll1+4ffs27u7ugKHGvkKFCixfvjzSY2/atIn8+fPTokULbt++rW3LkSMHAwYM4Pbt2+zYsYPKlSt/VToi0rNnT1KkSAHAmjVruHDhQrSfIz7YsWMHly9fBqB06dIULFjQzBFFPzc3N6Pa8rFjx5o5ophjUqG8XLly2uAMn9O5c+dvftS/yMSz1vpCCCGEEMIE3bp1o27duoBhlPSKFSsyefLkL+7qOW/ePDZs2ACAi4sLa9eujXQucICkSZOyZcsW7R787du3NG3alObNmxsNynzo0CFKlSpFzZo1jZqOV6lShT179nDhwgXatm1L6tSpvyhuUzg4ONCvXz9teeTIkTF2ru9Z2ALq91hLHmrYsGFal4cZM2ZoP0R8b0wqlL9584a3b9+adMB3795pzWyEEEII8f0JCgpixIgReHh44O7uTrt27bh27RoAY8aMoVSpUtpf0aJF6dmzp/bcwoULU7JkSW37woULtW0BAQEMGTKE0qVLU61aNbZv3x7raRPiS1hYWLB06VI8PDwAQ9PiPn36ULVqVVauXMmrV69MPtaaNWvo0qWLtrxw4ULSp0//2ec5OjqyefNmrY87wJ9//knmzJnp3LkzlStXplSpUtqAcQDFihVj//79bNu2jXLlysXa+Ent27c3qi0P7TMvTOPt7c3BgwcByJ49OzVr1jRzRDEnXbp02ndIUFAQ7du3R6/Xmzmq6Gdl6o7//PMPRYoUiclY4rz4NrCdEEIIEZGQkBDSpEmDl5cXSZMmZcWKFfTu3ZsNGzYwcOBABg4cqO3btGlTrVltqPXr15M0adJwx50zZw6vXr1i69atXL9+ne7du5MjRw5cXV1jPE1CfC17e3s2btzIiBEj+PXXXwFDE+MdO3ZgbW1NmTJlqFWrFjVr1iRdunTa80JCQnj27BkHDhxg/vz52pzTYGiBGpUCl52dHYsXL9Zaub5584Z3794xa9Yso/1y5MjBmDFjqFWrllkGMnZwcKBPnz707dsXgHHjxvHnn3/GehzfIqUUw4cP15YHDRqEpaWl+QKKBYMHD2bVqlXcuHGDAwcOMGLECIYPH/5dDcJtcqE8KgXS7ymDwpIiuRBCCGEofITOzwzQsGFDpk+fzsuXL0mUKJG2/ubNm9y8eZMKFSqYdNytW7cyefJknJycyJcvH6VLl2bnzp20bds23L5BQUEEBQUZrbOyssLGxubLEhVGaC3M91gb8ynxNd1hfW0e6HQ6hg8fTsGCBenYsSOPHj0CDCOc79q1i127dtGlSxcKFChAkSJFuHbtGkePHtWmHgurTp06TJky5Yti+fnnn6lcuTJjxoxh9uzZvH//HjCMaD1o0CA8PT2xsrJCKWV0jx+b10C7du0YO3Ysz58/Z/ny5QwbNoyMGTPG+Hk/J66/D3bv3s3+/fsByJIlCw0aNIjWWONi+u3s7Jg9ezaVKlUCDF0e/P39GTt2bIyUO6M7D0yZO96kQvns2bO/OpjvgVSUCyGE+JaEFgii4kum1Dl//jxJkiQxKpADbNu2jZIlS4YbublZs2bodDqKFi1Kjx49SJQoEa9fv8bX15fMmTNr+2XNmhUfH58Iz+nl5cW8efOM1tWvX58GDRpEOf7I3L17N9qO9S2Jr+kO62vzIF++fBw4cIATJ06wc+dOdu3axYMHD7TtZ86c4cyZMxE+N1WqVPTv35/q1at/9bzjPXv25Oeff+b8+fMkSJCAggULYmlp+dnjxtY14OnpybRp0wgJCWHo0KGMGjUqVs5rirj4PlBK8csvv2jL0TE3fWTiWvozZ87MwIEDtUEVJ06cyNWrV+nfv7/WFSJUcHAwx44dY9u2bezfvx8bGxvKlSuHu7s7OXLkIFmyZCadM7rywJQfm3RK2mSbbOgCPb8u/rCsDnzV4PXfFL1ez+3bt3F1dTXp157vTXxPP0gegOSBpP/bS/8PP/wQpVoEnU7H8ePHo3QOPz8/mjdvjqenJ7Vq1TLaVqtWLXr06EHZsmW1dWfOnCFPnjy8efOG8ePHExQUxJQpU3j06BG1atUyOv/ff//N/v37I5yfNqZryu/evUu6dOm+mdc6OsTXdIcVU3mglOL8+fNs3LiRjRs3cvr0aW1b2rRpyZs3L25ubtSoUQN3d3esra2j7dxREdvXwPPnz8mYMSN+fn7Y2Nhw/fr1GB1kzhRx+X2wceNG6tSpA0CePHk4ffp0tMcYl9MPhm5OnTt31lp42NnZUbduXTJmzEjatGk5efIk69evx9fXN9Jj5M2blzp16lC0aFHc3Nzw9/fn7t273L17l3v37nHhwgUsLS1Zs2ZNtORBtNWUCwP5+UIIIcS3JiZ/ew8MDKR3796ULFkyXIH83LlzvH79mhIlShitD51jOXHixPTp04dq1arx/v17HBwcCAkJISAgQBtp9+3bt9r8yx+zsbGJlgL4p1hYWMTJm9KYFl/THVZM5EGBAgUoUKAAw4YN4969e9y+fZu0adOSPn36ONf1M7augaRJk9KpUycmTJhAUFAQ06ZNY9KkSTF+XlPEtfeBXq9n6NCh2vKvv/6qzeEdE+Ja+kN17NiRJEmS0Lp1a96+fUtAQECk0/8B2NraEhISQnBwsLbu/PnznD9//pPncXZ2RqfTxVoeSKFcCCGE+I5ly5aNiRMnfna/Pn368O+//5p83ODgYAYOHEiyZMkinI5n+/btlC9f/pMF59CbHaUUzs7OuLi4cO3aNXLnzg3A1atXcXNzMzkmIb4VadOmJW3atOYOI07o1asXM2bMICAggNmzZzNgwABcXFzMHVacs2rVKm1O9yJFinzXI65/TsOGDSlbtizjxo1j3rx5+Pn5GW13cHCgWrVq1K9fHw8PD96/f8/WrVs5deoUBw8e5MSJEyad58GDB0aDMsYkKZRHgdSUCyGE+NbY2NiQKlWqz+5nbW0dpVr10aNHExgYyPjx48PV8gUHB7Nr1y7GjRtntP769euEhISQKVMm3r59y+TJkylatKhWcPfw8GD+/PmMHj1aG2V30aJFJsckhPj2pEiRgtatWzNz5kzevn3LjBkzGDFihLnDilOCgoIYPHiwtjxq1Kg417oitiVPnpwpU6YwevRozp07x7Nnz7h//z6pU6emXLlyODo6Gu3fpEkTmjRpAsDt27c5ePAgZ8+e5eHDh9jY2JAuXTrtL2PGjFhbW5MmTZpYS48UyqNAyuRCCCG+JabWBgBRKvw+fPiQTZs2YWtra9RffMaMGRQoUIBjx45ha2tLwYIFjZ73/Plzxo4dy5MnT3B0dKRIkSJGU/u0b9+eUaNGUaVKFZydnenfvz8ZMmQwOS4hxLfpl19+Yc6cOQQHBzNjxgx69+6Ns7OzucOKM2bPns2NGzcAKFeunMkzWsQH9vb2FCtWLErPcXV1xdXVlWbNmkW4PXQMmdgkhXIhhBBCREmqVKk4efJkpNtLlizJli1bwq3/4YcfWLduXaTPs7Ozi1OjLwshYkf69On5+eef8fLy4uXLl8yePdtolPH47PXr19q89wATJkyI97Xk3yOTCuUfTznyKRHNJfq9kObrQgghvlX+/v4sWrSIEydORDgq7YYNG8wQlRBCGPTr149FixahlGLKlCl07doVe3t7c4dldhMmTODZs2cANG7cmEKFCpk5IhETTCqUz5071+RfZKRQLoQQQsQ9Y8aMYceOHUD4Edml1kUIYW7ZsmWjfv36rF69msePH7NgwQK6dOli7rDM6v79+0yZMgUwjPsxevRoM0ckYorJzddNGfxFvtSFEEKIuOnw4cMAZM+eHVdX1xidSkcIIb7EwIEDWb16NQATJ06kffv2ZpuzPS7o06cP/v7+AHTq1ImMGTOaOSIRU0z6Rg47UMzZs2fp0aMHPXv2pGLFigDs3r2biRMnMnny5JiJMo6QmnIhhBDfKhsbG1KnTs2ff/5p7lCEECJC+fLlo1q1amzZsoU7d+6wfPlymjdvbu6wzGLp0qWsXLkSABcXF4YMGWLmiERMivJs6BMmTCB58uTUqlULBwcHHBwcqFmzJqlSpdKaVwghhBAibmnQoAEvX77U+iYKIURcNHDgQO3x2LFjCQkJMWM05vHPP//Qrl07bXnKlCkyd/t3Lspt127fvo1SimPHjmnDzx8/fpx79+59983XpaZcCCHEt+TjuX6Dg4OpV68eP/zwA05OTtp6nU7H0KFDYzs8IYQI58cff8Td3R1vb2+uXLnC+vXr+emnn8wdVqzx9/enUaNGWrP1Nm3a4OnpaeaoREyLcqE8S5Ys+Pj40K1bN+zs7NDpdNpFkzNnzmgPMC6RMrkQQohvyebNm41+MFdKERgYiLe3t9E6KZQLIeKSAQMGaJ9To0ePpm7dut995V+oPn364OPjA0CePHn47bffzByRiA1RLpQPGjSI7t278/TpU60wDpAsWTIGDRoUpWO9ePGC4cOHc/LkSVKkSEH//v0pUqRIhPtu3LgRLy8vnj59SsqUKZk8eTKurq5RDV8IIYSINwoUKBBvbmSFEN+PSpUqUahQIU6dOsWZM2fYuHEjtWrVMndYMW79+vXMmjULAHt7e1auXImdnZ2ZoxKx4Ytqyv/++2+2bdvGzZs3UUqRKVMmqlSpgq2tbZSONX78eJIlS8aePXs4duwY/fv3Z/369Tg7Oxvtd+DAAZYuXcqkSZNwc3Pj/v37JEiQIKqhfzVpvi6EEOJbMnfuXHOHIIQQUabT6Rg2bBg1a9YEYNiwYdSoUQMLiygPh/XNuHbtGi1atNCWp06d+t23QhYffNF8KLa2ttSuXRsw9E/7kmlV3r17h7e3N5s2bcLOzo4yZcqwbNkyDhw4QPXq1Y32nT9/Pr169SJTpkwApE2b9pPHDgoKIigoyGidlZUVNjY2UY4zLL3+42V9xDt+h0LTGp/SHFZ8Tz9IHoDkgaQ/+tMfGzeYs2fPpkCBAuTJkwcHB4cYP58QQkSH6tWrU7hwYU6ePMm5c+dYv349devWNXdY0SIgIID79+9z7949/Pz8OH/+PJMmTeLVq1cA1K9f32igN/H9+6JC+alTp5gzZw7//PMP2bNnp0OHDmzbto3atWuTL18+k45x584dnJycSJo0qbYuS5Ys3Lhxw2i/kJAQrly5wrVr1xg5ciRWVlbUqFGDNm3aRNokz8vLi3nz5hmtq1+/Pg0aNIhiSo29fp0ISKgt3759+6uO9y26e/euuUMwq/iefpA8AMkDSX/0pT825pxdsGABOp0OCwsLsmbNSv78+SlYsCD58+cnUaJEMX5+IYT4EjqdjhEjRlCtWjUAhg8fTu3atb/Z2vJ3796xbt06li1bxq5duyIdVT5HjhzMnz9fuh7FM1EulJ88eZIuXboYXUgpU6Zk8+bNACYXyv39/XF0dDRa5+joiJ+fn9G658+fExISwokTJ1i1ahVv376lW7dupEiRQmvS8rGWLVvStGlTo3XRUVOewLhVfbzq067X67l79y7p0qX7Zj8Mv0Z8Tz9IHoDkgaT/20y/vb09/v7+hISEcOnSJS5fvqzNfevq6kr+/PkpUKAAHh4eZo5UCCGMVa1alaJFi3L8+HEuXLjA2rVrqV+/vrnDirK9e/fSpEkTHj9+HOk+Op2ORo0aMXPmzHBdecX3L8qF8jlz5qDX6ylTpgz79+8HIH369CRJkoRz586ZfBx7e3vevn1rtO7t27fY29sbrQvtp968eXMSJEhAggQJqF+/PocPH460UG5jY/PVBfCIGTdZ/JZuyqKLhYVFvEx3qPiefpA8AMkDSf+3lf79+/dz+fJlzpw5w5kzZzh79qzWRPLWrVvcunWLDRs2SKFcCBHn6HQ6hg8fTtWqVQFD3/LatWtjbW1t5shMd/DgQapXr240QHb69OkpVqwYadOmxdnZmSRJkuDh4aF11RXxT5QL5RcvXiR16tRMnDiRH374QVufNGlS7ty5Y/Jx0qdPj5+fH8+ePdOasP/777/hRlZ0dnYmWbJkRuuUjLgmhBBCmMTCwoKc/2/vvqOjqNo4jn8nCekEQjG0UEKTokgRVCB06YLSVERAmiIgTYj00IuIoKAIGHgVKYIoUZp0FUGqNOkIUXonjZDsvH+sLKyAJJBkk+zvc04OM3dmZ597s+TuM3PnTsmSlCxZ0jaK7ODBg8ybN48VK1bcdwiliEhaULduXZ599ll+/fVX/vjjDyZMmMCAAQMcHVai/PbbbzRs2NCWkNesWZNhw4ZRuXLldHVyV1JekpNyNze3u5Jii8XC+fPnk/Th8vb2Jjg4mOnTp9OnTx+2bNnC0aNHCQ4OvmvfRo0a8b///Y/ixYsTHR3N4sWLee2115Ia+iPTuQAREUmPYmNj2bNnj+1K+Z49e7hx44atPw8ICHBwhCIi92YYBlOmTKFSpUpYLBaGDBlCpUqVqFWrlqND+0/79u2jfv36XL9+HYB69erx7bffJvlpVeIckpyUFy9enF27djFy5EjA+qzxgQMHcvnyZcqXL5+kY4WEhDB06FBq1apFQEAAY8aMwc/Pj+XLlxMWFsbChQsB6Ny5M+PGjaNBgwZ4e3vTtGnTu2ZoFxERkbu1a9eOgwcPkpCQYEvC8+fPT9myZW0/efLkcXCUIiL3V6FCBd577z1GjRpFQkICLVu25LfffkuTw72vXr1KWFgYQ4cO5dq1awBUq1aNb775Rgm53FeSk/K2bduya9culi5dimEY/P333/z9998YhkGbNm2SdCx/f3+mTJlyV3n9+vVt944AZMqUiUGDBjFo0KCkhpusdKVcRETSm3379mEYBv7+/rz66qu88MIL+Pv7OzosEZEkCQ0NZdeuXfzwww9cunSJJk2a8Msvv5AlS5YHvziFJSQksHHjRr744gsWLFhAdHS0bVv58uUJDw+/a94skTsl+WaGypUrM3LkSHLlyoVpmpimSa5cuRg+fDiVK1dOiRjTDCXlIiKS3nh5eWGaJpcuXWLq1Km89tprDBo0iEWLFnH06FFHhycikiiurq589dVXlChRArCecGzevDlxcXEOi+no0aP06NGD3LlzU7NmTcLCwuwS8rZt27JmzRoyZ87ssBglfUjSlXKLxcK5c+d48skn+e6777h69SqmaTrNGfes+v8kIiLpzPr16zl48KBt9vXff/+dlStXsmrVKgAyZ85M2bJlef/99x0cqYjIf/Pz82Pp0qU888wzXLx4kdWrV9O5c2fCwsJS9bne8fHxjBo1ihEjRtw1Waafnx9t2rShS5cuPPHEE6kWk6RvSR6+3qRJE3LmzMn3339P1qxZUyCktKtCcQOwXi6vVc6xsYiIiCSGi4sLJUqUoESJErz66quA9Wknc+fOZcWKFVy7do2NGzc6OEoRkcQpUqQIS5cupVatWsTGxjJnzhwKFSrE0KFDU+X9jxw5wuuvv86vv/5qK/Py8qJ+/fo0b96cJk2a4O3tnSqxSMaRpKTcxcWFXLlypatnA6aUGkrKRUQknYiNjWX37t3s3LmTHTt2sG/fPocO+RQReRTPPfccX3zxBS1btsQ0TYYNG0bBggVp27ZtiryfaZocP36czz//nAkTJtj+frq6utK/f3/69u3rNCOHJWUk+Up5586dGT58OIsWLaJ58+YpEZOIiIgkkztnXwfsHmvq6urK448/TtmyZR0VnojIQ2nevDkTJkygb9++AHTs2JHHHnvMbrLoRxEZGcmyZctYtmwZ69evJyIiwm57UFAQc+fO5ZlnnkmW9xPnluSkfPr06bi6ujJ+/HgmT56Mv7+/3T0c3333XbIGKCIiIg9v3759tmUPDw9Kly5texTak08+iaenpwOjExF5eL179+b48eNMnTqV+Ph4mjZtykcffUSnTp0e6h5z0zT59ddfGT9+PD/++CMxMTF37ZMpUyZ69+7NoEGD8PX1TY5qiCQ9KT99+rRtOTY21m49NSdYEBERkQd77rnnKFu2LOXKlaNkyZK4uSW56xcRSZMMw2Dy5MmcP3+ehQsXEhcXR5cuXVi9ejWfffZZkua/+vHHHxkwYADbtm27a5uXlxeVK1emevXqtGrViiJFiiRjLUQeIinv1KlTSsQhIiIiKWDy5MkAbN269b4J+cSJE+nTp09qhiUikixcXV2ZO3cuOXPmZOrUqQB8/fXX/PzzzzRu3JjAwEBefPFFSpUqdc/XX7hwgZCQEGbNmmVXni1bNlq2bEnLli2pXLky7u7uKV4XcV4PdU+5s9JzykVEJL3q3bs3H374IeXLl7eVWSwWQkNDWb58uZJyEUm33Nzc+Pjjj6lVqxZvvPEGV65c4fTp03z22WcAhIaGMmrUKPr27YuLiwsA586d46OPPuLDDz8kMjLSdqyyZcvyyiuv8Pbbb2sWdUk1DzWGLS4ujhUrVrBnzx5y5MhBkyZNOHXqFIULFyZLlizJHWOapJH6IiKSnsTGxtK7d28mTZpEuXLliIuLIyQkhJ9++sn2JVVEJD178cUXqVChAm+//Tbh4eG28vj4ePr37893331H5cqVOXr0KOHh4dy8edO2T+bMmRk7dixdunTh5MmTmm9DUlWSk/IrV67QpUsXjh8/DkDp0qV58skneeedd+jQoQNdunRJ9iBFRETk0bzyyivMmzePXr16MXLkSL744gt27tyJm5sbQ4YMcXR4IiLJIjAwkKVLl3L+/HlOnjzJokWLGDduHKZpsmnTJjZt2mS3f6ZMmejQoQODBw8mT548WCwWB0UuzizJp8anTJnCsWPHcHd3tz1WpWLFinh6et71IRcREZG0oXfv3nTo0IHo6Gj69OnDzp078fb2ZvLkyUl+hFBcXByhoaE0aNCAatWq0blzZ44cOQJAeHg4lSpVomrVqrafM2fO2F67b98+XnnlFSpXrkznzp3vmkB28ODBBAcH07BhQ1asWJE8lRcRp5MzZ07Kly/PmDFjWLt2Lfny5bPbnj17dvr168fhw4f55JNPyJMnj4MiFXmIK+U///wzvr6+fP3117ZO3NXVlVy5cvH3338ne4AiIiLycO5MhgGaNm3KtWvX+Prrr/H29iY0NJT8+fNz5swZcuXKlejjJiQkkDdvXsLCwsiRIwfz5s2jT58+tseiVqxYkY8++uiu18XFxdGvXz86d+5MvXr1mD59OkOGDGHGjBmA9bGrV69eZdmyZRw9epR33nmHEiVKUKBAgUdoBRFxdtWrV+fw4cNs3bqVmzdv8thjj1GsWDFN3iZpRpKT8sjISAoWLEiOHDnsyi0WC9HR0ckWmIiIiDyaF1544Z7lhmEQExNDv379bOtbtmxJ9HG9vLzo2LGjbb1Vq1ZMnjyZK1eu/Ofrtm/fjpeXF02aNAGsT3SpXbs2p0+fJnfu3CxbtoyJEyfi6+tLmTJlCA4OZtWqVfd88ktcXBxxcXF2ZW5ubsnyJfvW8FVnG8bqrPW+k7O3QUauv7u7O5UrV7Yru1c9M3IbJIaz1x+Svw0SM29LkpPyXLlycezYMXbt2mUr27hxIydOnCB//vxJPVy6otnXRUQkPTFTqePavXs32bJlsz0T+Pfff6dWrVpky5aNVq1a0bx5cwCOHTtm93xfLy8v8uXLx7Fjx/Dx8eHixYt224sVK8a+ffvu+Z5hYWG2K+y3tGjRgpYtWyZbvSIiIpLtWOmJs9b7Ts7eBs5ef1AbOHv9IfnaoFChQg/cJ8lJed26dZk5cyadO3fGMAz27t1L3759MQyDunXrPlSg6ZEmXxcRkbTu008/TfH3iIyMZPTo0XTt2hWAcuXKMX/+fHLlysX+/fvp27cv2bNnp0aNGsTExODj42P3eh8fH2JiYoiOjsbV1dVuxmMfH5/7jsJr3749rVu3titLzivlERERBAYGOtXM9M5a7zs5exs4e/1BbeDs9QfHtEGSk/I33niD/fv33zWp27PPPkv79u2TLTARERF5NHc+kzwl3Lhxgz59+lClShXbkPS8efPatpcuXZqXX36ZdevWUaNGDby8vIiKirI7RlRUFF5eXnh7e5OQkEBsbKwtMY+Kirrvc4Ld3d1T/H5QFxcXp/xS6qz1vpOzt4Gz1x/UBs5ef0jdNkhyUp4pUyYmT57Mjh072LdvH6ZpUqpUqRTv+EVERCRp3n33XQoWLMjbb7/9wH0/+ugjTp48yYQJExJ17Pj4eAYMGEDOnDnp2bPnffczjNtjy4KCgliyZIltPSYmhr/++ougoCD8/PzInj07R44coXTp0gAcOnSIoKCgRMUjIiKSXiU59Z86dSonT56kXLlytGnThtdff10JuYiISBq0fv16tm/fnqh9d+zYwYYNGxJ97FGjRnHjxg2GDRtml3hv2rSJy5cvA3DgwAEWLFhA1apVAeuV+5iYGMLDw4mLi2PWrFmULFmS3LlzA9CgQQNmzpxJVFQUe/bsYePGjdSpUyfRMYmIiKRHSb5SPnv2bObMmUPp0qVp1KgRzz//PL6+vikRm4iIiDyiY8eO8eabbyZqv8Q6ffo04eHheHh4UKNGDVv5lClT2LJlC0OHDiU2NpacOXPy+uuv2xJrd3d3xo8fz4gRIxg7diwlS5Zk+PDhttd36dKFkSNHUq9ePfz8/AgJCaFgwYKJr6yIiEg6lOSkPHfu3Jw+fZo9e/awd+9eJk6cSLVq1WjUqBHPPvus3dlyERERcayoqKhEXy1PbB+eO3dutm3bds9tZcuWpVevXvd9balSpZg/f/49t3l6ejJy5MhExSAiIpJRJDkpX7p0KXv37mXlypWsWbOG8+fPs3r1alavXk2OHDlYtmxZSsSZJuiJaCIikp7c6/neIiIikrYkOSkH62yqpUuXpk+fPqxfv56xY8dy8eJFLly4kNzxpVkaECAiImld586dHR2CiIiIPMBDJeXR0dGsX7+eVatW8dtvvxEfHw8kftibiIiIiIiIiDxEUv7uu++yadMmbt68iWlaB3TnzZuXhg0b0rBhw2QPUERERERERCSjSnJSvn79egB8fHyoXbs2jRo14qmnnkrmsEREREREREQyviQn5c888wwNGzakRo0aeHh4pERMIiIiIiIiIk4hyUn5Rx99BMCNGzf4448/AAgKClKCLiIiIiIiIpJEDzXRW1hYGJ9//jk3btwAwMPDgw4dOtCuXbvkjC3NMfVMNBERSccsFgsRERFcunTJNi/MLeXKlXNQVCIiIs7toZ5TPm3aNLuy2NhYpk2bRo4cOWjUqFGyBZeWaaJ5ERFJT/bu3cvAgQM5ffr0XdsMw2DLli0OiEpERESSnJQvXLgQgOrVq1O3bl0AVq5cyfr165k/f77TJOUiIiLpydixYzl16pSjwxAREZF/SXJSfvz4cfLkycOECRNsZbVr1+aFF17g+PHjyRqciIiIJI8///wTNzc33nnnHYKCgnB1dXV0SCIiIsJDJOWurq7cuHGD+Ph43NysL4+Pj+fGjRvq4EVERNKooKAgYmJiePnllx0dioiIiNzBJakvKFasGJcuXaJz58588cUXfPnll3Tu3JnLly9TrFixlIhRREREHlGfPn04c+YMX3/9NZGRkY4OR0RERP6R5Cvlbdq0oW/fvuzdu5e9e/cCYJomhmHw+uuvJ3uAaYlmXxcRkfSkYsWKd5VNmDDB7hY00ERvIiIijpTkK+XVqlUjNDSUgIAATNPENE1y5cpFaGgowcHBKRFjmqTZ10VEJK271U8n5kdEREQc46GeU96gQQMaNGjA5cuXAfD390/WoEREROTRDR061NEhiIiIyAMkOSk/fPgwp06dokSJEjz22GMAnDt3jj/++IM8efJQtGjRZA9SREREku7Ox5SeOXOGTJkykT17dgdGJCIiIv+W5OHrI0eOZMCAAbi7u9vKPDw8GDBgAKNHj07W4ERERCR5NG7cmHffffeu8h49evD88887ICIRERGBh0jK//zzTwIDA8maNautLEuWLAQGBnLs2LHkjE1ERERS2KVLl7hy5YqjwxAREXFaSR6+Hh8fz8WLF+96TvnFixdJSEhI9gBFRETk4YWGhtqW//rrL7v12NhYDh8+jJeXlyNCExERER4iKS9YsCCHDx9m0KBBvPrqqwDMmzePK1euULx48WQPMC3R5LQiIpLefP/99xj/PDLkypUr/PDDD7Ztt2Zdf+KJJxwSm4iIiDxEUt60aVPGjx/P2rVrWbt2ra3cMAyaNm2anLGlaXoimoiIpAdly5bFMAx27NiBt7e33Ql0T09PChYsSJs2bRwYoYiIiHNLclLeokULjh8/zqJFi2xn2A3DoGXLljRv3jzZAxQREZGH99lnnwHw9NNPExQUxPTp0x0ckYiIiNzpoZ5T3q9fP9q0acO+ffsAKFWqFLlz507WwERERCT5bN261dEhiIiIyD08VFIOkDt3biXiIiIiadibb76ZqP0Mw+CTTz5J4WhERETkXh46KRcREZG0bfv27RiGYbvdDLBN+naLaZp3lYmIiEjqUVIuIiKSQd2a5O2WP/74g7i4OIoWLYppmhw5cgRXV1fNvi4iIuJASsqTQE9EExGR9OTWJG8Aixcv5sCBAyxYsIACBQoAcOLECdq0aUNwcHCSjhsXF8eYMWPYsmULUVFRFC9enH79+lGkSBHCw8OZN28ef/31F/7+/rRp08ZuItgKFSrg6elpO1nQvn173njjDcD63PRRo0axYcMGMmfOTPfu3alXr96jNoOIiEiapqT8IWmkn4iIpCdhYWE89thjtoQcoECBAgQEBDB37lxeffXVRB8rISGBvHnzEhYWRo4cOZg3bx59+vThu+++Iy4ujvfee48SJUpw4sQJ3nrrLYKCgihXrpzt9d9++y05cuS467jTp0/n6tWrLFu2jKNHj/LOO+9QokQJu5hFREQymodOyrdv384ff/wBQIkSJShfvnySj3H58mWGDRvGtm3bCAgIICQkhIoVK953/1OnTtGiRQsaNmzIgAEDHjZ0ERERp3PlyhXOnTvH1KlTqVmzJoZhsHbtWv788088PDySdCwvLy86duxoW2/VqhWTJ0/mypUrNGvWzFZeuHBhKlasyP79++2S8vtZtmwZEydOxNfXlzJlyhAcHMyqVavo1KnTXfvGxcURFxdnV+bm5oa7u3uS6nIvFovF7l9n4az1vpOzt4Gz1x/UBs5ef0j+NnBxcXngPklOym/cuEHfvn3ZsmWLXXmlSpWYOHFikjrDcePGkTNnTtasWcPmzZsJCQnh22+/xc/P7577f/DBBxQvXjypIYuIiDi9KlWqsGbNGubMmcOcOXPu2vYodu/eTbZs2ciaNatdeUJCAvv27aNBgwZ25a+99hqGYVCpUiV69uxJ1qxZuXbtGhcvXqRIkSK2/YoVK2Z7/Oq/hYWFMWPGDLuyFi1a0LJly0eqy50iIiKS7VjpibPW+07O3gbOXn9QGzh7/SH52qBQoUIP3CfJSfnMmTPZvHnzXeVbtmxh1qxZvPXWW4k6TnR0NBs2bCA8PBxPT0+qV6/O3Llz2bhxI40aNbpr/19//RXTNKlUqRIXL178z2On1NnzO0+WmKYFZzqB5OxnzZy9/qA2ALWB6p/89U/M2fPkMnDgQBISEli/fr1defXq1Rk4cOBDHzcyMpLRo0fTtWvXu7Z98skn5MyZk2effdZWNmPGDJ544gmuX7/OuHHjGD58OB988AHR0dG4urri6elp29fHx4fo6Oh7vm/79u1p3bq1XVlyXimPiIggMDAwVX9Hjuas9b6Ts7eBs9cf1AbOXn9wTBskOSn/8ccfcXFxoWfPnrbJV5YvX86HH37IypUrE52Unzx5El9fX7t7yooWLcqxY8fu2vfmzZtMnjyZCRMmsGzZsgceO6XOnp+/4A3kBKzDAE+cuP5Ix0uPnP2smbPXH9QGoDZQ/ZOv/ok5e55cMmfOzIQJE/jrr784duwYpmlSuHBh8uXL99DHvHHjBn369KFKlSo0adLEbtuiRYtYu3Ytn3/+ud0M8GXLlgXA39+fvn370rBhQ27evIm3tzcJCQnExsbaEvOoqCi8vb3v+d7u7u7JkoD/FxcXF6f8Uuqs9b6Ts7eBs9cf1AbOXn9I3TZIclJ+9uxZChQowCuvvGIre/XVV/n222+T9EUlJiYGHx8fuzIfHx8iIyPv2nfu3LlUrlyZwMDARB07pc6e5zh+ezlr1qwUKJDtkY6Xnjj7WTNnrz+oDUBtoPpnjPrny5fvkRLxW+Lj4xkwYAA5c+akZ8+edttWrVplO0H+7yHtd7rVjqZp4ufnR/bs2Tly5AilS5cG4NChQwQFBT1yrCIiImlZkpNyb29vzp49y/nz58mZ03rV+Ny5c5w9e/auJPu/eHl5ERUVZVcWFRWFl5eXXdm5c+dYunQpX3zxRaKPnVJnz10Mk1sPRnPWs0fOWu9bnL3+oDYAtYHqn37q36RJE4oXL8748ePvupL9b999912Sjj1q1Chu3LjBuHHj7K6Eb968mQkTJjBt2jTy5Mlj95qjR4+SkJBA4cKFiYqKYuLEiVSqVMnWZzdo0ICZM2cyatQojh07xsaNG5k9e3aS4hIREUlvkpyUlytXjvXr19O8eXPKli2LYRjs2LGDmJiY/5w5/d/y589PZGQkFy5csA1hP3z48F1fGvbv38/Zs2d56aWXAOu96BaLhdOnT/PRRx8lNXwRERGncerUKbJnz25bvh8jic/5PH36NOHh4Xh4eFCjRg1b+ZQpUwgLC+PatWu2Z48D1K9fnwEDBnDp0iXGjBnDuXPn8PHxoWLFigwbNsy2X5cuXRg5ciT16tXDz8+PkJAQChYsmKTYRERE0pskJ+Vvvvkmv/32G9HR0WzatAmwDjvz9vZO9P3kYL3iHhwczPTp0+nTpw9btmzh6NGjBAcH2+333HPP2Z29//LLL7l8+TK9evVKaugiIiJOpVOnTjz22GMAdOzYMcnJ9/3kzp2bbdu23XPb9OnT7/u6p59+mm+++ea+2z09PRk5cuQjxyciIpKeJDkpL1y4MLNnz2b27Nm255SXLFmSdu3aJflsdkhICEOHDqVWrVoEBAQwZswY/Pz8WL58OWFhYSxcuBB3d3e7yeC8vLyIjo7+z3vUREREBDp37mxb7tKliwMjERERkftJclIO1tliQ0NDH/nN/f39mTJlyl3l9evXp379+vd8jb5UiIiIJF6nTp146qmnKFu2LGXKlEnS/C8iIiKS8hKVlH///ff4+/tTuXJlvv/++//c917PGBcRERHH2LVrF7///jtz5szBMAyKFClCuXLleOqpp3jqqads95yLiIiIYyQqKQ8NDeWJJ56gcuXKhIaG3veeNMMwMnRSbpqOjkBERCRpnn32WXbv3k1UVBSmaXLo0CEOHz7MggULAOsj0sqVK8egQYMcHKmIiIhzeqjh6+Z9stP7lWdEyTRXjoiISIqaMmUKFouFQ4cOsXPnTnbs2MHvv//O5cuXAYiIiOCvv/5SUi4iIuIgiUrKt27des9lERERSftcXFx4/PHHefzxx2nRogV79+7l22+/ZcWKFSQkJDg6PBEREaeW5CvlM2bMICAggBdeeMGufPfu3Vy7do0qVaokW3AiIiLyaGJiYvj999/ZtWsXO3fuZN++fcTFxdlGt+XKlYuyZcs6OEoRERHnleSk/LPPPuOJJ564KymfNGkS+/bt47fffku24EREROTR1KhRA4vFAlhvMytYsCBly5a1/eTKlcvBEYqIiDi3h7qn/N9iY2O5cOFCchxKREREklFCQgKGYeDv78+rr75KzZo1CQwMdHRYIiIi8o9EJ+UVK1YErDOs792717Z+p2zZsiVfZCIiIvLIbs2+funSJaZOncrUqVPJli2b3dXyokWLOjpMERERp5XopPzWvWeGYdx3lvUXX3wxeaJKo5xocnkREckgpkyZYnsU2s6dO9m5cye///47q1evZs2aNQBkzpzZtiwiIiKpK9FJ+dChQwHrM8vz5ctHhw4dbNs8PT0pWLAgRYoUSf4I0yg9EU1ERNILwzAoXrw4xYsXp1mzZuzdu5fvvvvONvv69evXHR2iiIiI00p0Ut6oUSMAtm3bRr58+WzrIiIiknbdmn391lXyffv2cfPmTUeHJSIiIv9I8kRvw4YNA+DmzZtcvnzZNqPrLZrFVUREJO349+zrt7i5uVGiRAnbfeUiIiLiGElOyqOjoxkxYgTr168nISHBbpthGGzZsiXZghMREZFHc6uv9vT05IknnrAl4U888QQeHh4Ojk5ERESSnJRPmzaN1atXp0QsIiIiksy6d+9OuXLlePzxx3FzS5YnoYqIiEgycknqCzZs2IBhGLzxxhsA5MuXj2bNmuHn50e/fv2SPcC0RJOvi4hIevP6669TunRpJeQiIiJpVJKT8gsXLpA3b17eeustALJmzUpISAi+vr4cOHAg2QNMqwxNvy4iIiIiIiKPKMlJubu7O97e3rblc+fOER8fz82bNzWsXURERERERCQJkpyUZ8+enfPnzwPWoevnz5+ndu3anD9/Hnd392QPUERERERERCSjSnJSXqpUKWJjYzl8+DCNGzfGNE2ioqIAaNCgQbIHKCIiIiIiIpJRJXnWlxEjRtiWixYtSo4cOdizZw9FixalSZMmyRqciIiIiIiISEb2yFOx1qtXj3r16gFw7NgxgoKCHjkoEREREREREWeQ5OHr169fJyEhwa5s79699O3bl1deeSXZAkuLTD0TTURERERERJJRoq+Unzp1it69e3Ps2DF8fX0ZPHgwZcuWZcSIEfz0008pGWOapEeiiYiIiIiIyKNKdFI+ZcoUjh49Clivlo8cOZIiRYqwY8cOADJlykTDhg1TJkoRERERERGRDCjRSfnOnTsxDIP69etjmibLly9n586duLu706JFC1577TVy5MiRkrGKiIiIiIiIZCiJTsqvXLlCYGAgoaGhAOzbt4+IiAgmTpzIM888k2IBioiISNoSFxfHmDFj2LJlC1FRURQvXpx+/fpRpEgRAGbPns2XX36JxWKhSZMm9OjRA+Of+7727dvHyJEjOXnyJKVKlSI0NJTcuXMDEBsby6hRo9iwYQOZM2eme/futslkRUREMqpET/RmsVjIkiWLbd3Pzw9ACbmIiIiTSUhIIG/evISFhbF27VqCg4Pp06cPAD///DOLFi1i9uzZLFy4kJ9//pmlS5cC1mS+X79+vPzyy6xdu5bSpUszZMgQ23GnT5/O1atXWbZsGaNHj2bs2LGcOHHCIXUUERFJLUmaff3gwYM0adKEJk2acOjQIQDb+q0fERERydi8vLzo2LEjAQEBuLq60qpVK06dOsWVK1dYtmwZzZs3J1++fOTIkYPXXnuN5cuXA7B9+3a8vLxo0qQJHh4edOrUif3793P69GkAli1bRufOnfH19aVMmTIEBwezatUqR1ZVREQkxSXpOeU3b97k1KlTdmV3rhsZfEpyPRJNRETkbrt37yZbtmxkzZqV48eP06BBA9u2YsWKMXXqVACOHTtmG+IO1uQ+X758HDt2DB8fHy5evGi3vVixYuzbt++e7xkXF0dcXJxdmZubG+7u7o9cH4vFYvevs3DWet/J2dvA2esPagNnrz8kfxu4uDz4Oniik/KyZctm+KQ7KdQUIiIiEBkZyejRo+natSsA0dHR+Pr62rb7+PgQHR0NQExMDD4+Pnav9/HxISYmhujoaFxdXfH09Lzna/8tLCyMGTNm2JW1aNGCli1bJku9ACIiIpLtWOmJs9b7Ts7eBs5ef1AbOHv9IfnaoFChQg/cJ9FJ+WefffZIwYiIiEjGcuPGDfr06UOVKlVst7B5e3sTGRlp2ycqKgpvb2/AemU8KirK7hhRUVF4eXnh7e1NQkICsbGxtsT8ztf+W/v27WndurVdWXJeKY+IiCAwMDBRVzgyCmet952cvQ2cvf6gNnD2+oNj2iBJw9dFREREAOLj4xkwYAA5c+akZ8+etvJChQpx5MgRqlSpAsChQ4cICgoCICgoiCVLltj2jYmJ4a+//iIoKAg/Pz+yZ8/OkSNHKF269F2v/Td3d/dkScD/i4uLi1N+KXXWet/J2dvA2esPagNnrz+kbhs4d0uLiIjIQxk1ahQ3btxg2LBhdre3NWjQgMWLF/P3339z4cIF5s6dS/369QEoX748MTExhIeHExcXx6xZsyhZsqTtkWgNGjRg5syZREVFsWfPHjZu3EidOnUcUj8REZHUoivlIiIikiSnT58mPDwcDw8PatSoYSufMmUKVapU4fDhw7z++utYLBaaNm3KCy+8AFivbo8fP54RI0YwduxYSpYsyfDhw22v79KlCyNHjqRevXr4+fkREhJCwYIFU7t6IiIiqUpJeRJo9nURERHInTs327Ztu+/29u3b0759+3tuK1WqFPPnz7/nNk9PT0aOHJksMYqIiKQXGr7+kDT5uoiIiIiIiDwqJeUiIiIiIiIiDqKkXERERERERMRBlJSLiIiIiIiIOIiSchEREREREREHUVIuIiIiIiIi4iBKypNAT0QTERERR7hy3eRwhElktL6NiIhkNHpO+UMy9Ew0ERERSSEWi8mXq+DLVSb7/oRTF6zlhgHlipm0ed7gudKQJwc85g+Z3PTFREQkvVJSLiIiIpKG7Dho8tYHJr/9cfc204TtB2H7wdtXzF1c4KVgk0ndDPI9puRcRCS90fB1ERERkTTiy1Umz3a1T8iz+UHVJ+HlWlCmyN2vsVhg0Xp4qoPJpj0a3i4ikt7oSrmIiIhIMkpIMDl6Ci5dg/gEyOprHWbu7QEe7mDc5x64jxebdJ98O6kuXQg+7GFQs5z9a/YeM1n5Gxz+y+T0Rdj4O1yJhItXoWYvky8GQosaumIuIpJeKCkXEREReUhXrpt8vR6O/GVy6iIcPAl7j0PMjXvv7+ICft4mBXPDMyXh8fwGri7ww2aTFVtu79flBfiop3HPe8VLBxmUDgKwbrt83aTFEJM12+FGHLQcavLhBXinhRJzEZH0QEm5iIiIyEO4cMWkYheT46cT/xqLxXpVe9dh68+9nu0yoA2M7Gjc94r6v/lnNlg2Ht6caBK2zFrW8yOTyBgY+LoScxGRtE5JeRKYuk1LREREANM06fL+vRPyInmt937nzQFurnDhKpy9DLFxEBULl6/DsVN3f68okAuGv2Hwer2kJ9LumQxm9Yf8j5mEzraWDZppEhljMrpz4hP8jOzv8yYL18GeYyZRMVCumMHrdSF3DrWNiDiWkvKHpL5NRETEec1ZAd9stC5n84PP+xsUzw/5coKv94O/JFy5bn3U2eG/rIPQC+aG50o/2qPNDMNg2BsGvl4m735izfjHzoXIGJMp79z/Xvb0KjrW5MetcO6K9b59b084fgoizplkcgNPdwNvT4iOhTU7TDbssj8RsnCdydAwGNcFejTPeO0jIumHQ5Pyy5cvM2zYMLZt20ZAQAAhISFUrFjxrv0++OADNmzYwOXLlylQoAC9evWiXLlyDohYREREnF1UjEnI9NvZ3az+Bk2qJi2hy5rZoPITUPmJ5I4O+r5i4OMFXT+wxvjxN5BgMfm4J7i4pO/E02IxWbUVZi83Cd9kTbjv78FDHG/EWYf67z0O03qDq55LJCIO4NCkfNy4ceTMmZM1a9awefNmQkJC+Pbbb/Hz87Pbz9fXl48//pi8efOydu1a+vbtS3h4OD4+Pg6KXERERJzV5EVw9pJ1uVk1aJrEhDw1vNXUwMcT2o81sVjgk2+tQ+6n9kqfiblpmizeAMPCTPYdf7hjFMkLretA48oGnu7w6XcmH39j3Tbze9h6wCSkNZTLb032vT3NdNlWIpL+OCwpj46OZsOGDYSHh+Pp6Un16tWZO3cuGzdupFGjRnb7du7c2bZcu3ZtJk6cyMmTJylRosQ9jx0XF0dcXJxdmZubG+7u7o8Us8W8c9mCxfJIh0tXLP9U1uJMlb6Ds9cf1AagNlD9k7/+Li66LJfeXLpmMn6e9QuBi4t1Qra06vV61pndXx9tTcw//Q5uxpt82gfcHmGYfGoyTesQ9QEzTLYftN+WzQ9eCobyxQ2uR8P1aJP8AQZBua3XyGPjIDIa4uKtM90XyWc/RP2jngbPlTZpN8Yk7ib8fgReCQU31/zEJ0AmN5MCASbVy0Kb5w2qltEQdxFJGQ5Lyk+ePImvry85cuSwlRUtWpRjx4795+tOnTrFtWvXCAwMvO8+YWFhzJgxw66sRYsWtGzZ8pFivnjBB7DGe/nyZU6ciHyk46VHERERjg7BoZy9/qA2ALWB6p989S9UqFCyHUtSx6CZJlf/6f7b1YPHC6TtJK318waGAW1GWRPzWT9YTyx8NQQ8PdJ27Ef/tk6mt2a7ffmzpaDfqwYNn/33PfhJr88rtQ0K57HOXL/zsLUsPsF6nJvxcORv68/M702K5oOOjaB+JShVKH2OOBCRtMlhSXlMTMxdw899fHyIjLx/ohsfH8+wYcNo06YNvr6+992vffv2tG7d2q4sOa6UZztwe9nf358CBbI/0vHSE4vFQkREBIGBgU55ZcfZ6w9qA1AbqP7OXX+Bn343+eRb67K3Jwxtnz6SslfrGLi5wmsjTW7Gw5KfoH4/k+9Gg59P2qzDhSsmwd1NTl24XVamCIzuZFD/meS9Yl2xpMH2mbB2h3VI+65DceTI6k70DetEfLeeOX/4L+j/qUn/T8HHC4JymwTlga5NDZ6vmDbb8VGYpqmRASKpxGFJuZeXF1FRUXZlUVFReHl53XN/0zQZNmwY/v7+dsPZ78Xd3f2RE/B7cTFMbk0a4uLi4pRfypy13rc4e/1BbQBqA9XfuevvrG7EmXSecPs+ttGdDPIHpJ+EpWVNg6y+8NJg6+PA1u+E6j1M1n5onXQuLTFNkw7jbifk+QNg3JsGLWuk3NVpwzCoVR5qlDU5ceI0BQoUwMXFhagYk29/glk/mKzbeXv/qBjYc8z68/2vJus+hKpl0lY7JoVpmvy8G5ZvgfXbA9h/Em4mmLwUbDKyo0GBXOm3biLpgcO+VeTPn5/IyEguXLh9CvTw4cMEBQXdc//x48dz/vx5RowYoS9DIiIikqpm/QAHTlqXK5WEbi85Np6H8XxFg7WTDLJnsa7vPAxDP3/wDOWp7bOlsPQX63LOrLD5E4OXaxkOGS7u42XQ+nmDtZNdODTX4P2uBi9WtU4ad0tCArQcavL3+bTXlg9isZjM+t7kiXbWkQljvoRf//DkapR1srsvV0HptiY//Jr+6iaSnjgsu/X29iY4OJjp06cTGxvLhg0bOHr0KMHBwXftO336dH7//XcmTpyYIlfARURERO4n7qbJ2Lm3k5KPexq4uqbPK4cVSxr89JH1+d0A076FQxFpJ+GKOHv7GesAn4cY5M6RNtq6aKBBn5cNvhnlwuF5LsStNahe1rrtzCV4caBJVEzaacsHuXzdpGZPk47j757RPm8O8PvnLtPIGGgywGT+mvRTN5H0xqGXnENCQjh79iy1atVi8uTJjBkzBj8/P5YvX243KduMGTP4888/qV+/PlWrVqVq1aosX77cgZGLiIiIs5i3GiLOWZcbPQcVHk8bSeLDKlHQ4N2XrcvxCTDqf2kj2TJNk66TTK5HW9c7NIRGz6Xdts7kZrAw1KBALuv61gPQbLBJ3M200Z7/JTLapEE/kw27bpc9VxrC3oNfJv3FyUVw8muDFjWs2xIS4NXh1qvqIpL8HPqccn9/f6ZMmXJXef369alfv75tfdu2bakZloiIiAhgTRQ/WHg7EXmvddpNEpOi78sGUxabXL4OX62GER1N8uV0bEzfb7L+AOTKBhO6pv22zpnVIHwMVO1unZV/5W/QcbzJnAFp9/FpN+JMXhpksnmfdf0xf5g3xKBmeQOLxcKJEwkAZPE1mD8U/H1NPgsH07TWLcECnV9Im3UTSa90c7aIiIjIfaz8DXYftS5XKgnPPZExkhFfb8N2X3x8Akxa6NgroKZpMvKOK/ZT3jHwT2MT0N3PE4UNwscYeP5zh+UXK2HhWsfGdD/x8SavDjf58Z/rXVl9YdVEa0J+Ly4uBp/2Neh1x1OF355k8vNuXTEXSU5KypPA1N8fERERp2GaMHjW7c6/78vpI0lMrO7NDLw8rMszvodL1xwXy9od8Nsf1uUyRaB5dcfF8jCqljGY/d7tz0f3ySYXrqStL44Wi0nn902+2Whd9/aEH8YZlCny359rwzCY+LZB738S8/gEaDHE5NSFtFU/kfRMSflDyljdsoiIiPzb/j9h2wHrcpki8NLdc9GmazmzGrzRwLocFWOd9M1RRn9hf4tAWh36/V9a1TJoVs26fP6K9ZnmaYXFYvL2JJOwZdb1TG7wzUgj0SM/DMNg3JvWx8aBdWK7FkPSx/3zIumBknIRERFJkunTp9OiRQuefvppVq5caSsfPXq0bULWqlWrUqlSJXr16mXbXqFCBapUqWLb/vnnn9u2xcbGMnjwYIKDg2nYsCErVqxI1Trdy+INt5ffaOCYR3KltD6tDFxdrcsfLYaYG6lfx837TNbusC4XyZv+rpLf6eOeBll8rcthy2HbgbSRtE5cAJ9+Z112cYGvhhjUrZi037Wbm8G8oQaBj1nXN+2FPlPTRv1E0jsl5SIiIpIkgYGB9OnTh1KlStmVDxgwgJ9++sn2U6RIEapVq2a3z7fffmvb/sYbb9jKp0+fztWrV1m2bBmjR49m7NixnDhxIlXq82+mCVOX+hE6+3ZZRrtKfkuhPAYt/5lh+8JV+Ponn1SPYdQdV8lDWqffx80B5MpuMLSdNX7ThB6TTUwH3/+4Zb/JgM+sMRgGfDnIoHn1h2vjnFkNFo8wcM9kXf/4G/hylRJzkUfl0NnXRUREJP1p0MA65vnOK93/dvz4cY4fP07t2rUTdcxly5YxceJEfH19KVOmDMHBwaxatYpOnTrdc/+4uDji4uLsytzc3HB3d09kLe7v0+8sTFzsb1t//mnIk8PEYsmYyUefVtbHvgHMXJ6F/q9bbElXStt+8PaM6/lywqu1HdvOFovF7t+H0bUpfLYUDpyEX/fBFytNXnveMXW6GgmvhFrvAwcIaQ2tat6/jRNT//LF4aN3oMv71vXOE0xKFjB5qmiyhu4wyfEZSM+cvf6Q/G3g4vLg6+BKykVERCTZLV++nCpVquDr62tX/tprr2EYBpUqVaJnz55kzZqVa9eucfHiRYoUKWLbr1ixYuzbt+++xw8LC2PGjBl2ZS1atKBly5b3eUXifbEiAPAEoEaZaAa2usyJE/GPfNy0Kps7VC39GD/t9eKvC25MX3yeF56NTpX3HvBpTsAbgE71L3LmdGSqvO+DREREPNLrQ1p60u79AAD6TYunXIFT+HimbmJumtDz0xwcP20d/VCuSCztapwlMQNQHlT/Ok9Aq2rZWLAhMzE3oOmAm3w37AxZfTNOIveon4H0ztnrD8nXBoUKFXrgPkrKRUREJNmtXLmSnj172pXNmDGDJ554guvXrzNu3DiGDx/OBx98QHR0NK6urnh6etr29fHxITr6/olh+/btad26tV1ZclwpN004+Jc1ecqbw2T1ZG9uJY0Z2ZA3oE5v6/LnP+agWyuDlJ5rbedhWL3Tupw3B7z7WnY83LOn7Js+gMViISIigsDAwERd3bqfNgVg0T/PXT97xY25G/Mz6t6DPlLMnBUQvtm67OcDX4/wpGDuAv/5mqTU//MBcOwsbD0AEeczMeB/gYSPsd6znp4l12cgvXL2+oNj2kBJeRJkzEFrIiIiyev333/n2rVrVK5c2a68bNmyAPj7+9O3b18aNmzIzZs38fb2JiEhgdjYWFtiHhUVhbf3/ZNhd3f3ZBmq/m+Xrplc+edi7eP5Daf5UlqrvEmF4ibbDsLuowartyd9IrCkGjHn9lXVkNYGXp5p515yFxeXR/7dT+pmsmqrSdxN+GAhdGxkUDhv6tRx33GT7pNvf3P9rK9BUBLeOzH19/aCxSNMynU0uXAVVmyB9z6DCV0zxv+Z5PgMpGfOXn9I3TZw7pZ+BOnwSR0iIiKpYsWKFdSqVes/k+ZbX3RM08TPz4/s2bNz5MgR2/ZDhw4RFBSU4rH+2/HTt5cL5Un1t3cYwzB495Xb62PnpuyliB0HTb772bqcJwd0bJSib+cQRfIZ9GphXY67Cf0+SZ3LOyfPmtTtaxIVY13v0ND6uLaUEBhgsGCYYbs6/v58GJfCnx1JeRYLhG+C8V+ZTFlk8vsRx09YmNEpKRcREZEkiY+P58aNG5imaVu+NSFOfHw8P/74I/Xq1bN7zdGjRzl06BAJCQlcu3aNiRMnUqlSJVvi3qBBA2bOnElUVBR79uxh48aN1KlTJ9XrVig3LBgG/Vte5sWqqf72DvViVSgYcBOA9Tuts3anBNM06fmR/Yzrnh4Z82rHwNcNcmWzLn+zEdbvTNnE5uJVk7p9TP4+b12v8DhM7pGybVuzvMG0XrffI2S6yYxwJXDp1eZ98NLwXDQdAP0/NXlnislTb5gENjd5830LP/2u321KUFIuIiIiSTJy5EgqV67Mzp07GTp0KJUrV2bHDuuDpjdv3oyHhwflypWze82lS5cICQmhWrVqtGjRAhcXF4YNG2bb3qVLF3x9falXrx4hISGEhIRQsGDBVKyVVTY/g+bVoUvDa9SrlOpv71CurtClwTXbekpdLf96Hfy027pcNB90eSFF3iZNyOxtMKrT7YS198cmCQkp065RMSYN+5scOGldL5oPlo038PFK+RMeXZoYjO58+326vG/y9Tolb+lJxFmTNiMtVH4bdh/3uGv73+dh+lII7m7y9geWFPscOyvdUy4iIiJJMmzYMLuE+k5VqlThhx9+uKv86aef5ptvvrnvMT09PRk5cmRyhSgPqWnlSKYszc7pi/DtT7D1D5OnSyRfUhcda/LuHcO4P+hm4J4pY14lv6VtPfjoG9h12Dq53ZwV8EbD5H2PhASTVsNMtuy3rufKBivfN8iZNfXaNqQ1XLwKExdYJ0xsPcIkfwBUKpmxf7/p3Y04k/HzYMyXJjE3bpeXLgTdmxnExsGKLSZrd8KNf55COe1biI0zmdnfeuuLPDpdKRcRERERADwywXt3TGrf/9PkvZf0/flw8qx1uW5FaPhssh06zXJ1NZjU7XbiMnCGyfXo5L3KOHyOyQ+/Wpf9fGDF+waF8qRusmQYBhO6GrzRwLp+Mx5aDTO5fF1XVNOqE2esE/UNmXU7Ic/mB6GvX2T7DOj8gkGP5gbLJrhwMdxgai8DN1frfp8vg48WOy72jEZJeRJofgMRERHJ6Do1hsJ5rcvrdsKqrclz3KN/m7Yh8W6uMKmb4TRX2aqXNWxzFJy5BKP+l3xfKn/ebTJijnXZxQW+GWlQpohj2tUwDD7ta/Bcaev6iTPQbZK+QKdFFovJq8NN9v9pXXd1hZ4t4NBcaFMrErd/jaf28TLo+qLBl4PuuB1jqsna7fr9Jgcl5Q/JSfoQERERcTLumWBUx9tfdPp/amKxPNoX7+vRJk0G3L4a1+0lKFHQub5MjX/LINM/ic74efDNhkdPZvb/adJ8iGm7cDSig0Gt8o5t10xuBvOHGvhntq5/tRpW/qbELa2ZvhQ27bUu5w+AnTMNJnV3sf3e7qdVLYOQf0bTJCTAy6Emf5/X7/dRKSkXERERETstakD54tbl34/A7OUPfyyLxaTNSJN9x63rj+eH0DecKyEH6yPShraz1ts0odlgk14fWbgR93AJzR9/mtTsaXL2knU9uAz0fzW5on00gQEG73e9/Tt+a6JJdKwSt7Ti7/MmIdNv/z5mv2fwROHE/58c2dGwTYR5/or1NoWb8fr9Pgol5SIiIiJix8XFPqkKmW5y5SHvDR4y6/YzybP4wndjDPx8nC8pB3jvNesJj1s+/Bqeecvk4Mmkte3eYybV37mdkJcrBt+ONnB1TTvt2r4BVHvKunz8NExe5NBw5B+mafL2JJNrUdb1NxpAjXJJ+9y4ulqHsecPsK7/sgfem66k/FEoKRcRERGRu1Qva9gSyPNXYFhY0r50m6bJiDkmo76wrru4wIJhBsUC007imNpcXAwWDDOY3MPAPZO1bNdhKNfR5PMfEjep3q97TWq8Y3LusnW9XDFYPcnAP3PaalfDMPikt4HLP9nGuK9MLl1T4uZo32zAdpIsIBtM6Ppwn5vsWQwWht6+JWPiAvjhV/1+H5aSchERERG5p/e7Gnj988jij5fArsOJ+9J9I86kwzjrrM63TOpmULdi2kocHcEwrDNa/zbd4PH81rLoWOgwzuTlYSab9pgc/dtk2wGTFVtM5q02GT7bpNkgC4VaWniuq8mFq9bXPf142kzIbylR0KBdPevy1UiYtFBJmyNduW7S7cPbv4MpPQyy+T38Z6dSSfsRNe1Gm5y+oN/xw1BSLiIiIiL3lD/A4L3XrF+6ExKgYX+T46f++0v3mYvWK7lhy26XTXjLmojKbWWKGGybYdCp8e2yheug8tsmRV4xebqzSf13rTNkD/3c5JuN8OeZ2/s+Uwp+/CDtJuS3DGl3+2rq5EXoarkD9Z5qcuafWx4aPWd/K8XD6t4MGj9nXb5wFV4f/egTQzojJeVJoEeiiYiIiLN592Wo8Lh1+dQFqNPn/lfDth+0JpO/7rOue3nA/KEGfV9J24mjo/h4GXz2rgsLQw0yez94f29PqPqkdaKtHycaZPFN++1aINftZ5dfj4YPFugLtSMs2Xj7RFlmb5jWK3keSWgYBp+HGOTObl1fvQ3en//Ih3U6bg/eRe5Fj0QTEUm72rVrx5UrV/j2228Ttf/69eupUaMGly9fJmvWrCkam0h64+lhsHw8VO1mcuAkHP0bqnY3+d8A69VaFxeDUxdMRv7P5LNw6xV1gHw54bvRBuWK60vTg7SoYVD5Cev9vn+cMLl4DbL5QY4s4OdtUCg3PFEYCuchTU3mllgD2hh8vszkZjxMWQy9Wppkz5L+6pFenblo0nnCHcPW3zEIDEi+9s+R1eDLQVC7t/XxfANnmNQqD+X1fz/RlJSLiIgkwmeffcbs2bPZv38/169fVwIvTiVHVoMfP4Aq3UxOnLEm5pXftn7JNwzzrtGEz5WGb0YaBGTTl/LEypPDoFszgIzXZvkDDDo0NPn0u3+uli80GdUp49UzLbJYTNqNuT0PwYtVoW295H+fmuUN+r9qMnYuxCdA6xEmO2aCt6d+z4mh4esiIhlIXFyco0PIsGJiYggODua9995zdCgiDpHvMYMNUwzb88tvuTMh9/WC4R0M1n6ohFzsvffa7XvLpyyCi1c1jD01jPoCVv5mXQ7IBtPfTZ5h6/cS+oZBuWLW5YMnoc9U/Y4TS0m5iMhDslgsjBs3jiJFiuDh4UH+/PkZNWqUbfuePXuoWbMmXl5eZM+enc6dOxMZGQnAypUr8fT05MqVK3bH7NGjB9WqVbOtb9q0ieDgYLy8vAgMDKRHjx5ERUXZthcsWJCRI0fSrl07smTJQqdOnQDo378/xYoVw9vbm6CgIAYPHszNmzft3mvkyJE89thjZM6cmY4dOxISEsJTTz1lt09YWBglSpTA09OTkiVL8sUXX9i2xcXF0a1bN3Lnzo2npycFCxZkzJgx922vdu3a0bRpU0aPHk1AQABZs2YlNDSU+Ph43n33XbJly0a+fPn4/PPP7V73X+0IkJCQQO/evcmaNSvZs2enX79+dz1WyDRNxo8fT1BQEF5eXpQpU4ZFi5L20Nx33nmHt956i0qVKiXpdSIZSYFcBpumGUzva/BCZahYwjoDeOUnYNDrcHS+weC2Bh7uSsjFXv4Ag46NrMuRMTBR95anuMXrrZMEgvWRhHMHG+TMmnL/N90zGXw15PYTGz79DsJ/0e85MTR8XUTSpAoVKnDmzJkH75jMcuXKxbZt2xK173vvvceMGTOYNGkSVapU4fTp0xw4cACA6Oho6tWrxzPPPMPWrVs5d+4cHTt2pFu3bsyePZvatWuTNWtWFi9eTIcOHQBrcrlw4UKGDx8OWJPRunXrMmLECGbNmsX58+fp1q0b3bp1IywszBbHhAkTGDx4MIMGDbKVZc6cmdmzZ5MnTx727NlDp06dyJw5M/369QNg7ty5jBo1imnTplG5cmXmz5/PxIkTKVSokO0YM2bMYOjQoXz88ceULVuW7du306lTJwIDA2nfvj1Tpkxh6dKlLFy4kPz58xMREUFERMR/ttnatWvJly8fGzdu5JdffqFDhw78+uuvBAcHs2XLFhYsWMCbb75JnTp1CAwMfGA7AkycOJHPP/+cWbNmUbJkSSZOnMiSJUuoWbOm7X0HDRrEN998wyeffELRokXZuHEjr732Gjlz5rQ7CSIiD+aeyaDzC9D5BSXekjTvtTaY9YNJ3E34aDH0bmmSIwWTRGe2drvJqyNu31oS2t6gVvmUb+vi+Q0mdYM3J1rf+I2xJntmQ67s+j3/J1MSbdb3FpOqCSZVE8xPv0twdDipKiEhwTx27JiZkOBc9b7F2etvmqnfBnnz5jWBVP/Jmzdvotrg2rVrpoeHhzljxox77vvZZ5+Z/v7+ZmRkpK3shx9+MF1cXMwzZ86YpmmaPXr0MGvWrGnbvnLlStPd3d28dOmSaZqm2aZNG7Nz5852x/3pp59MFxcXMyYmxjRN0yxQoIDZtGnTB7bn+PHjzfLly9vWK1WqZL799tt2+1SuXNksU6aMbT0wMND86quv7Orfu3dv89lnnzVN0zS7d+9u1qxZ07RYLA98f9M0zbZt25oFChSw+wwVL17crFq1qm09Pj7e9PHxMefNm2eaZuLaMXfu3ObYsWNt22/evGnmy5fPbNKkiWmaphkZGWl6enqamzZtsounQ4cO5iuvvGKapmmuW7fOBMzLly/fN/5bv/81a9Y8cF9J35z1b76z1vtOzt4GqVH/rhMTbN+nQz5Ne+2cET4DW/ZZTN/nb7dzu9EJie6rk6P+FovFfCHk9vvX65tgJiQk7v3TAkd8BnSlPAn0SDSR1JMrV640/b5//PEHN27coFatWvfdXqZMGXx8fGxllStXxmKxcPDgQQICAmjdujXPPvssp06dIk+ePMydO5cGDRrg7+8PwPbt2zly5Ahz5861HcM0TSwWC8ePH6dEiRKAdVTBvy1atIgPP/yQI0eOEBkZSXx8PH5+frbtBw8epGvXrnavqVixImvXrgXg/PnzRERE0KFDB9uQeICbN2/aJjdr164dderUoXjx4tSrV49GjRrx/PPP/2e7lSpVCheX23dOBQQEULp0adu6q6sr2bNn59y5c4lqR09PT06fPs2zzz5r2+7m5kaFChVsQ9j3799PbGwsderUsYslLi6OsmXL/me8IiKSvN57zWDmravl30CfVrpanpxW/mbSbLBJVIx1vfFzMCMF7yO/F8MwmNkfnmhncvYSrNgC7003GfeWfs/3o6T8IekjJZKyEjuE3FG8vLz+c7tpmvftAG+VV6xYkcKFCzN//nzeeustlixZYjcs3WKx0KVLF3r06HHXMfLnz29bvjNhBdi8eTMvv/wyoaGh1K1blyxZstiGp98rjjtjvvO9wTqE/dY91BaLhb///tv23uXKleP48eMsX76c1atX07JlS2rXrv2f92pnypTprhjuVXbr/RPTjg9y61g//PADefPmtdvm4eGRqGOIiEjyyPeYQadGJlOXQFQMvD/fZOyb+madHL5YafLGWJP4fx5LWL0sLAg1cHNL/fbN+c9j0uq9a5KQAOPnwWP+Jn1e1u/6XjTRm4jIQyhatCheXl6sWbPmnttLlizJrl277CZl++WXX3BxcaFYsWK2sldffZW5c+cSHh6Oi4sLDRs2tG0rV64c+/bto0iRInf9uLu73ze2X375hQIFCjBw4EAqVKhA0aJFOXHihN0+xYsX57fffrMru/NESEBAAHnz5uXYsWN271uwYEG7+879/Pxo1aoVM2bMYMGCBSxevJhLly49oPUS70HtmCVLFnLnzs3mzZtt2+Pj49m+fbvdMTw8PDh58uRd7RgYGJhssYqISOKEtDZw/+d87MdL4PwVDUd9FKZpMmGeyeujbifkLwXD8vEGXh6OS4JrVzD46J3b7993msmkhfpd34uSchGRh+Dp6Un//v3p168f//vf/zh69CibN29m1qxZALRu3RpPT0/atm3L3r17WbduHd27d6dNmzYEBATYjtO6dWt27NjBqFGjaN68OZ6enrZt/fv359dff+Xtt99m165dHD58mKVLl9K9e/f/jK1IkSKcPHmS+fPnc/ToUaZMmcKSJUvs9unevTuzZs1izpw5HD58mJEjR7J79267q8/Dhg1jzJgxTJ48mUOHDrFnzx6+/vprJk2aBMCkSZOYP38+Bw4c4NChQ3z99dfkypUrWZ/dnZh2fOeddxg7dixLlizhwIEDdO3a1W5W+8yZM9O3b1969erFnDlzOHr0KDt37mTq1KnMmTMn0bGcOXOG/fv3c+TIEcA6Ed+uXbuS9SSEiIgzyPeYQefG1uWoGHh/nhK1h2WxmPT+2KTfJ7fbsGtTWBhq4OnAhPyWt5oajOhwO47eH5t8qMT8Lhq+LiLykAYPHoybmxtDhgzh1KlT5M6dmzfffBMAb29vVq5cyTvvvMPTTz+Nt7c3zZo144MPPrA7RtGiRXn66afZunUrH374od22J598kg0bNjBw4ECqVq2KaZoULlyYVq1a/WdcTZo0oVevXnTr1o0bN27QsGFDBg8ezLBhw2z7tG7dmmPHjtG3b19iY2Np2bIl7dq1s7t63rFjR7y9vZkwYQL9+vXDx8eHokWL2mZw9/X1Zdy4cRw+fBhXV1eefvppli1bZnfP+KNKTDv26dOH06dP065dO1xcXHjjjTd48cUXuXr1qm2fESNG8NhjjzFmzBiOHTtG1qxZKVeuHAMGDEh0LNOnT7fNjA8QHBwMWB8b165du0evrIiIEwlpbTDje5Mbcdar5X1fMVP0cV2OsO+4yYotcPKsyZVIyJUN6j9jEFwGXFweva4xN0zajDRZvOF22ciOBgPaJP4Wr9QwqK2BCQyZZU3Ge31s4uUBXZqknRgdzTBNTV+WWLO+N+k43tpc0/tC5xecZ6CBxWLhxIkTFChQIFm/cKcXzl5/UBtAxm+DOnXqkCtXLrtnkd8po9f/QZy9/s7EWX/XzlrvOzl7G6R2/XtMtvDRYuvyu6/A+Lcc3+aP2gYJCSZLf4EPvzbZ+Pu99ymc13pSom09yPSQ93tfuW7ywnsmP+22rru6wmd9Dd5o+GiJbkp+BkLDTIaFWXMpw4AuL0Dt8gaVSlpHT6QVjvg74PhPvoiIpLro6Gg++OAD9u3bx4EDBxg6dCirV6+mbdu2jg5NREScREhrA49/pkiZugTOXU6/1wovX7feL13kFZOXBt0/IQc4+jd0Gm/y1Bsm63cmvc5nL5nU6Hk7Iff1gvAxj56Qp7Sh7Q36vmxdNk349DtoPsQksLnJCyEWjv6dfn//j0pJeRI478dERDIawzBYtmwZVatWpXz58oSHh7N48WJq167t6NBERMRJ5Mlh0OWfe8ujY2FCOry3fN0Ok7ajLOR9yXpv959nbm8rUQAmdTPYNM1g3/8MvhpiUKv87e37/4Qa75i0Hm7h9IUH1900TeavMSnd1mTXYWtZjiywfopB/WfSdkJ+y/i3DIZ3MHBztS8P3wSV3zbZfTT9fQaSg+4pf0hp6DYNEZEk8/LyYvXq1Y4OQ0REnFz/1gafhZvExlmvlr/7islj/mn/i/a+4yZ9ppqs/O3ubfUqQc8WBs8/bX9vd8mC8Eptg1/3mrwzxWTrAWv5V6th+RaT4W9Aw2ehQK677zmPOGvSfbLJdz/fLsuXE378wODxAmm/vW4xDIPBbeGtJrB+F+w6bPL5Mjh9Ec5eglo9TX6eCsXzp586JQcl5SIiIiIi4hB5chh0ecFk8iKIuQHjvzJ5/+20m5DFx5uMmQvDZ99+/BhAFl94vS681cSgRMH/jv/Z0gabP4VZP0DIdJNL1+Dydeg+2aT7ZOtw9NJBJoVyQ3Y/uHQNvtkIsXG3j9G8Onzc0yAgW9ptq/+SI6tB8+rQvLpBn5dN6r9rsmU/XLgKz/cx+WVq2rrPPKVp+LqIiIiIiDhM/1cNPP+5t3zat9Z7ptOiQxEmVbqZDJl1OyHPHwD/G2hwZonBlHdcHpiQ3+LiYtCpscHBLw1e/dedY5ExsHkfzFsNH39jvZJ+KyF/zB8WDTf4erhLuk3I/80/s8HK9w3KFLGunzwLdfuaXLyaNj8HKUFJuYiIiIiIOEzuHAZvNrEu37panpbE3TSZMM86MduW/dYyV1cY2AYOfGnQpu7DPxM8R1aDuUNc2D7DYEg7aPwcFMx1936ZvaF3S+v7NaueMZLxO2XxNVgxwaBwXuv6/j+hUYhJVEza+iykFA1fFxERkSSZPn06q1ev5s8//2TkyJHUrVsXgPDwcEaOHIm7u7tt36+//ppcuazfMPft28fIkSM5efIkpUqVIjQ0lNy5cwMQGxvLqFGj2LBhA5kzZ6Z79+7Uq1cv9SsnIg7R7xWDT7+z3lv+8RJ4tY5J+eKOTz5/3Gq9l/vgydtlRfPBF4MMKpVMvvjKFTcod0d9I6NNzlyCi9cg7iZUeBy8HjLxTy9yZTdYNREqd7XWffM+aDbYZOkYcM+UseuuK+VJoCe6i4iIQGBgIH369KFUqVJ3batYsSI//fST7edWQh4XF0e/fv14+eWXWbt2LaVLl2bIkCG2102fPp2rV6+ybNkyRo8ezdixYzlx4kSq1UlEHCt3DoOeLazLcTehxRCTK9cd9+X7xBloNsjC831uJ+QuLtC9GeyclbwJ+b34ehsUyWd9n6pljAyfkN8SlMdgxfsGWXyt6yt/g3ZjTCyWjJ2IKSl/SJp9XUREnFWDBg145pln7K6IP8j27dvx8vKiSZMmeHh40KlTJ/bv38/p06cBWLZsGZ07d8bX15cyZcoQHBzMqlWrUqoKIpIGhb5hUKmkdfn4aWg9wiQ+PnWTsYQEmLrUj1JtrZOr3fJcadj2mfW+cR8vJQIpqUwRg/Axt+cZmLcaWg0ziY7NuIm5hq+LiEiG065dO65cucK3336bqP3Xr19PjRo1uHz5MlmzZk3R2DK633//nVq1apEtWzZatWpF8+bNATh27BhFihSx7efl5UW+fPk4duwYPj4+XLx40W57sWLF2Ldv333fJy4ujri4OLsyNze3JJ0ouB+LxWL3r7Nw1nrfydnbwNH1d3OF+UOhfCfrjOPLNkOX900+6W3ilgpZy+Xr8EqoyY/b/G1lAf4w7i14rQ4YRsa/Yuvoz8AtlZ+A+cOg2SBIsMCi9fDzbpNOjU06NYK8OVPuvZO7DVxcHnwdXEm5iIjIA1y6dIkhQ4awbNkyzpw5Q44cOWjatCkjRowgS5Ysjg4vzShXrhzz588nV65c7N+/n759+5I9e3Zq1KhBTEwMPj4+dvv7+PgQExNDdHQ0rq6ueHp62m2Ljo6+73uFhYUxY8YMu7IWLVrQsmXLZKtPREREsh0rPXHWet/J2dvA0fX/qKsHbScEEJ9g8Pky2H0kllHtLlE0780Ue88jp9zo/OFj/Hk2EwCuLiZt61ynR9Mr+HmbnDz5gANkMI7+DAA8mRc+6+lJj2k5iYp14cwlGDEHRv3P5JkSsVQtHUuJ/HH4ellwc4X4BLgZb3AzwSA+HgL8E3g88OZDj3BOrjYoVKjQA/dRUi4ikoHExcUly5VCsXfq1ClOnTrFgAEDqFatGhEREbz55pucOnWKRYsWOTq8NCNv3ry25dKlS/Pyyy+zbt06atSogZeXF1FRUXb7R0VF4eXlhbe3NwkJCcTGxtoS86ioKLy9ve/7Xu3bt6d169Z2Zcl5pTwiIoLAwMBEXeHIKJy13ndy9jZIK/UvUADIBG1HWxOtbYc8aTg4Dz1bQEhr8M+cvO+3aiu0HAHX/zkPmC1zAl8PN6he1g/wS943S+PSymfglnYFoOKTMPRz+O5n61Vzi2mwab8Xm/Z7PfD15YrBgDbQpLJ1ToDEcEQbOL6lRUTSKYvFwrhx4yhSpAgeHh7kz5+fUaNG2bbv2bOHmjVr4uXlRfbs2encuTORkZEArFy5Ek9PT65cuWJ3zB49elCtWjXb+qZNmwgODsbLy4vAwEB69Ohhl9gULFiQkSNH0q5dO7JkyUKnTp0A6N+/P8WKFcPb25ugoCAGDx7MzZv2VxhGjhzJY489RubMmenYsSMhISE89dRTdvuEhYVRokQJPD09KVmyJF988YVtW1xcHN26dSN37tx4enpSsGBBxowZc9/2ateuHU2bNmX06NEEBASQNWtWQkNDiY+P59133yVbtmzky5ePzz//3O51/9WOAAkJCfTu3ZusWbOSPXt2+vXrh/mvmTlN02T8+PEEBQXh5eVFmTJlkpRMly5dmkWLFlGrVi0KFy5MzZo1GTVqFOHh4cTHxyf6OM7GuOPyRFBQEEeOHLGtx8TE8NdffxEUFISfnx/Zs2e3237o0CGCgoLue2x3d3d8fX3tfjw9PXFxcUmWHyDZjpWefpy13mqDtFf/V+u4sPZDgyL/nOuLT4D350PRV2HiAoP4BCNZ3ufn3QYvDrydkD9ZGL4deprqZR3fBs7+Gbj1UzrIhcUjXfhzofWxcUF5Et8P7TgEzQfDs11hw67Ef2aSsw0SQ1fKRSRNqtDJwplLqf++ubLBthmJ+wP63nvvMWPGDCZNmkSVKlU4ffo0Bw4cACA6Opp69erxzDPPsHXrVs6dO0fHjh3p1q0bs2fPpnbt2mTNmpXFixfToUMHwJpcLly4kOHDhwPWZLRu3bqMGDGCWbNmcf78ebp160a3bt0ICwuzxTFhwgQGDx7MoEGDbGWZM2dm9uzZ5MmThz179tCpUycyZ85Mv379AJg7dy6jRo1i2rRpVK5cmfnz5zNx4kS7IVYzZsxg6NChfPzxx5QtW5bt27fTqVMnAgMDad++PVOmTGHp0qUsXLiQ/PnzExER8cChXmvXriVfvnxs3LiRX375hQ4dOvDrr78SHBzMli1bWLBgAW+++SZ16tQhMDDwge0IMHHiRD7//HNmzZpFyZIlmThxIkuWLKFmzZq29x00aBDffPMNn3zyCUWLFmXjxo289tpr5MyZ0+4kSFJcvXoVPz8/3FLjRsc0Jj4+noSEBEzTJD4+nhs3bpApUyY2b95MiRIl8Pf358CBAyxYsIBevXoBUL58eWJiYggPD6du3bq239etR6I1aNCAmTNnMmrUKI4dO8bGjRttv2MRcU5Vyxjsng1jvjQZ95V1VvbL16HfJyYL18G8IVAk38NPurbjoEnj96yPYQNoUgX+NwAunk9IngpIssr3mEHoGwbD2pv8cQJ+2QMR50yuR8PNeHDPBJlcIZMbmMCKLdakHGDbAajZ0+SFyiafhxhkz3Lvz018vMnoL+HFiqk8mZ8piTb9O4tJ1QSTqgnmjPAER4eTqhISEsxjx46ZCQnOVe9bnL3+ppn6bZD3pQTb/7fU/Mn70v3rd2cbXLt2zfTw8DBnzJhxz30/++wz09/f34yMjLSV/fDDD6aLi4t55swZ0zRNs0ePHmbNmjVt21euXGm6u7ubly5dMk3TNNu0aWN27tzZ7rg//fST6eLiYsbExJimaZoFChQwmzZt+sD2HD9+vFm+fHnbeqVKlcy3337bbp/KlSubZcqUsa0HBgaaX331lV39e/fubT777LOmaZpm9+7dzZo1a5oWi+WB72+aptm2bVuzQIECdp+h4sWLm1WrVrWtx8fHmz4+Pua8efNM00xcO+bOndscO3asbfvNmzfNfPnymU2aNDFN0zQjIyNNT09Pc9OmTXbxdOjQwXzllVdM0zTNdevWmYB5+fLl+8Z/5+//woULZv78+c2BAwcmqu4ZzdChQ83y5cvb/WzdutX84IMPzNq1a5tVqlQxX3zxRdvv8Za9e/earVq1Mp977jmzY8eO5qlTp2zbYmJizIEDB5pVqlQxGzRoYC5fvjy1q2XjrH/znbXed3L2NkjL9f/ztMVsOyrBNIJv99m+zyeYX65MXB/0b7uPWMwcjW4fq17fBPNGnCVNt0FqyEj1t1gs5vebLOaT7ey/65Vsk2D+de7uz82NOIvZbJB1nwodosxrkanXBs53ej+Z6JFoIikrV7a0/b5//PEHN27coFatWvfdXqZMGbuJrSpXrozFYuHgwYMEBATQunVrnn32WU6dOkWePHmYO3cuDRo0wN/fOuvr9u3bOXLkCHPnzrUdwzRNLBYLx48fp0SJEgBUqFDhrvdftGgRH374IUeOHCEyMpL4+Hj8/G7fF3fw4EG6du1q95qKFSuydu1aAM6fP09ERAQdOnSwDYkHuHnzpm128nbt2lGnTh2KFy9OvXr1aNSoEc8///x/tlupUqXshnIFBARQunRp27qrqyvZs2fn3LlziWpHT09PTp8+zbPPPmvb7ubmRoUKFWxD2Pfv309sbCx16tSxiyUuLo6yZcv+Z7z3cu3aNRo2bEjJkiUZOnRokl+fEQwbNoxhw4bdVV6hQgXblfF7KVWqFPPnz7/nNk9PT0aOHJlcIYpIBlMgl8HsAQbdm5m8Empy+C+IjIHXRpr8uM3k454Gvt6J+4K+eZ9Jg34ml69b16s8CYuGG7hnMjL87OrOxDAMGj4L9SrCl6ug36cm5y7D/j+hytsmqydB4bzWz0xUjEmrYSY//Gp97e5jHuw8DMFPpU6sDk3KL1++zLBhw9i2bRsBAQGEhIRQsWLFu/aLjY1l1KhRbNiwgcyZM9O9e3fq1avngIhFJLUkdgi5o3h5/ffkIqZp2t1Pe6db5RUrVqRw4cLMnz+ft956iyVLltgNS7dYLHTp0oUePXrcdYz8+fPblv89o/XmzZt5+eWXCQ0NpW7dumTJksU2PP1ecdwZ853vDdYh7JUqVbKV/f3337b3LleuHMePH2f58uWsXr2ali1bUrt27f+8VztTpkx3xXCvslvvn5h2fJBbx/rhhx/sJiID8PDwSNQxbomMjKR169b4+vqyZMmSu2IXEZGUVb64wY6Z0O1DkzkrrGVzVsCv+0wWDIOniv5337Bii0nzISZRMdb1SiXh+7GGnj2egbm6GrStD1XLQO1eJsdPw59n4Nm3TN5+EQ7/ZfLjNjh32bq/pztM73GOKk8GpFqMDv3WO27cOHLmzMmaNWvo0aMHISEhXLt27a79pk+fztWrV1m2bBmjR49m7NixnDhxwgERi4hYFS1aFC8vL9asWXPP7SVLlmTXrl12k7L98ssvuLi4UKxYMVvZq6++yty5cwkPD8fFxYWGDRvatpUrV459+/ZRpEiRu37+a4bpX375hQIFCjBw4EAqVKhA0aJF7/qbWbx4cX777Te7sm3bttmWAwICyJs3r+3Z0rd+ChYsaHffuZ+fH61atWLGjBksWLCAxYsXc+lS8k0G8KB2zJIlC7lz52bz5s227fHx8Wzfvt3uGB4eHpw8efKudgwMDEx0LNeuXaNt27a4u7uzdOlSu8d3iYhI6vH1Npg9wIUvBhn4/nOO/FAEVHrT5MOFJpHRd1/tvnzdpM/HFuq/ezshr1kOfvzAIIuvEnJnEJTH4OepBqX/+Rpz/goMCzOZ++PthNzXC34YB1WfiE3V2ByWlEdHR7NhwwbefPNNPD09qV69OoULF2bjxo137bts2TI6d+6Mr68vZcqUITg4mFWrVjkgahERK09PT/r370+/fv343//+x9GjR9m8eTOzZs0CoHXr1nh6etK2bVv27t3LunXr6N69O23atCEg4PaZ19atW7Njxw5GjRpF8+bN7RK9/v378+uvv/L222+za9cuDh8+zNKlS+nevft/xlakSBFOnjzJ/PnzOXr0KFOmTGHJkiV2+3Tv3p1Zs2YxZ84cDh8+zMiRI9m9e7fd1edhw4YxZswYJk+ezKFDh9izZw9ff/01kyZNAmDSpEnMnz+fAwcOcOjQIb7++mty5cplG96eHBLTju+88w5jx45lyZIlHDhwgK5du9rNap85c2b69u1Lr169mDNnDkePHmXnzp1MnTqVOXPmJCqO69evU69ePaKjo5kxYwbXrl3jzJkznDlzhoQETQgkIuIIrz1vsGOmQbl/znXH3YReH5tka2TydGcLNd6x8HRnC8VetZCjsckHC2+/tmlV+GGcQeZEDnmXjCFPDoMNHxlUKmlf7u0JzarB9pkG1ZN+Z9sjc9jw9ZMnT+Lr60uOHDlsZUWLFuXYsWN2+127do2LFy9SpEgRW1mxYsXYt2/ffY8dFxdHXFycXVlyPLv0zltMTIuFf0ZEOoVbwz8tzlTpOzh7/UFtAHe3wcCBA3F1dWXIkCGcOnWK3Llz06VLFywWC56enixfvpxevXrx9NNP4+3tzUsvvcTEiRPt2rBw4cI8/fTTbN26lQ8++MBuW+nSpVm3bh2DBg2iatWqmKZJ4cKFadmypd1+t+4zv6Vx48b07NmTbt26cePGDRo0aMCgQYMIDQ217ffKK69w9OhR+vbtS2xsLC1atKBt27Zs3brVts8bb7yBp6cnEydOpF+/fvj4+FC0aFHeffddLBYL3t7ejBs3jsOHD+Pq6srTTz/N999/b9dGdzJN865Y7xX/nWWJacdevXpx6tQp2rVrh4uLC+3bt6dp06ZcvXrVtk9oaCg5c+ZkzJgxHDt2jKxZs1K2bFnee+89LBaL3e/2XrFv3bqVLVu2ANiNdAA4evQoBQsWvOs1iZHYR6WIiMi9FQ002DQN3vvMZNI/SffNeOts2/fingnGdTHo0RxcXJSQO6NsfgY/fWydnf38FShRACo8DpncrJ8HR8wrYJim6ZDZDHbu3EloaCjffvutrWzq1KlERkbSv39/W9mZM2do0qSJ7csQwJIlS1i/fj2TJ0++57GnT5/OjBkz7MpatGhBy5YtHynmeet8GTg7OwDjOlygRXDUA14hIpJ+tGnThpw5c/LBBx84OhSnceetAJJ2WCwWTpw4QYECBZzqxImz1vtOzt4G6b3+P/1u8tVqk9Xb4OgpME1wcbEOSS6UG2qUhW4vGbbJve4lvbfBo3L2+oNj2sBhV8q9vLzs7hEEiIqKumvyJG9vbxISEoiNjbUN64yKisLb2/u+x27fvj2tW7e2K0uOK+W9W0OXlyz89fdfFA3Kh6dHjge/KIOwWCxEREQQGBjolP9Bnb3+oDaAjNUG0dHRTJ8+neeffx5XV1fmz5/PL7/8wsqVKylQoMA9X5OR6v8wnL3+IiJpXdUyBlXLWBPum/Em8QnWSbsSOzGoiKM4LCnPnz8/kZGRXLhwwTaE/fDhwzRp0sRuPz8/P7Jnz86RI0dsj805dOgQQUFB9z22u7v7Iyfg9+LpYR3ycu2yiaeHi1N+KXNxcc563+Ls9Qe1AWSMNnB1dWX58uWMGjWKGzduULx4cRYvXvzAR5pBxqj/o3D2+ouIpAeZ3Awy6eHPkk447FuFt7c3wcHBTJ8+ndjYWDZs2MDRo0cJDg6+a98GDRowc+ZMoqKi2LNnDxs3brzrebMiIpJ4Xl5erF69mkuXLhEVFcWOHTt46aWXHB2WiIiIiNNx6Kn+kJAQzp49S61atZg8eTJjxozBz8+P5cuX293/3aVLF3x9falXrx4hISGEhIQ89KQ6IiIiIiIiImmFQwd1+Pv7M2XKlLvK69evT/369W3rnp6ejBw5MjVDExEREREREUlxuilORERERERExEGUlIuIiIiIiIg4iJJyEREREREREQdRUi4iIiIiIiLiIErKRURERERERBxESbmIiIiIiIiIgygpFxEREREREXEQJeUiIiIiIiIiDqKkXERERERERMRBDNM0TUcHISIiIiIiIuKMdKVcRERERERExEGUlIuIiIiIiIg4iJJyEREREREREQdRUi4iIiIiIiLiIErKRURERERERBxESbmIiIiIiIiIgygpFxEREREREXEQJeUiIiIiIiIiDqKkXERERERERMRBlJSLyEM5deoUzz33nKPDEBERkRSivl4kdTh1Uh4XF0doaCgNGjSgWrVqdO7cmSNHjti2z549m9q1a1OzZk0mT56MaZoAxMfH8+6771K/fn0qVKjAhQsX7I7bsmVLqlatavt5+umn+fLLL1O1bknRuHFjqlWrRmxsrK0sMjKSypUr06xZMwdGlvKcue7/pXHjxuzZs8fRYaS6HTt20K5dO6pVq0atWrXo0qULf//9t6PDShWNGzemUaNG3Lx501Y2evRopk+f7sCoUk5K/f3/+++/efvtt6levTr169cnLCwsVesld1Nff5sz93nOXPf7UV+vvh4ydl8P6ae/d+qkPCEhgbx58xIWFsbatWsJDg6mT58+APz8888sWrSI2bNns3DhQn7++WeWLl1qe225cuUYP378PY+7cOFCfvrpJ3766SfCw8Nxc3OjWrVqqVKnh5U9e3Y2btxoW1+3bh0BAQFJPk58fHxyhpUqkqvukr5FRkbSt29f2rVrx7p16wgPD+fll1/G1dXV0aGlmujoaMLDwx0dRqpIqb//EyZMIG/evKxevZqZM2eyYMECfvvtt1Spk9yb+np76u/V3zsz9fXO1ddD+unvnTop9/LyomPHjgQEBODq6kqrVq04deoUV65cYdmyZTRv3px8+fKRI0cOXnvtNZYvXw6Am5sbr7zyCk888cQD32P16tU8/vjjBAYGpnR1HkndunVt9QNYvnw5devWta3PnDmTRo0aUa1aNdq3b8/hw4dt2xo3bsycOXN46aWXaNGiRarGnRwetu7Lly+nS5cudscaNGhQmr9SkhTDhg1j9uzZtvXw8HC6d+/uuIBS0IkTJ/D09KR69eq4uLjg7e1NjRo1yJUrFwkJCUyfPp1GjRpRt25dJk2aZPtCOn36dAYNGkTPnj2pVq0aXbt25eLFiw6uzcN59dVXCQsLu+eX7fnz59OkSRNq167NkCFDiIyMBOCtt97i+++/t+0XHR1NcHBwmm+DlPr7f/r0aZ5//nnc3NzImzcvTz31FMeOHUvNqsm/qK+3p/5e/f2/qa9XX39LRuvrIf30906dlP/b7t27yZYtG1mzZuX48eMUKVLEtq1YsWIP1dDLly+nXr16yRlmiqhUqRIHDx7k6tWrXLhwgYiICMqVK2fbXqhQIb744gvWrFlDpUqVGDp0qN3rN2zYwMyZM5k/f35qh/7IHrbuNWrU4MCBA5w/fx6A2NhYfvrpJ55//nmH1EMeTYECBYiNjWXUqFFs2rTJ1hEBzJ07l99//50vv/ySRYsWceDAARYtWmTbvmbNGl5++WVWrVpFQEAA48aNc0QVHlmlSpXImTPnXWfQf/31V+bMmcOHH35IeHg4MTExTJo0CYA6deqwevVq274bN26kVKlSZM+ePVVjf1TJ9fe/RYsWrFy5kri4OE6ePMmePXuoUKFCSoUtD8GZ+3pQf6/+3rmpr3fuvh7Sbn+vpPwfkZGRjB49mq5duwLWM0C+vr627T4+PkRHRyfpmKdOnWLfvn3UqVMnWWNNCa6urlSrVo3Vq1ezatUqateujWEYtu21atXC398fNzc329njO9vj1VdfJVu2bHh4eDgi/EfysHX39PQkODiYVatWAdY/UI8//jiPPfaYo6oij8DX15fPPvuM2NhYQkNDqVOnDoMHDyYqKorvvvuOrl27kjVrVjJnzsxrr73G2rVrba8tV64czzzzDB4eHrz55pts2LAhXQ7tBOjcufNdZ9BXrVpFs2bNKFSoEF5eXrz99tu2z33NmjXZtm0b169fB+DHH39MF3/z7pScf//LlCnDnj17qFq1Ki+99BJNmjSx6/DFsZy9rwf19+rvnZv6eitn7Oshbff3bg/9ygzkxo0b9OnThypVqtCkSRMAvL297c6eRUVF4e3tnaTjrlixgooVK5ItW7ZkjTel1K9fn48//pjY2FgGDhxo+48HsGTJEubNm8fZs2cxDAPTNLl69aqtTdJ7x/SwdW/QoAGffvoprVu3ZsWKFenmSoncW5EiRRgxYgQAf/zxByEhIXz++eecOXOGt99+2/blzTRNu8/8v5dN0+TKlSvkyJEjdSuQDJ555hly5MhhN0ztwoULlC9f3raeO3duYmJiiIyMJGvWrJQtW5b169dTo0YNtm7dyuDBgx0R+kNJzr//CQkJvPPOO7z++us0b96cc+fO0bNnT4KCgqhdu3aK1UESR339berv1d87M/X1ztfXQ9rv753+Snl8fDwDBgwgZ86c9OzZ01ZeqFAhu5n5Dh06RFBQUJKOvWLFCurXr59coaa4J598knPnzhETE0Px4sVt5adOnWLSpEkMHz6c9evXs2LFClxcXGyzEwJ2Z5rTo4ete8WKFTlz5gx//PEH27Zto1atWo6qQorw8vKym6k2Pdw7lFxKlChBjRo1OHr0KI899hgzZ85k/fr1rF+/ng0bNvD111/b9j137pzdsmEYZM2a1QFRJ49OnTrZnUHPkSMHZ86csW0/c+YMnp6etrPLt4a1bdiwgTJlyqSbuif33/9r165x/vx5mjdvjpubG3ny5KF69eps3749JcKXJFBfb0/9vfr7O6mvV18PGbevh/TR3zt9Uj5q1Chu3LjBsGHD7DqaBg0asHjxYv7++28uXLjA3Llz7TrduLg4bty4AcDNmzdty7ccPHiQ06dPU7169VSpR3KZMGECY8aMsSuLjo7GMAyyZMlCfHw806dPt+ugM4qHqburqyvPP/88Q4YMoUKFCvj5+aV22CmqWLFibNy4kcjISP766y+7GSkzmj///JO5c+fa7hk8ceKE7Z6pJk2aMG3aNC5cuIBpmpw6dcruD+/OnTvZsmULcXFxfPbZZwQHB+Pmln4HIj377LNky5aNDRs2AFC7dm2++eYb/vzzT2JiYpg2bZrdvZQ1atRg586dLFmyJF0NZ0vuv//+/v4EBATw7bffYrFYOHv2LBs2bKBw4cKpWzG5i/r6u6m/V39/i/p69fWQcft6SB/9ffr9JCWD06dPEx4ejoeHBzVq1LCVT5kyhSpVqnD48GFef/11LBYLTZs25YUXXrDt06xZM06fPg1YZyMF2LZtm237ihUrqFatGl5eXqlUm+RRtGjRu8qKFCnCiy++yMsvv2ybwTBTpkwOiC5lPWzd69evz7x58+jUqVNqhZoqDMOgQYMGbN68mYYNG1KwYEHq1q3L3r17HR1aivD29mb37t3873//IyoqiixZslCrVi3atWuHYRjEx8fToUMHrly5Qq5cuWjbtq3ttTVr1mTevHm8++67lCpVyjYsLj3r1KkTPXr0AKBy5cq0adOGHj16EBUVxXPPPUevXr1s+2bOnJny5cvz66+/8sEHHzgq5CRJqb//48aNY+LEiXz00Ud4enry/PPP8+KLL6ZizeTf1Nffm/p7e87a36uvV1+fkft6SD/9vWFmxFOgIqnowoULNGvWjJUrV+Lp6enocJJFrVq1CAsLI3/+/I4OJc2bPn06Fy9eZMCAAY4ORUREUlBG6+/V1yee+npJaU4/fF3kUVgsFubOnUudOnUyRAcNt88A5s6d28GRiIiIpA0Zrb9XXy+Stjj18HWRR/X888/j5+fHtGnTHB1Kshg1ahSbN29m4MCBGXLIooiIyMPISP29+nqRtEfD10VEREREREQcRMPXRURERERERBxESbmIiIiIiIiIgygpFxEREREREXEQJeUiIiIiIiIiDqKkXERERERERMRBlJSLpBPbtm2jQoUKVKhQgVOnTjk6HBEREUlm6utFnJOeUy6SBjRu3JjTp0//5z5Vq1aldOnSALi7u6dGWA+0bds23nzzTQCWLl1Knjx5HByRiIhI2qS+XkTuR0m5SBpQvHhxsmfPDsC5c+c4d+4cAMWKFbN1ytWqVaNp06aOClFEREQegfp6EbkfwzRN09FBiMht06dPZ8aMGYD9Gel7nakeNmwY33//Pblz56ZLly588sknREZG8sILL/D2228zdepUli5dSubMmWnXrh3Nmze3vc/58+eZNm0av/76K1euXCEgIIDGjRvTrl073Nys5+v27NnDtGnTOHToENHR0fj7+1O8eHH69OnDDz/8YIvzTo0aNWLYsGF88cUXLF++nDNnzhAVFYWfnx9PPfUU3bp1o0CBAgCEh4cTGhoKwNixY/n88885ceIE5cuXJzQ0lPXr1zNz5kxiY2OpU6cOffv2tcVWoUIFAHr27Mn+/fv56aef8PT0pFmzZnTp0gXDMFLi1yMiIvLI1Nerrxe5k+4pF8kALly4wNixY8mUKRNRUVHMmzePNm3asHTpUnx9fTlz5gzjx4/n+PHjAFy5coV27doRHh5OTEwMhQoV4syZM3z66aeMGjUKAIvFQs+ePdm6dStubm4UKlSImzdv8tNPP3HmzBkCAgIoVKiQLYZixYpRunRp8uXLB8D27duJiIgge/bsFCxYkGvXrrFu3Tq6du3KjRs37qrD0KFDiYuLIy4ujk2bNtG5c2fGjRuHh4cHV69eZdGiRXz33Xd3vW7atGns3LmTzJkzc/nyZWbOnMmCBQtSoplFREQcRn29+nrJuJSUi2QAN2/e5OOPP+abb74hICAAgIiICObNm8eiRYvw8PDAYrGwfft2ABYuXMjZs2fJnj073377LfPmzWPcuHEAfP/990RERHDt2jWuXr0KQFhYGF999RU//vgjCxYsICgoiKZNm9K/f39bDO+//z6zZ8+mY8eOAHTv3p1169bx9ddfs2DBAqZMmQLA2bNn+f333++qwxtvvMGiRYuoV68eAMePH2fo0KF88803PPXUU4D1CsK/lSpVivDwcJYuXUrZsmVt8YqIiGQk6uvV10vGpXvKRTKAW8PFAHLlysXZs2cpXLiwbTicv78/Z86c4dKlSwDs27cPgIsXL1KnTh27Y5mmyd69e6lfvz5PPvkku3fvpnnz5gQGBlK4cGGqVKli60z/y5kzZxg9ejRHjhwhOjqaO++UOX/+/F37BwcHA5A7d25bWdWqVQHImzcvu3btssV/p1q1atmGudWqVYudO3dy8eJFLl++jL+//wPjFBERSQ/U16uvl4xLSblIBuDj42NbdnV1vavs1j1XtzrLW//6+PjYDUu7xdPTE7AOF1uxYgW///47x48fZ82aNaxatYoLFy7w+uuv3zeev/76i759+3Lz5k18fHwoUaIE8fHxHDp0CLAOl7tfHW7FD+Dr63vP+EVERJyN+nqRjEtJuYgTKlWqFJs2bcLV1ZXRo0fbzrJHRUWxbt06atSogWma7N69m8aNG9tmgh0+fDhLly5l586dvP7667YOHSAmJsa2fPDgQW7evAnARx99xJNPPsnKlSsZOHBgstdlzZo1tklt1q5dC0D27Nl15lxERJya+nqR9ENJuYgTatmyJd999x3nzp2jWbNmFCpUiKioKM6ePUt8fDyNGjUiISGBrl274uPjQ0BAAIZh2CaPKVKkCAD58uXDzc2N+Ph4unbtSu7cuXnttdcoUqQIrq6uJCQk0L17d3LlysXFixdTpC4HDhygcePGGIZhe7xM27ZtU+S9RERE0gv19SLphyZ6E3FC/v7+hIWF0bhxY7JkycLRo0e5ceMGZcuWpXfv3oB1aFmzZs3IkycP586d46+//iJ37ty0adOGTp06AZA1a1b69u1LQEAAly5dYu/evVy8eJGCBQsyePBg8ubNS3x8PFmzZrXN9JrcunbtSoUKFYiMjCRLliy88cYbvPzyyynyXiIiIumF+nqR9EPPKReRdOnWs0uHDh1K48aNHRyNiIiIJDf19eIsdKVcRERERERExEGUlIuIiIiIiIg4iIavi4iIiIiIiDiIrpSLiIiIiIiIOIiSchEREREREREHUVIuIiIiIiIi4iBKykVEREREREQcREm5iIiIiIiIiIMoKRcRERERERFxECXlIiIiIiIiIg6ipFxERERERETEQf4Ps3aUJfxdQREAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "covs2 = compute_moving_average_metrics(hfcs2, metrics.ic)\n", + "widths2 = compute_moving_average_metrics(hfcs2, metrics.iw)\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(12, 4.3))\n", + "covs.plot(ax=ax1, label=\"coverages model 1\")\n", + "covs2.plot(ax=ax1, label=\"coverages model 2\")\n", + "ax1.set_ylabel(\"Ratio covered [-]\")\n", + "ax1.set_title(\"Moving 4-week average of Interval Coverages\")\n", + "\n", + "widths.plot(ax=ax2, label=\"widths model 1\")\n", + "widths2.plot(ax=ax2, label=\"widths model 2\")\n", + "ax2.set_ylabel(\"Width [kWh]\")\n", + "ax2.set_title(\"Moving 4-week average of Interval Widths\")\n", + "\n", + "bts = pd.concat([bt, bt2], axis=0).round(3)\n", + "bts.index = [\"Model 1\", \"Model 2\"]\n", + "bts" + ] }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.16" + { + "cell_type": "markdown", + "id": "a451393c-35a3-4af9-81e6-48e197e74b9e", + "metadata": {}, + "source": [ + "Stable coverage over time for both models, but consistently lower interval widths for Model 2 -> we can clearly say that Model 2 is the winner (through **lower uncertainty**)." + ] }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": { - "0315f3b861154f7ea31e69b8327b1403": { + { + "cell_type": "markdown", + "id": "49feed57-19b9-42d2-bb88-201c56034e96", + "metadata": {}, + "source": [ + "### Example 2: Multi-horizon forecasts\n", + "\n", + "Multi-horizon forecasts are supported out of the box. Simply set `n>1` (or `forecast_horizon`), and the model generates calibrated prediction intervals for each step." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9816887f-095e-44d8-afd2-67ced7698a37", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5581bbe9a69240718e7e746c28ccbb5f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "historical forecasts: 0%| | 0/696 [00:00" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "multi_horizon = 24\n", + "pred = cp_model.predict(n=multi_horizon, series=cal, **pred_kwargs)\n", + "\n", + "# plot\n", + "ax = series[pred.start_time() - 7 * 24 * series.freq : pred.end_time()].plot(\n", + " label=\"actual\"\n", + ")\n", + "pred.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "9970b109-f4c7-4784-999c-a47af6c23d3c", + "metadata": {}, + "source": [ + "Oh, why do we have such large intervals now? It's because we used Model 1 (the worse one) that was trained to predict only the next hour. Then under the hood we perform auto-regression to generate the 24-hour forecasts on the calibration set. Consequently, this results in larger errors / non-conformity scores the further ahead we predict, and ultimately in higher model uncertainty.\n", + "\n", + "We can perform much better if we use a base-forecaster that was trained on predicting the next 24 hours directly:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "db681fd0-5cca-435a-b4bb-72d1cb97aa7a", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6b1cccc2e3bd441382af4022099b735e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "historical forecasts: 0%| | 0/1 [00:00" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "multi_horizon = 24\n", + "\n", + "model = LinearRegressionModel(lags=input_length, output_chunk_length=multi_horizon).fit(\n", + " train\n", + ")\n", + "cp_model = ConformalNaiveModel(model=model, quantiles=quantiles, cal_length=four_weeks)\n", + "\n", + "pred = cp_model.predict(n=multi_horizon, series=cal, **pred_kwargs)\n", + "\n", + "# plot\n", + "ax = series[pred.start_time() - 7 * 24 * series.freq : pred.end_time()].plot(\n", + " label=\"actual\"\n", + ")\n", + "pred.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "3138c737-2b42-48c9-812a-05fd0c42b963", + "metadata": {}, + "source": [ + "### Example 3: Multi-horizon Forecasts on a Scheduled Basis with valid Coverage\n", + "\n", + "But what if we want to apply multi-horizon forecasts on a scheduled basis?\n", + "\n", + "E.g. we want to make a one-day (24 hour) forecast every 24 hours.\n", + "\n", + "By default, the calibration set considers all possible historical forecasts on the calibration set (`cal_stride=1`).\n", + "This would use examples generated outside our 24-hour schedule, and might lead to invalid coverages.\n", + "\n", + "Setting `cal_stride=24` will extract the correct examples." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "f616f864-2ab8-4d82-8a0e-90da8d43d640", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "03f79ddd66f84399aaa02edd0f89429a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "historical forecasts: 0%| | 0/1 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IntervalCoverageWidth
00.90.9022834772.75975
\n", + "" + ], + "text/plain": [ + " Interval Coverage Width\n", + "0 0.9 0.902283 4772.75975" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# conformal model\n", + "cp_model = ConformalNaiveModel(\n", + " model=model,\n", + " quantiles=quantiles,\n", + " cal_length=100,\n", + " cal_stride=multi_horizon, # stride for calibration set\n", + ")\n", + "\n", + "hfcs = cp_model.historical_forecasts(\n", + " series=cal_test,\n", + " forecast_horizon=multi_horizon,\n", + " start=test.start_time(),\n", + " last_points_only=False, # return each multi-horizon forecast\n", + " stride=multi_horizon, # use the same stride for historical forecasts\n", + " **pred_kwargs,\n", + ")\n", + "\n", + "# concatenate the forecasts into a single TimeSeries\n", + "hfcs_concat = concatenate(hfcs, axis=0)\n", + "plot_historical_forecasts(hfcs_concat)\n", + "\n", + "bt = cp_model.backtest(\n", + " cal_test,\n", + " historical_forecasts=hfcs,\n", + " last_points_only=False,\n", + " metric=[metrics.mic, metrics.miw],\n", + " metric_kwargs={\"q_interval\": q_interval},\n", + ")\n", + "pd.DataFrame({\"Interval\": q_range, \"Coverage\": bt[0], \"Width\": bt[1]})" + ] + }, + { + "cell_type": "markdown", + "id": "bfa1fa34-aa8e-433d-8998-612daceb22b8", + "metadata": {}, + "source": [ + "Great, we also achieve valid coverage when applying our model only once per day.\n", + "\n", + "Since we have multi-horizon forecasts, it's also important to check the coverage and width for each step in the horizon:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "db5a32f3-0a21-4be3-b23b-09647432f921", + "metadata": {}, + "outputs": [], + "source": [ + "def compute_hfc_horizon_metric(metric=metrics.ic):\n", + " # computes the metric per historical forecast, horizon and component with\n", + " # shape `(n forecasts, horizon, n components, 1)`\n", + " residuals = cp_model.residuals(\n", + " cal_test,\n", + " historical_forecasts=hfcs,\n", + " last_points_only=False,\n", + " metric=metric,\n", + " metric_kwargs={\"q_interval\": q_interval},\n", + " values_only=True,\n", + " )\n", + " # create array and drop component and sample axes\n", + " residuals = np.array(residuals)[:, :, 0, 0]\n", + "\n", + " # compute the mean over all forecasts (365 1-day forecasts) for each horizon\n", + " return np.mean(residuals, axis=0)\n", + "\n", + "\n", + "covs_horizon = compute_hfc_horizon_metric(metrics.ic)\n", + "widths_horizon = compute_hfc_horizon_metric(metrics.iw)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "699c9790-2fb2-445e-8983-0a3174ff23c5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax1, ax2) = plt.subplots(nrows=2, figsize=(6, 8.6), sharex=True)\n", + "\n", + "horizons = [i + 1 for i in range(24)]\n", + "ax1.plot(horizons, covs_horizon)\n", + "ax2.plot(horizons, widths_horizon)\n", + "\n", + "ax1.set_ylabel(\"coverage ratio [-]\")\n", + "ax1.set_title(\"Interval coverage per step in horizon\")\n", + "\n", + "ax2.set_xlabel(\"horizon\")\n", + "ax2.set_ylabel(\"width [kWh]\")\n", + "ax2.set_title(\"Interval width per step in horizon\");" + ] + }, + { + "cell_type": "markdown", + "id": "785c893b-ae78-48f4-982a-46ed0e5df748", + "metadata": {}, + "source": [ + "The coverages are valid for all steps in the horizon and range between 89% and 92%.\n", + "\n", + "In general, the widths increase with higher horizon. After horizon 16 they drop again, due to the nature of the target series (low Electricity consumption during the night -> lower uncertainty.)" + ] + }, + { + "cell_type": "markdown", + "id": "b6563158-d607-4991-bec9-bbadc2a69326", + "metadata": {}, + "source": [ + "### Example 4: Conformalized Quantile Regression\n", + "\n", + "Finally, let's check out an example of our `ConformalQRModel`. The API is exactly the same. \n", + "\n", + "The only difference is that it requires a **probabilistic** base forecaster.\n", + "\n", + "Let's use a linear model with quantile regression and perform the same single step forecast as in example 1." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "59a7d058-241b-4fe3-87d1-baf77b3638a0", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ec085a67dc854b55a80d5ab3f9256734", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "historical forecasts: 0%| | 0/1 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IntervalCoverageWidth
00.90.900241770.154514
\n", + "" + ], + "text/plain": [ + " Interval Coverage Width\n", + "0 0.9 0.90024 1770.154514" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABTQAAAG/CAYAAABmL1gGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydeXwU9f3/n5/ZI7u5SSDcV0BQBBSp4o2oVEWtR61nq2Kttra/Vr9Vq209sNaq1dYeWlvP1npWRUURFUUOBeW+75CEkIPcx2Y3e8zn98fMzs4mmwPYJICfp4/I7sxnPvOZz87xmdfnfQgppUShUCgUCoVCoVAoFAqFQqFQKA4BtN5ugEKhUCgUCoVCoVAoFAqFQqFQdBUlaCoUCoVCoVAoFAqFQqFQKBSKQwYlaCoUCoVCoVAoFAqFQqFQKBSKQwYlaCoUCoVCoVAoFAqFQqFQKBSKQwYlaCoUCoVCoVAoFAqFQqFQKBSKQwYlaCoUCoVCoVAoFAqFQqFQKBSKQwYlaCoUCoVCoVAoFAqFQqFQKBSKQwYlaCoUCoVCoVAoFAqFQqFQKBSKQwYlaCoUCoVCoVAoFAqFQqFQKBSKQwYlaCoUCXjxxRcRQlh/TqeTIUOGMHPmTPbs2dMjbRgxYgTXX3+99f3zzz9HCMHnn3++T/V8+eWX3H///dTV1bVZd8YZZ3DGGWccUDsPdebOncv999+fcJ0Qgp/97Gfd3oaamhquvPJK8vLyEEJw8cUXW/tvr237wyuvvMITTzzR5fJPPfUUL774YtL2fzhQWFiIEILHHnust5uiUCgUim8gaoz6zeFgGKMmm9LSUu6//37WrFnTZt3999+PEKJH2tETY9yOjrW72bRpE/fffz+FhYU9vm+FoidRgqZC0QEvvPACS5cu5ZNPPuFHP/oRr776Kqeddho+n6/H23LcccexdOlSjjvuuH3a7ssvv2TWrFkJB4tPPfUUTz31VJJaeGgyd+5cZs2a1att+N3vfsfs2bP585//zNKlS3n00UcBWLp0KTfeeGPS9qMETYVCoVAoDg/UGPXw52AYoyab0tJSZs2alVDku/HGG1m6dGmPtKOnBM32jrW72bRpE7NmzVKCpuKwx9nbDVAoDmbGjx/Pt771LQCmTZtGJBLhd7/7He+88w7XXHNNwm2am5tJTU1NelsyMzM58cQTk1rnuHHjklqfYv/YsGEDo0aNanNOdeX39vv9eDyeHpvRVigUCoVC0fuoMaricGPIkCEMGTKk03J+vx+v19sDLVIoFAc7ykJTodgHooO1oqIiAK6//nrS09NZv3493/72t8nIyOCss84CIBgM8uCDD3LkkUeSkpJCv379mDlzJpWVlXF1hkIh7rzzTgYMGEBqaiqnnnoqX3/9dZt9t+fO89VXX3HhhReSm5uLx+Nh1KhR3HrrrYDhunHHHXcAMHLkSMs9KVpHIneempoabrnlFgYPHozb7SY/P5/f/OY3tLS0xJWLurq89NJLHHXUUaSmpnLMMcfw/vvvx5WrrKzkpptuYujQoVY/nHLKKcyfP7/T/l6yZAlnnXUWGRkZpKamcvLJJ/PBBx/ElYm6Xi1YsICf/OQn9O3bl9zcXC699FJKS0s7rP/666/nySeftI4n+td6NrOzYwTYvn07V199NXl5eaSkpHDUUUdZdbdH1H15/vz5bN68uc3v09rlPHqsH3/8MTfccAP9+vUjNTWVlpaWTvv5jDPO4IMPPqCoqCjuWNtjxIgRbNy4kYULF1plR4wYgZSS/v3789Of/tQqG4lE6NOnD5qmUVFRYS3/05/+hNPpjLO8eO+99zjppJNITU0lIyOD6dOndzobf6D7XLFiBd/5znfIycnB4/EwadIk3njjjTb7KS8v5+abb2bIkCG43W5GjhzJrFmzCIfDHbYvFApx3XXXkZ6ebp0bzc3N3H777YwcORKPx0NOTg7f+ta3ePXVVzusS6FQKBSK/UGNUWOoMWo8+zNGjSKl5KmnnuLYY4/F6/XSp08fLrvsMgoKCuLKnXHGGYwfP57ly5dz2mmnkZqaSn5+Pg8//DC6rgPGeXL88ccDMHPmTOuYomPdRC7nI0aM4IILLuDtt99m0qRJeDwey2p1f8dt7Y1xozQ0NFhjOLfbzeDBg7n11lvbWD//73//Y8qUKWRlZVnHe8MNN3TpWBPR1bFjZ+PaF198ke9973uAMdkR3bfyulIcjigLTYViH9ixYwcA/fr1s5YFg0G+853vcPPNN3PXXXcRDofRdZ2LLrqIxYsXc+edd3LyySdTVFTEfffdxxlnnMGKFSusmcUf/ehH/Oc//+H2229n+vTpbNiwgUsvvZTGxsZO2/PRRx9x4YUXctRRR/GnP/2JYcOGUVhYyMcffwwYrhs1NTX87W9/4+2332bgwIFA+7PegUCAadOmsXPnTmbNmsXEiRNZvHgxf/jDH1izZk2bgdoHH3zA8uXLeeCBB0hPT+fRRx/lkksuYevWreTn5wPwgx/8gFWrVvH73/+eMWPGUFdXx6pVq6iuru7w2BYuXMj06dOZOHEizz33HCkpKTz11FNceOGFvPrqq1xxxRVx5W+88UbOP/98XnnlFXbv3s0dd9zB97//fT777LN293HPPffg8/l4880340S1aD919Rg3bdrEySefzLBhw3j88ccZMGAAH330ET//+c+pqqrivvvuS7j/gQMHsnTpUm655Rbq6+t5+eWXgc6tEm644QbOP/98XnrpJXw+Hy6Xq9N+fuqpp7jpppvYuXMns2fP7rB+gNmzZ3PZZZeRlZVluXylpKQghODMM8+MG+yvWLGCuro6vF4vn376KVdffTUA8+fPZ/LkyWRnZwOGy/s111zDt7/9bV599VVaWlp49NFHOeOMM/j000859dRTE7blQPa5YMECzj33XKZMmcLTTz9NVlYWr732GldccQXNzc1WDLDy8nJOOOEENE3j3nvvZdSoUSxdupQHH3yQwsJCXnjhhYRtq6ur49JLL2Xz5s0sXLiQyZMnA/B///d/vPTSSzz44INMmjQJn8/Hhg0bOj3vFQqFQqHYH9QYVY1RkzlGjXLzzTfz4osv8vOf/5xHHnmEmpoaHnjgAU4++WTWrl1L//79rbLl5eVcc801/PKXv+S+++5j9uzZ3H333QwaNIhrr72W4447jhdeeIGZM2fy29/+lvPPPx+gU6vMVatWsXnzZn77298ycuRI0tLS9nvcBu2PccEQFadOnUpJSQm//vWvmThxIhs3buTee+9l/fr1zJ8/HyEES5cu5YorruCKK67g/vvvx+PxUFRUZP2m+3OsXRk7dmVce/755/PQQw/x61//mieffNIKBTFq1KgO+1mhOCSRCoWiDS+88IIE5LJly2QoFJKNjY3y/fffl/369ZMZGRmyvLxcSinlddddJwH5/PPPx23/6quvSkC+9dZbccuXL18uAfnUU09JKaXcvHmzBORtt90WV+7ll1+WgLzuuuusZQsWLJCAXLBggbVs1KhRctSoUdLv97d7LH/84x8lIHft2tVm3dSpU+XUqVOt708//bQE5BtvvBFX7pFHHpGA/Pjjj61lgOzfv79saGiwlpWXl0tN0+Qf/vAHa1l6erq89dZb221fe5x44okyLy9PNjY2WsvC4bAcP368HDJkiNR1XUoZ+61uueWWuO0fffRRCciysrIO9/PTn/5Utncr7OoxnnPOOXLIkCGyvr4+bvuf/exn0uPxyJqamg7bMHXqVHn00Ucn3P99991nfY8e67XXXtumbFf6+fzzz5fDhw/vsIydo48+Ou78iPLss89KQBYXF0sppXzwwQflkUceKb/zne/ImTNnSimlDAaDMi0tTf7617+WUkoZiUTkoEGD5IQJE2QkErHqamxslHl5efLkk0/usC37s08ppTzyyCPlpEmTZCgUiqvvggsukAMHDrTacvPNN8v09HRZVFQUV+6xxx6TgNy4caOUUspdu3ZJQP7xj3+Uu3btkuPGjZPjxo2ThYWFcduNHz9eXnzxxR0ek0KhUCgU+4oao6ox6r4c44GMUZcuXSoB+fjjj8ct3717t/R6vfLOO++0lk2dOlUC8quvvoorO27cOHnOOedY36Pn2QsvvNBmf/fdd1+b4x0+fLh0OBxy69atccu7Om5rj/bGuH/4wx+kpmly+fLlccvffPNNCci5c+fG7aeurq7dfXR0rInoytixq+Pa//3vf22uSYXicES5nCsUHXDiiSficrnIyMjgggsuYMCAAXz44Ydxs5EA3/3ud+O+v//++2RnZ3PhhRcSDoetv2OPPZYBAwZY7jQLFiwAaBPr6PLLL8fp7NiAetu2bezcuZMf/vCHeDyeAzxSg88++4y0tDQuu+yyuOVRK7ZPP/00bvm0adPIyMiwvvfv35+8vDzL3QnghBNO4MUXX+TBBx9k2bJlhEKhTtvh8/n46quvuOyyy0hPT7eWOxwOfvCDH1BSUsLWrVvjtvnOd74T933ixIkAcW3ZHzo7xkAgwKeffsoll1xCampq3O89Y8YMAoEAy5YtO6A2tKb1+Qb718/7y9lnnw1gWUx+8sknTJ8+nbPPPptPPvkEMBIa+Xw+q+zWrVspLS3lBz/4AZoWe/Skp6fz3e9+l2XLltHc3JzUfe7YsYMtW7ZY11fr36asrMw6j95//32mTZvGoEGD4sqdd955gGGNYWfVqlWceOKJ9O/fny+++ILhw4fHrT/hhBP48MMPueuuu/j888/x+/371McKhUKhUHSEGqMaqDFq941R33//fYQQfP/734/bdsCAARxzzDFtQgwMGDCAE044oc2xHuhxTpw4kTFjxrRp276M27rK+++/z/jx4zn22GPj6j3nnHPiQiJE3ckvv/xy3njjDfbs2bP/B2jS2dhxX8a1CsU3BSVoKhQd8J///Ifly5ezevVqSktLWbduHaecckpcmdTUVDIzM+OWVVRUUFdXh9vtxuVyxf2Vl5dTVVUFYLkQDBgwIG57p9NJbm5uh22LxjnqSvDsrlJdXc2AAQPaxK/Jy8vD6XS2ccFJ1MaUlJS4B/Drr7/Oddddx7PPPstJJ51ETk4O1157LeXl5e22o7a2FillnFtNlEGDBllt7agtUdeRAxWSOjvG6upqwuEwf/vb39r81jNmzACwfu9kkahf9qef95fhw4czatQo5s+fT3NzM0uXLrXExehAfv78+Xi9Xk4++WQg9nu195vquk5tbW1S9xmNrXn77be3+W1uueUWIPbbVFRUMGfOnDbljj766LhyUT755BMqKiq48cYbLfd2O3/961/51a9+xTvvvMO0adPIycnh4osvZvv27fvS1QqFQqFQJESNUQ3UGDWeZI5RKyoqrDjmrbdftmxZm2270uf7Q6K+3tdxW1epqKhg3bp1berNyMhASmnVe/rpp/POO+8QDoe59tprGTJkCOPHjz+gWOmdjR33ZVyrUHxTUDE0FYoOOOqoo6wMku2RKLFKNOj3vHnzEm4TnU2NPvjLy8sZPHiwtT4cDncavycaI6mkpKTDcvtCbm4uX331FVLKuOPau3cv4XCYvn377nOdffv25YknnuCJJ56guLiY9957j7vuuou9e/e22z/RZC9lZWVt1kWDqO9PW7qDPn36WLPy9qQ1dkaOHJnUfbZ3zu1rPx8IZ511Fu+++y4LFy5E13XOOOMMMjIyGDRoEJ988gnz58/ntNNOswbt0XO9vd9U0zT69OmT1H1Gz5G7776bSy+9NGGdY8eOtcpOnDiR3//+9wnLRV9Sotxxxx3s3LmTa6+91hrM2klLS2PWrFnMmjWLiooKa8b9wgsvZMuWLR0ep0KhUCgUnaHGqAZqjNo+BzpG7du3L0IIFi9ebI2t7CRa1h20dx7vy7itq/Tt2xev18vzzz/f7vooF110ERdddBEtLS0sW7aMP/zhD1x99dWMGDGCk046aZ/33dnYcV/GtQrFNwUlaCoU3cAFF1zAa6+9RiQSYcqUKe2Wi2ZvfPnll61kIgBvvPFGpxn6xowZw6hRo3j++ef5v//7v3YHFfsyC3zWWWfxxhtv8M4773DJJZdYy//zn/9Y6w+EYcOG8bOf/YxPP/2UL774ot1yaWlpTJkyhbfffpvHHnvMCk6v6zr//e9/GTJkSBvXk/3F3j/R/ewLqampTJs2jdWrVzNx4kTcbndS2nUgtNfP+zpL3lH5s88+m3/961888cQTnHjiidYL0FlnncXs2bNZvnw5Dz30kFV+7NixDB48mFdeeYXbb7/dGpz6fD7eeustK/N5R+zPPo844gjWrl0btzwRF1xwAXPnzmXUqFGdCqsAmqbxz3/+k/T0dK6//np8Ph8/+clPEpbt378/119/PWvXruWJJ56gubm502NVKBQKhaI7UGPUxKgxalsuuOACHn74Yfbs2cPll1++z/tPRLKsU/d13JaoHYnacMEFF/DQQw+Rm5vbZYOElJQUpk6dSnZ2Nh999BGrV6/mpJNOOqBjTTR23JdxbbL6WaE42FGCpkLRDVx55ZW8/PLLzJgxg1/84heccMIJuFwuSkpKWLBgARdddBGXXHIJRx11FN///vd54okncLlcnH322WzYsIHHHnusjYtQIp588kkuvPBCTjzxRG677TaGDRtGcXExH330kZUxe8KECQD85S9/4brrrsPlcjF27Ni4mDtRrr32Wp588kmuu+46CgsLmTBhAkuWLOGhhx5ixowZVmzCrlJfX8+0adO4+uqrOfLII8nIyGD58uXMmzev3ZnFKH/4wx+YPn0606ZN4/bbb8ftdvPUU0+xYcMGXn311YSztftDtH8eeeQRzjvvPBwOxz4P+v7yl79w6qmnctppp/GTn/yEESNG0NjYyI4dO5gzZ06HWSyTQVf7ecKECbz99tv84x//YPLkyWia1qF1x4QJE3jttdd4/fXXyc/Px+PxWP115plnIoTg448/ZtasWdY2Z599Ntddd531OYqmaTz66KNcc801XHDBBdx88820tLTwxz/+kbq6Oh5++OFOj3Nf9wnwz3/+k/POO49zzjmH66+/nsGDB1NTU8PmzZtZtWoV//vf/wB44IEH+OSTTzj55JP5+c9/ztixYwkEAhQWFjJ37lyefvrphK5zjz/+OBkZGdxyyy00NTVxxx13ADBlyhQuuOACJk6cSJ8+fdi8eTMvvfRSl4RbhUKhUCi6CzVGNVBj1M7HqKeccgo33XQTM2fOZMWKFZx++umkpaVRVlbGkiVLmDBhQruTue0xatQovF4vL7/8MkcddRTp6ekMGjRony0q93fcFqW9Me6tt97KW2+9xemnn85tt93GxIkT0XWd4uJiPv74Y375y18yZcoU7r33XkpKSjjrrLMYMmQIdXV1/OUvf8HlcjF16tT9OtaujB27Oq4dP348AP/617/IyMjA4/EwcuTITsNFKBSHHL2ZkUihOFiJZiVsneGuNdddd51MS0tLuC4UCsnHHntMHnPMMdLj8cj09HR55JFHyptvvllu377dKtfS0iJ/+ctfyry8POnxeOSJJ54oly5dKocPH95pBkkpjQyE5513nszKypIpKSly1KhRbTJS3n333XLQoEFS07S4OlpnkJRSyurqavnjH/9YDhw4UDqdTjl8+HB59913y0AgEFcOkD/96U/bHLe93YFAQP74xz+WEydOlJmZmdLr9cqxY8fK++67T/p8vg561mDx4sXyzDPPlGlpadLr9coTTzxRzpkzJ65Me79Ve/3VmpaWFnnjjTfKfv36SSFEXLbNrhxjlF27dskbbrhBDh48WLpcLtmvXz958sknywcffLDT49zXLOetj7Wr/VxTUyMvu+wymZ2dbR1rRxQWFspvf/vbMiMjQwJtMqRPmjRJAvKLL76wlu3Zs0cCMjc318ryaeedd96RU6ZMkR6PR6alpcmzzjorbvvO2J99rl27Vl5++eUyLy9PulwuOWDAAHnmmWfKp59+Oq5cZWWl/PnPfy5HjhwpXS6XzMnJkZMnT5a/+c1vZFNTk5QyPsu5nWim1nvvvVdKKeVdd90lv/Wtb8k+ffrIlJQUmZ+fL2+77TZZVVXV5WNVKBQKhaI1aoyqxqhdPcYoBzJGlVLK559/Xk6ZMsU61lGjRslrr71WrlixwirT3lj2uuuuazN+fPXVV+WRRx4pXS5X3Fi3vSzn559/fsJ2dWXc1h4djXGbmprkb3/7Wzl27FjpdrtlVlaWnDBhgrzttttkeXm5lFLK999/X5533nly8ODB0u12y7y8PDljxgy5ePHiLh1rIro6duzquPaJJ56QI0eOlA6HY5+yrSsUhxJCSil7QDdVKBQKhUKhUCgUCoVCoVAoFIoDRmU5VygUCoVCoVAoFAqFQqFQKBSHDErQVCgUCoVCoVAoFAqFQqFQKBSHDErQVCgUCoVCoVAoFAqFQqFQKBSHDErQVCgUCoVCoVAoFAqFQqFQKBSHDErQVCgUCoVCoVAoFAqFQqFQKBSHDErQVCgUCoVCoVAoFAqFQqFQKBSHDErQTAK6rrNr1y50Xe/tphzUqH7qHNVHnaP6qGuofuoc1UddQ/VT56g+UhwsqHMxOah+7B5Uv3YPql+7D9W3yUf1affwTe1XJWgqFAqFQqFQKBQKhUKhUCgUikMGJWgqFAqFQqFQKBQKhUKhUCgUikMGJWgqFAqFQqFQKBQKhUKhUCgUikMGJWgqFAqFQqFQKBQKhUKhUCgUikMGJWgqFAqFQqFQKBQKhUKhUCgUikMGJWgqFAqFQqFQKBQKhUKhUCgUikMGJWgqFAqFQqFQKA5J1q1bx/HHH8+LL75oLXvxxRc5++yzOfPMM/nLX/6ClNJat3HjRq666ipOOeUUbrrpJsrKyqx1gUCAe+65h9NPP53zzz+fefPmxe1rzpw5zJgxg6lTpzJr1ixCoVC3H59CoVAoFAqFIjFK0FQoFAqFQqFQHHLous6f/vQnxo0bZy1bsmQJb775Ji+++CJvvPEGS5Ys4b333gMgGAxy5513cuWVV/LZZ58xfvx47r33Xmvbf/7zn9TX1zN37lweeughHn74YYqKigDYsWMHf/7zn3nsscf44IMPKC0t5bnnnuvZA1YoFAqFQqFQWDh7uwEKhUKhUCgUCsW+8vbbbzN+/HiampqsZXPnzuWyyy5jyJAhAHz/+9/nww8/5KKLLmLlypV4vV4uuugiAH70ox9x9tlnU1ZWxsCBA5k7dy6PP/446enpHHPMMZx++ul8/PHH/OhHP2LevHlMnz7dEk9vvPFGHnzwQX784x8nbFswGCQYDMYtczqduN3u7ugKC13X4/5V7B+qH7sH1a/dg+rX7kP1bfJRfdo99GS/atrBYxepBE2FQqFQKBQKxSFFfX09r776Ki+88AJ/+tOfrOW7du1ixowZ1vcxY8bw5JNPAlBQUMDo0aOtdV6vlyFDhlBQUEBaWhrV1dVx68eMGcPGjRutbU866SRr3RFHHMGePXsIBAJ4PJ427XvhhRd45pln4pZ973vf4/LLLz/AI+8au3fv7pH9HO6ofuweVL92D6pfuw/Vt8lH9Wn30BP9OnLkyG7fR1dRgqZCoVAoFAqF4pDiySef5KqrriIzMzNueXNzM+np6db3tLQ0mpubAfD7/aSlpcWVT0tLw+/309zcjMPhiBMnO9o2ug+/359Q0Jw5cybXXHNN3LKestDcvXs3Q4cOPagsKA41VD92D6pfuwfVr92H6tvko/q0e/im9qsSNBUKhUKhUCgUhwxbtmxh48aN/OpXv2qzLjU1Nc4F3efzkZqaChgWmT6fL668z+fD6/WSmppKJBKJs7jsaNvoPrxeb8I2ut3ubhcvO0LTtG/UC013ofqxe1D92j2ofu0+VN8mH9Wn3cM3rV+VoKlQKBQKhUKhOGRYtWoVxcXFlmt5U1MTDoeDkpISRo4cyY4dOzj11FMB2LZtG/n5+QDk5+cze/Zsqx6/309JSQn5+flkZmaSm5vLjh07GD9+fMJtd+zYYW27fft2Bg8enNA6U6FQKBQKhULR/XxzpFuFQqFQHJIUNjVz6kdLuWThSoIRFUBcofimc+mllzJ79mxefvllXn75ZU4//XSuvPJKfvGLXzBjxgzeeust9uzZQ1VVFS+//DLnnXceAJMnT8bv9zNnzhyCwSDPPfcc48aNY+DAgQDMmDGDZ599Fp/Px/r161m0aBHTp08H4Nxzz2X+/Pls2bKFpqYmnn/+eatehUKhUCgUCkXPoyw0FQqFQnFQc8nCVRT5/FAPiytrOGtA395ukkKh6EU8Hk+cZWRKSgqpqalkZGRw6qmnsn37dq699lp0Xefiiy/mO9/5DmC4gT/66KP87ne/4+GHH2bcuHE88MADVj0333wzDz74IOeeey6ZmZncddddjBgxAoDRo0dz6623ctttt+Hz+TjzzDO54YYbevS4D0U+Katk+sB+vd0MheKQ5K3icr47bEBvN0OhUCgOWpSgqVAoFIqDlhKf3xAzTcqaW3qxNQqF4mDk/vvvj/s+c+ZMZs6cmbDs0UcfzWuvvZZwncfj4cEHH2x3PxdeeCEXXnjhfrfzm8jnFTVK0FQo9pMV1fVK0FQoFIoOUC7nCoVCoThoeXZHSdz35kikl1qiUCgUCoVC0TMsqqhha0NT5wUVCoXiG4wSNBUKhUJxUKJLyUu79sQtqw2Geqk1CoVCoegqr+wqBeD5VpNShxMf7Nnb201QHKYUNjVTHQzSGFKTuAqFQtERStBUKBQKxUFJQyjcRsCsC4Z7qTUKhUKh6Cob6xsBaNEP30RuX1bW9nYTFIcpf9iwEwCJ7OWWKBQKxcGNEjQVCoVCcVDSEGorXtYpC02FQqE4qNnR6OvtJigUhzT/Ky5HIHq7GQqFQnHQowRNhUKhUByUJBI0lcv5oUF1S5DXC0upCgR7uykKhaKHeWHn4etmrlAoFAqF4uBBZTlXKBQKxUFJIkGz3N/CPWu28UVlDQ2hML8cl89VIwb1QusUHfHDpetZtLeG0/NyeOeMyb3dHIVCoVAoDjmk8jhXKBSKDlEWmgqFQqE4KEkkaK6ra+TJbUWsqW2koMnPr1ZtSVhO0bss2ltj/Wu30mwIhnitsJTdPn9vNU2hUPQAWxt81rWvkucoFF3nr1sKARU/U6FQKLqCEjQVCoVCcVDSFaGyKRzhVTObruLgIBiJTwISFTcB7l6zjVu+3shli1YjlemJQnHIUdDYzPLqug7LSAkrq+spD7QAKnmOQrEv3L9uOwC+Jh9NPp96ViaZd3dX9HYTFApFElGCpkKhUCgOShq6mNH82R270dWA/6ChLhQf53RhRUzQXFFdD8D2Rh/VLSoeqkJxqFETDLHbF+iwjBBwxYiBPdQiheLw5I677mJraTlPPfVUbzflsOLrTiZkFArFoYUSNBUKhUJxUNKZhebknCwAdjY181l5dU80SdEFaloJlZ9XVFsWJntNiy2A4mbldq5QHGoI4LkduzssIyUcl5PFHx97HIBFixb1QMsUisOL2rCO1rcfP/vZz3q7KQqFQnHQogRNhUKhUByU2AXNvimuuHXZbie3HjXC+v6fgj091SzeL9nLK7tKlRtYO9S1ykS/uzlAoc9PIBKh3vabFqk4mgrFIYWUEk0Yk0g7Gn3tlhMCHAJefu01AFauWNlTTVQoDh90HalHersVCoVCcVCjBE2FQqFQHJQ02FyXh6V549YN9no4Z2BfBnjcAHxYWkm5v4XuZk1NA9d+uZafLd/IS7sMEXVZVR1TP17GY5sKun3/HfHCjt384Is1bK5v6tV21ATbupL/c3sxlbbkQECnbqsKheLg4uGNBWhCoEvJCztLOizrK24ETWPAmrIeap1CcXjh2FVMy1N/7u1mKBQKxUGNEjQVCoVCcVBit9BsLWgOSvXg1DSuHjkYgIiUvFrY/cmBPimrsj7fumIzUkp+sXwj6+saeWjDTrY1tG+11J2sqK7nl6u28MGeSv6wYWevtCFKbQJB81/bd/NWcXncsmJloalQHFI0hsIIQG/HOH1bg4/3SiqIhCMs+fsihMNBekVjj7axp7j33nt577332L27Y/d7hWJfsHt+jHUdSZ7I68XWHL5IKdnV1NzbzVAoFElACZoKhUKhOCixC5p5LSJu3SBvCgDfHznIWvbfXXu63Q28MRwf1/PVwjK2N8YGxa/3gKiaiAfX77A+v79nb6+0IYo9hubxuVnW5wdsbQTlcq5QHGoIAZoQtHeXbYno+MIRVqxYwZ7iEnA4erR9PcXSpUv53e9+B4WCq666qrebozhMeKu4nAsuuAAAuXgxEomG6GQrxb4iAImRUFKhUBz6KEFToVAoFAcl9TZLP//f4weeg7weAEakp3JaXh8AdjX5WVvbvdZArUW4ny3fGPf99aIyIu2ZL3UTCyuqWbS3Jm6ZL9x7cbfsMTRv3JvFkZlpCcsVK5dzheKgYG1tQ5fLGhaaxj1ueyKLdClZVdWEpkvQHPTX+ieplQcPmzdvBiBVePniiy96uTWKw4Wv9lYzd+5cAI6q7YuugaZe1ZOOQKBCoCsUhw/qLqlQKBQKAEqaA8xat50lrcSx3qKqwbB8TGmR5NTGW/oMSk2xPl8ydID1+d2Sim5tU2du0qX+Fvq/NZ/ne3Dm/+3itse8raH34mjaY2hWPVzIsX0yE5bb3exXiZUUioOAN4q6HudS2Cw0X9q1h5CuW+skkn889Q8YcwTpMhVNc5AhMg3TzsOIlBTj+aPuXopk8lFBMQjz1VxKdCGZ6p7au406DBHCuFcpFIrDAyVoKhQKhQKAB9Zt5y9bCvnO5ytpCoU736CbqQ0YSX68fkhrFeooXBlzq75gcB6a+b787u6KbhXJ2nOTHpbmsT7rEm5ftYWCxp6Jz1Tmb2vpuLWXYnlCfAzNNB+ECxKLu4GIzt5WiYIUCsXBSSASs/o+JjOVHdt3oIeChGwW6RL46qtlRhnXsaST3tPN7BHEYSbQKg4OduPEOfE4APK0PHQhceHu5VYdfmi0HzZDoVAceihBU6FQKBQAvGlL2rJmH1wQuwufKUym+g1hzM7OP61g1cpVRCIR+nrcnJaXA0Chr/vczhuCIeqChtB7bJ8MHjxmDGcOyOXcQX2ZO+14vj2wb1z5noplmUgUfKOojL9s3sXeQPdnfm9NjT/WnnQffP7k6+2WLW5WcTQVit6mK3NAv1u/w3I3L377NebMmcM7b78dJwxoiJiFWRd28M7uCnY09t7kS7LpqUksxeHJMQRxDBoCgEM6kAIVQ7MbEKL9xGZRWiJ6xwUUCsVBgxI0FQqFQtGGldX1vbr/iC4JuZwAeAOQ3uo98ZhFw3jo1D8wc+ZMAC4aEovTtqSye1zmi2wxH8dlZXDL2OG8efpxvHLqJAalenjttEmsOO8Uq0zPCZptRcvPK2qYtX4Hv1q1tUfaYKcmYFhoOkOSlCAMr2zfwkTF0VQoep+uGhyW+Vv4srKWTRs2kjL9fHbu2GnF0wRwCLDM5W300fokrO+/u/bwws6S/WlyrxKz0Iw/1ud2dhxq5NPyqoQW9QoFQC4S6TPCxZTrpehIhBI0k46RFKhjRfOB9dt7pjEKheKAUYKmQqFQKNq4aS/vZUGzviUm0qUmcDn3tsANqTey4N0FSCkZnuaNbRvsHnd5u7u5fX928jNSOTrLcLNcUV1PaXP3vrxGdEmlmVV8YnYG6c74WKPvlnSvC34ias32pPuMF4cjqxKLGdB5TFKFQnHwUBsMsbOxGZCIFA8iJYV6W3gSIQRo9lcLQ4xxCzezZs1qU99n5dXd3OKDi8ImP02h3kvYpji4GSkiREqKABASdCHRZPIETRWz2kATolMLTYVCceigBE2FQtFtvFFUxjPbi3s867Ni32lslRV7RU19rw5+12zdZn32+iGlHc/pS8OXsXfvXtJdMSGvqZsyfMcJmumJBU2AC4bkWZ/n7qnslrZEqQ4GiZi/U39vClluV5syJd0sqramLmIIHFGr2iPCQ3E3x9xK7QZcStBUKA4NKsorWLNqFZu2bkMzvTEdI49gsS2JnCawXM6/Ci2zWX4K7r///p5sbrcSs9Dc92ekCr/5zWb27vJ21wmwJQUCXYAmk/eq/tCGnQdcx+HwzNYE1rhJoVAc+ihBU6HoRhqCoW+smDd3z15+/NUGfrV6K28Wdz2DqqJ3qGoVh3FvINir7sBfb9hofU71GwP9K9/W6Vst+dkzsdhGZ6WczZYvt5DudFrLGrspoZF9ID+sHQtNgAsHxwTN7nY7t8fP7OdwMSlBRvGejIcaiETwS+P3STcTrY92HkFKTczENs8mPiuXc4Wi92kIheOS/nxZWUtJK+Hi7bffJrg3wOpF68h35BsLI2HC7YxxqvQqNPM1I+o2+023EPuGH74CWF7V/mRxWWmpTfGWSEFSXc7nlh74BOvWhqYktKR3cQjxjb8XKRSHE0rQVCi6iUUVNYx5byGnfLyU4DcwuPQtX8cEqX8X7OnFlii6QlVL28Qyy6vrer4hJpsKdlmfU8336gs+gSd+KzlxVaycUzip+G8lGa6YoNkU7gmXcyOred3qeso/qEDaXuqPykon37Tg/KKyluoEfZssKmzxM5tfKOPsL8DVygSou5IkJSIuw7ktTMAQXyxhkr+x0XKNPxysPRSKQ505JXvjEtoU+fxU265lADntXI5c04SnYA+6OWmBrre1dJKSMTskOrpN0IyuOnxFhGeeeYZn/vUMTz31VIfllIHmocHcbpqMbC8hzYYNG3j99dctQVNIkEKiIXDaJmz3l5lfruOM/jkHXE97ExiHEhqCyKF/GAqFwkQJmgpFN3HVktUEdcm2Bl9SZkUPJVZU19Ngs5Ir9/d8pmXFvpFI0Py0F+Ob1diEOq9fEpGt3MjTISSNNnu+9OANxEan3eVyHhXfUoTAu72Fpu0+lp73FauuXUPJyzHRXgjBBYONJEURKZnXjde/3UIzs1qn7yPlzF49gK/PO9la3pMWmtH4mWDE0IzitRliNusw1LRw3d3sj0sqolAoeh5NgH3a1SEEj20qiCsjHA60iClUmoWd0smzzz5nCZXRS3lgYTM6umVdFhzSH8cRRx42gqawTxqZn2+66Saampr46U9/2u52UiV5OWT4orK2W+rVEAkT0tx8883GBRQ9t6IxNNHiz7d9pMLfQnVLkHdLKva7DjuHg3mG9EWISBk3EZ2IbQ2+DtcrFIqDAyVoKhTdhN9mldkQCnVQ8vDjn9uL474X+vwJMzErDh4SCZrv7K5o44reUzTZrp/UABRH4s+ptKNTWRBcAIAz6KLhg6rYtt3kch7to4wqnS+nLWPdz9YjQ8aAuOT1eCtkexzN90u6z+18r22yINvULZterWCk20PfFCOe5pqahh4TEuwWmnZB8+Tlsf2f8WmIfpXG96Au46xMFQpFz+MUIs7SUgMqE9z7PaQgRUyUy9P6sW7lOt555x1bKcmeSClS6jiEYYkdSfeiZfVB1w9MDplTUhE3adJb2AUm79U/7PJ2EhVD81Chux6ZWjsWmpVD801B02oBUkBRuDCu3FdVdfu0v1U19WyuN9zEPy2vPuCQPIdD7Mnyz0o5d8YMZv/zHVasWNFuuX8XlPRgqxQKxf6iBE3FYcP2Bh9fV9UdlBYAPe2hsb3Bx9Pbiinz9058us8r2lr29XbWbEXHVAViL4kjTXfpFl3nv7v2sLCimrPnf8XRcxZx9vyvWF3T/b9ls+2iSWnWKdXjBcOskVl8qs+3vlfPq8TrMB5prRMcJQNdSmpMsS7DDCFVtyLWDzXLaglWxwSA43IyGehNAWBBRXW3iawVNtEhyxQ0ww1hqpfUcIwZT7MmGOqxxEA1cYKm5Cnf36mIVDBlJVw4T3LqohYun5+Bd1ksDleRiqOpUPQqDiHiXEk1kdgl04ETXQPNXOepbUb3N7Nzp5FsJLrJaOdo9LTxhvBpZDoBDjxu3a4mPy26HpeIqNdJgjuw4uCkLph88VwTAj2BhaZ/0DCQEmEmBRISpGcUO0RVXLn39tHSUhLTSC8e0v+Ar8FDXdB8/fXXWbFiBatWryYzlME555zTbtlD/FAVim8MStBUHBYUNjUz9ZNlnPvZcj4qq+p8gx6mO2PoJeLqJWv49ZqtnPHxV6zqAfHJTlUgSHUCC4obl67nsU0FNHeTO7DiwLBbaN4xLt8aAD+xpZDLF69mVU0DZf4WVtU08Lv1O7q9Pc32gWTQTW3fGXHrvYO8MFJSoxsvtuWfVpBqmr50h3hYHwxbExPpCWLiCynY+3HMtVwTgjMH5BrN1yU7bPHpkond8jnL5ln+yi9fjUsQ9I9t8Rau3UVNK5fz4txiFgcXIoAr3pX8+FUX3hbI3Rv7gXerOJoKRa+imRaa68zwFA4h2oSC0H1NNOtNSECTgtEfbaffxnJkZUVMJJESYX7UU49ECCPWsLBWx+oMBo1nTktd1y20pZRogm4N49EV9tcFWAkkhw5CwKMbCzovuI9oJDZy0CM633Z/m0muyUzYJEHLQDjTQPO0W9fXXbDWNKyCjfP100/n8/nChfvX8Gg7D/GT+MorrzQ+aBpISU1N+5MjyppaoTg0UIKm4rDgwfU7CJguqo9s3NnLrQF/K9GusgcFzaZQmJ1NzdZ+v7NgRY9mJdzWGPMzvWhIf+tzi67z0Iad/OTrDQelFe03Hbvo/q3cLM4ZZCRxaQiFCbUafS+trGtzjiebgLA9nlqc1Kb0i1vvGeThiLFH8HXwKwC0kEZgrxHzqjtiaFYHY/2T0c7ltOvtwrjvUQvN1tsnE3sMzUhdFUEzrmhuUV/G1cesVv+5vZiVPWAlbb/XZTTBhVddSK2sa1Oun23eqUgJmgpFr+IQAh0445OveLWwFLcmCLZyDx+yZCcS0JGI6OuDlCA0y5W8fmMj/aacb6zyDMOhpdOMeT8WIs7l/LrrrgNg3Xvru9xOHTMGYYIhxNvF5W0ys3cXlqCppe7Tdv49fsJ1ve8yr+icxXtr0ETyE1lpCSYLAGpra8kVubi0FAaXAs6+hmmlbNuGldX1RHTZpbiYupSEQiFksIUlS5Zw8cUX4/Ptf2zIwyEpUDT2gzgMDkWhUChBU3GYsL4ulsXXcRBMqZW1SoKTyGKxu2gdC7E5onPX6q09JiLag2ifmteHEWbyjyhzSvbyz+27e6Qtiq5jF6L6prj5+/FHc8HgPOt6ujZ/MFeNGAgY4vRX3ZwBPeiKWSXoLS5qne649Z6BKYwZM4avQsusZe5G4xzvjizn9ms4o9W7QEga6+oXNxBpib2w57pjbe6ue0A04ZYnIPFHavGPNiYzcrVcmt4r4FdHjwKM8fvvN3S/Ze3uppglalYthPtfSp3eNrlCP1tUCpXpXKHoPVavXs2ekhL+8te/ArChrhG3QyNoEy52795NKqmGviIMUTFby7aSmETHF6V7SvGPHQ5gpgQSlDpjYzL7OOS1114DoK6+axMtT24tsoSgRMO86pYgoZ6eLHXuW9Zof0mAYF33hB9RJJcNdU2m+JjceoVoP7GO1CM4hRnCIGWwLVxDPO/v2Uu4i+e6BG7/5S9p+eQD63pdtWrV/jQd4LDJDq5lZBJKdSVcJ6UkQVQAhaINRU1+3iwq6+1mfONRgqbisGC7zZ1zSGr77hk9RWmr2JWJEq50F3sTBPJfWFHTY5nWt9isQcdkpvGro/Ppl+LGpcUGZQ+u395tMQUV+0dUcHPoUPNcCaG6WvJmv8TjziaWnHMST3xrHGcO6GuV/7y8e2OYhVPSrc/C56LWlRK33jPQw8SJE1kbWkNAGtdbToshnod0SUskubk4a+IsD2MjXccQjYXBzwHDSnTvF7EEQH09scFyd4WdqDBjY2Y1gMgQZF+QZa1zvefmJ0cMpb/HEFbX1jYmrCOZbC6LWYy4G1w8OudY6vS6NuX62U6f3SqGpkLRaxx33HGkhFy8+fbbgKF5yOZInPh4wgknYK00kwL1FX1BGtaKUkp27tzJHXfebgkBhjWlhnBkWZJM64lVGYnQVeUgOq56YP32hOslhtDaE1gWmq12l6Flti3celvloXJI4NKM1FeJ4l3uL4FAgPVr17JixcqE6yU6Ds0QNIU0/icTnNNxuYM6IRLRWb16VXQHAPzrX//ax5ZH9yspqyg/9L2spMQ5+ihq8hNPSEigfnldjzZJcWgS1PVu8QpT7BtK0FQc8lS0sob0J1nI2B8Wro13oerJTNF28fSYPhnW5wfWbe+R2Dd2C82xmWlcMWIQWy+aSsVlZ1sWfs0RnSWVba22FL2HlcG7QbLlt9v47rnf5fHHH+e6Sy9h2wIj+c7UvNjgb+HetomfkomebrwYOiKSUEtKWwvNQSl873vfY+aPZ7IjbLzgZgZiAuKBZvJsTZyFZhP4RzYz6bljOP3DUynLjc3OPvKDRyktLQUgN6V7LTT94QiNpgtnVgOk9E1hzNVHUBA2wm5kVGZS83E1R2Ya4nBtMBQnzHYHUQtNR1iC3/g96lLavjSkNUN6xHglUy7nCkUvIgROXTNiyhlf2fPZHlqajXuWlJLy8nL7BsioMmImMZFSMnr0aCI2H04dgWYPHSKwXM6jYyLHPgzXXtlVii7bT0qiSyODdI/SqinDHcM7KX6IC0HfEL788kvGV+3B39yc1Linjz76KO+8PZuzp0+noiLeXdztdiOljobDWiaQkDqujYAohHHqdaVtwVCwVdBOgabt3+v/z3/+c3772/uYOXPmfm1/8CA7jIOrS4kMqWtVoThUUIKm4pBnRaukN/XdkJVwX/D5fDz6zLNxy3oyKZDdQvP6/CGc2DcbMKxYP6/o/sygUUEzFUndy8XseroQaQ6mLhicZ5WbfxAmb/qmIqW0BM1M04ivfH1ssH3JJZeQm5vL/bf/HxOyDZF8XW1jt57XkQxjP5kN0KS5qHXGLDTDQjDtHie+gJN//OMf5B5tJN/x2OY2ku12bs/endEEA6b0Z+DFA/AO8nLpvZdY60Y0jeTee+8F4l3Ou8NKe2+rDOdZgzMZPmI4rwZfsZYXPVvMqIxYnLfuSk4UpUEYL2N96sGnmYJmxviEZfOajCFISXOgzcSUQqHoGbxXzkToOmgOclYvpb6unif/8SSlpaVs2bLFFvdSIm1ZmA3/c92y0ATQieDwG/clXUg0NKQAhGE9H63rz1t2RasEjLATa2oaeKvYLpzGW3TWh8KEpURrR4jQZSJbtv3Hvu+XCvbErbOLIVr/QftUb+8HRVJ0REtLC6eccgrLli7j3XfeSaqF5n333QdSB03wwQcfxK3TNGNiQGimoGnGecQ1oE09RmjNrrUrGAwBErdwc6zz2AM6Af/+979zkudU/v3vf+9/JQcBMpr7vd3JEZk4c5NCkYDOkm6+vGtPh+sVB44SNBWHPMur4gXNhl52ZV6xo4BwTnwCk6qWUI+5aNiFkzyPmx+PGWZ9f2Z792Y6bgiFKTWFici2InbcWcDm32xl51+Ml5dT83Is1/P55VWHvtvKYYI98U+mGTFgoDYwrkxNTQ1PPvkkR2uGa4UEvupChs39IazrREyrwux6aHK4qHPYxEFnCks3Ce593mizY7DxAuCxeS4n2wUkLnt3EwyZPMT6/r0fXoZzpOEmNtoxmmXzjbieuSmuhNsni0JfTJzsVw19R/bF6XRSPayKKt2YMKhbVc9om6C5s6n7BM1AJILfaRxzTq3xuwE0jH6cRL/GyBJD3AhLydVL1uBTbjsKRc/jdOGUDhzCSWNDI59+9inhiHG/+slPfsLy5cutorr3CDShWck0UkghTcQ8QSJIhsxeaiYyCSKEcd8WDi8g2jzzNdOjZm8gyM6mZla1mqD+/Yb4JI+6lDh7KE76w5tiGa63dJBY0T35xC7XKc24ooqDl1W7S9H65jHOOZ7ioqKk61qTHJNAaITbTLpKysN7qJGG90tUtJS2V/XZs2fz5ptvUlBQEA2H2SlBMyHhGMdYnDhACE455ZT9br/scTPobkDKdq/DYDDIt44/nrWrV7O3Ym/CMgqFnd3NHXsZbapv6lCb6AnvycMdJWgqDnlWtrbQ7EVB89XCUi7ZWk7KmefFLQ9L2WPtKqiKuQL39biZMagfg824oh+XVbGzcf+zG3bGdpu7+ZCy2O1l24PbCTeGyXA5OalvHwCKfYFutxZTdI1oHEaIZfAe6BjIQw89xHnnxZ/LGZUxC5oV3ZQ1u6S+0XJ/zG6ABoeLsKaxyWvEh1yXZrgw/+0tw4omNd+w/vHaBc1ku5zbs5z7IG1UWtz6oecNBkATGn3KcigqKopzOe8OC81dTbFBVP9KyaAxhqXQmLFj2Bk2EgCFG8IM8TmtcutrG/m6qo6QnvzQHPZkaDl10GgKmroQNDjcbcpf/G7Yinm8uraB53aoZGEKRW+QqqWRLlJpbGwkFAyhywgIgc/no95M2uPChRROBJplHTYwZTzD3EfYhEppWT3J2nkQtea0PNRbuc6a3x0i8Utdc6tJjs1bt7Fnd+L7hGZmak8WiSZY/J1MutQPy+603sNADjqs2e4P4rniekPw0vWkiw0OqaEJB6FQ20nOOr2ORt10k0kgWF566aXs3l3C66+91mW70UDQ5nJu/pOfn79/jefwEDRN+8yEivAzzzzD+g0biIQjvP/B+z3dNMUhSKALoe4e2biz3XV/31rUo6HpDkeUoKk45NneSqBLduy8zpBSsrGukbpgiAfWJQ5WDz2TGGjBggX8Z/a71ve8lBScmsYNowxrMgncsWpLt1lGbrP9FqMr4pMzffjLeQCcNSDXWja/XLmdHwx8ZrPAibqcTz/m29x1113MnTuXd955x1of3r7J+ry8mwTNorpYvdn1hjCW4ob7h0/i3mGT+MfAI631X2+G7COzAfC0xM7rxiS7nFcH7EmBIG1Uatz6vmfEzuufpv4/Fj67iLqqStKdhvVod8TQLLBZW/bfCznDDKH3iCOOYEckltG8X1GsL57eXsy5ny3n5q82JL09pTZhPKc2JmgC1DnbCprZu+Gf3zra+r6pvn0rKIVC0X2M2xKL3SelRKKDEAgh8PuNiZMIEXQkQjhAOEyhx2l6bkbvvYZAUC0MN1cQ2MJqWi7n0TA0Kbpxj3AIkTA2Zmu9YfP7W3n/vffYsyfehW9+WRVaO6JoMnlwww6zXYlFncqj8hIuj6LscA5+dCFw5A0wT2V5wCJ5UVMr6y2po2lO67qKISD1SATxcWcRiV/Vu3ouGcJpfAzNA3kHkD1kId2tSAm1deRt2kvKjEviVu3evRuEhpCS+rp6amq6P1SX4vDHKQQhXeevWwrbrGuJ6DgOh+uqF1GCpuKQxheOtMnq3RSOEO4G66PWRAfOf99axGkfLyP/nc+p6GCGpaobBI3WfPDBB4jMbOt7XzO78Q9HD2WQ14hB+HlFDS91UzwPe0Kg8RW5cesa3/Th9/njBM3Fe9VA4WBgd3UsQVO6zzivJ+RNsF7ajhx1JNPcZ5LvGEXx+nUMjVrV1dR3y7W2uz6WjTsqaB47GnwOFysz+hLUYkHz/z1P0n9if3Sp47W9HzSGkuu+vNfmUuLxhfEMMvrgi/WS1z+V9Dk1B2200V+ZWiapT6YxftB4PCHjntAd8Ua32qzTB1SCK8cQB8aMiVloAqStC1ihHqK8szs+IUEyKLVZaPapkzQ5Ypah9QkETYFgeCBWpicmfRSKbzpftH7uCsH4DREEGllZmfj9fnSpI4Cvv/7asiST6Lh1SHcPB08+BY4AmjTcYnVdx+GI3ZfrtOgkijD/L0AIS9Asrqgg5TvfQzOzNbcnaIIxSR31BtCcbkQkwsbFG+PKLKioxiEEuoS6TuKoVybBEqajhCIdb6csNA92hqZ5CC7/0tAAdf2ADQD+tSM+1JOUEodw8Pe//91apus67qAb6R6Idc2YZoRCtj1jvJde3eV2RXTdFiuyi37qHSAdh8YZ/O+dJR2uFy1B0iojaH37xy0vyegTy7oEHHfccUQiKhyOIjFdvZycQhDWJeUJ4sUbp5ua7joQlKCpOKh5q7iMKxavZnl1XcL1Re3Eg0u2mNGaf+8sYdjbn3Hrik28W9I1YaAnzMkrKirQsrIBEMEW0kzrsEyXkye+Nc4q97ctRd2y/622OFNDyuPv8tkim0UvLuLIrHRy3IbwsrSyTsUOOQiotsVijLptNxeaVjktOnX3NXB7+p08kvlHdm/YzbdyDdfv5ojO5vrkhzAoaYrVmV0vaXS4OGZU4rL//RhScwZQqVd2a1KgqCCZ2iwJuVoo3gtbiyVTfy65cpbk+Y80TvvgFNaEVhvlRBrXeWfirzJiMNUGQ0SSHIxrp3m9OUOSnFq44CEngy7RefyzK9nR/3yrXPO6RkakpbbZPtkJ1OIsNOtiMTSBNlnqo6RUhK3MxN2dgV2h+KZS5o9dm3NLK9usl+hGRnIpCdWHiMgIUWEllhFZkCNdDND6GK9eIrqtIdJcddVVptAXFQMMRUYKLEElmi1dSolI8WKGZDbcxdu5PdYHQ9YYMKO4Br1gJ5n+rDblNEBH8kdb7MtEPBFNSLQPhBt6Nza7oudwaxqy3pzklfDOu+8ltX6pRxDCQVFRbByek5PDMMdwJLpNLBfmpdTKojKagEtKtE7k8eLiYn79m99Y20StpQ/IQvMQcDl/ZnsxWxs6GptKNC0FPaVtwqXd2XmgaVY4jKKiIlauXNlNLVUc6nT1UoqGRHk6QS4LRwfPP0XXUIKm4qBFl5L/W7mFT8qqOOfT5QnFgEJf4kC89Qli0ySLTXWN3LZyM80Rnf8U7GFVTUPcelck8cC3J6yP9u7di8gyYlSGa2sM1wmTswf2ZUymEffP/nKTTKIWmo6WMLnmeDA8IfZbbH9zJ5oQnNzPaGN9KKzcTA8CamzWh1Erx0BpgIg/wrpb1lP9uWHRkypSySrK5rg+sSQQK9qZbDgQymzCWHYDNDjdHDM68SC6sRne+jKXUr20VQzNJCcFChrXdXoT7KU/I6+Q3PkPSXTi/vXPJGl90/jyuCVWDKwzU85CVBifJYaomSx0KdljtimvCjQJG6tclFXD9rIMqkfcTa00rse6NfWMTPe2qaPYl9z7gN1CM+py/sLdgtsuT+xyDhAsC1oTHN3hlq9QKAxPko6ICpqpTWnkO/ORSIR5PQ4YMMAqFcN0LaeFZgJIKQ3hM2UIeEe1kVmE+b877rjD+C4Mi03NNPD/9/PPG5ZkCRC2l72UumZEUxONTY0dlks2wdr4e1NrC82uxCQuKCjg448/5q5f350gIYziYEGXEqnrZlYenZk3zGTHjh2dbpeIRYsW8cILL3D77bdby6Su49CcnPfLX1nLonFqQSKEM/rRTAyUeOwTkdCZtvjDH/4QTYr4VFRi/wVNrf+gA7bw7Al2Nfk7bKZ09TcSJMm2mc41YV7fEkY6RyIyMm2TOoqDmSW95PXncRjnx4a6xnaNdLQOvBA0aHedomuoK1Rx0FIXDMXFw3x/T9tsc/akGGmO2OncXZnOw7rOz5ZvbHf9xOwMpq38nOAXC9Ab6gjMi8Wz7A6XUzDizp0070u+t2gVu4UTLSMTAFlfy9tvvx1XNtNlDJSaI3rSrcUCkQiF5u+RVx5GM91lJj8yySrj2mQIFyf1y7aWfVlZi6J3qQvEhCjLylHC+ls3UvZOeVzZidoxDGiOvUx2RxxNexiJ7Hogw8XI+KTrPHaLsAasf31LUJNSG5flPJkxNMO6TpN5vWT4oMHhRkp474tYmcXroKlZcsesO/jAO8da3r8uljwomZMa5f4WoiFD+1eCDnEu3gjBTlMoDNeGkYG2Am9nmRn3ldZJgZocTvpmwfD+Ii5LfYiYONBc0mwlT+que6RCoegAKdGlRKAxwTnRsKsMhRn63vI2RYU07S7Ne0+x5qNR+mKCpoyAdICrn1FICNADmMEAqaoy42abN2/NrO9/j79B9Zq6hNYu9tiYEokb437ROo5mT8TQbI/71mzrtMxVV11FfUM9X3+1nOeff/6A9tc6WZIieUQMk+Oo6TEIjSVLluxXXVOnTqXe38Ljjz/O7t278Vx1A0gdp3DSOGx0m/JSeMBtDnZaSszrJPGr+vq6xrh3oETMnz+fCc6J9HXk2aYj9i+GZljXyXz06UPCQrNTHFnku0YxVPRrI9BqQgOHExHR6afl4Rg1Ni6chuLgIxCJ8Mz2Ypp6+L6oS0lZYRmYSYH+V1SW8Bn0j23F7Sa+g5jY2V35Lb4JKEFTcdBS2erl9qltbS0MCm0u55FdsRnU7soovrSqjjW1bS0DAG4fN5LPv30ikaICfH/9A/U/upy+S7dY61sfT7L448YCtjb4+LS8mvIbbrWWj/blseSl+EFYNEEJgC/JFgIFjc1W8PTh5YaQkn5EGoOnDKY8xRDFhoaHsWPlDk4xLTQBvlCCZq9jnziwx6EsfbOsTdlJruPQdxVYs/0du/XsH1X29jRqZPRxMLRVroVLToeLTzU+l1VDVfbQbrPQrAuGrZeBjCYj63prQmFYsNp4gXmh4HkrHk6eL5YcqyaJFpq77AmBKg33bl1oNMwTmBEB2JkZ89M/ZmNb4Tn5FppGfUKXZJmxT7PToV821DlTrHIlabHfpnJtJbkpRn82R3T1oq5QdBPtvSw5Bg9Fx0gKlC7SwYx3OcV1Ypuy2x1+9lJriQBSSEBD13U0TUPIiJHExIr7JyDSYLlv6pYlo2EZFbXQFLok0E5YHoGw7r+pIpWT3CcDhkBop/6rOiKhboqf3upls7WF5ueff95pFV9//bWVXnl/Lf6i/H7Dvm3/WCdu+IoYEV0HPYJbuAxLTVPA219DiZSzZwCGFaZwuekv8piccgIJ0/o40hDuwQBIGTYus+ZNcUXGuoykiIW+ZvY0d/4MlzKCJpyGUCqNSYb9EU50CcLj6RZB88MEBisHgujEClViCNWJXPY1YcTqBQfNshmhOZSg2Ys8u31354UwJtRDuk6FvwVfD40j7/5qHT+46Ad4V+5k3rx5pjAZX2bZsmUAFBYUtGuF6TDd0X+/of1M6IqOUYKm4qCldczJ5dX1rGnl3r3TFrOxbt1q63N9sHsEza0dxAscl2W44VZXVwNwunsq98s7rPXd4U7pC0f4uKxtPCyAkU25XFFwNaWlpdaydGfMgqsxyTf8LTZha6gZPzNjvOmafEzsJv7l00s5OivDshZdWlmrZqV6GXu8SU/beNWM+fVoQhON6zFby2bP4kIGmEmmSrshfEF12HY+NLvIyaSNoDliAPzie7HBaHn6hDgLzWTG0KwOxu5F6b747N125n1ltNvhcRDuY+x/oC/dWp9MC80Cm2VG/0ojzmi6FzJSBd+fbixfl97PKjPy/Rr+fvzR/Gj0UGtZsi00oy9X2Q3g1I1+6pNhCJo7vLEwBe9kTSZ696lbVU+OO2a9mUzRV6FQGM9YMGJ3JUqI45p0Arpw2F7upeFyHv1mez7rhtkaoIGM6iOCDz74wHTLjMXejAo2AvBIjaHOYbHkGmZczaigqcsIYT1C05a2IWgkksWLF5v719HQ0J2atSxKqCpI2BQ0y/0t6LrOm9sLu9pNHRLtAkumbSVorlmzZh/r69kxzzcpnEdnSaE6I2ImAxrmGE4/kQtC4wtHKmfP/+qA6hWWVbIgrLX3+5vXlogmBdIQwfiJZZdpoRzRJY6uiIvReLbC0fXU6AnQzY2l6W2h6zqflFXtf4U2liTBsOGNolg/bd+2naf/8Q9+8YtfdLCFSOjM7xAC4XQinEOMBZqm3lF6kV2+xLky7EgzPENIl3xeUc3ORl9Sf7PalhBbEoRH+3rVKloCfrI37ub8G25MmNzupJNOAuD5554jENHbJOiEaAxp2WNC7OGIEjQVBy2VCQZga2vjBc0tZnZmGfATKY+5H3WXy3lBO0mIAMZlGcJFTY0Rw+NX6XeTaTPm7I4Ymp+UVeGPJLZIyGwyrBne+08soHmGKzbLmOykKfYM54PMcUXm0YaIceRlY611VV9X49AEU/pmG99bQh32q6L7abadQt5W+uTQHwxm1G359JvW11rWuNTHQFPQ3BsIEmznHNxf6szxQEajpBk3uZmQmQbDzGSUJx4NmiY4bSIMNjW7Cu1IvHFJgZI3MKix3YsymtoXND/8Kvai6hlh9E9uU6xsdRITg8VZaO41rEb7mpaZM2cYA6aNqdkEzLFTyhY3V40YyM/GDre2251kC81ojNAM877XZBM0Cz0Z3DfsWB4bPJ7PsgdS5DHul5EinRybq7xyO1cokkvUY0VDJLSADnz0HrpwomnR8UE7Iol3jLnatJh0pgM6Ao01a9bEJQ8CUzsRglFhL04p8GheS9CUCJA6ac1QePpIItkZoEOwJvH1P+e99xj90TZD0BQOCs6Kd9f99/bdzJ8/n5/99GfoEZ2/bN7F5MmTueHhx5g/f36X+qkjoq727RfoqtWamShJCSTdxiMbD8waNSJ1MC2J87V8EIJK4WRH4wGMU4XGRn8IpGSPrGePvqfdE0pY149EmGJaovNlkDuFU72Zne5ak6ALo0bcAxHtWGj+adOuDmPBRjeRHsMlvqWlhc8rqjvdf1f4IAkWmmtqGihpDlDU5Of9998nEGjhr3/9K01NCeL0SwgRpklztlklhEA43LHfRwgyMjvvZ0XvITFEwbCUVoK5hw/wPhBle4OPPf4AixPE59R1HakZz4eU6ReiifZjYaZqaUx4fzEpCeKxOjrYTtE19lnQ/P3vf88555zD1KlTueKKK6wZ0jlz5jBlyhROO+006y+azRBg48aNXHXVVZxyyincdNNNlJXFZlICgQD33HMPp59+Oueffz7z5s2L2+ecOXOYMWMGU6dOZdasWYS6MeGL4uAhUVbwIlsSoGBEZ69pyRWpKEP6Yg+t7koKZBfejsqKWV6laBr5ZtKNqIUmGOKQMGPvNXaDyPru7liG9cty0uLWZTUY+934WsxdxW6hmeykKdsaY4LmYPPSzzAFzUkXHWut0/YYA7TjcmIDhPbc+BU9g91Oz+uH0qP6k35kOpOeO4YJT4xHaIJxlx9llXFtdZFniuMSKA8kMOvcT6SUNArj0ZRdbwh1OZnGIPPtBwV3fx/++9to9l3B984wtvNp7vgYmkm83qrjBE1JozNe0BxleIixqwx2m+PyfhP7meVt9STR+tB+L8yrMgXNbOP7MaMFOZkQ0hys9xrZzT1+D42bmxjoTcFhvnwXt5NUbX/QpSRo3uvc5mE2OZyWyznAiox+LMgeiC4E27yG+iqkIL0uNpD7JlkSKRQ9Qdi8Ll2aICT1uDiV7777LoRC6BiC565QASCRnhFAvJuldKQb20a1Oy0VHRDmq4SmaabYKRFSgLnW2BgQmuVyHt4bASk5YieEvS7DJlSXhDq4bwsJsh3hsFlKfE2NrFm7nvUb1lNQsJM1a9YQDoWZPn161zurHQxRqT2bLrqc6tawuvtmCJrhLiRKOthoaWnhgQcfBF2nwOE3lZIDt/3Rhgzjl4WGNWPAM4yACJJI0ZQymowI63yT7Sify79Ygmdp50k1hRSx60bzIEhscdgQCnd4Gq8wM31Ho0noSfx9kxH+RghDfNrW2BQ3wRAMJpgkkZIG0UyRXtpmlSYEQtPifh6VgfrgJhqbMqxLI5YyMmnvAJ9XVCf0bIDY8yAaU9phWlomYpx7PADeBOELgqUtStA8QPb5Ln3NNdcwZ84cFi5cyL333ss999xDQ4NhNXfCCSewePFi6y+aGTEYDHLnnXdy5ZVX8tlnnzF+/Hjuvfdeq85//vOf1NfXM3fuXB566CEefvhhioqMeIk7duzgz3/+M4899hgffPABpaWlPPfcc8k4dsVBTqKYk9EA2I9u3MmAtz5FNwcaekUZsjkmqHWXhWbUKsrr0Dh3YMxibYTHidNsi13QFMQs3pLdpkAk5m6em+LiMke8qJRifk3dmcbevYbKYo+h2V0WmlpYJ8/0gk8dm86/P5R8/4kU6lxGgwZFBrFjxw4m9bEJmq1CCSh6lqAWOy9CISc/0iYy8u2TGXjxAGt51tgs/GaAzTHaWBp27bLWlXYhjlNXqQ+FiZiCZpaZ4TzXPFUmjxU8dJPGqMGxweoVZxqf/ZozPoZmEs9vuwtbmi8+hubpx8CVZ8bKfmXOH+SOzwHiBc1kWmnbXVPSmo1+ilpoAlYSpVUZg2P7/6wKp6YxyLSu3Z3E3y1gs9J1h8CnOXG6NbwpxLUrylabZUnK7ti9S1loKhTJZduOHbz55pss/vxzQrqMMya8+OKLGeYYZn4TRDDvm648hHkftsSPSJNVLmaupccLmsRe7owdxV74hE3QDNVG4kRAXeos/XIp69ev53e/+11c++3veY2ygRo9cSZbqRuxAutq6xKLGO2wrKqOnY0dx4KWOlx77bW89eab7N27N87l/NxP9+FFVMp2LeS6m3mlicMTdRf3r9veo/vrKk0djMXffPNNVq9ei9R1Q46P/l4H4qsNEAoSioYtkIblZSKkMCYIWjTNPFdsgSCsc0Zy5Oz1PPj73xMIdCGGJrp1vloiaYLzz0zsnZCamhpOnzrVqMN0mU2WoPnKK68AcNNNNx1wXcZ8S/ykQ6J2SiRCOJB628l4TQg04Yj95sp67qAnaqEZ0nUEhtt3l43mO6AyEMScg0p4bQghjGtWAlImdDm3lea8Qf1wJbj9NK6sJ9I6+KZin9hnQXPEiBG4zXhXQgiCwWAsa2E7rFy5Eq/Xy0UXXURKSgo/+tGP2LRpk2WlOXfuXG666SbS09M55phjOP300/n4448BmDdvHtOnT2fcuHGkp6dz44038uGHH7a7r2AwSFNTU9xfIBBA1/Vu/QO6fR+Hw9++9FNlAquvQl8zNYEW/ry5MG65vjde0KxrCSW97SFbFu+R6am49sSSFFWuXomu6/h8Pvz+eKunaJKVhmA4qX20x+e33M1P7deHmooKAnNjWc1HFBv/HuucxGfzP0PXddJsgmZjF9vT1b+oqNWnVuLUQctyMOU3bq7/g+TtRbDTdFNJ1zJY/O4SJmTHLFzX1NZ323n0Tf7raj+FbQJdc8S4v6/YKuPKSCnpc1I2AB7hoXTJBmubkmZ/0trcZBMPU/0xC832yh9/pGRIP/BrDlxhcISjFtGRpPWRr1WM0SaHi8dugbXPw0ePwfEx41WWbTT6LXWUYRkZZ6EZCCatn+yuo+6g4Qafa+unEaYWvSojFkez8rMqdF1naKqRqKg2GKK+pWtt6qyf/LY+coVi1plSSlxOSWa8AblloQnQtCLmsVEVaOn162Z//7r7vqRQ7A+/vucedhfv5pWXXuKe++7j/TnvW5OcAJlaVgK7QxkTJqPoxoSusL3dSSEtAUHTtJj4E6ogWkgX0rSuxHI5H10niJTFwgRJXadIGCKk3eChfk10stMwWauQe6mRNQxZVty2xVLHoTmI6PvmfbKnOUBdq7jruq5TWVlJKBzmscceY+7cubzy6isUFhZyyy237FP9cW30DARXbqeCZkMH1vwvFexpd117CEjoMtmd9ObreXsWVQB/2Nh+4o2FCxdyhGsMI7WRQMyidl8E8oREdJwxZRI0Z2KrXv9OtJbdFHgM7yZjUsFwOY89AwQiooPQWLxoETt3dpxIREodLSpomnUmOv802s/CvGTJElsiMGNZsp5JM5/7LwDPPPMM9fVtkxfuC7qUbNu61exbCUIQTji5LRHCSaKztKmhAaE54idcevVsVnSGlEbM56jL+QPrDizpWsB8Tl25eLVxubZjmR+ORMxJCIH7pNNNC83Y+paIDm7DgEBHp2jDBkIFlXz00Udx9TicgnDQ2GeJz98tHp2HO22DR3SBhx9+mDlz5tDS0sLUqVPJz89n48aNrF27lrPOOoucnByuuOIKLrvsMgAKCgoYPToW78br9TJkyBAKCgpIS0ujuro6bv2YMWPYuHGjtW00oCrAEUccwZ49ewgEAng8seyxUV544QWeeeaZuGXf+973uPzyy/fnUPeJ3bu7lonrm05X+6m4ts76rGE4L+1q8PHc2s20tHqQart2cys387z5vayuzrLyTRalLSFC5gOuv5AUf/QBkfxj0PrmUfTGS2y65Ns0Nhqu02ki9vae6odqoD4Y6nKbutJHm5tiM7OulgBbtmzB/8pzjA+P5rSm8Qw3x7xZWhYrPvyKopOKCDbEBgu7ysspCicvdqXffACkthgDsPpcL5uKYg+BXe4MJmMMqNd9sJZp3z2DPJeDvaEIa6rr2VVYaA26uoK63rpGZ/3U0tICKca91B2UNGnGw/fTr+o5dmhdXNnsKVmUf2a8CKduD8C3jeUb95QzOcFM93611/Yi4gobgmZeuIaiovbDEowamMfX5YYo6w1AUzrU+QNJu972VMUC1qcEjTb1S60gwxGgrBQGZWiAkWxn0ZoARUUVhDzGC6k9ju7u+oak3ZfqmmPXbrSf0kUDRUVGW3PTsoEsStyp1MgmckQ6VSuq+PLLL+kjY4/+r3YUcERqCl2ho36qDMYLmo0OF+meEEVFhktXn7RBNPhiwnlxSjp+Inhx4NoShLOMNhTsraLIfei+PHTnfWnkyJHdVrfi8MVK76NHeGfOHEadfj0//vGP+d///gcYYldJai6EswyrMCnM7OVRqy6776WONEUWIk1IqVuWnIaFps3F3LSXKnAE0HQXEU0jHA7z9ddfs/mDBcgWYxL6yLnl7EJH96ZAK0PJiC/M6uVr8OAxxCVnH0SwHm99W8s0oy0O0mvSwXIu2L97yU9+8hNeDmgsdEh2fjiHUef+xKpv7ty5zJw5c5/rdH3rZHZfPIbU5d5Oyz68sYCHJo1NuG5LQ1NXPdy/sTyycSePTT6q84KtEKZVcZYwPQjMrOALFy3CM+PS/W+QpvHTwTn8DgydTWvrdmoQNsyBo/t2xKyhrYRa0TrMiYUf/OAHfPnll+3vWwLW/iSaTdBcV9vARNNbSovGxm0PIdAbG4hKB8kSNB2DhxHeYkyQ+3w+srISuHR0kVA4zC9+/nNck06ASAQ0ra0YbR6/SJAkafbs2SxbuhRNc9pWCSKHqM95SNdxJSFkQm/SlXtd1IoyZLqc+yP7H1KtoLGZZ3fs5qFJY1ld28D3hg9s19pz9epVeIVxjWq5/dCAv28t4v5jjgBgfV0jrm8ZGpYIh1mzaBFnp5/HuXeeG/dcdTg0QqYJ9+cVNRyXk8m47Iw2+1O0z34JmnfddRd33HEHK1asYMcOQwU/7rjjeO211xgwYACbNm3i9ttvJzc3l2nTpuH3+0lLizfPSEtLw+/309zcjMPhiBMn09LSaDZf1lpvm56ebi1PJGjOnDmTa665Jv4gnU7LqrQ70HWd3bt3M3ToUFtQdEVr9rWfmgti7jGTc7JYXlNPQ0Tn7drYi3zL4k/RS4r42bpJHJMbG/xF3B6GDx+e1PYXVtQAhhhxdF4uy7duoeFvf0V4UxG+ZiZMmGCV7avF3NGjbrAtUjJw6FDcHRz7vvRRQXk1UALA0NwcWsJhCIU4aXYJZ3nGx5XNWz2A4cOHM0y6odiwqPZkZTN8+NDW1e4XUkpCy417QdScvjAtx1ChTQo9MYvM5m1+hg8fznEldcwrq8KnSyK5eYzMSO10X+p66xpd7aeysjI0r/HbeP1QZ2aw3F6exfDhxsCythHeWghHj8sFDEHzqIb+RKOz+j3epF1vzfVNsN6wvnGFDFfq0cNzGD48p91txuXDorXGYMDTYgiaAei0TV3to5TGMMa0hCFoNjpcnHFCNkPMzOvDMVy8d5XBxiIPgwYPxzlMsj1lJ96AhjMkCbsEjWhJ6yd9WznQgjso0aQhaE4cmsnw4cbLycSxwFxACAo1HzkyHeHTuOKcK7j4zZeteiJZOQwf1DfhPqx9daGf9KZmWFsIGC7nTQ4XeX1c1vEO7AtFtrj/uhDs8miMC8DA+tgzPuxNTfq9uydQ9yXFQYtDwzl2HOHtm8HhJEvLYvbs2dYELMC61D6IRtt5KwwZdPDgwa0qk6boIyHSbL70m67mid76opmddQEOB1JKpkyZwgUn3BNrXkiCgIydFTBgSNzm/kCAH3z3R6SffBZDHUOpd5QghS9Oh1i/fr3RMj2CpjmoL2ugLqOuS4l6PimrJJHo+a9//YsJNzzG1oKPEe4UQ/zooD6tTw6OI47scF/OoyaAlkAk3g+S4U55OPP8zpL9EjTD4TASyXDHcIoxY+ALDc+MSwltXAPsZzxWh4Mn//ZXcHmN374LzwjDPVxDYogzdgHRSBjkQABLly5tt46U73wPWRkLC9Ha5fz1ojJL0BSifQtNY72gZd470O8yRJ9co6+SofMJgfPI8db94UCob2iwBGG37sSvadTW1jJs2DCrjPOYycZubaKyrutomsall16K57LvG8mYbPW250YspSQiJfPLqzl3UL+EZXqT+9dt5/fHJp4YOZTYVNdoCXxfV9VxQjRgvInEsKKsqKxk4JBBB3RePrczflJaItu10tR1aVo8G+ecJgTFzTEvTa9DQ5gGIxnF1RDcSOqUy+LqaGhoYO2a1eys+JTMSy7gv7v2MDl3/0X9byr7JWgCOBwOpkyZwquvvkp+fn6cFeX48eO58sorWbBgAdOmTcPr9eLzxU+7+nw+vF4vqampRCKROItLn89HaqohbLTeNpqtzOtNPMPpdru7VbzsCE3T1ItMF+hqP1VFM+a6nIzNSmN5jWFduNWM1eiuKKX274/QT+vHtOzrCdg8vRvDkaT/FrtsCTRGpnn527JloOtMCY7nl33uZFVoJX9o+j0QL2im2trVFNbp6+n8sutKH9XbXE77pLhYZ7qQ5Wq51vKIjOAQDoaWDeO5B59nzSAXZA4CwBfRk9ZHIV23tEunKWgubUqDVEj1GAkji1Jis02Z9VnU1tYyKSeLeWWGwLq+vpExtkRLnaGut67RWT/V1dUhUlORGOJ7ndO4fy7bBP+eJ/h6s+S1T6GuCbzuNP6XIRCNksn1I3jLrKPUH0zabxG0jURcYahyuOiXLdC09t/g8gdKpIBmzYHXb5yJTftwD+isj5ptLxIpLRDOdDO0v4h7gZ8yTmdXGfhbYOMuwXFjNVKGpxDcFiK7AapyjbjAyeqn6Ay02zQ+aHC64/pp9GDT5QoodsJxpgdjv2Aes597Bi6/HoDSQEtS+iloG0BGLTSzM2Jx9fplt7Xm2J6Ty7jSmji3/Jpg6JC+rtV9SXHQoTlwHnEURCIIW2LAqKBphbyMCpO6NC00ISXFZr0tIS7RjzC+213Oo/E1RdTlE8OKzBGWSEfMMsyBg7GOmACo2yxC7ZTsMVxNNDS8eEFoIBzgisV3PvXUUxn4iydN11pDpIh6eXXG5xU1TOqTmVAg9OCBcARcLnCa4yqz/a3FW1dmLqHBw1pXAcD62kYm9Mmwtm8vhqGdZMc47w1604r0xFaCR1eJRCI0yUaKIkUIJhhWweYzNVK4/1mThctFZXkFjiHDEbpunMMJO0ha12HUZVomsNAcrY1ijdDM66x9tOxcqNDjzld7UiBfOEIwouN2aAgE7dlcSilxCDdHa+MA8Jx7ES0HYAXXqnLYYFho7q/V5/z583l74XKqBuSChDHOsaTqGks1h+GFZEM4XRh960RiJGG6/PLLefPNN40Cus0d3dnXsExtp59L/S28u7uCPf5AUgTNRzbu5FdHj+pS2WBEx6UJPiqrOijF1GTycmEpvz92LCur63m3pKKNoKlLyZIli1n90Uqkr4QhP/tFmzq2N/g4wox9pEvJiztLuGF0YqMe+68tEHy1/GuKAyH0UYOt8d2/Pl1ortc4xnksO4Ddy3cTGBzToDRhTOQBRGTsWZl2628o8wcY6PVw9913s6Mgk81pHqbv3Mkmzdte6jlFBxzwqFvXdUpKStost9888/PzLUtOMKwrS0pKyM/PJzMzk9zc3Lj127ZtIz8/P+G227dvZ/DgwQmtMxWHF9EYODk4GJ5AwG74eA4APxloxDNKCYJmBtXtjizn9gznN11yEXV1dQDckvb/SBWpnOo+jSOdxoxwrhZ7uNgFzWQmBqq3xVjKdrmsmFi5ppiquQWzXYbkJBBsenQz//rrX61tmsJJGoxgxgkxiWY43imNSYnzT4LzpkBxShoR8zY9wjGCrVu3cmxOTORcrRID9Qo1NTVIj/HSGo0PCdDggxseljz9riFmAviDguCRxovdoMY0K/VjqT95yWXs55IrZFge9unE8yKaAMevOfCYY1d/RE9allW/7VpxBSE1x9nmhXbKUbHvX202/s0xEwNlmad2dUsoaW2KJuGxBE2HK2FSIICilJgF5DDHcKp2xWJu1SQpq3jA9nLjNmNo2n+3aKZzOyszDWusOEFTZTlXKJJLNKtqJBz7bMNM8WFajcmoGRcg0HU9XnyThsUa6ccYW5mJS4C2Qr5ZhwCOWh7CU7zXEixcuBjkMKw/hRmUr3UyD5/Px7pjcmDgoJiFmVknIibMNjQ0kLmnHokHoTkRGIJpXPKiDkgspZqHkJqK5+IrzbbZRKFW9//+Wv9263+tqFUm5S4kBfrvrrbZl/eX2bNns2DBZzQ2tB+25XBjUk5mwuUf7NmbcHmUcDiMwIE1Ra/rHbiHd43MknrD5Tsa21VK0Bxokbav4LopYkLUjTZ2ntljQaaLNAY4B3Kk4yjcZ5/f4f6NBDha7LMWEzTnl1WxutYYoGiCdq8XabreH+c6zmrbm2+9zdtvv81nn33WaR90xphiFyDi3er3genTp1NUVMQLL7wAUseN27Cu1RLEC3W5TJdzp5HUTMJbb71lK2D2lwQ8xiRFexaaepKSz0TZl3fEp7cXszcQ7PHYuL3J27vLE56iEvj4o48Y5s5nQH1/dmzeQU1NfL88v7OEgsZmGoIhHli3g51N7Ydcs/+kRYW7+PVvf8u//vlP3nnnHWv5rf9+1Yqxm22GqFg6eykff/Sx9T7uEILUa2402yjRzOeY+6SphMz3p6effhpdAzIy2VBdZ7nPK/aNfRI0m5ub+fDDD2lubiYcDvPpp5+ycuVKJk2axJdffkltrRG7a8uWLbz++uucdtppAEyePBm/38+cOXMIBoM899xzjBs3joEDjTeuGTNm8Oyzz+Lz+Vi/fj2LFi1i+nTDrP/cc89l/vz5bNmyhaamJp5//nnOO++8ZPaB4iAkGNGpN2/s7i0BXHNr49Y7gMCiTwEYz0TAuAFFxcPuyHIezbAOECmPBWW3W0Se5DqJMY4xHOE4wlrm7SZBs85WV/VTuxm/YQIamtUeV14Ku48opkk3BrGnuU/HFYht01Gmx33FHtM0aqFZ5jYEzbMnCy46VRDWNPakGMuGOoaydcNWxmTELDL3NCcnBqNi3yivqbVecr1+aOlk8F5oZqd26uCsM86tPcnMlm07l1xhw/IwK62DDYiJd82aE4+tKb4kifbNNpE1EnaSkdZ2tHHi0bHPHyw1BiregcZETFTQlEBVkgS7aFKg6ARCg8OFfdJ6eP/YoKgoNc9aPsIx3IyDZVB9oMkOTFoL0Y0OF31sBteJMp2v1vJo1BtJCYG7xeizZGaCVyi+6Wxv8CE8xn1I6kYikSjRF/1RjiMs91bcQxBahpW5NVpGIExjS6MO6ehj1IFkoOjH8ccfbyUFshDEXM5N1VDXdUaMGGFaKUZjBQqkJmgdwe9Xv/oVukMDTUOTwkpSJETiZ5T0jkZz9UEC41yGJdk459FxZZrDEZr3xL/IduRmK3UdHE5LbB3tGB1fQECd05gEdE8x3nkcw/MT1mXvmwOJPyhl160fa2trufTSS1m7bh3vvffefu/zUCGk61S3BNvtny8raxOvMIlEImgIS9CUSMvqd3/pv77cGGNFn5HSSMzTsiFIYWFhrKBwxWfpNicLoofSWuzThIaGhmNgfJiGOKREph6NcA+w9m2PoelxaATNc1Fg2F/P3l2esCohYtcgus5tt91GcVERZ511Vle6oWMSxQndH4QWs6LW48Vbq4jTtL7UXCAl45zxIboG0B+htc5ynnh3ujREq2KbB9+BsKXe13kha9/JFVMPZp7ZvpuGYIh1tY0JjzncojNSG0H90CyCHg0hHHwx/4s25b6srKXE30JIdnz/bY5EKDF/008++YRULZ1ckcMdd9wRV+5o5/hWSfKMvATRXC4OgWHhj5EUSLPJblaiLikRwRCiuJiyPnmMTPcSkbCpvglF19knQVMIwbvvvsuMGTM466yzeOGFF3jwwQcZPXo0X331FZdffjmnnXYav/71r7n22mstUdLtdvPoo4/y8ssvM23aNNauXcsDDzxg1XvzzTeTnp7Oueeey1133cVdd93FiBEjABg9ejS33nort912GzNmzKB///7ccMMNyesBxUGJ/aU2sxHEa1Vx6/P99ciGOty4SQ3E4i5GBc36YPIFzegDS4aCyBqjPXmtZuUv817On7P+ygxPbMa0uyw062wWmqEl9Zxceyrf9/6ATM0QnFbVeKjLu4klwcWAkZn6qFAsqURjEi00A63EjJAQ1DgNq7/p34ITzFBGW83Mxi7hZu/nlfRJiSUJqesgq6ei+6ioiyWK8gagRcQ/Ft6YJSh8Q1ghn9Y3xKzjPWY8272BIMFIciwP44UxSYPDRWehVUcaURTwa04rZi2QtEyBjTbRLxR2tcnYDXD8kTDU1A0//ArKqiTuXOP8zrIZH3eUfXVfiLqcp9hczu2iYYpbEA2NWZwee8EekzYW2Rj7zWuTZaGptxU07THNQwluN7oQrJWGB0bUSlNZaCoUyeOZpcvR+sQmXdt7A5ZRO0X3IIQjm6hyIaVsZaFpupw3rbK2PM5xFAMHDjQsNIWwEgxbqpI0BU2zPiEMyUYi2eHNAATC4QERHy7qySeftNpsueGaSVtam1QOcQxF6jqaabkpMYoZlpoxbnjnI5a9s8xKWgpQt7qePy9rPyuue/KJ5j4FqbaEjzhd6E6ochrPROeR4zn3U4n79I7jLEqXk+K+gxKuq2kJ8nVVXYfb7wv2JGX2zPZ2Pq+oTtr+7NhPtWQ9Zzri66o69gaCvFlczqJFC+Osqez8Y1txu3WEw2E0m0s2ZqIpgEHaIO6+++59bpeQGPEhLQtN3chyDlx99dWxgq7+sROXaObmxBaaACF0KiN72zcvJro73RDvwBJMo8d3xfBBOKKTDua1u6K6babxL774AoFN0IQuxQHdJ8T+W2ja67AETdOqtM3kgctlCdXC5gYcZag2BIdmJgwK7jVc8dtRyCNSoiH4YE9lwvX7yoJ9uBY/Kauy4jrOK227/wONR9rbfFZebYmKYSmpagnxRXsTElLSR+RQMb4/wbQU0AT9fHltihmnR+f9UtIcYNZb7wKwq6CAFM3LYG1w21AjwmU8n2KPOoQ0PJHBFC1NIxGdSJyg6TCrcrlcOJpbcK4zwqRcM2IwAphdnHhiQZGYfYqh6fV6efrppxOuu+2227jtttva3fboo4/mtddeS7jO4/Hw4IMPtrvthRdeyIUXXrgvTVUc4rQWNPPi9Uw8q74CYJBjsOWuBDZBMxS2Bs7Jotpsk6yv52jH0VzrvR7h6mQjwOuPOTQ1JjEuUp1NtE0zDQ6u8F4Va68zhRVV30UPPcK5nhkAnBCZyC5zfTJjNAVbiRkVKR6kEAzpByMHCVqCxkzisox+TK8zXKmca11kOB04hSAsJTVK0OwVyusbwGvM3nsCEDQfvt4U+Ncdgu9NM87dY0ZJVm+H1XUeoq+CmTUhmkYZD/GKQAtD0zrP3toZLa3OpQZHYgHRTp8MQVa6xO9wxAuaSRLtG/wx6+GWiIvMBAKrwyG47lzJg/8xYsa+9DFc1dd4QbcLmhWBFiZwYNkLw7pO0HRXibqcNzqcbawgRw6EPZXg9w5kr76APK0fQ8UwpC0ZSHWSrrtAXNgJabicp8fuv+0ZXu7qG+TUWsjwQXWuEUNTl9KavVYoFPtHbW0tf/3Tn9CGjgAgZep0Wj7/qJ3SMpYJ2Qp9KeMtNMG0GhMQrgNyY0IorbKcQ5yFplGDIaQYbr2aZQElpADPCEPQaRXFLxojUM/NtokpMYuYKB486FJH05ytto8v99577zHeNYG33nrLCGclYdPmrWwd4CQSieBo7ZJvO36tT64hxErJK6+8gnPs0VSMdTNwm9lnmobW2byehPDRI9kwbEzC1bXBEBvqOnYN35dboz0MgGNk4th8H5dWcUb/3ITrDgR7GKFTP17KxgtPT/o+7Px+ww6ePMGwtlu1chWX3PpPKisr6du346R3dsLhMMKVh47x7Ja6jmZeFzlaLg8/fC933nknffr02ae2CYcDoUs8wmOY9WkCIWWChD4SYY8XHk3ARbyg2RzxEdYiFIR3tBHk2iI53nEUxUQv7dg5PrFPBiFdZ2V1vWmhKRNat7794TzD9T4ajSJJoXOipJkTBQciaI5yjmKrYzMyWofpu9vWQtNl/AYidg+yo0sdh2ktC3C6+wzC7YwlC4oKKSip2O82HwhLq+rQTP128d6aNnE0OwqlcSiw2+dnkDcWw7mlg3NOCsPKP+IyLWt1aGxqZOHChUydOhWA1TX1TMjOSPCLtyXQ0sJ//v1v3CdPg6OOwbv7c4TeNtTICMcIdmqadQ1KIeOeTZpt8k23hX4A+O+//8MdP74Jp9OJ7sgA3XixaGpqJJSbOGSGon1U5HrFQUllK0Ez3QdZ5kM4y6Gx4oV/ATA6Nd79J+reHZESf5IsxsAYwEZf/LXGJn6bfi/jXeM5mvGdbAmpNoElmRaaNY0xkcXja1tvtct4EKyllEbT7fxE/VhrfVMik6n9JM5CMwx7nMbgZKwZIz/FLRjWH1an5xIwb+hD9g4FHXJMK00laPYOlY0xtwZvAFo0jWfvFJS/I/j+t2MP79OMyA7sdcYsNPvUxZ7cyXI7t1toEtEIaQ7Su6CTjhxoWGh6bJELkiXaN/pj96NApH2B9frzYv31zBxJi8e00GyM9VNlElyq7fe2lCA0aU50odE6bJg9juaAEwwrTVfYRR+/x7IWSZqFZisr7aZWsU9/emmsb6ZNii1vNM1rM8x3+IiU3WJhr1B801i1ahVS1xFmosz04eNw4Ur4kisJWy9lQoIudBa5GuLEAAngygP3ANuy1kmBrJImsTrBcLUOhUIIIIT9XmhKC6624pMQGg0zTrPV147LuYy51AtAE46EgkW0LU1NTezatYv5ixZQtGMHr7zySpuy41xHo23cDAhSvvM9a/nHH3/ceu9xljod0o6F0FNbi+K+r61tIKInLtuwzhAL/1uwJ+H6KHZB03X0se2Wm9MNoswym6Vpmb/7QwrluN1t+sueg6ErRCIRNNcApCMbnNmAG6E5yJ+/3SoTCOz7WCfFkcpFrgvJ1rJBSjTNbcTLpK3FWCwjedRCs6079rbIVsMdXdc7NdyQEvI0U4CVUUtMo06nZhgUPPn1ap568kkeefSPaAKe2xGf6Xnwzb8wRP2oXtPFTO1dZYg2BJGaxuzK/YulnzLjUrwi1WhTVPiy3XOi/PWvfwWnMy6uaBukjqa54u4dkXDb67C6upoLL7qYx//46H61uT2aQuH4cXAHlPtbeLGgbR4TiIZCPpQlzRhOIdqNY/rvncbxb/nuRKRTQ2tpwbt6EyA444wzrHJfV9dbAjB0HLYj0BIECZGiApxHTUCaCbjs15rngu9SF6pEuHNYZBpz6KZ+Gb2+WqpaEAhGL2xBFy4c5rUd3rGFX911Fzt37sTpdCJThiCcWaR8/Dn3330fl1122SFvYdvTKEFTcVBSZXPLzGqUCGDavD2Ed21nz6P302zGgLvgWxfEbZdiGx8HkpWBD8N1NRrAd2hzH8utuyvExdBM4ot6ra2PVtUvYkNofdz6atPlO5JxHMtCxixwTktMiUmmhWZLK0EzGj9zlM2r6oghRnzGVemGJUCGnkH119Vkuw3RR7mc9w41zbF4YobLuYO+WZDZKk7kaccY36tdMUEztzFmopwsQdoujIUjDjJS6TDDeZT8gWZSINu7RrJE+yZT9HOEJT7hblfQHDVYcPoxxucde+CHT7d1Od+bhBc7vz0BTxAanC6y08HljO+nUYNi3xvzcqzPJ7i+hWwyFMRkxdC032+jLuf2fho3QvDZE4I3HxD84rJYu+SAsQCk28La1ap7gaIL/P73v+ecc85h6tSpXHHFFSxebIRXmTNnDlOmTOG0006z/srLY+5bGzdu5KqrruKUU07hpptuoqyszFoXCAS45557OP300zn//POZN29e3D7nzJnDjBkzmDp1KrNmzSLUDQkIk0U4HDZe7h2G1aLL/C/6mhR9YSrXy6Hm45jllpRIAbp3dFuXc+E0EvO0etmSUpoxNM3XCmmzjrQyg8dcedfqW6jUo643NhdyzZZVHazEHmYpw+KqvZd0Ka0ELhLD3VwmipVmJjbSdZ3Vq1cjzfiGDz/8cJuirsYAjl3FiGgTzWNyuVzIYAt528zfX8QLt+0izWNKwO7mABJDKJlcX8HzazcTbuelNtxoeCHdvWZrh7vTNA2tX3/cp7Yf51CIePEx2fTUi/nYzDRCUqdl/lzShBHAubXFbfR6jeZ8aI3hcg66kCDcSM8ohObEEdJJN+tsk/yqE8Y4xpDtzOUIMRoNI7u55nBZ56ZdcJOYIR2kqbzYxj5xLufOPDQRFebaHx/l5uZCXEIrGedyDsZu/rdsOXv27OGxP/+JpsYm7lm7La6e9PT0+ORIsnMhtSv85z//AcCnN5Fy1nksb9q/8ZGW2w9fP3PAEdeueJfzX/ziF2BlOY//HaN9ImUEh+a2BE0pSDix8NRTTxGKRCBJ75rRdr5XXMbmLsZPlBhj5sSJcg7tGJvR0JRfbzeeE8uWLQOgsrIyXtxvbBV3NBTGvSuxyBsNdRKtPxF6RGfP3r0QCjLQMQgHmhHjOUEf14Zqke50dIfhHpVS0wQFO63f0r8nYByEMxeZPtmarNC/WgpCsG3bNuNZgo6Gg9SIm+Ndx1Owaxc7d+5su0NFuyhBU3FQ0tpCE2DiW3U03vVTQl8vAWDkyJGcMurUuO3ctnfz5iRaaNrdMgc3Z7VZ70hzcNoXp3Dci8cy8P8NiFvXfVnOjbq0iCTgryPrF/Eia41poUnG8cxv+cRopw6uoHFXTmqWc3tSoBCUu43ZqtFDYk+MI8y45csyY3FNtr+xkxxT0PSFI12elVQkj1pbhnJvQNKiOdpY+gGcOsH4t0Vz4DetanNbYr7XyTqfArZ6whFnp/Ezo4wcaCQF8gZio45khXjwh43zMiVoCnUdtOmJ/yfINW8R2xvaupzvTYKFZpx7dxAaHO6ESXfOOSH2+eOWmKB5c+pPcDUav3vyspzbXc4NC800T3yZaccJvnuGYNyI2LJKxxhCMhg38ZPMyRbF4cs111zDnDlzWLhwIffeey/33HMPDQ3GxXbCCSewePFi62/AAOO5HAwGufPOO7nyyiv57LPPGD9+PPfee69V5z//+U/q6+uZO3cuDz30EA8//DBFRYbl3I4dO/jzn//MY489xgcffEBpaSnPPfdczx94FzEEEImIE3XavsU1EQDCIBwQ8ZmZWw2Hxdbx56S/ABFpIBbpJ3a/tYSe6CIRSyZkySlS4nA4kCkjrO2ydTcu4UjYtviNaeXGHo8kPuagE5cpELWqUQJuN/WhMJnlWaBpiIhOZWV8HDqBkfjOubMwzuUejDBbMuAnp8i4f0rz7btDQTPaNF22SYBk589PPMEXi5fwn3//u4PKIKjLThPfaZoGLjciJaXDct1FMKLzyMYCJuckeEDZaM9TYGWCeI7tIQTMeuB3RCpKGekcCbQVND/99FMcLWG+853vdFiXBAjtNSwaNQ0hYYDDuIfsq6ApJOiawCGF4YKqS5zC2VbQdKSZxxE7h+2hGSxB05UHjkxTYJQ4TjyN9ojVJWP/NycWdF1nwYIFLFu2FNfRx5JNJmgONm/cEPc8N9phiKJxkxRC4yjnuH3qCzsbN27kuuuuI0vLZk+kBKQk3Emylo4oO26wMYHT6t7UWlB3OFNMb/RYAiF7ORkNeRO15EOiJ8gKFA6HjTAdZl8VFBTsd9sBfv7znwPw57/+jfe6aDG91zRsSXRLPNRdzjUE9957L6toRuo6P77lFgD++9J/ueCCeGOmJtPTzN3YQuzIE1jni47uvAbr169nz95KZDBIX5GLQ2pkODIpvuhbbRNzOQebwTCNe4LW0ISjxBb70oF1jkWEcUw7wjs4zjnZDMssTEHTDGuCca9B0wgfxJOlByNK0FQclFTbBjfRZBH5jnzcZlwbr9fLiy++SEuhKQ4I2B7eFmeh6U+iYGdvT2aCibOIL0LGkekMuLA/4352FM702CDK200u53Xm4CatGZplMxf8+HxG/GS4tb4gxfD3zBh0FhvC63mm2XDT95oToEnNct7GQtMUNAfHyhxhipvL02MuZRte30CkITZgVZZZPU+97dz2BiAoNEuQszMgV5Bnei1F3c5zgzaL3ySdT82+WHuCurND8dDOyIECvxYfQzNZFpp+c3beEjQTZDmPMmmMYPWzxvp6Z/ckBWq23dvcpjWkPcN5lCnjIN+0kn6+Ipfcy4wL0i3cDGo2VOumcCQpCZ1au5w3Oly0F1J19BDoZ7Z3a3kOdXp9q1ABybt3Kw5fRowYgdt0pxZCEAwGqaqq6nCblStX4vV6ueiii0hJSeFHP/oRmzZtsqw0586dy0033UR6ejrHHHMMp59+uuVePG/ePKZPn864ceNIT0/nxhtv5MMPP2x3X8FgkKampri/QCCAruvd/gcxazRMUSdtT62ZRMK4P1lCiqs/Mpr8JNxgi6EpLOHDQkYA2cZvz4pZbjdjNIllJxeWJSc4LAup4TKdlFYJgaL7HPlFNYR10HWbWOhoU67E0WLG97QJWLaXV3u/ICVaTl9eq/UjdYl0aAg9QmVlZVy5mtFDaMlIMTKsm0mBosfar18/hKYhdCBUidsXRAZjDx/7b9EYChMwx2sOjNiJSNr+ZlIidUl1dTV5jv4EAgHCeoQvKqrjyklpSlym+PN2UVm758HcmiYQ4JSONu2Kq8/8nbvyd+PSdexq9FEdaOn0HPyysobCpmaOz81ss87+/dGNOxPW8VZxGU9sKuhSu4oKC3nl9ddB1xmkDbLOOXuZzZs2424KsmTJknbbbJeCpJQIzYnTlnKis74qbmpuVR/oGqagaVho4oiFQ7CuUz36EBQQaTLW24S1UCgEQkO4B4N7KEI4kK6BaH1yE/ZrQUGBeT/UYuKcNLKcRyIRXnvtNR555BFmzZoFGJakzj592UPbc0Ui0Rwaq1pWAjBK5IMmcIj2z6vO/hYuXAgYCUuj/RrRu34etv3dzN/OvK9I90A0oREOh+PKHZP6LYTdHdv8J06sst1HpJCEE5yz//jHP0DTrPA9p5566n61Pfr35JNPEnj/LdZt2sSGuka21jW2W7Y6YJwry8wkOUVN/jZlIrqe8D5zMP11dO5UVFYyZ1cJwxcXEg6HrPvvcMdw5s2bR0uLcf/ZWtfI6ecZeSKO+GgbhCPms0LE1R/9HNF1djU2E/CFWF1dR2MwFLffRSVlMa8A3fAH0AUM/nRjrG/Nc0VEAKfDes5ECOMQTnRdJxwO89wLzzPg/a/M8zvCGSln2U4543nodDrR0THuDg5bOIf9uxY669dk/34HC/uUFEih6CmqbPH40k1rcqdwcmz2JJ5f8hyeKg/B+WF2rSoEQOsnqC2pbWWhmbyX4hqbVVVGkwQNJjwxnvU/3wDAyJ+NsNan9HVzwjvHU7OijkVfNZD6dam1LqkWmpEQCEPQzBvWj8GDBzPwPp2PCj28vT6F3R7T5SZrCg8//AjvvfcuuzbswuPPpyGj+yw03SFJedTl3CZoRsXNBqebAs1Hvp7GgMBAVny6AE47AzDclgd4e8eS4JtKo20W0BMwLDBz2slZc/QI2FsLZZqH4TSS2hKbE0vW+dTos70URrROEwJFGdIPlmhOBtoFzSRZ+gXNAW9KS+cWmgBD+wuG9JOU7HUSFoKshtgL/t4kCJp2l/OUINQ7XAktNIUQXH22mahICpZOPYpjV9XSXNBMX5+HaJSsZFx3LQlczlPbqVIIwakTJLMXQ0Ozg3oRiE+elsT7pOLw5uGHH2bOnDm0tLQwdepU8vPz2bhxI2vXruWss84iJyeHK664wspqXVBQwOjRsdjbXq+XIUOGUFBQQFpaGtXV1XHrx4wZw8aNG61tTzrpJGvdEUccwZ49ewgEAng8rcyRgRdeeIFnnnkmbtn3vvc9Lr/88qT2QXuUl5cbL/dCMHRpETlfbGEvAlKMh3FJid0tT8a7TZufw+FwnLs+rUSW6Ifm5mbTOtZmJyGEkawBw4JR4LbEBeNSN15Bygigo8dZS0WtYtMrW0A4QUKhI2DV27pcCzq6JrGZjhrFnH3jylnHFw7zv4YgowHPrlICVSVWuZAucU+dTt0QD94MD1qTxp4zBsICww1YSmkIRZrDTFokGbFoF1sXLUAbd0+b/c0pLmdGqgOpSyPbuy7RI+G4MgANjQ2UlhoxMfO0PCpkMUVFxexo9DOoOTYr1tjQQDAYpKjIyNa9oHA3k/TEcR0fKq5GpGVYYnDrfUbre7minh9ld+0ZML+0kksyXDSGdaZkdfww/KpwNxUNflwpzjb7tmdgb2xsaLdt9UCRt7M4kZLVq1YjTCEgmo2+trY2vl4h8OcabS4sLGzjNu33+xFSN845okK9g3xHPtGnUnFxMT5fKzdXG38qruT/hrVO0KKjoaGZVoFCOKxrqLCw0CwUNi0fBYTqjEvNZmNXXFxsJhMChMsQNFMM1yf7MUb79YILLsB1/FlE0CmSpUC2VaayspJf/OIXOI+ZbOtDHeF00Tc9jdJWdbYEWhCaC+E0PD1yRJ84l+1Ev11nRK3pDaNrN0IIAn7/ftUVRegwzDnCzHDuQSAoLy+Pq1N3aLEYmsblC9h/h3grWSklW7ZsYylH8EPbviorK/FkDySTbEJAWVnZAbUdQENDdzoJBQL8be1mftnqPIryeLFhTd5QbxiEzC2tjNu3lJJf/eY3rBw0irMu+jZDhw49oHZ1J/b7gJ2KvXtxHX0M7r1B/P97CbdI4bjZBTSkGpPxu3btIiUlhS/Lq6hFw4vlWBBnmWrvl6qqKjJ8Dcwrq+Lb5S5ekwGaI3rc9eocM46cJ1+mKOAHKQm6BU6HE1egj3nfLeLaa6+F/3dvm0RB0VFsfX09//jHP3hnzjvkTDoT+hlZzjNEBrjzmOBIZbEQNq8Aw7tAEzELzWZf8wGdT+31azIZOXJkt++jqyhBU3FQsr6gAJzGoCPNNm64+uSrGXfUOBZOWUJzQSzomnu4G99uX7dZaFbZrNjSmyDjuHSGXD0If3EzTdt8jPzx8Ljy2ZOyeKkgk9dWlHOzP/mCZkSXNJkj1LRmGDjKyP6huTSWjRrGkuJY2Tqfg8u+fwcVFeX41vu63ULTEYZyl2Ga1TqGZpR1KRr5fnAIB9kNLqLRjGqT4I6r2DcCtkGpEUOzbXKZKOPzYcFqqDTjaHq7QTxssgl+0oyh2RWy0sHvcMRb+iXJQrPFjGOVEoSAw9ElkXX0ECipFNQ7XOS0BHEFJSG3YG8gGTE0413OG52udkXoq88WPPgf417xvyWC0ydk0FzQTKYvNgiraQkesKAZ0O33AEGL0Nq10AQ4ZYJg9mKjXfWuFOu+BMrlXNF17rrrLu644w5WrFhhJQA57rjjeO211xgwYACbNm3i9ttvJzc3l2nTpuH3+0lLi7+A09LS8Pv9NDc343A44sTJtLQ0ms04w623TU9Pt5YnEjRnzpzJNddcE7fM6XRaVqXdha7r7N69m+zsbBCCLK0PKbUtRpZVm7XW4MGD47az1llzCwIhBP3792/jct3ardPr9ZqZn8uIs+C0KveCNx9N02LHb4pGJZrfEHFsL4bDhxtjqiF6NjscmTRiiJZGOUebckI37N00oWG82oSNmJ2O9Lhy1jEI+EGGk6VguICb99Thw4fTEAqj5Q0wXIVNIQqHIFtkG/sSgpycHMNVPc44zDjmMc6xDBs2zHrRdawtYsCAgdbxZUgvEZzxbQIya1sYNMj2m2gaQ4YNZWdFDcMHx0L1ZNS1EHRHGDZ8GKzcSUZmZpu6ooSX7zAsSc22vfjii9x3331xZTLqWqCivt06WiPWFDJgwEC8oRDD28mOfsbvHqVPUZB5I70MPXM6Gakeq/7o+Tl06FDLfTuzriXh/jPqWpAy9vv9bWsR/29s23KPPPIIa9ZsACE40nGksdDpYtiwYda27777LkjJwFV7qMvOYX7YwY2j44We1NRUaAmDiF7PEoeIf1UePHgw/fv3b7d/Mlodi5AghINavRYNI5EPprs4wLBhw1rVELUO1U0rY6Octc9gJZLBCM2IoSnDYYYPH96mXzdv3swJJ/2UBloo0EvJYByYQp4RW9OwyqyT9fiNHUIoQp8VdXByetwxpHo8oDmN0ArRsiImt3b13LETDQMiEOAyPrtTUva5LrulWApuJnqOoxyXdaz9+vWLqzMqaNotuIGY6CclQtNijssC7p/1AFc/90zcOQvgcqaQJr3Umd/3px/sjHMdzTrHXrLS0shMbb8vMmqNazY7OwtKa9rse86cObz51ltMuvIh7rjjDpYuXZqwntLmAH1SXHhbhWboCeznqxCizeRCblmN9Vk2+3BpKeQ7RrAW4zk/ZMgQUlNTCS5eD1rsmSoFeLVUyo413ouj1wbLd5CVlU2/PpmwqQSZ4iKvTw7VwWB8Py/fwZHhERRhGCzlbCwloHkQWiaaZoRrWLJkCRnfKUDIfkjC4NsA9EN35SHC28jMzGTTpk3mM1eAHiJMhGYCZmgJ4/wbMGAAbrcbXUrT4dyBkGHQNFK93v06nxLdX78JfHOOVHFIsbcpJlam2ZJFnDjoJKoWVMWJmQCp+V6aZXP3xdCMs9CEQTMGIoRgzN1HcNwLx+IZ2PZl5ud/kdQ73PFJgZIkItrrSW2GnMGx+HgllW3LL1kHAwcOxC+braQpISmTFrOyRY8JR6GIg7CmMSAH0myz6vmDYkkRdw8bay0f4s+2Pteq7MY9Tsg2kPEEwJnqwO1KbA1x9AhjeZWZcCqlG8RDn03QFBHRZZfzzNRoDM3YsmTE0AzrOhGHKWi2GIJvVwTNqJhf73AjwLLSTIaFZpzLuRlDMzs9cdmjRgjLOnrlNvCONDo0wxY6IxkJnVonc0KINjE07ZwyIfa5wdsn7j7ZmKRzSfHNwOFwMGXKFJYvX87SpUsZPHgwgwYNQtM0xo8fz5VXXsmCBQsAQ3hrbV3l8/nwer2kpqYSiUTishj7fD5D5EiwbVNTk7U8EW63m/T09Lg/j8djJGrp5j8wrCuFppHtMGKF6FI3BT8D62Unmg08zkJTAlrMldyOsMcnk+YiYcQrjIv/Z5jKCMPDGg0R/5KluSDiR0iB0OxWn7G25ZCKR/Mw4ONdhk4al+AkPm6n1EwJImWA5XIYtUy090vTgAy0QUOp3rs3tkNbOR2sRB860nTTh4EO2wytURjNPoQym+UW7rjfQvdFWLlqlSGUSOhLFs6Io+1vJsx+iFbn8YDQCNvabxyDmVrC7Ount+8mLGn3PLBb1D6yalObMtHft6vnVn0ojKYZ1reJ1gshWB2UCClY+vXX7C0vZ+4Hc1m1alVcu9ocUzt1YdvP3pZgwnK//vWvQUrSRAbHuSazM7Id71U3IMxtS0pKuPTSS43nUqUPHA7CZviDtn0Ribkt6xLhMELHBGTsvtBR/whbe6OnhUCwNPgFDuFARIV5d8wtPu5EFLaPtnWGcCcAHQFGJm4ZQS74kAKfn1W1jW3O9dglJYgtcFj1poo0K5SXIeQJanbXtD1GAZrmBBnNwK5bsSj35dyx/zmdTrNlsWOMhv7oah2hUIhjjz3W2n6ENoKhruHgigrOos3vYd5IjOvNNvEi4sTa2CSANAKpsm37tjbXlkNzoekw+qPt+90P8W0zfiohBEur6tot+0axYTW/bOkya7OFCxda67dt2wYIUkjh66+/RtM0vkxQX1lLkKB+YO1u/ffm7op9OmZN0/jDpl1t1jmcTlyTjEDwQhqnnj1GcTR8iZTSsKq2fl2N05ynoTtj9d91110APPanx3lwg5FsJyQkbodGc0Rv+zuY58cRjiPI+7oAoTkBSSQSsUJEpGwwE2dpAvQg534qwTMCIZwEg0G++OILIkTwCi+EawkQZkV4LTgyCJrhJRwO4zkg0RFCMybPpMSpuXFWtH1G7Gu/dvffwcTB1RqFwqTZfMA5IpK0DM16Fod2hil+sW32sqzjsmiWPlKCsbudP5ku57YX/swmyDsnNls+f4Vk+Pd0fvK43ib4dIPD1S0xNOtsbsJpzZA3ItaePQlCiM1fKU1B0x+fBTpJllDNtv7RdWOQMnpIfBm3SzDcHGOsTsu37j75zbG21yQp47Ki64QdsUzl3gCkZbX/WBifb/zbnRaazTZRW4a77nKemQb+VoJmMqyQ7eJhShCCmqNLIuvowcZNq8FpvCxkNxjfa4IhQgcYeybe5VzS0CqjeGu+ZRqstAShLssomO6L3auqk5AYyJ7MKRQxzqmOBM3jxoDHfI+qTRkQZ1mrXM4V+4Ou663cqA3sokB+fr5lyQmGdWVJSQn5+flkZmaSm5sbt37btm3k5+cn3Hb79u0MHjw4oXXmwYCRtMK4n4905BvWhjZB0xqvuHKJUxMt06RYmajoIIkf44CkQBoJLKIJWGQ0I7Cwb2dUee2119pehJwQaYztLEEKi6gY6qkPgumW2jo7MRiuprqQWJnatdT4rMw2fHlpaH3zeGfDFgA8mpcJzomtazTiz2nSeMm09ZCUklAohHA4LAtNFw7SSbfFKoyXkm6++WbGuY7m5KUR0GWsjxLgzD+CYY5hyIZ6K65gm+NF0EEVCRm4uhStTy4rd++JWx5tal1d3T7V197+JeA65lvGF01j8cKFbNu2jeOPPz5h+WgcwAMlVXpxai7SSI2LnQrELNSi57MQ1NXWtakjeq+w/9ZCOBASSiIl1rKO+Ki0rVVB1OJPi4ZEEAK0RBMhsYsvNslg7C8W41EgpbAsNAWCvYEgFQm8P6yjsURS47OUksmTJ3OS++RYYV3i0FwJj2+ZN9u8lxgVBb0OPJdc1WE/dEb0fiHMa02GQuzYsI5XX321y3W89NJLZkgQo80unAQJGaEhzLoTx/qTbRLExB23iCVjwpWDpqUk7BdNc6LpUbP2A6efFnsfWmsK1ImI5huYN+9DgksXAXDmmWfa2qWZExlGu0qaAzyxpbBNPRGZ6J5+YKypaei8kElIlzSHIwnf1+2C2UmuE2PWwSbR39V0JmDk503G8aaOAoeHwavrrbKPP/44AFu2bLFCpIWFJMWh8Z+C+PshQI7IwaN5DaFRSnBlAw4ikYh1HmRqmQjXEPPalqZOriOEi7/85S8MHToUXUiOd0Wzc0YnJGBbeKtllRo9DzUEDtNLQtOciLqOw2wo4lGCpuKgJOAwRLE0H6SPSCNtlPES3ripkb0fGYMFdz83Y+8bw5i7RzP08qH4ZHO3uZzvbY6ZD7mbW0gfG1MPHvyPpLgCnn4XNu4ylunmSK/R6UKT4PEb35MlaNqT56Q1w6DRg6z9lpqC5lHDsVw+56+AAQMG0iyb4107k2QJ1WDLlC3Cxk141KC25aKWYhUtLlInGH7NwwMxl6U6ZaHZ44RdMVcNbwDSs9t3PTl6hPFvlSloxovjScpybrtGZKRr7t0QFTQdSW+TLxJvDdllC03zXK93JD8xUGuX8wani6wOEhVNHhNbt122tdBMRjKuJttkhIwY++vI5dztEhxvCq3Vztx4C03lcq7ohObmZj788EOam5sJh8N8+umnrFy5kkmTJvHll19SW2uIJFu2bOH111/ntNOMTMCTJ0/G7/czZ84cgsEgzz33HOPGjWPgQMM9bcaMGTz77LP4fD7Wr1/PokWLmD59OgDnnnsu8+fPZ8uWLTQ1NfH8889z3nnn9U4HdIFIJIJHS8WhgwMHOhEcOBJmvrUnyRCm6IFoLQZEhUoRt2grJeZim9t4q3dkHRBCw+FwxDJPC+PeKKUw3OwSCZVmMh6BZgqvkOjVReg2C00JwtEHtHYy2ppCkvv4qJgj6KNlM2HCBFvTDWtKXcREKGE0lmAwSHNzM07hJmRmUR/hyOfq1O/HusUmfkRjhmo4GLRHGpmYE4pikj//6c+4T5mGmxRDUJWGN03csQrQ/j97fx5v21WVCcPPmGvt7vS3y+2S3OTmJqGHAKK8CAGEIoRSSquwKSy7F8Eqmyq1tPy0RFSwKwXrVQQKEer9pLG0FAyERhSQxtCEkL6/yc3t+3PuOWe3a835/TG7Meda+5yz9z5J3U/W+P3uPXvvNdecY7ZrzWc+YwwFSB6hOSozzFb35/Qpvehf/8a3OMYyANx7770AgCc99an4i4c35ndtrfKcVwIiUJI4tuswuenoKYO9FPPT7h42Brg8NX1qYAaNPEMW3Ton5q1yOHVyrUjSyv3vAk017Ht2CJC996GwzQ6udILvUICgBFLlEEiM/8bEMwDj/jVjGEoF7EWrt2MdUwolJVJKkSuFpCzUta8FyyKBUgrT09P4Uv+L2n8tNLCViBQKEt2b/zrIYUDCmMkL1wZiyIHBRsVHoNe1zI8dxuArX8KP/MiPbDiP8+fPa6DV7LlSlSAjM94Mw7U4rixjWftbteL6Nd0a+kWs7wKSZmEYXnPNNaCkBpLAgeTqDeu8lszT/Ejpp2kaLz1xoPC7BTRtLY6sdvDAhaLfV7kOOD+ODB2GJfLxs8v40KHjpdcUgOyQZlMKJJCM7Q/AsSWzTD87Gks5UL8MCsZXcVpsSyKBb3zjdgBAXwB1odnHseyjy7Al2YaH84dxTXItSA2g8k4w9wUEqHdUP7fsOYXKsVVov836nUM5wFUHcYt8TLs1QDKTcwUS5c/pSoZLBWhWclFKVteAyXQbuPvCFNSV2p5SDRRUrheAy3/0Mlz1M1fiwH++CtOzU2hj9XELCnR82T8Iav0uVjrA2/9a4bYHFG65x6f7uA5m5kDFZQNmTJn3m81isXHgb7oN/OGnr8J/eYfEyXOAxYOu3A1c/0z9+cQ5YFXtQwePD0PzQse/wFlA0zLUuHA/mtmBBQA+6BMAnNsEplglo0nOAM1mF5jdMvyxsDBL2LsDOGUBzQAc35yxxA8iVE4b9qE5NwW0k3TTx3cnY/6ZeoahuREfmiwIFhABmhP6iu1EUc4vJDXMDzE5BzxDEwBuXdENyufd2U3wXbvK5q7KEhB5BuYwecoV+u/5tP64+D6t5J+vEBE+8pGP4MYbb8R3fMd34L3vfS/e/OY348CBA/jyl7+M7/3e78ULX/hC/PIv/zJ+6Id+yIGS9Xodv/d7v4f3v//9eMlLXoLbb78dv/Ebv+HyfcMb3oCZmRnccMMN+KVf+iX80i/9Eq644goAwIEDB/Cf/tN/ws/+7M/ixhtvxM6dO/FjP/Zj/yeqvyEZDAY4UL8WdaXfQ55d+xYIqhUTyo4DMK05JglrWqpCQMAGLfEcONjdHJGJBm7zYOxMZdknYMwbYX0TksEYiu8MQgKwpngwOpYCn4AiBWHAJ1LQDM2S/bqiEIgRZmM5N8ecR5s6a1arYZ4Kz3iSUqIuGo5tn5PQEZWJcH7/VvzZBz8U6CYogYVXlZJodpt438OeTdxut/Hxmz+Od77rnQwU1tGlyxj92vDYy9F2F792x4PFysL0IWtbmUt8x3foaLu33347PvepzwEATp48ib+59RuleRTzHA4zWsYXgYAkXRfQVEqzk2LG55vf/Ga8653vwt/93acBAB969FjJ3VFeHGuXEpkK225fcjlQ2wmxaw/K4G4NZDEwCxy4M+M5AoEeMi6yHl1p42NHTyGWB5tzELUdUM2rtA9NpflYQ9uPCM5zZhScxonMNDAJhQO4Gr9z18NIS5CkuAwXDAcaEMqR6cjKAEhJEKWObVYQEoBjK0uXz7hi1wF3kGICJo1iyqqBOwHIHJfd2kUCgYxyd/gAxtCM1zHt3oEdCtjr6Q4QWycVCIIIq+0QEHzBC16ABCIwg55EGt/1GgDAFeJKZEsb2wsRCewWu7DlkXPB7w4s5qTTkvul2mx+5mjyhaXVwF2RlW63i5tuugnytJ5PLTR9ECcjeZ7jbW97G5yLAACgGhQUzqEI3u75+jE8KX0K8p4ub6m9gkYi8IarYx+2wEANUDN+Obcn2900lNJbYgokGkgXJtAXgATAs1O98S4A6Uq6Z5d1iZLnOYhIWxfY5xy1NKCpgLfff2hD7VhJFRSokotQBlJCNrSPvplV4NYzDXypXcf3gZ2mCuCyH9To2OdvV/jN/6kg974hADQ5EDGpnFr1gF2TBvi3v6Hw0S8V033g0wqrHQUbqDkngbZIMNWVOAdgaROYUACwGDA0FT74WAPn7wOOnfUL6KU7gCfvI9x8i/7trqOhD00AWN4kVt1Km6ERuV6w9+0qprv6Uv8CcWbrLOYQAZqVyfkTLqrhg8HUeoStC2u/TD71CuDvTzUgEZucbxJDM88B8y4pswRzUxs7p2zUgUFNBAzkzfDF2I4iivdIbMjkPGZocl/ASxMykQtBgZI65tcAWa9j5IFbHqvhFXOb70OzzUHRXGCqGZr6loldD5bS+qb7Pq3kn7e0Wi28853vLL32sz/7s/jZn/3Zofc+9alPxYc+9KHSa81mE29+85uH3vud3/md+M7v/M7RlP0/JHmeQxEhMYfAC8lOJMmsA+XchitbNvCJBTENjjI4yzZl3rEfISYYUhH4NLdYeOjhusAirUIpHVhBqhxuoYf0LLgSUZZCo6weJabpuTJgFktLKULYD9ibXAr0VASyaaAy1l8RoJJ5CMv4IgJJ33aXJpd60DaZA2EVDzdncfZq4A3/4bX40e//Ptx///3otNsgCFyVXA1CBgWFWpbg5269Fz9ylX6P/a//9b/igXPmPdPqoRSkwhCT83DDfPOxU3houbiJd40RNZm991nPehau+JFfw5LJVa3jDmXJRFX+0j/9Ew5c9+xhpZncCEgSQOZ4Vu06xGFJzvUGaNX0NjQVhEypgD/8q7/6q2j9uzfg3scew2qW42e/di9+LPZlxITcwAVA9WKfGkBkG1povOLV5STZqBZKKYgoKFC5CbMGxg+vdgu/50QQogmp6khJQI/3IUAl9HNT6gsYyjvqWL9+EnuxF4d7A6Qx1azk+UsG5FNKQUqJXEl/WKB0oE6lJJpUDBJIiWdogrf1mGLbwDFSDcA4sm8+oevTWJYQSoNDvAzbvrzfLCQVeNpw8y4Hkrqb65A6SNC5cyFomOe5iVy/8XZ4dKWNK2aKL5CZlBCzCwCAlI23Txw7jRv2+AjcHz58Es/b5pmHNeP/dNsDZ3CQ5WfdQrm6DdEn32SG5lvveWTdNEopM9e1lLXeW9/6Vnztlq8heeazAQg8OX0yPu9Yi/r/PM/xX/7Lf8H2d/8N+jBgvVLIKMft6jE0sSXI89uO7cKtuN0B8WeWFvG2//bfsDi/DT/Ueg2uvfZafPazn0V9uYdMDVCjuvahq3yZUkrnQzOxEclJ+xMmBQhISPsIUgow80ink3AB7QxrXkppTM41G5vqu6Hqyh2iHOsU15NKyqViaFZy0cliZE59rtbAvSKkH13yL3agtVcv2D/1hwp/9zVgefZbApPzzWRonuvqDXaro5A3m6VgJgB840Hg198H/D7bK60kNWdO2c4lsgn95wHAGWYCP90GVo2J/p9/yqfZu4Pwcuay6It3t9AX/cjkfJMiU3d8pmQAzR0LxXRXs4CSjzR0n84wYKUyOX9iRUoJ1WAvPv3hEc6tPOUKDdSfSxtIcyAd6Bei1U0CNHmgKik3bnJOREimUjR6cC+im8HQ5PUahaE5N03YsQAsGYZmq+NfHCcF7DoRyLqSpGvqND9DuMbMvdsfBpK9yaYzo1cj36dr+c+0Ylms5yNAs2JoVlLJ5JLnOaYPncJVt2qTEUkKSRmPgfwHvb81oOXq3QHY4j4xJicoyEBvyhjByzLmloVAD3pee2aWSWNM7Mp23edUx5hOehZoKUNTAUposz3A7h3rXGucPXsWW8UW7PtKF/KMZ9KJxqWQifeRFxDhmpdCJDOorWQF9ZbVCpaECR5E3temlTzPccMNNxiGJvNdCiCJbKHf9ra3Yfbp/xeo3nBAkZISEgqDiMG0+NVFEIB+BHSuh00Ia2IbATA26BE3gRwmP/dzPwcA+Nmf+zmcPnu2NI0zOXfgssIVyZWFdH934gweNiBsQjQUXKk947m4b2nF+b4DgMOrnUI6ZcAFKAD1S4DY/6jQgPR5ygCZo+xNvMjQBChi4cVtZA8otdk38H2nI3MJw0BV008xgYCUG6dDRRmAxmlhARKeqWZ71tHAsZMnCsBa69/+30Et/Ed933333YfcuKG4+mEFpQjC+NCcpwWXz+rqKq796omwbeTkDE0r3jCaRmZoAkBDtLCTNOi3nC/jYP6IW544Q9P7IFWanRswzUPAk4gxaKUCRIrt2z2waNPrIE/rA5p2zJSZfQNATyqoTL+HXVe7Dn1D7vj8qRBEPdvrB4xGOYQeetvUgqmHB0+JgC+fWXTfT548iTe+6U34lV/5r+vOe0CDrkfbawNsb77roeD77939cCFNJ5f4lW88gK+eXQIxnvTpbt+5ZfuTP/kT/IvmDVigBTTqlxr9BVblKmyf2f5MkTiLAi1m5sTnaxJQQkAogX2ffxQqIXzj67fiyJEj+K7v+i7keY6XvOQluPxLhzQzG4xNyRiamXl/t+bhED6AFJnSX/CCF+g2FXX8U3LOzDtzQDEwzx6iYEwKCECkxs1FxTccVSpAs5KLTh474xfw6TZwLq3jYHM2SHP5j+rd+fllhTvMerkq0tDkfBN9aF4wi9XsMnBElVAP15DlKDDQZrDGDp32kX8aHUK/5MVi73YNPu3R7jzwmduA2sI0ml2/ym8Wq261wxremJxvny+mswAGANyZTwMCmGHMtYqh+cRKr9cD6hpwq/UVMkqwZXbtey67RPfvmcjsfLPcF/TYBkTlGwvAYyWdTUFMp01haGZFhubMGr4huRzYq6OcA9jUg4Q4ynlXJGsyNAHgOdfqv70+0N3R2nSGZifyfbohQNOQbRbTRsXQrKSSTZZPfvKTgJRIzTM5h9LAWrx3jcwStWWcBr+8iZ0Hp3haDpY4QNBmyAOsGH+AygEWygOTFtAskXvoDKTboJIHrErFm9PqvWPNpc3zHM997nPdrdacEACQTMNGdPdZKTRWlalugku/Yn2G8Pp7XayPUF91XdcjR47o+lGCHnrOLycNinDa4LJdaKWzDCDRDM2jHw/NmGVf4kQtx7sfeMz9tprlOBX5Zv7yl7UPpClMgUhgf3KVN5Fk4oCpIvW2IH/2Z38GeWEJIMJ9991fmoYzNAnkTJpjkczvY0KaofkVBrg4SZIC+/DupZVCMgcuOEVU6CPQRK6WACAltmzbVsijWBcJIdZmaH7AmMJLpYay9RII5PXdsOxIsLFT6kPT/T4ELDPApO2vC8srRR+aIgEcI9vOReUAzfPnz0NNPx2ivgtXPQog3YZEJFCta4I+e+Mb3whx9Kxhl7E5SwJIQhbcKOIZmgBEUzM0FUYGNKfFHL6jpl0o9NHDWfg9JA8KlBdILqa9zFrg+yFkxtoDl7hvpdSg10YAzd+8UwN92ZD5NZASje+4EQoSZ5YP4QsmMNIDF1aDQ3UB4O3veAe6H9M+TiWpUpP3E2kTND2j18BGE73TfaiBwocPe0vHN7zhDfjSP92Cd/+//y/++m8+vG4dLgwyfOCR9d0+cFkqedclAH/60GH8wKe+gPbqKm4/r9fWfzx1zgG+SimcPnkP6KtfRQ9Ssx8pxYPZAy4f25+zx5Z1G/iFR/dJPB0UQLUatqstqLX7kIK0P2Po4H8Ze+/MoH3TquZleFCddGOVjyEBYRZ+v+6fpjbuzQ9i+/btTpccysxB5kOTpmDBdiJCriSsz1OlFBJKMBhU++FRpAI0K7nohIN106vA+bSBs2kDp1NN3W7ta2HHS/Ri8WXmv7KdpGFQoE1iaGZSomNepmZXgYc7O9a5I5SVJHU+NIHNCQx05Nx59zntJPjuFxGeFfmk3rdLvzD8y+fr790+ILc8NfQxuEkMzTb3n2cYmttKmH5X7vbv0vefSNDa30R9ANRNdPrzFUPzCZVutwsyPjRrGdCjBFONtV/OLEB+pqbnowM0N4lV12c+r/JcbNiHJgDU5/TGw47xTfGhGUUUT6cERJkX8RK5aq8O2AMgDHozYVvFDM0eJWv60ASA517rdT4xNYfptmeyboYPzS5z8bFRhuZVezQ+sZzUUHsc1qVKKvlmlk984hMukAIA3COWkAjmG46Dk0qBR0ewIJePcm7uQQyy6O8uLwtSMFN1MqxPe80Cmq50pbR5OGeDOvNPoDRqQywq1I2U0v4bDQ/vvvvuw6OPPurScjblcSzhIXWiACxd/Zk2kOc4QHttTUL9KHF+QBUURLSDtptf7YNP4HD+mNMzGfIIaF33fKBex5H8sI6GDoW8BLFIFdBnTK1HVjq47XwYXfiGG24AAMwlC66+TxLXljA07SZbYD1AM9m3H9kD9wDZIPBXyUW6MUOYFjO4VJSbiXNWZnaih1wqfORIGKhHbN8BCOHAuuULy8iyLLDksJKrDDVRw3lp3o8LJufkQ7NLWRoQJXaTYqOcLyb14LcyyRWGBuYRRJCOeGCB97J8pI7mzMCZsFzNYrQguesvIUp9aFrmIp/BfL4qCMCCl4ogKDEMMcIHPvABANr8V/uk5T40hX6ZTzdoQrOGUG07KN2Cq9Nr8Yz0GVhZKYLVa4ki5Rly3BReAbyuYZR47UNTARpMBQOqbV3tkiY1qB33u5QSItkKIfRLavqsb8EwsazKTKlSs+y+lBDzC3g46WH57CFk998HAPj7E2exzN6HEkH4o//9N7z2BZ0A4FDahJjVm7DW9/4wuqd7kNEhykc+8hFACNRf+kp87s67huo+qXzmxFlcYIfmtnsWa0184e1vwyHGtraj9NixY2gPLoAWlzRAqWDMsIVjndq6XvrlxwCbv3nWlM0skoBMhIlKD/1ckRKzNGv0MqUnM/hsfhsGpK0GjtebAAjfLi8NfGgmzSudyTmgdcxJoouBWTeYZYFVzqat74EgwcZk6PpBiAT3338/upXJ+YalAjQruejkMAPrZtoKK0kKEOH3L30aTj17N657zzNBiV4UvnSXX7Zihman5IVnHDnfz/QLBrTfufOJBnIWGIBwzWXA855cHgRjmZmcA5sDaB5fWnafqZtgz3bgC39MeNtPEZ6+H3jV84Hrn6Wvv/rb/UvOcusZoY/BTWJCcXYWZXpZ2b5QTFevEa4wBNcHjwDzT9c0zmljhXF+E4CVSjYu3W4XsIDmAOgJsW4glz2G1HAqinS+WQxNOwJIKuRyYxHFrUzPCQyIHNtveRPmWszQbM5s/LG5a6tnaDY3cd7xtS3tEzKidRmadj0AgHu7sxDK+/XcjCjn9oVd5AqZSjC1AUCz2SBcugOQRFil1B1sbJZv30oqqUSbra6qFRwUy9p8dijFUQMpnkWJ0DdmDLJYMzrLxBzCNDMXYVmQPsq5BR6KPjS5704N/hDQOzLUL69ltjhTXhkyJtPUs+wcGAlAtnYiS5roNa/wTK5MYn9ylY42C4X94lJXaSU8PZ+SGSBbBAAcFT100WON4zfcl9y5BLJrrKhBQiEdtsQ1df5ddHGluALPfNp1uO3OO/CNb3zDJclWcqSScPzMGUz1Q8CZy+Ki1i2RhBf+o36yNlAPAj7pe73J+XpSf/G/QHbn16EGg6GjyPVcumBM8YeDfLlSIAIefWAJj6y2C2nq3/YiUOLZcX/6p+/Gt337t2tGE5daHUpJJKjh/sF9GjtA5CNQeNNxJeXa/gPZkCdKcKLm+z3wxcjy0AzNkrz6pyFIQII8CDzMh6YB4fRHzzgOxRi2Cu2P86H8QVCSlIKpsypBAHoZtqFSCgcOHAAoAcEORgFhxqeAwGtf+1p/nzTMTjdWph2zcWJJtwF5B7NiHk9Lnzb6/YJAHosMJgOJEoYm1eCY5Zy9yhmaJNxJkFIKSqRIByFTN89ziPpOoKGDysz+f94yVMXPnDyLC4MMmVQ4W2KJ5gyT0jlYf4oAsDd6IR/kEvUXvsx9d2dFTKdQCNRs4Ru3345+yf6KSICEQLKBQ6O1jzqitMzdwwMXVoeSVdqrq1haWkL7UNGFhGSBp+7P7kdCKdC8CqhtBTfXVjL3B3VkNS1aIggFyFToQHMA9t1yBFvlPJ5Ve7bTGQCQLGDQvBSUbnEVJyLUkRQYmqQAJDzQj1bCMi9dzyhARzlPfFkkIh+a2s2B9tur5+hnPvOZoW1cSSgVoFnJRSdHF5fc5+k20DYn4HdNb8X7n/40LFw3765/iR0qtUXE0NykTTFnL82uaJ94RMA//CFhtwF3fu8nCLe8k3DmJsKv/Uh4/4qoRQzNycGD8+zFTw60/7zpFuE/fS/hjvcJfPR3BWqpXkhf+mw4cOG4etKmBiex0mXAkcwT1GsYapZrI50vt4HkKn2COGsAzXP9wYZ8uVSyOcIZmvUB0BPJ+oCmY2jqQWXBw84m+Ye1s6OWARmNZnI+N6XXAQsermb5xOMp9qHZmtu4b5sdC4RF60NzExmIXf7SmmkzzPWA32cd8IcwXz2pE9u1YDN8aPZN39cGQCY2xtAE/HpwPm26g5+KoVlJJZsjivTm+Lg6A8cQKVkS+Sba+yJUHrxhwIrbuDHQ0Yv3PaeMCR2UMqauIUMzKLvEnBOwgBLfqnCvayV1ZSbngpmxN1zwO8OQMZvQgy+a12aZyVzwrNhCWzS4KxIcomWjnwIau03VlQZGpF47j1IbHeUXecXabvaxFQhz4GMZPWLIo5KOGZNO0cI22orlpRUstlfwyle+EoBmLq0+3EY+GOD97/8ALv3EPfi2e1fXARsUtp8x5TOT89tuu00XZbaC9W/9dmQbMJ99SvKUgq9JLt2uaYfaJdif7kcLLfTQK6RLjZk5AFzdrRV8gjohQuJAdIVb77gTjzx6KEjS+v4fhaKWqZvO57rkurBdmK87qHJAs8jQNFHuCaD0EvMbBzH137fffwhSKdx1x504fPgIDh1i+qkB4Eat1W+N7Tf3URvowg8PNNCqDLCbHztS2hvHRY/laT5yRjXI5aFASERdAyoF+q1mhJLPpBB1elwhABic18F9xniHVIIgFHAgZ4cNyq4dvh4OjKrpfvTrSghoaqxJs18ttCxIYO6833va/AQDqXgesdx/YRW5VMhVaPbt7rMNKZoB07zxT58N+Ib7phrof+aTAIBn365/P5Q/6lJ4VrjNmNB42Y34H3/1v7C4uIhjR48G5abPfDYgEiQb8IcqlWYgr/dO/ZUzS7hzcRl/ffiELkMM949LSYp777kHnz57unAth4RQ+nlyOj+p56GrnAc0JaTzURyQ2aMhTAponFrCq27RL8I7j/TxtORp2CZC1xMH8hbU9DP9+GheBdTmcJxWgsOMXXndDrK120RptwCKZMAetgxN7Z7Eq2zH32CmATy6MWuwSipAs5KLUE6ySI3Tq0CH+a/5yr2ANG8Qea6cyfnubUA7SUIfmptkcs79y82uAItpDS99NnDdNYT7/pxw6C8Jr34hgYgw3SJ894vCBWglqWGKBQTZDIbmKgMgsixdMxJ0s0F4hbGEWMSsY0MCYQCmSYSbmyInbJ8vvhha4X40z+8wgYGMTn2p0N4kZm0l60u32wXVPUOzT+szNC2IfzryoQlsTmCggRk2tQGQ0WgMzblpoCMSBx6qTdCJryNpnzA7s/EXjB0LwIWkhi6JwNXDpAzEdmDenUCI4QcIVpKE8OLr9OfDfb25b5i+620CEN0zS1wtAwYkMD2Cn1EAWEzr3vdp5Xqikkomlte85jVwu7raTgAlZtPwSUAGdJHeJDZg8Wn6iI7+7Tb7RSGpGNZZNHUt+MhTMIApA4qc+adhaCpiZKqSki1blDNijPksAM8KhQIk/OaYZxFvShVAooYHWltMu0VQKvc9Cem+P+OvNQDqwAVlyzOsUFLYf1Bf++M//uOwzLPnsOuEBOp7IGWOJEmhhMCJExoceMlLXgIFhfvuucdFhb5w/6O4cCE0N+dSFy1v+qg8oHn+/HkN8kngxV9QSK66ZmgeXBZoAQnVIB4oHu7leY5v+7+e75qFjJfBw/ljhbQJkWNxTefDeJwAhHAsz620FZSmgb87K/P1KyFIGPDcMDTZ+ySRZeQB2f334H//j3didXWNyPDQgCYZ01OL8XFQwwI1R9pdLK+u4r+/7W04dfoUvvu7vzvIjUBA/4QBrAzzzAFopScMhqFGQDjqDCirnJ9bAOh9+mOl2OIqSZfGm71yf7EeZCFFSETNAETR/DCRvm2gIg/Oji+BD01EjG4mf3nouPscB8kBAMkYmmBAO6kQvA3Yiw4c9uCyX3PMWgV9WZunF+tqfWjy8FKDIaD8D1yxGwlpk/PjnRDcV0rhTb/2Jv/d82Bx11134Rd+4RfdtSzLoWSOGmlXZpTlOJefxYHkanN9yLuTqe9Xv/a14Ofac/Rc3YjfUhv0yvoDHSbPnZ4JAEzDJw5UcZLqcXZ0BvjYkchXcH0XRHOfuUdCiBZQv8zUhfWnkiHYSUCZP4xj1IdKp1GzTVTX5oI9dE0ZTLHaJXAjMzsHgsK9OIMsy1y6eZUaAwUGaLPnHBGZIHa2IRRQ3+vUBAl/+MNAbCgFQSkefdXT0VCbxIL+JpAK0KzkopM4gnc7SbF/j/5+YRW437wX/e0XgRWT9NufASSiC5X5Ib1ZJuecoTmzorCU1vHDN+iFZ26acPnOcOF85gHCm19HeNEzgWdcpX1obrbJecZOBPty7QjHAPBdxuy8I9IguvFmmJoCxUAuZf4zrVx9qW+vx0ykcw6yVmbnT5z0ej1vcp5tjKE53dJswDNpaHIObI6psJ3CtQEwEDSSD825KT3GAz+xE+rUYeAhDcRIjNHt8wCIcLLe2lSGZuAfONM6DTtA4PLSZ+s0NvK6fbHr5nLdU/f1xBog1vsG0NwgQ/OAWQ8usEjnK/nkzNpKKvlml927d2szNiWNdSULSlAQC3qogBUZmJy7NB6C4Bsxa0bnsUzydzEgjW+eLYOzzHehT0QMGB2yzln0gekiRM2ltmBFNqVflngQIlsfxwo1gNEMEqQgOKPpdLtrA1+sMmS6vADI+Pygo9ZOPdndM7MKXPWpB/HTP/3TLv0lf/tPgMzxLz+eYYdquI2tTHy+DzzwAB7OHwKSOQ+oKuAjH/lwoUloegbf+zcaFGtQHY8mXc3QNG05NTUFJCmSXGm2vkiGtW4oSumAGSWuDr/4xS/iwQc14OGBr/JcuQ9NAQ2YlMGaamnRmXJfKi4F0loRvCNCFxKUzhnQAzpKfM7HkXDAlzx9AofuuQu/+Zu/GWUTMk811m7GyuC0qT4D3pkmJ0+fBgzb0bJfbSZECbDyNSBvlzKSizpYUKvkAMIpljDGaeg3sPD85H4lDaBJ0ZxSIAjRMJ9C/fYl+4I50zi9CnFfMYL1OBK6PFBotcLT0Dd82ZvifeJYkclH3/I8/NNeA3qSefFQbEUzbREHc3Jt4nAk5e517gksuxwCsWdGKSUSs2IeaegXw8GQ95bLp1tQALISwPMv/uIv8O4//VP33Zof228f+OAHdXAxAFmeAUrhVY3vxDPvVhDHlqGmvZl+0eTcVFEqNEQTpw88JWoCASgJSooHPLFkSiERtOYB+LO3zmHx60s6b/PbqVOncObM2dL0T2s8CzWlD0Y+fehIcE0mLUzTHAiAVIaFSX6FcAdGjatAzOScCMD8txfYw+cpA5qXORYnJXMAFL72lPJ9MBEB6Tao3jEUDrMAPJx07GkVAMX8aXKf0iZwkIJeG2afo39Xeo71+312aEH2zBCU6HFcvQVvXCpAs5KLTjjINrWqowq/+tv99af+sMKTflDie/6rn+ovfhahnnQxyPyJ8WaZnHNAZKoLrDbq+O4Xrn3Pr/wQ4XN/JPCy52gfmpsdFChnJ0K9vLau/7xXfztQSzU4zE3ONwvQ7LMHnMxFaYRzK9bEFADuX6m7l3srmxFxuZKNSbvTAdX0i4BmaK4PaALaj+bpWhHQXN0EP5oDs3OxTL9RGJqzU3qMBxGzJ40ozn3mDNY37eayY0H/PVlrbWoUbw5oymz9gEBWXvpsU35SQw6FGptqQ839Nih9hP02qsn5KgOiM6WcT85KKqlkfNHMSmUYJ7IQ4RoADKHN+QoHC5jhGZrG91dkChtv8nUW2vekJVM6uEQxhmbsu44F4QA4GEiw/i7J1mfINo8DQBqT8Ew0+/fRF+7FlVkDV6RX4kl/8Q19Y3YByM67NJ/4uDbpvDJrYibvAv2j2CdnAtP3GDDSYDEBeQ9zMkGN6sz807D8bDTlpAkCQUR5JJnOgxQwnw0c0KuSYp8RzQBC4EByIGhLLs3vea0jK5ECMsu4NfUYDAZAmiLJLZttYzKNae3jrWQo9Xo9z/gDkHYHOPb0S0rzEQT0BgMcevQQDj7wIG69/fZSP5DP/vjRgNVFtRoDuI0kCXpKgkQdqqb94iglcfttdwQFWgCwiSauTq7GzTffPKSWZtyA+3ctAmMcLwUJYzId6aYAb2pu5gwNM1P2/DwJxUazLYMzni0wqX1C8nweXe1AbL+EpSXPNuSAi2L6KkAkde1DM2JozmPWByFSQNLL0Trb3fCYWUsIcORqBYUnP/nJo2VQm0fXkCMw/2Jg4cXmQgjMhr5PTcHSahD2g2P6msRECc6ePYvPf/7zLA8/77oG7B3mdul9Dx+BAnDLV74CAHjHO97hrv3RH/1RkFY1LoOo78L1XzRrLZHzhzvohe+Oe5M9oLo3exsGaEIpJFRDXm+Ev5s1koTAl88slt9rRCrl5uewQJLfaoIn2JY8evQofu1Nb8JLXvISnDp1KrgGANfIK3HZV7WbDc4yf97zngcF4KX0FHcgRiIBOgd1As6Ap4Z/pmjqIyxLW9/KgGoCHlHHASSYUQKKCDvvPBHU4eGEbdhFA0jmA6a0D6il/yPBmerKHB6WWCJwFiY0mOwPFhSuol0mlf5t7rEeHr7+SlSyMakAzUouOrnAAMSkk0AkhFc9n59SepYmAPyLbwFe9y+BVq2LgUxd5N7NMjnnQUFqfWBqew0za5h4c9mxQDooUACwTK6XBTRJKnSxPkNzyyzhFc/T5rghoLk5pp0DvsHJk9KAQFaett9//uqDAr1W73FhjVayvqx0/cB0QYEaa9xgZM92bSI8IAqCTG1GpPPMApoDQIryQFvDZG6a0BZJYAY/abAibrJOg2QkQNMC+ycKDM1JTc4ZoJlv3M/oU67QIKsiwoWkFgCavQnXy4F5m9AMTdpQUCAAuFK7pAtcBQCTM2srqaQSvWniJpFAAr9PL+HPKcMQMeasBVaTu4EzUhAyOQ2GqjxOYjM1OrES7S2M2cl1A8joYk3O13r3MuxDAmRKwL7L3RVeDyE1644a+1FrS1B+Dqp/Ckop3H333Xj961/PGmMAZEuoue0SKz+ohzHdzc7iStnEDM34MiUgEu1vkxQMuBzWFwCoebUG3XiejRZOPGNXoQ62/DoaQT/E14n1gyfC6Q9ZlulgMgGLEfiT+w8V83I6AdekV4NEgocOPlwwcR0YH/FXPaLBuIVHziEZ5NCBWEJJifBf3/hruOlvbsL999yLn/uFX8SgX/S1SQp46cteZj4roFbMq3nDq/V1QUDDgABK4T//51/A8eOWvSfc/qBBDewQlwTBooJGsNVVBtzj77icoakUvnffbnS7HfzK634V19ABIJmN8tOAvbLzUNmDhpKiwRiLziy6WC6UNQGXQG0n5jCHwarvi4eWVyF27/VV4UBoYHKugVFXsqgBSkHUi5HptV9JfUsDNTw/fXZ5BUYUq9l5tYgHsvtLrTNyqfDVs4souQTq9JHadwfZ1uxle42GmJw7RpwHmfz8Uu5whwBI0usTAXjxi1+8Zl0eXe3gHQ+E8+e2227DyW4fv/Gbv4n3vPe9AID/8B/+g7vebrd1wBtbejKFpyXXotUBnpRcC0DPq16vhw//xoexjbTfJ1LAvInQvUJ5UEddK842Jlz/6RJKtSA3lj7wyDGc6/Xx0cj020puAM2bj57Giz51CwDgzvPLpWn10CX87Uf+FlAKvX4fv/Vbv1VMKCWmTiwaFQl5rsfwtddeG06P6Wf4wywDWtr+0kBraoem7qulL7hb7ZpE2gkoiKadL+RlecEHCuNAZf8EAAlky0BzP8rWa5vYBvU5m/hgU3FQIF1GDqzcGrQPl2tot2s8Egkuua2NvL4+c7YSLRWgWclFJyv83aqX4pIFHUGcz/1GHXjqlcAf/jTh4/+NUK8RWrUB2knN+dFsb9KGeImZwOdZiq3zGz+T3LGgTc43m6EpzWlgvQ+0RW1DIMv3vZTQJwGlCFNt3cib5UOT55LLtRmal13i/TB++V4gn88ws+o7vWJoPnGy3PWbh3SDJueABjQVEc6mTeeHEdicSOdZ6pl+aYM2ZEptxQYF4i4eJgXGgnVkRJNzztBs9OA2U5MyNNsGEK33Ffq0cYYmEeHJ+/TnxbSJOptq3Qn8aCqlPBCdAX2RbJihuWur/rvZzNpKKqkEEFNPARJjwrnwcsS+KgGLUXg2k4RyAT8cUMktVp1dX5nw3wXIMA5BJoprQLWzCmj/k/xOHxRIGbCTPMBDYSmAZ55ZGTQJ6llPLeTny9b12/eVrquVUgp/+Zd/aTNkOvqNriexqiBdjhwn1VnftESBCbugFJSdN3moMHiFbS1qaj0AnKg3td/CJMHyHg3QcECGs1GhgGkMfzApgwOQ0qxF205ZlgFJgoT5HyQQDre7Q/NK9l9tSiacPH0K/+N//I/g+s033wwBgWferRyckvZzoL6zmBcRvn7qDK5NnwSSCpTWcPZ00aQYSuHoiRNIb9JsSkpruLBcAs4oaBaw+659VX7oQx/y9WNAuYIsAJoF1weWrahY4EtukaQUrpxp4Quf/zyWV1aRIkFxdJI2IXaR2aVnQyMEKl3wLIUC+zlsEmVYzTrVa5uvxcpDbXbdt4k/wTD/ggAwrGxFAFINaFL4IigkAl+Beg4OAXlGFNsSGTKsyLBfLRh18sxp3Hz0dDluf/goFh40dVd9wIKDSgFIyk3OTTsErG42p53JtwIUSf99A3X5lW88EPxmQdA//MM/BIaYdqfWjVi2CEDgMuwAAGyhBRARBoMBfv/3fx/3PngfUkrRUz1H+FMATgi98f3oRz8KAPhWGgRdj8Zl2HK+BLy3zEYh8P995ChWshxHhsz/TCqkRDi02nF+QD/46DF3/eTJk3jwEw/h/PlFnF9awpdOn9f9Z8yy+ya6u4xcNtigZNRs4Yd/6IdKD9EU1cJxy4DqGSlwbe1J0DNGQUSDpNPRGwL9+EiAVIPACQg5DXnvXb0NAAH5MtA77l0QYMh8BXCuZnwVb3l5rL3/OzjnfiEzNrnJuc2fB7SrZGNSAZqVXHTS5fTtboqdW4HZKcL3vEj/9H89DXjkQ4S7/qfAf3wNQZiN9HRzgI5I0DCb9PYmsMUA4DSjwQ+yGrau4R8ylh0LZSbnkwN2uXkJqw80ELARkOW7XgA06oR2kjhG5GaxIW1kTJIKuVrbhyYR4duMG5cLq0BvvhEwNBc3IeJyJRuTFQZo1gfavcNGTc4B4HStgVbXP9wnBQ+lUsiNeV1tANQ2CIpZmZvW86HZYzpNanLOwMdRGZpz09rVw4l6CwQfQGlSlnbb1Kne1yD0ei4nuFgT76W07p2jA+hNYOI9kJ7R4HxotjYGRG+b0++DbZFGDM0K0KykkklEByRIIOv72G/rRSY2AX1M0BLPumQgi90p23wWrtd3WlBRKbN7ZNlKfQgW5KdvMuTNhKEwPEAHoH0F2gogSBdVmFXDBzayugHAVZ9rI/bZqQwqIKU0ZoIeKLTg32HRdr+54jiAigEektoHnNX1C1/4grlF+/MEgMP14dHSSMGYRetgkqQ0KLjzjuPl6Q2b86rkKmwRW4oJlI2u6w31lWHoAQYsSlIkmBvO8owkP/igB8WI8KY3vSm4/sEPftDlY9vn6X99X+mYS4jQ+I5XmS6VIJEgN+s+BzWuSK7AzmQ3ZjCj80lr+IO3/gG+8Y1vhO0BGNYiBwaE72shgFQDqwtiAQJiCEOTi4IiAfRPePw9YGgCnftXcfToMSihkEjOinM3mPnjgQ0BUTqOY7Y036YHprNuXkggXYBQAp3BECA66FvpTM4dkOJ8SQoIkZo0YZmPiK6JJK2cpfYoh81riT0zIGPmzdv3137t1wAAL3npd6xr3t6HBAZngfYdZrwr7bvWSGByburNAakASGMuMPRSVub2wQDVjAEfg2mANqXe9sAZQCS4pvakUt1Ty2CW/bAs03dZluEDH/gAcuRIkOBwfli3R1TeF7/4RbTbbTzyqX8IwXXy69Jb3/pWVs8EkNIFPcqkQk0U6yCVjtDO66fHkE+za9cuPPrgozj4yCP4Dz/5k/jUsdPYRtuxl/agSS1ngp139Pvv7NELyJEHgOaDDz2EW265xY3NO9RhX4ALXqXrY8dJTQGzyZxb44jCgzN+EKTYhwSEHDkgZlx9goa3AGrvSGlwLpufYMxviBRQuZtfBB9cKhjASjnswub0EE6aS9rNRdmhVyXDpQI0K7noZGCClDQ7Cj2k2Gne0/7iTYT730/4wtsJu7cXF9yZpkRPJI4x1tkkk/Oz5/2JYU+m2Bpbk6whmqEZmpxvCkMz9QzNVbG+yTmgzXGvvlQHTbFBeBYHg+C0bFyx7Ky6iUy9fR0W6/Of5q8vTc1VPjT/D8lKzwOaGw0KBAB7zPw7U2uGAXgmHNscVKsNgHprtEfU3HQRGJs0UNEKc8ugMoG5DbqbAPQL7/Z5DWgC3t/opGCd9Q9c7wM9Gg3QPLBX67+Y1gOT80l8VnJ2p/ahSRtmaKapbqM4mFPF0KykksllBX2cSswzvn8SwDDffYCj+0gP+HmGpl/3yICbZEFLMeXN9YjnZvJAyDYrAiElG0WbnwE7VbSfjO9QrDxvleifHxasIAkcFX10KMcVWPDgrAFbpZR6k9/Y58BAKKAHhfljGabO28jlukS/QVagKQZWEDn/jNpHnQZWHmm0hrKChLJwka2G9t235dBi0CZIZgKwtYkGtt5+CLOdIqBFClAMcMkaCcg897MsA4gg0DT12NizjaA38ZI8g843g3KsXA+Slr9jCgLUygVclVytwcekBrmo8+MgxAymIZIUiXXaKQSuS6/D93//9wMAfv3Xfz0oG6pnldHMWAuEiASgKRCAZ9eeixS1NRiajK1nA2SZK3GU8+P/+zgWFxeRE0GoEkBTFw4LfHEQzeodKaHHsJLFnJh+FgAE1ZBA4Fd+9Vdw4oT2Byjaq9jy8FmXFlyrgsk5Ibcz1ACAlrto63qeMgN2sobY4HjZiIRYj2+P3/7t3wYAPPDQQ+gMjUgPqKmn47GkB9NwNiO9dpjv53t91J79raY8xcjXJQzNYNxKD0zF5Ubfl5fLTbB33XECSAS2iG2l11MK/TBy/50wDM1+vw+pcsfm1PMrHL9SSvzGb/wGdp7aiS0JK4vIgW4///M/736uUR0zmNZrHoCBkkiICu9fv3HHQ/iDj38GX/orb8rN6/7wwz5AVI1qOPjwQ3jx9nnspJ3YSTvQTKYL6/4NX5uBhIRgzyQIgV6vZ54xEsew5EorCxzXbDZ1oC/3vAoPmmw6+5egWdwgIFEECX0gUBCVw0JkLnJ5MVUws5QCVH4eWPl6cHBnD6as+KdiGJzrQXXCXSFKoABc9XcPlrpgqKQoFaBZyUUlUkrIlqYb2gjnO41JYpIQrrlsuAnq3JREj4QzOd+sKOdLi55e2c3rYzE0NzvKeV7zDM3VZGOAJgDMzwBtkWDGkA2k2hzgIDMnb6kJCLKWyTkAx9AEgOPJQgVo/h+SFebYWwcF2iBDU/vcx+laM/JXORl42IuAseb0iIDmlJ4PmwmyrnR9G6ksxcwIJueA9qN5sqYBTQu0Tjrn7NpWH2gQehTW6AHD0FxMQkBzrciV60mXbT5rg9GCAgHAJVuAdpJsKtu3kkoqAS5QDyftnnflKw4siYWYHbcNElFIphS82ay9MQZmWP5EDKnwoKHLy11RhWBF3J+dNnUNWX9FiSIz58PTnkAXPcqxzRwsabBCOfBW36cjfhNjhM6czDG15OsfQlcSaFzmqgowsE8q53+QhkIjGtAkYXLN2/oFrSyIU7Lg29rc11JNCBnWt/bc52t1iGAJRFld4Ors8iCdgGE1rsO4e//73w8ohW/0b9Pv4YIKPjSl9CbtBOhASMlCKfa1dM8FyA//jb4PEkKkyO7T+cXm9Yp0Pa356hzN4eRJzWh605vehO7H/hqAAY5X79M3Ku3Hzu4ZhAEJbKYEWteHpkHUQzCdjd3f+d3fhbCuUkkikUNGnWULOxStfB6yUjjWFpTrszCsz8FppEqg0+/i937v97CysoLXvOqVOHAkAdJ5BCxMBVggxdeP8EjSNWbsmint+Jx2HqbbQtYiDZ9f7SwfCYRx+bQOQNV3Bfc2/5UGrSEEUkHIV4vvBXqeWhNxqyBMPTyg+aGTSxB7LvXXHYM7BjTNNcdwBsrgku70rEmn26jZlnjhC4dFjDVtO2SKcVYmmz3mBw1oDgYDx9BEMoUHm3MB8xLQ/fW7v/u7eHr6dJOFqZswQF4ktaSu54lZZ37zjoeQEuF37g4j2B8+fgz/WzRxz2fv92Up5daVu+7SkehnaAb7xD60ZB3PbukXUyVzJMIfLORK9yEp4LQ6jSW16AsSAufOnXMt4FSWQOgqQT9LkiTBWerhJIwpN8H7TXVD3DfQInVxp4kT8JV0ERkHwLnYea+/BJYNoS9bNvbMQQ6U9AzNoMnZAZ8yoGUBPNd+cfUzT4Ek8O/+3b8r6ldJQSpAs5KLSpaXl0HTmv4909ZsK+tjbT2Zn1boiYQBmqM9VIfJase/sHXz2sgMzY5IUO/4VW2zAc2NmpwDwPx0yNAENsfsPBfeTDgjWjMoEAA851rAkEzxQC8ENDfLr2cl60ubsStqg9F8aAIoBLzabIZma2Y0PzJlDM1JgTHO0MwHAq0RghQBZg1IUiyxtlrJ8omY0V3zAt3oA30hRmRo6r+xyfkkDE3eb3UDaG40KBAA7Nyi+61iaFZSyeYJGcBDuVd9GW0KC3eY/xWUi0Rur7C1WEWbOski3hIzsWOisguAKkbGJaNWEFUYkcm5MwNXQ/VXjg2oZe5wH/Wv3T1kryq1jzIHvOqsvcm5vnRM9CEJUHUepZsBsUTMijh3ulktLKCpMaSE3a3/n6PwdJwU8OTa0zUDK18B6pdqQFA0jd5hZWaSWafOAs0DeQhYJLv2aKYkY3Ftv3sJ+++zPuX0ZnoX5jVekKS49StfRpYV38GyLMMP/uAPuvazdc0iSygeRV2b0E8DteJLfJZl+PSn/x4JpXgsPwQJ7e/y4EMP45ZbbnGA5qW3PAahBJQgCAMWplRHrvIATG1CM7VIpFDEGFnkAS0epduM8g350CQqB9u//vWv461/+IfOBFYK0izbGBg25T0Hl7v+4nnyYFrmIlcIwWSy88vNBa3LsrwASQorKyt4//vfjwvLy2bc2SiPjPUp2MGCYYrpj9IBNwVAM5k1LGM+BsvRua+fW0I3l/ibwydKr8f11gCtAiWzwOzzgjQ0O2+qTRBEWPzGUjGPGBu2bD0o8GjyD3W438liPYp+e00ZVGQHAsDRa59pUwAA/tUndNm1C4uFtKQASpKSA6ASUcqNYTJjZzAYQAiBDEBCdSDd4qrKc7HzhkDBOCQSpSbMUgANNLCS6hfbpUGGVFBhH3bPPfdAff1WSGONd9XMFO67sIq/PHQ8qMsuoQPb7K9djf5jHTz4iquhpDGhJsKFCxdw/fUvdvmel+exLLVbt/zUCRAJvOUtb2Ht7fvSBecya71dv1YwwDI6sNikA4fZAR1gpyHpmA8KWKI++BgO+0PCA5QozkN2D5FwwCsJYr8TXDAhB4y7OwP2MNwBlXR5Wnn/+99fKLeSolSAZiUXlZxdWQXMC8aUATR3btmYWcOWOdIm5+adOYf27TapdFgI77asY+vcxs0s5qa1SWWXUjSMX79JAc1cKqhUT916HxjUUzTqG9NJMzRTx9AENgnQTHT5tQ0yNKeahGce0J/vWp0OGZqVD80nTNqs72uZNl8exYdmDEJtKkNzADSm1/NvFYrzobmJwJj1V1nrK2SUojEGoAkUI52vjtlWmZQuCFe9D3QpwfzMxtekqwyguZhuXpTzTgRED8QYDM1NBqIrqaQSwIGY2TL0hiyBg9UipgnbAaJso+d+4WwvArD0D2GRyuwCSbMNSQHoHgQNzgYmdj4f6XbmIldA4jd6WhXD0IxM34MiEV2Symzii3W1QJerjuVoGsaPjWh8MOnqZslXAeaH0udHDPSVAbqgQJ5lqIwvP8YaegzncYkIA+UIAEkyh9M1DUJN0Tz21K8E0AjSgQChCLtTvZhbFpkaAJ/4xCfipEB9G+5v6Zcy1brGMQr1dYHdmIECsKO+G2eOncRf3x0GNQHgAnpAkAd8iJC+5oeCdEoZ+FxpHVXzMqhkuoAFfPjDH8bHPvYxpCpBH/0ATH7Vq17l2q651AUpQCZCm0ErbdKaqUHA4jyQHjBgXer6RCmpTePNe0UiEo1TmDGooPt7TVHKB05hdQSA+++/3/n/a6KpWc2yxEwcuh8uwazTywKqYVnRPRHg5eZhAIrqL1/u3wKQZpw69woKQHYhmBwUm7pGTGnLDHOj2oJ8gyVz6GDSUshPjqshAXzt7FLpdStOT1dhAMl8Aegb3HsnIAQEFTmhUkrdTnFTKvMfpS6/U30dBMshTBSuKbx9lQ0YpEyQNIhC2eQYkEr7vlQASCD5wt8X66okkqQeqOmB9jDnDjI8qo7j4aRjEToMBgMkSQLZugaicTlgfW6SAAZnCm1aANYJIKlw1acfCtuJgOtW9kOZfa71k/nBR0O/vXkuof7h79E6q03qb9y7Q5ODTR1ExCTPkePEsRO2oto3MBHe+c534v4H7sfl/3hQN5sJFjdz/ALozjuguh0sLZlxw60BVA5lAHXrysKDgdpNiDJlxf0UBnvizzwJJZIho1g6s289L4YBn/6aBZ/L0gSnBE6XiKHpgHh4H5oiWvsrGSoVoFnJRSWLKx7ZavS1GeLO4uFuqWyZTdCjJIjc294EP5o9tqb28tGCAhERts2HZueTAprt3N9fGwA0AugzPw10kiRiaG6eT8+a8aG5VlAgK99i3E2dTlubzhitZGNSZGhuzOTcRqlvJylam2hy3o2AsbQx2iNqtmVAVqbTuMChlXbu2ZAbDZrExYL7J2qtTQFaOXjY6Os+G4WhOTtF2LUVWIpMzieJcl7G0JweHvuiIJcsFKOcbwaTvZJKvtmFLDVEdszGb8iaSm5rbjZUax+SKLuxBBiAxM2+yw6TY+aZTqYcS0yb2EEkgZ9CEsKZSw7VKyhbs6oElb8bqdpuUHMPAGBBpeCbULcxt2wfIs2WNGUPjzzNynf7ZwamWuBMASCFh+l8IQdSQC4kzqR6EzstBfYme4ogrgNrCDmk20jXUMMrX/lKl2xw21c0sAjl3J7olhZOL9eeijBVm8Ue7Mb5qaIZkq1L88bv0T7hhIDSCGyQ7sorr3QMKXKgUfEZ/N73vhcAkBjgSEFCQODEM3bh3LlzrrydYqf2S0nAU5OnYAbTqIkGcmQl0ZAt64l9hwc0dbAQ3dv3ZPfgaH50CEOTtTcbV3a82/yklCZQDnAgvdoBjDGkomACC7Ff1mJKu8BaWqEAdPR+aR1y7vU0gGae5xBIdBrZ5YkMrlLO0CQlA0YjrysGZ40PTT3vB8jRxpAgRNDA2HpiwWTHgmPjMsjr4Qc0UFgy95XSzD3ZPeR+8wcmIRB1d2cAak2F6UpAKBsp261xhICxaeXok57lv2SLIKWZ5ufOF+e2TOdRE003tGrPfT4Or3a8HkzPPjIck+c8QEcCg8EAaZrq8Y1cMzQtUG0iZwPAC17wAuiWJO2kFsDLP+M1v5quCvUSQK4GeN+fvg97kKOVJKXWQ3fddRfQ7wNmPNx+++04dOiQa7OtW7ca3fXLt1QSH3r/h3T9pF4HhBA4efIkCITWubaZ93q27LrjJJ5zZBtUvx+uS25NlSAL4lrdpXYpoV1z6LEkYcFV/3zygCYV53fqAYYiCMnH2zDY0xwQmBlp56Wvgx5jHOwk2HErwnSuZN3nz80XKkBzBKkAzUouKlnqeGeTtYEGJy5Z2Ni92xYSdIVwDE1A+3KZVLiRVJ6nGwLrAr3mdGAgG+n8woQA4tKqb6NGH6iNYJZrTc5nVv3CvSkMTQtomoAg6zE0AeCZB/QCfi6tQ0iFZkdtmj6VbEw6gxAc72/Q5LzZIGyd0/5YGwGguYkm5xmQ1McJCpRsKqBpgT5t3p2gUVvnhkh2LOhxfqbWjIIVjQto+vrYKOej+NAEtB9NHRTIrwOTRDnvysl8aO7cSmiLJGyfQbUOVFLJxKKkZ+ooGZqOWyG4DZlmEZptJgdSXGAUxV2zIQYDTEEOKPCkReU2ch5wMH8U3Obbsm8cM0zZDSPKMVJfYghoSuUYNoW01AQleoFaodzVywOaeqvtNqH8L2dzEQ8KFPwBCQoYaERpsGWlqafjArzpN6BZVYfUcRxqTPlmHOa7zeR8X7KqzVlLgOr8qI6ErOPU6NIlQuCXIHA/NHiiSGAP7SppMV92Y6kb9GGs00/91E/5vBXwaNLBg0kPsSSJZkYlypji13chQYJL7joR5DtLc268TdMMLksu0wxNmQcMzZ1ipwF5E7jgO0oDnFIaM07hWbLSBGYaHuWcAX4G5LMmo1Y36y+UlAUhLaARgh8U/2SxSvs1ZmKak4UYPA9MZ41pfxg8RkdtX15exhXplWjBPoQ9gGpdAsRBgQA9NoTwDG5bR3sfWZNfAOewgvvlkbKGM0vI+oDm1NSUaQd7lOJ92XJJkJgIUsU8lVJIkEDmIYhIbg3ydX3OVF0DcgR3IFBWVz3v3MJV2qcAsOvBu4uVMqD2LbfcEilKGvy3/lx37gmAcQKLlM10UulWCAgcPHgQtVoNMOxe224qqsMll2j3GOR8ThK2LKpheBwkATnpcXwMCX7imsuxbYgZEvf++6lPfAI/8ntvdSQGO48eyx8DQTMv29dp1ope3wWICK1WCwDhKbWnumYhCKC2o4gh2qeNgj4UEeGzyx8YeZ+TYOtbPF+VO4EzF0QdmLmu/LESWC8ocMC54ENTJIw1beaSHUuB71r/UT9SomexXVegx4NQwE6MCDh8E0sFaFZyUclS29tC1wYafNvoZn3HlnrgQxPYnEjnfbbADrJ0JIYmoAHNZcY+Wslz5BOYwp9nkf5qA6A5s/FpPD+jgYNpZnI+qc9KpRRUzTM0UdsYO+uZ5qBQksD5VGHWVKsyOX/ipMNAtVqm0COxYcBuzzZgteBDc1LwkAFjGZA01mYJxTLT0kGBGgGgORnIak1q0mwyhmYxWNF4bdXJGBtyjCjngPajuZTWUd8kH5oxs3asoECR+4LTF1bG1qeSSiqBCUpQg3bAAwAqMEPkGzMCC7ioQmZTwDSMQZaAzBaBZTGjioLELieJMOhCYE4IHxRIGU2HV9hfV1CaUVZici4JjlmXRYAGETmGoY9GbQHHDAoeACOmFZTUpukA7m7OgJKtvt1k6BONAKh0Dqew4srV+eto07nzQak0EFBS5/mjGbY9qs2JM2gA5lu/zprCtPUj1NV3O3DGbv4NSwgCbco1cCB8JOSPf/zjQXlWx8tvOQzMvwigBEpQPBywbds2Z7IPAIpkxE5k+hEhNaBz3tiLhGpAyTv7vfIxaF6pLq8m6sigTc4ffPBBABr4dGPF4DeqthNCNCGl1KzFwGRa/y1laPJhiogxiYihycaKsOO24IcTUR/KIuuWpV1LHFijLHmTjW/D0Ny7dy/2JnvRMhHdw8wNcBjNca4pn+aBjz/hDxZiVqGVgWmbXCn87ZFTa9al4MpCrgK9Ikj6nc1Xo3bd83CsW/TBq5RCIhLkUEASbs6sqbDz75hGOlNggByuOc6vqOlb2IMOL0ke7lVI6Wjl05jGD/zADwTX9mOH9qHJyra55XkOUILvMt4iyFxHMgVZ2waiBPfcc49mtCqD+g3OmH5I3YGRYP5ib+1/VQN4DMssG1tKkGYZmjkqCCgDoxuXXxGM4Z1iJ7rbdxbSQbT0fEuAzlP1Jo9McDMiwtTUlD5UU7q91NTTQTPXoU4NPDu9DlvFttAM2413xtBUCJ4RJL3lgUq3gqhZXlsFEPrA4Kz7gQBvaVCQ8HlYzs6XzPVDOMuLzz/20firLZ+HGuQ9JDqYRbn/5EqKUgGalVxUstLxO9paps0QN7oxvmRrHT0KGWObEem8Z/1DDhQGNAagOR8yNIHJQJbFVY9G1gdAa3Ychqb/bVJG5HLXN3iaAVPTYl1zNQB4+n7/bnG21nI6ne8PJgqYUsnGpZOFzLosTZCmGwMR92w3bMjA7+HmBgVKRjQ5TxICTYUMzUndTtgaJfm4DE2jR+QjclMYmoPRTc4B4MBe2uQo59zkXI0VFKgrEjRY+5y8sDy2PpVUUomRfAlo3wvAb6IK+7LC47aEkUR+W+xMVsuISxY9U/AXFdxGvHRjphjgZy47houUQdlD8UzFmV4auBtq1qtD4bqseJRz7gvOViEAPQA873nPA48yri/0gLaO9LtYnwZEimuuucZUT4VBgTxtEgBccBuCZnZatI0cC7TIhqyvSrSW9IPuGzM7AABXH9TXH3nkEVMxwmnqc9eeUMgdCGfrDkWQRCYQlP79xhtvDJqMsyEhZjU4OAT8sKxFW9nhb3PkGJoDKNSoVgoanJy7DqI2DwHC/UkbCdUglQ76aSOd29ppVq4efypZAIk68jx3bEoFA6Sk8yBK1vChyQH10Nw4YC3CB1sR6Q7k9e3FWipVGIscJA0PFvz/pcyw4N06BEkJhFqtpuurFIRrewbQARFD08+vMva0q6tUhmWsWB8VJ+Ob7ngQCjr69dH2cJN0LopMG6kuMDjpdPvMZz7jGY1btuGxkyfRbrcDVwO2D/QcYy8dRkV+kCAV9MGDApu/RaBaDxLvN9UxNOt716wHAZhOZnFVchW63bDudZWAkhSQCq/4tASUcgG19PxPMLuifEYgIJkBlEJCCZ72tKcZ8F2a9UAbO6vGTpBSGm9G4uZpT3V12xF5hnBS/lImIZFcdvnQet1zzz2gpz9b+6M17OcX1V/s+unOO+/046m2DY9SF5JPK6UAoU3Op6amAJHgkDqNw6IHNC8DJTO4XGrd5mleN0EEaELlcFHBdQI3XhX8+ipr2yBEyDrgoD/JngfNs0UgO19I58QHObenB4W2cYxnwFkXuLIc6B/eR/Y+HhSIiQ2QdkJ0cQZ6Y1x0r1FJLBWgWclFJRe6EaAp0g37YrtkWxM9IQKG5maYnA+MKVS9D/RJjBTlHPAm5y0GaE7iH46b5df7wNTcCAzNaR11fTMBzfPLHnioDYDa1Mb0mZkiF3H5VG3O+dGUqCIcP1HSzUNGJBobB8c1oLm5QYEKPjSboz+ixGwtYmhOCmjqF44kn4yhqYMV+ZeXcRma3chfZU8kmJ8ZLY8rdmkAEZlv34lMzvPI5HyMoEAgQtrx4+8kO7ippJJKxhTZBzL7wC9u4p3EP7GNGAfvVOGmmMlpQTGHKBTu4weew6LI8ojDLmq29PkV9S+CP9xENmCDdQ8DeafAzLFBgYIo3VYvBQPmEJ70pCf5vMKagf/0bd/2bf6KSFlS024UApoAGAil66QSMRzEZeaMx+VxdJR+Nzx37pxvE6cWZzp5hubl6T5coeagFLDtwTOYPsteVJkEIBIAiBSqtqMAQGrTbgbLedQ4Ut0AVZQAyRbkBANoclcDtlFaEAaskjC+50y5O3bsCMoOx5EGI6WUhk2ZuDZRM98CzL+ocPhe5s9ORcFoApNzYf2FEpJ0AXkyV6isBcS+rg75X2gtoNfco8qfyRr8U+AmwEh3OJZ1nufIBYFqO4o3KxmwFk2OtmKFAEh+HsKYo8O7YliDuCCNZmtZo3n2J+ygcr+vrq7ipS99qddFKXzms5/Fvffdh1/8xV+MGsTqHzE4o7kv7SGMrSshqGvA0GRjWFEECA+tkK1DsV3uxQlQkkDY9pC58zP6r//1vw58G3s3AlID05SgXq8b8J2th4PF4YzA+ZeD0q3hYQwVX15v+LQBqFnk8Vhe8pKXAADqaGigFMCZ/JRen/p9vO51rwvagCSQsWn4jPrzgURvnNM0BUhgBV1cImuM4e7rHgDrzUvNBQVnoh31K2Ru1noF9E5Aj76yfo18SA/OgrKzGCpKlzvM9YNNQuaZp/qn4NdZVXzORc8ny6iN1yDPCAYWjVuSCtBcXypAs5KLSjjbrzbQQYE2ujHevaOlo5wzfG4zTM4HLKJ4T4ixTM5XkjRgaE4CaF5gLNZ0AMyMZHJuWK+baHJ+ftmbhtYygDbI8APgIp2fS5ubCrJWsjGJo4rTCIzIPduBTpIilXC+GCc17w71UaiNaHIOALXZFPUBnOncpICm1UhIDR6OG+V8sxiafdZGSQ70KcHc1Bo3lIgFEDN2jD6JyXkcFKg/RlAgAEhWEx3lGMDJag2opJLNEW7qVgAgeRp7zYMYa2bLEri8iG3IC8aOEZASMC8ZOMMBFxfISBk4cW0giCkEorS0FmpwEgS+vujdt4u0TYQ9smEwG3LgR5lhYAjpgkWmZu0stS9H/3uI8jmGpoL2x+ZuBEA+IFJUC5jGhgKwSm10pX7JtCzTvYmJgs5ut/7ZrFxQyzgq2lAgzJxeRa3dR//mDxdKizfUJBpAfdvag4QD25FothkhVQJo7sMAEjXUoMoAMGUAYVdtX6FarRams770DHhFggGagjFAKQkZfUOroMEFpfx4j03Oj2MJCgoJBIa9bRABJ7HkcuVRs2OWFllWXayL8mxR7w7BXNv9fwPJDJTS47iHPnqQPFPbRAi3/uFhRezewLMWlWbBKdsFhGEQgoIPCvSmOx4sTfO+h4um5dwv67FjxwK9Z2gWu4UO5PUHf/AH8Z16JmaL9qvtfmfWCwBX1wjyxFF2W6h/aL5vQHMFs+4MC6bm20sogITWpWClpgCIBJRLx84dmP3p/v37NRjtFdH5ZmegACQG+NJzJlxxFGszbnKOZAGU1EDKj6XbW0U2zvZzCo3absyKeQDAW//t2/CPn/98kObUKe06IKUUA5Vh3xcexXl5DoBC96N/hXa7HbKMpYISPjTWLjkDpFOOAa8Z3ISmEhC9w0DvuF5f2dx27Tf9dN+AhkHuMWnzScwArSv15+w04jXH92sOopqZR7b9gMvyRphfidAQtr+CPdRQgBoUGJoEa44Os/QTWxbLTc71sm/Hrb5WAZrrSwVoVnJRyWovAjTFxk3Od2ypoU8C9b5flDbD5HxgALpGH1A1gdaIQce2zVMBzJgI0OxyQJNGYmc9HibnsU9PMUIgl2depdt2Kak7H5oAcK4CM54QiU28R2JobtPjGoBjaU7qQ7PN+j3JCPXa6IDm1KxADnIszUlZo7lRIc01UDcqQ9MDmknkb3S8NSBjL11Jrg9ZRjHvBjxrNM99f/cmOPzZDB+aANAVNSyYPd+iql5PKqlkUuFm2BY4LMOYtL85eLZUxJh0ZsTmm0c2WB6McWXJmkWIJNYNhjUodPRsU7bfwJkNX4y9lmbor0j4CNRldQ1RXgYKmKBAjz6rYazkeQX9bdxkVbFsFKtZsMnn7CLD/ooZmkopiPpOKLs1k7YRvX6BMnbz77rC+MEzgOZWsQ1oXgUkUz7iL0LgKMMAKzA+NE2fPyV5aqHNrCnrAi0Y1WsuyEbAWFKh/0FX/2jMWeA4Jc3YUqTZmjxKsK9pyLYlZg5sx8lDdBbafNqwCG1djRmulPqaMibHYT8yPcv8SsaAA2doAjhqgmImEMjJB23hWRSjnPORUy52LA27GrpY8JLnOc7KJRwUnJkNN7ctQ9OB9Uxc20bgrVLSAGYmXQDMF8Xi0plSaGc5vnT6fHD9weXVgDXNmdhaDztHzJ+DB7HwyFkcSK7G7O++I9Q50oN857rPg8EAH3r7H0EuL5mmsKCWr78L4qVYwabRhrrRYu23HLlziIWSxAf+SWv47w8e8XUNsmfrKLQpOWCiwqvcjXGGdwEsnc2BCM5X7AxN4Vjdv5TxcZ+LuoO+a6s1/D//7f8BADz22GOB/nXUkCFDfbUPKCDJCVtogfWVCZAlgTzxin1aPOYOJOz66kpXAxDYgc4w37Lumu6PALylBpD4QGq2UeIo59p/cDEI2JQasu/xJw5DfU8ryZ6ppWxfoHyaKwZaxnXVwft4S+SbQM765y7VjqGSi0pWet5koJYptEW64c16q0HokQyinE/KzgKAQU1Pk0YfaMxszD8kl21zGpid6viFaxJAk7NYxYBGYmfNz2i2KGdonu0UI1COIksrDNDMABoB0HzW1frvYlp3JudAFRjoiZI+Y0PUBgCNYOK9ZzsgidBhUcUn9aG5wsf2mIDm/AzpADwmq0ncTkj2IiPkeD40L9kCtBqaGR1G8R5Pr0HE0OyNoZMFNCnz7dud4AQ4BjRVKkbqu+kWYbql18mti/q3Tq2O/iYcSFVSyTerWPPZcM9UxjM0QIYzr1b+M8zmTIR+BNdAFcFQUfZ7SZRzC+mYTSHPnwMp5KKcF8GlQtFGGkrgsmS322TGYCCRwB3JkiOmKnhAkyDw0H4D+rHyjiQdnBbhuh1vRx2QRpwZhAIbjCvMTc5R3wUYM8gOBuiIfmlbB2CXQmAWbdv3quQANLwjHLAhlYxAF4IigfNpg/H0imL7Y5vYDmeabNL+9E//dCH9qqiZti3vr0KUcyUhSPsILFZWOAxYA3ICSKYDvSCmYFmEFjTSgaESZnKuGZrkKVIbEA0pudHJwHYdRMqDsEJF/eKyKCtLuKrGJqyKAW3BDGIAXTxHIQdufkkpI/98EehCw4CUeM5GfiUdE00hNs3nVdX/FPYZM43lQYavnlksaQMAsD5PTdkqWiMsKLW6gvpKHwNkEFu2ubs5OO90cJrpT0op/Mmf/AmuOnYAL6u/nKUrB6qVAZvsAYsJ2VXQvDkIzVDuS9qOxVpk1BGQ1DzSC+UsCC2Tz4H+ioBZ7a5CKglhWIUxQ/PemsRJ0Wfdypjtq3dpZNEwNDm4GWmF06KDnmGsz9Isnpk+C3u/egQ//MM/HKS9sfkqZMiwL7kCUAr1r34Dzzw8HwCaGkQ2GTNTf8uUtQxNwACOSvNfTwq7ceesRT++iQPeZg1wPjSzC4BcLoydOMq5B6ZV+ZQcIn7elcwZhOxd4vcwoNoeOtn24b5fY0xBwvoG9TlWDM31pQI0K7mopN1ngOYAkK0UQpSswiVCROijG0Y5n9R/npTImcn5zPzoU2b7PNBJkk3zobnMQF+RCcxNbxw4mJ/WbMg0h/Pnd7qzMcfdw2QxikwvRgAynnqF/nshrWFm1T8sJjWDr2Rj0mdP9XoGJM3RfGgCYWCgSdmQy70I0Cwepq4r8zOahWwPNiY51BgwwNeyIUdlaApBuOYyYDViaY8L/nKGZprrKOejmsFvX9B/FWNodidg13ZYXeoj+NHlsnOLBjS3LPrfTnQnO2yppJJKwOhxVIhKrj8gwCasaXdBlAUqdSoOWHm2jAciHFjIN+qhYq68YSw4C8D4cocxeMKNZVMJ7KStJVtQoxwIXUjP6FEe0OTJyNUbWEIfbQNUBmARq49CkRkE4lHcOeM0BDQtEIr+GRCAY1jGCTrn2ylmaDpuG0Gl07BRgIPARj6Z/k7KpXMbdaUPJi14O0NFsx/OEFKdhzWgYLri7W9/OytP99eDzdkips1ECAGkW4DaDiBfgVIZiDPMHLhk20WgI0xEZ9GEmnpqaZsQNxVWmtlpAU2yDE0AkG0gW1qfoWnBGJ8iYGgm1qTUgaSiMJZRmE96vJc1jYZxzHhcC3RVKmR5Xvi8a788z81c4CAIR4TLAU0o5c1nLQAeMKVZYCuQqWukvxnauQJePrUAQL+zJCX7uDjIURk4eW16rdNfKYlDyQD9z/99VGYccMlX1QJkn/zkJ1GjOlJYP6BF5ne45pDPjFQBLPnkJz+Jy04WA+kICIBKgr0oIElqwOy362xl7F+UtQ8RkC6YtVNBGHZjEOXcVo/g3FwIYu/vMvOscKeCLyP0UTvtrmQqQ0Y5pk+t4LOf/axLkh18EClqkMY1BJm6Pq/2PJ+fHdMKQPNyIC7frq9Bn+v6LFOu101B2Lp1qwc0l2919wY+KeEPFtTgLChbjOYLA7j5oVbJAcsDSbvYJqYM13JEpQcQPp1iC7jXl7PJQ7cPJoBZCaCprFsQVkwFaK4vFaBZyUUl3OS0lgE0tXGABQAy6oWA5oQ0bW6y3ugDMwujIyzb5i1D0/82CaC5ytqIshEZmtMaPATgGJGLE7Ihl1jwjloGiBH8MF56iV7jl5J6YAZfmZw/McK8MyDNANEaxeRc/20Lz4bs5hLZBA9e7nKCckJtDEBzYQYBQ3MSv56BebccDzwEgGsu0yBrM2BojgloBiCrQleIkRmarQahkQ6CoECTAJorkauQ2hjBnC7Zog9+LEMTAI5NyB6vpJJKtFhwkQN0gahgCxhs/JQDOvQ1C7gUgFDLzrHApyeoGNgt2gySZ+kEQGhkcq7YNU3VGwK2Mp2XqIcTOF9WTaO2Z6xZ1o7zoRlIjNjwj+ZLmS9GBhpJwLEiGd/IZeYATSkh2O9KKShKhtbXVbfzEChpAsSAD64j70soUH13oKdFoXaL3bgsuRy7kl2F4mx/HEy6po+SUsaX1d5dGpwDBicLaZIkAdW2Aek8kLeh4z0V3z8ebs2C+udAlODB1pwGokRDB7tCtNF3JvoWwJAgw9DUY7jmwE4MjgPZ2XJgz7SUbS+TmRvvnKEJyx6uWzbwsEYJJkpY0jo6hOk8CMchUWlGmVJKg8/GhYMv3s4hbRI/LBhJrL8PvKLM3FM+vyHuK7Q+CoMLGW47t4R7l1ZK01jw2+ZqgSHeHjXoF66EEhdhm4tjwQXrCpl57teEwNcqyts88BdqzPKVBZYj0PSGG25AE+G8VwqgpAU09hcAKAVoP7pCszqfnD4ZeZu9cxFh2ZWRwEZjl0pCiDpjaOp+dnnC+2QUYECq0kCvwWML4Lgz91eAIq9rhgx5STCqZz5oX3xtPilapi6+LdlzIZmP9IwBTQYYRwzHH/uxH/MF909ahXUfONwwZDdaUJtU2CaBfhYB5kLr+GRWLF3pMixdhHVWobBNeD72PukPFkp9aNo2MdcqQHN9qQDNSi4qabNNfm0AJDOjIRp50g0iHE/qQ5MDovU+MLswGsAKeJPzzWJorjAWqxgIzE1v/N7ZKQ0eAsCMwSEvSLXGC9X6ssx9emaj+dCspYTd24CltF4FBfo/ILyVawMgaW2873ZZQDPZvEjnKxH7uD4iUAdo0L4tErcO9KUa23Q5i8y7+2MwNAHgmkuLJufjtlPMGs1T2jCLnctcqw/kvr87/fH7bZX1W5oDjdbo+niGpq/fsfZk7PFKKvlmlmCjxDZmBeHPf8fCLG70ineW5BXkH18fDqRYUNGWGjDDHEhlOUZF9k0Mwq5ggPNYKUkHD36mW/RGO/ahKQRe8xGpQQUiBgZ4MCGsFntPZcBw+F5lNtx5V2/Me0cdIGXZjwqAkMtAvmgyyQM/oMX3NOFAWS5BRHIVjgNvcu0BJQvENaiJGsqdxDs2lL3ZgI+zVAw0oseOATfkig/WwiRJEqiA+aiDpajGvkJdVfs+zT5T5ve0BaisWFfA+ye1mpD2oemCpkAOgxxN+hgwVwwssUApG6M2urJjL5aAmqXv13GkcVua8hhI6W3k0zFwE8YPLWDHkwmOZFJznShmaBJPRh70RQSkMEBpKHCrgMHyAHfceRcevP9BHFlpY2mQYY1g537Nifz2ctFgXfE9TtdjCEMTuj/Ddg6ZkLH/V1OFACDTUc7XGDWObaucr8gyn4eCEqjOIwCAmkrxwEMPBOXfOW3MnuQKsPJ1k6NEYtaX0qBAzgtAtK4qpd0OWJi4MCT5epi7PAfIkCMv1DalFGfkOaB5pV4/6nvwnPq3aKDZHBi45gAAksGwsmUmSeLGMCkzp7jeJFCr1YrPCOXnIZQN1MXWZeO/U7kDMFWchpAhY9LqGs3rWJQq5sVzJfeM8HUpMEqjZcG6wyg3Odf+nylZ8L9VgOa6UgGalVxUwk3EVSYwNeLGWCb9wIfmJP7z4vsbfWB2YfQps20e6IgEU5sUFKjdZ/dmowGaSUJIZxL0STgAURJheYJ2WmYm66MGBQKAy3cCixFD83zlQ/MJkYy/5GaE5ghRxWsp4ZItxejd4wa7AYD2IGQfj2NyvjBDAWsUANpjMrVj8LAvBNLRzzRwzWWEHgnUu759x2VoDlQIssr6GAoBmJ8eQHKGZjZBlHPWb5CE5hgm51tmQx+aAHC8YmhWUsnkopTbtJWt8HbD63yblaAP8YbeGDoH8EMxEAIDtqA8GMZLtoCcYCZ2DGhQZrPKgcKwauWgTQiEFu7SedZ2mH2vZ4bZoBWNPjzwGVTKMrdYefmK07tMNwU4YFKt3ApSOdB9JABS7V/KLwCDRcCWIUoYmgQGUph+JcKddDpqE6sWCyyEEJwhSoDG5VAAbs9ux8G8PCp1ANAwxu6+9IpinZlppYN6oiqsrq5qwNhckBY4pBK2q1JQzImmoNSN50L0dQNYkAN5Eh/sBalj3XEm1TDza1ueBfJMAcy/qwUyFZZ3WqBmyHOUhDP1hy/e5+N+jhleYTrX5Q58tNds0CPN0CRhWH68Lko51mJhjJg5qn1H+t95Xcm4frAsuJi1+K53vQt/8o534Kb33ITv/zf/Fvfdey9Onz2LhAhfiXxoehDMg1S8T+J+FSQgFQfqQ5AyWHqsL0flwduPfvSj4FDsWm4uPMjmF51hUa6jDEBC+wQt86HJ/a0qKDz22GP4yEc+YgtwY4KU1C4RYPxPipoHA8MC/XgBICgN1hLBx62reVjXgMoIIFcD5JTjmuRafiN2iz34anpWm5IDIAlIk52rq21PCRAp7PjsYWw5r/O2AKT1Uezb1ev1UGMOA8X3fhzgjtaVkjFcrGVYV3vfhoX5euaMZzdOAEjJgVZ2NsAYmrE7FrviEYa5fjCp6rt86grQXFcqQLOSi0q6zDw0l8lIkXIBAPUcdbYejgtk+Pv9IlLvAwtbRp8yW2c1O2uzTM473DQ0EyOZnAM6aMqFpIYZZgUyCYDIGZr1gUIyAigGAJddok2EW6v+vsrk/ImRjJ8gZjQy+3DPdhTAw0kYmu3AncJ4DM2FmSJrdFw/mnFEcVkbPSgYAFx7OfQmYuDXj+VxfWgysCHNAYx4gGBly0wOJVmU80l8aDLWuMppZBN4wPfb1vP+t+MT+vetpJJKyG8EiRzHEYg2tWxDHW/2+YawmH2RhWl4MiXoabgJpRCdgQcQQtCIOBMxZrPwoCX2ksk39H3oxYF6QXowk3MG/pUAGQGrq6wEFTLNCiarjokWg1ce4CF4kKpQhAMhPIAAAk5QiS84lQVlKzYCLKCk8mUQgGWs4r7svmJ9wIAt83+ZeTiroC0AYsjz8u677w60sX7jhj1dBSXA4BQgpoP6BBt9A4r51tSRuS14JpgvVq7Wb9318NCaBACwBekDhqYG208+uQ7v67UAqej3hoWXsd/WZvz5AmMw21+Ljxismao2OedACksmPSgf5suqyL4XGJo2TYHJCvzET/wEdmY78am/+zsISkAg9PoDJATcfOy0S/fLv/zLePvb3453vvOdenky5y3cB64ObCRAUuJY0oMgoQ83ABwQVzF8mdg6Egqfm0VAiIGWpWnig4w13rPc0qXBRyoBZKGARNQgTXlJtw86dRqf/exnzRpHRdQfeg0IGZpeZ+ensUwnfhiifFtIdq8TUYdlmZ9R59BX/Tg3LdPPQtDOpu84Q9OxvyHRONPFt97q9fEHRq5JfJ3FFB5rzKCHXilrMegvBRA8u9E9I2y9GQM0qKu5Fq7ZGzA5L0vgfKwa1r5NJ/yaXqyDB2T10ltucg7DJOXDoQI015cK0KzkopIudzyeJZhurZG4RERTBSbnkzI0OWM07RO2jsHQTFMCNRGYnI/LzgKA7oCdUo7I0AR00JTYxPtcf8gDbAPSYXVJMyAdwYcmAFx+idlo9TwdrzI5f2IkZxsDygSa5dZmQ2XPts01OecuJzBBUKA2CwoETABoRibnGCPqOgBcfan+O8h9hcZ1hxGzRmmEQE5cts6qiKE5fr91GUNTKZrIVQAPCnRktTM0fSWVVLJRYZFnAZTbsrqk4MwfL+Q3dhbLiLLx7CCbhAomwECRJRMEazB5cpNzjxgUAZ5gs8q2NJZBGbNqwjxh2GY6kIz1U0cBoBT/5SBkqAsFnznLlEAwpsm8rnEQFLPJ1el8PoV0iEDn+u5SkO9w0gNW79N5tu8P9H7uc59rUgvQ4KxuvnS+AJNZiRma1lQ9ZiQ5cCZqlZic+9KXvtRACexQlYFkhf4iAmQXyFYCkDlsE4DYeFNKIRE1r7sbwh5sV0qhbUzSyyUC0SkENMPoxwLWTUGcBRDhVezzKD40OYNTBYCcDQTko6970JOCMR37H3SgFwOIrHC/kvaAwMysUo3naF63RJKY+S8giPAv917i0vz2b/829si9uPnmm8OGYH2S5zmQJBBSoQ0JAQFp9JpCC3fefTfiG4M1jl1z9antAqim9XdDr1hXO46UPTigcuDw0SQ6cFXav6uCLAE0FWrUQGZA2dr5FYg772bzigNrvj7a/LgWgYEhIGfXxtCVgI8U/rXp7e7A6mCksy5JOkBzSZ4v9VWqxYPK2hSfgnZzeSrrOsQDeNxfJJlDo1vTZT9VkhmnUCnIp2z5JpkogvIeezTlsvFkr2vgOLwvXsOKonR5cTq7nAtWTz4/eT3sQ9FlOTzKuQNcBz4gXAVori8VoFnJRSU9tsnPpRiZoVlvERqbBK4AQJuxqNIBMDMiwGqlNodNY2j2MvbYyxLMjsrQnAaWktqmBeHpsYV2PJNzvWD3+3Vn6lZFOX9iJOOskWx0/5CaoZmgFTA0J2Ef+3spH5+hyYMCAeMHBoqDAmFEsN7K1jnCwvQAHaohMfN3XL+eAzbfKCfURmREW9k+ryB5lPMJ/A33WPsqKcYEogkdkWLLkv/tyPLq8BsqqaSS9SXG5tZkmPvNl4rTUdlm2gs3sfM7vRgEKN+EFgBWijahARDEwIugXL55BBQZlstQ7DYCaKE3jZoFBYNjqLhwFOrPwMcw+9BsnrPPhjE0yQCFvkYWHCvvM0q3mrITQKTA3AsBAB/72McAAD1IwzAUUJldWDXIVa/rQCMQOtAIAaCpawGxtg9NW2Vrcl7Y5Nv6uSGg6xo3UavVggZSbD72c7ExlTSMUAcweVAi3Ogbxqfpkxw5UkpZGgNwsyKUUkiJ3LO+LMq5BiodwhyNYZ1+9kTmwehYf/vT+U+F9w0bnGSB+HJ42cPkYc1DE3CCDSxTuHuouS4b7+ZyHCgHQTutoT8lIAhc+w+PAl2JJ58M350Wv/3pLq07RDH97wBNkYByXUZCNUjHvFN41nXPxvLystEjHDeF6NT2WzIL7uuU+BoQNAMDi804Lls3s3AgGdCxBcis1OS8IZroe0gdAoQPf/jDcK4EfFLYOaOUBqfD9bWgrq61iIB+y6Km4l1B/2dLsD5pVX3P8GcEczkAAA/lD2FZLjOTc55YwsaGjwPChYxnrlScSXg4QcxPZnhgxA8WVKGypc8IdqZUuobZi/oCis8uu3bziOQlBwEcbGf/a/Z/ssY8FED/REl+lQyTCtCs5KKSQe5XojxPRwY0Z6YIxMw6J/HnBwAXWLCLpC/QGpHB5vSalah3fN0mAjRztmiOAULpSOd1zK76fCYxOe9zFltGqNdHA1guMwe3F5KG88V4ZrUyNX0iRLIXIMpHH0u7txk2ZNePpZUJTJd5pG2VjwmMTRudAkBzc3xojsuGBIArdw3QTlLUzNTvjRuoiDNSJKHZGE+nHQu0eYDmgAOa4zE0rcl5fQDMrOg6Hu9WPjQrqWRiYWsGJyUFZoIFX5H+b3HTpYGNONABv1tFaUvFbFD1R/IbewqjnFPJVsXmGPgz5BtgAMO3OCZt94j+Rt4vpmZiCZyinsvDw3GaM1Vg37hize6487DbcBNpYMmBDZyNGfWDBhg9UKRBWb9G8344Ifo43jCspu7Duv9MtPWMH+ApaKDN5NlDjvvq3IxY+6NUAFDTkf4eSorM+Bg4tAzAWDfva5G1Cb+Tj4WAtWTZhyHIi8F5nS6IsF1uck4GQCUDukhov4LeJLYIliilUBMieNaHYkE+VWCZckbprnv60OOt7DlqwcDy9xDuk0+JeAyH6QIwiIGKzn2AZVkGrFKWYRk4w7FJjvAgml/Bocba7/lCaIbmwrkcR48cRe9kaAXWn2348hxq6OvpTM5t29QvgWppv47XJNcCRPj85z8f6m8BsYAU5+t6WvRwRp1j7YVCub5+/ADC1HfYEGH323lRiHKuFBJRh4TEhTSFSOfxjPq34MiRI6YMARj/kSq80a0BRWY7OzBgjD+tsvdzqxQBogaU+CC9vzkfVmL6Gb7KsUw/BWAMzW5SR061YlAgBRAp7IdeT1RtR7SGc9cn5u/glGsHt27yh1U0Dws+NAMz8xAwDRjwhecRFU3TWRbud3Y4x8eOCvRS4M9RZdc3pWxnsUztgVuZyTkYk1RfqwDN9aUCNCu5qCRjNhkqEyObnM9MJRA9P6zHBTKsLLX9i50YjO5j0MrWWaCP1LGzJtGrL3kbJSP7q5ufMQxN5kPzzATAQY+9CIpsdDDj8p36L2eNVibnT4zIxCOGagwfmvPTpKN3bxJDs5+FgGZtnKBAs9avpx+X47qe4OChkIBojv/IvGqPREekSE3zjGvizTdeUo3uJsDKzq0JMunrMy7ACgA9VpdcibF8aFqTcwAuMNDpfu7MzCqppJLRpAC4DSf7sQTKbeCizPRfxpwMfkcMCAzJvXQDxwADc6vfwElvqlsApaIyeb6yZHPJyyPS0YTZBtgClQDhsaQNxJtI2QWy86V1A+D1zJccC04IAaVyENIQNPLFhgwiy+JRgI1kXWbe20aOtt+J67Y1gNOLXvQi3kDOXJYA5CRxMmHlUqrZkYqA5n5g/vrSulnT2ANZy4EnZcCXrxh53IsBly5AjwEeUQA6orGjBvAAqh0C5YCmZ27Z+skIHDcggQpHUbImQxMRyFcEUhT4oYACRGQ2pYr9WGqy7fQqZ6m5X5SdKBz8zIuMLwdghrq4CN4lbNRC8C8OVHH2pu3XsnQQosER1AABAABJREFUEMJEqlbAz/3Cz6Oz2i7WFwAciw9BvzpTbCVMKuGgYiFhQHqjUxmjUNn/PMi3RH0sqSV9n1njij5lzXAVns2rcevhCycP7qWDMYUuGhqv/FfmoEbrfKrWAlEDO8VOVi4B7QfMHeTmNAoMzbiSHq0WnLUoo4MFUQ8YwjbdmVoTIKAB+7KdA5TiuCjZE2YXgGzRg50ixd8nhwOzeauWgsJVaov+bsBKvr7q9Q3B8LauOQpsf32zq4+Zqca1Ak8TzYpofQ2ea8E0CUFDOwfjo4XSHlDSpVTRXYESXB/oYE8YMg91pHYRtE8FaK4vFaBZyUUlGQPrkI9ucj4/k0DmiTNdHjfwhpUlFvCGxmBDWtk2rzfrjp01weI04C+ReYLGGAzNpbSOWWbNeeT80tj69BnAQvnofg8dQzOtY9rotCxVBWQ8zqKUgmRRE9UYDM05w4YMfGhOwNDss0jbckym3/y0Zvo1NiFQURYxNGutMRBWI5fuoHANGDOqODc5l3I88BAAdm1PkVGCmllQJlmT+mydlXI8VwHW9ykA50czA3B2AvZ4JZVUwgEy+73k2cowqIAVA3jmZPRMDsl2FhDyTEQVm0sPeaT7jabfyHKTc2GBVpSxlDj7htdHMpZLXKBlwFg2kdlEclDL3BaUNzgHdB8rr4SpqXJAj2doKuQmQAdj7ZSwGxGBdXBACoXp7DXbP1JpgKdzMEwnpowuwuE7sd9KzQwza//qbUAyW8rOKgLCYvh1IiDvogAyx+kCQEwG7a6Ca2ZcmUpwdlaQDir02ap0u+TWR6YBH3m7aoYmBf6yo5oHIDM319agrPfT6kzmrfluxAQLco0ZYLw9yP4WzzffnsUukhFQacyDXfHsvhKTc4rYZi5XzpR2LgGiMRTX1Zicd/fuxgLNY47m8cUvfhGDQcmz3BUX+gfN81zXo3EZAB4qC4DMHaBpM1EFNMuqGR/MJB5+ClisrF/5WHFS7k6AVwMMeOcAlNi+U+clEpdHYS0r8TXsQONC8BijR/8YKF9h+UXWOmtEZg/Y+QCmYF7+lQY0l6HHcNBnnQcBJfFAasBpkSA3/kIL6zBbRGxwNb8uiTCtT+h8Y5av88JnXRjDZiCVHca5FH7tDUDP+u6CHgBMED1lhoo9gGH3wba78ONvyEFFVCoobpOwsqyIEGytZLhUgGYlF5Vwn34qp9EBzdk6BuQDgkzqQ3OJRdkVg/EBze3z2j9czTwb+pMAmmza5uMwNKdRiHJ+7MLy+PrwBTmnkVl1OxaARt0wNM1zUtFkgZMqWV+yLANSPXiSXCGnZOTxPTtVFhRo/H4L2YfJWCbnCzP68KC5CSbnGTPRgSQ0x/ShCQALc6k2OZ9wDeCs0UkAzd3baxiQcPpMBGgyNoJU47kKsCbnALDAzldOVWbnlVQymUT7PgdXBkCauayGbczi7ybww1AWpAENyadHIZADZ7aw3xirzrIUNb6jCmp44DMGIQiUlNDXYzARcBv/mN2mHChblMD8l6suVQAaCWGBpQ2YYSsZBgUqYaR6iZ5FRED3YPhbOmNAPpunbT/GKDN1JQWQGgCgsmDLTk6LvgEewgjyoek/gP4xBm5QIR1T3H1Sw6KcB8yqEEwNo5xDt7Mbwxrk4axQn858AFBbi6GJaAywzwE7UMGDw7If6ab0pWB0ogCQaUDcwxhFz6NcrQi4UTrasnebUK6zUhL8wCCqagEMik3OlTQAz7AxnOgopUIILD19D7bTdiwkW6CUwrvf/e6SihAje/px6dlyHuy1Gj84uF+PvwD4CfO093Dgy9bdVtVV2pQdguQUjKPh89DlAusXESgLlAMUXWcQnvGMZxQB7eBYSQIF1qJJlZ0DlHGNoRRIpEEdSLDo22upb65dekwBYhqY+zZ3qW8Cxj6cPwis3uXxbgVoH50sABI3+ybBIp7rXnauOoA1Rna5eb0G7MkXPcTk3EsJ85alKyu/zOScSvo/GHd2TEVrnasrCf1cYM8ugmFoIgJvgylbPg8rGS4VoFnJRSWSv6jkCaZbaz9EYtk630CPhANYVif1odn2m2maANDctiDQTry56STmnRlb6HI5jsk5FaKcn5ogmjBnsWEMdhYR4bIdmjU6zXRa7FeA5uMp3W4XVNcDujYABiTQHNH/6dxUMSjQJO4UBmxeqDGZfrNTQCdJNt2HJuT4LicAYNt8DW1mcj4ugMgZmuOadwPA3ksaIaCpJgA0swjQHJNZu5LoG6eZdVp1sFFJJeNJYVNoKISxzzDux9JcKMEziwF+ynaFHr/UeZRtH8ujulogx2zjI0Az/mzFAR8xGJPOaRNqCw4EDCLlfBUSA2cc08i9h8qSjXW48fXMHFZ7BnZaQNODYlafYn524683wCY7EoU6R8oAjt1W7BBXP8VBMr5zDoP7DNsWOrNdkcMgmkElYpNj93kIQ5NiYMGYh6sona1j6JdzGKAZgY8GbIh9aHIYTPs2pDV9aHKmL/fJGAOkMQBZ8N0XSMlBgLL/UTA+eDqKGbwO/IoA9sjdpWW/ElBkhgVjMyw7aF+eTpT3K9IFoL4TImlg9xdWIBRBkj78+Mmf/MlCnWzkdMACOywo0DAgOdkeXRMmsjZvlxLgi4T2E+tRsQDwi83rlb1IYGsZV75miiNzIOD9VsaiLODtRzgIwDXXXGO+l9yn4NjXpaxFV7Yyaw5jaAbrWNEQOlxztDztHvMLpaXpTFYA1fUPogEoBAxNsk1m5vJiWnPrYRg8iODmFlsLCkAlF/Z8GhYhnAP9hbXE6BHnztd/lwdrF6VU8TDOleHHbVB2UAcGRjt1JUQJQ5PcGmAZ6ZFulQyVCtCs5KKSnA1JNYbJ+Zb5BnqMnTUpQ3O5wxxZD0ZnsFlZmEnRYeam3THNTQEgE/6hJfMESTIaCKWjnIeA5rlef/gN68ggYrHV09H0AbQfzcW0HgAZlR/Nx1d6vR6ophkstYFmR4/F0IxMzidx88CnhZSjuy8AACEI1BKbHuVcSRrZvQOXLbMJVllQoP4a5ktrSX8QmZyPqdOurQJ9IbwJ/Jj6AMAg5+00bpRz4FzawIAo8H86qduQSiqpBH4DTyUbPTA+CwNVwNJRsBn3QlE6lgkcEqD8byHwxUrnpq4RuGApXMXgRWzDzQENAGpwCtQ7WtDX4n56Y6tY2bxMvu0tf58pY/OE5fCgQCHY5H+L8jIbZ48oWfZP2SaZbY4tWKJQSKc349zEM9pAu0wsirq+2PHAq10IzsTZbUyfIIhPAMJGQGtUnmJBlShooyBliHMBUEKEvvGURbC81EiEB/OxWGZY1L5ExFwsoDA2CyBECYusUIPYrDhWxekRXQ+wFnIgtr/LaYUg8EqQhwUqy/qLA45svXC3MgWmngxKppAke7VfR/ChEI+/JAQYjXgfmhb/4pHmp8FZugF8ZQ9eHA6pr27btk27YJh6stdjiA9NKH3g4Q56gJK+A5DOcwX8YciQdyliezfrjiPoA1uesoc7AO+v8kz92sAZmjDganhXtC4AwOAsgvGhJEpN1Ws7/ed0qwZRZ58DiKniOGfA+5laMzyUUhFb3Q9oA27GTHYLqBqw0M1f3iYsf49OF+sK0+7BM4g0m5ylYyu1ObCKWpEdQPi6mWdJnM6C5hLBGNLLZFI+D0vmfgVori8VoFnJRSXcp5/Mk5EBze1bp9ATiYuWvZJlwx8EG5DVDgPVJvChuTCXBOysSUzOs0RP2yRXQDJ6hOP5GW1yPtUBhAEiFicAfjPWvONGOL7sEgOyVoDmEybdbhdU4wzN0RmIc9PAapK6+QZM5kMzNKdOxhpLAFCfDk3Oxw4KxP3DTsjQtP5GLSNygPH8xPZ7YQCecXXaMgv0iZw+3dLorBuTjAGa2Zgg6/w0IIlwstZCixHGlycYT5VUUokWvzkvAyBdKnuhdAMfJrem1XFeZeDbMKXIbVfdH/PRs2UQMOGKOkUgn/1fZiCVB4An190CrcpVQgVMI7eRHWJybssrsPLcf9zknF1VHrQqgDwGCGBPQQBDyreojS2wTE/ZgWNq2SZ07CgGPkIB2ZLJl4BkZo06G8Ujf33D+js22V9rXBCVj03rg88nFCXjzmViwFTff9yHZlyWUtqH5mCohYJuIwPNl/u9U6q0mwLAJWY4DzlYYN2DuF+DNpEhAFzGXvbjw0Mtts9L2WZmrnFc280HVl6R4xbXQUGIGoQCBDUCEKms/y3D0NVEWZNz8oCQ8AcqZL5bs15FIsSpGXuutK42sT0TUHAHEL4O1h+qHcMlBwaDMyYta9shfiuVUkAyC0X1oH2FY1/G4KNtG4mhUc6DO1QwJ3Weib3C6h3VoXcEAOEVf2MZLrL8cITsyzjToXcQKltkzHa/rgVz2dwXPCOUS+jzW7kNIVAJP27ADoUUHHjrDsLWWKdDhmYk7PBsqAm7cbQctrcfY5xtXnRRUhLoDABMMKEQ0ORlEvicrgDN9aUCNCu5qEQG7MPRo5zv2DKFHnlz01xN5htulZk9qwlMzuenk4ChOQmgmRsQs9YHZG10QHNhRpt3E+AAxJXxMd+IxTZeZOpLtgAX0hqmV31eFaD5+IoGNPVLSi2zJuej5WEZmo1NinLOwfF8TJNzAGjOp5tjch6xj8c17wY0oMmjnAPjrQOdrmdTj+NywkqSEDLV9T49hzBCNiI577cxfWjWa4RWAzhebwUAeWVyXkklkwoHh/ymiYOGYESzct99ZYhNOQhlWU9EcKbdPA33GeaieXOGJihghvmyixtXnk45dKI8rcuO5an1DEFYG4BGKa5DWIdSYIYXQiGgSYXNfgm4wMBOpyL3Kx9s9CVsMJ8YrHPpsmXAgYHKmJ+j2C4KQP8MoHJA9YtRuuOyYQPzwKXlDE1ifR4TDstNmAHYA7VSwFMa2FVpvGUIC05ZYMoBXxpgKgVSGPtLEMGeXZazpXjQmRgUjfor0Mf3a4BgmrrHhFjrZoADN0XhtuRFPbleqqxODLwpYwciYrcFCSzQpRC5ACgZH6IGUjlSpMiJBw2M3nlE6BfR5pXnOZypv2VT8vZkJsAxUOzqGdU1hgNDsCnyoWkPW9Y91ACU69rYNQJXi4B02s9Z+ysfT/E6Q9BAcsDkCziAHmA3AGYAoovEmYAPG5sW7EzcK3IOoGRfKaLNgQIgVwHZK/Sp7ku2bkFBcKCyUA+rk4yCPYXiWcfe5LxQp5L+Cg6p1mDQBuOrbGqrKB0ABRvlXK1JcPfPGXOQBpTWQU8G6epqa1IBmutLBWhWctGIUgoy9TvhXI7D0GyhJ8SmMcba7F6VjW9yboOnpMzcdFzmaJ7qaVsfAGpMQHMlqUECLjBQNxk/ejMHoTCmmfCOBSqYwS9WgObjKt1uF2A+NMcxOZ+bAjpJGvjQnMTNg72TpEKOBGMMbwAa0Gxugk45Z2jmEzI0p4B24g81AKA/hi/dbtfPi0yND2gCQIa2P2ShCdYkVo1cjc+sXZgBTtSnNs2FQSWVfDPLMNCN+MYd4dZSb9zKALJCqpLPrOzSa+URbAv5MPBCObNrVboP5ZtQbrJYzliLi/MbbB7l3O9khwcF4veFCun/AvYNAynDsEWFysAG0wiw2TLpHgL1D7O8hgBRShnwhyvIGWUsrVwFVu5Yo1CfJwljTJxu9XnF5fJx45rUjIyARedrUVoc9Oafg98OtonK9VxKI4LXNRxjAHD27Fl86IMfxJ//+Z8Pry9xEKLI+FOw4Gk52K6gyqtWwgxTYEBaCZAOnnLNsQl2Pzk3BxZsKn/Ws7aN+suCiAwRHqobzb4QQiTA4ATuTNvIRQ2KmkG6ax4K62LnjE2jfWjCk1858MfZh44VWT5ZQoBRH3rYNU6fK5S5sgj7qwBxl7JMrV5DGJpQINUHsnMAgFX08Jg87vIb2peqzOTcIWv+q5KAYJsvzl7snyypRXnd0D8DZCeLv6cLxfsMQFdmcu6YtQAs0mcPgooePZnOZSCf6SeOMBKJqNwNHCyYZMOW1TKLBVKAcg6NS8Z9MA9D9yWuruYzd+tigdD4gC+qtP5LJW1cSUHGRzEqqWSTpdfrAYYxlg4UMowOaE43KfChCWjG2HaMh0R0mFM/OSmgycxNAaAvFRoj+r8EgDzVD/L6AEB99DOJLbPatHM5qWFmVYMFWVpDL5doJKPnx9lZckxW3Y4Fbbpc+dB84qTb7br55oMCjZbHrAkKFEQ5n4BRl5sHe5prE/hxgbHp+U0KCsRf0iUmAg/tGrCVNU9XSsyNmE+HAZq5EpiZAGSVIg/WpJ6UaI7hxoK/ao3L0AS02fnxeguXb9KBVCWVVBKBOMPAILupVxpSKQXy4v0cM+Hz4KgHA2Mz2+H4nN346UQCIjQ5d/cWN8OxWS+/h4M6RUDARjb3OrtNqGAbVFBQTwDIzCFLMco5/y4ChmbQBtYXYVwHZSP5avRsrWjjPEc1DHglDkZbRC5uDw9SbfRtVJn2C1qUPystw6sEXBi6MXfAVDG/AJzmQA0Tsvdw09qIoWmBLMU+f/FLX0S9OY+/u+9O/MvnXldaW22GrRxgxUFZZ5pcWiUOPK01VqJLflYVrwk7T1TUY7qMApMvBnyVT1eisBubRTZa5Ptw6DwEqHMIJFIIEM4jA9JpLNQuBeD7f/+jwJcBZhYdjmEpNeDjpjCbR6QQ+KO0upNX260Xdg4QEZAtApIATLsauVlIUX+RgKbt+rViLdGYonSm8Fy2iK2me0w+/bPoUh8dtYxd0Rrs1y07Vf0Y1ocjYZn2B2LpbBVg6zc4AyTD+8sJAZArQNYvphuc1kksUKl8ydxVh7tm+sceQgRApQ10pqJRxADhmD2sgp7V45SbnLslgdEkC4xJPr7j3xGuTSXQZvQDP5Ax80n538uE9x9vkxDM1vVTgkBOHfI+ZSsZKhVDs5KLRtrttgdYMmAgRjc5n2oCXYoAlgkYYz3G0JJZOjagOdNCYHKu8x7vxCU3tLV6H2MBmgvGPdKFpI7ZFf/7uf54gYGkYi+hY5qc71gAchKotX1eVZTzx1dWOx3ng3Vck/NGnZDWCQMlUOvruTLJfJPmZSbJNGN0XEBzZl6gxgHNwXjgeMbn6Cb70ATGY2j22LzI5fhRzgFApSoENMfQBwBytvPOFaFRH/2gBtD+fY/Xp0KT84qhWUklE4rf6dttGIBwEyqCK+HdazCPgg12CcPF0ayGpvGbVQsfgDi7zfzgw+cG94bBaNZQrkxclgZgLORRLA8A/uqv/qqEReTTWeZjAGg6IKCk/gGQYilE8W6/WEcOSdqownE662/QMdEAB6wEbCkFDSgNJU9x4EXpPKXXMe4HDm9yKQKaHKgY1l/WxN2UF49F7jLAApomqQrYvoIBI76sPWIPAMKXvvSlsorDsSYBDN02bwC8LUZBt3/ZPGRYZFEVfr+K/kYSR0MPxlXIDKNgVQgBn/jAwGYxNMo5AHQOgiiBh+0llpCV1AHBQUaRoRky8hyjNVdBn/OxH8xDMHAdALILQHbGA2ScRVioK88kNA0fynyHAigpdIl4znONatZkP4NlNzr3FTy4FG9b40OzvO+ZmhwwNWl8wCo7sEr6lbW7Sxu1i88jqKlrkwBsI5tFBNKRr2sw3qJ2JRoSsIoD6goAbxM+f1AEH7krgbUOodxBhQUmI1ckZelkUJ8w/5AVroxmPvXwiO6svwyleD2G5rjv7v+cpAI0K7loRAOaGg2zjLHRGZpAT4hNMTcFwsi/MkvGjihs2Vncf97Y4IGhP2mG5ngm5wCwnKSBiff53nigj+QL+Lgm5/P6L3X9zRVD8/GV5a5HjewBwjiA3ewU6cBAZs6Ny4YEYobm+Ey/hVkCMgaOd3trpB4uPc4OnDDK+dwUgijnwHiHGj0G8KkJAU3USK8jRrpjrkn2LpIKA6Tj99sMcLxW+dCspJLNkHLwsOx6lM4G5BgGlph7PADCJHaayEtmzDb31zJbtEKAAgQiX3AO2CiCfAWfjIwBAyKUxzrjG0+PRIWbxhDgHN4SRYBMq1LCNHJ1MICS2TiH/uy8v8uSbMMyHBikCtGpbYaKtx9QZH06RmMEgq4hSvn6+d/0TZ8WUyE4M8SfHauBV5YBKeXguC28JGiJ0jCLBbeUTctAIz80w7yvSvYDREjTtNT0N9TRlymEcIw1ilICRRBiqKmtvc5A2BBAYmkcM6xwCbauXl0FD9jbn1Qw5lwRDuwEqw/C+0x0ee83MLoOn49QxkcoNUCi5UZXGTDja+THcMxI4+ONQBCCrxEerCWd2M+LCLz1Is14UK4x+Twkx97k7VlQ3elj28D6q+WyunPWzQV/RSDuLxuIjK+rqlCHIlAIwDBvw8jfAVg8ZB4qFNcExf8vA9z6x2FNrRXgGJrE5mUcFCgYL64efu31LTAM5PNJlQGO47UEgPE5yn8e4mu1mO2ah22+JtFNMdBfyMsCk0x/C2JHDM0yZrZ1ZTEM0PyfDx/Bhw+fxD+eOjekdt88UgGalVw00ul0oBhDMyMaGdCcakKbnG+SCSzLBnk+vsn5TEv7GozNO0eVTEooYxZe7wPUGH0KTzWBNNHgCgc0z/bGZGiyx8S4gVx2LJgPPQZojqlPJRuTFda+2ofmeAzEOQPW2zk3SVAgaU6mk1zrMy5Dc34ayGSCxPhDuDDmWOp0/H2TRjlv1IGOUBMfagzYPXJCnUSDNoc1zoDoSZi189PAiXoLjU1i2FdSSSVetI/JIaARJ+nEPwAhMGU3rRFgxZkwnk3H0ke+4LyJqd+YW5ZLqV+2Er1KN3rKB8BRpRvzMICQVdFvNK255HAfmiHbpwgkWrBCCMss4xv6YjpXRx5Qx8Jkw0A+UwcV5x8q6sGFKJmuA8/OfMvOlGQTtl8MaNl+uAAOPPnibB1suvLgO+WYkTXPJGUxqhi85eCJhqLI1S1+R1bxLa6N7L+CBHi6B1Ji/6gxMBS4TYjYr7ptykEjNzTjYcVB/gLrTjE9S1oxANOGSww8DTc5X0sUBAndE7VdQGNXSR1sGd51gfPzqZQxOfcMwyAQlFKAATRVoR2K61S85rCpr++IQd4AFAYD4ErqEGGMw3xhcgYl+eWO5ccgcT5fzaQdBraFgZNYUF2EzMHhBwtrsxbLRbF2UUPWagGIBpAtOz09Q9OkKSybquhKgOnr3Tuo4rMk+J+3XxRMiq8dMZBbCqQS/KpSNl8lSJH3Sx2zOtlhAfeV6Vo/LpM9K7kOwwDNdp7jrx87ATkMBP4mkgrQrOSikXa7DRkzNEc0OZ9uAj1K0Oz5yT3JhrhvFqDaQGFACdIxg5RYX4NBhOMxwIxVxlqsDwBqjq4QEWFhRoNQMyyq+LELyyPnBQCKLSNKjseqs4CmYgzN0+3OWPpUsjFZYazFcX1oAj7glQM0J/B5KI153sQMzRlCl0VfH/dQo8NYy0oSGrX1XvSGCxGhnw4mBhD5uiFVMrZ5NwCkLREcsozP0DRbxxwYiPFY2oA2OR+IBJ2BH4jLleuJSioZSwpmihTuVR245PanFKTl+RD8pk1v0kyQnnU3vwwNKigItmn3f4miKOeWdedAUr8Fd+lktGmPUYOCVoLhBdEmFJaJtk7gFaMfuWaxoITfwIc+NG2Fw3YOgRRiHze4tjvW4jCAzLA+y+4NzIhhyl/nOaCU8WnIAIUA5NHXXH/ZbEt0cwwo5RQopHOBgCwmyBiMvO082OmwDJfGMt08+5QDVBICSdjXAf5oQSOARDkzjHi3xnVQJYDSEIBRBQUXU4SAY3gnB28CpmCInrmxWczIjEcLWMVgO2NUx0B/4OYAGvi1gDLjzBZZq8ZEm4+VoO/Z2uSCK9lI91H1/fLkx0AIwnLWYtRhBfCWfKZD5mHY/MootkaUbuJHLAbS5uB4Ccin5+UwlilbL+wcKcxDru2QNTg+lwnaP7rHsV/hGJkBQxN2OdL1o7ztguq4vifh2zQ6WFgLvLXTkAPVAdvfFW6yVtH6yupvV2o9F6K6mjZxBydrgIUBWBwdEFmg2j/iONAqXV2HHe74x8VwQLNGArlSyCtAswI0K7l4RDM0jU+/MU3OWw1jcs4YPqsTMMYG5rS83gdkOuT0dgMy3QQ6YnJz0/OrPmpObQCIMRiagA4MtJLUAobmY2fHo6xL9tDMx/ShOd0CmnWgp+qoG1+M59oVQ/PxlDbzK+kAzcbo+cxN67Ft3Tz0pMRgTKafY2hmQJ4QkjGCZgEaGONM7faYDrW7XTYG5XiAbyBJP2Jpj/4SknG/vpImMjmvtdJN8aEpzbqYSD2OxjXNt+4wzqsp99tiuzskdSWVVLJRCQCyAhhkQABDXQpBJivlAIzbCzu2lM6jEPWZgRXexI5t3NhmrzQKcwkQFdQBPmpxqHo5bBT8ZawdyyBSYSbrS4m5e+mGu1gF1g9S130I+DjUDBsox1zMZl4FJrhxfuRxm2DDPVwUvHmpxioE83lqgS9zLapJwUUAyzUEEePyPOhs26jYDMr1pQffuckpGXAlLEcqCUHJ+u/3DLTRWZMfO2vWdUiDlszDEMxcc8atoaYKkuih6UHgQnRllyNTIB4rvOwYDORlmuvCtROVjDleHQ4a+T4O9FMG+GTKEGdoCg4qh2OKwNccZXFEM6ZMZhGgpRDngzXq4MFTfR9jkoYNFACMikJAkxfggFtzXxGAjos3jHQKXXVwhuuaYHt8cQ23CyHZW7dpMKftGBPCNUppe5ZUZ90o8Zyxa5jSZQF13DoWHVS5AD6+AmEZVne+tChAUYlvzMLN9oYha4gyoDy3RIj8hbpDApa/fS6v50OzAjQrQLOSi0hWV1cha2GQklEBTSEIWaKcPz9gMsZYZk0pM0DWxp8uSULoJHnI0BwD9Flse0Cz0R8f0FyY0aw6HhTo6OKFsfJSQWTK8cxNiQg7FoCVJMW0AVmXKt95j6t0GHN53KBAADDbMibnmzDnOENTifHn28KMDg7WMHhkdwzgEAgD8GBC8BAAamkfyYQs7YHy9+QqmUinxnQa+tCUY/YbMzmfhFk7P63zOZ1OuYONxepgo5JKxpIiawpAYWNmE6wDZlHBMHEI4EfuEq2ZLtTFg6l6ExeCQYwBYysSgxDBJtB8KvO1aEFPMl8UArDM1rVQdqHqbHNs7lGWDWTArQJDU8ExBQEPwHAASlkWoQVn1sLYGIDKYNio35WOvOyqU1ZXBp6xti3W133xbSSVY5D5Mgm2L3VnlAcssnV2HxirsIxlSg6UpUK/shIj/Xl9yVc1AOskEoqtnXwZYQCcGGwvzxPgJucqaAN9W3nHkkfcChKMkzWYg0H+Suvs8oAP3sRNYKE8nOnM9dnYVEqBhAeSh/rQNKUQEp1ycAakcqtIiV9RpmahPhachu8DMwZik9ygwfjXmLUIESxHgdYBk88AwGx9KKxjrs9Na8QscZPn1ofOmqKFBtptnuTTWH+UASirlKnrMCafrSwKoKU/BFCloGVQVwrbj6weLF1hOFogWZUEv1IKgMDnZ7eYDJXm6bpDL/804u2lDOgbHo75GvG/JIYxOREOqqj/fXGmXnH5Lp0BnMvqHmRh61NcBGx9SPlDQl9zD7Zz8fA4/zucoQkA9y6tIB+q5DePVIBmJReNLLc7xoxFM8ZUTSBN13qbK5c8hTM1BSbz6ZcLD2iqCQBNAMiSLGRojgFmLLUjhuYYJueABnxWRehD88RKe/gNawgHNOWYJueANjvnOl1Q47HFKtmYdNm8qE/iQ3Na+2MN/NaOOecCQHOC+TY/DXRF4lmjZYyfDUiXB6ZSNBaDlUsj7YFyv6b1xgAQM1YPlU8WqGhqtrEpDE37UigsoDmBD01ArwPeJ2vlQ7OSSjZHwvcpvklSFuCzLBcVbszCjRbLqnRD6DdizsQzAJb8vfF2WW/8ROkGTqkid7GQzgGIahgu5HWz2CPiDb295kEC1zwAXvayl4F9Dfax7jeBANAsBOORfmPPGUTE2mR9gyALpkWRnple1l2A/V5kGrHkjjm7tvg8bW+UmDAPafjAxDZSlobeJ81YMWMzDrzCmXzCpGPYEmfBlWCdkFKbnIdpo4TKlM0ATe6ioazNPGvVVT4uOipzAy4O2PUIooLthxhc9Int5/B9qCxAFgflAQT+ZMs0jF0EuDy7h0DIXdG33XYbAOAErIsr3rY+Lw7YKqOzY/9JA65aJifrV+ITlYGDw8FAxW9k5fk2UUPvj1ePYuTq7/me78HWh88a1Zme5n8+NgOwk5WuCoBmONfcvEBaYCOGDcP6aK33YTfXysVDd2S6Lw6gphm6nWDto8I8VBy8dTkPG/8q6BPOCrd5FjDFGMh131UEHOs/fL4q21cOVI7UcQdD0q+9fPoEBy2h/v6ZNyxwHBAHVhsGaO5o1vHD+/dWDE1UgGYlF5Esd7zPxFoGJGOyD1UNQZTcSaIuO1PKHEBjTAeaRvppNnFQoJUOi0w9AJKpMRmasxqE4gzNM53xTDtVYHKejGVyDgCXbAFWkxqmDa46IApYhJVsrgQMzUl9aIokjEw9Zr/JhM23CQDNmRYCH5qKaCz/kP0+q0c+OUOzVRsgGTBAc4xj1Uzyz5MxNKcWmqhlXoexfWiaF9ckB/oTRafXf3tsPLWrg41KKtk8KduYq+HbSH9fgMfY20o2+gwI4AzDYF+pop+UBzctKBUwiOALj4qLfW3aj57rWaK019CYFHqwNWC+SRltemP2jVHJXPMAp96sOhDC0kpD1KXA0CTLejKAXAyTDQchjM5l11V8bQB0DrIEbgdeYN2tLcLiUMUNNwfdShhrXBh3Ewoi7i1zBR7sjECQ0LzaIwouH2IgHxlgLspDosTkPMR/HEgasjXDGsRzay1WVRkEqpQBfwKknF8f4gfV3hzrpSxL1mdaGtjED7mhYJYPQAM3R0rBcbK1E+ajCtplaWkJALBCejPk/S4WwTaHwTo2oO9rEik4QIa4PjCsOArXEsf0jeoYuLlQjD1XAN2YfvaaYVXH4+rEiRP48Ic/jDrMi7XggH285oDlGVQjap/iReJt5GoaHo4U4G9WV3vtkeaML6NQrtc7YJCXzVgFzQpXcG0dBAWyDOsSFiatwdAMXWIUGZoWgPTHLAj6n7ezbZKygwWKinajkecDROPINUqQxq299hnBxgoZMLjoloT1msln2FoyX0/xlIUZHP/4ydLr30xSAZqVXDRyIQLr0uYoL1deVENEbLFJgpRoHdIcEBMCmnk6mDjC8SqL1pzkQNoc04dmCUPz/Jgm3tw0OFeTMTRXosjr5zlDrpJNlS7zK5lOYHLuopwzVvQ4fmulUlCJcPogHf/xNNXUDM1JDzZ6zHReTRhRHABa9UHE0Bx9DcjYC6RUk/n1nN3SmviQBWC+TyUwEJMzNHnftWmtjXwllVQyTELWDNswRRszv1nkG+44n5L1mIF8ZXPUbiuJ6xEDWvyruSYKDE2/caYobWzWG5bNMJBYP9YWMejmApCEiFYJ6ms3ucXNt01cCApk2D4uf7a+qdJC1olObYGBIaaTigMdCoCSQO+xMN0QsDgoJmbgcZPfsjVaBbv20nwK7ClCwdTVK84AOYrHKatfbELPGZUGMI3xQm5yPpShaT8x4EsIAR9lGoX2C9o3AgAd2MfSuatEkAkKgIu9pty9ZaAoiyQNGL+E5JpFsXRFiQDTyB2CzYTCJinkZ2ujYAEbz6684oorojL5OApBPhdkSyEcb1LBMvSUY8+p4jBWcECayVi7hSg55AjSEQJT5KGsWdsF1lxcI61uvet29UvM5ck+Y8avTfY9iFX0oWnbjkcoJ4S+Fj1AFs1tCutq1149/MoBTd8SwgV3XF/MOsYBVOXXBGV8Abtrto1c+3oWPVF5HlwC2FTZNhlihu/GA1z/DF1zogkWm5zzZ03haKzkoEu5+4Y8E/ktkCi6r7DTxCnu+rUM0BwMBvjwuz+Cv3v/p9Fbrly0VYBmJReNrHRDQLM2JlgnWiLy5zf+RHcb9RwQrTGROqtXPQv9540BHnRYIJckH7+NrA/NaQYetsdcDpTwQG8GGhvM2DGvQdZpZvm+WAGaj5t0A4amwkCIsdh+cZRzYDwfmgPm5zLJAZqAoakBTRGxRkdfB/rsHqXGa59Ar0YOwQDNcdYARqhEPqFOC1umNyXKuWIMzQGNr5MNCtRlAZ1yGl+vSiqpxEgJZlUwiXU4kSrB1eKNo/4v3pAGnxlGWsb+C82w2Qa+sIFjG/lhLLixDj3WuMcChQGlh13mgIADe7hJaRQUiNfBw01BXrDAgwW4OJMTYftyVEmxtFzcVQcoFU0nA9bT+jbucImF3uJbdqrvhzDZ+jk5iC1wcxAmYi4PrJ4cfOBgp0kWRx0P2FnmLn9Ngkref4PkbjxEJuc2IE0RJgvGcGH8D6mqTXf01XsL5wsO5HOgjlWsKMr2uYILQBOXUW7qSoBUrv0CprQg1wVxjUOmrAzHEvs8PT1doiyrW2llEPa5UiCROEAzaMwAaCq2Ddn6KwtBltTBHfAoWzjLswy81Z+UDNfDwKUHG3/k/ucuAljAG6GDx+gqaJhxrUNd5Q5VQtKND6RUXDejhEC6EHwftuYQM4Uu4b/7eWLdQrAEgXk9WylZghD4jDK2gch0dSIwsIwtygBy/cGahw+ZM0H/+/tjymaon7SnE8aNCIL8ObgZuxKw/e+fEf5q3F95SWDT9773vfjE//4kPvqhj+LEmVOldfpmkpF3jG95y1vwile8Atdffz2+7/u+D5///Ofdtfe973142ctehpe+9KX47//9vwedfvfdd+MHfuAH8IIXvACvf/3rcfz4cXet2+3iV3/1V/GiF70Ir3rVq/CJT3wiKPOmm27CjTfeiOuvvx6//uu/jsGgAjn+Ocpy16OQtQyotcYENKdjf34TMDStCawc31+llUban5id1WEAH+WERmOjL6ChLMwSVpIaUgm0OnqedpLx6ufAjEwho2R8QHOBApNzoAoM9HgKH3+1DJCJGCuq+Nw0GYamX+/H8aHJI6OnOYDaeGMbAKYaRYbm8hhjqZ9tLkNzpimBjK0BYwB1uXlZSnKFfIKI4gAwPZWCMr/Ojh3lnB38TORD0wGaIRhd+dGspJLRZegmONqscn9idltYuvqWsfCGmbA7oEGDBwWzbsAxm+KNKAXMlTjq+BBAs0zW2MQHLK4CKGuYRnFLxBtkpruKN6tU3MTaayq4NWaQUdwcQ3Qnx0wbdp/SSEiBdRfUNe6DIVGGo5xD8CkCIYgDK2uanHMwA1DCgw1lpq6ubPJwSOAigLFRPYBUEkk6yloqiURok/PSOcMw7TCStBnhDvcqH5tD/RGW/WyzkJHOhQRDsnRgK9MZYIcHEgEbcagC+jM319XzUAGubYvlukLdJ6X92g4proyR582wi+xNm71IUj/3OXM0qkMcSToGiXn+/JCCrw8AAjaiu6XQ53w+xWuTro+dstwNAK8315/Xp5SNyFOZsR+yvc3vTo0y8JaVHzZxSSl2btkqeOZtyND0a6o3y+bzkg1OXj58n8egMT/40BlHfmCDRZXP87BfUZKM14F9dfn6ksuBVj+owudhAWxHsYGHzkPyJQ6L/P7f/uAP3Bp3+OiR8ny+iWRkxOi1r30tbrrpJnzuc5/DG9/4Rvzqr/4qLly4gC984Qv4q7/6K7zvfe/D//pf/wtf+MIX8Ld/+7cAgH6/j1/8xV/E93//9+Mf/uEf8LSnPQ1vfOMbXZ7vete7sLS0hJtvvhm/9Vu/hd/5nd/BoUOHAAAPPfQQ3va2t+H3f//38bGPfQzHjh3De97znk2qfiUXk6z0PKCZTgBoprO1kKE5ZoASpRRk4plHYkw2pJVmLQvZWWOAB91BBGhOwIRqC804tSbe3WS8zBQL5JKRQG1M3NeanE8KjFWyMeHjbxIT71KG5hgAVIGhWZ+ModkTCVreLe9YgOaAOaxUcjLwEABmWgpiQgDRLiGJmW+TMDSbdUAEAOu40en9wc8kUc63zRk9NqHvKqmkEiZ2czWEUamFbY6DW4dCnEGaoWbnQ24v/GTNIxH7ZHQJ9N6RmQMGm1VXGC97CEBGPoJt0TOhZ/vYK6SoRGG+aYdnNpkNfWxyzMvWqIAKgZQSc8kALuEsuAhH4Tpb0ED7alMuUJLyjRToUgCCysCOAitNm89aUKcUvCvZqwfsxkCkYx+W3MVASxSAQ+9fU/m2deVHQIoqBnlRtUsgYtAgAIjtfSGopD+LIBkXy6pyAXVCZLkA3nqWYvlc4/PQjc6hfUWuBJ9nCGjFvvt8MB9VaGcdHX34GhDML+n1hAG6ikA1K9swDJ0eKhpDCubAQPn8yTM0FchmgWDSDFu3gvyV1zEAA8M5OrSuuhL6T5SWtytseyveJyyveHyH3TUU+ApnL+8v2+4m0+jAY/jaBDNaov5S/LrybV0iCqHJuV2wuGsF5eYrS6fCdHGuwfpUAlQ7fe1P0foaJASg/bz672VB8jROWRbFnQubM3G/Bmsqby/p6hq6JbF1Fe7uAhvVyOC7vg/Pnb8eU2hiMEaA0X9uMvK2g/u/ICL0+32cOXMGN998M/7Nv/k3uPTSSwEAP/iDP4iPf/zjePWrX41bb70VrVYLr371qwEAP/7jP46XvexlOH78OHbv3o2bb74Zf/AHf4CZmRk885nPxIte9CJ86lOfwo//+I/jE5/4BF7+8pfjKU95CgDgda97Hd785jfjJ37iJ0r16/f76Pf7wW9pmqJen3AnuobYSbDmSXEl67bTKgM06wNANssjXa4ntflaweR8nHw4Y0ybnCcT9XGrloEG/inVzfNCfuu1UbvfhzMryAn1dLxxZyNTA8DsCnB6O9Cv1TDIcyQbNjvSogyz07Kz0kRByvKH71qybV7rxIGMpf5g5DaqRMt67cTBqyQHVG14JL21ZKZVDAq0UtJv60kv96BVmgGUjjf/AaBZAzoixbauf4kYZyz1sxxo2M0goZ6ON7atzLSkRyRRvgasJ7bXRK4j09cm0Kleg2GN6/tX+v1SfdZrJ8UOfnKisdeAnVu0Tl1KsIOt4RfGGE9PtDwR61LxxbeSSoZLvAmypCALLgRjVZDbaYZQ3hCxOMSQ9wXHUiwBUngmHAx05Jsyk3OpoMKIKWEd7GY41mMYA8ZsqElZ4KFwJ3xLFfMMTHEZROHTF1lVyoFirlbRhttu8JUHRctMJB3w4tHPUvaWsv+RK4/raFl39rMbA+sIDxDDmUY33XQTPvXJT2HasiRdJbnqw54LIbgxDDTyoB4DXNy4tjBecGNxHsQl1y8FrRHlnJuEUonfu1jHuA6hxusJB7NKdIEfR2USAM8mD0XGoH5dBZQrOw5Y5drWAoAor6tW0gMyQ0FFl7YI+PD5pcw14ixPA2jZue9NyMOjCcv4G85u5NWO52EMaA9vPjLrmG4yz1q0z+uHW3NmLvj5qvs5DJRj18JgjqLEXyShGNjIAbvK3SdsYCaXK09ett75tKV1ZSBfEbRkZZhDFI+Fkh+3FsRU5TqUBYlyeTozfD8PApG2GhygLQkw5/ILk3LA1ddNl0sgFN7syuYoB1btd6Vcl4drRNivniFrdJN+0JWtORe+5YU4+uXPoKu6LoDxN7OMxaP4nd/5Hdx0003o9Xq4/vrrsX//fjzyyCO48cYbXZprrrkGb3/72wEABw8exIEDB9y1VquFSy+9FAcPHsT09DTOnj0bXL/mmmtw9913u3uf//znu2tXX301jh49im63i2azWdDtve99L9797ncHv73mNa/B937v945T1ZHk8OHDj3sZ/xxkWDudOr/oPtcGwIrs4dCh06MXkM5BKkKjp9BrEM53uo7xO4p0OIMtBwbo4tCh8f1UCLQDk/MTp8/gkChnHg1to7NngalL9BdJ6LYXcejQ0si6DNpNrIptADxDEyRw18FHsJBunGKplAoAzYwIJ08cRtYeg3nWrWNVzAXA2KGTp3BI9krTV/NtYzKsnS6seAeqaQ5IgfHmyUoTbVF3EcUB4PCZszhUG20MnOiF/mEzZGPpA+j3h54Ifek+dOQoDg3apemHtdFyuwMYn08qFzh39jgOHeqXpt2ICLkC5P65dfLMORwqPsbWlIF5w0nNfDt/9hgOHRrPDcvq8jRoIGBtkg4eOYpDazDjy9pJKgXFTM57RDh7+igO1cZjVV66fQ+650OG5kNHjmL+Qmus/J5oeTzXpSuvvPJxy7uSbwIxiGbsH83ttYbcFpoJBldCVhDfOHIgQ3n2UMzkjIEZDQokQV6ekenQT/cx8FMYmDkiqFG8IVRONVXc1ArPbLKXyDGreF6cVcUz14BOCKSwtAGjh+UnValf0bhnLBBqy4pBvrA8C86E0b2DOigVu4lbRzzbDEYXKSW+67u+C8/80bfiKL6BjbLbiuUOAeoYeFtqwqwM+OPYr7ZoBo4bsKkw5lTJ2I9BbgdKMCYfZ5jFQEpQV+VwSp9/STo2jkgV28GWt06YKHDzX68XORCpLKCKBqmYWXlpHThQVKJbSf0UTPCYPErn8mJ9EuUZAGYiOi4QPiiQvk+xdHZolkWFp+KYi/rV9kNsXl/wKxkucYXxHqxH0l/jpurD1sIQMCaoiCXogLIAu6Pgr2Ohu3Fa1q86i1umWs4fbszmhK0b9Lrpo3T7Qc2fJYXxRypI449+yIGFrowSNmLhAMKMxZDFz9aHYWMzeiYNH8PxM6lkvkVm8wrK6VXMz84t/nzSCgxbDz2/GkMZmgBwWp5CX/WgqrPu8QDNX/qlX8Iv/MIv4Gtf+xoeeughAEC73cbMzIxLMz09jXZbbx47nU7BEfD09DQ6nQ7a7TaSJAnAybXutWV0Op1SQPNHf/RH8drXvjas5BPA0Dx8+DAuu+yyikGxhqzXTgnrz1oGTG+Zxr59W0YuZ/cuZUxgM/QaQJ8E9u3bN3I+S/0B8PWDWrccmN06M5Y+VrbMHQetKNgn+9TCQkGv9dqoMX2HX2tzgZ2XLGDfvoWRdblmBegIhRzAzIr/ffqSXdg3O7XhfLIsA5JvAPAMzauu3Ot84Y0igwRYTfoBoFmfmx+5jSrRsu58azT85xwQ9XSseXJgCWgny2gx8LA+MztyXmqlA9yhAcw0B5LpBvbt2zqyPlZk/VgAilFrauSxlKT3+LSKcOXluzFGEzm5dPcZLN3uAdHm1Mzo7STu07oZk/MrLt8ztk57HwLOdXy9O5SU6rNWO/WlBL72cKjTvr3Yt2c8na65HHjk4QQtxq6d2rYN+/bsGC/DJ0iqdemJl7e85S34x3/8R3S7XezatQs/9VM/hRe+8IUAtE/3P//zP4eUEq9+9avxMz/zM26jd/fdd+PNb34zHnvsMTz1qU/Fr//6r2P37t0AtE/3t7zlLfjc5z6H2dlZ/PRP/zRuuOEGV+ZNN92Ed7zjHVhdXcVLX/pS/PIv/zJqtQmjhT1OUjQTBscCw425osAPZCyEMhCpZFdYQCVMAWVZh3t2DyBgjWA/Qzahri4FX3fDwZ/A92HJxrJgPr2uuT6DXakEvFtHHwsUSl1AoQ5B4J2A7RP2A9/AWzDagzNxuvW1CvO0aUNwxl6vUx2g4T40h4uO+lsoz9SDzF/PDlSFdBSMR4cMuHScABUISRCV+NAsfJQl48vrJaK6uv6SKGkHKgUt12sviuu3higDU5IFqYYAWgAD64aWb9vW3rcWUK2cpsRB3xLhQalczSxrkS9W/LNUwaGHN+2ONGZj04N9QFnsKX5QoQp1LW+XwIemAptrPJHVzUS1dquKgAW0dF2FqxtYfbip/vBo635uWxNmDqCVonf+ZgCE84nAHAdII6DSHqIEeUbscbJtwtYZBu+ywyx7LQIOGdhe/uwiaPNvBUJSGMO2xYo3xs2gir+zutqyhrV30CbwY7j8UIj82kNU6IXyfmX9pUJ3CLHIZBoiTdZ8dn+zyNhhm5Mkwbd+67figx/8IPbv34+pqSmsrHhkZHV1FVNTGhhptVpYXV0N7l9dXUWr1cLU1BTyPA8Yl2vda8totcrZGvV6/XEFL9cSIUS1kdmADGunHjNRrA0UZIvGas/plkRbpGj0NENoJcvHyidnS0+SA7VWMlH/zjRVEBBkIIebEA5ro36ee0sOKdCsE0TZC9Y6snVOP7g6IsXMqjc9XhxkI9Uxy7LA3DQjgcaYOu3YorAqYl+McuQ2qiSUYe3Eo2WnGUD18dpzfkaZoED+t5V89DnH+XxJDlBjwv5thmbwS73+yGMpY2uSlAKtxnhj28qWuRSLzLS+n5X5z1lbcpPcMqIn0WmqqVBr+/JPtztr6lPWTjlrIyG1TuOuSwBw1R6Je0USjKd2PnwduNikWpeeOHnta1+LX/iFX0C9Xsfdd9+Nn/zJn8Tf/u3f4o477nA+3ZvNJv79v//3uOKKK/DqV7/a+XR//etfjxtuuAHvete78MY3vtFZ9nCf7g8//DD+43/8j3jyk5+Mffv2OZ/uf/zHf4zLL78cP//zP4/3vOc9Q10gXUzi2Dfw4F3AXAmmaxnQEn3nYKD9KWa4cL9wFjgr3ZiFG+7Yh6aGFpQrj6vCgc94T1e6AlnyUlQer0OJV8ngU9EcUuvl8y4HEPjWX0nfRkVT16j9jAQ+3uIPMd7s1UFZNOLA95zyZQ/3Y+nz9UxIVreYAQsVAj5ROjJs4QA0Llk2LRAQsgNjIEVENxggT9/MdPNmsEH3KAVQOhwwImsyiwBc4GNFrVFXN755EzG8LJyHHhg3lQ/zC0y0y8WBRq6u6z2L+Tw1HyKgWmfjTX5jUDAwsWXjX8KCddGaUyiat2UEjrr1Q1nkEUSMoWnXNPtZaLB42DwsBZ6iNuK4VyGwV+lhhs+HVLGupEz0cgv4iXhM+wJtO3tYM2bUcn18nzgQ0YDXzpVGCfMwZJma/AbMIrJsjQPc+hCAsDY/ywiFQshchqsDz1AX7f2r6sRD3p2C+YoCUB1f8/eVBEoKMi2u6/pxSOye8BDF5hsXG4LIYf+7soM5FQdT83M7BCiHz1+ZbgHVlfNj/80sE791Sylx5MgRXHnllY6tCQAPPPAA9u/fDwDYv39/cK3T6eDIkSPYv38/5ubmsG3btg3f++CDD2Lv3r2l7MxK/v9b+mxjnGZA0hhveE43gXaSOMbY6piBZQaM4p/kQL012YIx01IejQDQG8OJb6/P7pGTBQUCdBCe2VXf7uf7o5muDgYDqJT70KSxA4LMTQGZEEh6vo2qoECPn/DxraOKjzff5kqCAq2OERQo41HOJ5j/VlQEaC52y10XrK0T37FNHuV861wSrgFjtFNuXnQSCR3lfMKgQLWu1+dsb3Rz+jzyNZxPEOUcAPbvoSooUCUbkiuuuMIdYA/z6b59+3bn0x1A4NO90Wjgx3/8x3HPPffg+PHjAICbb74Zr3/96ws+3QEEPt1nZmbwute9zuVbJv1+HysrK8G/brcLKeXj/g8oAQaiTVjOg4CRTxdH99bpog0d7MY13sDxbTgDQVgaD8xxBpH5azakZbo5QMeqEqQr1k8xTCcvCXim3P/+Pq2bYNcZgMSy52xJV0OLepk8y8zhHdsQcICf1a0co/KFZuZ9yN7nu6ysv3j9TJoAD1PI8xxkg9pwBiOro/0Xth8rT4W6aY15mxXHXCH6s/lbFqBDDBRU6oEHZcGgqK5Qxj8py9b2nx1zfmQi6EulJEgkwdwpoVJpf6sQrg5SSgfwogRccW1SysT0IEcI3rPxHYmug59PRb6XLY7PJ9smBohiZcYBVXwGHkj2Y9OPIwvcUMmY02PT93v5WuILJUr8OGVm2H7NsXgmH28a0MyyrPSAhEB67htgite1DNy3rN/iWqIMuAQH1tm2c7q4oVkcA3zOKJ4nG+t+zFlQFuEax8ocxh62rcR9DysGDiqgwCz2awTP0wOqZXXg4LN1EWBT2rFp8yESUP0T8IPJ19UdhhQwU++HPDaJ9/+b9iNRWNMdmGrvi58RyuTj6hmW7+crK08VXRSE6yv48PauTCzz1vlEjtdC3S6xz/WywzIydSh7xktIfBuughRUvPYEvWdcLDIS9NBut/G5z30O119/Per1Oj73uc/h1ltvxc/8zM9g9+7d+N3f/V28/OUvR6PRwPvf/35n+v2c5zwHnU4HN910E17xilfgPe95D57ylKc4E58bb7wRf/qnf4q3vOUtOHjwIP7xH/8R73vf+wAAN9xwA97whjfgu7/7u3HppZfiz/7sz/DKV75yc1uhkotC+mwi1wdAPmZU8akmacaYATP6UqGfS9ST0fIbMB+alBOajckAzdkpAqTPozcYfTHoDSRgsHyZjx912QKa7ST1PjQBnBsR0Oz3+46hmeZALgSSMaOcJwlhdkpBXUhgzfIv9Csg4/GSzYoqPjulgwJxRt04gCY/0EgkgPpk8020ErQW/fel/uhgXcbWJKkmj3K+dT6Fyv0E6WajrwGcoTkgmkin5v+PvT+Pt+yq6/zhz9r7jPfcseZUqlIZKgkZAMMgMxIQiSigOODQ+hPaBn/9/HwJTbc/9LFVNCig/bOflralAe22VVAfWzGPzDMCARKGzENlqFSqKjXfW3XvPePe6/ljTd/vWmvfe849u5JK6nx5kTr37L3XXvM+670/6/utAZW2y8/iBsZbn9RRJQMG2PhLDQC4bCfQ8YJMndlAf5rY+WETn+7FdubMGQDzbN1IMcSRI0fY90CcvRw/fhzFKhH1fbvdxunTp2F+oAgp7c8dkbtF7dLSEjqdjrtSxlITOHbsmPetBKTLu1GcHjx40ObbIoscSqUFp5Z67LHHeHIaLkitnDJ24sQJlZ4FuzQbflnnAVMGuliVgEgSnDx5EoPBAPb9jlEAeVXp8iatgocp/nQ2Av+8ugKlt1g+evQoqTXJobJWTnW7XZw8eZLAGARBgagPa1p/JoKygbdCuHagdQBTBJK3Rx99FEmSWIWmO58HNXn00UcBqOB3sqJLI6Hhk/utcuTIEdhAIuaGTC2o1q6nTp1iEJipcLVC88SJE3ZHIIOFBORAJDh+/Dj279+PkydPsrwIGvEc4HVCACb5gp9nwbRwdUuuMO3qYG3cFhcXdT14UJ7Y0tISut0uUKXsLATVrG9qnCQi97d90/J8Uz4N7/Tvu0OHDnlX6jHqwbvjx48rRaPNkctlDgmIFMePH7dlNTBbeOATQuDUqVMOQhWoVYVIXf2GOVRp635lxoXNF4W3ZKypdvXgvqXRqp1XV1f1OBSFjSqg2svf6arKYz6oM0+ePEn+hu1HvrH2olx7jTlH6vuZKUMIJwt3zxIS5Gj1DgCXG7KIlZUVNb9a9SaH3coSnDp1Ss+vm3lZQJoVaq52LyAcLPZJpXlZSeEqNOymt3fnwSpopYtaZzNy9OhRMj9wIGy+7/f7bn6l2RL8utOnT9vnodumT/qMrucjR44UxhTYhBYOIQ+OPx5xJs4lv+4jLTuEEPjoRz+K97znPZBSYvfu3bjxxhuxd+9e7N27F/fffz9+/ud/Hnme40d+5Efw2te+FoDaBv7e974Xv/u7v4t3v/vduPrqq/E7v/M7Nt23vOUtuPHGG3HDDTdgdnYW73jHO2w09b179+Ktb30r3va2t1mfRW9605vKq4GJnTNGF8bJQKC2QaDRagAn/C2wgwE2paOt/NsE7olsfHXWTEugTYICdfsbgD49suUo37g6q1EXaNTUFm8GNLsbUGgSoCkrxX5HhrG5FpD3KzBA81S7vfYFE9uwDTwQlWxwvM1MAblIAKqs3YCirksUHpUBIGfGU2iKJodip0eE9YC35TxLxp4DNs/XIAeuT29kDjBbSyoZ0ClBoZnnKRptiU5TYHkDL1z73pbzbEzIeulOFeWcKn4nCs2JFdnEp3toxp+ryZ+AA35Utbhlyxb1QZqFKll9EduyZUu44NarWvO4bzQamJmZsYcDIKc/zs7OqrpahrfwVOkbd4M2bzZBOGhhgI8Atm/f7k4g6hv7p870jh071F2I+sZsU5UESm3atAmILFZpThuNBmZnZ/k5Qmig5fy/zc/Pq7YmW6YlSD3rhf+2bdtsWg64qf/Q++7cWeCY2C6k1QS+bds2Blmon0Lzfb1ex8LCAilCCD2oP2UOLCWM+suooEz9qqqgkYr574qdO3di9+7d8XKQsy+88EJyLzieCVMG9b1qf9de7ohLrdFoYH5+HsBxe5SWVsocSFIsLCxYd2cUOCrIbCJqJ9i8eTP27Nmj6o+AcR+kGNGOSc+2g/dTi7WrMPAsbJGtW7fC+SeN0y8pJebm5gCcsPWBROisGagmMTs7i3q9jp65pwFfFgirvmnGl+tH7jwK5nft2kVzAbYBlEA+Xie05UjfFwKbNyuYJcycQF46CK18m5+f13PzaVIdDpQbmLuwsIB0TaWF6qdmzrG+HPUYVWV1ZbjooovsZQbwcd+R6kzbrnnO4J2bGwUajQYWFhZcl5CIrKEEZmZmoopaATPOJCASlZbNg7B16LuIcOOLJMhgqzLTroLkWZpCkPO2bdvGx71ILPw21mw2sWnTJvuixY1lV3gBgfn5+RDekrlQXZeE7eo9usxcy58R5DiZlwH3jKBv9YSXHqDHob2f1HVi+oqqg2q1qufX4zTTvEwQmJ6eVi4U2/4RUxxVJ1u3bg39239T/d4ZIMdKVylML7vssvPWn/tIQLPZbOJP//RPC4+/8Y1vxBvf+MbosWuuuQYf+chHoscajQZuvPHGwnRf85rX4DWvec0oWZ3Yk9B6ZOIQg42rfKYawIHIFthN9eJrYrbSdURU5EBjTMXYbCvBKuEXG1Fn9YnjwzwbD2bMTwMraRUzJCjQhracEx+aojLe5Dk3DWS9KgBV96dWO2tfMLENW5+Mt1T70NyI1WsCtapEPnDK2o0oNNt9HuVcjrnlPJ3ygOYGoBgtRT6GiwdjWzfVIemW82wjCk01DxkfmuNA1kZNBU2bXgU6TaW0HdV6BESbwGDjKDQvuQDoJSmaJCD9mYnriYmtYROf7uubUd8orqGX+mQxV7R91ZwXPeot0lx6GogAGgTElDhwC2ObjNSwIg0W9WZhJwUcSIls4ePQKJK3ICt8m2iSJDYvRWWlPtCcCbKA94BOeCr56F4CuzsaZY6Ir4NtGSi0JGn6KjVo5aMHIdRilyJADYMkPe6lqRPmAXS8F9kaqAiiljJHfR/DvGixvkSPSS/wjz7Pwk7p4BxRS7HzaHezxVFBgdYMvAKoi7W6lJbDRiYWke3MMICM3tdAt3AcAoAk8I69Q/DUXfEs6jIQFwfDWHCWBlgsEnpB+VjezJZ0QT7DbfR2bW/GaWrnAen1TWGgqdfm6k8+vhxb4nOQ7X8UBvqF0GPNjUPJkpAQ2t2AV1YybqyvRQIObRTw/jEC+Tj4oulxYE9Rb8R8+MjKbgul8i/9GYK2gymYPt/OK3572dzqOomML5uvHDzKuUnTnGfO9X7/Fo0/O2jNAFb1FwumQ7u7Ad+8XSPPgWgFi8ITkiRhfZrcnmRZq1QhAEEjoIfl8+tYQtqxpua7tNA3u5h9Pj5z4k489kPPxI/92I/htttuY+meT0Dz/CnpxM5565OBngw27oet1YAKCkR2mG4IsBCgmZSg0JybThjM6GxAndUnEHTcLbDz01AKTQI0R/Wh1+12PaA5HvSdnwb6A0dDltqjbxOe2HCWBQrNjT8OZqeAnqyioinp8kbGG4HplQyojPkCoeIBzeUNvECgKtZMpmP5hgSAzfMN5LmDhhsBmubyNAMGSFAdAx42akA/SaxKu1upRH1SrWWrZM5Ic0CmAmm68babnhKYnxlwX7obmCsndv7ZxKd7sfn+LgEH5mLQLBjBRHnErhfuM1PkSbhFdDEFQXgCAXD+6V76gB8NXdi1uPQUZCTT7E6xvNmtlNIDvUVUlwArk6biMAZwSHIfXedmMU+DzIDez5TH3dSU1aqlbJOEbSvgwKwD0msEraBAZJ1HAA9Oo7LJ8pYQmIF4nyPf0EwHx7lPxtC/q7lDTEkV9k191NafSScHRMp99wXdXVrgQoMCWfVhJJI5q1/WXkER7C1EIaAy1yUWFBaZBahmy6rpR4b6CR5QhfUKoecKfR2tN1XPri/TOrftb7Pt+jEFvdFxnZu65WWw9WCb3Hyn3A6Y9jLKUWHmI1tWb/wi/Nt9n5JxSBSaBs4W/KTxQX+MmFpcmbi/BXiiViVO64H0FT94DLuraVcGDcH6j0Om5hpSv2uYf55NxwPQ/jWSlc0vgyBlo+fF537hTjA3gAkKJbwyCpnztqIvXvLc3k94cyErqwHTNptk7qDp8qtBSx08Dxnt5Pe0/l1j7SUBkcQiuuvrhYAUKWQqcPvtt0fPOV9sAjQnds4Y1eCIgdgwPJiq6yAlY/r0WyU+95RCc2P5MTY3nUIOCMzYiEIzIw+kcRWaM+P70KQQKs0AscHAMsbmWkBb1FDrGTB2bjkdfirZgDzMKxmQjKGInJkCVsiYW+6Pvr27Q6/JsGGXE8Yq0ynqXf1jGcDqBhxY01lDrX/Gy9PMdBM5dTsxItDMcvcjMtVuAsbJU6OmFJVmDpBJMvL27k6fAM0MSMZUaQPArq19iJ5LZ6LQnJhvq6ur+PjHP47V1VUMBgN89rOfxa233orrrrsOr371q/H3f//3OHjwII4fP46/+qu/sr7XqU/3Xq9X6NN9ZWUFt99+O770pS/hla98JQDl0/0zn/kM7rnnHiwvL5/zPt3ji6AQaNlt2BSQxdLxuWMEpNETzNIRIPyLLcxJohr8SQ3EWN4t4/EVPJEItgRm6BvysrJEJYDcAbhIWamPOhqFOdhOHaijeBlCBaNJE6QMkSjmrgjrBmGItbZbimsQ5QUHsYvpSH2vdR9BVWsEGohcqvrMdcYpiAJpB7N91WtP/zy/YAaim/Y27eDAgyDAzysI8fmnL1b/5g6QFRfa9J+YYo1RN2suPckPCVMtvG+CgqDI2A2CfCG4JQGyZnQVgycXKId96RSn63WEwry5+0czSb4zsNMfneqvhJ4ZXO7GtIHd3nkaDvrK20BZp33uRudLaXq7zWRkPhRev/LOAyBN0Bzhxo+Zv6yaz8Ji+rtOsvN4vgD2okmEeXPKbBdpnueN9FsZqUNqhMGGczEtv1PoOsU6OTcRAGs7l2YMaLpykixHjkuSBs1yNIs2TXc/FuyJlCXIZ/AsIadH6kT6LxYIpY8FAaKfJQDhPUsA4Dvf+Y7KQ76KiSkbQ9sxsYmVawP6wMkEahtU+7WaSnnYJEBzNRLhcj1rM6A5vkJzYaaCnACM7gbyRIVK4/jQBICFaWA5qWD6tPvu1Ig+NCn0TTMAJSg0V5IKmm2gVwNWN6Bgm9hwRtWHaQak4yg0W0Bb+61dnt5YMCcKNJNsvMAyAFCbTiEANLpAuwms5rFfQWsbe8kyXtcGoLam5sRtxKhAk0amV/BwvPzUq3rLOXmpcao3wOwIb5PaXT4HpGMGTwOAi7blEP0UxifcRl5ITeypbROf7hsxS1IAUJAGu7gzSpPwysh2NwNCgXDB7Q5ZKAD7p+QnWLDj7hVb1PKIvCrPDEIZYZIPkNg9Abe1EhYg8Gw7GGRVaBE+RhI3b7z0WjW8vznP384aLlb1gleXT9V7ZMEtyLkkz7asniLPfB8oiAxINumsobpylrvK0PVnFXrpZguIY8v+cAHvt3PBAt9u5XXlMca2vhpcpeuPldUm6PVHKB+aWZZ5wJWn7wMXCrVjgIeCSveuwIw5EfQRWfgHLas3DqMMzuSL93nX97yxSl5kqI8u0AqrN9pXaHrwYZDqH2Y2YdvWA/UdATyMRbreQ3qbvoUEdLR5H/JRaOTmNa9+Yt+wcSjhwBN4V/cT8hWG5DruV1WBZeMOwdBBCqCl8NMs/s0qeYXoNBP+Jen/a86HIMX0lMTspVfQjt6LIPfWKgq0/WeERM4AoAk2FsJblYT1/yx9lxekeHRo55H51a/awp+rIc73n4vB+wUpWbGlNG1O+0Z4cXTOtc9pVc9+e7361a8G/vP/BNp3Qw664fXnoU2A5sTOGaOKMTHYOKybqqst5wtdN7NtZEHcKTko0Ka5KqR0afY2tAXWfS5LoVnvAdW+RL8qRlZodjygKceAYoDyodnWEY6X5gI/yRMr0TLyEK0MgHQMRaSKdO4Umqsb8qFJ8GG+cYW2sUYrwQACzbYCmu3ReSboCE3E+MrDNE35S40RVaM0AM+4qloAaNS5QhMATvZ62IO4T8CYtb05IBlTpQ0AW+aAQZ4CUPNRb/JiY2KeTXy6j2iSbLHzFqsGuFAVkhhivhxq26uFjGbNFwMpIAvNPAI0taKHqGV04NxwyzktA1FOMeUSWdRKyaOc09JxoOABAt8sn3IqJ76tN5a+v+CmZZAcvIJv63V3i7eDK7tudwPS1ngzx/3gFZg0uRRR8CXQhApcIwnYEGun6Ypj+10cfEE3QwTemmwLDbSjwKbAB6TMAVQKFZo0srOvvLVpm5vT6xi84ZuM6Vhzdee2ui7ccrwYQg3zW8Yqb+HdOcybz8bsBw8aWYgpUZg3BxTp74DIOLSH1oh4LYjyVhi0qfp7Avoyw4O35ludZuGcw3IYrQULA+2cA7/unMpYoafI+JIABN16L61S2io0bR0gDmFpXwqOS1tFbs4xo1QfL+xL5JidN4u7mJ1XNLyjcw+db6EDpNGEXURy53tWevUu4INKV7eCDpqiZ0TQOUO3CS7BhI0MDrT9vJFcSgVe2b31ZUXXRPs3EJ1LTPYs54+sPQ4fPowFm9fJZmtgsuV8YueQDciglNnGgcbMFLCaqu2mxlY2sGWRqg9RAtBcmKsiz8bzn0f9HuZyvGjCRg0pAAs0TnRG81np+z0sY8t5J0ktGGsnxRP+xMYzihxlLsba4j2rx5wJxNWWEvmI7UajnIsSFJpTddWXjB/NzgYed7SOkuiid3QbSCDRriN6IwJNOv6Vqna8PDVqQC9J0BrD7UTHczsxbp4AYHoqwYDOlRtwFzCxiZ3vxgCIVGAmUBBpEwBZmEu2qHbQyAcDBNhFlXZmuVi87TW8BsG2aH0DDvk0QIouzPVCW5IFMIdLFJB5/t6kWiCuyfQCxZ8DGy4LHGi6UyNo06r2bG0BkAFgpCo47h/UXWmNcsSI2tDd1wQqcUBwPZMUkGjAyJRcaaoZTjFIocFBzH8Lt7BqMm4jSXtldbDJh6D8njb3HluQkBBJXPFnYJY5kwIX6fd/L/sUtrPhY/3zeX2BNEDr4WVELfDd5xWWlFcSNaUtT8RY1VnlpdqG7/dzqU8WphxeWVVfykkTGZDng0zh/vWrwUI+Dak0fKI5Fhpoxra6q/5o6tfvUxG4C7AXCzSiO1OheymZ5AX9ImgHPob5jMsDa9kkwizGVYt+ZgLlsi7NugO7YL61ZTD3IxmTHKT5ykvqVsOMX3OeU1H7fizVyX5Z3cs1Yecp016xwEA0SeH5KKYTl9kWb4zOr1F3DL5JkHNMMCz+PBSCgF0RznHxMpAeJ2XogkXbRQckqkiBqWsxd2Ai/5kAzYmdM5bRB1a28aBAvloM2GBQoA5RaJaw5Xx2uoGMcNWNLNIH5FdsnqWlRDkHYAMDner3RwKIHS8ydVIdD2bMTwt0kxRNPTfnQqAzUWedFcvoz7AxAWIZY64zKFehOdXgQLOXJMhG3HZOVaxpSUAzEzmqetj0/CiP6xhVaKYZUG2M9wivV4G+SDGz4tJdHNWPLp0DciAdcw4AgPnpFF1RQaol6RsJoDaxiU1MmwZ7/shczydjYAEIAvuCLeDJwlLSHcq+qgbeolYCgfqGLviEu45uOTeLdgGorYZJ3O+dYOlQuBaWNfTHFoMj5ubUk5/KG1uUB1swpb2uUEFE6xIRn4xRgOHDBUk+FeqHCPgUUfDlQ0Gq+qT+J5OBhKhUvDSL0oFCGyH3CXJHS0Hr1oBEaa+lEMwH1Q6esdbIfXjnmdDgQYL5W4UtnySfw7LGwBb9zIALBahR+BEqwywQLgRkHiETEdhO0hQ5dBwmf1w6yEfhPS2DOubub8pepLxl1/v9mao3SduprCgA7XIVpAgzKsMXC/7ZEjE/hfZe4L5ew63pOk0ZAm+Xjp4Edd90StZw3uTB1Pw5glaQl1EG+by52KslDm+909Z6sWDnzTA/NNK9mR9ifUT1BwPb6XHYseayFBlb5OVB1M2D96zxobz7KBDMEfRYtJQOyrLvAAivfv05U+eYZ4P2Te/Fk73CV0pre9639LX1Xdh638SX5gRoTuycsZwpNJMNA5bZlttKbWxDW85pxO8SgGaj0WBAZSMKTaozzcf0oTk/LbCcqkpu6bmwl0u0R8hX2weaJW45NzYJCHJ2LKcP8ny8aNmzLaX2bbCo4qO1W7fPFZrVMf2xTtUFA5rA6Ert3PzOyCVEJV375CEtS3JUdTa6I6pY+wRAKKA5Xp6SRCCvCKbQPN4ezR9Pt09dcwD1EhSas9MVdJPUgt+NzJUTm9j5buEiiC/S+DZst7iOz0rhAo4u6IPFmyTXyYKFniBrR714N/7xogt4svA3gCQK+di61YeBrqxqXc6hJVv8+utRslD21VIxYBJCI4vcSFb8wEY++CQvsUkkcWHrgWxZ9UwxFqqI4nenC3NBF+lrTeHCQEX3W4+WIRlIyFpVb/fV5SEsJdj+azIa5N0HZLoAazwyC/t7pG/6vvvg+e4TQkTrKwDVMGXz227toEAxM1vOpQCQh32FlSEColigJLX/2H7nMyr/xYIdz/pfC/IYvHNNSVEqLysMDVXfg0YM56VV+aJbziP5s33Y+ZI1x5xC07wgMGUhIM8rd9HLiyCIl81SmEZYCv8bko4/TmD6m9c3dUcyKj+qIDd9jvZNoxy16tew+0G1nx7b67Q/Bqfc5VF465kHoGPKZjsX02cLnRNN29lkIu5GAlpN2tnvM96pKgueip+erEF/8Dw0mNfflRCkzo+tVVfS3G/NdiDfC50zKSFEPMq5VQ/3Dsfve57ZBGhO7JwxKcjifEyFpg9XNgY0CWApCWgOkKPSVxPTqOosgKvq8jwZK08LM8BprdCkyrpR/B92++VuN52f1lvOKdAcMeryxIYzqoiW+cbHGwDMNNVLhPIUmht/oWHMKjTJTozTI+bJQN9KCepjY1kiUdFFHXUOoIGckhIiwQOArKbMh+bh02dGup6qtEUJyloAmG2l6CSpA78b8Dc8sYlNjJiFMw74MSXMGlvC7SLUB4rkBa1dcFtWyFfYsYjJzOca3bYc2WIn4eCMS0BwaKQyUlgGepr5qACCn2wcehRHfeYLeArITD5DIGwWuWvAW+8ypkYNVKtgC3Nhvfk5MBilHpbcaGBVsKXZBxYWUkkFbSxszQFhfsv7+fTTAVibStvHYuagm/BAAw2UYwFGDFQX+ZqLgErDK5RPS2FpSajA0+4J8vXLytvJlcGlZzBlDADScRjJv3dPQcep35EotAU/5NF2T91mwKGED0HD7dAUKhYDMqPkiyrx9P0EJKS3Q6YwKj1VuZH2ipbVZYqVlc5dtv4i49D0b1dS6foKLaskTSalVz+0HlA4z6yl0DRj28BArvjTM2dR3zRFPX1zdLy6C/TYYnOcD/USkjYHsmEZTHt7NwGBt4K0gaCXcUWt4AftyaqaC3wUk1EY1AnI2JDuPDYmC+YS2k+DF0Z+Ns05gRKa5kzNMfGb6dNWvhvv1+eZTYDmxM4ZkyRkr8zSDQONakVgUEuYD82NBCnp0kjN2Xj+KgEHNM0ivbeBqMs+0BzXh+bpikqgvsGI8BRCjRspG1A+NLueqm55EuH4rJiv0BwHIM62BNrE9ykALI+4TbhH+90YPnSN+VvOgdHheKarKMkAUSnncZmXpNAUuRhLoW2tkmCGAM3HlleKz41Yhyprc5QCNKebSl1rFZoTH5oTm9jIFgUqWgnEjuuFF3kihNDEXOYvnKILYOkWoQaY2fUhTViEC3gDy2JKPvtnEkADCg+FARTCbdwLFvDkfjJYnEZWnuRrX6GpOARflIqgrPHkwiAYLkUYpZY+zIMCgbcXIjBQmpwJd4hVtasMtrxf97HkwI2FekRRiUQQAC3826q/CeQV6gsv6w6XCQKUpJTx7b8GytobFDEHH4KY8vjRlb0QQroPR8G8dO0VK4MC/w7O0PIAtF09v6kRdulA6Fohubzy2nEYyRsQ9CNaA+wQuc4HZFQ9rI7bG0XrzN1cBJ+tkk/nRd2SKDTh+9B0daKSIZC0cGz733rgSwJKX0raXR/nIDUBJVUCNsMMaKlgZxTyqrtSeGd7fCin5ApNlTV32EDmAA76n2iSri6jFvw29QBgTuvdP835IFXX+EBTvwSwbcePRxWVQNBX+DMiRgt5H7Z387d4e/Orz9aDmoj+bg8BaXhNmEcKNMPt87pZC3xo8tqfEM0J0JzYOWMycQrNcbdTYyopYcs59+k3rkKzUqmgj8wBzY0oNMmEl+Xj+9A0Cs2N1hWFGWWo2ExQoHEg1MSGM+riIc/EWFvOZ6aATqCKHq3dOn6U8xKCAvmQddS+ZKBvmgNJCWpIAJApSvGhmeQY+yULAMgaDwp0fLVTfHLE+Jbz8dsNAFpNNQ8YJetky/nEJjauWTQUwAkACp5YtRFfHBtoFVnZRSCfSYEs4CRAE/SVOtId0CdHFnDSgAyTlFr4U7hgIkQHxUYIXNxBDhD4wtMva4DlbJoGzUkvTa5s9aiihLcwJ2AjgI0+SBH23KhvTEHaQdhPIVwydZkT8LWOSZu+yllC2kHkANJU14tJs6jtSYIFsFBFtE5cPUYud9t6XT2zvmgAmTBbcP2byAiANhDYAy40yIj526YRB5UAWJOrsQYGvuwxd/ewLsw49MuvKoGVVeeAtBW/QwCDKCzT9Sz8vmk/yaCrxF5ACEnmAR9WmRFjVXixPuzalYMpVe+BD01P7RZV3EXBv19WfswfFFQV7hS8XFXo1wWbU02a3vwFKRWoTEQAswu3M7OselDWRhOPzV0kL0VZ9u9Ly0pBLwyYCxP1t9dL0845mfmFnjeEm/tZP5Gu/aS5F1Gj2jnOe6nhmLoZX+bBZ4ojiucmqg71vlNp01qic7aXVpLo+jLX+9AyNqG504S+V+GW80Ale/7aBGhO7JwxmbqVcD6mQqsyw7e/bkTl1yMKszK2nAsh0Bc5KhZmjD4JcaA5rg9NoJekaCfphtWsNDJ1mgNpfbwpZX4G6IgUzY6rmwnQPDsmiXP7fGyFpoGHrt1GHXO9vvthJ8dwOWFsqqECFdEt56PmKdPbRyoZkFbLeVzKSu62nAcrq7WNbjkX2fhzEgCIasK2nJ+kvoOHsC6tU1nOlvNWA+iKFLUxXv5MbGITU2ZnjYJFsuJOBGZGzIFOt9KKRxEmNzUwywOf8bTJhYnvG5jmTS9Cc7CtzgEs9LMTW5irA8VlCOqCgC16Dllwq7NUmvGtrhQM8YWxXezbbPIFMI/CS27vQRemDCOQLw6ghzOmSNVqM8eVCUgxi2xFHggE4emEW8/j98sBu3nenBlGajdHKDSS8WY1TFSwr2wZnNIXrp5NQeGV1WXCXUOSZpG/QftHXHnrurCBbmuMLf9v/9SEtIEhJDR98D4bJC39QDmmMmR0G3tQBpJiEWTUGXWADLB1KfX9NSnifQiGXxX1YXduIagMSs39FLrI7FLVZaSstIkMSlM1FPZx3Xsg7Jm8rBbHkM5Jt1r7ZTUwyyph84jST+jrwBWTPG9+mu7+QRWxv+kkZBJwymyh723nA2oJyUsA2+PtJW2dcGgZyx+b+bzo9Sz/MPXnt5eBsx60ZC8yvFcOZh6OvljwMkiSjs8l5NnkvUQJTAgyHgsA6XliE6A5sXPHCNDM8nSshfHUTIq057r3RracU6Apx/RXaSwTmYMZG3irQrcJ5zJBZYzAKfPT6t/TaZUpNEfact7nW84rY6rYYgrNyZbzs2M5BZoY34dmx99yPmK7db3xVoZCczWtjAXHcw00kwxIa+UEBUIFVqXdT0b7AUK3nCc5StlyLuoJWquA0OrPxRFdBXQHTqGZZOVsg281gE6SOIXmBGhObGIjG9uiKDVIIYqOwAed4SgIQRsEQmUbsPYCTtBUIvDEqGqoslI6WOEVhicj/a3pkp9qoWUcoNkTmbLIFKkA9FAIRuGgh6zUuXGfjL6FC26NRKRbxBtjgIwC0hi8MzyL5TtKvjg0gt6yv4aZ+xMUQhSw0gJpDmjj7SDg4IyD5GBXCZE4plgAUmh6TinF+6ZSckaAiIEbLG8xqMPLQMGxU+fFIJ9fnyLsS6609qP0smBVcPb7IeA9Oy0GtMDr01N8FZ7Hcxt5YUDOikJF4c41I8hLX5jrAyjmBY8xeQ66LQeU5tyQzUmIhOcxSCoGvszgYnnz4a0pBYdgJso5qxcD60wjF4AqN2/q42RujPbh3CLWoL2El2ff+IsKfm74MkbA99VrghyZc8x5UpfXpKDmgIK5mg9n9YW/DZswQFdueHVM6zpeBvev7X3RPi6i82RsfuV1LYRQatQYgDRwco16phZ7Hi8vL0fPPR9sAjQndu4YeSsv5XhAY34mwaDv0ht1+yvAFWNlbDkHvAjHGH2RnhEIlQYqhtFsYUb9ezqtok6UdaMpNImKtYQgJZOgQI+j6f6TZBIDpGNFFbcKTQqiR2y3Pgn8IksILjPVUMHBxnFfYIBmmo2vPjYmqrCgDuDbyNczeq4oCR6KeoJEAlNayXpmRH+VXKGJUrecm635AwDZBnwOT2xiEyMWASTqa8lVSAHvIbDBAzFrLIXJeSRpAj4tkCQLVbXwD6O6BnDHK4ME3IKaLID984I1p4z7ZIwvqmMqGEmAnLm/A2RWNUVwp0E4PkijME9YaBn6AVVbeUme7cqWwwy2JJeGBUbKCpPnIYyCAJsmV2gmIrFlcXXL665IWSe84yxokPlvDAaa6mR9eLjfNNEo5yZtDZfs975PRgLY/fHD1Y3kPA9Y+H1TRMCuu18SPRZ+44i2gWfkhl7f9FKhYyg4ZhPVc4Yy379rkTEFLKCBE7+fawfTx3JAJOwkM3dQ+GTS41A2BlNjtSW846b+CPiTvKwUrvtjzSu0Ans6PSklqzv1N4n2Hk61/IUR2X5N82zUqPallXCAkftmpXNOWBMQoXsRYerIJpOHjU3dXJh/STq23oQa57FgRSZvtJ8437JmDlEHmALeFob+fnVb03lNeQA9GK98fvUt6HMmEe9rdl5Oy8ohr5+MKTdgxukaUc51OlNQi4FoQLvzxCZAc2LnhOV5DllVAzIdKMAyDtCYnRLIBhRobkChmfEtsOUoNPPxFJrkISiS8YbvnFZoLlVqG/ahSbecJ2P6YQQUhOpXErZNeAI0z5LpIFyVDBiI8V4gWB+aY0Q57zGgmYzfl6xC0313ZsQXGxZo5kClJIVmUhMW1AFAZwSAyLac5+MHKgOAvKkq2mw7XxnxZwGdA1CCqwDAKDRTVk+TwEATm9hoFmzHBVX++HDJqWZ8YJLnShFFg5tEoSf723wS4cmgxwiINBcG6kaDAKW7IliY8wWwnxGuSHL5ogoifj9dSAIXQhhIUqPHPADpvvdMwgv4wPPtK3OK/YXyvFAY5DBgvA1E5K/YmdHtk1KCbq835wnzst0HDlEjfTRyqgsyo9srtrCn11kY6NqOAzINHmjUbOlgEEuIfBT6PNbnbB8goCkGWz144gdJoUDTDwpEzSpCSbvaOopu6zb1sF4beBDOwiQfBpEgPYJfx8CySdOlvqbqV3jt5Q4YH5CmfKa+gMDXImdnrhy+6lOIUNlG0iM34GnQ3XEU3vrj3mt/4fUjB4uFg5ssBQXhhJdeFHwJ4/hBujRJvsksBv8PVlZaBtuFed9kd5eSdgKvrOSY7qeC/KZkKkcL7wSENJUTAdCsWnXv8vqmt5mfmB90TZB78/FK/SyHW869VCPQl2LQGESNQUwZ9IHYvYrdJqhyS+yUreh9zyebAM2JnRPW7/chKmolXBkA/RIAS09WkQ7U4N7IlnOqGCtLoZmnOWp6kZ4JIB9x8jHbhNOBRDImYKlWBFpN4HRaYz402yNsOaeRqUU+vjpLCIHadILmmP5PJzaEacf9aQb0xXiKyKhCc0R42PeA5thbzo1Ccww4ThWalXo5bz5FVViVNsBfnKxnLMp5SQrNfFolYoBmJ62MlKceU2mX50Ozk6Ssnh7PwED7l9v4l6Mncbg9WoCkiU3sXDQGswi74EFL2Iq3IB1wzkMWw3xh5i14GR+ILMxtvqReiEdUNRa0WroE5kOTqJdUthKAwIsgoI5LmP0dQCr6fQFccH8Lq0oKfS36eFKXxlM3uqjIrqzR9nLJ+CWK3M2ghgglY0ErMASABCRyq1SUEhCJYH4FkyQFITcApHJpEoGBls25ZiXHXdkUFDM3FLa9pekvIAmxK2P5978I68Vs62W+SE2eGWzX//chGAq2nJvzSU64H1iNiAuHoe4QpD+qbz1Yon1OurHv6izcAk76HAGHATTy8lTYXmwqySHJVmumRgUc7CoYh6ZdeVCgnJzjvhV0zEjX/wIln2dGAVik5PSvpH3dlVXdTzDwyk4go9CBLxOp3Y17wILxPAapVVuH/UNG21Vq+OheBYHUj/dsINdFjfo7iMBiE73c3M0qNAOQR4I90foLXkC4Q5JUD/LwZY/zhUnHIQpfGDlYHJnryYTE64eOY7/s3jPPnsaVxVbxHVVoClav0o7zuA/Nk0lwu/gz4jyxEjaHTWxi41uv1wMqqjtWDdAcE7CsphXUe8BqZfTtr4Cn0CxhCywAyFSy7abdLEezMjyYNIClMlBgZFwzkc63UB+aIwBEBjRLghmN2Qqax9zfE4Vm+SaltD5rzQuEsaKcN8OI4iMrNDP3wM7zcoICrXgKzdOjAs1UA80cSMbYkk+t0uBbzkdRHlKgiZJ8aEoNNDefBB64RH13uN3FnunmUNf3sgxwgpxyfGg2gW6SovUEKDTfcvPt+LtHHgMATFdSfOVVL8Du1nB1MbGJnUvmVIl0ASwgPHc3ZhkWLu1IOhoOhtGGQ5RmU7Xr34LAIAYEMZUTImmCwRl7WaDbYZlm3zMll0B0IR0rhZcxm1a4wBQMbAnEQEoMmMS3fyoOYALvcPClqszBBWnz5sEMryzCU4xJouJy7SDinSBWCukip5sy5FIiSSpqW7x0+TCKqLW2TgoZi+1N72mARdhTzdZaAyKj0FnDBWHTMGm7KOc+EKRbztVVXAckdFAbdYkHWWi7mvT8RvHOc9vD7V/BeQWVEzlPkn4bqQ/zmZJJ8ykKzAykcsCHwTtr5H52nHoJsvJTwOSfFIkeLqRya2Dbi7SJ/2ImtqUZ/BRVnILAK1JtFaZboymANvHei/qtdc1g+pzlaCLIm613uo2dKJNZ/sikLW0hTBFD2Fb065UGHgKZrwKVuXkGEOhYmJ6Bt8JlU9JrhFP6Sn0efT75adv5y0L5OICmaZgyUBcRPpxnauigTKpyTZrhOAxrVJr5J3I//4VHUCe+MaV2vG8+1NwCtLnS6nwGmhOF5sTOCev3+zBERQGW8dRHM00V4dgoxlZGDHQBAIOcT25l+KaQac5gRm/EySdL1ZCtZICojT9856fDLefjAM1xtwkDwOxsimrX1fWo24Qntr4NBgMLNJVCs4wo5xVPoTnamKPjTeainKBAY+Yp10NMKTTLeVxWG3wr9ShzAPdZm5TjQ3NGA81T7rsDq+2Cs0OjCk2UoKwFnELTf/lztm2p17cwE1D95R8OHDnr953YxM6+aSgQWXAJBijcYtaYC0aTw55k1pYxVY2UZAHnBdtgajUHbigIjSk045QtpjTTACER7Dq+/ddcCwLyaCoUUJB8Ff0GpOBSAkDuFFEGXBhfgSxNIIgkTZMV/FwWSdqt8vliGQakOhWUUsh5WiPSPpDSbQkWcTwTbjl30IVHm1c+NC2doXVGAq/EtvfGIg5bGEjhrQfgCtsltsXTltq/xt/CSsYHSzLhZbCMxfnIM+eH6mHv3j5IkZJFrY5SKJG4tmJdn5eV+SYUQte9l5TNr3cjmavEme8+A+R4XQZltYlH8g6/H4H7jiTnhC8DHBQ1rRLdri10uSS0iwxE0orlce05R5Cy03Y14M6BL3eeVXWb/krBoVcf5qWT1VJqP5N0fqX5FrzoFvrGyhAO3YJAOcSsq4fYixtzXcQFh2shOp+7vmnVqAZM0nzBlcGHt/6LIYkCH8VBduMw0M0rzmK+UYNr1vibl5t+TX12ClYeWlZ7pX0UOxcEReb36wnQnNjEnmDr9XqQZst5Nr5CU/n0c4qxjQQF6hPFmIg599mAyYrk2yhHnHxyAzQHQFIdf/guzJigQO67lZG2nJMtsCVAKEBBVkEi1J/ZAIye2NpGFdHWh+aY420gBCoERI+q0KQBb7IyFZrUfcEGFZoqynk5c0B1im+l7owA6tpd9+ZB5ChFEV2dStEVCbacdPX/6OrwW617dHyWpGRPU4GeyB93H5oPLYcg9wtHTpz1+05sYmfDApDjKVJCQBZuZay+8GUE4ICt14QsVv7YRZlefMvEO1M43RYDKhrGBQt4LwNqXS7IAi4nS2ipvdCZa3w4RWEnL1QMtJlT49sE9WFTWKpCKlLfkLKybdgUGEcW1awMVIlWuD9ZOnhC8uWnp88sbktqGs4Y321SL86tQjNXPjQlzDZzwG39j6mvhIUsNiO0rIQFmlqSBliR8xiK9GGJPaSOSekpqWDAJA9YZWuYgCh6T1IhAbsNzyPFs6A6lp46FlXtGoDq3VqNGT8F/W9sjPrA0GWF86okbC+bK9vfeVmFhPXDaCNex/qcBwBFrAKFVr9KCVClnb7StJffo9h4jinII9CvyE+hUzG7dAJftnosmL4pybW8weD6kOc2wUJPKe1cKSVYWuwlROQFlfU5GtsOLXgjszndtyTiIkAl7MpAYCuvCwJlDUxdY96kilmp046DZdqHYF+OrKWAF9JvV5eOe4ln2i7sm6rpWOPZ84Kt5PowBdUsf/ThWTRdC6FjGpE5BQCSeFAg4vAUh4X67ToBmhOb2BNs/X4f0FuvKwOgn4yrGBPoJqlVHq5qPyWjWEbOT0oCmn6E41FVRwawVEqKujw/DZyuVEtRaJYFM+amAXTdNvzJlvPyTfmsLU+hWasK1OsCou/65KjwMGMKzXRsON6sA6tJlSk0R4GsOflhWcmAtAQXDwBQa6YbVmm3226gyrwchWajBpxJq9h80n13YGV4oNmnc1hJLzUAoJ9mj7sPzYdWVoPvbj6+iM4IL3kmNrFz0QRdbMVUcAzyub8ql12pFkki4dsTYXCgQPeyLVi96DIOyCyQCxWawVa8yDbRwi2N+r8i5+DTbke3sMsDMXSxKrzvfYUmUTfy72Mw0EBDB4ckKYMg4MIBVPenQNFilW/bBHzFn1P7RMsqHJx2P18J9rMwS7AjFMgEaVIjaQokER+aXk+i0DKaDj/OFZrkmAFM0et43VJ1mwNT5rY+CPH6qTDMhgRe0ffiKlN1zPndi/cRqyRzRNOmSbcwr78TjIKpoNRufBl4q6mI8M4MoawBbeqjKk2Rr039WcC6C3Aqbh900TkmTCrw/enlz/6XNZcfbKcIFIXtGjOpgWnROJRe+qE/Xq//RdMhZYWMlFvfn4xtUdhe3r0JEI4CSJIvP5iag52IjtFAjWqv0nVL88e2qxNw6KkRefAgnVVy73gZwPxk+ip+KRD0NDP/xNSo9lOBKwE7PboT4Rt/j6TLk8T6s5k73Gzh14m7hSmFPlPXV+HLEV1vK0L9Rs3O49+qE6A5sXPCer0eZJUAzTIUmiK1ysMMoyt8Buw5Xs5QSarlKDTTQTmKsflpYMkLCjQK0OQ+/cqBGXMtIKcR6s/jCfpsWa/Xs0GBzAuEcd0FzDQB2SPtNqpCk4y3rAR/rNWKQLe28S3ndAt8kpe35bwxXdkwqOt0nWRR5AK1EiBrowYse0BzFIXmgE6UJb3UAIBBJRtrrtyIPUwUmtP6BVsny/H144tn/d4Tm9jZMqpiImumiHLFo5Xg50kfJOjFqqwmkBX/AcIXdOG2VulUShqMSJNmBKSwLdNkmyFX1dDFL1cvMTUq6LFI3ux5/qLUX6xyREaLXbQI9VMtCkYi7Xkud0wZFiAq/pcfFMgG6IC/kDYwS7WlgL9Q5+Z8Veq28wCJlDrKuZSAzB240u3MYWCkQorUUvR4VPHnnRgB1ap8kjalTdO0V6iCg2FGoJGKSaK6+sz9HIG27ZW7vmtvXaRa1Ew0FhU8GH8mBxEQZdOLHSs61/tDIGXfUZwlDFX2xysBd+SGtn1CME7BjX+V8SGr0zBJEXgX9hNvHguKLiJ9CiEMJGUWei4xrejgvRszLg9+u/IMOAiFoAyquaS9H207Xz1M32noE+IwXBLYTupkKPU4vPPUfn59KFqJ4KCSgjqSVuK1AXvp40E+nYxg9RyWlfZN/n0BqDb3RcF8J6JPBZaub7FkzAsi+uwSXllpqiJo1/XKwD9MFJoTm9gTbL1eD1IDFhsUaMwo536QklEjndN1elkDJalxheYo0YQBIK84H5pnTaE5StRlem4mUC0hcMpcC+iLCupd1QArE4Vm6dbv9+0CtIwo54Dyo5llFbXNDKP7PiUeHpDJtBR/rLKl4GGqEx9FNdonPyDKjHLebFU37EOz3SEXlvQCQSk0K9hCFZoj+NCkrjmkLCfyOgBkaca3nD8OLzYeXHYKzV+4bJf9/IUjJ2OnT2xi57TZBTDd3hhTpGgWY9bQ6iI/HR9Igp6tmQ5fhNq/cskW5mFCdNuhRODPzt6aBGr0QBpP0oAfV6L41kn9n4gvuGB56tUBV2jCAgqQ5Wu0DEFdxherFqQQcyq4ENiG5CZxjIApm0LjTbnOc46kqa6TEMTXopQqKJA6ldatao/YFmYTZZqaD2/NvWJRmaM+5ghc8qFRhGhGALRwsJbBW+5Dk0IWW0z7lbmb9Ng3h9+h4g/23kFZC8QV9MxAAW0oaRFIiTE+KaHiHUn3t8qty7qBg8J3X+HlcS2Aav2tgrl0oNt6nfrPtIFEUgR56DgjsHXN4FwxFRyBcBYjeu0VwCcgaH8K2qzCkMwBFKALO3VwMM7P0+fSFzGmb0bOCy02/8KVx7uGvwgi15A53ZWV+AGNbLX2VYtU1VnYf6mxcTOcS4/AfQk75sFmD46HanU+rwfpmpd0sXKwucKVJZwPlfpUmBOljDejPiy8cT0BmhOb2BNs3V4Pkmw5H9en3+yUipJbHyPqMgUsCYaPRL6WpXWgNoZfOBoUqAzAsjAzrkKTVFIJfg8B5//UugsYsd3GsZPdHv7p0SMjR8N+shlz8WB8aI6r0JwCuqJi223U8UZrPC9pO7WYSiEA279HcV+QkbGZZkC1JB+ardkae6nR3qBCU2YC9doaJw9pjbracj69AvsSYSSFJsm/zJJSVKMAIKu+QnOdH68lGFVo/h+XXmg//+9HHkP7cZyHJjax0o0CEm9BpqKzCs+vIPlMFvxs27VZuMr44o5HzA3hkrmR2VptFnAiiahfOJ2zWxldGXJ3XLoyBso9gMHOIigivb8pmwvBlx8UKFJf3sLT3Fsk8aBAMRWoH7SC+nmktqYyNAZvpSEpxXO3VaOZBbZ0SiO+5TxXCk2TT+hFd+61F81jjsK+qW9lSypzns9hVLDO/DYw57q8sfvqduTqr9i2Xl1/a2zXJRkOIBiDhkI47Oy/QzAAKAqFRfAd/ddLKBjLQctLiSLY7mrI3Dz0Uxj4riyAQMJ+V9COkpfC9AeTFn+xIElhin4vxOhtARQn96RGt9cbH5qCloGW1UIxss0crh1tGSjtItMhomWFitvE5msCByN1z2Aa6DgkJdRJRF1r2OeHK0Ns/lFK8Nzeg/YVVwYSNIzmK1ZWARsgy1xCx6vLazguRA67BTwwO86p/1+35ZyQ8fj1UdcQsRdG5mWIax9VlcXPQ3ed/qIIytKJRP8zAZoTm9gTbCsk2IXZcj6OQssPCgSMHuGYAc11/doMZ5W64D40R1ykGx+a6QCoNMpQaAosp1VUiUJzFBDFIsGXpBibmRIKaOq2W36cggKd7g/w8s98Hb/w1dvwjm/d87jc84mydrdro0saH5rjKiJnDYg27dYbQ6GZp6XA8UYzQTtJ0dR8bhSgSRWaSQ5USwjCBQBTszU0Oy7tUfLUpXVaUkTxRk3NAQKw284fXe2s//Zb24D8fiojOr212gAVIpM/GwrNLJf4wpETeEgrM82/m+tVXDbTwvdt3wQAOLDawX+6+6HS7z+xiZ1Nc4vCAthB4M266ZiFpTFFItbPBFFx+d/HtmXHgse4xTgFfmoxGkZX1mfb6MmkDPpCSYESWWi6+0VqREocf+lF8TKye7s6j5aBni5jEd2NYkkDRAJnnDJMEv435G9Ivaj23cGzresUpBSl7XNWKQECZXOZQyTk4a2VpKHvvtBiIMXDlwXXkWezXd/zdjXwVpo80yLFYJvu31xpxoEFVS5LC3zCdHUmaY6L7wuhWVdOi8PTjX3nqxv1maweCtReCuaFqcbUoBLSQm2jyIM/Dg1E8vsKYn2K5s1rL+GEJDYIi+WWMRU3UWZ7t2HgK1BowgaZCQvsyuqPQ0ga/sa/j7lbGGjNwkF6rpk7cpOGIN/H+6YDjKpNpK4T+hJFwkTK1l9JACLh7RWb7vS/DPKJ2BmmKhR4i5k/V7maJGmS8ROD3q4FHByMzyXkGQEJFPkoBvRLvPicY55P0esizww/33QcOkZp+iadN/w5wsBbNd8YpfJaqlX3gm4CNCc2sSfcVnscaMqqiPsDGdJmPLgCjK70o2fHFAMbsWoz2fCW895gAEmCApXh029+GsiFQH/gKMTqCOCAwgzkopRtwn7bjZKfcezG2/fhER0M5SP7DyMfdqHwJLR2zyn9yvBZC4RuHkZ28UB+PGQlKTSn6sBK4vxojvJSo0u2zCcl+PQ0NjPbQHPVlXWJtMW6eSJAU5bkr9IEBQIc0OxkOU50h8vXgAVzKkelDQBp1dtyfhYUmh/cdwCv/+K38PJPfx0PL6/iUFt13otbUwCAd193Jap6cfbH9z6MR1aG34o/sYmdK+ZQjlP1Va5+BgY+UCGQkv76yulx+rvME5awBR1VGunPp159VcECTrDrfNAZIBB9XWGwBAN0YtvryffSKmf4tfymarEoJdDbNmXPCbf1ko/CXOeBlABsxKLwQoMSmk9ehrCFzE0JQPWj8LLykLKay0xfINss14SPJGGm0MxzJEL50HTKs3igIZVP4ephLfDlqLZmV7TvGkjg6pFv96Vm+jLHpFEfmhJcaahhkN+HXZPr0WWb0WtX/ZEBK3IeVepZn7I05wUgJfrCwF6jy+KdUKQME1b+iAhI0WVj8NaDS1KjJy8/RX3JQFOuUowWwn6WiQZFtgwOBqpcUp+xERgYJC+B5hQ6LIuuHox7h9i4IEzR/Acs6Fq0TK5vOvAl7LXSQlkOyPhNdT+ivN2/F6dptjwq6bBvUtcIwq873Y/cMCyeG2zQI6Mm9mA7he+AABIOff25X5oxQ/qcoHWwhhX6MiZNQ9tCld1XtHLL8xxc0SuCz/49g2jpBfDWtA8PelUANNsPk1tPgOYEaE7snLDVPgEsGYDKeF1ztqXgSn2DykMAyMiEkopytpxXmwmqVHWUD5+nVU/FWi1hy/n8tPp3RdSR6nyNAqIyX51V1pZz4cBYO89ZBOyzYd86uYQP7TvAvtt3Jox4/FSx1a4j/WVEOQf0mEsrFkSPGswpI905k+WAsakGsJpWWF8aFlTT8SZyoFrOFIC56RrqbVfYxVEUmlStXBL0rVcd0KR+NIfdds7mgBJ9aNZrOcTAPQfOhkLz9+98AACw1B/gV4kqe/uRHP3TfVw5O40371WqrH4u8bVjp0rPw8QmdrbMLdDI+lPRIFSe+Rymii9aGFaf+WwMdJRzHxLRrZMr11zn3xyA0NGi1RbEvFVz+bIwLbLw8xZwForyE73zpD2ZqtL8iO5GFUkXoUHJY6vZSF7d99Awi1/ib+v101KMIPWgQXhrY9xPIYuBzM6j7a5ut8ZvRZNpAkSEV2fus2Cg2LZjQnxoQtqAgzTRQoVmkDXJy+rROhdNnKYRAgUfGsTVUvSqSN4syBeO+UbKIHICb8nShQaPcf4OKSTlZTWbzWVRX9P59AMGUX+KAeQz8MwWXoRloLDO6/vRFwYEChs/kry9bLIsj9H0bP/jfc2NHWnrnRbDKJtZ3YKfx/LCXD/Q+tDnXnU5DqS+Dx9Tf6QP0zKY+vTwPi2HX1YGtjyoLKW06mtfSR1/iSLcR7iXI4FvyOCvIh/F9At/HOrvzZgSYYAqp+g1++El/PGrUmEjEawDxsqqEnfZzxFCPn/yVQl5L4zYQbhewvumpPeLXRl9sUCeaTzj/JgAkHOFPVWuqn+F6yt+/6Z3zNvumFB9dwI0JzaxJ9hWiUqp2gfkmNs7Z7QPzUbXTWQrowYpIRNWpYRgNwDQmEpQYYEuhgd1K10HGCoZUGmOP3w3zap/l0hgoFGC8GSeQrOcLeem7dx3Zao0T/f6AdT6/+5/LFg/fOvkUmn3PNes471AGIjx1bW+m4eelGohPKSZ8ZYOJAZJWqpCs7mBSOcdAjSTktTHADA700C94+aTpRG25vcI0JTyLCg0T7lRMGxgIDqFlanQbFQzJANXT50RA6itZ4M8Z75yP/PYCfu5/qnT+NYvfBdSSlxj3vpgdLclE5vYOWHmpwJdFNJFowVylGyof9LdF7ud5gQs2C/03+2rv6dYhaUXgP0LZiOKL2/BK8MtdoE/PigFlqBBS1yKTpVGFrlssUpTIYohd164BVeSr8IFtymDKQ9NCwi2l3oWVfLRNLXx7Z8EikUuF9GX8B4ctItlCh6ELUKRskmdRmGK23Is8twBTn+BT+BC0G5a6maL4kPeGGS2h0T0GPW1aO4PxPymEp9/Fi4IBvCNj0RB0jNgQ9qK8EBSrF0NcBLheQQ/RqGKAZUh7MIaZtpAFAAXfczvexKIIQKjfLTJaJ+mvE6HCApEz9VALsxV4uYq2t1FLIiPLoNW+lKsGvQ1CyJ1krE+afJk7h1RexsfmmqaIe3PXsb4jcWBmOubVKmq+odgScYaOTIHsMOqzWOBtNz4InmVuv+R7kD7sFNJhmnS8cqOkGcGBdVCtysD0EVlDYZRfA6hte5uHd9yXjy+TL4ix/W/SqGJYODF6sSftoR9EeW1P1Tdy1hTrhHYSGq3AqjMAwCyx2lH47loE6A5sXPCGGAZAGJcoNmMbDkfVTFGtpmbqI3j2lSrimrfTZLtEfK00vEUmiUEKdm+oPOROGXd6gg+K3Pp6qgsmGG2Lo/jLqDIPn7wKPZ+9It4/ie+in1nVuz33z11Ojj3WyfD754q1iYgxyo0x41yPhWqokdpt1x3ZwNYy4Dj002t0KRAc0hgv0JUrCJHaaCu1UhQa7txs9gffst5j9RnXpoPTWDZKDQd0xteoUl/kJWUJwBo1nMIItsdJRr8MHbX0nLhse1HJU588QSOfuoYpiuuQKOq/Cc2sXPH6MJJLdQzqviDAUCSfNbfGwgjiTc2icjKi97OkShJF/uRXAnAbXVFDJCYe3lgCEmoIPLUPsHCnCywXTrrlEErpowyLqbkY0nq1Xmh4o/mLfA7pxe6OaVG6row4vDavwF5NUQAI0tDOgZssyuDU0XOe5ICHRUHhbKMwxmjbrNuByMghLZJAFJ4Fp1aj7ZFSPgCNXHQzgRoxfqcHgsUPgoZgmILhG0fiAHoAov1TcCCKPqVSc9GfPfNA2SWAXnVIzTYPLp5B4Fp8Pw8auSSxEAK/dtUjGB+JYXXlixfVI3G9mvzjFrFq263wIUCHCCzabAOr9P0uoYwAIi9KzDtj6gxP7OkDKwOdDZI13QA2t5F6P+6k6PKy0TYdqLgi8J2SAlhA96Y/lcEvlw/ND40uQLeVZIQgkA3f97UX+Z6zPgq5yLVop8WnEsA1wQFZbUVasahGduev9DISw2jCo+ZeclGX+Lx+TUGp0k5ChWaIajUuXZj1zuPtwV5luTaAcEaQNPv4EUvFc8HmwDNiZ0TFmw5r43XNes1oJ8mPCjQiMFlcvJDs1opZ7/pVDNF2nMT0CgLZLpNOMmAWhlAc5NOm0YVHwGy+uqsMrblxmB0WSDhrx8+hIGU2HdmFS/55M24a2kZuZS4ffEMAGC2WrGPh6eyQrPt+aztJ2VEORdjBeIaGIWmjrpehip6tqV9aG4gT7SOkgylKTTrNXCgOYIPzR51WltWlPMacCZVhVsgXf5Iu1dwBbeMkI+8JNUoAEzVcsjM1VPZCs1vnige37sPqX/v+a37MEV+uC6PqPKf2MSeSGNwwy7uVH+uvfjlyNlSWwfp8aBB2h3gW9/+Ngw04CzQrUjTUyc8tQkBFw6DugWcIAtGf3EY/A0HKNwNwBdzHsX0tvUGai5BId96C3OdDnOv4eVFOEChcka2fxJwxG+0VsAHs1iNADIJpwyjZQogn1cnQNgOIPWA4joL1XD2AJAIrlpLTAAXSTgE3/7pwxkXMznSXvqe0u8D5hBIHbMS+3DBwAvpn6i7mOdD0/5rIjZL1sYcbBClbwC+TftrEFVYz8Q3oCkXzSaBfEH+g+31Oh3brkIBEn3eN17wSnt5FJKuBch0PSigxssQOzv6S86M35B9Blcy4COh560C2OoBOdN2LKJ7NJMF/nhB+4P6zKLXW9gdjjXbxyMQPxSdC303Mg4lQpWxzoqk7SqhgwJFxg0dZ5GyxuCsSjnsmzwAUlimcM4xqXrtaFw4mNr1Lou9zOJzsretnswxbqyFZfUyrM4hUdBd/kJQyC81bksipi/LLnuaHq9qLnSaVlEIPtX8aMrq+kDRtnkBUi/9o0F655tNgObEzgmjirHqAEjGBJpCCIgGGMgYFYrlbMt5OUCzNVVBhSg0R1GwrTLAUo6vuoUZBWraScUCzfYI4CAnU4gsCbCYLedM6VeSjP6eJafK7OY5/t0td+GBM6sWcr102yZcPtsCANy+eAbdkiHKuWKdiEJz7CjnLa70BUZrt1z/sKhkgCzJxcNcSyk0+Zbz4aBUp0d9aJYXvbtRA6oEaI605ZwAzVyWo4acbbkt502yy3zYeqIjRJbk1xNQ/k+pD82yFJqPrLTxb79+B/4D8Zl5+cwUKjJH9cBj+Ml/zLHnUfX9yv0r6H3LKTlHfSk2sYmdC+YWe7DrpHTbDruVnIIZQdd0APZ+eh/+5m/+xp5nUYwIF+rcaMRhEgjCW1gbkGbVoblaBEaVfN51ceBijvFnCIsQDqfMkUA0GE2wfbAoL0GxXT37sCCVLnKu0ICJgxmKYSx3jdxXL7jtwYL8RL+OwWJyarD9np4r7InWz6MEK4O0/vNitw6/lzpNExQo8FMIt2iP9TcppYtoT8rHAnsEF8Wy6AWiEtB9kcDHKASC6t8Srr9rC/xKGnBjGtcvqw91vDwaQBItl1+3Uv1H6mNC2C8DmBLtJpo0RSGfB/OF4FHObUAY8k0Abw3sNvVAyuteeiQEntEXAxJJRN1IQWUUWtr8h+UJXubQOUF4f7P2cmV1wYP4XCXdR2J6XrRl0HUtzYnCnsbqxGYCZIIwsD3R93FzDEVp9DraN32frg5n8rIa34580zQtkec+wAyZoF1NECA7GNR29xi8NaWj85KuzKiKm11I6jVyqPDFgs1zfAaJ+Yv1LkReb3jnmFBP2l1KgZKT8XNIrSSN8xAKiIPvzkObAM2JnRNGIwpXBhhboQkASVOMteU8Jz+SKmk5Q2V6qsoUmqPkiQYpKSvqshAC2xaAduoUkX1I9IeEB1ShWRZg8X0xAuX4rstyGfgF/MaJJfzp/Y/Yv5+xMINna8ei/dwpN59q1g58aJah0BxPWZtpoJkOAFGWv8oWj3I+Sp5oJHiRledDs14FRC9BogfPKFvO6bgsKwjXwowDmhsZc0yhWVKeAKDVkMBZUGi+584H8ZH9h+3f1UTgyz/wAmx/13/A9/y//xqv/SQ/v/u1Rft5suV8Yk8mY4tRukjzwYyQgV8+s5Y7es02GNWTSooulhEHM3BrfStI0dctTc+akx1opbAAsejlERCmF3ohNHJgQoqwrHRxL20+Cgo/zLcEytpEBWwZXDAS4NnZFlTgXo6b4/4i1JVfxBerBEAzgEAX5jGVaRQSe4CZJFekCjJ5NCczsKxBsz0mBQEYEWWYAaOe4jTcrk3hg2BlcazO738OGnAFGW9zuYYPTdauLB8OhNkTPFDpggI5yOSAFcK6sPUgVJ5iQNOUwTFCXRcJP89Ti9r8RtXHBf3dByk+kNPpCyTxvmnHocurq1/YsgaEkZppV8qVAcQC29j2EIaMu/qlW5MFyyPsNuxoYem1XruyfNkTBIPygvcQ2OjrEXhndIvm9oL2v8ByPm/JWFlDEwjnHHs2nXL0cQaqA6jrzU0W5tK51p1H294eo7A4Cm95BHT1EkX7joy8CGDm901tp195Jbko8vyyD6+iZKX3EoXkzVxWSdnXtuQC1u9srKyAhBR8LMfKYPOZ8HxOgObEJvYEG1VoVkpQaAJAdToZa9tyTiaKSkkhjmdaVSR9V7b2CHliPv0yoF4tnnBHse0LXKEJDK8cpdvyy/ShGYKx0bd6+hP7I6tt9CLR0v/8gUft52cuzOK6hTn7920R35pPBaMvEJRCc3wQNb4PTdWfKxnGDgpm89QSWEkrLDjYsD40O31SEInSFJr1qgLIrVX19+IICs0BgXp5SWrIhRnnQ7PJwO+QCk3yK7eslxoA0GoCkgQF6pUENG/1XEk8a9Mc2stncPddd2Gz2BScv/qFU/bzRuahiU3siTaZaFUIwEAIDfbja3SMdeYaDMCEi1pl2cLmNTLgbnDHXXd54JOt7mFgU6gONLkjIK1AfUOhURTOCU+BFPyUigBUKzfyF6GmfGplLpGzq1l0ZZohe6c1In8ntF7CMnCqxfMsREJu5RBCUDay1VV4x1k7GYBBlXS6TgQBy6r8iYIO9D72cr/8pnim/nzIp46FLUIgCdtivLbZdo+pRYO+pNvV9r01oibr+hHsKwJ2DKeKwGZfKWnVoSg4z3sUWp+Q0TJA1Y9RwgLo75xFfvIEzpzRL+wdEXa+bAvVbW4eEULoeEr0vLB8wqbHkgGnWd5hC8YJjDackvSRQLUYfPb7e/h10OdYIhw2sfMo+CLtWpyebn8CA00ZBHi9++UJwJc0fZgUpHBJSMChzjNtL9JywUjj5+lEpATfm2PMn3PM1z68E65qTWcidRkoNA2kJXNo8MKIXWfmEiCm9h/MK/WkFGuM18h8Lf3zguYlX6QV74WHM7FGWSE1qBY0/bXcIUyAprEJ0JzYOWFdAj4qA0DUx++a9ZnKeFvO9RuYJJOolABYAWCmVUPac2mtjKDQpKq6JCtvC+z2Be1DcwN1RX+6y6wcmDHdNApNNzGPGhToYweP4qqbvoTf+M699jsaBOiXr9yDi1qN4LpnLszg6Qsz9u/bnqIKTV8RXUZQoLEVmqnqS2mGsYOCGZudAlY3GuW8x8dbWQrNRs0Dmt3hfFUCSjVsLC/pBcL8tALRA3BF+7Dbq+nP2qzEKOczUwlkTl7+jLjd+97Ty/iVb96Fzz523H43yHM8vLzKzvuev13Bl3/uX5BlGTYlDsocz9V1yaOuH0yinE/syWThYp8v0qwPTQMv/G19AC7+F7ODwcAstgR0gMH7LUMhDgWRh3bvJWcJB0boqdFgJAHFgUj8CLY84nBssarWqm5zsPAWhUxpBnPSOi+PHc9kZeXbYXVIEJ8/RACZpPcHgoV07FjUvGplCqJI/vzlcRzIwEE+afKSRmGAUdtaYEHggq9Kcio43Tcju4Q87BcWNAqZ/bJoMBmk7G1hFiTKuVb9SomwvTQQdnXrAHbx1lQOo2PR61kEbVYG57TApibdGIrBdkE+SwFI/UP9tttu81Jy/TMaKInVFwDoLeGBWk7YfPlXBHUXgdFWySdcHVHwFUQ5J+fZgFwURHlzRIRE6bIGGYm+Lgjai6hyI8kGH+k4818aGEhnW74IVBOYJzUkDZR8rC3pzXl7WcYbAEbPby9or/UKB7h5wR7lzwx/zNtxKIxqlteDTcNcI6DHYfgyS7LapXUUW0sIXR7hooST/FnXFoJDQ9pm3IdmOP/INOX5ku6F0ZovIAjEtPeKPg/h6ix48XR+2gRoTuycsE5GgaZEWgJAnJpJUB1D5WcUmmkGpCUBlplWjSk0RwF1/hbYssDB9k0RheaQoJVK43NZjg/NNBXIKnIsde2/+sp3cbTTw5/c9wiWdL3df9qBjKfNTeMd11zGrtlSr2Jbo45r5qbtg+uOpyjQjEU5H1eEPNtS8JCC6FHajfrQFCW9QJhtAStpxQN1w80DXXpeieOtXlP1bYDm6UGGfMgfIQMKNGU5LzXmWgCEwJm0uqEt50ylXaJCc7opkJMt590Rgebbb70b/+uhg/iJL33bbtV/cNmptF++bQF/9D+rePHfdZF8pYKrKldjMwGan+h8HADOSnCyiU3s8bZgUQu4KOcA7JZfby566JVXqsMWBHCgaf8+eRLLy8sITYMivaht/NDr2dUy2DXhAy9yRwowAgWZwV0CHM156UnJoI3vK1MlHweYNLiFJIveUBmmw9vQhaaFHp7nNuFDWQRt4LgzqRMPHvjnCX9LpDT/4RfZdo2oiUKFJrmH/a9kQYEsWKEnw4HQ4gW3YFcw1aKABg+hqfPCCNixRb5TwSGsOyCSN3Kibe4wKJDU96NBgQTzK6q/Nv1WgN0/BqoR2U2U57nzOUnSKCiOPaaq3gBaAdEZoHLrd8hZPuTTn70+ZNSbkkBL029YhOjgxYg/SAj7JW4hOIvS49vc0PiFlApamvotBuPsTuTGvJ/ZMogwj66worC97Dj02sScJ5hq0czDktURABex3Ify/j3pNZHiBWdYSMe/5y8gaN54m7M+nIhQ1cjOM3Mcheg8LauIl2b+9dvLnzdBOrhLP5zH9PeRlxqFUN72Kf6MYF04cqn1x+xN/JL0U6fQBNSrQ78thfc3SdHkC3JNtwMxBegEaE5sYk+wUYVmdQAkJSg052crSIga8syoUc6JYiwtIaI4AMzONJBsMChQx1NolhV8Y8cm7kNzlHwxoJmnpcGMvIoNb1327URX1RtVaO6dmcJPXbwT/8+zr0JFPzxeecEWHP7Hx3DPL9yGi6tKvXnX0jIGJQUjOZesRxWaxodmWQrNDQZzsgrNAZCU5E5hrhUqNM9sIMq5kOUqNPtJgintzlUCODMkZB2QHyt5npYyB6SpwNy02naeSKDeUfcYPiiQa6ssT0p5qQEAs9MpZOYoe6c32hzw1WOL9vOHHz6E133hFvy7W++y333+Qx/E1pu7NvdXpldic6qApkgFWj84BUA9j1Lt73Sy5XxiT07Tyz0LLdW3jz12BORPbXwB3GkKpXLR4EF4sML8NSWm8Ld/+7dBOmrx6maJ/OQJCz6drzYO+VZ+5IXrFMdsofd895n86EUzU5yyhV5CREJe6WMwUQhIIdGQRQ8BEgGYAlMvrSCozVoLbrM4jpRBSoUMRCxNPw1WEERVUKYEFjBFoLK6lj6XheUHwg8KJBJ9b922DEoU5FPooEBF917jcgc6/K9j7S8DoGDSCLf1OtijSJpE1NeiBcJQ22slB5+8rBSsemU1JEUIKEVyDC55wWvMsQKFpvGZyHI8yPD0I8S9SgDGpVZ9cmWYUxeTegnOI64tzD9RGKgOxLbk0vPUFm12RI02UTBW7f04QGJRzk2wJ5oVCM6Qpftg8JL5zrlXsCk68EkgIoOyvHA6gJDX58znxKQDB2DZSxShItZ7L21EpKz2llpCboLMMADtSmjZrckzDaZGsGEwb7KKkyZvEm6moibseeZvE6zNL6uZzz1sZ89zvp29bixMa8TdJpgLhAzLqvKvEonNFOq+iZndWK7sXylXiJDSAGRMBopaEohM1V5R8Dt6WdFz7vyyCdCc2DlhXQKN0gFQKQEgzrZSoO8mlTMjLkalfjtZyVCKYhQA5mZqAN1yPgJkpaq6UhWaCwKrJfjQLDMgCOobC1ASs+N6S+8X7rnffrdTw7NfuGwXPv/K5+G91z0N/3Hnxfj2v/4ujn7iGHbdp+q6k+W4/8xqmOiT3DqkPtNMAbaxo5xrH5osAM+Q/VtKaYMCVbJyfOgCTqHZ2ECU826XKzRLcqOLepUrNIHh/WgOyG+VMsfb/DRwsqpIpBl3Qys0ia/hMn1ozrRS5ARodgcbf7Hw1lvuxpePnmKQc+tDXXbO3srl2FHfAQBIt9Tw3g+9BzdnX4OAU2kuLQ8fwGliE3uiLbYolARY/dl//3NzIoJlG/kzFak7jZGK8DJyd6JycQBE9nv4zne+Qy4OIZ9s1tdZwOmyFS301oJGeoFt1HLcXxop0hr3j27rNTTAltXfEivwjeQoqy9RBL4CtRgvg2CqKgTnrW1+O9N68rCBD2QtZHH3M8pLB3kImDCnEqIp/fbQi3gbed67N1coSSCCGAqQWJgW+TaoNw+QOTElDVwTKwMBE/qFgYHDdGsy649a1RdsdQWHOn7BjOIrBsbZdaYAPrwlkHwOs7wGAzboj5uImXZlPlTBgZxJ3zfb/A4Ahsk7pa9RQorcJEdhoINn67mHsMHM6He5RPa8p0d3yhgtXqy9KHAUpJr5DWhQG9cObmo0B10gLRMtHazp/B5L1KHkXqGZfuv+5H5gc3dUz+/qxVc4b8bKR8sR3d7Npkndz2kbCRVwTgKFL4IAOPGMgY3ei6CYwFadVwQDdflIVgIFvPuLFcVXq7sUNR1NBFaqdXutUeXauXCdoEBuzoR+tqyvMo2V4XyzCdCc2DlhXaLkElmCen18oDndBHICNIf1CWfsrCg0pxsQA5en1SGVWQBXaCIv0YfmJh3MhW6t3NCW8/IUmslUeVs9j3V7OHjwIB5cVpK4fGkRr/6+l1qH6NfMz+AXL9+N03/hIh9f8B1Hd5+Kkc57nouHPE0Kt9kNa0qhuTHXBZl9K63HW6M8H5orCfelO+w80CWKQCHLg4e1KjAQggPNISOdM4WmLEehCajAQHc35wE4oDmsGpHOAQNZng/NuVbKtpx3St7u/ZwjO9jfV1WuQmswDQC483Qdf3LTPP5+29/hX3pftkB8eYQAThOb2DllFEaa9RiFWWtOuYkGgDlTj1gljhAKNPi3o/cz9+p1wxPpdmKTN7YwM4tAtxAUUkIkkQjhokDBZiEUrDJHpROWlgWMsUWQ8XNNloVWIoIvVqn1SGRiut09uoDX7SXYd24hbaFsxGJbXW2i/gLeqMTMdwULfAPYhJcvX0EkkQHCbAHnICWmRg22TEbuHR51n902Tw/4xMpKIFu4cdZXaMIBQHOKAT4UfNismHP1WChU3hpY4sFb//w8Dzijg/jgIIP8HQNfrA9rCHZpeok7KeSZOp8RdwgG2ghdDh2MnaoM7db0sPSeIk1YuGvyYc7hsDjIATlG+6hfoAJAFQFRcsdW3PTf/jGWYzPj2PFPlXwkJ6QMfFxLr9+6uS48z21TdmPNnMNgNeubfC5xgci8ohj+TNuVDRPaV/yy6jqwY60AnEn+B/OpS9pV6hcE5kUQU1uyPoKo+4UgKFBs3s+LA8c5tyTeOFQfyPjyxjpMnXhzDnlB09s9j9prfxLvete7XOqCPRFZoCQ/ff6SCcVQVrKrgvTON5sAzYmdE0Yj2IqSAt5MN4G+qKCht1COqtCkQLNSAmAFgOmpCjAgCs1Rtpx3uUKzrK2dLsq5mwiH3nJOfOxkeXl5qkwlDEKNs+X8WKeHO/Y9gGST2k6aHTqA2267De973/sAAL/2a7+GKy6+Ave//wF7zR4X+By3n3rqAU36AiEtyWfljFFoMmXtcGOOBrupZEBaL0cOOdsCVlM/KNCQCk0Kr/LytpwLITAQwBRTaA4HNDPyW6XMADwL08DtrQUARKHZz4b6cXS2opzPzVSR0S3nIyo0q0nxnC0HA1x/8hr23Y70ArvIPVmp4zc+KDG/dR5f6f2LrZNVP7zsxCZ2DhtTwdGFme7Hxs+iXdwRsMhwIoWYbFhp1Wc1RRJ7UWQAEJP0cFgoZe4vyXjezbcRJYr4vpdFg8f4IKrxhl/QoEA49YtmHm6Lp0uXEZ5IhYRbXc3f4cJcSgmjsrEAgyYZBDYy6UkOeul92YKbXeg+xlSna5iA1Fu+XdkL539Tf7psQBKqESVIvcBCMF+haaPHU3AIcMWnECRfsTwVlY5DA7uRNKJ+jJVRaoAvhblWsmplMDUCaoO+aVXB3Ljiz37r/hDA7H/5n07hxs4DLKWHB74ohCcQTJo0aG5j1NDvQ7b+dX3qstMo9+p7m237r9/uLrhUEtSduyFpc6aEDOcIN75CEBUAMgPuSPH2fOJe1GW4gOFhgfz7mnwJ1lz2qIz4smXX0TnaYFM6F8fLoOrTg7QkAwzyFYwZWgZJx543DoMXS+x+4OWIzUnkcrt93Vxjfvcb0Brtw3oOIK+CIOPRw8NbSyAJ1xJzn7nfVhd9NEZfjkWmCknHEXtrokEnBbCxLfF5TKEL17DshZEaZ4VQ1lO7ToDmxCb2BFuPTtYlbaduNQU6IrUwY9hgIICaZCzQzMsDLPUqMECKmoaHqyOoRjs9b8v5WVRobgRolulDs9oSXoT60dqO2vFuD588esr+/YqjV+L9cx/EHX94J77zze/g3e9+Ny4+fAnEsnswUKB568ml0QtwjluPtG8lA0QJPitrVYGsKjbUj/qey4lqozyguZL4W86Hy1PPA5pl9W0AGKQCrVXXT4feck4+lwkP56eBu6fmMYCwdTWQ0gbQWcvyVM0BSSaRoTwfmvMzVWQ52XI+oi/benQhoUxUKrgAWwuPn6yo7UJzmy/Cqly1c1Fb5Of1D8aJPTnNbRWmYAhsi6C/RTueBlk0Qy/YJZAud7HzO4e8K+hildHAyHlUIyQLFmYOpFiItOeiKPi025TNur5Wd4CMwEcBqRehofnYqdLJMXPGAQ2u5FPpOfAFex47xQNRAhL5y19UoL6RNpf+gju2TT40f/7TQI7dwlJGdy+X23CBj0T7eDN/63OJUlbKPLrbg6rNfFOHBCtTUL8FxbWqxfAAgw3S/m3UbGGCQbuC50Hlc60trA70xoICWTPbp/Vxrviiabg8ptsvgNnWGx0bRWpdUlZp2k6EQDN2JQWRgAOVpr8Lnaafp8B9AKVGhXn0vqPlpxDYDt/IlnMPDsbvafxIMjKtVLVpQk+LfbR5c/8KAqqL7kvnBPOfCLyTbDeybtY45KOYj30bnTddeycSSDzlLe86pu34HOCGrzvmCrSW8bo2MNDl2pDlYt/DfiaLlO3+VX6wH2PpqVXWBuF8p46ZfuvPpHmeB/Xu7sn/dim68kqZF/q8tQpWPQdA+hHVaUakZunSzq/n8+/TCdCc2DlhPbpYzcpZqE83VZASs0AfNvAGAPT7fabQrJa05byhIxwb6DNK0JRun7wBLdF/nlNouu+G9qFJFZolbsutz3qANRseZvjnHuv08Anit/T6r1ewK92Fn8XP4a9e92EAwNVVrtaaPw3shCrMzccX8VcPHRy1COe00fFWyQBUy3kU1JoSFdKPhlUg98lDuFKii4c5rdBsbCDKeY++bMjKU2gCgEy9LefDKjRJtZSq0JwBukmK+5uzI/sbNT/M0gzIRMkKTQo0R5gDAKC9xvlbj7pjn+1+Jjh+wvg/al3HgGYu1k53YhM7l8wHagLQCyX1ndC+MWOKNfqnsLApZwes4q2XoXVshV0v/UWvnie2nXZvPEKfjCjkHhx66IWbr24U7lwn7qIL98SCXXurWNk9FamAwNTRHq66JzL2rfKNlDUCiCwcomnngNyxTblc8e/PkpEc8rLT4zDIXUfOkoXV68pgKw6RhbYqiTDQDWaLLIV3EkCiAY+GUlQd6C+46fZZAr5YWRNaCMCvX4EQJNCyD2s+lHOqMQ1xNG2iQMshEYPfDO0VvB30IQrqQp+MKs9HrmlCEvcOJk2qgg3gTVAO942g/QgCjaQery/fCre6uroVACrPf5G3Ddv0j6K80Yyt10ga6ug5iOY7Dm/CvhIqoCNX5TKq5pO07fR3VI3KoqqbzNHxE/EryVCaD2Et8DOQ1DvPZCanEd3jvoAVvNWn6GOXZVPYne7yoCzNGUzzseOCjtHCSSTSlv6cR+7EnxGAQVIc8gnbp1hQKn3emq6yJApeAJhjsHlLLrgQS5xnuvwHRVqjTH79SG/StXOcA5r21JirALm2D037bNZJToDmxCb2BBvdcoqSFJoKaDp11spguC2UANDtdi3QrGRApSSffnUDNDX0GQXU9WiU3ywpzX/eplmgW+XRqYf1oUkjuZWp0JyZSXnwpBEUmv65H330CB7TUcsvfLCDvQ+5Y09vPx0AcGl6WZDOLx2bt5//w7fuwSMr7aHzcK4b9aGZDlDKlnMAaE0BgvitHRaM+4C1LB+a9ZpAWhUQ3dHdPPTIFmdZIqwHAFRSBjTfduvd+Ff/8h101hl3A/amWyBZY1v1KLYwo/69o7Uwsr9Ro9JOc5W/0iDrXAN9pEh1JKTeCArNfp4HkAAA8hPHAAA/eZP6u3NdGx9p/3VwnlForqZXYUWulObPd2ITeyLMbOuVgsMfpv7R5558/jbkU1W7CHvuVwZWISJzohYh2xoB4Gnp0yJ31unnmf182cfvDvMWEkUPLqkz+YUS+J6nR3/TSQMtdbKNH/4xDo2oegyhki9YtXvr+FAtZTCfPqtQVRXkFICMBiMxiMwpND1AJtbedEnYICsrXUgbxZ875p0fq1tzpjDAD2zLsYRTaHL/jWvBhXALKW+v4kLRMnhJRspBWrFgu66/1dXdV30jAmiQgPpDtecBwZZzzjI8cGyyJgROX1iDCkcTqRORuO3aLPth/m1FEPAlADTBt1EQhs3uFbaX8D6rPplccVUUogtS7QGA1XkWGs7ZcoCMG+0v1PUjweovplp0p3nR1gkcDkWM0q9qP7esPD6AZueRreIWuK1xPzsOVc7sManrYy2FJgDm85bljZSdZkBIQNLx6jNFYXKiDlAfmoKe583b9sWGBykjsztYAQELbwWpE1YmQNEq77ng903mNoG1d3x+pT6kK5ddiUWk9pjpm5J0Igmg+twXWYVmWLiCoF0w9SzIeQXj1Up09YQQGYeBQtjcc7LlfGITe+KtT8dgyQpNs+U8x/AAsdfrOYVmSVHXAaCSAn3htuWu5sMvjilgQYnqrCQRmJ6TqI64VVhKaRWaIpcYiBIDgkwnzH/eKFHOfeBwtONI7as/x382b0m2Ym+6F3vSi4J0XnJHip+/9EIAKtr5pw8fHzoP57r1fJ+VJQHNmSnJAnENq0AekPyUqYgG1LbzLiqo6Elm2L7UJ4pokZcX5RwAUONAEwA+dugYPnbw2JqXDeiOqFhEyQ3a/LSq7zun5kd29UCV7Jkob2v+lk2z6AmBqhavdkYAmjEV5QtEH6f//Zvx5l+/By+4RX336v91Az531+ewcP08O9cAzcXBpViVq8wH6ygvVyY2sSfSfPWP+a8026yTBFwhJ9CfqzEYeHqxrRZ3vhJRgK2Gm6KJ6ouuDzNhtofrPGTSzb/SpkGey1JicNFWHE896BLAHfXvYpsMTukWxwYuGKPbet2OVEnX1XGTwYfIOQRQFPhHEzbTHojKEQBNqRVXUsApfihIo0CLXUoWukU+BaOKJgVWmT9AL//2WsLHFG2SkHTBLXMoyOcAqgF5NECHVX6Z9qIKNfgwUFhIVQSfYkCWHad1EYN+XnlVvecEHBfXn/UtSeovDm/pWHNN59fJ5Z8+bfNEoVwI+fX3a0B0OgeYfpGJHPm67mQiKMp2P2maRBdHsCjnRpXL/E/6dWz+pS9lvdvZFwQkGdv+MtI/bZb5vZmST2hw6A3DIqLpNpILe2bQN0157Dwrw+PsbjLwCewrNO25RZDP68+0tahq0Y4ZfQ8FNGl6pE8Z6OaK6vqmrQnh+ntgXEHrEXzSNz3/oN5c5W+HF1JGWkfgsdZcJA/EZOjflRyCU18D6WVXWN/SMAxX15MUrgdUnnatq/vgRYz5ntWIPeaev4iOV1XtnlsQrAMq6cmF7jDOD5sAzYmdE0a3nMqSgsu0GkAnSdhidNht591uF3lFzRSVDKiWpBhTAUGkVUO28+F9svUp0MxEaQpNANixOWXKukPt7hpn6yxkmVVoVjJApklpirH5mRSDviMjowQFKlSVDQZ44XfDSvuRxutRFarD3dz7mv1+5aFV/NCF2+zfRzrr18mTxZjPypJ8aALA7JRANnDtNrS/SrqFJwPqJQXhAoDZlsBqUnXBboYNVERgrCzxBQIAiFqK1kr4/d1Ly2tel+nxVelLJJXyHt9GobmU1hjQPDPMiw2q0EwSKtoey6rVCnoiR1U3V2+EgDy+0vWGnVvwisVDkKsrePoJ5Tuzvr2OxgUNXHnllfjev3wOLnrTbgDAUlrFXVPzAIDHlneiLVeZQnOUlysTm9i5ZUbNof8yWyylW3jJBEBOtjpCA4vtm+GrxpzvLuC2/m2oXHoFuRfBBDHVmzlqFqse5/iTv/t7nlIAL9R88Bu//duRItJzOUixi1HLAx00qD7r+SqJ4GWRD1MpWBLeORwu2WuEB1PNuTInMSQkO+QDOAqD1ntC2jKw1bErq9nGKEy6OUMMwSLabZU2QEK4JJniyyg0pVee4oV5DNPFYWBwgT40ZOAVdk1Yg/5WVwtfBD3GoaxMDJwhUEKr1eIgxQNW5DsKg/I8D/LI2iskcnEj/cjcJxfAtyrL5BQHHOl1hf46ee45SJGwkNIF/hFBHoUGobF+LGbmSD1xn6fC8E3hKzQdsDVzQDR1ITSw8kCU3x/YmGRIOwDQ7FoPVMfKp+ZNv2/qNqAA2oOBrAwW0jKiFYe87AxeBu/boM5ou7p3KDJIV0HjyA3pyx5bNt03pAv2Y8C4OY+DeJpHd4uHFtz6zL+X+bvQ/6QHtZO5BdSlC0TG6iQ2Dilct2e6CarR9p9Bruyu7WLtQPqw7Q9FbSLtNSZQ2ARoTmxiT7AN6O+es6TQBIaHGatdt4JNM6DWKA+wZIm0C2SJ4X2y9UglyaxcwLJ9U4Lpk6nyIwPgLx48iA/ef2DNa/r9PqChSpoBqJRXRwuzFXSSKqo6eNIo2zyLFFTVx05YOLLjNdvt99fXX24/3zO4B8dzpZJbfXgV2xuOrFOl55PdmIuHXKBWEtCcmxboE6A5bNCrLlVoDsoNwDPbAlZIpPNhtlEDQJ+OtxKjnANAXq9gKuLBIF3LHxCAgQGaA5Q73jTQbBOfw8Bw406mbg5IKmJtn0Yj2kDkVqHZHeGHWofMqT+6ezv++sXXoXPsKFqihYVkAQDQ2jtlz0kbKa79g6vxq899Mf715S9GO1WNfeT0HFaTlG/DnwDNiT3JjCrjlHtDDV8sCOJji6lsEjVOei9/jg4A4hb3FAbm1QV+U6vs0Qt4feLL69+vb6IW4zJQK5nFmh8h2v8jAhPMMQPP6GJTLyJZcBqpcmdOq1zzzFBB5giAVzwP1tF7B4qkaBIWGpFwj+Qfb3Eu/KjZBmYUzYsRiBR8oH/QBbf6ECo09TFLNvIAVMrIVmmTPFOOsfpDsMDnW5iN5i0CQ2l70dvm/G+aXtGiP6aodYFpTI377hBUPdtWJ/CuSOFaCKotzNCQIpo/A+7YkYKtydJmXDESDZsFsIr1nmMeqCTZptANUiJ98UuZf0+WOfuRlNXUgxAw/lap1V73k/pS0je98rr6oF/HxqQb+/71hDzqu63x2yVQe8MbCzKoH6cK95KSklwmydgxtef6XJHyViVEy+NgtymrgFNCmlODbfPUJILAPFE1apEJrk2VXhlMuiagDpk1Yft+LG8WbtO5ysuLoEARDgjSlyjkhsLrH9XnvzQYhwLQEckp+SQvOkjueX7d13Qk2jnbu7c/F/rPtEJXHXRcFM3Z55FNgObEzgnLctcVFawbf1E83VSBLpjiaEiFJgWaSQZUSwI+ADAQ2FAAnn7mQagSAcvMFNBcquK1n3Df/fZt960ZQKXX60FqOVaaAaJExdjm+RraiQvmsjJkFGigWFU2e+iM/bz1+7dgam8zOOeh7EEczg4DAHrHethEVKtHn0oKTUkVkeX5PZyfSdFJqqhpEL08ZLt1mU/PctXHcy1gNXFBpoYNCkRV42UHBepO1YIt5wBwap3gQAMND6sDQJwFoKleALlyr/cCKM9z5BqyKqVvuT8p+kmu4C14n13P2qQ/NfQcdfz4cVyYXGi/b+1t4ZZ7JPb+dI6f+u0cy6sSd642Lcw0lm//BaQd1y6TLecTe7LYQCRAJYG/rdf50ExgwVeiQMeWLx5WvjbNOdXNROXibYij6pF0U3B/t2h3arPcgBSjXjKqMw98VJ/zwsJyCXcaQnWe4KGCfWhkwUPx4jjCTtjH6PZPs1YFX6yqBD1oSFKUF2zFvbWWd3/h6gdm6cyBjLT3C3Nt8hNEc/bv7pXD+Ow0QaKiCk1OISys5kALcLDYLeLTHbvCe9o6E3EAaaowAmhdGgkHhaREsXKGgCxyXwMsBCxglBry8XMN5fVBXggXrL9IwU814Isp+mSo0LSAzG9XD3zRslMYpK5XbiZkZSvNWLQeoiCFqsZM0QHns1q6fhQR8tk6o9ub/XPSy51PTglooYVwLyT0+GXbdcmWegERijBJUSUBdzZPRf2BvjgJYKB0nC0yTziVbThfhBG9FXzMLfoyc0C8D0vdF1w3iEA+/xs9r0vWN/0+igBA6g+6GjiQY+fF5prIuU7pTfuqy39sG7bNm55XTHvY82xyPugkc5M3ZCCEGg768MC8CKfjEFR3CTRe/Xp9z8Q7zys2ub+ZO+xTINf5FwLdqWlWL9Fni/e9e+kDV+f68wRoTmxiG7BBnuM/3fUgPnD/I2MPooxOHyUpNFtNFb27SZRQw6prVgm8SkqMKA5whSYwvJ9BqqrL8/KCAgEKaK6mKX78JonrbpM6X/ma26z7/T5khQDNkvwwAmrr8goFmmP40DS245ADEa29Lez4we3BOY9VD+Nwftj+nd2/aHvmU1WhKfOkNFg3N51gJak4H7HDKjSJoi7plzveZqdUpHOj0GznOQZD+GPkgcrKi94NAIPpKlOOGzu5DtDMTKCyAZDUy/Shqf5tk7YD1h93/X7fKjQTrdAs07JUoqaHbbdQiRQaVWg2df6OHz+OC9Pd9vvWZS38+G9KPHAQ+JvPAf+TvMzZuYUkdukfIO269IZV+E5sYk+0HduxG909C5BC8oWllBC5hIlyTiFc/VjHW9BCQRwh9EJMfS/oKl4ASOtr5CQnn0iwNUMmfZ9vACqXX1WYmhRCKwGh/ID6xyGDtfXHP/5xWAUR2ZZaBFzY9yGTILCSL+YpRIxu//S22c4vp7jj05+MlsFAnGCxKsEVZ1FoSe8jbJoWNJm0EgUw/QA+oSLUpUPVZUJKiISCr9xCP18wV33VD0cUmAbQmfT947os6wFIj+fQ8gTpSV470XMM+dL0UUip+r93noXr5hjZDhzbcu7KGYFGPtQB6a9HjuA3fuM3yPiD65OSX+eVyqVsIZEAqg5oxuoijIIeK4rrkxmNcm7KSCFXbI0oAIYh9Clu7Cd6izlpSwoA11h3CjJXMRgkHLBnlk7j2sb3BulQsGYy6NwrEA+bkbI68MUKrD8KO6YpvGVzquRl4LA6Ps/4W9MlT1VBUyF5pHZ3cTA/sT5slZ8mxcgLBB/IeeW2MNeASajnQJHvYQa/wWfswA8nU2U7wB2dh/26lBK//c7fdocNNIeba03S1B9zdGLKJXLvseTuJmCehyd++jo88AOvJ2XgTx4pc+uaIdbXhX05ICyIjs4554lNgObENmz/9d79eNcdD+D//va9+PrxxbHSyklXzEvyVzfdBDoiRaPrJoJhFZrtnoNXSYZSYUaWcIXmsLCOBk4pe8v5bEvBDAFgy0n3/eIaCjul0HTbTctUjM1oCOWiwY/iQzOe50secxXW2tvCJf+vi1Hfzp21vue/vwdHcMT+/We/8wFs1uT4qQQ0B/ThmJWn9p312m1YNRsN+JIOUCqsn22BwXGVr/X7U5++wh+UB30BoD9TRyKBq+/lP1JOdtdTaKo8VQdAetYUmu779dSsFGhWSvTFakym0io0e8OssLRRNx4NBjSdQvOx5hT2P+au+eA/u/Tf8lqBd/ys/kOkEJl7iz6Jcj6xJ4sN0pQspqVdRJsFXJIkHNxY9Y1ga1WRVHUKfOsm02tm4ctPoyDJyVZ1GhTILDrZrMEgzRpmfg/5QJOBKAdxbrrpJjj1oQEB9Ibgi1Oy3i30K+duaD9KmbPzpVa0UQDsmkTi1CVzuOVb3w7TlyBReFXaLvCKKYMX2devCJ85EDBAy2GqwajfDEAo2pZKa0RBhSRUaCrKp7OiIR+Ko5z77UWDzLh/42UVJvK3n89CdWo8hFC4/VMDA5CqTBIsVWr2fJOaH905prYy8JtFgTfpCAHkIMq93NWxAH74O9uQZdka208JCCWqOsfSPJi/fKdf+DBFD6SwNieAMf/yF21gKwuwiKIxAMuG6QiiCPZMSgmRUOCnIbBtiFiUc14PsZ8MwpbV6xtJA7vJDg6bD5DebquVzhlw+fIs5gc1RHzw/uZuDopejlhYF96Wv+zwTvhusoRV2WF917s4vI9JyEDYSMLBPE4zEIDlhN/bwttYWQV/7kie63CM+c+nBGyeM/fT5TF13f/ON2FexAg6RiNuA0wfljm8+pL2+ty8eLADOufXm/u2ZoI5h/pGVbsb+DOOtZ1X6ROF5sQm5lkuJb5xfHHNbbbvvH2f/fy5IyfGul/GgGZamg/NbuBDc0iFpgc0y4QZgxRcoTnslnPy4qXsICUzU8p/HgBMka2wi/1iwBLCjPKmk5kpvk14Nc+DSKBFVgQcrnpsDgBQmaugtrmK+tY6nvmnz7DHt71qK37mZ38Gv/ze/8t+d+DLB9Dsq75wtNN9yjwsqM9alNiXVAAeBw9Xh3xbyBSag6SUoGAuT8qHJu3XJ9YBhwDQp79Z8/ICXgFANqMK+O//q8Tr3nu3/f5Ub21obhSa1T6Q1MsLu26A5iBJUCUvgNabL9UcoPKU5EBSokobAGQV1odmJoBs3cisyjoFW853Jbvs9391F3c58Z373efLdgLv+jcCP/Z9+ocjcT0xrMuCiU3sibZ91zzHbr+OqXhowAS3Lsv5+tzsbfbUN8YPWnxF7f6x6MZuOfeeCbLAhyYFqggX3lLmuPqLRyG8KGQEL8YzxnyiORAlaPnMgpdcJjxoxeoTsItQvjYl5xhXgZGyJmn4AHZ+9hxO49s/hf/Rpme2h2suGpTVrxOlNDOLY2HhQtBnDEyj96Pf6wxxYGfUlRIgSk6qcEUuebRrgANSBjO4WZBCFXKRkylEiCMlH1QJBRUTMEWZqFRw+8IOdh69m+tb8aBAkOTuHiATBtwIoSIue8ow2L94WWOKZHY/o7rTdRCNsO0xPqMu9Ps5K4Nw/T0j7WWSETB1x65WxySQII01g18AMGxH0ooqau2kwwu0pm9v3WdzeOkBcFDeHTLtKmjdhhciz/XLDa/f2r6ogWzYN+HGH4F8TlXt5ge2BTyq5OPtJ70+Fz2VpBkooNecYBN2yDWD399IRuDGDN2Gb+cJfa7VFwg6X0fu5ZdnuoUTeieC8I850orBd28hY5nrQGnfmbn3oAXVIgCKZjBIZJGf50I9SFTZE5X/rOYWO8LugiDn6fsXvQhiU/9ky/nEJhbah/YdwA2f+yZe8smbcWg13Bv5yAqPaDEYcqFZZLlwoz/PygEaKso5D3IxtEKzS4BmyVvO+1XBfWgOqT5kLjTzcv0Mzk4pEAUArVV3o/UUmjkNCFKiOmu6qZV+GwC/RUDzmuPKx9f03pZ9QG156WY8+y+vw65/dSGu+t0rcXpFon/l99hrLqvsxbEHFOno5RJLTxGYQRWaskSF5swU2JbzthwORHcY0BSolag+nJ0CVpMKth9z3+07Ewkx7lmf/hjOy8sPAMg5NXhrfeCqfSmqPTVJrbvlXNdLZQBUzsKWcwBIuq6s66kR/TkgrZVbT6g5oAkA3SEBeWcdhaZMBT50S+hD19hVe4AkEfjr30xQXf40ZM89n06vrA/DJzaxc8G6zZZa+CJhKighgfrpqtsmLp3WUnq/5aoyV9HQBaBgJwcpzomcZ1ItRiUAEsYb9w3uRbL7YpUPcyL7R6JyeBHo0pfpIRQAgEQCSLyVo1GgRiEYRSN+AAuygKfqMsMKJABRQW/XHAaz8+x2IhIhvH/BLFuYCy3pYfjDpF3xfswJgk8JQPD92YXl83ECBV8yWIDzxS8BQJa3hJUupAEQpo5k9FyjMhX6zior8X5iIFiUlZhF+5qPliR6XbyciG85jp2rQZPJlwpg5Z9rcQz5JCESP6CK4USqTaQPjfQx2+2kgSbr5BHQ27JFwXFSD7kKCiREAgjPRURMtbgWIKEuFqTEN2+51d5OGrhP06F5M2UXAFOy6tv3b73ZAlVbAg15bOR0FCk0oY+5/hYoqhn4VMdzIfCgPBKk5LIVQj7z4sDCSUaX6H1D0hb60DTnUUWgSn/l2buRkXnO1Rlvc8v8IgpNAdeTOSCjM1fYB3IGqkVwDTWltvWLyreS25ct7Dpal7xOjN9ZCwO1rV67E7e3+zhz5gxJiYxrM55mW7gvbXh5cmUwwLSFFqaSFkmGPtfcjbc/vGJBtbTn8VqwwBKmToPXca5O/LnftAF7fhX40CTzuxkXE6A5sYl59v77HwEAHOv28MvfvAtfP77IwOZHD/CJ/2AEeo5iOZFU51k5Cs16DeimYqQtlMZWCVgQJQIfAOhXgTpRQQ0L6gbszV85dWSMKjRpsJLTawAWX6GZlqjOmtEQqrEBX6NFgUwq+vKDUy289h05rv+VHHc8KLH9B7fhGf+fa9G4eAqveJvEy95ZR6eliPre9HKcftRFe3+qbDunfanMCN6zU0oNaYCmBN/+W2Qd0mYiKzko0LTASlrFzsfIonoIoDkgPwqTkoFmtZliWb9AWBCzECvLANbecp5LiaziggKlJQLNek2gqdc3oufSHWbLuQkKVMmApOSgQEktQZVkoTtEXwL8oEAJZC6x5fgWXFq5DABwMG2i6zs50vasK4DrrlCfa1WBLdknkffdADnTngDNiT15TPQysi4zC0Zg19cWrBrMLTpFoDrq949CJNqXHV1Ea5Cx7v0BSLjtsw80ZlF/2atsfuhC1qS7fX8H9cyNOcswaJpS+QFFGkphpNRQwJftGNWLMMtVSQ4ASBIURSZWpyXoXzCLfGaO3w8GIgi7yDzzoosjkI+m5aCpSPgD2GSbgUN/sUrUe77izmxr9uFCHP1oGGPv6Y4E4IykYf2fSsDfSm4ApjnbtFcsTQe7BGtklt4a6joDAwNIGVO3CVeCdX1oQrh+BFKchL8cUEWVIJG2bCWtt71eU94Q4MD0YXsWyxe8MUO35MYUegYGWWCVVIDstEuxQKG5XnRlqRWaNdTwgQ9+0N1PCAv6bdN5L0pUl05U1Ggv9ezwQdx6660MhBn4qTJMADB5YcBhdM7KYyGf1+x5qwZIiUdfMBsFmutBPhacizM3Bb6CoGUKcAWQL1D6unv3d84iT2JtwaOFm/TIYf90MKV11MK5xOWajm2E50XGqXoJ4INymmkC92NqVFAc6O59+hVXIKnUcejQIXWOIPOYOVuPteBXrGHTiSvvhekubE222TtanknzpY/+2q/9mkskNjcJ4JKvKNGXa38DUMl1HiC3T6RAfb2Oqw7hfH1OgObEJkZMSokHl50C8/NHTuAHP/dNvORTN+OBMyv44P0H8KcaeBp7dFygSfwgleVDUwiBvIYNbTnvkK3WpW85r4kN+dCkZ+Ulq0ZnW7DRfVtsy3kx0Oj3+0ydJUpUZ8WA5rD1tN55Nz5yAW76KvCFbwNv/WM3+f/Dl4Fb7lGfbxezKh/JDBqLrgM9VSKdZ/THQolbzhUYr3AF8hDttkIU0WJwFoICJRVcQH6r3n86EmLcM9rzRQH82qg1arB+uObEDAZLiwDU/NQrgHY9ovZQCs3ytpwDbts56Pbqddqu0+vZN9FJDqQl+9CsNBOm0OzkQ87fLChQinvecy9+u/q79ruD9SkAwM+/CvjQ/83z/Gv/SjCFw8KMQDZwD4DlCdCc2JPApJQQvZ4GCdLBNKGhpXQgTUq16LTLNrpIy1ah9t1KvoAjwGoBLWzL6I8kT12it9G98vMSWxM/GrqkVwCQqCBFKvwfXR7MkxJJjgjQdAtFf3HuIEE83carfxSf+MQngu/Vn9J+Lf2FI/1MfZ0HQJBDN5OXJPXKauCxIF/Qe9JjEbWhVQH6bMNbgHMI4SAV8hC02fyYa9j9vQW3BcmktiVPk6nyzDHyPQ9aYuhCgeko5wzs+PXBa4gpLWPnMeZiroFE76pdWK7QLWSJay+apZk5dCMAitefRPOn36QVX2Q7vzBAkeBlMn4tEyVNVwiDqHLQbGM3bbyO+YpamwdG3SReUH2B9WUbji/+YsGqWiWggpKFPjTnk3n85V/+pe0vdtzoRjEzRlR5y47FIK/r3wCw+GoVgKg/W4H03WF4xlTc6oN7V0RU2uaT7cP+VJIX5a0gn16b0jnV5MNew8z1YjcO9fXS+95c7f7D8if0/eJzKCud96cH3+3fkp9b2F5g/ZteN5fO87yTZ5dRgfbe8Co+P+tjgtwPOfD99e+3gXykJCmS/AsA2xMXTNaH3bT2Z49PeUVwzzna/gDQ6RBIwV5keM9c8z15FjnGH87Z55tNgObEAiuCk6d6fTz341/Fr377Hhxuc7BzsD0u0HQ/SrMS1YeyLja25Zz4shNlRzmvJxvaSk0jwUOW69NvplngQ3MNhWa320VepdtNy1Vormxwy3lMofnGv1IPiUcWWrittWC//9J3gTOr6sfC7/+lexDsa87Yz9esOL97R54iCs3MD8JVlkJT+6vkIHr9MbdCIJEYJOUHBUo9oDmMQpOMr1SW+6isV4FFvSiaFk30T7pIXKcKxhwFndUBUCl5e7fZdi6JGrFI7WyPE8BfHQCVeslAcyq1QYEAoJdJ3HbqNPYvt4svAtAZcIXmkc8eY8fvmFqAEMAH/2+B73+O+35hBvjRl/C0Ns9VMOi7Dnmm+9RwOzGxp7a9+93vRv/R/fqFg1pAuvWvhgrW1Y9amEvDAr0t18L8PiOBSlw6QCOpogXflyWBMzqxNAOSJoleTnyGMcBE/cIVmISEyIG5P/zvQHPKPwgn5pHY+4VVL11yP+8+X/ziF+Gr94QQOCP6OJNUACnRe+Zzg7y45N22cuYLDhwwQkoLYNzzRZL0HEAwbcEXsiSPEaApDLimbFlb/4JZLF9xDbyr+MfI4tgp5Aw+cOoyHwbyCx3IiyuNYCGf8MtK8rXmYj1Y+PMgHDQ9jhP8ZAxo9RVYCqxlW2fR0xDdQWcDKwwgkUif8704mXrbuk02abnTCgfVKiEO1wIVmFfWCNSmp5pEbV/0hpek96Zp+tDQ9iU9f5h5RTr4aV0SCAGR+9cAFKTVf/r/0OCJ33tXutu7oZ9Z8zX1KylUjVHYHq2TEPpRFOnfxzrjIPXNA1a5AeYD4CLVIiADn7HBjVUCdi7OAd4WUs/nBepskzV/xAgpIZLUc4dAYCGB7bSsqv+Lwn62ZlnpOaB5JiCWgMNQsezGBb1OeFCeK9IFkOdAmtj+ww57L4WU2wbqG9WcyBX7M1rsYl/ysSKTO1Rmg7LQ8ySZ6770pS/xcrBJu3je5MG51JUToDmx89LuWDyDLxw5EQyAOxbPsL+3NeIOLZ+1adZ+PtzuDh2wIWaSAM2+LE8xJhp8y/mZDSk0y91yLqYqG/Ohyd4ElTt0Z1sgPjTd92v50FwldVTrletDs9VQ+aFAc1h1LT3vb19yHX7ub47g+q+ov//xwkvYQ7c/AD53K/CZW4Bv3efS2NdwffvFq0+3n489RYBmTvtPXl4Eb9+HJjCsQpNAvKzcgFezOk9THWBhUc1RQwFNuuU82DY0njVqwGLq5tXKGQfoivxodsn8Wu2Xu+UcALZrzi/7bhG2Hrxb7nlzQMlBgeqtKlNo/sl9+/GyT38dL/jkV9d0c8KjnKfoHnUd8n27LsE/bboIF2wGqhWBi7YLvOeXBF54LfCp/ySQpnwe27qphsHAdcjlNebEiU3sXLEPfOADSHfsVH8EartcLaYSpZCiiiUhc4VuGGBUKrRcH1Pn+QCEng/+Bwlw8ljd913LF4wSQF4REOR3EYV6pjwiz5HkBiR6KplASUou1fBM+Ad9KOjlchE9LFaqgAQGuy8m9emrwdxW1wAGyciNACT+7zm6HVG48sTUjU5pROowAJ+C/S3TBLJWL1CHqbpJNm2JLI4TxwlteSSiW1ilBK1FqcsVlAG6zrx6Yeo24aIR+0ZBCj+Hb+sN8xamF7oIyFnN2nuxZnVwF6aMAJLX/CjotnF9MoR0W3AlgRV0W6kEIIpcH3j3N+ebczs7dgXt6jiQDiQDASACtNhWV4TzBvlA6+To4DH70kOSdGidGLORv6WEqNb4dmR/rIrEpuIgzxrb6z1lqgvU5Y9DSfqvm8viykMC18yw8tMTwhuHFAZG2tDLpxsTLm8KOruAV55AU33nAd/oCPGVneS+tHw0yI4gx5mSc4glXhSoxTPGDlN/kAxUi/CYvS7n7RB0BwHImZZtX/qUsMpT/SwYyAH6ItM5I/cr4BrGVQd3/WBuIoDeMe8KabuHlMqXLXKJl3zJW1N6bzzWdP1gXkzCPNeKAOr5YROgeZ7agZU2Xvbpm/H6L34LHz/EB94/3PJt+/lDL3g67nnt9+EDz3dQJxHAX7zwmfjM9z8Pr7pgCwCgn0sc7W58O26u33hW+xIDkZYHNFobCwpEgabIy91ynkxXN6bQpD/aRbnbTYt8aC6tEeWcbhOu9ssNUpIkAgPPXcCw273plvPnbp7D07/RU8EDAHxWbgvO//jXJT78Wf4Q2Nd0QHOO8P2nypZzyRSa5SmQZ6d0MCfyjB4GRK92uc/ashWaq3pL387H1Hcnun2c6K4NpzPiBiOR5Y63es0pNAGgvuzKX6TQ7JIFfmUAVBvlPr6ffqn6N6NbzteBd8tEyV7rla8abc7UmA/ND+xT/mw7WY6bj58qvI5vOU+QnVR192j2KD4+txeDJMFuMhX86s8IfOVPEjznaWH+t2+po0e2nA+jOJ7YxM4F81UzBPEAAIcQiIBDfTT9+Z/DYO+FCKVtcTDkJyqREfDjny+DNJOBBLIclWc+B0UmJYBkNvxeCKdu84RAZluv83dZYMJTBVGVng/DBDQQhoYzEQBkr+BllVKiudhV0Z69cw2uoAolDlJEQXsRkBJpS/dv2A5COmjQ+OEf96AjudYs2k19rLnVUd8nl/EX8YZ7WubqlZWC3YIWC/wn6lOLfW8WbzmnKkYK4lWCgKwkeLDewv79+61C0ylqHVAXmzatr6oC0Pih1zsXQBreqiTyQPFnygpwkEJJzvI13xPc0W4zl7mqE19RG1NESxkH1aYUug9ICeQyc2sSAvo9SZw+TL7MMohKGtx7M3VLIV2fYGo9uL5K8+xUhBwmWgWpyT8ti5dHv6z0fgBRaJL5lU4Lkp0XzjP0bwvWojjGg9+uNFB+iWmYHg1RqULTG+MUwkUV0H6/gle/ZkaK9evClwTuaze+PLW6BrR8B4H+TFT18cTZF/y0SBn5qQ54f7P3dWSOWDNMSf2bfuV5Js86X0VzjDRrxaJ8q+ubGVnsCPdyTNjzwnHD52LS6SZbzid2PtpfPHjQulD5V1/5rv3+8OHD+MiXv2b/vnZObb19/e7teNNlu3BBs47/9r3X4od3qdXgrikXPezg6sZhjwkukw6AvihvC2wyXfF8aA63GO32eJCSMhVjlekaGhvxoUkBS8mKsdmW8n0IeEBzDaCxQuBwrQ+kJW83lVMJLnrUTc7fOL401HU0kEmrkqK6qsDRaaxgoBcOP/ISBZUA4GM3A5/8Bk/jeKWO9oxSqs053+lPmS3nLAhXiS4elO/TdORgTm2qBByUq9CcaymFJuCAJgDcf2ZtP5p0vKUlv0CYawnrQxMAplYcgCsKDNT1fGhWSx5vz9yr0uuhgmpfjbv1ggKtUKB5FlSjU/MNBjSprRWgiwYFqg0AaAHsKbg23x2+24jahdta6PZdWw07X09sYk+0JRBwu5kNoFOLSQkNNO3CzFyloyvTteD0NJrffQjIMwIGHARRypTITh67PpTBYl8nApmHiLN5eoBn3p0g2bqdXOMWbwpr5ICs2jL59xVudYzVzSmSC3frQ5KdV2gUMvllim2xFvQ6ASQJOrVGuBD18nrpNwQS+3zxa4IAmbpLi/sK9DNH4QJtV7c4NluBnfpKWtBmUUhsy7lIwWCahFaR+T40fYhjgF+o0BQatNnoKtr4tl5WPJ4yhR0M3oeBV6Q7GIAbmidbfqtcdtio8cgpVPMUb37zm9V5EHq7qvqLuUvw6w9GjcnL2jFAHNSlAxlbgOdD0wM3BLp0LrsK7IgkUMy4Q/DAu02fcXruwzNqpKwiIW4TBAFtXhpKoQnFGwcDyEoatOuC2OzSB1frcejrUTFbLwKSqCPpNmxphoX+u/Xtg66dkumgiOp2HCoy2B5snybXWgWfd4z6SaRqRKKaVfNrbvvXiWc8l88lwYsgQFYTfGvnZaxKGLC0wyQE1caFh3sx4/JnywrESkPul5D76o8x6Mf6n4aKNC+sTuA9n9T3ldNdvPCz3pqQ3ovMb0nuKaVh6s+1XU/2kUSUxf6cfWaGPoPAy2YfrK544QgS7mVVHnmxIt15Ns0YFIXX/6VOewI0J3a+WasSX6DfcsstEBddDACQnQ4umVbbg4QQ+MNnX4U7X/NS/MSeC7Bv3z68//3vxwKZgMcJDGQVmgOgn5TnQ681VwFI1N4z/SG3nFOQlwtUS+QZtfkGV2gOu+Wc+FxJylZoNoG2boNGFxBa4bS4lkKzd/YUmgCQtFJc+YD7+2trKLJYvjRwaKQJThw7hlmpVByrjr3jussFXvY96vOBo8Ch4+rz841bKSHwD8+5Fo/OHMA8eWY+ZRSaBGhmJW45V/4qq6h33UN1GADUIeBMZuX60JybVj40AeACGun89PKa1w1S8gKhRH+1ALB5lis0p0lWTvbioI5uOU8G5brBAIBn6N/BnSS189N6bUeB59lQaM4sNLDnQPwH2lruH6hCMz3jPi8KV55hgebeSy9EGwnSgYa8kR/HE5vYuWhp7sCJ3b6o/gKyDgQSOB926ugF+Qwq5PkgIYEkwRxa7DyqHlGL7sh49CFfxOzCUrpzF8Q05gRXXwYQJ5fh4k9/tpBLLzaXt6RItl2gtrBSuOGpnuYfOmnLw8tAABQBROZITpR8Un/u75jB0W0XknQUcKFpm+3HiQh9LToarKDl1C/8nwTyab+VAgiie5u6grCLXJNv1w4U90VgQwTasm2xno++zg3PDRbSNP6yAPGV6i+4Tb0khqZ6wNP8d61Hi0isStZlmHapyDMkkt7irKeqzHPr61Dqwif9HJXOALfddhsDwlGgFXtWeGOh+5l/RtuMN9u3hAawrp6X0qr+GFejGmvcf1cIg3QakgYFYkkIg7S9y4p8npK20f3KKDQZFKYvMvT3Tj0stY/DlAAk/0YUdOmDOd9yTvuJnUsE2DgP0iS/per7jsNWxsyz40X1pi/qDkFNDx5kpmWlL4doogGUpWCUHlN11Z1d4KWIgMLlZ+/GqUYrUmZyB1kwDvlZvAwkW2srpRGoN0M3DnQOdGWX0ToxTem/9JLY9Y0T2L08793dm4P0n1V/HOp5047aHBC1CwGrMtZQ15SVqXtJIkP/FuRtbMoqJEDjjdL2cVeq529UoWnONX0sWSt6/VPfJkDzPLXZCMHIpcQ/HF1EukP9CLvoEPCVn/8Ksm6ObDWDzNwEd8MNN+CXfumX8Km/+bC9fi2fZutZrgFrRSs0ywIs8zMVrCZV1Dt6MTqkQrPXJxNVyUGBpmfqQN8NvaG3nBPAkvpRMce02RawkpgfTEBtVdXTmj40SV1W+0BaMsyozFYxuwxceEi13XdPnVlXMQa4Lc6tSoo7vnEH6nqx0J5yvruu2A385PVhft9wvcCurerzP69uwoNveAC1lT4S3fcPDeF78clgFGjmWXmKaONDszGiS4U2fdGQlehyAirYjfEPu5MEBrrv9NptacZbtSeRlvlGA8CWee5Dc3bFtcepAoUmDQqUDlAq9AWAay4BBHK0E6dqX89dwCoZj9UeUC9ZNTo7U8fzviHwK+/P8aqb2viZi3faY2uppTvkJVG65D4vEv+Yu7YOl9drrrkabXRsnazKiUJzYk8OM6orFyRCL6hyCbT3Ib9Cv8UwYEYIPF3uQILUqXn0QknoSCI0+MeaCkebCZd+1AKlELDvkhQCKVnYhdBNGjWMfzt/wS2lUqmaOUHKwmxv3WfmFLOANXDPpSmktBGd4c4iV6nFd/OOxzCzdBLUYqqqXGZIUy8irpQM8ggpUXvhy1hK7n6hObgS1q39QNtXhRwBW3DHYFZsm6WUkAszBQvp8Pr4NuyCMpijhrEUquA4ojX5ivrkM8ci9uiFF3uJ5wRe6zpPEohcolIxP5rccReNXZ370X/6J56cSBTkJPU3eGgfehIQSFi+WHmEwJEa8T3LVKkI28Qze0hHVzaQiJ1DQbUpT+GWc1iQotSPde3v0gA+MGjqR7k2tjmfR0wt8lD2oL7QjDOiXGWKU5I3b9s820jOzlNH6eix5y7f6p3njlEfk0zZbMeRRz2h1soxqOqHpYrXsa5bDdT7s/ME3goHp0keZaPK47RH5l41bQovKJCfM6f8jm5vjl1p6yRWFH/+NhnRY1vA9k2TFgO9tn8bOCztSx0v+6wJTL38+Z/+Cc/b3Iuh+rfpYhKyspWp+ml/o3e57Itml48ARCQPfpb4kFKnmHbMJXKWX8GeEWpqltHxavJG027+zL+eAM2JnX9GFSzGfv+OB/CPMzvs30/bX8fKx1fxyZ2fxqcu+Sz+5WVfRdbJcM899+CBB5R07is3fdSePw7QlFodWMmAnkhQEIdoZJufrmIldQv0YX1o9gdE+l8y0JyfrUMO3EN8VKApcokkLXlrZwPYPzWNZQ1+5trq37V8aHYIhKr1gWrJCs3WvAKRT9un/s6kxDdPLK17nfFxN12p4L5v3m+/X55ykcuv2AX83KuAS3fya294HnCt9iW4uAxcdd0rcDI7Zv1o3nfEd/T85LScBOHKZXkAsVoRSGpAteue0mu5LTBG+1J+FqKcD5IEXZFg90H3/ReOnCy+CE4RXR0Aolpu394yxxWarx283H4uDgrk5qSkZDcYANCsCyw0jqGbOL/DK/nac9MKmR8qZ0E12qwLDJDiud8BXvaxVSz+2fvsscMrxS4DOrSuTrkynCJ1PqxC84orrsCqXHXPEDFRaE7sSWSJAZB0oaMWk/nznxWoUL6FAyE/TBLthzqPIzLhLWS9RZ6UmUvzzNfpiRFIJXHssiYSUWOLRQF421dzxeHuuScss1EhmTNTANlA51MvQn3gJwCkVBXqoKI6VYOqQc4iU6u1uPZLR/y9Je0+lk56QTelBF12qTvkSOD94BW8Xvxt2pIs8KUEZOLXt7THhAcfDUyQXjq+PC+25Vxnmi32zRc+NHLbhFVdmy3A8TRzlo/G63+GK8MQ2yBOjKhKYxnlKrhioK2GBTmXKDRNVozKN01TBntY9eUS8mtfxYFHH+XZdAUyGQOkxHv/4A/sn66gWt1Hb67vT7dQ27sLl3oc3qqyCwsbvfYyx+zteZ+jxpSpEkB9j91yzkCT9MesBtA6yNgF2A6kqSuc/idD5uqL3V9Y4GbS4vlzZfXBsUtBhPVnFJvRl5Vh+tz1g6v3aJTz2BxH1Jxh/bo51b5oSgTaOy8K0vZLJxON1MmLoADmMoUkvGOwym9eBpBq8PoOTcJE/iZ14s9jMnJ/uy1ff92v1sgxkoZwdQpIJAE9pHkRVkF5QbLTpgUASFp2vpC6jg69fAZCVFxCdn7lvlgTGxRt7e3dXJXr5kkI4RT9UjKFpjqVTgLqOt+lBxt/QntSlRKiWp0AzYmdf+Zvc14ZZPjoo06+dOUdHbz2E2QADSTO3LWME/9yEjfffLP9Pj/hAM9YW84rJiiQUmiWBTSnPcXYsJGy+1ShmZW75bw1VUXedyv/obecG8XYAEhq5SrGhBCoT6f4wpwC2tOrakJd6g2QF0yQqwMCM/pArWx11myK1STFlfe7+w+z7ZwqNA/c/oj9/lTNLVYu363g22/9AnlQJcCVF7ngKACwaffLsbB3AZs1+8qmZ9DeoA+9u5aW8af3PbJuMJrHw9iWc5mgWimv7aabOZpLrn8OMy90SJ1meXmKUUC181RDBQaaOwNc/JACrHctLa8Z7ZzOSaLk8RZsOSfZKASa5CXU2dhyDgA7Zo6iTXygdiExWGNbDVXWVnooH7LWgJ5eKFVRwV/99/dD6hcWD58ongvoC7vklKvPxarbjjUs0KzVahhUB5jVLzVOp/madTKxx8d6vR7e+c534tWvfjW+7/u+D29+85uxb596+3XTTTfhec97Hl7ykpfY/z/2mHOge+edd+Knf/qn8aIXvQhvfvObcfjwYXus0+ngP/7H/4iXvvSl+KEf+iF84hOfYPe96aab7D3f+c53or/GS78n2lIpUIGaKCyKtOpGCYjELvChGd+j8hQC9VKSKj+BVAlGfhc40ZNbSENKCMnVRF2RQfaITB5QMMvcnFh0m6bNEyBljry6gHAZ43yUmetkIpBs3mrzZW621j3CNPWnQQ4pE7TbbVYGKQwvUOVpooqD3ziEAwcOkDL5YAPIBSB3bvfu5n3SlzlVFan7AuCk3AmQ9vLuC+aHnSpCHRz0F9HGPQGPTO0gTxiMhPYRDyIR0ObhQNRe8gq+aAdgdJhFZQ2UaFgPfK39m6c/W2NQzPgZ3ZFsQkUm2L9/v/o+EbY/GlYIALjvfg3rqGnIQlSfz608B+1OByait82X2aIfy5yUlq/Dqtbi5eERos1YE4AfgT3PwWC7cPC0yEx/qPaXMZvOmxvqvITtJaZaSrVo5odMRVwNxqFOSwXK4WplX3lLc8O3Kqvz8qkqen45qDIQtOZiZTUvK3TWrryG9U0BqPzkrhebfhdXQer7RJsrAjfJlnV7Xx9Ik/oRRcGkWFX5MI6PV43y2D3NdUWjhru5YAcCgBkETxNgCs0Dz/jeyLkkDTNF0bnfAuCwNS9NiV9Rll93Zm82hahMRY/RlwVqXCZwgbS850/QhWJtoV9W5MDxlPx+SERQXya5opdLtB+vB1mf6jYBmuep+arAW08sYZ8OkjG49068/X19LJwOr/vMf/0MPvWpT9m/85PH7VjaqEJTSgmpFVCVTC1gmzGXQhuw6SawnFbdFsr+YKgB3z+LW84bVYGMKDSHDgpEAEtS8vZuQPnR/PSCcjdgAgNJFKta20TFejbUWSrATAVX7nPffe3Y4prXDPLcwoxWJcXR+x1wP5grh98XbAZmplT9/ewrgVdotzl/9H8JCCHw/Ktd3f7TV4DLnncZthFh5r4lEvZ8SMtyiR/74q349e/ci7fdcvfI15dtkvzQHshy225+GgxoHlhtr3G2sg7pS/kgtQGbysyTCQz03FvdeLvp0aOF15gXCJUBgFr5Cs2lAh+aRVvOO8TFg8hE6XUEADvnT6CTpCww2OF2sd/YVRZ5vfw5oFFXin0AqKOiFnJLCmSeyovncbrlXBxz9bZYW7CfhwWagHqhP6PbSIpi6Dyxx8+yLMOFF16IP//zP8fnPvc5vPSlL8Xb3/52e/x7v/d78eUvf9n+f8cO9bKu1+vhV3/1V/FTP/VT+NznPodrr70Wv/mbv2mve//734+lpSV87GMfw+/93u/h3e9+t4UX+/btwx/90R/hD//wD/HP//zPOHToED70oQ89vgUfwWqyhvlkCkR+ow5IiaZMtPpMWDWWWikqVZoLCiT0lnN4wEADEgFAgwe7yDbrWkFVOgIPJyscXhkSGhUMeSoeGR7LQaMaE8s9TZQA6q96LQBBghCFyqnetJ7nEx8kEcQ4yFGvTuPv//7vARi4oM8wCiIB1GSKzclmLC4u2mullEzxBymRC4ney0LfffauBF4wtRQDy7wCXBRmLz29WBaDDLlWGArEoJlKM9xynug06Jnu3EANSlSaeQSSsnOFsEVKd+4mKjhX1gB8eXn2I39LW0UU1hooBHQv3oTqs57PSm2hUargo2TcV6Ip6njWTftdlbDxA1sXP1V/AxbSzSyHhEFa25Xswkwyq6/L7TGJOAwjI5VkywP4PrwzrIn40Iz5NgwVrgXrDNM2AJBLLGTApdXLvZMsdbLpVZ52rR0fkEDSz5SqzO+BFRqcRzpwa8oacyVg5xJhx6GAQPeyLTg+Mx/LPvviwm94v+sl+wcG8dWe/xLmy9bf9m0svfgyveU88tuRNU+BylQYX5+uz3a7XXYdBeMA1Lwd3Mf1dwuShYi8HBEEFkdePJi5IlBD+33En89j/YjMOVKDcTp/eM8aA/d9EC8SEhjBJEenAP1vhkHBOaYf6bOp6w8B19/I2UI07HMzMvUGFoPlZgyk7T5WV32BC60/E6wtwb6pOX49PVe3SbJ1hwowdp7aBGiep+YDzb/Zf8h+Tu+6F1PCKVk+0/20/fzIZw/g4f+9H1ekVwAAkkxii37w3n16mamIhrXBYGCDAhkfmmUpNFsNwbac5wBWh8hjLyOTQiZK8+kJAI0aMBi4BFd6wwHNnACWpOQtsIDamruvMYOHalOYopHOC4AmBSxpv3x11syUUtVtXgQ2n1Bt9u2TS2uqo2i/nq6kOPOo+5FyoK8o+RW73flpKvDxPxA4fpPAL/+Y+u6G5wEt7a7of38JqO1sYDsBmncdOzFyWc4MBtbn3//vYDFEe7xM6i3n6UBiIMr1WblpNkFtySV4YGX9Fx10O3VWYtR1Y3MtFxjoBd92sPWf1gKaFaeIRsnjbW4aaFcr6Ogfu8MoNFeJEkwMBGolqmqN7dm8hHaS4mInbF7TzUObzAGVnijdr2ej5oBmFard8qVFAMAZKZAV/Hhrkzk+O+yA+sqMemGTpsCOTcPno7lQxQxZ7xwvgM4Te/ys2WziF3/xF7F9+3akaYo3vOENOHToEANIMbv11lvRbDbxute9DvV6Hf/m3/wb3HXXXVal+bGPfQxvfvObMT09jWc+85l46Utfal/ifuITn8ArX/lKXH311ZiensYv/uIv4uMf/3jhvXq9HpaXl9n/O50O8jw/6/8HlILFBo82Y0Uv9p+TbYGjJ25lljNAACCdh9AKTUjny84X+EgAotGErOvJW7olHA+OEsKfmO4nCMwjyUJPbyeUgxOYFTN8wSwUGHJ+Q/UCligMQRbO1PY/r2nvLUg9SOEWwSLLg0WsjEIBvrhWdST9CzWr8cAEYBfuAk5da2Lt8YV0CAxys1Xag4w2l0UBemwR1PEsy1ifcmpekl+dBvMXGHs0eWnaeydC+4lzkApQLyzM1ntZTQrBgcoXLDBl97MfJVfLGaidJkDF/di45+67sbSknne1xR5U1HEHeAyMbJ7p2XvbexhwpO/dQA1pyh+IMjFAxuVzh9iO2XTO9XGC20Hq08FcHsRLHeMQKQTR+joDgzyFXAxcGuVrocpQKLglJZBBoi265kK40StJ7QGoVFW76vTTbh+iUecKTHK+MOpXooSk27zpXKe+cOPQqlFziTt2Xsagttm47qClRH05C+YDc9RVGembcH+7acnBzdpLvp+cBwR9U7gyOFcStnJNgWwZAOCzn/0sT8ObOY1ys2gcmr4Jkbi8BcbH4UD/xqP+QtlcDFonfgAkyZ8DdBwy5Se87fsc8vJgdIBRLn+zSgN7Ci9f6h47Humh5wesMxOGMBxc6mnUBecyB31/p8g7UDsbdGZiPjT1d9XnvAC+uaBeAvUjK9i0fye7NPfmB3P3/Y3p4PnOHgRSonL503BykNnjj9fvjHPFRlo29no9/P7v/z6+/vWvY2VlBVdeeSV+9Vd/FXv37sVNN92EG2+8EbWaI1F/93d/Z9+K33nnnbjxxhvxyCOP4JprrsE73/lOXHDBBQDUFp93vetd+OIXv4iZmRn88i//Mm644Qabzk033YT/9t/+G1ZWVvDyl78cv/7rv45qteSV03lmK95k9pGH3ZarTfe6rVl377oLf3Hwf+AZg2dgW7odz6g+E8+oPhM92cN7ln8fv9J6G/7qVoljz1bb/L596jSev2V+pLysdrv2rXVlAHTK3HLeBA6mVesTDlAqzaIo78YyAjSFFFEJ/0ZtZgo4JCqo9CUGVYGVIdU+BrDU+kBSsmLM5AtC4KHmHFpEVbfY6+OiVjM4v82ClJTv02+66YK5XP6QwInNCkbffXoFswXXnCFAU/R6mOpNATrrpyoKaD7D231QrQhsdi+/MNUQeM0LJT7yWeDkaeChQQPbj7kHx70nF0cuy7B+Uh8vM0CzMgAGJY43AFiYSdCTVcwtSSzNCRxYWV+h2SPbTbK8clYUmqYvbTuZ4Lq5GXx76QzuWFrGkd4AeyLXsPFWsn9YIQQ2zwn89bbL8KYj96M2AOpdiW5dFANNEv08yZLSxxsAbJrJcW9SweUPufb45okl/MiuuJyxneX2V0TSPwt+PWvAst5yXtNAUy4q/w+5UHW1NdJ5qULz5N1H7A+dpZYCmjs3q5cZw9qmHU3rRxfAOeE2YmLcbrvtNmzatAnz8/MAgO9+97t4xStegU2bNuENb3gDfvzHfxwA8OCDD2Lv3r32umaziV27duHBBx9Eq9XCiRMn2PErrrgCd955p732BS9wi5TLL78cBw8eRKfTQaMRqkX+/M//HB/4wAfYdz/xEz+Bn/zJnyyt3GtZIilSoLBMQgoC3ihQkBpcmXP7J7VCMwMNRGGvM5RHAukll6Fdq2Dq9sdgV7J2kQ2gshCBenzBaEDi/eK4BwHYaVDeJyWm4UX1lQqBRNVlRqG37u85riBy/2rwkMTTVmorDSIlcPxHXgr84d+7exuQRhLPhUTjLu5rUZdAbxp3kOCz01t02qYyZLDlvPq9L8bx48dBgQ1LWcOt3tS0hv9z/km6+gQOHjxo+/XRo0cdBA2UfMCpU6e8LefkNzQUyBNXXYmjR+/DgQMH0GnNAovmTAIDtR07pt4i92crOPLiLdj1tdNR3nT8+HHA+O5jzeKUVf1+H2fOnAGwmdzHQB930c50J26//XY87YWvgwFJkm2zlZBJgku1oGNxcRHC+j81baJKlOSASPwHoov2bqyBur0HVYPJPLN1s1dsxykpFHCxCjlSUklhGrC8vOwf9PIIDpT030xNKCU6P/C9OE7cipFasEWVkHg06eAMlu11Tk0Hez8pc6BaVf1Iw6ekOwDm6gF4p/WlYB6F07DlWV1dZaBS+uXT4/1MtYaZXg+YilSJXy/e7WktmXGoxhdNyME0k0oyv6DLmgTAGYCFgwMp9ThcIHlRN7fJS4nezV+i2dJ+GPkVSASWj5y2ENLCOq+kEIKXwSUKo3A1ZsYhBbux9yAnT56EEIK1j0relb3f7+sxU3F51vNRDvdsGQwGWF0lwXfM84NVTwXHKt5vv6BP52jcuR+ncYZdqh5N+gUMLZAOHMuCt+XSqeolbKA9iIS9iIlZ5apnQD7oPcN0PoX+n6zwtTXtKxJSbU+vVtHpdOxOEVM3DvQDRtB94vhx6+aEujs5W3bJJZec9XsMayMBTbrFZ8uWLfjwhz+Mt7/97fjoRz8KQG3x+eM//uPgOrPF581vfjNuuOEGvP/978dv/uZv2h96dIvPAw88gF/5lV/BVVddhT179tgtPu973/tw0UUX4e1vfzs+9KEP4Zd+6ZdKKP75az5gseNsMMDufR1AP4eP7fwRHPj6r+CWN34NZz7lHpI1UcN/nPktAMDVdwJf0Ttmvnbs1AaAplsclq3QnJ4ClpMKpghTOdXrY/s6e9r7RPkjZPGEtREzW6mbHeBMFTi2RrReagawVAblRxQ3+QKUko1uOS2KdE6hQTIQqFfLridhtwnvfUji5ueo9G85sYSXF8xcdPv+4MvL+InmG+zfpyo1TDWAt/3E+vl8w8sFPvJZ1Qc+clsDzya/6R5YJzp2zNreC4TTvT5mzwaRGta02jfNyx1vADA/o7Z3bzkJLM0BR7o9dLIMjcCflLMeWdQOBmdBoTkNnCFqiauSOr6tf+SciCiQpZRsvImz8AJhyxzw91suxjdm5/Gn938TM8tAt14My5bJPCEG5ashAWBuOkEnSbD3IffdN08sFp7fIUAzPQtAUyk0Vb8xQDNfPGWPH+t0C4CmUzetPLyEOb1oPyKULHOU7eYAsGvnHOr3uHlj2Dl7Yo+PLS8v4/d+7/fwb//tvwUAPOtZz8JHPvIR7NixA3fddRf+/b//99i8eTOuv/56tNtttFocgrVaLbTbbayuriJNUwYnW62WXUD4105PT9vvY0DzjW98I372Z3+WfVepVNiL/7NhRjkxuyiRJER1IoxChKgMRehzkiseoYGmRHQbr1mYAUC/D1mpcyAKFckbQkAkHnwEAAIAqZ1oXQlR+RrAdoLShXLutlHqPNhzJMemz/unNj73ohQuaAX0tnJylg9UCJ/ii1Z+nhDCKlAtlNIwZzDdZNeZ7YP0JhISU8TXt02HQRz1uV6r26t8VaqxypXXYNOmTQ4+emZauv2iV2Duu18g9yP51CDqggsuwJ496nXf1q1b7bmBjzcJzM3NFb74l8KVYcuWLdi9ezcOX/VM4OCKStFEEyfKwU2bNsEAreqZPoSXS0ApoDZv5tu6Wb50PiuVih2r9Kif3tTmXa4WBFywGJaiwDTUWJ+bmwPQgfbHYMVZUqqXCSIGvj11mwUkAFfBmQ4ogIuwBSf7p5CIVHNCDlKoum1wso9HH30UwBU2TVMVUit31T1435csX+rjYO9uPJi5YJpB9RmQJwEI31evKSvJZ7WKzZs327aUeY4krQKyz9Kl3Za3gGBpNhoNTE1N2dvRus2NulYIpCJBtVpF16YTIcJDmTpvYWHBpSNM/7a5AADUXvxyLCw9HJTBv5983U9jbs78cJKUZ7qo9BLYmm6DXXmYceKNt6aoobXYwn2HDmH2YgQBmQwcFaQMgXld1owv6vohZmbOofkSxtGrvqxSqegxs4ygVnQflvUKkmoNzWYTWPGgrOm3AhDpFGT9QpZv2gYmqBkbJ8H9zEeJzbeexMkfvR7p4S/ZvMDrbxISIoedwwM3G9Eb0e8FzA4CQyJl7rl0MvVMofK/fRk6/a6di1dWVsjJrjy9z3wMm159PXbv3o0DBw5g9+7d7vl/HthIJZ1s8Vlbdvt4yHvL+n+R38bswfuwe7DV/v25x6bw238O7Lr+wuj5AJiPw68ePTVyPZ0mztWrA+W7LklkKeVs1iVW0go2uzUw9i+vrntdnyo086TUup9uSqwmFezWu/yPZQMcXGmv25cyve21qhWaZfcJAzSXkwpaq678p7q96Pk0knDaF6im5bQZrae2hmAUsNyit8DGrjlN1G314/yBeapSx++8CdizY/18/sBzJGb12utzjzaw7bhL55HV7shlWfGg2QHS3mfz/7F66vf7kNqHggnCVa2U13ZzLeUqYCvZmX9gee3y9szWnVxiIMvNj8nT4Zrzj7P6iItwvppF8pNl9q1stQ+Ievnjbcuc7pep6mhz2mfxiW4f3cEg7ENtAtGyBJWS6yjPc8xMJWgn6oXGzsOqTW4/dcZGM/fPX/VealTTcp+D9Zq0W84B4I/e80fIl9xk/lg7/mw3gbuaaYLBCTX2VpMUPa1M3rV1tHzu2TWP2ooD8sc78TkgVkdl/n9ioXW7Xbz97W/Hi1/8Yrzuda8DAFx44YXYuXMnkiTBtddei5/6qZ/C5z//eQDqd6xbEChbWVlBs9nE1NQUsixDp9Nhx8yi2b/WKKGazXAHA6ACSk1PT7P/NxoNJEly1v8PALOfP4WO6Efhlg3WaleCQq/f+JY3SKkiGEu9ldsek6DYSEgJmWWQFR6oQdhz4ws/H6RYACOBymVX8u8Js4SUzocmuU5IyReaEtjdraIumjDwzCZTBDK8LblCCPJiWwZrcbuIF4CAg5sMEEmQhbK5TCIXQILYy741IAtVpeXxuqX+8lyKEcBpiKS9zpVHCMH7lL6fD0riWaRpWtpg0+Qnh6zk9ttvBwA0H+ti051L9jxqrX/3m6p8kWAaDt068OC6j9eXtDVO+e5xCPjX+e+AuH6xfYwEroHaFp3kABL+ZlZExlc3VwGBVGAjusVdVYpFr6KOVFRV7j1XK1Q1+331l+ErX/kKqwdHTHMHpL00hNc3pZSQtQpyCiTtQQLwkUOmc0ial9rvVF1zSCohgWqNqOKAvLFLqZB9lbb9ZPqJ6TshjIypgoVQvyXN14GXWNI3LxfbqZDUM8E+SwBIK6zdYXqdVhHSO33+859XL4P8MUNBb+Ln3/UjoyKsH13Bz952RUEZXLqnLp9DHe5lmcbG6jNj+EkcxFGQB6Dxoz/NttELcl4IS53K2Dcz8gbbd9q+4V1s1Y6rz9yJ9uatfN6SBM5K67UXuYewito52rQS7uUcJKYfXgGEQO2lrwRQ8ILPqqPJs8BPXPr/xuZxky8BrN5nMg+nMg7PPVOt23mYt51wJV9t46577rHz6+P1O+NcsbF0MJMtPtweD3lvWXZyOa4y69/xHVyQOJ8Oh2tT+M9/J/GqNxUrUrYfAzZ1BU7WJW4+dhIPPPwwKmv84PHrad9B579TqaFgpdXjWvtME8tpFZeTLcPfPnAQV/TWVtm1CYBKBqK0/ADA6pk62kkFlz4M3KV/r3/q3n142YJ7g+zXkZTSAc0B0Ms72L8/3AoyjiX5ZgDTWEkr2EEUmg8+dgT7s3Db8OLyCrBFXzsQWF4+if37Rw+YU2S99rTdJrznAJDmElkicPPRE8D26eh4e/C0y3idvPjqC4HltIIf/J5HsH//cG9j//AXm3j7B7bgeN7A7Bmg0ZboNAUOdPsj94cHz/D6+/bDj2BqPqJWOQvm11On04HUUrqaBppnlo5h//7V2OUjW5LPYzWpYAsBmrc+tB+VuanCaxQcT1EdAP0kxZHHDqC3XB7ASeQmHKi7+j5wy/3A9cr3wGougzpaIe4UqgOgM+hg//7jKNOa1S0AWlhJKshkhvkl9zj+zgMPYZsnU33sKLn/QODM0gns37+MMm3QW0IncS8RDl0A9KXEp+99ANfNNIN6Wlpt221caT/ByvIp7N8fiSa3QVs6WbdRzgFgbmoOkig073r0EC7phHVwRqtcqwAa3TognMsJALjigtHmqiSfQXU1BaBA6QNHj2F/Nd4/z+bvgHNpe8+5YIPBAL/+67+OrVu34q1vfWvheXQBcOmll+If/uEf7N/tdhuPPvooLr30UszOzmLz5s3Yt28frr32WgDAfffdh0svvdReayKpA8D999+PCy+8MPpb9FywriSrK6lVKxoiHhNtAAJiZoYvovQCzgI5KYEkQWLBlwOFxg9ZFxmOiS6q1zwT+MYjBC3oJTqNqOyBLnOM6GXMQUC7BhLedYDacukUmtxiAVWEMAu/CD3zz7XZIISidxAY7C04Vy9spdA+SJWqSgpALChVeKCKI7kVBmjSZgAJwpGTICT2fqoMQgdxsvmZmbUvPyTAwIMJCkQ3HQkvAJL1N+pB8KIoxoVBgbxasu3sgRjl94+4MtAg6n3vex+Q6GBTGiQwEAlA2F0focKQctogAE4RYGeFE5AyC4DwMnpYEn2SLq0/dW4OiVPZKZI/epyD19P5IvdNaD+6Nvwa9qHZTxwMomW1sEX983D2sFckqaGe3/d5rn2oCCmBNEWylnpRGDBagUjpfm5X/+6FA7Cpth1Zlqm85BIynYJAUth3ot8QBTQPqCNIexgVnIBMhH3JYfJM77cX2/EQHizmmfbNj0qn8arXIj+xz69ClRcvlQ9/+MNY2PGsYMwIoyD3CahNVOh7a5cHWc78rEPooD6ROrvozkXcHCsLXB8QSVy9TdXCkBJi0xZkOZ2fzXzkXav7uURinzP6dAvbB1taWH7+6yHbx0DhM+xfrm82+k3eXsiRkPlBCIFEApkfcCmoEwkkdaD1LAAfpqwYUkok0syhJp9aeannGSn4s0Toc5MtW2ED4a37LPF3AgDIMz0v83pQN4/NVc6Wen37+kuSl3OQwLScwn/+4/fhN//Pt6yZp6eqbRhoTrb4OMvz/Ekn7833HQXAIUu118Xix/8RF6S/o84B8Fi1icFA4Ne/cCnec+UxrNwbLh4FgGecrOILF/SwkkucmduE71kIvRwW1dOBdhc4pNq7OgDSesVKq8e1S04CK+kRbCUs4HS9uX76xDdHIpPS8gMAJ3vAP6aruOph9/Q4WGlgz549hXXUzXLglgcAKMXYzHwLe/aMENViCLtAb8NcSatsi346Mxstf9pwqpRkkGDH1k2l5mnPLuDBVDVcdQBsO72Cw/PT2N/pY2mQ4dpLLg7G232HjwP3KkBe77kHwalKHVNNgaddcdHQ9//Xe4BLLwa+/23A6bSK7ccH2L8bWEwq2Ll7N6ojjPWHj5wE7jlo/+7PzGHPnmLVcxlW1JcWFxeRV11fGgiB3RduRVld/KKdwD3JMWw56fp3b2YOe/bsLLwmS++1+emJBHsv2YnpYv45su3eAXyzTn6YHHa0ezXLgzo63u0B33rQ5mlm0zT27IlvbRsnT4Ba0LWrfcyddo/j6pat2OPNodX7jwJtBQtFnmDnjs2l5+nySx9AWwPNyx+U+NILVfs9UmngOiCop6TunsFJX2DHtgXs2bNQWn6OrAK3C+fTedf2XcgXnbo2n47PTYPbFVSsSomWUL8ZTuk5/R9/D/ih529Ckgw/V128G7h9pQJAgdJeLXyGPBl/BzzZ7V3vehe63S7e8573sAXxV7/6VVx11VVYWFjAPffcg7/5m7/B2972NgDAs5/9bLTbbdx000141atehQ996EO4+uqrrU/3V7/61fjgBz+Id73rXXjwwQfxpS99Cf/jf/wPAMANN9yAt7zlLfjRH/1R7Nq1C3/2Z3+GH/zBH3zcyz2smcAiQq/MDUqRUuKeZBECDaRPuxYYeCCFLrSNIqWyRW1ZJTzT/LeLAQ6KDoA5ftxwPr3Fzi5cmfkYgNy3UrXp8W3sAiLPkQkVuIRta5WCKy+lER5psMJ8GHoLTQC1l70Kam+ng0ZSADLvAVItRAcNN1dLX1VjthPqhX/jh38CeMCAT2/B7ausrBrKrwrpThc2pAk57v6qf98rIQ/dqeqFACWTjoNneQixWL5C6GG2CtNAObYnUCgVTVIC9z+E/NIZdh2gAlElNk2v9F4wK5O44y4UtPKy2vZj4AvwoYFJcCHdzv5WrgT8mi4CoTz9ewf3RiAdBa/q2B3929FDH0IkTMBrzpMAVtFDMweEMODIwRe/PPHo5aYPq/IICGRBL8vD/FZSNpY47hU2fSGd6taAL96W6tzp2gJ+7ud+DpWm+m2TCyhQFUAcc5nXHwzcp3VkrhGw/gfdnCMAIVAdeH7JmXKU5JkW33ZlyS7j9/VQNr0+yzWQj40JOzGCBsDxe79RaMZ6nCjoi1fBRZun84INDlcwtl0BnXOHxg+8BottHV+D+ZOVbH/v9DveBev/NQLGhQSy2QayLduBA54QR4Jt2ZdCoJZzXmMBMFxbCQA5HQOxOSeXQJIGSmlkbdg2sFvT9d+JhuX2WZl7jFSi+do3AJ+8gymji/NhOyspsvNsnRnprCl/kCZvp/fe9SB+be+FrC6MXZ5chmNpittuuw27du3C+WYbAppFW3yM0S0+119//dBbfAygHHeLz9n2T1Rk56IEt8hWIxHOWp/5Jxw9vYidC6otj1UbGOjyfP2+BH/2kmfj//mDFSS1FF+74evs2ssezPAFtR7A7YvLeNbm+cJ7+/W0StSQ1R6QNsqrx9kpieW0yrcMr3TWTZ+++Unzctt1rqW2nF/6sPvuW6dOc1Dg1VGP1FFlAFRKrCNjsy0FfJY9H5qnB1n0XoQXIhkINOoCScxn0AZtblpimThVb977KPC8pwEA7lzp4BmR8dYjD40q+Q1zJq1iyxxGrrNLL1A/d45VG9h+dBn7d6tgJIc6PVwyAnFre9tFD7W7j9tc4felwWDAt5wnCZoltt38tMRqqnxoGjuwuvaY6+tD1oduyX1pfkbiYM29GNvWc7BwNcuDOuqTvl0ZAOlU+eNt67zrE7UtM5g77cb48W4/uF+35+ZsmQk0auXWEQBcefkedPSPqT1EaPjwShtoTgX11CXjLRkI1EvOU6sh0SdzcbMyBUm2nB+L1BMAdHJVVylxrbJYqWHvhcDrXjx6O26akUhW3Vz02OnVwv7wZPod8GS2w4cP46abbkK9Xsf1119vv/8v/+W/4Otf/zp+67d+C51OB1u3bsXP//zP45WvfCUA9Rvxve99L373d38X7373u3H11Vfjd37nd+z1b3nLW3DjjTfihhtuwOzsLN7xjnfg4osvBgDs3bsXb33rW/G2t73NBql805ve9LiWexST6SYgWYVaKJHts3muggIBSBpNyGUHHozqwy6WtEJTiJq3WNUoQEM2u6UxWOAJ0MjObMFuFvVCRIUuwip/9K28hV4OiZ70YAUkgRkESNitySQydWRNn+65FLhbeCoknrmszpdOFHzZbflJDUK4dYqJQIxgrRpZFLuDBEIAy6u6LSmsy2WwiJaOvATr6wd/YA6b/1fBvQC9wAcBiDRNp3xz10kgTbBYrfPtvzYPcH1AVGyaSzv3YBZ3Kbxmo2972bJ1psmeB6LsabpOihSi/c3cabJlnywRga3SF2L4dSvR2dTC56tu+0kUN8VAhz2Ucz+Zle1wwXgIGqdjTfcBkaTus8sACkEr6TsqzSyaLynCYEWO2YWDhAJ8CzxJGSzcy/lViRWKqJcOq3MCop+uUV+CtJGZPyQMTQtBtVZl6v4mACTtPq46+AAeMNBQOCWnKnu8jCTbQVkHRLUodN58EHXFJ+/H10Wi+7c/7lU6slGF3LoD6JgFqiQM2EHHqAqdgN2wn5o0/LIJOx4DoCkSWyApgERnJCf9gN6O3rD6jGcBpx5kaZCcwiQkze8iIYLxS+flXqeLgwcPAvVn2DybejbnJTJH1nW+h9386v32Eqm9xm6/P/0vAJrkUSbttY1Xvx543626i6lJgtW/hH4eAshzCN9zo7Qlcvf0qlpaVb3Kc3rRJeRgrvtM+Lzs6cCgpu3Yi7RcQmQSolKx551vNjLQnGzxeWoYBZoCwCu2b8I//PX/wGaxGTNCLfwP16bwuhcDn70VWG4Df/G1Gn7uJ+p4xbOA1t4WVvY50Fy/9wzwIgV4jnQ8J3STEccAAQAASURBVLfr2JmuO7/WB5JGeYvB6abyCblpEUgHEllFqMX5OjYgE1gqywaHQDtJsWkRmF+UWJwX+PbJ03qrUtyWSR1VB0BlpvwF8+yUmrxXEj8oUDzqMoWHYiBKD+Qy0wSO1NyCoHbnYxZoHugU5ImAwwpxW3lBbxWbi0Kjr2EXblW/UU5V6th23KmTH1xeHQ1oei8QDrV9X03D2yDP8ZnHTuDa+Rnsmhp9HlztdiH1Vj6z5bzUoEDTKigQ9aH56Ora5R1oCFbrA70kRbXkvjQ/DbTTCo5V6tg66GJnz6nzViO+Cbt0y3kfSJvFAY02alvm3IoqWZjG/NIpmF9YRyJBZ6gbDAzSsxLl/PLL96IDRaKpSns1C+sIAHpk76LoJ6XPAY0a0E1c3ddEjQUFOlrwrDFBgdJeBugNOotpDZs2MAcAqv+Itivc0ZWNj9+JlWMXXHABbrnlluix6667zioyY3bNNdfgIx/5SPRYo9HAjTfeWHjta17zGrzmNa8ZLbOPs/3t/sNItmyD7J/QC3wgIYBOWl2SAJpNyGXzm126haUArhA78Bg00JTgUBTg0MX36yfcIXedZIswIUxAonA1LiSAtEL+dsBAiR9zSEickqdZnoSV+zjyJXR+3PY/uhEW/JMgGfe2GxtrLGUsb/YmGqRIISCTCvwlVi5DP4+O/rhiCH0/tigGcOfddxNIIYJ6sana7yK++8wNRBJXadnaiCg0IwpMCQlZr+K+uW3B9mx3IQWi6vv2whaY6VipO0HKBq1uI/fxt+eaRb0pay4h2WPa1V/7OS+E7C1516qj9R94LfCZJSAReAzkefL/Z+/PAy1JrvpO/Hsi865vr32vrl6rVy3drZXWhiSEECAQQmK1MfPz4JkxnsGAMT9sM3jsseFnj8E22OxmDDYYG4FALNql1tKSepO6pd6ql9qXV29/726ZcX5/xHYibr7qrqp3n9ruF4Kud29mRkZERkTe+MT3nEOUQCPTh869chK1Bx28DtA2cCgb7V61IqDtjpGO/dDqydeB6IO2jbTomez7gSuyCTJkTF3ZAnuAKqF23BL2PO/7cn1ffeGT+ZwL0FR1C80a1D8Hxaui3BTuIRSGVKv5fJgZz35jG3v/QplxQRU3IDlXAU6hSRaIVfpp9cPe9gtF+NMPfhDq8cdx7V3h2CWaS9w//EYzFzrI5ymfKWQKmSHHJfn2l/kwEYqpJnDTLcDDnxTHE0BbMTuSOJZ8GwdXSy700A9U7ZNbzCWcfCemqXR6td/JNhFZwjxbKjV4YioaM1EZmb3rDJ0p3H///Tj6um+2XFwjk/OYtTrQXRHAw5fV/q1sf6/tQjG9BLTasSm8BPhs+5gariCnm3ECmlb5JA71Nqbp+mwdalX+ng/zmBsj9Te+HTgW2guAcFFi7n3oM8/hXxz7F8A3f2dyF9f3Yf32Zi9ZoHnZVMSZ+Pzsz/7skInP/LxZaDgTn3vuuQdAbOLT7/fXNfFZXV3FV77yFXzqU5/yu+nveMc78JGPfASPPfYYVlZWXvQmPv+9JBfl/NBYE8e/8y34e+PGB9pPT/yMP+eZ5ji++82EX/m74Tn/P39g/G+8+o/uQvPH6zhfngMAbDsXulLVYvxSaVUAs/rAqA83Kk2PGxNqxfCKseOrnUv8kDOpELs8+eUPk0umibYJmkIArnvWfLc4KPD0yvo+DFfEwr22wW0kywWYKOdtqdCsiAINAAMd+oUeAWCZaANnBdDccyEsDk711ou8HoMol55rjPsgLJeT6jXCnm3AxbyB3RdCn3l25fmhuExpEK7nA3yXSj/z0BP43nsfwls/cl8E3l5oWhEwtTYKoDkBzNcaiULz0u3lFJq1AVBml/LFdWVpyoozT1o/mtP9AILXyuG5oCNMlGoFkDc2tjwAIsDea9UwLVxPVoG67kAoi0o1kijnRASum77aENP42jpB5OI5IB9JlHOp0KyjHpmcn6941zCznwfqYg17vDF+5UBzAujpGppd01dm14lEv5W20oshLQ8KA9zSRRuR9z/nEjXb5veQU+cgXHMEO83aTikozRF8ZLcIhFtgy4UYwveAjwJuP8SFTSBpBPHyQKhiwEeQwX3SlXvqT3Hg6mTrTg4EoSJFi1yXe9xmNSi0vveHw72HFsAIcC4CinodwJiSB7FYls/L1kHgzOF7uPrHVbhkirEI2SwrVFxKIaYZppR6uo3FRjN6b0f++OzzqlaGAYhAnr3V/kPhHkkf9m0h6urKHlJUgHUrne01ppmsCKscv+eG/UpG/6yfmIGJu9CoDbsVYiSbAtmUV2jG/VaqKW2gIWdyHkFR2OdgPj/1TcHkWPZNBxE9eI98A65v6pr3qn67yb7JgO6GZy+bjOMrqFaPrwNM3TkO2hTKFQcFiv4kDCk0g9/F0EasCK/IXh7UbXY8+T5F6wBOVw859uzfZZAt+jyQKFz9ZyIToKiia5JmoN5IxkSYU90zIRCeaYYYC+zGkauCuL5XoVh3+bk8B9/2lrS2Ah4jGsfeH68bC4nClZJMqpTSBALJQLtRw8Ln6aDp3PXb5cUhwBOs4xT3KKKxPzxemRlULqB7pIZsbzoWQ0eyhv8ACIMvPxCVxUWa93Vl02cJmX2OFXOMrV5+9DYMdo4PHXMqdwM0xftQKtKTcuZUw0//9E8DAP7LyfOgsQkL0ckHRdtLuzGWT20BzReSnInPgw8+iDe/+c245557cM899+DBBx/Efffdh+/+7u/GPffcg5/+6Z+uNPH53d/9Xbz5zW/Gww8/PGTiMz4+jne84x34qZ/6qXVNfN75zndi9+7dL2oTn/9eklugtrMMY3mGhx56CN/b+j4czW8GAMzmDfzR9sO46RDw/rcAh62/tw99Hvi+n9P4+PEG3vL334ypmw0l2rkUiMi5zuUpNEcJNGcmjAk1AG92vlKUuNirVvi5VAqzScUbq85q1oGeNaW6VgSoeWhu/WAaUqGZFUC9vvGAxUX1XlU1tARvWynWAZpi5cLlxquzJtrGh6tLRy4Gk+HT6zy/fhLMBQB6pPA7u6/HjukrK8fBXcB8rY5t8+G7y1Uhd4p4EXfqCoHmk0ur+NWnjC3w+W7/khB8vZQqoguiDVdozuZNNHvAuDVlPLa85s10qpJTaNYKgPON79tT9jeFCwzUFI9vtQIKrwpgpQpCrbbxZZL9cbVe91HOAeBsxRzaFVBRl2okCk0AaLcJPVJRUK11gaaYA3SZbThkbTUQBQWqFTWgswa2P9guVIBFuanRWjTz7IrK8bHpvdg2MXT6C0pTY2YTasKKtBe2Io5vpRdxCpFptVWTJBGHma1iEaBmC9HiUjuTN5jFJBtTQaPQLAWwDHmyABTxghJWX1Xhn8/e1S1CI2WRKYgxsWXBFSgsLI0/yGG0FJSkAYLdW1s09SUFnfqxFGn/abeYDLAj/BvUMJlci8PdL5xHAJrLGhOffDY6D+mC27e7MK23JwtUHANh3xqSGlUBTaPki9fG8TO6pA/NBD5KM3ZRAbgHp0GxgjOBHsyMJtXxlUceiW5FIGinOETwlErtdmiI9auKH//xHweg4meO0JaD3RMod+2NwWcV6VWEmwfC6oZMUKD1+opsk1iNasr8zJsZb8peFp9vlaShbwJgQohyjnBMsz/FfHbHhtWVEiKNXYjf1a49OQHHFbWpHKMf+Z2PijOS5PoIA86/Zwq8Izg21gJNTgeACkC54CoVN+CkOE7RXQWzAYqCwrD1dwsi7FKJywGhpnyAn43KnL/szqSS0UgEAO9/VD6u9JkczY8GH5oSoLqzCT7YV3wnV3ey7Wc+P9WMd2OHALT9889qMnil2LQRf/DEWKWoh6ToUyqgHRinkEea/PslVeq7PyIwyojysH0zjZwe6vA8Yzcusr2KEFSslIxjMbe5uYpN3uXxZ5L6pYARIPebdJ3506mF1fS2CkgPhE09Ubeo3eWEZ46/89E9Po/Z3gCo1YaewvHBM6D8pavQvCwEsWXic+Xpz06dx387fhZ/5+g1uKMiYM5mJs3sTQjbdgf8oYcewitqrwQAlAT87OFX4GKtiZsOAnlO+NH3AH/335rh83sfAf7zxxiP/gfg2juvxaknTpvFuDZOkM9eJuxZFYMv6wON6Y2DB80GQTcVNBD50Xx2tYMdl6A4pTBzzGljgSYRAS0zIR4IAd5x7BJwSgKWrCA0RuAmdsKyw9Usj4Dm8qAaZpTCFJ+LbMPLNNE2gTy6pNBkjeuXtgNlCWQZTvfXUWjqGGj+Sfl5/M6tfx+dLMcbrnDYHdxlFJqTIijy7GWqkFOftac7PVw6Kmic7j0/h3/yyDHcN7sQfX9yrYubp8arL1onyb7kFJobCaKmx4HZmokofeQ48JVbjGr7Pz97Bt9/bYVigRmFhZi1AfzfG5mmbRM5hWZT9O/UvymQjjegPoIyScXwch4rNM9WAO9+of0bm/VoFJoAMD1ZR1dlmOiFdqnyuQwAhdgTLYp8JCbnJ4Xv08HjBW7Nb8WZXh9crw+5cgBioFnvm8X/n207gE6WY/vU0OkvKE2PA2sqx+QycGEHsKyM64d8y1fmVnoRJhaLURcSyCvkYAAcO2LZbMKpHRkEDQ0ZNduBRGI250UwIYFbgIWg4Wup/lp3cVdlqtx9NjLr5ni1ihDhNcmVEUe79eWyZ6+3ICbCqx9gPF23i1+tUeVtSBFhaNaR4M/emxhA9Dsl9n3pClelE2Ug/j6qu4ALlByzSTt1WgI9UkBksjZ5pYq/aNHvaxBHiKZ04R99Sj6zRo1z/Pwv/AL+0T/8h3GuWgTecMo9F3RSlC/l172P/BnWlpYwuWP4/i6VMy2UMzOA8AkdRft23UQRsjR6c+piwYGs/lnxHUXH3HW9MV3RfoDm0l9DYHC5EMzrpX9XwI9Xx7AV5eaDHDOuD9iPex/t4WRUZBanhXE4HHk5bT/zeV+2H88OHYnrCtYgH3jFlcX6YhW+CFev24vs2htATx7z5VKUoWANJhVy9VWjIQgvFWzz+6/B5PJcZTuYsUVQsGBa5iLyuIBlEJvfq1zLUXvla4DHQwuQvL1mTJxZ9grNSEWtGd5/Ixk4GI2pmGear0oJDcVBcrdzgdwI5dBaQarew/UX33QA+CtUHnNgsrzuIPTKcaSpwQpt5ChFu3vTdA/aGF4ZmCSynjfDhlr4r1NZautvOAWtl3IDIOcxvc67BDBze7SmijZhkvEu+rDZ4DPnTCr3I5GsSl0LRagbogQou4kSKu8mblsWm/eQT3nn+sHkr5lBE5Pgem4fz/A8duMDq2h3WiIHIHWH4NTKinKU6/xe/x89bf0a34TEzPiBzzyMPzpxDt/y8WogvJmpIxZ8YxZoPvzAwziUGROPM80xPNOcwIGdwHjbDMYf/pZ4Aa41cO9XgOZeY7qZa0AtGyB3uSbnMihQVhBajcuv06XS1ARhTeXYORsG/3Orl1a2FRHQ3PhhQmMmfwlZn7uEGfNKohgbBWDxCs0sN9HmbeTT5XVMziXMKMtsJApNEOFs3eya78Mu6IsmQt4LUWjmA2BJGd+JgPNZePnp0G7jQ3MyuNA0O2SXkVKFW7fUz6sSdumrC8v43nsfGoKZwJUpPVfEBsKofGguZTX0SOHb/zyMuf/70WPoVCj9eonfUx6BGtKZnJ+ov0CFplCNU0Eb7tMTiOfTeaphMlJoDj9X6V5gFIpol3Zta6GjMigGchsdaV2FppgbB3rjVaPNOvDI2Iz/fPpfnsHPT/4LTBfmOXYrnp2EnPWB+QH8J9vNu+1KFZoTbWBNZdGmxtw6voW30lZ6sSSGVWRZJVWIcC0UL0rFgEcsOD/BjxkAqMgrH/36nsMiD6CwtnKLWXcvQgQUYtDlVDRxqa//xCowuAjkOdwtht4KHurVImjngUWUoztmga3NrXtoEtwMkxZZFRz5m4ZKuHKrdCkfKRnDItMv6SNFY3Uk8GJ6DGrv/qTcUYxicT/XhgLnrmNyPpTkaZoxNzcHShbGIOOTsdLk3JVFwGImBgalAW4i6IcvIrnP7H28PfHEE0mOFn3YouycZaAo4EC6soRH9j+AsX0wYW8Xg9bwAE099Y7dfsHvC47kT6WwwOG3LgEVUc7tJcrAhSg/FtdZKMVI+7aA0a6HdJ8DUWbUw9HYCIFn7M18MBKvhmMLmUN2Q7fzlxMAGyzPdMsKAF2hcH1D7Q0VGYvrrNrRgRu3iWL+zxNNk5QLLBZSRkGFPXRz/0GML7GpsrjvkK+Hg+1GiR2CoCkQymQLYj3/oZ1b9yC/4Wj4ukJwsO/+U3DW0/FIj9uPGFAqBylVuYlCjEsEHnNt6aKcx+UwfVOOwwBTB9uTH4Zuc4sE1G6mZu6m/bZzEzvRlpUTxZHPAOv2N0rmOxbjEGWJX/qlX3IHQ94OCFdlSuEdMQTik/El1fdMQv1o32FeTWy/I5AfT+591VbtCK4WeybQ3d60eVpoqhQG3/1NkApaXyU5JegS2UqVWyS3UWJqVLvjlejvdYqbdBMFmJiP1+DGla6K20KbYHgqy6v9o74E0hbQ3IQkAyqkvvS+HkkuTttZBq01Zr8yixoZqnGsZuRMNx0K10yNEz79bwjfKd5tjzzNaO4J9LGxYCDh+W5v/R9UFWlVADM12FjzV8CArJUsT+DhpUFQmQWgmW2wQhMA6pOmkjsT1eh6aU1AKFWORqG5y3KDkhQ6xF6lubyOybmMBM8jMIFtNczGtfOjWaM6sgsm0sxyqbFYARSkQrNeACviOV6JD00AOLiLcLHWwIRUaF6mD70qJdmp5wkM9KWLi/iOT96Pd3zsi1hZZ964El+cK4lCsyCF5gZuIkyPAyDCbK2Jo08Bdzxs+s+ZTg8fOHlu6Pw0AA9GADSdQvPZ5jg0ECmQO0PKhFg1rkYED6UPzYtcQ70A2mumLFU+NGXAK12MzuR8cjxH127oOLPz9d5bztdwvc/oqY33oZnnhLOtNuazeMKr26H/fArNWh9YowEWctPBt01eWd9SilA0yJucA5e/qbGVttJmpaBSMYteBkKkXWWCnbBdSNapEevshPl0DwOrslIeCAX1jVi9mZUyAGBcNZHygkjJAobaucusysgtzCsYBhi5GPcRsPKBfxio7RpaAK5nfhz82ZljnRu3Q7fCpKUYHgxE0Fd8pooNbqkgCmbchOuwI4YiWseY0uZZbB9Ddvi6cD/Px0w+KQSOnxcPqYCYja976FixxMxQBXvw8Gu/9mu+fYaDFVWYnFcEEmIwmo+eRnPQr1ZHuTKzRsYEZFml2laqrkjA5Amu4Vqe8cWSkHmvCmaYUnVnPloYWbEUkab2LRu4hxXhHIX3PgsoFrULAB5/WVS3KFl4y9B4hs8M31sCC7YQwq4xYvBlysjio3IDM1LIBRg02D2BXhow1A9RC/MrzdYdNIrHTH2hi7RbpHVl1mZMKREohez9hvzjqnB/p9CEgk5cUgRIb59fpIC2JaeKZ6tFPvYZKxDKISWdOC8B+mqn6FNR1c39nnrr9SI/MUck4+KxG8RckfrXTFK3636QVj0TYB+mkSUqbbNZZc5zR/Y9qEHl+liHRV2rfNkqr1SEb3PfciweSaSEdaezfeYYMq/3KcuwurqKyk2CijzjY7J/rEfvZR6hruSvIg9Qh8AomXln9c5bwgYLgPzZWeQdsSHHAMYmwNum4LxKD5XE5c8YUsWzaz8QtrN195LlIM0eyqdzTh8J0IR7x7t3kpkTTr3+OiiVbSk0t9Lo0uo6QOjrlSKgmWc4duwYdvV2+++eaZpdz9uOxNcdPRwHCHrkmaDQBID2ovkxMNB8WeoVuShVxcaqxQBgZoKwmtUiePjM8yg0JdCsqVEATUNImn1gbMn0j+cuATSlYkyNIKI4ANx4EB6Urqpgdr6eQrMUoLcsN97clIgw0QbOiMBArQuBKByvMsuVCs0CWBELois1Nz20C5jLG6gXQLNjXiAXLxNoVincLqWu7JUaP/y5L+OT5+Y8zHzFzCQ+9fbX4Pe+4eX+vCsBmqnP2oHaWPPldtPEcrhQM3PD2+4Nr5njFX08MhEeAKhv/GvJWeUv5XU8sq0d+YesUmh2BqNXaE6Nh5gXp3rmAUwvms+zFS4V+gK8lrzx/ipdGm8BXRXmJwBYXc/kXDmgaa4ZRZmaDcKjY9PRd3VbriqFZjdRaHaEOuNKgwIBADfVVbmd2EpbaVMTwSu+XKAXt/hyyrFi3zbs3HsbZCAbFiaxsGezIizso8iXI6cAwi6A61QbWuJJwMhgZPsPBQjn/BQOXwSVx0DTncQWgrH7EF1ny6LE3wKCRUhRESQsIXYLRYJTv6WJ3D38FxQgFTmgY667HruGLoxazcGmUoPyamUVAUHJVavbvHUwhR1SuApYkUAL1S9w+N5Veyy6Iq6hv3yIYEVA2KkNswsr2L84i6GUAMZd2AYolSiI3DMQQNiBZQJyDvAhNc93n1xgmShP95czD44AdYAGHmypOHCJyX8dpdPKQ0N5hv5tTa1Z4xxfjK8jmM0Ed3O2eagcfuPBH0tgqobxKUuxyli2RP/ANFa3rb9eYaF0AzQm/+VvhHJVqBZ3feFk/JXk1ZlTMtv2jdZJoX4eIoFBPFxm796B0mdGQ+ApmAArO3alWb8Fyb5ruroSdKTQrAqAFMqsJpOFQqI4LJu5EFZadaowTXbpazclvlEvkX75l38ZvpnEJpHzjTqNNoiSvhZF3zb9ubmsItGizM8XLTUlT+rKdh6LznOQPoHForT4wAc+YOtQHRRoSEWfHnf1SZ+LeDX4/kbkx5Das08Uf3izxc/X0gUJhXPZbgi4z4Od06JWBC6KMFfY+6v9B8AHdiNS3Efk3rrH4HXawo7tvRiHgulzVCbBl0RaQx+zOswliii4qXC3ZsbKwRkobCk0t9II00rig/By1IujSHJx2s4zfOELX8C12bX+OxdN7V2vG/4xt2uGsHPa/P3IM8BpDj84JxfDILqcwEDSDHUUCk0XGGiX+G1xYvXSIEgLoJmPAGg2JsOP1+kLZmF8ptOrVBwBMWBBSSNRZ9Vywu22G6zkTbQse1rXh6aYUMty431oAgauyMBA07OhHSrhmPShOQCW83DtlSs0gYW8Dg14oFEVjORSqVMBXs5cYoz85rETOGFh5Uy9hvcd3ov/dM/Lcdv0BO7Ztc2fd/J5oodXpTXRl0YR5ZyIIj+a46vh2GIFqOslfk9pBBHFx1vh/f+pPbvR6IeFTqUPzXQDYUQRxW8+bP5+ZM48ABcYqKMZK8lGwkC8NnSZjUyhOdYEOolCcz2Tc7fxY4DmxrudAIxS+yvtmeg7p9DslsN+yjoJIF9T4fiVmpwDgBrPMLkc8tqKdL6VXvxJwxssWj+FZlEmwGTqB9aBNA/MAGQKZ49mMeBhFtF7g+Kq2UlW1Obm5rPzPZjl3k9npEgRC2ligLP4t1e8NqyOcm7qV4IRfC5yPgGoBkAKxFqYwxMg381s4ZhbBStxngAnQ7GIIgVZ6RfhKRDTlSAFBqTJ35kJYHL5NN709hgMuIVzlck5KYSgUMOJc1+54WPM2J7tiObWT3Ld+HyTdIYBJvaKpFihGUNLZoZioH7nazAn3ycW8nnxFBh99H2dztEaztKaNUeP1Usk8xBmt9GxS6y3xriBzDqmZkUgjq9f1+S8f3roO9ce5pYOrKU9lBLgwwAYykU5F/3FFFsEwWEGdu8xech+5OtufJGuH8OUQH5jwcDTbP9Be8hCFhXoEQMYo2Zl/QHg2BuM2xfNDNIacCpT7SJEWwgm1MNZAWOCTQG8MVyE6+Q+ys5ccmyZh2LqrEx9oxRBPqPCVNRCUdsRtUMEjQjVfnUJVvkWPruynD5n5jH3jMyhWK332i+GqPT++kul0GFDObUYbb1Y7cs6jAWy4JiqXBxEH8k351oFVlSaPLR05/2rX/zFtFi2bVV0hw9/+MO2zBK8VoHyiiTgbdXBeENMR23VeNu7ED6FErln4pWMQ5tmDpqLMjIw/tiJ8A5y/S0i+QD6PajHnh1ScPuAZrbfEgjb1fCPTleuFQzQgf0x6yC+n+NSeBzPu1Hj+fMApca3gOZWGl1KzfWWv85m53JxOpZl+NznPodrsiP+u2eaE5iZAN748urrnXLz3Bzw1v8rkJBti2Fkn70M9Up3xArNbZMmcnd7DWhZhd2J5wFB2u6Wq5JBtY0HmhMThK59IewQvj3XA60SQqmCRqbOesUN5t/VLEQ672kdKR9dcoGTSDMGPBqz3IlWMDkHgN0XQx87XtFWaZTzlTwEzLlSoHlotzGvX8zq3o/mQr/A4DJeGlUmu+sBzfneAP/ya8/4z3/0xlfiV159G3ZZu/CxPMM2S7OeD8xXJemztj4wKruNViBOjwMXcqPQbIuhtlih9k1NzrPGxo83IvJ+NB+e3o0L5blgTt0ffo5rUmFebnz7uHTPHebfRWUVmsKP5vlkDu2LXzGj8Fnr0ngLOG/VtRJoVm3EFZlVaA6ALo0GsjbrwFeEH00gKDSBYZWmBOT1PrAmfiRfjUKzNplHCs1zlxn8bittpc1O2vvQBGQU2RAEATh4/2n4xR2MHzJpjklygSqjPrP/j81TY3KJ0Vouk0WsVHbaxWarZYEmReUyZ9gyKgKyZIlC4RztzOZTVQ/D+oAErCwVnLVBZCYn1gGeTH762SjoR4EMLlqzUXipsF4UdXr/B4bnQkKoD9n/LaEbnRFBPgdNYcuZBmLy55n2e/WXODoexFLD0C0E8hg6NJw4gQ52gT+hJqOF8Tm3XIxM/8OVH/nwR4YX0hJUa6MqVXv3oyv6VIBWFrQxQ3OJmn1eBUoMqLTnIX7W0Y3iOvjPFQpNd78x1JE5MKMUUAtqL1toV6w42ayemt4VfyFPSICmYV+xytkc0GDKLRSWQDOGJcwAvvmdoU5V8FhzHMhKKmQFOI7axyU3LvzXjCO0H4/THKrSNZ9ds/nYjQVhcs4UIJ+sxN5HVqDn5yCjnBPJMWOLbUGhdENgj4Q8ybSRf67K+dAMcxxAUFRDOfXauPCpqpnXgSGinZzK/RVfZvzGb/12uFDmKdr74Cm20E/276r8qz64Ori5mMCDC/FhORe7/lauoFaIHykAll+5G+VEwzM9B74+Pba9sjiunxKA7KlnUMwX/oh/GhVumnwOEWxX0RRE7vd/ugGDeFwcfSJ5fzBbDwMBfju8KcsOCJWsHU83lJNmGCfvGKfxNI9YA2Q26Fqn56KR4ceMux0zUGqoMxfi55o8S2YgY4IeeuwmSBUDuEBrWJVA076nKbohQMjB9cQVQuQqwbRL+1wfirZMzrfSCNNKYnK+8HUOJpCanH/2s5/FNbmhlMtZjot5A+96nVHsVaXbgpgTC3nDi/kPLYfV4tnLUGjKBSmNxOQcWMiNGdQOq9I8udY1u+XrJG1tQWsDgBobP0wm2vB+3Q7Mhgqv50dzTcKNEfrPe/n15pmvqTjSedqHAaHOGgB92nj/eQCsyXnbfz5wMbg4OF4BpVOF5ko9UMztVwgzds0AtRyYq8WRzl9oUB+g2tffmQofmiuDAt/96Qd93u85tAd3zMQF14XGHm1o1ulOz0dcfKEpVmgyVI3W2Rm98jQ9AcxaKNYW3h2WBsNtFgUFGgBZfWPL4stk2fZa0cT9g/vR8v4hK0zOpZK0HI2LBwD4hjtMXReta4SpxXAsBWay5UqtRqKIBoCxFnDKRoNv2GlHA+hXAc08KDR7ajRAs9UAjjfGcaoZop3XRWOkQFOOtdogqE2BqwOarZkGdgqV/6VchGylrfRiSA22C2pK/CEKcKJKBDmOU2pRMO6NlIIJjHF+wtyCigl45hWT8oRwP7H4VtPbQhARp4JjiPWpWRhH6lGpgPILP6EG8+cZRQ+TC2QkFr2kwCaGLwhA7cJKtBD9amvKKnlUABQJRCMiZJHAMAZRri0HYHxRxoe2ZY7yGvJjR/4eURKmtIB7JgEqRibgCDAnBUrrqaVSt21uGV0VOCTNxQQbISwuLWJ5edmfKWGnuYc2QZdUhtLN2YqGfVUyo6FamKIpEJRlJym+MJ+oZCDLTFkTf6EOupBmNJLAHLH61RWZgK4IhU5J36y4/qNHbkPccjYfaQadHGMuw9eaoaGRqcz2uajFBGBCgN6krMm5KCdMnyGd+lMNZTF5lR68D/WFIT+P5vgxtYA0ERh5z/YxrW0HUuEqC3PTqNPP3rMNGeWhPi43Lk1fkLf2LiniO/v+TjQE1piDX0lLsUAglNlkkkUI5uJyuLYci2+WPnNb5iPHGdnO3faUMG+y1vHTZlgXAajcWEg9ZQwPTfLgNer9ninKzaTw9x2Pi/U0gMF0E1zLwv1sm5UVgLXPJQoKcHxsDRhv7fD3cBtIzDoyeb7pSfksY3+oHvoRMP6kUJkm+w/SVcewAn54fh3KxB8S8x0z5qkHR3Pl2Vr2Px3mV6Vq8PCWYihv3ndsgtVpt+kQTcw2Szv/lSV6VOGyTWzgDB+qEsoQ1vKmPAsCP/s8d39+GYq2TM630ghTGtBj/usNNMWCL9clnvnKs9ihzKT1TGMCIMJ33LM+VLjtSDimifBEy0Cjg8tBWn056pVoQVpsvMn5tokQKXuH3WwcaL4kdNXWHKdWAGoEirHJNnCiYcq0fzbkv94iea0XnhmNELA4heZKlqMpeFuV2bkDmrUB0FcjUmi2gXO1lv/5dv18AJTPVagTe4kPzeWaAJpTQ6e/oKQU4eAuYC6vJ0FBXrgKucpk97Ttfx85M4vvv/ch/OXpC/jhz38F988ZqrWrWcc/uv36oeuO/cun0fqSoYQlM85eplJMunioDwA1AmAvTc7HpEKzwuRcjn9VEpojKA8Q/GiudnOs8qrv352KHxCdnoh2WoxOofkNt9v7qQwFAdNL4QfKuUSh6UpEmlGMSBENAOMtwik7X0pfo2nwJM2MMhcKzRGZnDfrABPhZ66/C3f9p1fitDoVAc10syAKCjRgrGWhUFe6qQEA4zsaSWC5LaC5lV7EiQhvLnbDRUGOII6ATbdmtwDRMefLrCJPAc+GFNuaUWbAyvbhXQ3Wcowy9MI8vAkg62glwnLhLhSaDBvtWpaTMEQGyEg0ozJz/7RRNLm6S6Wqv9AsMEkcqzKhrhDcBKBJoVw3lO0K5WOyAPaINqUdCGtWMnX3yjtn3i1PpnAMAJ555hk4IDIU7Meel1l/kcE/pSwo+8X8bx87Ka6MAa8JXsQ4SNsxiUmZQ3wekVdoQimUpXmbObN3CWiNwk8E42QHrQFo2X6E4PAvAKw00aDEoXufxfHjx0UzVITyUASSPwUI3n3AUPtVgWEW/XY9RR4QR3O2wJwpQxRV3vUjCAij4d0heAWyO9mZJmuGjhSacYk5ar+UKMVK6cqayg0HX342/cACLgnpOfH1WWOFI/m1AERwKRoG78aNgvJ9PSqmg0gE9HceSZS3GmxF1S7itSLC0K/v1PXDOuIWpwg09zbQcnIZyHburWidOI8lVQdRDjeeuMr1w5BS0Q18x2uT51V30TvJjgWEIWn/d/OXK/iC7Cs2/+ONdnyKIjyFecz7wFiMPU8tofdt32zAsGsyci0j+spTTyK4ewjPMgKxAHY+ss5ve9/fzd8R0EzGkwOfnI51d56wLgA0ZlUvKQ+icWEyDYp2ahwe6lNpYDXKMuO6ZJ1xTvY8VZRDm1Nk6xq+DvWOTgJEvyR8YirEOaGq8xnG/QcyfPKTnxwq00shbQHNTUgvNoWmNH+dPXUKB3HQf362OY48A95+9/rXp8GCfnH/LViqhYAWwOX50OxJR9xFNhKFpgsss0MobE5cIqCKro1eoXnSqqDkIvnZdRbJvb54JZcbG8RFpjuuM3PjaqLQrIp0ru1iozYAejQaH5oTbWMS7VSat6zsB9sI1Ccq4G8vVWg2DKhvNYB2c31I/3zphgMmMFAUFOQygKaDLoqAtm2302s99EuN//m+R/Ch0xfwPfc+hA+fMZ1hqpbjv77hlTgw1oryYWY8+c+PYft8+O5yAwOlCrZ8REDTBQWqDQA1MM+l2uQ8lCcrgMaIFZqDktDBAE1nTs2MdHHeFUCTy41Xjbt0cDfh0G4ARMalQaQAjvvXwDZLrQCKEY03wJicn0wUmsCwH9jIV2Uf6G5wcCmXXNuf5zp2vm0HLtQvoHYJk/M0yFRHhYaaHscVp/a2HFNLQK1v+sp6avqttJW+3snNoJGhtw6LI7MoNJ+fGzwdwZhILUdAKeZj6b9sSDhVMg4I14IkfZZF5pEAikIEBRKgMFkfSrVZ7GszRJGFFruMrn4W3JC7ZHAGgAWUQp01xKUshBtSXSZqGEoqL/3ZRf5Js/j9nYKToChKCkKIQeQQeLVQ4s0zQ3Dmhr98Ar/1W7/lQegw5Aufm+9+P5zqMgIU9n7MjCeXV0OdnZrSdwLjuuAQtuMNjTfGdUvVU9BQGlAqx7PPPWe+c348OajbiIFVNkpCo6hN+q2sSTZpVYvDUMwnzRg/t4K/+qu/EmWx7cCBh0f3clA7haT++VUDMF9OZtSXBuD6HmQ33eq+BkAxpGITDd0Fj2EuwziwYy0gLgCk4HonoucFR8Bik3NRVMMstVXUIumLVAG/TSqpHp9mMJ/InhF31XTTQ2AtBnLrXocErGFOwI8Yh1Fy49deN38ouAgwJuFCJWnHoYKKzX4pLlcETdNhmJjsA8CTSw+BF6QZvqsror7ydHMSKsvtcxWbMZfqOkkiDjO4ZkbrfX/d35EhALRs8ygDX7BQD2ZMH1/GWDn8W9yBNtc/bqWbQWfO+WOOoA4rE9lsCCgVz9O+YUyaoknRBhKoC7+wRFDyEILvYd9vPbSM848CvkE+5/U2IMi/8wystfrlVD3si2nGGLIMOzANivx5iqztXEWljn0j+1u79iPx7nXzWIW60m4IyXI0v/19oYWseT0TQ1GO3/u93xvO4yWQtoDmJqTVQarQ/PpGPZdqsVPPPI1D2SH/+bnGOF55IzDWWh8q3JoAzRONcfzhkT0R0Lwc1Vhfvm0KheYGA42ZCeBszSk0w8R2qYAqTnlUG4xGoTnRJpysW6ApXKOst0iOTGBHaHI+1iLcdDD2oQlURzovrWytPmKFJgA83TTq3xYaUDZC/dLz+GMsBmso6zsBXLn/TJduPOiAZug/lxPl2Jk1t7MMe1sG9J3pdPHJ8xeHFNuKgN949a24phZPz8vLy/jBt/41AMD2qB9fHtDsFjHQVM0RRBUfCybnBKDZMfdcrDA5l24CqCA0RxAUyJXJJW61vEJTU1wGAOgOxOdSod3EyJJTaZ6vtTxkBYb9rhb2R1xemMj0o4KsY00TiKsEXVKhmUYT747Q5Nyl/gBYqi9dUqHZT4JMrdnAYNPjQJZded+a2JYBDG92/txq55JuS7bSVvp6J3agyqv6bP/XASB0yjXECz6jSPEBdcSQ0Ym/RhYLbmiN199XAQYic3e76C4GNugHEtVYkpKARdFy1SmUBgtQM8EfnIkuq/06No5oTNHC3JUv3MBANFu55Dp3+iXelxQiUF9QfWDqDfFxFs9AgEl3j/hP9mAHIpCRjKq77fG1YWABoPn+H4KPrrwevAVAE1NDh0hAEGZOuBfFdRCphdbQdzKxBVGkFH7yJ3/SfJcHf6WhnzF2fuoa5C5Yj6xEcm9i5SFfFIwkDXQVVVrWWOStMkBr1O58jT1CEZxeP7+qvss48LE5YOxlUJPT4VYAMARBXJ1UXNdQWHg/owTosUa0AesUXwBApca24+nvYkE0dSF8tSbAWevEj6s5zjPfWFVp/9+h8StNwlO4BYCgQNbf5czDSy6XoSJThULTZG/yD9HMbTkTUOlMnwmEMhlnQ0AOjGOZiF4Z1dL+zSbPAQ9AKvfl9HlWKISDQlMPKwrXS6I+DuT1UJhAWe4U0/AebaMsQc4nsayro+F+yjBuDY4+0sP1i2Lh6Wvr2pYABvaeY2RPPjUEDuU4ZFgA6MYcAx4tUXz7lxVj4ZTk1m78snj3mGPxOPTK+RSKIobrlJiY++M2TxbbfV5JTIBC3Od06ssWDKgMB7Hb+mN22ciAYgZ8ks4AYSVo6iffm/a7tdXQdyp/UxI4L6H2H/Ln0NRMqD9Zs3kkgaheYmkLaG5CSk3Ov94KTQk0n3vicRzIgkLzRGMMr7310tdPjRPen7zjzmTbY4XmZcCeKCbHiIICOYWm9IFWFVTGpdLCpHoBqNbGD5PJMeCklfxPLwHKQu/1TM57ArBwOTqgCRhgvZLlPoASsA7QFNC3P6KAIA5oHmsGdwZOIVUVOVwqNHu9VSA3C52rBpoHaMiH5uwV+NAcyzPstYRmpSjx/z49HC3zRw/vwfff9XIcPHgQ999/PwDzEn/ve9+L1c+aH13bxQbxqcsFmomCrTYCgDg9blS+a3Z30vnRfD4IbYKCjea1tGsm/K2mZiJ4uJJsOnXFZy4VWiOChwDw6ltM+5+rtyKAOAQ07WKjNgAokwvbjU3jLaOKPltvonkphaZ0XdAHumo0fnTl+6DTA1bbKwnQjMuVBpnq5GYSuRr/mQAwNaGwpnLstuuAbqm3AgNtpRd5kgop7ZVVLGJVm2VsOE/632IYSFJfsP088nWY3Epr6HQt5fhmZGLHQFnYRWUAAUM+5eyNetdud5mExaqtg1uDN7/9u6OrnArOQQh/7/EJU3P7+SbehSbEBOOVYTEciSEYogUvOTWOrQBbWLyoGNDxbwTpqy3Nx9cRw03LrIMpMQUl2viZvoEl0fUEqtVFmwlIRcJ8O2bMw8UgoCxLH/yQwcC118aKPFHQFSRKWQGVnfnnUo1Re+NbAQDjZ5eBTAXVk1PGMrC310GO2nDZJCBjtkAzFGbYdx8sp0jAsQOAkUgsAzMjv+VlcCpA1sMmo/WVBEZYKOvVXeSCmChT+Vp4KRo2I90hwAbnUo4OiuKbutYvDgALlokUlr7tbmsKb6Gi6w8EqM4Aux8PL+0YPBO4LC1YSxvWBWWpAJrd52TLDSkAPZzhcF0Y6kn/Y6AUyuc3PtcOdUX87HwU7eSG0uT8VR8/GR9D8KHpyqVYo+w8ntQ3Hr/xN+mpMSDkfKdwfSH62JA/T9On3DOndSC7Kte7cxjn59QaFrAmbuk2TmyrWd+pOQhlBmQ33OzzcM8gDBtGVjD+8Dd/Xd7KHLN9QLZI7DYjwGI5j5FmwKuMEwBYEbRMVCTU1QX0Uah4GHLMlSY/Wxa1WwTyGnIlEPfNNM+on9p3YFCH2nESRVg352Z5HTt4CqkCnpO+QiVHmwRxucL3NdT8PFMJxgHoRh/1u1/ny1G/8zW+b5ItpyZGhhHCgRd52gKam5BWE3PdF5MPzdsfvwk35zf7zycbY3jdbc+/UP69f0iY/zPCnTfZ64pJ1AugvWYG2OWYnA/EzKhHZHLeyXIsZLUIBFWZLAPmR5wDmrUR+RicEGadioGpi+ZHyHpqu54MXDJCk3PAgJ/nMzlnZpQuIMgA6I1KoWk3/Z8WQLM5MM+jWxFoR8KMbrEKWPOWK/Wf6dJNh6xC8wp9aDqg2coC0ASAD50+DwAYzzP867tvwa+95jbUP/4hnDlzBvPz83j3u9+N5cdW8Ns/8dv48F9+GHfVjC+IHfMh7/X68XpJqhHVYDSKyOlx84PjXM08wImu6StLg2JI1daLFJoKrRH50NwrgjrS5I4YaCb9W443XahIJbjRab/xioBzQwrNuEyFbZa8AEb5m8V5OThdH0sUmpcwOR+xD02Xun1gbWw1iXJ+CR+aBbCWGzvzqwWa0+PAWpZj55Yfza3030UirKGwayML3Zw1jOVC+fklqILFop3gzMPdN43ZHnbeb95TUWAhFtdZhcjaOlM3S2NAZnC/Z8zJLcQJdx9WdOlWTXAxLzWKTPCSmwEO+DCiutF3vBskrtvH06hFihayShsD4Nz9QiRu8+mhRj1ZdAawEchOAazcH663UC8yl4z/iL+Tr0lmzPvJ1T0boejxzUL+Xw+6AuKp5gqIgTY780YiLGvGbxwL0Ii2bwvReN2V9u9jxbHhjIXbAc0a3YxAE2Yivv7DT4Frru1jM+xXr1yIAIyDsBFAcPRDKV/XdSs4VGFG2sYLbzgUAUUHjlMWcuiLHUjAYoC7ANEE49OS+0D3KVBNvqxtH3DPhNkCQAtmo/FlwM2Oz6xAkYIGgycnUOyaHAbh0i9nTURDjuA5wFah6cBMdN6QKa89tvZodKsEPXrgw01pSk6IVOE2rx40VrEaPS8HY2RfAWCVZolC07at+6DK2F1Q3C7O5BwoB2dFHkngmkQBeOQ5kZ9oB+cv1igRk35Gqb9Lc7FSOZwSu0rVDADf/cfVOwu70Aa8WXliikyIx6FmcGb6SJEBtVe+eqh8ctODCajddJs//NSb2qH/JazWzzUuyJbtK2FeAZDvE3UXGwuS70XzZUVbaPuOoLSlKBKhs9/8MDeov+r14R6Rz1bXdyruS+S39Nje2+5GWKApCx7nwczQirCiV4fHkP/bbGqoIgmQBNPjg29e+57RQJsapswyqrrMXPSvqiCzzOYt65TtL8W0BTQ3Ib2YFZrXrxzCDfmNAIClrIbFrPa8Ck3A/LCcniBcY9+dc5lZ8bugOyfXun5n9/lSIUZvUY4GaAImWrZUaK7nQ7PT64OtaWJtAOStEQQFGgMWsjpWrOnCzJIZiitFWak87Bdh4tTl6AKCAMDO6SqT87gPD3TYeTIKzdGoRrdNmntIoNkemMp3Sh39mAGAni0naUanDNRjI0zOZ4cUmpcfFKidB5NzILg1+5b9u/B9R/bjPYf24jP33uuPT5ydxKffeC92/9Y+/OvJf4vbcmOfvF3048s1Oe+lJt4jUB86X4UPjW8DAIytmeeoeXg+lBAaJV3S3cXVpL3bRb5jO6KgV6kaMgKaOhsp0NxjQeu5WjMCmmkgKa/QLAAaIdAct0DzZKONRi+Mr9TkXP6oavQN0BzFRots+04P6E50UbukQjN2qbCWmUJtm8BVpelxYE1l2DUb2uEPj5/FR8/OXuKqrbSVNj+5NdQnshPwoIrZRB0GoO2C6uCXl3AtXROBgOqgQDZ4i4UsVYmtZujg/WIjhuAhRIT/1laDcqXU1SqW9KtoYelAhlnY1l/1DcmpQYGXgrzYBF0oJglA9zRgf5O5hfNQsRThQnMXsoPXoHf9DgQzc5E/gItH6kCx4u4Cs1iNF8dDUc4r625hRpEh6/QD2BP3I7GUI1m/RDEEBm4s29ENQtCT+FQQ8PsriUVFvRGDL1udp3Ee3ev2x+cyy5oOmVlmai84MyBP8/ACnSCBluvD7om7ulqFpwdy4WoJ27fTDpmxqyGA4HOyv6sNaEbjLe8QVaj2kefrUDLyhbWQbcjVAO3BeaAW/8BKfcEa8KYQ+wsNRTTAxR6ZngZqedKHraTNmnlzanIqWDvrUviljWFMXFcJV2NFqfyDhTuJ+W+9xdfdtakcQyHroMR1UMer0mSdrSuBWCAYFJrOH24ocexWw7URVfS9aFyMvxIVmNYDrmiEMqNNTexWu6J2cH5o44mGvGl6/LzEpQSoiFOGux3BtFF2Vs1BSAC+1oBSoQRVmy3+e/P5YFeMCXud9Fcbxrl7KBXvCJtuLicN6CWKnjmnz0ju+yQ312x9GxPhPK9Zk2o3XKVKcp05MyqzL2jS75Jz3Z9ufiZjcu4XZnZc+OHKth2UwgU9hyHXBZFrFQZhfJ35I34n1ZAJ4DvcF5kUqPOc/1wkv8VhVe6u/V6qaQtobkJKF8tfb4WmLI8M+nCiMYb9uwgHd7/wAeGA5orKUXCJPcZ/MApmHH+ByrGBBJo633B44BayZ+stTKwAdWuyvJ7J+UovUIVaAajmKHxoAiDCCavS3LkUfvTMVUTE7osJjEs1soAgALBjiozJ+SV8aKb+88o8g6palFxl2mN4GOZrDQwmDJgYH5jKM+J2AYKpcF4Aq2J22zl9deU4uAtYbNQwIYHmC3SroJk9dEkVmi69+6CJYKe1xmc+8xkAQB11/O9jPwYUpl2vyY8gJ/MDaWoZyCzkvlygKV08qGI0al+nhvvChPFh2hZTwVIy/0mfnlQojI3IX+XebeHvQXt7otBM/TDG422UPjRdH38+k/NSbLLQiPyMAvDtf7I+FgcFuoRCs9YHeipDNgL3PalCs5gqUB+E55MqNKPAYAXQsYuKqzY5HwfWVB4FcfvNYyfx3k89iA+cOHd1mW+lrbSBiRlofuf3BuhnoZv3i2kXhQOUeKB4YCgysVwERpBAlwkrSxa5BDRWLNQQCyuN+PfDxHMXMfeeO2BAV+nWf+tWxmlp/L3JQRBgL08n50OYmXMEEyipH6X3HKx4U9dI3SMgmA/J0mqhmLSTpQ6mrrDQNxtURNJGMH8X+qDKusdsibH/WA3TxxeHF6w6XhyTtioyUgZFrbPAHaq7+94q1o7fsR0DBv7WjYfCbfIckWaRYYEkY+W1d0T5OO1h+Kyh/FRNANogFxRIx+afTACpmnkW7EzeAQwBxgxGUasiuJC6L9CHD1XU02QaPSXWKE8dh1MLStNucWX4i10/D5jFQRyvYJMm57a/R3UFbJ9LwRvH8DoyVde+KKlPPuqdisrqR48ir9CshCwcbyx4H4PSDN4PB/Lt4MeXaycdPqdeDNWgBmocQAqctU4UjNr6MpRAzf1lgTATsLS0iFOnQn2lH1W2gaU8MA1NEvsCrm0LwogKpunHvYVZY9TE/uxA3HSunYa6Sg6QslDs8nHLUH+IjpXhfoLjfYGfjSqwE+Noc8PXx70Tjp4NTuWv//iah2JeKavZukNwtzDHJMR2SWkOJvWXcNURyhU3lFfpgjzYnv7V3/dH03YIkDfJW8JHSszyo/vB9z8fTMr1YZUGYk38n7JRw0JNxuMuxqVmo0kTUOFzOVXz5qwMjaNQrqESdx7315TM0I98OS4nGJxPAyD8wA/8QEUe/+OnLaC5CWklgUELX++gQFJZIxbQJ+pjeN1tFRdcIl2zx01chKVsgL3nw7GnltdeUB6F85WiGQO98QpNpxY7U2+DECKdn1zrDE3MALAs/KLVBkDeHoEPTesb8pT1ozm1FI5drPAz2Bd+VrjMR67QXHsek3NptlwbAHpEfg/3CDPh5d3mQbYGofJDMMMq62oFsNzY5b9/IW4ULpWUIkztZbRXQj4vVKEpwc9YnmFvOwaak7Ucb9ptKvqVr3wF8/PzAIDvbX0fDiQ/nEoq8dn+Z6AYPtL5ZSs05Q/UEUXwdpDu0fY0ujkwJqaCNNJ5pyeeYUleIbjRSZqcd2szl1RoyvGmi2ykPjR3m41onK811wWazIwiN30vL4B8RJHggaDQPN1oxybnia+nSKE5AHQjq1QTXG2S/L/bB2pjNbAYe2mU89SH5lpm5ovtG2Ry7nxoyvSvH3v26jLfSltpg5Man0AMA1hALPOHAmHQOBid5wNYiDV+w/u4KGNI5ZmE88GnfV5hLTtMK9+/+GYgz7wC5oWoStKfak45M3Qlm8U+KwJp+N94g31TwNiYBUMBcEYZsFiYI4n6LNQ3DJh8fJCxYbA7fWowpCYyJsyy/UQjr9sGZrGvAeun07SnxMWSMlO+2wfoIAkXbOq5oE8I90zPcuXSzCgtJCoAY94tYd16ClObhw/eYe8zfT68SLlgUC2HU9a5c7RDptYMwWFRAx7MvV2piclDOOmHMW3Je1+TlG0des7MKL72FZvnOhGHbQ4AkJUUgnAwW0UwIrPRVn0qXOYHhegDZOtkA7YEjGb6qe+tfQ3UnW/U8MxD+6FqqEW35qIUUdA5OirdE7hydlQWAU13HYGxW9fMidK9g20HV5ZU5bznoxNANubPY3I1SMExg1QWgadQV9Miyt7zi1/8oihzAFqxuXFch8hP4XrDzvVbudmj0+A+4ncix1CWmUAq9I3q+1gT54qx/xCdF35Nwzrb/Sv7pgx0toi1KL8MCpm8XmtwFmBmVOXUvJoyeHcZog5kFaEuraFE7XVvEgrauH3c+E3krtFfwTcqBX/EjXwo2JN3cVDRoGYciLVoWp/0XJ+nOKJE25AF40Idyszm3aXM+7XSlYBTTA46AOmhY6zleoOtxwg1NBdG+QkVe+dkD9cvzCSVZ1BjHwCFHTti9e1LJW0BzU1Iqfrn663QXLuEQvPmw5eX1zV7w98rdYW9Z8PE8OTycNS4qlTaibFuVT4bDVjynDDRDoGBnFl8p9S4WBHYRSo08wFQH4UPTQs0XaTzKRE9++JgWKEpBEnQJY00KNDOaVQoNNf3U1cfQPhC2ti0R6jqzltHmDIgyNo6/vNqA2CldQQAkGca35y4lLmSdMMhhUXV8H5in3iB/VsGT2llakih+S37d6GRKZRliQ9+8IMAgJ1qF76z/V0AgD738b8s/s94+DsexImfeA7/ZOUf42x51vuDXRwUlcF21kuyL/EIgnABAUSXpPD07rFIoZkCzW5fPMNCYaw5GlgngeZyNo2mMKdOfWj2xQ+ccsQm5+NtA3HP11qoS6Ap+nbBQfFUK4BsRG0EBKA5n9cvqdCUc0DeB1RtNGWS/XO1CzSbTSjxDk39CaWbLR27qNg1c3Xlm7YKTbchJtNXF1cqffpupa309UiULChN0mGhaNU9BIJuXQO54NdRAB9jDnctzIt42L8XR9cBJcADpKt3ncDBgAYTFZIo7nhF1Ozgty2YXKZqPAJBa3E/ucAeHzPmzW5hzvKWbtEe1HIsAIK8A8MGWHFmlmLh7hVrHFfIwZmQpfCFmYJBk5H/6CLtOnPyOJqzVEQRalw3IMXD4pBtgRInMvOSueshWx6Xj6gj20Yt5HsQZM1aY/Wth+RRFVKyRsbNgYsOTQCXIVBK6AMBnJDK4w0yglGQqVT35/pFaFv5TIaSVaAybNAo+fOe2UArD0krYLt4NqQRldEDXvFMtjf2RhfrpL8za/RvsIFZ07FAsN5nDSDh3LRfCs8uFY09agVd2PrIdiXzsZTm6KYORnCRQHn773llbOtSL6NDoChqP23MsC3wcUBTp0id3TOlim7FduwQbs6ORgct9g/zg/IXibMoKBFdpqL9ehH8DBCODFnDCplI51EiBD+MLq09ZWG3QggSVZHEZCjr2ic7n7qmNJ3FnyzVw+tvK1T95mGQqsfPGvDjAgQPEU83JoBs3NZfzEdCJckAjqseajfd6suZ3tXtaz2brSe+EKpPERRIN5x4xcFUisbWUN9MVNpSmdt413cl58tNqLCxROVKBcSuuspcF94RojbOsmHQQ5UUXkZVBzN6XAKUmTLrMn5svt5hI65/YYBa5CvT+d40bVMl1HoppC2guQkpXSy/mHxoRgrNxhh2TV/eou8a4X96pdHEnitRaGYyuMzGA03ARTo3FFEuSKvUbRJoZgWhNopgN4lCU0aIfz6gWep8pEGBvA9NAaGGTc5jaEAjCuQigebTk8NAM1Vn9XVQaHbqZgfr9bf2MTV+9bDl9usbmK01vR/NhX6Bb//El3Cmc2mFpISurTzDvlZsv3w3DfC93/O9mJmZwT/4B/8AAPD9rR9AxmZclG8t8NO//NP4yX//E7jpLuPvdlbPeoUmcHmRzvtyYVlmI3FfIJ/b4zt3oN0JHXgxmf86EmiW2cgUmrtFmRYxeUmFZhGNt9ECTcC0V6EUVnWYbGSZpOowL4C8ObpXtwsK1FF5EhQo/pEk3yNqoFAfkWr0wM6Q7zNngFarBeq/MIVmXhgICQA3xGLny05OodmoeH33tMZnLixc3Q220lbayERiEUQGpJBdWQZzRQI3DyVATZhjsjEczqDwzg8zWIJJZsjlXYkSRApj2vn0CzlyshnCdiHHTtlZ4a4ml8sTRlLGsFhdno43U02gFavetNd5dqGUv68HH3Ih6sy14a4Li3Z3P59XWQZ1YKQ2qoZLqWmwa4PqlAC5Ib+L4e/X4npMUHhB3VC0AEUgqKgOabrpKZl/6mPQfC4EOygAkFLRYln+PfHxLyA7fG0omuwChuYCRVgTlGAoUqYdJAxixsVMY+kb70QKe9OgH46UsANkUacLkGKI+MjmjKxZ2fojJMsQEriAOK+bnkIMqhjWHYJQs0kfmmQQYFxGRueuG5Auxx2wcv1Tw6ji2l98OuRhwV+lj0ZgaFzp0picm3lAR+foSKEpGy1VN1po4r8oPaz3IN/NLRz7zgUz0G5Cve4eMGuUnlzFviIZAFEW+o3oSKwt/iRCBjH2E4DlXD889+qxoecfbaIs3RsdP304g56wJtqyHSx8PpZ3sMzCpM7fPAb9rDsgWt+HJsHMAT0b/Cg6YFNsmszJxbESMtrEqphXyP5Xs8Zcxnj4ddNQ+2NXDM6Nh2v2R8amQVSzGwTmeqO0THwplwyozPh6jPwEy/FLWKhNpDURN7cwNVNQbrmpBJz2rx05ByQ5Rb9R44GfX380PEppNk+w70ML0LVY+BIBXMTjwvUdjeQZiPmQ7aZDWTEuBTj2XzEAq0imoQ0+Cr47XRsoYA8J+AJblsEFGBcHW0BzK40ovdgUmqtJMAeXTjTGsGvm8vI6LMbUUn0Me4UrsWMvGGhaheYIgebMBHDWRlyeep7ALqviO1WMRg05aVXtp+ovzORc9piyHE0AHpd2TJko581LmZwnPjRRH41Cc8dUWF882JyBZh1FOB4KCGJfBnlh+hIAfHscL+CK083XZJjNG7jmRPju0+fn8e+eOH7J6yT4aWcZdjfryOxLbjLP8Ol3/Qq+6y/fh/9H/SL+j7G/i+9sfhfe0vhGAEBtOse3/dq78Df/5t9ElmU4etTsSF/Us16hCRj3CS80bYZCc2YCfiPgjJpA+xIm510B8LlUHqhtdKrXyEe7ny0mYx+aySaCnBVKPdrxBgRF64XauPfxuypck/QT1WFthEDTAeWuytC8xFiLQGJBI9tkufFg+PuJE4xmswmId+gQ0BRtVR9sHNCcHAt5veVTwz8YP3xmKzjQVnpxJEoWfAQJNOFBJ4Fw+hsuRletFwhFaVgTUpezBBBBebaXG0Mwyy2U/flCheOjjg/dk5N/uFIpo5L9X/JloQBCnVsjZf3ZufWpFJMRrAJQiUV0AJryDoYHabvgdme4jFxdK0gaB+jG9r8EeZpQ+0geJxbKBi6EOe4T+lEMIPxQc4CynAaPiO/iP7iymM9hse+8jDAzvqiawNSUWXC7dvFKQYWsN4XancG2Wz4vAkGjNGzq/gcAOLGl8B3pzOAZADVQ7Jr2bebLqSXMcM1MNv8kKr04q5AfmeEgHQP41g8U4hD7CO8eGkVtFXfSVz0oXRRIiMvQ9jexyuMXYwQOgdBG+/b5cpFmcL+HiZNd0xxsy5Zl2AEb5dw9A0XG7Fu2ifhbKusclorAmzWvH1JT2uu4lfsALUGtGNqDtQR5BtaQa6okT2ZGsXcG2Q/+dQCML9N5eDWta3N7b+XKFSWKTIAVA/U3vR3lVNOMWeGL1UHLQVtBQlnT3nJjphcqZpMWPr0CHGK7+ZIPzQdk57jYD6gzm0/M+eMr8URrKuFz8hno4avItL+WYyGaP+TzhoFq7snbZ9Inxu5sT9KfyQJB1+7WtN/eYyjw2RCAduNXHAsD2tw6m0zKG27tNiuyzgDj5+M1QqRIt+pQB4TDfczRMAcgArt6bjYBkwG0OjN2UjTEguUcGs3FyP11USFc52cNWi/gXbTBxwA1/DsqtJZ9askwWB4U6BFwx1fjgjIzUMwCIJQvUWuhLaC5CSlV/1yNQvOJpVW8+xP34+cfPXbFeUgTWLeoP1Vv4UKtedlAc6JN3pTzNM9grANMLpmB9tQLNTm3QLM2MLtVI1FoThgTyh4pTKyEiWCu4lmsDcJ3qiCMwpq61TC/Oc86oCkga5VCU0aCL8vRKsZ2TBm1GPXC9HCpoEC1AYARKTSzjOB+1z63XMMz6ukIaKZmns5UuG4jrwPAe9+yMRFd9u8ALtYa+OH/yHjPn4QfGh87W2GDKpJUaLbzDLlS+KHrDiAjws6PfQrvHnw7mtTE3mwf3tp4G364/T9B2an5uh+7DrWp8IN43759mJiYwEU9ix1zoR+fXCfAVVUqxLSvy9GMNyIKwW6KZmxynvgQ7on+rks1MoUmEAIDne+20eiG9ktV9NEnF0l1hMn50TxXa/k5eaUXSpEGuqm3RvfqbjXM77EuZZFCs5uorKSpNxXZyPz6xkDTmJxjECaBThqhvozbqmMtAK4WaNZywsAuUv/6f2a84dc/hMe/7Y2o2R+sHz47+5LdGd9KL8bkFrdhteyDArEzTwOKVhkrB+VCub47WlAzgjKHnb9Mz0O08WuHGHb6+0X5IERc5wIpKAICdAmAQqgNFQEyuEp0oiubA0GhPiqrRZ//kr8Sr611MA2NomsjLGSNn7MY5rJYHMd+6ORi2C5yKXwTKQ5FRDWJJQKAKeJ62jSQ7ceMOR5YKIs4/yhVfFfhG7AEo3+uh3/6iF1v5LkJ4CJ5BQDUdwP1vVG+DnKEpE138W4POEBMqXBlxmcn7AtRLPJd/XyeFqYpMmb/FMGFOE8J9qM2oDjKNIOxi3ZCN61vTy5CnSpUdo9vV77PyzTY0cLF1+yyxUxUhKnS2FJ1ettbPUy5/YOrIAA7H1425tgOMtdrUDNTQ5sOEWBioPm+vx5uKG6uq/qDIutasUjYjClMb/8k8ptuia+JIKWFdVZB5uEkW7cN8n79WZD1BRiXOQB752uRYH93yfnIQ1J4lw3UHjdBWpCO2fXUycYlxRALlOVUoY/5vsPu7wz9I+7HhOi36eYBM0CZh1tDYItCdfxXiRI7+OyMQaW5qBSPIVaHyvT6D8yJ8Wqe03ZNWNSLvv0bcPOFqI9vkmQuI/fMXZkRnhsp69JD9g+xM7NesoCRAByareOm0/vC90QRsJem1yKD+F72O//eGSpD2NQwh01/qM2uoTVXiHYw7xk5tnxe2aTd0BFF81eZfhurVcV5wkLC38du7mg5tjn6ByDC3GwXx/JBJMjwANX+rZPf6i+VtAU0NyGlQYHWSh0tul5oYmZ816cewKfOz+GfPfo0HltcuaLyOMBSGzAUA/9ubBF//5q7wERXFA36R77djL75zFA2p9I81+2/IN9+RW5NzvtWFTQCWDczAYAI52stjItmu1il0OzHQHMUEY6JCJNtoyKcbzQwtSjKVAU0xQui1KMNUlKvEabGgbIIP8RSH5pSPVYbADSioEBAUK+dmwOeqD+5rsk5M6NnF2l5AfRVBsUrOLBrY8q2cxq4mDfR6gHf8efATaUBjY8uruBsp7fudZ1EoQkAP//Ko/hFnsOdv3UeGVUT80N/4yCO/Mjh6Dsiwg1HX47Z8Ru8L1jg8gIDlWLaL4tsZMo6BzTPdOtxlPM0KJBUaBYjBpq2L/XKDEqM/XTTaeAW05pBavSQysNfERhoVbRLakbdHBtdVDAiwljTbGpklzA5j3xXFqNTsR7ZG9b6T5w0JucsTM7X+ulmS6xmXVM5dm/Dhrid4DFTScVA74uPY0ejhtftMIvv51a7eLb79bW+2EpbCUiwkl+LafipjJ0OpGKxJdSU3L8QL9gi078A8ozfymowaVKyCBXrc+YSLD7LPO54NF1gRxQHAOHAse7QdV6p5ZRt9tBEbRom6JH5vMxrApDZPC0MjMxgBeDxPggjlY8sZ1nZruZYbC4pZ9TW9/yN4QvIAlRmoFjwLgNiuFF68Aci7CprfnE8BOEEJA5wm2GUoyE5v4hffexxPPgXD+O5M2cBAIex37e7vBbZGFAsx2v3ZDHvzj2YHYI3YXUm+xZasW2jHrEjuWbxb0MAM2RQFlNmBROMLnZrQOIvwp1/Hv8+ulRQoJerOzD3HbfbsgRg4WCBTCXBtrWFs9qco+bXcMtz9l0x5DtRwhmGU4HSq+4OfzNgALANCsSwmwnAs9fXkJres+ibDAbVxSIqMmGNg5EAAGfiGXgQ7g/HLgBTIEvBHNhwWdPn2PDMBP0D3HkK0D1792A2H6kb7Tj0AXXcd3DzTHCj8ZX2NkiVnHM1YZpWmEVznBUl0G3IK6u/TM5xFuSpOlbueX3chuTAl6ysBm2bEQAw7jsB+FMMzKI5Tig0xVzrg51xOOT5mBuTsM9Es3+eDANeF/Ma1vJJf5sp7dpagD82s0D/W9/kQWj8XgnPi5kBleQBVxcBB9eZFwnGRJsJyJEhd+pgD4HD/Vx/Y3GvcqppP+moXPFNwlNmXy7/MgNAaJ5dRWu2iJpBy/eh/R8AcLkSbY5FrBRGid3SuQW9SV21NNm3G42uruvBSJvv2okOOmsdPKKDqaDJU8MEiGtsAc2tNLqULpaBy1Npnlzr4qcefAzv+/SDEbj4/OzCFZWnJwKnAMBfTIzhYs1MCE4Ndznpx77bwJ7F3FA26Ufz2POoNEvN0Lk0OR+NCayLcHuu3sSEAJpzFUGBJNCkgtAekRrSqWFP19veLyNQbXIuv9E6Q55f/eL8UmnHFNBRdTStii1VsK0KoJCP2ATWwZ6iBJ4ePx8HBRJjayCAi1H7KrTz1NfNlaed08BsLdDt286H+33y3PoqzTUBWFp5aKeHP3E/3t74JgAA1xlv+cobccs/O4pd79iJl/3723HbL9wCyoaf82D/z2F27w8kJueXATQFQC31aBSaQHhuK1RLopzHY647CO2jdYaxEWwguCQDA0HAp9QtSGF/XNQKALXRvyb3bDP3O18PQHNN7EqnCs3G2GhcPLjkzP65CHVPTc7X+jGIHpVCs5YTrrVxFZ44ATQaTXAv9Pe1XqLQFG2lCkKf1FWrM12idqhkq9vCp9/1Gdz++yt4z65d+NVX34pdo2qErbSVLiMFUY9ZqHmfYQIiEpHxj4YywAUQpAoTEKpLQiUQ8f9cYhHF0twdconrghnIhSWA+i7EUdnFMZuBAzzS/BWu2v4Ym/93dchUpC7iIEMy/2oNqAyD/dMR2DVa1AAUuPM4oBRW7z5k7yeApgemFbDYBiMJy/zQZtJ0OSa8AHSJDGbRn0I1CWxdeygbeEX6ckQCoqI8hgpqvpmfX0RndQ3/5Q//Cya5xJ5TA0g4zYANlqKTviFy9Y+2RE0D25X9YaC1B6+M+FqyYMJESR9EMCNSaIK9NUsEKUn2MeBlS83hc3z543rvpd3VUc4rlGbMqFRoqvkOdlkPJJGfxyqgs85Peadg9AAlUp/FoNWNIWVaTuQdo7rIy6jLTyk7PyR+ERO1m8xTdu/YnURoMw8fE9WsB3uJ39TIvQMDBOtbUg57NwfZvsHsoH2on8NUaXvJ5F1SuK6UDgC5dyG/Ywb06lB+qRIc9v7Ft7zZznEMrBcUyORg/xvagQhG7SjAV/11bxLFiTdHaD2Q544R4GaeAgyIoDLnlRljOjLZZ7x65Tz0RFv0I7LTZNpXACIFgjKbSYkZtn8dufNV0hZEgC58OXmwBCq0v1C6OglwM9x/9c6gmH2hwbLCeA4B5hQUtHCqywRwGYNx16+4WAzuKYaSqe0ePRbKE3WZBLy6IFUk6yfaRuT7pfEuTp88BV3bFn0fXJ3wFtDcSqNLKQwCLs+P5s8+/AR+9ckT+Ehi2nrflQJNFzhlAAy4j0F9JwAzx2ybvNSV1Wm8Tfjx9xMWMkNG9p4LI/fJ5/GjKc0Y6wOr0BwBYHHw8FytFQHNKoXmmviOCjUShSYQgM+JrI1cAxM20nmlQtMCFtIMGjHMBGxgIBUinacm56mKdZRBimSAmZNTDCUUWVKN1U2gT19lmG6vr5y83LRjCpitBbp99IkAVT5+bq7qEgDDPjRd0vcBTTKda+d37UBzXxPX/H8O467ffSX2f5cxuVhcYbznZzRe8yMaJ84xBgXjKxffgNlaA9vmwz0uD2iaaT8rGAOMEGhaeLiq8ktHORfzY7lJCk0AoG54LkNBgewQywuARhS9WybXVitZzZuSdIlRWkjfL8OcmhdAa2K04Mw9Ax6E/rqWBgXqhuemi9EEl3LJmZ2vdYEedkAPQn+PgkoB6Is5YaCNOeKNGwQ0e9tD53x38z1Y+fwqXvMHXfzEfWP4zoN7MJZt/aTaSl//RCDUXn43vE8+mIWYV/j5BX0NoCyGBhFgDCoqwCn3xGJVQANvRuflXQIAVgTKyVkNBcpJ01s/ydjVb0f1CrfmaJHs/aklii8XrfyNn2FkeSMyE4yAH8E4jSTCyuuvA7Qwl3ULTXfdYB65Ej96JOyK/N6JayjAHrbXyNaM8lEkmxAMxoIC+lm7AmjGgZqUBiazKTiT1WqIZvOXqlZJcTzryjDgAXrdHtrMqPU5hguuLYtZ3My7h+GVgI9aKMcAgHWBYJIbg7YIqgt4kprQG6CYw4A0AQJYAGj7Xf2Nb6toh/gjw7SfgwsxaOWobQBAswKpmq+XVymKyMgqDfYjwFfYZCBxTLQf7AhmRMDY+60kez8/1lQaoxuywJUuCJQyQE5rO1Zdm4UNC7VtB6qS6e7iWflNhTB/BKcCDGbG2ttfHupu154pjI4VmhzlG1Tipv5q917bFvGzAZugXbse60ZtYOYO64eTo9KKazncQyg0NWvQ4CKG4L2dj1IFuVdgCuVoxIZhfTYSYeFdtzpRrq11qOtuNr871Lbtpo+yG/ehuJXjPBwU5dTicaXXCFjIjJY2anPTLxIYLjhdbN4/3A5+bh7MAlmO+W+73Z4nTxPX6a71BRzaz5+b+p80FTGftFRwx3XLr7lOXBXmIrexZO6koFlHMFwCe3LXAmBipK4fZGKt0V6V2yruT7Jm+eLkci3UQYLxaLPK5LWSM1RRgkmACbdhaU/eAppbaSSpX2r0Kxxzv1CFJjPj0+fnK49dKdB0C768AFZ5Daq5G4ALwHJli/dbjwALVqF56GT4/hPP418w8sXYH50PzV0zpl7n6i1MCNHoxYrn0JGKn1KNTDHmfY82Yj+as4Mi2V005p+AAyyjH7Y7p4DVLPeRzpf76ys0acQQSgJNbu1B2Qt0TPaffmJq2ieF3TPDY+9KU6NOWBa+C/c/2sW4dZfw8bMXh56ZS53Eh6ZLdDqMtevef2Toum6P8a6fYvy3TwH3fRX4x7/D+NTD5tjFWhPNPjBu/cGeXOtCM+NjZy/i/ouL65YFAEoLVesDoK8UGiMCdl5ZqxTqa6ENUh+aawJw6jIbWVAgANi7PdRVi+hIKbAfOIXmAMAIQZ1Lrq06Ko984zj3IFJ1mBXAWHu0Ck03nssigNPUh+ZiR2wGDUbnQxOI/WjOd3ei7EmgmQByUc6+jRp/48GN6eODfWP+7x0q0PHTnzu9Iflvpa20EamIfIeJhaZ2ai9rJgpGviyxoIB8dr2/ir75mxyEgshbgrwSjtCxhQ2AvS4BmivdHvaed+yiIpK0zXPbApDrAEeGAZz5fPi4XESHAEXk4CYR8hIoshjqUAohRJRzdx1cLR3YIANo63kArZHJqIDIYMbh7HD4jKQOhFD3KqWPBVbMJRYzjSk004NIzfkHnFUGepHYhkBQDORHbwO36uAEQjiTc1J5BEQ0lzEgESCyL/1Nehgjn1dpMKWHLyWcv1ItQJ7xlRpUfhGMcvURzZ3lNfs5wLMIUdkyZIdCBPaq1DrTARUaz+lZsKLQNyO4ED+jhc4YSCql7ClauDWYv2U/OJe/2dP2k3AoHocEwrGsg6Aic0mYeQOAVEWmJuGiGZgL69dPnJIpC1lipSXAwMCY22U3HA1Fd+4J2OXvQK+rR5gT2EOpUM5y0u2WMjC4KMofn6ecQnMIkJlzSSmAgcZbvyXcI9owMH9Pni0QtTmcGrX6mTSXVbgfURx1WgIzV2c7Djkd20KVaZTVKr2V/Wzgqm7mcV2JfKT7Ca7FF+oYfkcbMzJr23xRMDVf5rhdmeKNJ2bGc7kOdQ09KQLVrjwgArIsGvduDjSdlYByxTwr3yfk/CDHPExgLKdm1zFAJjEHABCm6XEQJdlGjefOBjcbCMpnk78p8yFsg07kutE85ju+GwpJXd0fZNro2mfknCTbL/47eg8NRTmXGZtUX+wAtZ3JoQCVt4DmVhpJqjI3B6pBWlV6brWDC0Ix+Ood09hmnZU9u9q5pO++9ZJb8NUKYJVXwbkZGFdibu7S7pkANG9+EqivmUXmh05fiEDTUFnEsZEqNKfNv+dqzedVaHaE8ohG5EMTCBDjdBLpvM/DJrClNT2uFYDaBKC5Y9pGOncBSsoy+qG0OojN8kcLNMUrqr4HJMZOZz2FpoV1B/dsbGeiKfJ79nRe4y4bNvtCr4+LFe4LgFihufqJefRm++h0OhhfHfffj103PnTdj/1bxr1fDp//4OPAH3zMPAOnhnZm56c7PfzmUyfxXZ96AG/76Bdwz199Hg/PV5vbaws0DfQdpcm5WED1JdCM22m5lEq/2qbBcTUI42gpgWKl/YFUHwCqPhrgW1WujooD8bj3R09A8awgtBujLZPbxNFFUCGlJudzAmhSJx/ZPAkANwkgeXFtO7gvgOZQUCDzOSsZfZjyb5TJeXNHHQvZsBz9wgNbEc630osnDbyiWyhYUjWlXZju/PAzMaRyiiv71RoGuEB2vEU+NCHEZSbgyJfoVMhHsFS3MDdnEo6Vu3Djk1YbI44lqMUCSbeATBQ9KOUSMfA9owULbMUuFrMSGGQ6WjAO7fuxDqbfaZAZqfxhFovoGLq5RfR1pXmRTZAwe9Jx+2ku0eLqzalItaY1CIyWtiAngkbSfJFwMW9Ckz8YgYcQFdi0bX7djQakiGdl2IXNP1Nhc5SBknSkpPIlZOAYzsfPJwGADMYaaXytfCrAGigPIz3KYB3un5pM+wA08B0w+/6/bo5F5p/hKhKmvk5tFvFOe+r0Y8tAobHKfUD5eODi5rZNxbVFEQdk8hHFdVClrRza5gGOCwwVZzkMSsNRwoIyGwUpbHJqSg/TgNQS15cr5Mi46YMXwyk6RGlnGVyKzDEPSlsC3g8VU6q4KXp2zg9j9XUC5Mq+QtZEO8tF/qFczk+m8VtJIM3GD30E3WR/MNc2vu29om5hEyUqHwM7jukwpL3yDcZvZQLMfCIzp0YwDdpsjth2iNrW3ZgAdE+i+f4f8u1AAsu4uWSNApTt3uBAVoU7BNt+UWJEbQtooLho4GJchSH1+rFsNRRYREBPlcSGjWZYfe8bbHCkeNzLctLkNPRYPYwVWy7psoQB1DhDXeV2Q8yV0OVHIkgTwnOOfFrG0LS3f2f1xoIhmgARZtBKNt8IqW/U6H0k3SbItrBtZPzIEtJOw1LhSxyeEUkFclRK/+nQCaMi5yhPC+m3gOZWGmVarTA3B4Azay8MRH7p4qL/+ydvuRZ//pa78YPX7vffXYlKsy98aK5xx0uXryQgkEu7Z4BFC1lqBXDDw0ZuuDQo8Mnz65vjSoWd8aE5YpPzegv1AXyE4yoIFZkwFtkIgaaZfE7XzQ9fGRjoXDcGrYVQjKnm6AHLzilj/upMzhkxnF+L/IxunkJT57sAoQ5dT6GZFwbW3XB4GBReTZqZUR7cZ4sZDojOcWadzQUZ5fzi75/BIz/2KJ588knsVcYxYJEVaOyOO/2Jc4xf+2Ccz+IK8Kv2u0IpLGe5DwxUMuPXngpOor+6uIJ/9ujTleUp7Q/FUY43IHluWiGzi+y5btxOy3b3lTSj7G+eD00u675M88l4G9gNhLwAshH6h3VJKjRjoGneH8ti7NV6o9tkcWlmwvzbpxy1vmmjThH/tJqXm0Hd/IrclbzQJBWav/mpO1HUbvKfO0X8481tkuUDYM2arcnrryZNjQPHG8NzytjqGAZLWwGBttKLI4XNR7FoA4uFL1s2QxhHAtRkJG67Nl2EGeupn7ghgFBlGUDxeQDA+UQ4qIvIXFwuyF0EXXtzcW8H6+wnHa4jpgigOgimNKAzik01IYCfkdaB8xwoNaQC1FhLO2hk/BS6yMoB7dkFaaooi1pLwiWgQIm+f0YV7xl2VRWquASgatbRpc/Vx1Go0sIfAYGTR+NAXueW3QFcOXZpVXyU5R48XHdSoySGV7g6mOptZJMbCOhhov6W5jl5PmoUmgQXfTuus7kwAEDDMJMIyl6VpCLIQgh5DAFdFl1q6DGxuZ2y/jsjZVgAu8WucdTf/A7c3O15YOpBqwUrc9RBVYrvaeDFYO+0OSb69AAD5H6JTtZvobsqBRYpeHWXhb6y6/G+AXIcILHSMBH3CNZ/bBhfvq8yDwFN175MYkPC+/z0ZyCYXbtym6P1Poe5hMwRuV9AjAD2WLYZef+XRMrcsmRkdpM+9IEEIgJQU9LnYDKPyWeiu4nZcqhRrDoW6k3CkA9hsvOVg1vRlOCfkZ3H6o1wr0jdaMbxadGXuJ6BmKCr3CH4jwLoC3cI5GAxAKLUfYWnuHBAm1tB1RxcUsAHkLKtYMahV14m4z7uEciP3IBi+xiiL4Hgj9KNW4ZVaMZ5xs+Ao3yMultUR46TPENpgzqmgNFFZjd3kpshMFYJ0RvDHF84XAM4UexGeZqceuOJMte/D8l/f+CDp0KAtKGJmsR1ZizkZRJui+D9MwNbQHMrjSjJhei+VvC/d6rzwnzefVEAzbt3TAEAXrNj2n93JYGBenZCywtgjUL5HPS7krRrxkCWFWVgyV0PhHz/1y88gmdWqn1pRgrNPqDr6orN3p+vfIDxoQnAm51XKTR7MthFqUYWFMjBlbP12OQcAM4n0Ke0O0u1Asgam2ByPk2RyTkQm+WuSVA/QrN8ANgtfoeUage4H9pmVTyr1IdmTynceM3UhpZl744c520fanVb2FkGO9sz64xpqdBs9IBzf3Yejz36GHarPQCAwbY+Ul82/+q/MNxlt1xTXZaFrIH9Z8LnJ5MAXGe7w30bAHQeFJo9pUbm+1ACzV6e+b60kIy5FfujsNUFChqtyfnBXeHvbm0GY7bJpE9jZsagFgKVZZuwgeDmpzWVxSbnFtZdEM+yvUJojdgM/p47TJ07KkPD3npIoWnnA9KMclDDzMbuHUQpBZLF2Ov8391UoVkEC4SOhffX7ceGpOlx4HhjrPLYV//yaxtzk620la4yHXvabWaJhTszYs5pANyd5Y4YtElffW7ZZOGFNP3zfsgExIkhQQA8w6a0IbFQSwGxQkhFnEua70GsZUWQEoY3Mwcs6HSLTnYtki4Yxb9aY7q2zZg7rqsctXlm4d0f+VxLQMrajjaQWSWiNGGmePFKzfAjajgisqn7oEbIj9wwVBb5jFEsARYUps8k3I9wlsyLZu2OfXDcmLR9Ot6XZ+bdFLzqUY3SmZwLniDhYZq8/0RbV6/KogDv/DE4aKmB7tPiegnrhELO+n4Mx2S5ArSbQfV87doj832KTN9g8urbVInm4AUTgWo17OsPIMPwOHN6zRqnVKyAs1mgUlk3cEGsQu/scQ8NsdlQSoAl1aheRWgD5aS91d5j71d7kWm/K87stx4FyEAdgmlCkgMMCEBTfh+Ne/tZqiS9mXxoXzdOvvUv2SvYIrjnPjKDKA9AO+pfDsiZ3kFaG6g8pEwsBOGIVXd+bBPQvX4byvGGbysSrMkUT9R33SAwdmNBwnZnbk82UI6A07LGzoemMeUX5azvgnYwTSrsS/Y+T6N5s7Jccq5xZ9pxUtsT1cUDW/83A8uft30i8aEZ7Tq4j07pK+BqVCRbCO8eIO6n3s0Fu6YuA+STylE3v0rXCQ7kpaA6HQqZcyci2lP87f09R2UT7azZt9Hsra1EFS6hLwG6BCvg5N3D6mbWhXh0jF29use+kbuwoU0ixvs+wDioDoAHwSooBNezxdwCmltpFEmq2m6aDCu+Uy8wiMcXLy74v+/aZuDM3dun/XcPzC3iclKhNUo7SGoFsCoiel0N0GzUCTMTwFmrNrznsWnUrDJttjfAq//8s/jshfmh6zqJ30M0R+MbzqlPl7Iaegre7Hy+N4h9zgDo9sVuUKFGBlhcIJCeyrDcJEwthXKcTxWakWJstP7zgGByLoHmkgSaPQE0B5un0BzQNmAQ2qYjyhH50CyMD819OzZ2itu/q44Hx4PMb+ypUJb1FJqdBNoDwHP3HkdOZkFEe5v4pT9k/O1/pfEL/4kxu8BeidmsAx/6eYLYC4Fzwzmf1/GyR4eWWj4tDaoVY2UufGiSGnlQIADo5DW011y5YgC1Yn/EtTrAQDFqIwx6dc1e4OV2PbiktmHcAs0F0beXBwW0HW8TK0BtE8ZbvUbYNjnsQ9MpNOXGS2tFRf1hFOmdrzH/SsXoWgI0F62rgLE1oEe5V3WOIu3bAbxCrOMLHZ5JJ/nx5gBnbQCsqRxjjR5aG2SiPz1OlQpNAHjoTx7akHtspa10temjv/qJ5BtLDvzaPMCfNJr4sArTnWdhp78ugW5cgEAopeltdHWSF6yaxi5Qh+5IiE3Ohc9Oo9gKi+/gl1FgEVFXZ5E4tugiutuzxu8ElJhMNQO1HP3D2yIwyQgmxEZtyIDd2DT3FtAjCRhy+s79KMfMSzaO1usvHk4pm7FQp9cC8ttf4U8iccyn7lmrnoqjnMctTDhuVV9cz3z93HLA/SZWzx3H2Cnjuoa6Cj3uBXBoOkRc5ogRaA+1HSig2E9BKFVkhq2BwuzUqutvhIQnBoINR0gmUhFskhg6RzbUzB7uZOPWV2OANqYhaMin4JDqTSkDJmiAWOkLoEzMVFPQJfKMfGiKY33uYYUGvo466lemXDd9dNW2n8wzapzkb21NdUVODatu1OW65ay3q4UBhLBlIiN0h0xE32SE/s5AHDBImpUTuNQgqooOTyJ4EYH7ZzHx8S+YDQMg8neZmpxHdfYuN4D6cwu+TXJkmNE5auSUfOSD0MQBiRD3d9DwvKk1gnRaR20bnrnJhBxU0wJM5jOIYJq9meoVdpyKeYyTbaKor9q52j8H5981bhsWMNxB5aDGjiprI5nLBtXADTeiOLJnyNVEBB6ZUbvztWg/cKJi7gjqWgZDu6jnGN5Y8CVPwaYdl3DHEiVz9J5Dch3MM9bQ0TEDlcP1EeqMFOOhjd1m0npYMZpXCLi73O3rSqmrkyQpDRQogDIWsHg3MopQbgHNrTSKJCOc3zgZdgod0PzY2Yv4/nsfwscqguesFSUeWTDk7abJMUxZ35kzjRqOWIL0lYVlFJfReXti8NcKYE30gJ3TV7fo2z0DfGncRMNrFgq3PRQCJRTM+ERFJOjU5FyNCB5sn3TvNsJso45xCzRLxKAOAPqFnLizkSk0JahbaNcxLdh0CjSdQrM+AGqtzVBoGpNzGUBJqtiWJNAcIfQFEqUfz4BFQJC13joKTWtOLa/diLR7G+G+iRDxsXF/aKD1gKbc1HBqN31fKOvnVw7i7/wS49/8N+Anf4Xx2r/FWLEg+YfeCRzeQ/jBbzKfJ9rAn/8C4VU3G6B5/TNAe616UZQG3wHMQoWFQrM/QpPz3WKDZC1rYMzWaUXr2B+rMn+3O4BW1T6HNyoREX70PWae62QZxixkXWWNge0/0mfx5DJQa40OsMp0x3WmTA0x9J0vXVmm1urogeZt1wL7d8YKzbU0KJBdYI2vGt/HMxOjayciwl/+C8If/1PCa48uoo9gCp8GK+pJlyoqw/TYxvWpqTHgRLNa8XP+/vMbdp+ttJWuKnkrFweDrE8vxxP0wC62A1KAvyIsoofVlMLPHjgGUWUHoAzP5Ob9HM0GiTkwdYKaWYuI0EhKFCs0ZSK4JSnB+MdkFU70AR/YQUST5/RsGS2OuXEIULnPkzWjdBtqUaAGCSLJAkBJNmRdK97HNvBKHOF6+DR/B0JYqEuoohH70ASs774Ag8gGNiIHFYeglrsQQ387s1T3vNTCIurauvdYAzrNPQEGUdo/httBRjln6xuTSAFKQXt/hLJdyLoPAKAUmj/1j0IgKzg47cAB23apgGIiLVEPs7SOtQplOF53ylgLbbSBAlQBp33+tk/pRBnned2Q/1X5D/u/I0WXOFaQMW39o9opn0HqY7Bo52guuycgYBABas8++4mijiYDXQHAvi91/HVa6+h5+U0JZtTr47IaUXKq7WKmjezwtYCok4y8HI1LwLahOyT6EZl7+ijnchwq+LoSEVAso3luEpQ3fT6hXEUEEX0iAGIeyxe6HoTuxDjGkCH3MDUeL5wBulER/ZCc6jOcq23/Jxi1YVQ/eZ0FwXLzxh3TUfAd0W+YTTvYPR7XRNVTSmjn/ZiCdNURP1CnwnTvC8Yw9DMXSCWkg59eaZGoh0X2AAPZvgNQbt0m5lCnmg3oNDebBn5jIXmn2aLlYogOuZ2wfTj2nenKHE6U/mMjDOn6cOIv4Man7LMoy7DRJWEnWZVk5U9iAodIDKE8/r0Qzx1U8WDP6XN4IhMKcIIv59IbrsVaY4QL8hdx2gKaI04SZuxq1jFjoeTJtS6+dHER33vvg/jQ6Qv4X7/wyJBS8KH5JRT2u7u3xztkL5+ZBGBMth9fikn9pVLkZ3AArKoAEK8mKBBgTIM/Pxkib33DL5/EwU/9hf+8UuFPVKrX1IDQGFGwiywjWIt9nK+3osBAs4kJbK8Mz0GXhPpwDIgNSdKf33yzGcHDucQEVio06+0RhhO2yUU5H18NbSH9jc4KoNlYzjE+QugzNQ4PTJf6u6BlQJB1FJq5VWhKleBGpJ3ThGPNSczmlih9esEfWw9oSmDetr8fd53c47/7cmcyOv8p+xu2XgN+8ntMu/7L/43whz9H+OrvEN56F+G6/cB83kCmgdu/Gt+Pux1/3yH1cRKEqzfCoEBjrRAsaiVr+k0EJsKC7d+9UsPF5ml1AZ3ripw2Nn3PNwI7pgyEGxdjbsEC4Auin08uA42x0Ss0AeCeO4CSFPJeGEvO/+qs2OBobALQJCK88zWmjZxCswf2qo1Ca6zY1dv4KtClbKQKTcCMvW/7BsK//pGT6GGAun1MvRRoiqB3HZVjx9QlyMFlpj3b1jc5r59toNOp9pu2lbbSZqULFy5ADUoTmFEG6BCmdFyuAHbRzhQvxOTC1V9LVmEYKdbC0hMEcNnzSic54twyUYINlEv+KKOAC3AilZAAoBhCVZNCjwAJ3v9HcfAbaQZrFrkmIvKJ62PfOHFcCrOoXp2u+TyiKOdRtRnjJPKKuIdZWJ5T8nelg3IxLOaUalZAMH+dXgWxRu0b3iyeq1EJReCGXT5kFF8JEDGXWWAhfpMz4BWazBp3PsSRSm5udg5lbQYE4aeOOVE/StCamLuzNuc2ZLRxd1zO4UbZpuvu3uL3eBSAxmVBHv5EgETc4ctZdYBEEOOZesOfpyHcMlACmCK4A3hTYrL3clwxAdcHvyDvHeCMB0EUmsHd+z80zuGbv/kd2LnT+shRBHCJvQ9dRHOJwc0cp968x1wqALRTrNXvem11HZLo1G99pmlOIvKbFe5sCZEaqunrHT1unz+hnGwiO3iNOBT7sgUYL8N+1+ymjdzGiwwkY+tg+p6rW3iu2rkdsNdmagrIagg+TG1aJ0iUaYYCUIS8Z1tHAiQN4dOXw0YJAHR60E2h3pS3S/y7eh+ezlxcJbjFcTJmgJT5d10/tKFuXkkp/HdGQbWSpdjH6h2/aXME28Wck4I6l497DWg4eEikgqsOggHAkem4Nqpke13VapDsLZHXgFJ7Lumr583dLVi1SmmTp5j77Zhx805ewLdb5B9ZgtAyaVdfGJdlmCdv4KnQ1kBQPtp7MzOuf8Ydj+dCeQNeV5+Z1EeLEernDneiuTXJzzDzVBH5UCU4dxys1NC676WStoDmiNOKgBnjeYb9Vu53Yq2LH/jMQ+jb3cdz3T4eWVjGQGt8/70P4W0f+QL+5OQ5f600MweAV4gIDA/MrfOyrkhd4QPJKDQDrbuaoECAUWQ91ZzERRs05RW1V+CJD/yJP55G7gZihaYqaGRwBQgm9Wfz8QgepoGB+lLCrtU6vkmuPu2YMv64AeBCre39+QHwwAcABpr9y6M2AOrtTTI5z/J1I8LPCrPh2vJoA7kQkTc3Xepvgx6E57MmytHTUu3LGCh11X06TTunzYvyi1aluW029I1Tq9V+YmVUbwc0dw92++/ONKojSP4v7wau2WvybzcJ73kT4cAu8/m6ffDBiaTZuV5aQPGEUb9oAGs6frH1EhcPPaXQGBGwB4ypMADMczvyETtrx9xyAns5H61CEwCaDcJ3vMGYI49XKJAvCP+1k0u8aUDzG243z1b1Q59yG2KzYo5qrKqRBwUCgHe+hiKFJhN5NeSieG5jq0YNPcqgQDJNjDfQ554Hmt3EL1hfuFRZy3Ls2rZxP3OuPwAsZHUsiUjn3aYZ1Ieza3D8uRPrXbqVttKmpCeeeALNsws4el9iEcNarOECWEt/3QSzcgvcVAPIzc7geia4Tt2Tqo/EyeFPrYFW8B8hoV6qKLMryuE8ogUwkJXifgwPQYyJsxaqPgxF143agBllzfmCS03/2F9CWgsVV9QMYBjQuqyk2bEDNzF0C2UazspDMjh1XmH8BTYT9Y2EVA6KCJNzCYgjRaAw4Y9W8GSeyc5ZgFQ2BKfl44jhVgxVfXAkX7TS1FO1YAIraZx4y44YqAPWpBhA5mByDOQ85PAgzwXdGHKCEErdOBTVIaoRyz4gxohQxvr8XH/RDKrXA9iEx0mGa4p30viFftLPYpASl0qj3jGK5f/4H/9f/O0f/TuY2bbN6OaYMTbbw5u+AKAsUVsWAhFvMpsmOchNIJl5oVadWWBse/C8zSL4lYw3B4w/z6H2s34rndqMCg21Qzgp97Au5LOLrNKT4zZK1bVSFSdN8ofajNko9LJg2h3Ok4pJRnbgkL9OFwWgFG7581XbV0OfUgwoe29VwvdDAoB+ATWoBlWcwGKwtuNQxf41AxcEoALMtePRD6P+qaHAPzseu4DVl+8zYE32IyQbOuImZ8dvAlF9WD1cdJHf8jJ/BQFJYKN47pDjywSoEgc1A70+mp/7WjRGHfA23c8MdMpzUMk2/+jBIlVoUpbZdgv3C6pf8zkvQ3WHIK3tK+1VjZ1PrSXxy0T7CXcLh3hCzJMAl0XUj+Lrwto8ms/NQXFMNFdivm9fWPEcLsqfzmqzqgBRDdEmEIl3MzN0su57qaQtoDniJBWaY3keRUVOI1l/4twcPnjyPD50+gLun1vErz4ZFkepQvMVM2H1+ND8CweafbFTUSuAtVr4cXQ1PjQBo9BkItw3YVSadarj1uI6f3x5MKzQlAFTqBidPz8gKFAvqgYml0M7zCUKTQk0U38zG5mUIm+We1qNV8IVIFYg1Qqg1h79sN0+aXxojgugKct00Zap2WXwoDZSH5oAcPfR8HfJQSHVEX1KKmvzAqg3+xvuj9EB0i/YPj6xYn7IAcCp1Wp1VpVCU6bTNijUV36b4Ib5RBv4//7A+mW/bj9h3gNNgCzYLb78AHg1kMPlZBOhk7h4GKUPTQB4/e22HFSrhONDbZNtzot494xRH45VjDmphpxaBhrjo1dEA8BrbzNLDgzCQnl14BSaZkGRlYysq0YeFAgAjh6KFZpAmK/lXDC+5kzOR18mAGi1WuihQM0+pq74YVdqxsD+WKwNTLn279y4xrp2HwAifM6O/x1v2Y7trzawp4kmjoxds2H32kpb6UrSzp07ATBeeTa4RvELLPd7RoC1L6vZAAmYhkAelX1Am806qVZJZ2rWZfi9lChEOIGUXLc/fGgdJUv/vHFlyBL2leFvC+SEN7Xgg0yWzi1cXbUpLQsJvkhg8X6M/IVGC2Cjbpzftc5OoE5AACDM4RNgYPPcjnF5IwTA4b6O20hCWZ360NRsgvnY66INebHgNnDRBcmw3zvzbqv2Uc4HoIeIDNbaw1Z2Ck3XPkI5Gi3SLcAk3Ue7KFCnhq/7kFk0G0jASoFXlr1ZOQOgRAVn/M0pmIjXAYoZdZerKAHZdNR+AQZJAGJVwtHDk+osRPdufc/fMJDHVZGl79iAIYhV/HziSEbmriLC8c1/ueabnBlolV+1qmBR99lF7Hxo3nwfARICi/xdwCU3BHro4c9qIZJkNgDqFoxqbcGN42vSxD1mceYE52fSwdRBidZ3fA9kcupNoKIJIqAZR6cmZijKxVWhH7F9JkQEZrOZoduZaAf74JO+Unv53f5vrXuAMgDEqKbDeUoDPnJ9oaFzZcvkQKtog6jfJn5TrRk2792O1HWBBKjGDYAyY0/OTeWq9xfqrsqKEoMD02Yqt3OxGXoxWKOJKXGvBDC6e/ROoH53CK4IiOdLZKFYMEGPZvzIl2hoByo0WET+HlrBMIC8NlxXAcYLaHSotOPGzWPDmxouivzuC8B4x8FOaXIe1I67aQrbuIWa2ISSAdLYur94Ri2hg0I2BID4uWoBeofcGrjvKfV5K4qvjBpahr/zF1Os9I1dMZi/TjenQfk2cJS/nV9BQ5sFL6W0BTRHnKQqcbyWYX9rfWnNx89ejKKauzRZyyP/mwBw+8yk7+gPXYZCU8KxfAAUY4FiXjXQnDElun88/JC+cRB2RqsUmqv9AA9osDkKzaWsHoG6VKE5ED9oRqXOdMn5eHxWt9cHmomqrrEJQHNyDOjk2bpK1nk7CU8vAn012qBAAHD30fAcCkz7vztFaBup0FQFYXqi2m/S1SQHNI81Db1RDIwvmHZJNyhcctCu1mfUEqbfJ4WLeQOvvx247VrCh/454fveBvzxPyXsmL4E0NxnTM4BA91e+SufBv7iL/DDHxjDDb0D/ryVJJBLBMetn9FRjrlvutvUYU3lmBCbCBcqgGarC6A2eoUmAGyfJHRUjnHhf9SpolMfmu1NApoTbcKe8bOgQRjfayKwGgBMLAMlspGbnAN2DlA5WgJoujl8TswFxoemGmmUc5mazSZ66AeFpvihPdS/SWH3to1T2LYahAM7gX+z72b8n7e/Cnf+x1fi9p+4DXf951fiTV++B7UDI5Q7b6Wt9ALSwAaD23XBfA7iktIvDFks/OeolwhGYjNR4jWQD0AgFVBCFUIBglWnBH8OAlRhnW50s/hv4D9REcX9CEZV5ZkHkwcI3rTVSFgqyxKC/Zhzs0JAPakwrFD+HDjlAJ4spIUQjvoB0QI1Rq7m76HI67KUBDgVZloFE6039n0IbZVhiiLwEHE05xtOa2BQJm1tAAUxjEKTQn2JdXy/1D1BVIEEtHIJYsZMbx4TtZlQCWdCG11HQEYoP/5RV0v/zIcaiZRvo4h/mQ4at6WofzgggCazUV35PAQgiSC96yMOiDKkybOszxQ3PCAz1ySqT9FIHtw4pRoD0/0PCWiUKBHl/QgV/vYobgNpvk2m37no29r6YiXfPsN9Eg6QEgG6Z7uK9eEqf2uSHVfSjyAzSusv/cnGhKlDZBIunoOu9qFp2sS5mjBtohg48/odQ23Lwr9hTFMBXQyMf0abv1Q3Epuy3/qhVVDBQK4wc2JgishFaNNM/K5wLg/ks9QaxYEd6L/tNYk7BImFA3RTnKjcScyv9rrxwpn++10EP2+Fb4DmN31buIrDhsBDdCa0dWqWrAjeNQiZsa4lHBellnUlXx4790Tm4RLXGQipag3jUkCwZ9NeBmovootj2RrMZpM5IXqurj/Y67/rg4wDF2u+jNFYs/9qmPvlNgCYnHvNCUZNWYKjDQFTLvFc7fwegGYMO0MLkVV9Dh8zjFS6C4jT0OZVYiXw0PhuQLU87I3qANN3t6Kcb6WRJKlKXPvEPPZQvOCZrOXYb1Wbn59dwBMV/jDv3DYFYuDk753C1/7R41h6ZAmTtRzXTxjI+cjicgS9LpV6SSToQTs4Gbxa81wP55phZXtksNf/XaXQXJHqyGK0cMUBzeW8tq6/SgAQFs3+ZT+q5NrsXN5CuwO/Qz4vArpEELoA6psANIkI+YSKVHVzFj6vDAp07CQ7vWj8MI4yKBCQKDQRzFo6ApJLhSYVCjsmNx6OuTFyMW9g1b74ti+YtlgodeU4dOa51erMFpgI732TyeNVtxD+4z9QePMrLw3SjQ/NMFhef6KB9/1+B9+0ejdu6wcfVUtFXJ7ukMl5hsYIx9xb7zK/PVazPDI5v9itAJodgOqb8yI2EcXXUWgKWDe2TBif2BygCQDX7jgNHoT7LfcGYGbv53dyBRio0fvQBIxKuKMyH50eCNBXusQYX+XNV2gKk/OeCr7o0vdbT2VXHewuTdftBzQpfEFPYWVA2PbaGex620409zZHvgG2lbbS86W+fU9HpsYOUDi44dVEEky5P93fzp+ggA0RtGR/yCzMQ3Aaw4kEoIDGjR9zTpQZ6D0HkIJZQouAGWKF669m57OO5araL+BW0UeXsrCQTdbp0lffkHJSogwL+aKgQBZecIQLDHCZmitx22PJ/aTilOLvzSI8NoPltLBIrvHl1AESyVMwbP7J1AKyul1UJ6AogncKtLyCmU8+E/ITvugAoDy4PzGL1kOAmGQdxJ9atJ85q4Ri097F93w3GIzDH5/zbREutAAmU8g5i9qIOQ7CIxWtsc9OCuWOeABHkEUx0N0+QP/wjAFDkSaKEkg/DJQfpNP2PFgIBKR+8A7oloAspg13PjUI+VTVJ4FNEw+dQ+3kgjhNKPeEQi6qt3IR5BMQK8alB5oOFvulBXn4SSn4SpLr79F5vhoC5DHwUTwGwAQclaq7NBgOWIP37g55xA8Rlt4CYJx92+7kmLi3SgaMTWXZ88ekSXtjpcC3/qXpY7U+IysYOlc49KWeeXKi3Y1CV9yZy6Rvit+yOjFH92PZPjtSaHM9vgYE5njNTHa9E+C0/cAIMDpJ0vXDKvpBeZv2PVOJ+E9ixzfDMyKYeSztfwSgZP/MyRcU/jzWwFQ2jdfguhAF3l6qHSx2riTKnlCQSz2jjvKWFkR+fiX4/uGub/REfWUG5ECuP+CPmSNF9M6LVijSR2zEDeAVlNd/Yi3uJwoWjIc8g60BxRnJOYwIjW/8FmDtUVA2CdRCvBKngHfl3/KhuZVGkk6uhQAmCz//HPDHcTTzV++Yxlt2G6jY0xofPzcc7fz2XgP3fecX8eW//Qie+TfP4t43fg7//u5fwyvsCnKg+QWbnafmy0s1E5xkvAVMX6XCZreDc7UWelY+fo065IOUpOavALDSCUCTy9Gav7qF7VJWbf7q0kBMX3nqyHmDkwsMdCFvQjF81OX1FJr5AGhtUtTlxkzsY9Cpss4JH4ObpdC8bj88MBlk+/33EtD1hLkYlYTd2zZ+UvfQnwinrXPwXYthk+JsRWAgB+1a3aFD+OPthwEA33jn5ZVj73ag2w6D5Z2v/xZ8143vBQC0O6Hey2U85iQA3gyT8+1ThLuPDvtjddAwNjlnZI3NBZrjAta5MXde9O/WKmFsE3zWunRk5wK0MDlf6QywPCgwsD9QJpeBAW0O0BxrWrN80UaLdqNFzk9jq8ByVts0H5peoSmmbfdeSxWafaV8MLiNSteH6QfHTq1/3lbaSl+PZBSaEXY0/3IZzGmlKokYsfKyGL7Wr9l0dIylCk6XfgFm1FlyYVaitejAh8vPRrB1C1mbqYQbBEChYcvFAT54v2rAGg0wmzV8HmTv56vmgAgBE89xDHhO/1pYl0sYBAd95WJVAhh9iWA4Q/ofDzCkoocdKUjOC+2g/WKfLbScvli4m0RlkZCUqA1kdQQoleTt/mzdgpxqmETTl99EGDfLeGJgcMsN/nmc4vMwQNOaXDoI5lSsQ5s5McTxfYUBvu1W+MAfkM+cPIhiRXiZui2ugzUxF1/YyjhXCVV1jctF8jgPUGTPoJhpI2Abc7/Fgw1wpJ0d/j15lpZCdGpvnh/O7R+aQSl/Ptg22/eIeXnpROEV+ZOlAHBVAVApwV6JvZ+bxfGsZ+FJ6OMe4ihHdszn/9aYRRScy+VvUYouQ6RnAmJFsou1ECYTXyH37JpIf0iSAT6yD1D4w7krcD0gLdfg29+K1buviSE2kQdFbrwW3oImcV8RKc1DGdrIoTlAqnS05tYfLwOoLfYB50qKEQAWWx+qImlnIeanWJOzvukwIrPvBHwBNhq6duAulDlsEtm+WdZd5hBDBmgeNqo92cahIWK3GtA+x3gsxTCNvbqWECC9H/jxqNIGmpJmHwjKdxU5ozODSEFBBNKy5XJm0mTnWtKlMcUHrC9RMVcQ2b4TV9Zv4CT9VAN43x9LmB9XO2wKhd4Y6qZFv/UFRL5WxkBTlsO+/4gIu0sXUC/0YZTuHRvu58ebjt2EREHyduy082gfKBZFFcImCjESX6gvnbQFNEecnloOq8E95wH6i4Xo+Gt2TOPNzxOKuflzJzH36fnou4NPH8LYp5/znz96dvYFlaefLPhm9QwA4LZrcdXqEucPkomwususbveoveA10wYrVQpNCTRHrdCcNv8uZfVKuOLSQLRDlm2OQnMly9HFwAPE9XxoqpLQGlEk+DTNbK+hvhbqf7E/bFo9s2ig2CiDAgGmb951k/l7QNP++44wM+/JBVShsHfHxoOoVoO8GnV+m1GKzoT3Cs50Y6Cpmb0y2YGhRb2Aj/U+ih+9/nr81cx+tJvGX+HlJCLCjkN1//Nt6YEl9I6b5yIVdcuJYnRtEPqVAz6jHHMA8E2vMibnk9GYq1Zo5psFNCeMOXWVm4dZscHRXFEYa27OeAOAmUlAF0GhudItIxP4iRUDNNubADSVInCTMCbN8m3/mYsUmmb+mqiObbXhKc9z9NBFTUzbbmNjSKFJ2YYHBrt+f+gPT20Bza30IktvetObcPLbXxV9R4kJKaegS0TMZUgVXLjmZKMdA4PVAdTiKo5+eDXAOrdoyxVUv8R19zqzhHXmdUrKkiq1EBatvgaOfWihaynXImDAQr3k/d4xsO2RMgKmrNd8mZmC6fdtX+NIGcapmslBPZ/E70QL+dyCPR8w2tTwuKyqru77cqIZ6uzzD7BufFGnl8YRogGg8xz0gR0obrvWqHaq/NmRskCVsJ0m7II6+IDUWiMvgLFPfslf8mX9BE5881QCfeMo5zSzTTZRuDdZk2ZGUIEiuAyIlWEWWmYKJ153TdRaUf/zZqfrBHFyoN3Ck+a73jPUdobla7ByJt4MFBoz84zZo60YpjqlW/wNgj+/AISdkm/tjr0oMgoKTammJNsW9th1j4boJrV63Vcv+Lct0bJwH8yYPNPHX9Xngaj9hPm+CigMAOZUiX/wMz8D2RMYbPykEjzAT3qTyaoAuBabWLs6uPIdeqbA0T/+atw+WqgkI9WYUexW+R8EbBCseg3FTBs0pJK1prXKzQiM6Wc7w+rrxKelSwe4FW/aEKCiuAlhLdw+s4ba02ftncn7GSUGqC3cwDngJ9tFBPTRWkddJ3YRYVrcBDCzxN+3Rzxf7Crbtm7xvMnN64Es/CjkgYvkaCAfC1cEkf9Ykchl7DORcF1FAJVTP4+akSHD2ltfFsFbcnWEg27m/OW8n94+2SwzwHbhlhkBU+NyOWQaoHgyv8p3HsXPlcV/zZ/p3BGO6aENN/Pv4U8tQusiuCyJmLzp34+pOUxwFpWDrSuQyo0WmLaVrqgjVyMA0HsGKJfBfeG2BW4+NXXeMjnfShuemBlPLZsV8/aLjPoA2D4Xn/OaHdN4657taF4CnF33rPn3QnkB/7Xzh/77a341qDI/emZY2VmVpKItt1FgAeD2a9e74oWn3eG3DC5OG6CZUYa8ayMaV/nQ7IRVKRejjd7rfWjmz6PQlEAzHzXQDC+2i3k/QK9BgUIPL9KzEUeCl2nXjEKXcrQt0HDBk84IFeLMAqOnspErNAHgVTebf/sqR61vyiRhr1RocqmwZ/toqM/OKfPv07n5QTOzEF43ZzqxDHNlUPiXUcuu7X5q+e/hX/R+HccaRwAAr7gByK8geNGRg8pHW+5fCH14TJi2Lycm59LFg/ExmI00yjkAvPZWwmqWYzKKcl4dFIg2CYpVmZwvWPXhBTtfNbsMKrJNgYcu7drWQikVmr1BtOGymQpNAFDtWKG5UKHQHF8F+o0Sah3zrlGkQg28yTkQgl11xQZHbl0qbLhCM7ioxV99kfHlY7z+yVtpK21y6nQ6KNuNocjZzKVYw9nADd4UOlncmT/sisqM667KEMxQAfRL0FoXjVXr41AE7Wl+9Txaj5/H+GyJxirHC0YtVqAAYH3iebgljj1Vb6J073gBjpxZolsqc7kcWxNa1WII5EF4Kl8zkGEInskFt7nX9KI5RmLR7tfzdoGtLmXiLtbSeQHvD1D6Y0uj1wIIZsJyiS4AwrHb0h/IZuEcWJB9lrUcPN6KCydhCWDUugQ88I1T4XsPdhhzeR0KytQ8zwHk0HUCEPvQ9IGgCGi+/VtlSwjoYRqERBF8tOK0GZwyTBHmtpn6uMsYsXqJrFKsd9vhOCK5gEEEgPrnAADlZDO+HcOrywzMY1B/gFfdHyDi1Bmh9kXUyXx/YXBk3hwHJ0FYaRO8WynABgCx15WLpR9773vf+3x/LsXv2v0w66oWavhufUu4gVMtSjNbRTboTLjfj//4j4lyGZPzSTbq5siXrXCHwJlCvcPQraofigRoA3y2zZbY/lRYhxKZwChyDHk0M1iw6lBbWkVQ1netYXyBDjEYLEz2NYegQKRNKWee7gowHuYZjicFAMB56hkzYgunWCG4JCXgIbUs4Bb5TQ5zfhi/9de9KW4GOPWmzcs+54kPfQngArEaMqQyB1CrgXPl5yoJt/wtmA0whxs7Acv5IEOurkK4kIROC+BQA9syIaaiWOEqN4LyV94t7hIDTQdllevkUtEYJTu/ao3PvLEB74vXUE9oXYoyMqAZqwfH3A1DNm7OjsXGoa7rmP2rhPHFriycupawQKlvME7uYz7fXs4g9RMsZiZoXWCBhi32QMBQNHl3INl4NEWi6CwUS0iDTBHiOWfL5HwrbXia6w+8/7y95813MwvxOa/YNomxPMPb9u6Ivh+77xFMPnsR3/uHGmMd4A86v4//Y/CjeN8H3otn288AAK6b244DNkLdg/NLkankeilSaBaMVeWA5tUvRp0CEgBONMPuVaNr7rkyKKLdXQBYE74idZldtdn7JctngeayNTlX1ufi6dW16LxCmJnXa6MdIrceCX/PNRpRsCLXd9bED5psQJsS4RgAtk8BKyqYCjtVljSrnl6yCs1NAJo/8E2E6bG+gXAuwrHoTxJuoiRsnx4NHXeC6sdstPVtC+HYmbV4DFZFOF/jVWA82Jg75enlpuv2AQv5MNmSCs00KNCqAJr1AW+KQnPPNmBV5ZiQPjQtpJN+dZsdIBvfnBfxtkmgk+WVJufeX+Umw0MA2L9nHIMiLBxW+mWkGJ1cZhREm1am2nieAE3nQzM8t7yjUGv000tHm/IS8pZVCs16YeamjVdohr9/48+Al/0Q4yNfemn+gNxKL94kF5XOjC+wysQXpoMsTvnjF3BpvzYZ3P6nq/b0INsxC1Ly93PXHv3wir9O3DFcJyNJZyoKLvJQe1xENocvp85JLPbd4lYCJZsnmzJ7rdrgfAI0paLHXNfoMbLSLdpFeUV7arHIdWesbUsCttj0jZ82z8KYIUozdg7nBn5i/hFADghwZHZPLq61d4uUaOJZKhVFsyexKneqn0ghBwtNyPgKnKs1QFBgaDTf8e0A5bYssl0sVaia/tIgURxM6M21cfCQcF4ZwZ+qCMchBwbabay+WSjD2KKXQKDBPSOlX76nQrmhBYwkjefeZXwyXvfRRQAa19zXdQWRLeXLQPaQizAszaJZEU6jJ9qePGS57U9XDBC29bn1jIm5vWfPHuzcucPfTmvtNwxcKniAi+iIPMUgcX+6dcwQ3LCAhAgdLtAlM9617Zu+69lyLXzrrdjZzcDNfBg+EzzUqVOOI7Wbo8OlLhyvMs/FXr+0e870Dw+3TT86/MWurUNQdnICjYK5s/VdCvYKWAkA11NoLqgBNBe45t45/E7zHPJTC2geX/DHVxEgrLJx0H2ysH2we3yobbUeJLczz7m1UkZRp71ZuW3jhRvbyI7ejNlrxwCIMeMgqZu7NHslKXPI3xQvg/SQ6+BwOC7+FBtW7ea22M+oP9f6jzU7QqB9B6phJwCnoHQBhOLI7AT/kMm4COiUbjxBQFH3LnGBgASwJUI0p6ZBcxDmNj/vI3700fjzOcv3RTCvfwAno0aL/JgKXi43msx5oj4+z2HayUSALuQdAAj3G5FlQBUclq4nZNFCu28pNLfShidpbr7bAs1cA3dNGGeA37J/J37/vb+HP97xp9j++09E1/74J2/BL//zGbzzo+bzoR88iM/e/1m8/e1vx83/MERIufaLQaV59E8+hW/9+JewWqGEdCmNmL1qFV63HVnviheemg3ClJ3nH0cgk+2ujaIHoKvjl+taT8jyywxTcTD3DU0OuPZUhgGZXXgAOLUWq+oc0MxKRr05Wv95dx8NvzvO12cqAYtUQzXXNg9mbJ80/cMBzYW+UY1GPjQXgP4mKTRvOkT4o59+GF2VeXPTrnjRdQdSoZlhanw0z86Zh59omM46vRCOne2+EKC5hvE9b/Tf33V0+OX0QtJ1+ykKDAQAZbPE6sp5/zn1obncC+VzCs1RA83d24wSvNkDajbiVlWUc/TzkSq0ZZqZMJA1DQo00NqPt8llY5K/mUDzwJ4pDMoANNeKArNdCTSNgry+ScG0G5O1GGja5zUnVe3dGtr1599M29BU15HJeccBzTTKudp4k/Pr9g9/97sf3gKaW+lFlKrAg6GV5rMHXU4hY8bNgQe7YUHlTftixcvk2QKqTG+SKAXTm0cmgwCEBaMLCsQAdCMD9Qpf5K+02gFoKvgyHX/7TjBJZUsewB2HBTAxAzqYtu7lFjhZHAfzTwXNJd78aWNNESJY28IJsso6jktOBLTnvXzKt80r6RocPMVGBeZAl8gynTXYmaqz1O1QtFgdSqKcxgTcXNe/+yiiqMnufu6myw8gmGs7FZq9q60fkRKMI8f+vzoPbUPJ+PYLuiXXPBbyifYjszg3Eehlacjq9iQsiUGAVwq6cqVm5bu2g8ebcR+jWP/q6jfYOxn3WoZR+SkyUaaZoWvkgRNr+fuJhwCwf9beLDwuM4iwwIMEgphj2cDVVaG2MsAUWzWsvbaeA9/yGsIv/uIvQrEL+mHSeczhi+qszZOCOpVEe6nkucANefdM4h6oufBjIfi5BaY/+CiUBthaERZ7ptC3QI+FOXADNeyDMNMjxApN4bf33J1TYIhneeIMdt+/gOlTBUhZk3OVGUVi5O9XQEurPmUwlJ/HxKMpBkMqdZdJqfuYPD/AgBjZche1pb7N0vVPk9m38c0YR8u2ieun5Nsiul/qL9SNKaWqg8eQHdsE0HbXbgk0j4Cwxs5zGrWVIh7IBPDFPwJYrBOL4M+V5b8K0Tg5uy/DYOe4uPPwOCQG6u9+r1fGAm4TJdQ1Vo/GADp6BMyg0n3PHnSbZhfrNzMBuipE4NjPiglAjPK050T+mDl+lw29B9aZXyO3CWDITsW68H1Y3tu8UssoTz+nKDmvmOMP0HFMwfyol+4JCKHvN8kt1OycI8rh1NYu6RcYJPp/tLQFNEeYjgmgufd86Gz/bsf1+M3X3oG7P3g/dn5yF+qo4zW/HxOhg6fD37WZGv7PX/lZHD1qQOYbf/gN6MJAuNvujzvuZy7M4w+ePY31UuSPsQB69gfNRpicAwH2fKkTyORkL/iEW012DmSQkqLIMDV+ZXDnhaT9IijYSp5j+7z5e77Q6ArwU2SmDLUBkI84ovh4m3DHdebvM/nOCLC4IDwSHtTXNg+wbJ8irA75GSyGFJq9TfCh6dLMZBO9/rMhwrGYxLt98TIuR6cavfmw6R/nay3oGkXRu+cSf6yLFUCzy10cuOXd/vsrVmjuN9HWZaI7AF4LDyw1OU99aPaUGjkc2zltgCYBXqU5a8GvBJplP8dYc3PAUC0n5OMZqKe8Cdh8b5CoIY2fzc0EmocPzKBfivmySBWaQKlw1f6OX2hqTMXjf6Fik6Xs1jC2yQrNrMlRUCA3f6cbdmXGGz4PTLRpCLx/4Wsbe4+ttJWuNj2Srw4t0gJ3EYtOASW2P1cA4pgx95Q5aBz53Jo/FikMyyJQEHdn/5+gKiHWWKESC7ldwIkAHcgVyL2ziIw1sM2TlAE3+7/cw/avrkA7P3FEQLYjAgYSLrBVHZIGrsF0tKCXfvwIhEGkxjHtsOPpQYX6hjG+KCIOiz+kSmwHTUCJa1PoIdOBUxwiL/tr2LcRCLjl4X44bptW6yJ+zvY3Ns9MRGofd777g3UIAuPNrTUMYLTKoEihRhnuXp4GawGuZXAQYaYLIAJwMnqvK7sW5uNSCazToBje52asQnKwxSkCtIRGDta78jjfoGM2QIdgelSa58wCBvrLEKdh6OEQpA3s4srqlJeKQGqbB8e7vjgPLCyKupm67vn8BVMmDiVoNgivuoXwjne8A296wxui9owAjBoO2AIAyIajnNdzAEtfwNi8FozejZPQ98m3IUCDMvgHZCCbWw1jVAFcekKVzBWEMor8nUBmQawkEAMUmEvo3dtM2aVbCAIAA4pS36smyTZi3PSndpGX/F7SKAz88OpWOX7gx2ELNd83TbAV608xC9G3Q4sV0X3YVmiGpiO4z0mvYkldhTsOM2sKFSYD22cZ+74wb/LTfjsHXK5EY7tdCJWCnCsQQN7Ka6+JyiHb041gaUIv25pSn8iaQW7eSdx4yPyZObhciFxOkDDDDnPFcCUAvwnF8pC9T6oydqcoY3LO1V5C7CaNuz2LqpIFreFdAhDOUscMNRnUS7BUtu4WYkWoqC7Ev6xxlpawTzv/uFJl7DZMYKC9+RIAsPDO68J5RHCuW8BAZ1ts8ftSSVtAc4Tp2HJYCe45F74fm9PYf+o4sl8RfsgGNez90y8CAF79JUZTCF6mXzkVveCVUlibMnnf/cw09iS+y373UkBTLPjIrIyxZxuwY3pjFsh/+ztNPudqLQzspL+jN+GPr6YmsAJo6kFtpArNdpNwwELNxayBbfPhmPQLKYFmY2z0EY5fe6v593y9hYnVMNU6eDArylbvbCLQnByOTj3X70cKzZkF4wMmyzYHsLRaLfR0x8OMrnCM0hVmsFyODrLefNj8q4mwvK0VmXgv9GOgGQe9YazxGlSusMyGYo63gBsPXlk5rtsH/NXMfixkNayMN7H//fuw/8f3Aath3lnqxwrNi0Lt1+gQ8roaue/DWk6YnM4wIPKBgeZ6A2hmLAkAXPRrGG9tTj8CgG1ThMWs4RWIF7s9zHZDeaaWDDDeTB+aB/dOoUM1NLpmHljVeigoUKE2B/oCQGtyHR+a1vexKhm9QX3TgWajhcqgQKmP6Hq7wCjg7197R/z5a88BiyvV526lrbTZ6bqvrGCQT4u+79RMJqVBHewp/lh91Sx9h4GBVMqQv8wEBUqDPrJYdGp8Ll/wX/eoxGJWw60fWomUOWNfPoPGs/MiB/a+z9SpWcw8eAY7nh5g90PL4H7fl0D6VpTm2qSl0oiHoBVLeEaEEuI3BGsQFA483B9SBjKXeONHq1XpLgqvS0rD+ytlYYbN0TVAJkCKbDoAFgwpbL9gAtZ4M2yK4fRQYJTE/DMsrA1cyJ0ZuWs456/SwtwD2X5MarvBRjU0kYMRlEdSdeeTYw1sTYF9lbQPfEJPPgUGY5zziJkAiIGI5qilIoBg6+ABbgKmyMEhAnpT5nd84ykRPNUqtqa/NIv6yQUDXCDvRxH8hniuoZ3tPRzYZQduSn8e0bjvDrXVEpBWM9aEmfJJq97U+OrOeM1BRNj3uptxAUviW7FB4MqBGCCt3bLHlFc8nkadgPkP4YZPusjd7K/SqZ9bm/ckWhH4VBdXQPZ3rYOw6yUPzdmel4yhMFQFLKMAtzg3AVWkCtj7B7TAf7B33NRhSK1Xobqz55RcGEBkfVFGwWKcH0si/C49jMyhJIYF18P1JNiNhUjRbf4ubr3G1JXk+eTPmXh6JcpnaJ4ODQZNgAG+DBdUyx2TrdgsknWrKJYbsy7IE0VzSRhDBpInE5Etu3QvYiufKDTFDRGelwG7U2guapSsjXrV31tssiX+fuNNKLPZQkD6dL3JuXxLuTJXRUV3Nw8R3d1wlvA9NrUnYqxS6Tcyhna0fB6lV0kjmSejyO86Rdw6UX1W/37VzSB8AJGPLg8AszfdUXnN/+hpC2iOMD21Ekc4d6l/vo97f/EzOJIfic7/gQ/U8Lf+7pfxv/1G3L0frU+iP4i/a11rZCc1Vvie+x7Bf3vjK3G9DTP7wNwSvrbO6kr60ESxsepMAHjfW4Br95kfcE/VDcic6oXdorU06rIwQS8H+UiBJhDg0YJqeIUmEJudlxJojshsWabX3mruN5c3YoWmA5qibJur0ASWsjiA0lxv4BWazS6j1QNok3x6AhZoctcrNPvK/ZAF1npC7VeOzgz+lmvC3xfaY4lJ7voKzbGOMTf/9vf+LZyaNf3qzptwxUDx8B7gsckZfN/RN+H/fus9eNm/vR03vPp66NUgGV0exOPtgoDR7ZXNCzC1O/GjWcLA3wURFGxQ1DC+SUGBABPpfD6vewXifK8fwcPJFWCu1thUhWarqdBR7P1DrunS+xsFjEKzdwUBpK40jU0o1Dvhfg7Yz1kwPrYGLOd1jDcHldePrFxjGVQhFm92Yyw2OWc0R+ST9Zd+lPDArxP+po2BwQx88bGR3GorbaXLTt/8xAGwmgqBGgAAAYSFhSuZNZDWfj3GzLjxw+EdQnIplvgwDIoyGdTBLnoj9ZLGo7l5UWoE1WethxiIFDqKOKzn/wLKjmkqSmT2HX/oc0tCsUb40OT2GCZECiIDf7wQSlcvlI3uSC5ehXk4w6+WCGbxyKK28To55PExfA3EQDHZsEUL7cfJol2V8Atg0uF+IKs+hBczheUwu2MSa8k5L16ohwU+YtUYW8WehYDMJTSABhqoJfXUQvWpHYyueiWl6lAWi38y5tV7dSsc86cJVV9EaAmAUGE66FDqcJ04VeKFsmUas3ft9riFNIBSgFCO4UJsliqO2NP7Bybx3KvaAZvYfiIjjRsK5eBj3FBaG5PzQ6XdfWeN49PDy/LB/hbmWfwQ5xKHDx9Gs9WydwrlnLvFtOnaHXs9pK5Ksj8YCJSY13uVYh19cFAPlwzIqO3CLP+h2wS0IVhQ5DBdwmYSWCyVtw7kdW/eEwMy6bbBgeRuiELNmn1shMj82D3ezPX3IvjvlBCPTLmICH9Rm8MC9ZBB4S/q8yA2IDTu0+JPp3Al9705+NTRmoFb8jo/JgnN0x2ZiWg/glTrkWYwaVzLU5DJTCN20wZAThnyKL5TmCvYj9+qRDE4dIDMlymdV0QP0kJhG7l+MGf4N4bWoFLh4IM9MFtXARaWM5cgJjgXGyGPapcUUZAucUxu4kW1k8M8rrWoTzBT97UWmygBbMNv4oXNHYRxYd8RlD7zijITCOQiVBGgy8QncqryhDgWfRLtPHTuSyNtAc0NTsdXO/ir0xcw0NqbnGcM7BRByHvne1h4ZGHo2jtqd+DOteuHfhv88qOT+Mf/Ie6iB18VQq2e+cSTeNPu7fifrg9Sr997plql2Y12B82dbttAoJnnhB9/v8n33+09ipONvo/uDAwHKem4nwKaMSgz74NzVOkG22xLeR3bFkKbSqBZ1CzQLIDmxOYpNBezemLe7YCm8Hu4lm2qQnOu1sC4UI1e7A28mtX5IO03N28aabfb6PFaYm5qTShEhHGtR6fQvGYP0LAg8DjGUC+Auo26Pt+PVSpLfanQBBpTdbz7B3/ef/f626+8HLWccNj4r8exU+aHy/j4ODT3kNsNkOXEn+6sLM/K5kXw3j1j1L6T4jf5bG+AJaGI7A4amBixiweZtk0C83lQaK5ojtTHk8uMi/nmAk0A6FHhFfqr0EM+NJcam9dGk2MA9zO/SJizPljnC9OPxtZskLVWqs4abZpoZ1CD8KZcLyjQ+ORo7p/nhFfcSLjnZaEMn//qaO61lbbSlSalVLx+ikiO/cqu0m78eMeeouOTIwoRKwy9kkTB+AyzAEpBoZTm6JH6SyegVeOGT67h2s90IrhAlBvwYCFbjLYMMHXVWSENUOaPgRnXfq5rzUTtvXUAFqE5YqVbHFREKo1i/4mMMjg/t8ev+3QHdkXqy1qghFbAhXsO2NPE+5gCr2OYubRJ9cBgkvu5xfHhE5AcKoKkqdqNh+CFvFCqf9zvcLMwNgowG03aXdO+GfPoxso6FlHOfb3cAlyo2Zziki2sbTYEKDHAO5TZlGvyqVVc97Xcn2ciHyeQVAPI8nBcsgxmzB02OHbsqRVMnVwKUeRJogbt+5fEmWMXi6gtUzB4zXFGOdnAoG3N8okSSAZzvzI1oRdWcrau45whNCnjVTfHbaooCU4DDX71IWPmLqETEQbtzN87Ksvcn0Z5QrNvC3OeUDQ6yBQ+wDVuNruEia9eMEcSn4xfuiWLpo3I16KAOYx47EVKNCIP8IHQH1wZnDLRKDkZ+dxa1L632YBlUhXnWy5TVjAqlNgCpprpwUDmE1kPp2kZp/kCTmQ9EAMD7iMjguoMsH0u7g8e7rNtucjXYrUvUQDeVFtcjNv/dBWcAVzGZuyagAYysGa/CWFvAK/6BHBxG7D8BrOwZwt/w0hP5gSu/sBu86BCIagl/CYDQqMAT9Ezd6cpgJ3i3mwekS2YmQHi9tz50bOYfio8S0kjjQra5ssAsraoW6CPcmpSCUyMo5xL9xemhuG8pL1c8CMC4mjjcgvF9uF1CWPwk2kixLsHRPHJWqqHo8b0dXT/ah+g7aWKM7eA5oakM2fOgJmxPCjw9o9+Ae+/9yH8wlefxjNWobm/lxtzEpt6F/ronw4L+S+3HvZ/NzFMYZ5oTeH/+h2gP2AMCsbnH2VM3BKA5vLjy+j1eviuQ3t8//7shfnKssoox06heWDn8IR1NclBmqdak/jdI2No9sIAWyvjweaAZqsL9GgzFJqmrstZLTI5P20hnWZGt2nOaa8B7cnRR9+4bj+wYwpYyGsR0PQ+NAXQyLrZpkY5n88bkULzxFoHKxaSOaC5Nr5JEUrgFJqrXqEJBJixKtqpLLOR+dDMMvK+Yh/rm/HqlLWXMjlvd4Bdh3fhS0+EB/j6265u7F23z/y7vAY8ftz8rVrk/XWmGwgXRXnqKwrTI95AcMlEOq9hMop03vcK1maXsarqmGhv7Fx0qWSAZthEYABPLIUBOLm8+QpNABjkBbbPmb+XMo2H5o2pWaPLaHWB5c0Emm2gp0Kk8/leH4XWWLYLjokVq+JurR+IbiTlGq9BDUI7uHGWBgWa2j7a/vSaW8LfW0BzK71YUs2yGGUVI8TJApODwTiBAK3RXggg0y+4NQcfb/2zAIeAMMwDgDJ8qD5nTw2+MJUFD82xNnbu2IVf//Vfh4QXLAAFWKM9rzFxobTX2QVj1gRPvBqKCTd9eNVcaRdrzoOdXJ66RV5jsQD3B5g8Vxo1DWtABb4QRW5nhuMAqU8+CVLyR2dBT50Qx3QELAjAxEXnU1NHoHJqCdh173mzaE9MT2V6z58ycso81HKg2ZgTFiAyarlv+DwjXvQmih6RpO9PAw8CNHJ+Mg9+yb3zjFm+JgNguJjFElYxR/Y3Da/icXUxgqucAkYA3eu2y5u7xoWPcs4MPrA/lDWxOXcQbOJ4B294uJ+ABwm3TH2V9cUqgz+5lpi7pmb82WlGQ5vzyEJfJgtYBViVJudHPrMagu0A4HqOYlvLn9tdHQTY6lgqm17plFtMBKw9C2f67fr3vCosuigDeLTtDjDe/40J0FQUgUOwxsXDbcGNrIpZABFWQVtNALD4iShPMLDKPXfUK/cayxreJ6g9j5ihXD8alKgtGPHA9X+xEAHabiYFIAR4NxQcuxKAA3vusAXqFOYjWdcIOPrgNLKNPB0Sw3LY5Hz5ddfYPOUGrOzDBM0abDcr3ve3fxj/+y/8PXOECSUGUFDIKcOb7xWuH2y5YiBcvbFguJoAtNI3JZvjWWGeH8qgnIefE1xz+QktzDlk5tedF4G1O/bZc0P+RsOUAk05H/qSeH+UQdUqAW1QhNqJDVm/xPWfKCPz7TRb1mwUvjBrbSXAnPZw0IyR2mIfkye6vn4hL9vXrZ/aUzljSfkbiM0TAQftHBNNHRI4+/5QBXADTA1uLdz8l7gSiC4tEd5U8bsiBseMPpWYpYGvazyLJfDS/jl2/1nxZTxmXqpIcwtoXmUqigK33nor3vCGN+D9/+Sf47yFKv/uieM+8urhlVjlN//MPKYG0/7zy35m2N9BPp6hzBX+fGY/Fm0k4x/9RcbNP8B47d9i/LX/EGwzd+s9+JEf+RHM1GuYsRE+5vvVJoDLQsWG0jz+jYYa14sosAu1fZFCM/Wh2bE9sNk1EWlHDVicyfliVvPQAAgKzcV+4U0tJlaB8anRwzoiwtHDwFKi0PQBOITJab6JCs0dU8aH4LgAml8VrgymF03EZT2ZV1w9mtRsNtHVKxHQ7FjV8Zro87oYbeR150fzbGZu4oBPCjQXhQl6uwPUJmv4zCPh+Gtuvbpy3HU0/P2unzKbHdl45oHmchKEa97CaNKMWifD9AQ2Je3eBszWGphYDq/aC70+lkvzQ6LVsWBsE3zWumRMzmM3D7957KT/e8/5zfehCQBlrcSR4+Gzg75HjpufL5325m0gTLQJayoT/bvArJiPxlfNvDXZ3lyF5vREHVMXQ1950vqrlgpNVRB27hhtW7nNKAC476sv6c3xrfQiSjOPncUz9YmwkAMMmIxMzhEojAciiP8tNTiP1ZSftr4wmQswajid9e1KLvhR66JAPtlE92+8BQcPHsAP/dBfC1mwThRnYdAoKBEIQ4NXHwUxobnCNgK3ObeGDH2I971QPbXmC1Ahguc4P4EO7gmfcc4sOghpYpNzv3QtdaykSt6rESb1wS4yX73dPBbgqljSSn5AbFVMAEjHC2sH8oYUZ3AQzC2446PGh6H7EGCxqbqBIM1l7a9xATvY6l/XuIcl67NZ0xncwjutr8XQfr4L2fuUU2aT15/n25YtQAztdCxb9cdCmbWFfO5bHdpLqr+UeabGz6I55m83xCQ06hx+p7pmMkPCta25IwPokUbO8fI4W1iB6gYTe44me9t+HpoEkEIaXmWVQaHkEv+1YXx5aqHAMv2Tk3xtNkrAGdsmPDRaXcGA3efZB64Bp9q3cNUn8LiogenvRz/aserNBKt4RXL4vtFhrwwrUA6RFB8cKborcOSPT5tnyQH57Nixw1VWwC1TV1cGk6dTfjvI60BfDMYjZZ1d05WTzrS/DDkyojLKyOx33nUX3vbWbzS3Y/aBp1iocUMpE3N0AO/4iAPeMip4AlptffIBWyBnemHeY8hATdCAdupANnDQZ2EVhm5jZt9ZoP1la6V5+lf8ngG7i20i6X7DkMkoT4BCPxIpro/Jc+YpDc4nho5RdJ32gcdgobkEtuE8xnZuoMm5zUE+WO3fa+46Pxa4RDznmPp0qcB/3nEEUMFncDx6zXgiBmjsZZCbB9KVhWlfOyupuMxSEWz4ogGUxzK7GLObGiYfEXiIGQNoLCrbf6J3hJivEafmsbnAOsmNX9MuL9WfoVtA8yrTfffdh8XFRZw6dQqfXg7miivC1POOMzHwmX9uHrvULgBA0Rjgm3/kHSiuiUHI0Z+7Cf+/97wF/2ZfkID8+z8xpqUA8HCn7Tvt/uwAfvu3fxs/8RM/gem6ude6QLMbgCaPCGi2m4RD1hT2fLk7CnCURjnv2hdNs2eA5qhNzh3QXMrqkULTAc2L/aDyG18BxjcJ1h3Zi/8/e+8dJ8dR5v+/q7sn7WwO2l1pFVY5yzknGRtsg23AgXDgw5zDwZnDhjvgyCb4TDoOvsf94MAYuDMYzsAdcgIbA47gJOcg2ZJXWavNu7MTu+r3R1WnmVnJfPHO+gt6eBnNdldXV1VXVXd96vN8HkqWBblgke5paI4Y985YQaHc2gGaHuDTEAJ8wtqsLaMa8GlsqB3AYlkWLlliIaKxB2jmQmOuqOxpjbzuRTrfE9eApgdEZ10ZkXUoZ2g69Qk2btZ/r1wArY3lX95/nP3j24Sv6fniTjj2PYrtsXN8ACqDCkTUgWGzO9o4DiWmfwPBs84WQX8sFXE5H8wVmDBMv7qsZk031UCz1rNyhibAuHleC7YpFmxjRlzOVUqxsK/yk2TxVv2v21S7AjWmIRdiaGZUNNhdxyCMOzGa07X9hGpujNOyN+grz5l5KRwUSJQEXW3TO38LIfxNiaEx2Lq3dps7B+2gTWWTKsuwkwiCzBiQxdfQDLtWC4LAKniLQMHi345ofUHLioB1zzuTeqGliiCC/i6V6y8onhS7+ef//joNjQ0MLPUirgpW3paJgHrBIlr/bRHEzxVI1Pj9IWYleAtuW+kAPj7bqTTsL6J1bj5lBy/YhHbvtSKuoQrXgEX6DkpIikIwads+eDZquYRd4fU9PH05qoA4nkt20Mb1Kg5CB/epBj4aLCsEPqrowrzMVT38hyRgCYUZhs19Y17O4dIF1ynJoY8Udb1DgJxmGEpAsv21i1HKfGzZFg3EAwDVlN9zG/Vdl0MRoEV4iRnW0ATchlhQulB3UIaR50PEHr7ttalVVh8fuAvcc8Put9o9Nczc0/BA+4sFfNdVvxAayN2ebEJDXpL/TQ7R9UzesJVDt7ZShJ9fALKEtFgFPuix9K5JJAErbYeVNwBMGNCMYiR+iYXlN8SLyQZdV3MvjYGEQXrFmmf1n6PrOpAt6QqAt1HaOrsQGC6RxCelAXVlENAE6N4eBeEEsPjuSWyigbSiz1Ig3VIgS6FCEgTSG5fCj968du06rk/t1c8kEmDMR4nx9BS9zQkFPuOvvI6+K7ndyNCb14auj2oyZsmyj4w5LZCyhKeFGJVNFf5c4m1AeLb0rkwE+CK0+aL/DM95AYCOsJjl6jXE8hei5V9y2wiU5REwv8smnrKNGUsSjMfCgN9VwmkBVj8bysYfMuY6EzBN+eOrvD6hEigFuDQUzfzul5NIf1BKIfJDdLp2MKeaucN3cTfj8wjZxULZaLKvvHc5oOyli7CSjUkUzyWb8TeZoqXXYKR5RyhVCJ2Jgrzho8/bEwZwDs3nIeatD35bqdBV5t9yVmwU9Y3+DoHDJ99XtokSvp/3jlCKzPxF/CXaQUDzFbDXvOY1EIsRO/SoqufXbo3OtIW9BTosHW7b7tIDbO3lUTG9+mVpHiu7zjPLgoJl0x/TiE2Prd3Pv/KVrzC6S+/KjBVLuLJyxE9mAyRougBNCIDDYVU/JUNTKkXefA+ncpCz7Gl3Oe/tBtvWi/CmcbDNy3CnYa4OhdhHdRlBY31tFqgLuvS/bi5wR/ZA6THTZvUZKIjaBQVyHEEubUVczsMMzZYRxUAsSUsNWKxhs+w8ThX9vDCg6brOtLmcQxAYyBuD1SJBQ3mUcxgl7ge5/FP0Mz1raRD88suC3u7g2JCY5TM0lQg2V5RSjJo5oWncbCBM83jzrLMV9sWSEZfzndk8WfNVUpeFMSdGYy0BzQbBcCzBEY9XzpNn/Frv+Y7GHWz7TwOd/1iz62BhX+XxhX2KohDEWqYRqS+zxjo9L9eF+vdjw8FD7NynGLNjNKUrP/qm09qaUyRGHZImGrwHaObDGtEli1mt0z9ZXvJ6wdffL/j9N2Fue22ZqgftoFUzYcVgcmsFiybMCvFWUR6jLMDSNNMtPVQEV/ouh0Hmgofm2DhtcZzuZn0IA4T6bn4C2zA7hxa2mXsIYvkAyAjKJSmZ94CNpZleoXMVGo1VTPX/xGdVSfCDTQhJ4BbtTVHme8EuKa1F51ULHZiiL5FmV7zOByF+nBxAGqBr9pPaRVdJSUYU2JKqx0M1FbD47qxZmAdttTOuvamEAVAji1cfgUgYjbfyinkHo21W7upazdbsbIiyJMubUUkWvCSZLfX7RAl04BGTpzR0Wx8Ety0DeoSjnFeZ9/1yBvCIr5VnngkE90KFqqkIMbwMWEcI3C0DApRSAUMzzFgz6VfdkjGAn/R1oD24o+fJAkiIK4FDoGEZaSIk+0SBzk1FX+8yqGY8+Nu4T3vu65HnY25aNyq5397DuMowp6eH2xLDEcapLUHZURfk4F7CB8g97T5/xEbYgvqYWdqR6J9EuZX949RiM3pAhNAU5bLil6N+GiuAlFn3hyKWsEwf1qBRekhqQDPc/9x8WT/1QD4VAWfCWrYlFCNqjL3rmnEFegPFDWlclskayDKGZsvPnySUqd8MCqnnASsZ2dgRpq7bm7L0NO3gJbWX54UX5ELgqiDQi3cbvwoyeAZ7ZgVpUmMKReg6RcC8db0+7bVJFC6bpfRC5diHlA+KCwzQ622AeMC4gIwomWEQIP3lsbNm7VOIgieBEWx4SOE9v7B5bSYiAZ4UGoyumP+BiCay0nN6t6yjy8XIDFRe482vzvgkDcoAmn4eQWR7bxaXZtyLMlDRZ1SbYv8qGfQVSQDQh2oGeBHWp1hfmDILBWSfI8rQLN+c0Bsb0q73+4O+VxSZFN485jTgvSOiaaP18eaJ8kBkwj8n6N5bhj6HMVJTd5VwCIIT/WXZX2atX0E7/vjj+dWvfsVbr74GkaxEULoSMUr3b48cS43VYZuB1by4GYDuN3UhQhPHUHM9ITk3ulrhtCPgd18XXHOpTrc9odGItEhzZfoDXJR6F5mtOpy6IgqmeJYJBeHw3nrTwYpcaiQ+88IingsGaDjKeaYUaN4k8xqsa5jmKMcxR9Dbpd1bLQUtI/r4LhN4ZyjEbE1mBPU1ClLS263bIVeK+x9ew7miBqHMhNqQ0SzOWjLGrCaL9HgleAjQPAYDsSRNNQJ9PatLKOyIy7kuU1g/r8j0RvD2XM6Lls1ILApohtnR5VHOd08GbfWn6md61jNL8Pj1gu9+RAObk2UA1Kgpz2ixhKdy1jimx2YtNTT740l6dgfHbt7Z7/9O5TRDs6O5doCm1oiNs3ITvOmW4AOjaUxyzCOQExalGga88izeYNExAPUT0YXNoq0w5CRobqodoNlQB1nLpj7Unx4dChY9Xf16Lm1pqLYanz5rbU5RFDZzTH/qm8yRKbmROUC5Fs0N0z83nXui4H3nCY5cDrGDBM2D9mowuxmZ3+sHrvHX0H4E4NA4ETracni55WvxRQBNvShrbWvnmAvO5jvf/xbf+N53gquUW8aaCYMCIUBCSt+1+mfJQU477TS+n9gDQJYCGQreRXpBH9CAuOxvL+cPsXFuiL0YqW7YzVGKcJAFU1fjntyXSvt1X3WzYVWFWC4iAtBJf4XkLb47XjTvdlniUbEzUDsTgh8k91I/KEFG2W0vJht8QE+qUgggCTeWXqAqP5BLCFIRAuVqNuoLYjhSbw+si4KIOt+OIQ8p9CC8MhjDMIhSyg604TzN1PII1K7ypQc8JlD30wWfTVmBBEIErPNYwEKpSOAcWQVslUqCZdGhUlpXMsSCLNfnE+AzNMNAuTOex8oVWfGrSTQA7Ya0MqPQwny3idmiJQDefCBWRH+XsWYjJkPjRAB2A1hpkpsHqNvlsWBhr5ikQIHm5maOO/44zYw2lz1ZbIwAJFHToE7GZxe7KBU8V2mAcqEbULvDAukXxxCuZNbzhcoclYj0QT+oiKl1uL1cBUJYrN4wEXF2t7F8hqYSDkIko88yDDCZ/ObuUCxWzYS1Aku4lDwpHQFSuvRuKvm5iAqQ1DwdFaDhAuWP11W3ZCipErfF9po8ox1N4bL2PWextPUJPcd4Ug9C4KoisawH5psrDIDmgUZztyt+f3i0/ZQqq6u5Z++dlpas8MaCGd0eSPWU2m2eB/75oM+H2OQKSkKx28phD+RRoQCWEIoyjmDd02CPGW9ME1QNZXqzCsFpIQw4cOE34KPH0Ix5YH/Z3Eg4E0EbJjBPZD4ikk5JSd1Lo0EbhbLw6yqqgPpl+rECr9yCCSuE7IUjkis/kb53uZt8+JzHvJUEz6a8rh6YL0yBncZIH9aB8QJw2NdLLo3495n9ROU4pAxgVuXgbehdFi1WNFCd357m2K233lrloj9vOwhovkI22ru06vGWvTvJD+WqngNoWdKCUornRuOkTtN+2mJFEx/+r2Bl9PGLYPf/WNzxLxYnHSJ4//mQTsELyUY/zemJ1/KW1Fs5JL/EPzZSrHQ7D+sMutPI0Fw2L/jQE7kA1AkHKZkoBceTOVAJqcWvp9mWztUu54Dvdj5UKDJZchkMBU1KToppdVsOm8ewG3USPngwlCsw6UpfKSqdgWINGZoArc2CYj7mM6HC1jwCA05yWrUqq1ljvY1VCqYuz8U7Y/pOKqvAscq0e15ZW9Kjmb4A/fFUBNAcDY2xcobmppDu3ymHvnLlaagTXHyW4J5/E+TsQEMTYMSUoT8UNKlpXLO8a+dyDv2xFLMGYM4u3ZfCAXhSWRgTiuYayhd4kgqgAc3Df9fP7FSCd/ykhOOagEDJ6Z+Pyq2+2UZCREezZUTRNqIBzZYaApqNaRh14pH+/ejQmP+7sx/GnDgdzTUrEgAdbWnylk3PruDYprGJiIYm0qr53HTQDtqrwfSCtOBrhnlH05tydD+dx6d3+GtdPW4edsZ583lvNucU1liWxO6QiwaKk08+hVQqRTJu4xpEatbTOc1QklAV3YqYQsgxKI0waBW5/fbb/IXZRtVHn8+WMuBFiCAjgCdjk2QtAcp7z4qAyWTubinj3qjw3emFgr2xuL9Y9tal/kIfj41jwAQZBniivCYdhCPEjBOCoveHW6YdKQIoUZaVU4XWqkKVgY4q/NOU2XOFDbGqlNFq0+XXx9c8rcurKiLtmnwsq8KFVWtcqqAdhKD3zp0oJI6rtTHD7rqdm4tBG4dfkz7rSvpEIs3+kqa/qSBZWf/TlxnAVKaDOvlgTxSUCPc0FdrMqn9uEHuveU8JXZ9hXyc2gIyE0sCD1nQNXO89u/3221mydElws5DrcySpVGBZpq8KFDEQMezJIlZGg+YeMOaXV5m6mWfa+XwHYmhkCoamBcplu+2tJTWsGM8/bgCYAJxpeXSYnl3Kv4kCup+pAqRIFa2D6eECYcAZ0y8E5GOdxOwUloIiEgeb8qeghEC4mQBkEcJne3su2EIIVj0H7SoVeV7Rglgo5RJ7cdhUIdTBhPCjYevxFx4kARDlFDQwvccKQL+jHgnpeSo3BKi5YBi6AsGoyrLstgGv+Uw/NUC3QTgXb5GInB1pd1/v0gMJvQYq7NXnIrqSwe9xcix8Lh/S+w1SBYiqCrGtBdZECVyXJb+d1ACwUH5AIa8IQcuW/OIoEb3HOCGNXUsEgJxpIyWg4+lhYsVwXwk9V3OH8FJLEp1zImUJRxMPz3dChAJI6ZMRnWcV1CrC2A6QzeBc9KT/U4Y2Dzxg18MK/SBHwYsgXOqqP3VTRqVA/LlQGA1NBMhgg27WC0UW/nYMCJVFhQBur41MwSqDCWlb5KajIG9oXvY2xa644gr+0uwgoPkKWElKnnH07kQsJ1nyYtAJH//xf1FvTY0a7LSSrHin4pB3K163bSW7rzyc8zmMn90dpDlkcXRRnUwIjlsFP2ufz60tcxAhFlF9NkhbTUczF3KHVa5hiU6jyzmACr1Lwy7nE8VgMkjlwEoc6EP4lbFFc7R7K0DbcHB8VzYXcTlPTFrU1Qg78FzOR+y4H6RkIF9gKASw1mdgwnKmlXlYbh0tDsNOklkDlec0QzNRM9DXv2+9gwgBmllXaiZrUvfnlhFQsekFouIx4Qe/2uU0UJ8J+u5wFUAzmVVYCjYP6QXmql6Y3/XKl3FOh4CkKnOB1+XZF9rRbfIZmrUB7DpbA/f8w56oPF+XhXE1RmfnrJqUB7SG5ojZ2LAUvP5Hgzz+muM59hH9jIacBPWp2r8i21oS5CyH3r7g2KKt+GVK17BMjXWwNxYF7PsyGi23XEX7oMesrS3wO6u9gbxlM2d3MO6eHc2QCzM0SwcBzYP2l2lCaEAzCOShTaGYtbkYwHPCS+sybJWYf8HpfP8H13NHbABQWBN50lvDjJoA1mtpwP8WmbUpj1LKD/ABBFGRy6cGD0wwi0G9iS142BknsmI0lJnyRab2RnYIRyoOAwbbxCR5CtycGDJgpWEMGXxShVzalVAhwNTS54r9fjmFcX3OU6QYjoSrXERyvgYILAsR+q7VwZJM3REhd+oo88jjYOm1uv4+8ADGkiWJhQMnGXZR+ReyZtcaF09zrSukZq6LKFBYwdCMMJb0SlwYnUgZdvsHHBdG3rBK5yD9hiSs3Rf39FT9LAN9TWWidAsDTMzdlCFgaPqIhV8uIQSW9I56dVDBvU3+ANakYQiqUuTeIFhfbNLppYuwmkLtoBNaygNzTROGoyQLOOH44znttNM0SO4qrEIQFEiEQB3lRlm5ZJ8HOYFmTwbN5YFUiYQeOFK5vneoFyiluoam7nMKoDgESqIUpCb+14B8gRt2vD+H5T0+RcXG/tFHH83/Se0KJfB+hgD8MDjjH9A/9zDCRvqCJ2YKvM+JU5JR4DSs364UgZ5mWd8M+q8GHWVEmzAAfya7kkjLm7tEpK2EDAAqv26hv9qHCABQJfGZn8rFc0UeFwXuEX0hBV7THXb/fzpQlylXADgFt1Ceq3oZUK1nMTcShTwotGYtLtpU0gCfGScb4kPm/gZINAHd7rf6INalhx6SuhFJ885S8Ly88oYsrCvpXQewbLOiQdrUkfAfgQeS6Vvq6xZnmoiVQwkRl3OCm+sbhgoRBhVFhBFfLj3iRy9Hz5MRt+zIfOSro/pgeTiP6l+iRns1/IaKbEoYQFOa40TrowOnlfVZd6zsXWKawQC1OiCb9x4IrG5Y59GxuWCyV+Y9Zd4IIaCyXObCCk1/mpEcAoQNsSfWH9L1+guzg4DmK2APDIwwZnY2DntKcIoRbm1LxFicGadOTC1Ud+0dSZ43TJyCZfO+u1uZtKJ+a+sWV1530jpBxo7xjdkr2fv1U0h/3ERbjkTJrnQ5z4dARFfqSXw6dPSWhQBNUQxYV5OhBWeYoZnKgTXN7uaedbcJRm1dpnBgoB2TuQhD05p0ahbhuKdDM/5GnDjdxksii+LXewK2Qn0GMnF7WpmH5dbd5jAUS9BRBdBsGdG6iLUGDVqbE4hS0AZZ19Xu1MYlqnUErMT0T21+pPNYOgoghliZHlvTY0xmLD3mXn/M9JXLrreqAqz9ob7dNKYo1CAIl2cdzdo1OScsDq+iWbl8s6IQy5FM1g4db23UEg5jZi5okA2M9gXsw0EnQTpVOxd4zzpaE2Qtm6WhjbHlL+jfQ7HaBilqqIO9sSTpTOUzax+EkrLIyzHWrF5eu0KhAc2CsCIMzefGJsiF3m/StaddwuSgHbRXqylZBCsaBMFn5IXZHRql4tkjulm4sBdLCLbZOUJQTxnjR68hD10qOO2IYMEmTZTjlbfrYDTCqj53KqVdwBv3GHBACI497lgei0+y/tT1obuZBbBhXpUooeIGoKkANPVKb/HdkzzqjDCmxthjdGk8Fo3PPgzrnpWKtGzNhepYRTsNRb/IMMxECLyQiIKWkpKW8HU5vXN+gGyBWXx7AEixbBEfmFTCP+eisL1MRKgsdoO5h/KZQLiujwkqFG5Eg62KxqV/KswkNc/ZJ2IZtp5Z3B//YFAfwot4E7FZoTUXVz+jSAkD1hFajAv0At9U2CEe3DXUCD2P5fz+IRQRXVHd72SwiFcKhKL79u3mzyhAIlA0mcjmUko6zHdQnlIAvioNugnvBp57rslBCEgkkjQ1NlIcHmb2AxpoqidJVzFPO/p5CClRthUK7KOZuAKPSxnAyU3NTRx99NEGN3EjbqN6vFV5ZgZ4k0D3k6MgLAbGAmaDUoEM0zLZFG72Crvmmmu43eh3esRDXeiSaTVF6tk9JPpG/Ufjw2FKt9/nv/kV3a74GZB1B2lUccLB4b3I6d5cEvGQLYPng2bXEgv43T8AJhu2Z8FoporwuPBwSiGoS6dpbm7m2muv1YmKg7T87IlIOn29d63UgKbu8EiZ94MOZTxPp9yL5nLpg6YBoEvknP4jpEksQLmloI+ZvL3hq6RLo0hpsMpcu9cusmTxEkDS8ULB9FNJyfQND14TwIIHcwZvDoXDUbqPYvL39x9CQHJvn2ayBxsRItI+msEd7kHheSUazCqMZ8ow01IF/3p1DQIuBfOD1omMbqIEuqBlAKM0oKiHNmefJ2BNScP89G4bsPOJzHchRiPl74ho0CiA5XdmI38LJRDuBG4IeLcHMsT2ZfwiK3eKuV7oMTb7aVNmFbBrRfjeStfHm0d8BqmXZ2Q/IGgjK+8SKyiwLEqlSgzoz9kOApqvgN2yc5//+4jHFSc9AP/8Nbj3tcewsLFzv9e+5EbRoGw+en7pXFg4u/K6kw8Jfv/2eZve8xbwUOFB0pOVQEbYwhqI0tUMFsd55QGyeZ0QNzhmyQ0Q09GQ22s4EnwyB/vBfV9R62rV2odDTpyOwaC9tmWyDE6EgiblY9MaWCZsjiOYN0u7d4YBn+9v2eH/rs9ANl5bkbbOVnQ7lQGayZwildcMzfpU7QBWgPaWJBSDqWuyUGJXaOC0jIBdAyDKCwy0t8zlfDhfydCsM55C3mbFWcdOX5ulWpxI8J2BvMfQDAOatdXQjDmC9mZBfzzFwj6oHw/6+BEbFYc+YlHfOJV+1PRYq16LMOzohUGL1cqOJ4PxNhhL0NJQ0yIB0NVex7gdY93TcM6tkjcW06y/R58bchI1Y42Ddjkvl1TwrHOfZmcm7QlaW1trVyigtSlhGJrBsedGJ8iEgt5577eDdtD+0uzH1jOQH/QXpHbWi9nsmSQ+6UFXaH3D0PUXvvWteEuswAJ4o3xP1UKzqoQSxDP6XlZ5olA+Qgl6fx9IMR1zzDFcfvnl/MMHPxDcU5jF/q4S30vuoU/tpHRUgwE0YxFAU7MpLdJDuoannHJysFA0gRU8TbWIy3k+R/smb7EqAgCwNIIMLeg//OEP6YW4aYIwg0y4EkolFi5aaMpSpiEng8Wwcou09uVNK0Tbd48TTFaJ5wdIP7vbb3OfTek0Bdd6ZQkF6alo6ZCenRcZ2Vsce1F4vWdiboQSOgK6x3JUSrHshaCvhN0slZQ+K0miPZ6SBtD0XCdb+4rM/+0w5HL+M1i+zdElinXoMhiQue2lkq+RaJl8A7d4ou7HpshHMidodx/YItK2SpVImrWPGM9hj+UDQMkDVvQfiLwuy4b4gMa5TDYTapK4cU220eClEILFv5vUIpO27h/KElAKvYcMKGE5Dtdc8888cP8D/sat7io+XMhUAZ5OXqd0sBIBszbnobCbK16/HSkl8fESolRi9S0ZEII2mfDb7KjdjbTvia4DTz31VOrr6wNQ3G+kEKMsX8IuGuduqSC7TQP3pqTz5s3jN/ERvhfvCx6EKuF4NETAY+T54wQfmmGj1a91TSMF8NKZjYx4l3l2gZuyVVK+LrAHvnqXarBHMdyWYOGihfzde99j0rkIqbRbthcRHYVAYlkWGqAPxraSBTwu9A13KLw4qFpa1quPBpgDdqBAEQ6Go3zG7mGyjUgAHELJ0Oz4kvDAez2u58zpoaGlmQJFZj9VMMdVwOY16GiARxumucKXwmjG280NNj8UIqTzWAZ4+8/LpDUamhZWhat6mDUblMSz8JwTrasMs4BD82QsI6N9xZPD8IZ7OHvTby1TD1Xo9+dtaXYU1vxiIlpBAXLkzsr5LgRARwocwdr1H+1bClDGAA2/UWP94yT26Q9lJTyGZrTMAO0yrv/2p9wQg1ZE81RKISwR4OAV7RB+z+hnt1DM0qQoYVGsIjv452wHAc0/0aRS3LJLA5p2SbHuKd1v5z4nadgrcceCF9R2d1vF9f3xJC0N0N0WPZ6Iw08/K/jt10RVXckjl+s0AN+/HS760hzutbZRH2JojlYBNAshjQzXnT4NPdsWPkuzWAo+1EYmA+BpIsRkS+QhVSPwoLNF/7s3looAdX0TWQYyQflK2XjNGJqg3c5HnDiHPYEfGOjxUETh+owil6otoNndJhhyEswaiO6mNo/qfwdiyZq7nM9qS2MVgqlrKFNgTxmgGUtPfzutmK/H5Z5YKjLuPO3aopR+wCIvSM+k7dCYhuNWT1+5GjsSNIUATU87cyY1NCFwO7cUnHWn7k9zdyku+4Fiwo7T1VY7/UzQrFHLCnQ0kyLJp//2av/8kJNgTntNiwRAV0cd2xJpBHDhBvirX+ZJFIMydbbUbgOhMW0YmlUAza5+GHdizKpheTxLJwV5YdM6AnUGmHlyZJzx0PtFuvZBQPPP2AqFAldffTVnnXUWJ598MpdddhkvvPCCf/573/sep512Gqeeeipf+9rXIu6+Tz/9NG9729s4/vjjueyyy9i9O0DGc7kcn/jEJzjppJN4/etfz+233x6574YNG/x7Xn311a/KRcN44xGofJ+vudj+yCj23iF/4alQLPmVfkloskvQNkJA74Le0CZFGZOqynC3MIFJQoytaq6zv4uNVjCzPKurS0VdSA1oUDeqdPRjpRleJ510MpqhGbR7RCsSwU9/+lMAzW7ymDkKBC7lDEN/gR2uqywYkBQcxzFsqVDZpNQAZ3EPLY8MYO8eor6+gTlzZhOAhqaxsi+AFSM5qlBugZ7HNZCrHAuKrg82RFx8pdTgjamPDyAUBxm3Ha8yoTp4FVIIs+rdEUuiImCnwHNb13hIANj6EK8fedyAf3YTCkUyB6knDB0+Ergm5AOJIpUNvl29Ms59NE9sUvlsOqXguAf1OWXFTWTvENQuSyhLu5zrdgwDKfqZvLC+zr+rZX7JsLs4ViQatpKSVc/qvxM7R0n0DZMX0iAIIWBXQfPNT7Hg3m30WwV/7aXQwKQXbErrjepLkuMSZcosFDo4kInSLfDAaD0O6+rS1NUl+dg79UNXMsTQVCVAsbbtLsptdrsAdzzybJIJC6UUHY8Mwci4r0n4gNjlA5oLh5Kkh/MV+TU0Ngagio9BakAp67v+mn6hMM9cZ7p8xUoAXrRzSKPtGTwfQsw6jBu2ziTMyCsISbnLeYS9qVyUnTC/A1bk7PuHYa9etFVqTuqR93Ao+ngArmrWs1UKjgmUZrB5DE1zVCoNdh8/9zd84C3C18rXWKPrlZZEqM/+ILmHcFA0JSNhvaLBnlQ47I8GEV2PkZwrYI/nsCzYdFxnGbgV3o7S+SQazQf8yCizHh3z214AludeHXo+ss7RQb+M1WfwA3MpS0tOABCbhQdM+sIXoaZW4Q2dMsRRySgrMJiWhb/B8oKdxYi0ArDsV6PR65TCFeFNlCrtEHlXmEOFHN2PTei5Q4XfawI18XgEaA3XyYtCH7A7I8ghIOh5omDwzgAoDRjI+i+BoGm3nnPDm16ENmLmy7rIO9CTfwnmYBk5F66jJQkY6qiADW0JvLnYwWblJsA6CGgetD/SNg6NsduAKas2KZ+JBTD6xBjuWDBIHy8+zu252yLXT1gOn/0bwZtOjOZ7+hHw5pMF3e3VF4vJhOCYlcHfv3tc8NCSvyM1GQyGagzNYgjQLMnpBTQ+fbGgMQ1ZK0Yyq+87FnKDDzM0RcGioYYMTYA98VREG7Ivk2UwBPqU8rVlQ/V2w6gdpyEDKzZXnq/PQCldQ4QVDbRrQDN6vHkUikIwasepr7FbZ2d7mvqBAPx6bmSC3dlg4LWMqhoBmvrfoVgiElXck3ooDwgEmqF51ArNWJwua5qVLGNoeoBm8GHrRTmfDrmJqay7LdDRPPtX8F9OG1f/s6Qup93RF8ypIbqKZkXPbgsYmgBz8nP830OxBLNnANBsabDZmgx2d7J/CPr2UCxe0zIl4zCWSJDIVvbXzn2KMTvOwrm1p7GmEpCz9FJ28VZ9bG+uwFOZYCBK1zrocv5nbK7rMmfOHK6//nruuusuTjrpJD74wQ8CcO+993LTTTfxve99j5/85Cfce++9/OIXvwA0EPqhD32It771rdx1112sXr2aT37yk36+3/rWtxgdHeXWW2/lmmuu4dprr6Wvrw+AF154ga9+9at8+ctf5pZbbmHXrl1cd911ta/8AWxzqsGPYg0egBUsj/1Frr8AD32LCb3+2pmaDK4F2oxrdjQmq38VIA1LSFOFKmDLHV9gs5ONsuzKTHkAk29RwAxg7Zo1HHv8iQaIMveOsA3NTyG0G64K9NFU9gWU+QbeaxUr2DEiEpzGAGRCYNsaIvAy9xbAKA2oeQFPdB0ky28f99s2JwQFYbHsrkkIBbWxtgwQe3FvqGYCZdn4TKqweYCtaZswQzO6OA7wP0uICqA3YCLpYDjBelsf73jBBBkxruQ6kq/CdqGt33Ndlcx72PQFGYpaLgTr71PUjRpNyxAI5rlSCgVKKCYNMKTyu0zXiQIWAoElVQSUyM6O6UAbQtC8rehrzwkEZ9ypDJPP1N30x5sSA7oEshTCRXWiHyT6EcCAGqdk5BK89mnaFWbb6fYJR/eW0m98XQapNJCpFKnhkj+eBAKXoI+5xmO+rUl3nrCOqRq9G6UkDfFRyi3M4vR7ixD+WPJHtoBhlfN7hI3l61iec845kTyVUj7omxqRoEpsm53ghuQ+MxY82E2z/5Slo2x/5jNXhyQSbfTGgj6w7r7JQBJLlAfBKgMfQ2w9hI1jgxBWCAzyE6KDUaEjs4cA1zDzTZjs/KIJCP1F7w7B7L3huUSyZs0aKA1DfodJJVCqgAB++INvMG8WfsBDz23Ze5ZHPu4/CgoCKqJoBxg5kaBAZk7xfkrl4qLB0NieYeqe3UV9fT3p+obQeFWGkKegNEwRiYvkuZPm0zFrFqLkEht3g3pHwMcAAMyuagUnuP+bbgmx/ASRQE3eO8KKKIrqhCrkUi+IgtgoVzMFwgn8TS7JMsvzWg3Ghe7LJf+oz5QXVQDTcOOaI/5Zt0TTrmKVLTOhXeF9MLK8kYxERGhYI6D3gWxQdrz28TaFFFK51O8t0bY10KXu/X0OLJBuIdQf9P1uTwzzqDNadu/oPBdmHfu/Fb6XgbcBIiJB64LnJYAjN6qDgOZB++NttFhiWaNGBY56JHpu7Ilx5HhIM1JN8P3s9RRiGmB4qq4Zyxa8/XQ4YW30A+a41QcGPP7q9Gia0bq12JkAkKumoVn0JhCpKClrWjX03nyy4PYvCTKWQ8pgKdkQoDoeAnysvE1TunIamg7rMmzYPbGUFoo2ZXopk/WD8CRzigwOsRoSInu7BSMGXDliY2Vb1GdANtQwIhAG0IxVBzQHnSRK1C4SvF+mzibq+0OA5njG31QAzdBM1E2/y/nyefrfUTsWYWgOFypdvBuN28q4HaO9aXrL1dxqka4CaO6rxtCsIRY1u01HOgf90k0+MUrcaKGO2zGWL6qt2zJoaYxBJ+jAJ8VP9n/vjNcxZ4oNpem0xjS8lAwmZmsgxEZ2EhVs/uk0IQQNaUG+ULmR0tUPA06CRfOmuUNXsXgMCubDbu0zwVy53Q3eKSXpHGRo/hlbKpXikksuobOzE9u2ectb3sKuXbsYGRnh1ltv5fzzz6enp4f29nbe8Y53cNttejP5kUceIZVKce6555JIJLj00kt55plnfJbmrbfeymWXXUZ9fT3r1q3jpJNO4le/+hWgox6ffvrprFy5kvr6ei655BI/32pWKBSYmJiI/JfL5ZBSTtt/AOO2pUEiOzp/hbkfYSAPw6DyIi9LBRtbQtHGgZ6N+iXn2BZK4d/v3BN8VJTAT1CDPketwE9LcZ8GAwlcSHU6ae4LrlSRUlIWDCKZTCAsixUrVuv7eLcu5VGOhrHecPa5AeAEvmuj8AABk+cvEoNRho2Ps3qLxCAg0eqFip/86NsUjO6eF/AhFJvWLMr1X/EctG3VX9u7rDwDjtHoC4M42TyiEOhKokBYcb9aHvMwAgxFCuuVtXyxr627kCUcyZzQFRrblGwRWhOShhSl1hSxvFFFNEDZknzRB1UahZlMlUvLDg9YLS9XYOGyaEkC169bvdK+3BKJVVRaM9GrjQGGhAqCYNglxcTiJF7glZ6NeR9I8etngua8dEwSL/L39al+fR/l+kw0fR8NhAkFT6ldTIiC//day3zYCYGSekzEkgkUSj8TFeobAlYV6ozmo3ZD7/3tCGHmr2aOWtybHCdfUMQc5fd5KYMgKYFjKVXHtG7TaJpSyQSiCY0Z10SnntWv2CZGKVLkOXuS6667LpSf7QPCAEt/kwVVon79oaTqkgZUCh6kkJrN+/3EXhoaGnGlIpFMopnSwXdly64QiCOizFulIKr/HwAwCAdLSFAFPJdz3FFz+2C+ONOdF/QsHRGLiPajYSDvW9pRsXHStQ/mjHgLOgXK5VOf+hRrlrXCyB3MfyhnylxgF6P09PRwzCrFgi6duQ7mEmwCLHuhHKQNszCjc1x4w6W4eBbjazxQT0s/SD84mc7vhBNOIplM8W/f+Eao/YwLsyrygp3hrPNez6rVqxEYIMfH6oQ55iGqAQu8/UuPIPb2Y9AyM4YMkObtZAG4Ez6j1sunsq4mfxn0yRLSSFkEj8lrb2E2gppJhfLz+r4AQniFVJHxGskprN9Z5i4QHndYQX10cUI6psZa+zQY73tvGNKoEFDf79K4Vz/TufOCoCDhKVhS4tR7FT2P5829LZ0fAuUGfcVMbGy3PbmRqFt5tFghBqry2kZ396etTHSuDaP3HqseYZicFvl8flq/NcJz06vBauu/+mdop3a1cd9rj2HD/3mE4qNDkXNjT4yhQsytTKyFsdwk6S8u4kefs/lly2yOXQUtDYIT10YBrONfhkvqJW+AJT2Cb/1CceOvzcFcsPitxtD0pgynBEXLmXaX07YmyFoOqSwMN0M+FHUzDGhStGvGFvN23PbGU8RKGgAbatUamqVSCWwNHk46omLCnE5b0K01NAGOfhT+6wKJ64Qi2GeA3tqu0LtatUtu+67o8ZZRrZ8J1BzQ7Olu4akitA0qBtsEz09OsnIiGGgtI9BfP/17NemUYH6XYtvuGMkqUcX7yzQrQesytk4ziNjWbBHL2HivyL0G7N1ngE0hFQ0TkK+rnYYmwJwOuD8WdJaJJzM4aGB6zI4xv6v2dLqeDnikoY3zB18CIG3pSWjASfBisnFGGJqNdUQYmmEbcmrPGm1MgzuSIp3Jk0nr+dApKubvgCcSdSxsqW15QH/IZs2exZpnqqcpSbumDPuDNrP2xBNP0NraSnNzM1u3buWss87yzy1dupRvmMXhli1bWLw4iLSYSqXo6elhy5YtpNNpBgcHI+eXLl3K008/7V977LHH+ueWLFnCzp07yeWqBzS7/vrr+fa3vx05dsEFF3DhhRe+MpWe0kTETdQzhTK6cUEEakxQm0KxyNjYGNu2DTM62kyhUO6qqt8nuVyO8fEx+vqGAfjMP7yWb//uGXRABgNI5rdTyu7k6IUlHDdBX1+ej3zkI1z7Yw+wDMrV19fH2JieRPb2Z/AXdEJEFtGve91rEQJmNw2we1c0mrLKZml+bhzLqWPu/MX079mmmS9o4G7hrQOMHtVtEqsQW08hsOj9fY5ne6IEKyXAMmvStsR22la3cWGinyPpNWxAK1hwKqivr+feOVnURq2z1vN4nr6VZd+PZYw13/HU05EMgVsygggEvx+tbzdpvOqEnnNY507ocxGdQgXdTxfYNk9rvA2ILLMA5rRT7GgE8rpU8U6w4rxgB0tEgTDgYYgZJANmavCt7JcstJ639HVe9GIFjrBRwJy7h9kyPu5hLL4mqCXh9w0dIBSrbs4wEHfpVy7CEiy7a5J9S8rBXA1ulVIWYNHW0RrgfNJFWdDbV0YUUATMLdN+HaKRAnlAsG277pv5c9bSeWMXYkT413l1cyTgRTn3QcCAoSkthSXhhViO/oER9uweJzsmKeTzlLv9C6GYmJjwGeGe5fN5P40HXOzdu5fh4WFEh+UfA8+NHQ57Eu4VfUhVYntvA+Pj44yP653uYXUoDepBQGkNUJNvJpMlkUj6rDhl2sQLRqIE9PfvxXXh9NNP5+YN/6PlGUxrlHB9EpwGj8KkmiAoGYk5wfgUQHEv85q34ez4JKz5mm4XmQUaNDiIoOvZAp2q3od0BQSUV/A1NIvFIi+1Omzfvs0vlyAEkBsbGx1idHSUm266iWXLltG8swSHWyDz3Go/W/EMGve4gURANe5NCEANR3TfZ+XMhoR5QoUSohRlQrooPwDW5Zdfxqb6PMMjRd5+9sk8dvV9uu2MzEVDvx7vH/vYR/m3X0wwp6nJgGv45dLzm9evwrqVoFTwvAilEx6jG8Cd9AFN/z0RrmoowE6op/BSTOEH9wkmKK/mSNflKaufiY42fK1hD5/2XbQ1QC+F5IVkPWJ8L9EGN5sRHu4X0fbUc4cAXFsgfC9QYdjdoWqjmLsxz9D8GB5zXpi+LoBF9wXax/mEwzO9dTDstYnBG1WJw90WttsDUX1LAVKFgwKJkByAiKTzSMZ+7wlvAoQ27QAyEXkMFdo8CL8HgoBufX19087S7O3tndb8/xg7CGi+Qtb+SInRXPTY6BNjWJMWnjbvxLwPsLTnNF5oXMH1ZtfnvUfrDtkzS4MjfXsg5sARLyNorBCCUw6FNQvhZ3crCkWg0Ajoj72qgKYnwluCQg2CgjTXw6RtkzTfxsWYg1QKCxjPBS87WbBpqq8NeBhzBO1Nir0ZDQ52DGpAcyBfxGh+0zAB2VhtCcyz27QEQQlB44Ri7UMZNh4bABvxSQunrrZl6m7T0Z7jZWTflhHFPgNOzZ1V0yIxd04LOWuMnt0w2Abj0uXB/mAzoXWkNgxNgJXzoW+PoFiMIYyOkjfu9oZcvJvHFDlhkbGcaQ8009oIRRWjbjLPZJ2gf1JPTB7A2pABW0Je1G4TAWB2m2BHIrihe5/0X0BjTnzamavVbO4suKmuhSEnTmtIyP+BxlkoIWYG0ExrQHXCcqgP6QpNWjbjdqymDE2AhhQMizo+e+0wDx6qeKphF6/bNJuWUdjdU8fRzbXb9Albf1L3ntl7oC0vGEyUrTIkVfWnD9qfn01MTHDNNdfw3ve+F4DJyUnq64OPm3Q6zeSkXrhns1nS6ejEl06nyWazTE5OYtt2BJzc37XePbLZbFVA8+KLL+av/uqvIsccxyEen25PC0HUBVKPjabWVubX96B2B4vcrrt3MJDNkkwkaGxsZMH8RhoaIB6z0UvfaB7nneSycUcj8+c3+neLH5KDXdK4hCoe+d23OeQQLd8xf75O8/nPf57rf/dDGAgtxID58+fTaLJqbasHWaB9a5G97QSrPCH4xje+weAonH0K/GBDPz8mtHxzizS8NMkP24f49dlNLFnUBDJjwA9JLC99HE5Kl7X/m+FB87iUgKY9Lsz2ojCbxX8hx+JfjvB4/Qhz587VQLA577nze26Gx55wHO2HHcbDjzwKFWhHOTApaNta5CVC9xKYCNs2S387yVNYQQRpf7Gq/9QSKWG4M5q/p6HpXTfZFqN+GFTMgmKJji0Fts0nIkmgnnkJZ3EaiCNtgSINwonkL4BH0y0+6+4FJwsqYLgKMCxY29Qp6GO6eq4fQEgANoL2u8YMA0zR+VzB3E3naUnIWY5xf4bYUEkHnkIHchEqBHcLfHfZxb+d5B628F9f/VceeP9NKLS7qRSwbDNsCtHHtKtnVEPTr1BphPnzdN9UDY1869v/wWcv+Lq5TvnphQIxmaf5yQFE9ywN/IYYbNZEgbbHMljJJtL1zSzqbSadgkRyT8RN3nN7b2hoYL43aIx5oIRy2oB+AGbP9qLFWrp/qACUKvqCrLo0tm1H8mwR/+0DQV4gLZCkUmmklIyTo4CiCUApLBkAr7NmdeJKWLy4kzec/UZu/vcv+A+hZDZRPNBRYsBiQ8H2Qe9Yc5TdVRrh+ENbcWy7yjPRQGjnpgI/cDbju5wrAa5kltNMFg/fsYjH4zQ1NTJ/XmME8HGReoPC3Pb4lVnmz58fZcAKgZJFQFY8Aw24Sx/Ai8LpQIh1F3aF32llUSH2Yep3z9HcPIF6TRAQS6F4ON2OANo7OnjXe1v48Ddh8cImwACaykVYFovuy3FXXDBv3lwaGmDPmw/j//vb/4+r/+EeHdfc32BwTFECxp8GPTUrcbcaQaimQFNTCF+ewDwUEAIbwbLN0Bdh20blJIbFJHusHDgdvixEx+YCfaHyeGWZFEX2rE6Q+onCe7sIrBADFVCSR6ydwGzzXMLNHN0QCz0eMBt1CkgO5LFCmuqRYGahzaTyNgphvAAcffTRjL35KPbdfgtqOHA5N4XxLsNCGN1P/X5TbqFaMZHAscccy692DNOp6vEis/tyMBFkNJA4CCPIA1ZB6x2HQVLz7DwWOULQ0dFR2Y//jO2gy/krZNmnNWhQosRTxScBKOwrMM9zXwAmbIdNmTP5xX1Bhz3z6CCPay4VzOuEz/6NoC758hdibU2Cc47Xv0uFUACebKEibcks8GJFKNYA0GxKQ8ZyaPPwJkvw8OAoAGOTIcC16NDZVjs6TVerdjkHKtypQbMhc8nagGJ+mdoAEbidn3pXFJBWOYfUH9EvXglrqoeJuEWxjKmazGtXXcdWLJs3xcXTZPN72slbNj0h1uhz5sVluYqmMUjWgKEJgY7muJUgZTY0Ro3UQxjQbBqDwVgShKClYXqfYVsjZC3b19EcKBTJu5JdBths1cQahhO11Yid0wEvJhvYbcZdohi4MW9Mt84YoCmF4L7GzsjxBxo6AGYM0EQItiajk/NvmrppaoBUorZzgA4MpPWG33AHXHFTA4c+pc/tiqd8xnutbSCl2b0CWNtXeV7ZtW2ngzYzls/n+eAHP8gJJ5zAueeeC0BdXR0TExN+mkwmQ12d3llOpVJkMplIHplMhlQqRV1dHa7rksvlXta13j1SqeqeE/F4nPr6+sh/yWQSy7Km7T9tBnSzouyaXXPSpOZ18uY3v8lfZ8bHdPRW27YRQgd01DpsMuL87S251h+RRggi99zSW4e3Ghwmy2GHHVa1bC0trZTDAF6Z3/YaweqFFmQ3M+dxzZDz2TdKYVtay9KyLE5Z5+l5BmUTQEEojlxh4TgW9H2Ke2KjhgkW0keTQfAOS8FhJx1HIpHAnighQptaSkksBYm9XyxrW1B+QCKd0VVXXYllWxFGjsY+BUrmfJaZ14Y9jxt2nk4KwOPJBEIIUiPSBFkKse7CDK/SWPA7VIbRHqeS0xkCLes2DZN4arsPIciwW+x4VkdrB+xJF0bvxQtSE174y5BA32/iJsCTDs0b8DGF+aiYzNH0kqfDammmmArACYXAnvCAWkXXswUeiI0ZcM5IBBjtRoDWe8cjzDAfWPD/1s953c8nkAI6ZoWYrLJkIiCDJSy/X2lNugawEqZaIRbh9muIxSxf8jDWnuAxsce/zmsWS4IoudTtmTRgrQ6UM/vJvG7rQpHkiGafFUs6/oFlaa1IpTSzMytcNji7GFYjxGKxinHjOAacstP+jW0TrSYAUE0rhKIrvyBGeFHtQEpZOUcoGWG3aZd9QbFYZDP99DFgWGhG48/k6dgGKBXoTZxQ39QMTctvF0IbsioMROX7fEbe7Cfzfn10f9QgXytx0zWkP34lAbvaY7OtEXO9P3Q6Icz8FIA8YGKZS8XaDRlzPyJt67WldqFXVeZUfY8wviSUpGFfyW/P+Q95bFddlhHL6EKGtT4LLvHB4P3iyhIuIJWgpErY0vQPAbGY4BnHRM5WJb9tAWxL6IDvjsUJZ5zAk/aof48Hk3GEFTMllt4+TCSKtrA1gKrMmBaWIMwO1Bssurcd/kTQ4XXyUDsorbk7IaIyFLOfKvjtLzyQT5aCOUd54LD3+EreE0BIl0Gyfv7hmd4DHzUwLYhgsChm9/Twkp2j6dkxrPFJv5xKFkOIV9m3oRd4SpnNitBr84EHHgiCg6kwwKh1ex+zNZ5x5OFH8IlPfzLIPuwhIbyAS4Kx7npuv+1Wtnnu5zIQkgj6tjezBzssQkC+2Sa3qJ1R4QWzCoPFASvcY+i6rjut3xrRsTHz9uoqzf+jVhovUejTH0JD9UM8WXrSP/eaxOn+7zFbTzC3/0H/3dkKh4SCJ779dEHff1t8+K/++IXYe87V1+RVnFhBj4rhfCVD0zWLPKek3b+nG9BMxAXFuMOhTwazzv/0aa2q8VxQvlIhxuzO2vm/drZql2kXQcdg+Y66ZmhSI1DMMy9YkRekZO32BrqMC0DdpKKUj5OqbUwghBA0p3MMOFHkK5GHfbEES3oE8VhtgYO6VJw8kp5dlc+taUwvUpINNQI0F+i6jzpxX0fTG3dhl3OtOaofXmsj02ptjTr4kAdoZqTi2dEJf3k0W3+TM9FSV1NJhdntgBD8prk7cnzASfBQQ/uMAGMeu/h3TV3+sWw8xlPpFkCzpmttjYbRvy0RnQ9/0TZPRzutsTXU6UjnntVbAcV4d7xuxgDNiZRFznzgr93oRs4l8gpV43npoNXeSqUSH/3oR+no6ODKK6/0j/f29kYinm/atImFCxcCsHDhwsi5bDbLjh07WLhwIY2NjbS1tb3sazdv3sycOXOqsjNn1IxemecWrQ8JnLjD9uMX8IMffD+0MEMvwCOAnV4gSSR2KN1VV13FvHnzuOrC6NhSHlin4Cbr2f0WTRGKALzjKwC87zzBUSsFy+dbUNzr1yEMloTjTJRrdwV5Rr8JnneywQJeeeu/IM1HP/8xJs9ahQIanxnF2TkYLIANO8a2q2xsK6k1EyHyDm2ob4iWQSnI9WlNOlRkERouqUDwdNzxWXDPsJenVLBLE46q7efr/9R+8WNdTgSg2mdLkJK6wSIrb8tEQF19XQniHbq+hSIiowGI1jsHdLvLHBSH/JL2YD5Qw4w21yU5UjR1MHXx2iObo3Gr/ii6NbaLPNmARWXYhG4ELoWnnUmfoblZZKCkUI7tt4Ef7d1rAwPSYPqrCgqhAWZTMmVYYy/26raOgMXJhWA3EurC1YhVWCmH7WLMeyAwqNsrHNDDd83GpePFIuEAN0IILj9XYKrD8Qv+4PeHnVYOV7iAigBs/r3N2NR3McCzbXPTTTfxiNXPqBpnyNKAkLSD74ZRq8CoGo+w1T0La2h6lZIKjj/+eDxWZVhf12uVZByMepHphlH9Tq/xltw6hCwZ92alIRs/uJGc9Mdlxwu6/xQKBQP06rHXqBzWPRkw3rw7eZqOAoyrf1AWKwT4JeLAtk9jGh+F0gxNU+fwHPKhD30oaAVZ4F1/fVFFe+lzGqQK99uF93ngpKR5ZyjYmiUYEMUgYni43HjF0uCtUgqnYPGc3IJ1hN7Zv/ZyDc7eHx+nZ+N4hFENVkQew2OWe8Dl1phFwaMbVomOjoBJYbFb5COZhIMx6XnFYojJ4Do8fNEwdoW3rRCdj0JYp3kXKTMWdB1atnlrf2EYwiFQ3ry7sAJgLgLcCTPX+3Odrl/bliKuKhE/tJc/tLuGNelXDi/o0ELjSq6CUyjl8tKpzXoDRQJWwMKM6D2rALDXeUg+nnoegPM/ewn2YbPot4oGfA/pM1uWX94Ff/16rEQ4DwjP5whYs0Ev3mRdnFx32j/hxqA4uwkfaQ7Nd16BR8n75T4YFOig/dE2+viY35lKc4v8On+Hf65O6NXpsB1nUypKQXrL+lfOJW79YbBy7hgZ2yFtNolGqricu+bFGCtBUdg018DN20o7HPYE2K5upJt37UMpxXg+mDyLJWfamWth62oFKSz6Y0lm7as8Xz8BidbaKjK0NGi5Aa+f2MLmdTdt5LW/Ubzv24qMqD2gCdDeVKQ/nuQD/65fHC0jisMfh4FYklW9tS8PQEHICEPTsxa9WUayoTbPbuV8/e+IEw/GXbGIVKpCQ3PQaI7WwuU8a9k0hQIDPTAw7P+evUfLYxfaaqvHOsewHX8TAg8BftkyBymsGWNoAjyXamK4WyPN982ZgyssGtNQX1d7UCyd0t8n20Pu+SN2jB2JdM3dzUHLhuyNV/aVUTtGxo7RMQPPDSCRUOxK6PfrYfcoPrlqEamC/ihe8iIQPwho/rnb5z//efL5PJ/+9KcjC4+zzjqLn/70p+zcuZOBgQFuuOEGzjzzTAAOP/xwstksGzZsoFAocN1117Fy5Uq6u7v9a7/zne+QyWR48sknufvuuzn9dL0xfcYZZ3DnnXfy3HPPMTExwXe/+10/31eXCZAllBAsvC+rI9XaFscco/U//TWZz35RPhgghN5cxyzb/Si3SvEv//IvAMzrLAM0zcI5YNpUNy2xGWKWFHYCsHB2NL+UsowbtlkUGt0y7zIPjFh980QEIQgvNr3K6HWfMBHYIQyhvec9l6GEIJ/LoRfVOt+ld036IGk1QFNFgrkEdJ6lS5fyute9TqfxzkWv5HuJ3eaX8g4ZUC7QbM+LEjmCgDwoGWWcR4JdSOwCHPvtEf9YXrjsFeMo5bLwd6PE81qT0wqVSypXA5qAGs2QenhHqFQylH/5xnHwt5Au6f68TuiRkRAkJjTL1Htgp7/9fA0ilmFoGsILB1fSoEHTjjxFJWnanMTu22NKpKJ6oSiElEiPPUWUvWlbfoGQsogSsHmRwMLyAU3NtAxAOGFAvIoalx0QwJr7C1iu1sf0TqdGXO63BymovJ9SGmbdmWeeycLZwTNuTGqQu3Fb1m9plOTd73435eZd031Xp3+zuro6zjvvPM7/wGXkKfDTpA7iJZMLfV1JsHBiDieddFJFhaSqfLbNzS2sWrmSd7zzInwgU8KjVr8PTh29El7vywirYNNBGJdzU1ZbBuOp62kdZEYJwVY7F9VrNJbJZLAsC2VZqFKRrfYk3Xs18CrMOJbCzEcCkBrUkqbpkv05xPhk4GUuhD8XCQSuUr67ebl94Qtf8OugVJ6Ojqk+tHR7vWRlmKAQcdcOB/xS4Y0Lp0FrfeqCmDk1yE6qEhJFx0sJXFycOr128bEBpWjbmjVar+ZKK0EypFoiwpOjEGxzbAoCmnZHtwx8B2kFMr+LEYrBe1PoIFh+0Uxk9hGRJyvcIBcVAi09vNkDaxWE5Ra8Y91PGxDRAJptLxb90iz5XZb/SuxEKcmS30766YQQvtwEShGfNG1oaaatQPlVRsCcJ/KUKLCntz70pEz5QptjDfu8uqjQTBJsSHibLQA/TUTdN6MB7XTllRC0HbIMO2ajbIv/TQ6x/OZRXDfkISsAKWlqbmbTzkQEjPY2aRQKYSIhCQ8Xd2xSe8IsU7RWLyDCDE2B355ZiiglEOJglPOD9n9hoxsDF5D6tWl2y908UoyGPN/QNpeCFf0wuvTsV27BJYTgqvMmmbBi1HvAilv5Yema7cFYEQqWVZMox3aDQ/0krNAbGezKF3lyZJyxEOBTLMZqGqDEY0PujafoGKw835BRNHTWFj0UQtDVis8OA2i+p8RFP1GseU6zAFO1DXIOQGcL7IslOexJ+NePSr70KUWyYADNBbUvD0DRcpm9Bz9CvWctI/rfdM0YmvrfUTtG2jA0JTBRLEU1NEeDaNrTDWi2NcKk7dAYTEvcvy8MaMKeeIrGxtpO/52t+v27K5FmW4sGDyVwR7PWyWmbQUBTCcGNpx/BCXcfy7dbdUCQmWBngp4HGurgnqZOJmIxiFtcPe9QXaYZcIGf36kjvrtlx3fFNZg4UwzNhjqHnXEN+tqu4NJkJ+/7+Qt87F8kH/imwkoe/Lz5c7bdu3ezYcMGNm7cyPr16znxxBM58cQT2bhxIyeccAJvfvObueiii7jgggs4/vjjOeeccwDtBv7FL36RG264gfXr1/P444/zmc98xs/38ssvp76+njPOOIOPfOQjfOQjH2HBggUALF68mCuvvJKrrrqKs846i87OzqoAxMxb4HLesM9lr5jkxl/8mPp6PV4sR2AbapPHMHPMt6EQgsOX6QW6a+AmDzKaynSgWy9id/lMETbD1AL+O7GPK664omqqM4qtmiWjJP+TGDTlCtZvHiPWLnm1NXqWoZXi/fff7yGoeIF7dE11PZpbWrx1Jjcl9plr9bnUmPSv84DuSC180Fbxa7GVmFlEdzQLbt6wgfCCPkqCk5REcMYjIGkwNcLd8n8tu3MCz13bbwjPjRTNBFp98wRtfdpFXKDYbmlmnFQl0kMlFBqetkOQJrIEpRFeSDaEQA8NQYVd3PWiPVyJELsxQhPCZ1Qtv3MSjMblmHDp7p4NPqBk+UxG17Ctovp2LvMfmgAlsMe2IMLBQ70I6KZhhasoOV7TekFFdBmsMGpgAE2A59jDS+wDK45QCtcDp70msAR7rGBtsnSuiAAQAELq/xCYYC667zTvdnnRmdTakboUSFVi0eIlzJ07N5qH0IDf7IdGTAUUH//4x1i1ahVTmrTYJ7TMRSKh1ycNDY0hgFsgh+5guwh2s3/96zv9ce9Zs3pQAyLmukccrUHc3t6GZVucddbrCY/Vp9jnlzHmCBJxwbknCFbNHSPM0CxZcX+Q6qjWuh06n8/449P1+pMBxbym9V3ObcvoWHrgoGbejlgln6HZ+0AWS4GSkj+IrSAg3TeJMzQGlD0sr+mUxJLlrNTAgmFZrHje+ngIAA73F9MukWBZ4XEhPJAPeh7NUcLF9oI1WDpYzR4x6bNhq7rxKg12+yz6/h8Sj1Utormvfia9f8jp8fT7IX8zwQOZLTcAFUGBLVCuP6ESBDAzTEkRqp1b8oE1hfIGvglEJiNAI1Ixa9MkoLVsg4z00wTIC91+dcNS9zgTKV2YMY4tWPErA3a6LqmB8GYPoWehcN2gLFaoL0gVBP8SA5OIgRHvlYDPYlW6vEIInnYynHrBuZH2lcJITITu99rXnUHh9Yd5pGYAHClwCYGJluVfs2ah1zYBYO1VQW+o6MZe8ctJEIrYaNFvSxHeWTGSAF5enoYwAgaNl+dBQPOg/dE2unHU/506pBdazuTW/K3+sSxFbmmJvszmzoLVC185QBPgr85sZUK41BlAM6cUOTf6cSlN1GzHBAWqRVAQp1F/cRz5WDAYb9u1j5F8APjk3XhNA5R0tuq232O04cotPSHonFfDAhnraoWn6pr9vw8pHur/HrNjM8LQnNNh+QGA2ochab71BmIJVvW+sn345dpkHBJFKliarSOanZiuEbOupUGD0KNOnMZAso09uYIfXTxWUKRyQVT4aY9y3hR1OQe4f9+I/7t7rwaoarmBADoYV6fB6r+1ZA3db+7iP9etYV88RWOamksXgAbj4jE9L20dsmFBAxM5XY6ZAA89a6yDESfBh446kfiPT2FTnUZ7ZwJk7Z0tGHfikY0WmHlAs60lxQ5TBoCJFzK4wy4rNkO8CHaqthrIB6221t3dzcMPP8x9993HPffc4/936KH6nXnxxRfz61//mt/85je8//3vj4Bdq1at4sYbb+S+++7j29/+dgS0SiaTfO5zn+Oee+7hlltu4Ywzzojc9+yzz+a2227j7rvv5tOf/nQNAvz8X5g76oM/AA9ae5izLPgGtRy91GveVUIAjmNzyKGHctjSMHVEsoMh7kAL5j4p9k59O6nZUEIFTJipzIu6O2q5fPWrX62a5tb4EKO9dSAl+yy9eA2DDD09PbztbW8L6oNeEIYDNh177LEcd/xxlCjxtDWiI9gC3iL+jW98o1mEKo543akayCsP7AE+KzWwIOCSAg3KWYL3vVnw8b/W4Fd4Pe8VPCM0SOqxrIq45CkahhNGH9KAdenV4DQDkJiQKCR2UYVzjZQzyhkSHg4BIc03zdAMrnVlCUr9QTYoinjspQC0RCm2W9qtNgr0eACwAQkQPFLf5oM9Hubzk+Q+Sq4LSGZtKqDsJt/9X+Kx74I6SC9SsQQ1sdGHeiUYt1uMNqoGO1w7WiKvNL7LudDRlT13/hEmed8/XQWyYAAC5V/sMX9vTgxx/fXXA/C350bb248KLupQVtKPnB2wcW0fIFnOLFIIZnXMqgqSKeU9E92Wp5xySmWikMnh2/hfSzNDGk0krcxkhjCqo1SJvZZXRod4rHJ+auEPSBUA6tm1c/mnf/qnULl0iysUWA3I+rWU97uTDxGcvGof+DIAgn0NqwO2HsJozZp+EmIwCgTSMDRvTGiw1NPk6/zDEMLzKBLg6VHelBjwAc3GPVoHVymXSatA57NFH05c3BQlE3n5ZG0bSeBpUi639OPEPtNpi35beuYx9D0ZCgCLGFGGqx4LjXtKRAIggS/T0NZXwsU1Gwu6YFKagE6FflBTAJroKOcKwXY7D5NPR/IvlgBZDMZdCKdEKZp35lh0zyQ7RIYR5ckmCEoWDK/Tu/rKslAGL+jZmNPgphAgLKxQn/bK4ldBI3G6kd1xgmjlgGVOefIQSvr6s+ExH8zgJkszBygB9bsLpoLmXDbL7EcnzH3L50JJqVRCSsUkRSbUZOhUAO7Z20YRYxlesnPMfyjn31sohbQFuJKdi1uYNz8aIEIql9i41qhdcfsgKMWOHTtNmYPiWAhcpSUnEhlJcssg8Zd0+pULAiBTd28JSte15/cTMGk2LCYVIpvHmSgGTRPZP1L+nBZ96IKH69sRWJRKU3tL/DnaQUDzFbDRx/QEYaUsLt9wKKy+mQe7XsczxacB+JG9mQknup3ymb955RfvqVSSjMj5Wn4AI4WgQ5ek9HdVtMv59GtoAsQb9RfH6pC00lMj44yZ3YNYQZFlZhiae+IpmsagfiL6AnMmLbpn1R497GyFoViSncbFMyaCfjNm17aNPFu6oIH+WNTltCgEo3Z8xlzOh1N66nrnf0efW+uwjr6erqE39Yr5MGrHg8BXwPbJrO9y3jym30G1cjlPJaDg2DSOB23jRV4XUtHZDzsT6ZpuIHg2R3u48WSujrXfXMudddr9fCbczUF/B3S36jlyez/sCm1uzCSg2d6s/90xbvPSWCCf0N1We9C312A995QFTtodT1Gf0kEOZsLaW+vYmQgAzcyLkxSC71fi6YOA5kH7C7WxB4lGOa+0nycGzGJO8tOf/ZR3vz7JO14bpI/F9PgxsAZ/EDumzMvT0hNK7RfQ7IhvMkEdBKm6uqp6gQB5JMMrGkxgBSC7iYY6mBXaU/nhD39obm4AEhRnnnlGRV45leMJZwShoHF7FumWSM3vpqWlGdDAxurVq2l945Fsli9FsIw169axePHiKvV1DTAZrDB7jdu8EDC7p8dfeHrMmR8l95n0+ttlTOTYJUb0Ql8IZHixqkpgJel9YFgDKMpl9YaxMGKHkJ5uqGZSnVJs0i6jYRxFBUw3zdAUPhAQcYvVOfI98bBhWYWiGEvJw45meJF7MWACoaIAsKmD8OmcAZtNuhrFsCT4UdiVV3IdMChYs7tYPotTM049uE4pycLfjPGckwUlsSSMezTdsMu5CLmc+8/LLyjHHXec/qUI9DQ9YNm0ybve9S7/+qvfLbAtwIqRHtagjCVSYMfZLvLBswbTLwwLDoFQLrIKSOUxNDX1ygEE+UKuIl3YtJahy+c+9zkf0GxpDgaFQAde8aGizovYtMOqcJnXbWLYygpe85rXAHDVBYKVC4wAgDIjX8Rw7VZdzrH7I3m4rgvK9T2l9jgOHqKvWdMl5j+Y0wBWuL9ZGhyc/WSecVv65bEsCzuvAoamB4YZm6BoAG8Q0gDQQtD9bMGAnRZd6W0s6AoNAlOWZ2KSfWH9w7JGGbNchNKbFU2p6HP4zne+w381DhLuYwIHhN58YfRubrjhBh53Mpx/r0MEbCrtIxzwxlUujuc2b56qJYWR31CRfhtdAK+bAACP9klEQVRUQflBgW5PjETOfeht3n0GQ9N9mC2q27d+UFIUyu/vloKtToa2R/WmhlVw/fm27aWSr2OpG9D2N3B09pqhGZ8Mxi0AbgaFJJbzWJLRuUDJUgj49+oGEXqjl07o90/rpknU6CgAy36dBRRCCZ+tGH2OimLRxXVd7rV3M6iGsUt6YpWy6M893v/fGR+heWcJiaRpWx4hofHRfcT6+o2OtM51VosBsXcP0fqk9hiIT2rBjHyhYMqh65JIJBBKIA0rd/kdk8QyJTAxQy46QzOcAXofyPlBjpSC5LgENwCEG7YOs7TPfMcKgSMFjmkXPZyC+TvcDNsS9Qc1NA9khUKBq6++mrPOOouTTz6Zyy67LCKQ/r3vfY/TTjuNU089la997WuRjvb000/ztre9jeOPP57LLruM3bt3++dyuRyf+MQnOOmkk3j961/P7bffHrnvhg0b/HteffXVr6qHlB8okNuuJ7/igkb2jpqPwPkf46MTn+BdI+/kp6kRP31bE1x5AbzztdNTnqyV97X8IKqjmXODj49Yybic1wAgS7Xoj9aOQXDyugzPjWaYNAM5ldcusrUENTym2M5EHZaCv7tOsWpUYJcUHQOK2S/EmdVc+4W6B7Q+XddScW7MiTOno/Zl6pnl0B+LBj0YcJI4McGSnpoXB4AxE7Bp5Sa4+kcSa/du2gcVxz4E/bEk9TUGNEecOO2h4FJbx7MMmbHXrN/FNXM5F0JAnRPR0PSsYwDipZlhaELAMHRdDR4OmzLOFMsPYHar/vAYy8CzfaHjM+RyDoE2q+vCbx4N+tVMgKweoHl/GaC5awYDAgHUJQW74iGd0WdHKGWD84mGKj5ZB+2g/ZnbN77xDb34lFFAsxzUGLS0i/gA47R3t3HUyui3xd+99z1EWVlTCNCFbhDPKPbncj637iHEwDDNj4/sN6tx4TL/9n0+62TDt8+mMS2qB0UTkFdFjjv3dNrboxPk2rXrjGuuZvx1PzaMKuZ5oFez1lxpgg0JWL5qdbAqBYoU2LGuY4qqRt1Sy3HjiXecwFhj3C9fuRXDYbJNGk8DUgKMPQAyR+MuEwkXLxAGkHkGUKzekGH1LyZ8ALlFxaI0IaMbF2VoWjzhZNCBuAuhgnvlkcaZ3fWPohRuzHwsKNcHSNrbOyoqL0vDAaYYNBauDNCBEorfNnaCcT+2EPzoxh8xb/58jjr6aJ+dZcmgxz0QGzOwpqRu1FcCBBQvWmPmNl5wEXj/+6/UwNDwHXgsOCXgtN/p9gnrE4bBTqkUm0wk87A1pgUr5gN7/1PXTSmQGmodSM0OjgG6cQO2lKWkiQ5fzRRLVAvEWkFY5LKTU6TTmpkSxcKF8/nYxz7mH29qauILX/ii3+KuKumI1aGnUN2FWrMNn+t0iBv/5bmdgkveIBCGMadQWAb4VAIY/FkkC9cwb9f8r2ZUyslnQ7J+2uW8eZcGfiIBnQxI3/Fi4DrsaWVaXv/zQeKgT98d62ePMoxOBSVHkFs2y2wKKCwh+NCHPsTfnx+qsHks/Zby2bT7M6VKlIajwO28efM47YwzfExDAVvjKZSAXXaBn193MW9/+9t5KDbOPJk0QXCMyQlQknkP51FACakZmmaqkaoUCiylQs9O22te8xpKytXu2mXnjl4h6Goz8+Le7+myCQGTm/D0Q8NRzsPAoVCCB9IJLGUjUMy7fU9Ewsvf1HBaI4GvvH4hJNoNPFxXoYG8FbeOUBAG1JWmXhjdXmChm0SMjFP/UsbfTAm/X7SGpoJiv9ky0ndIjUmfJStCgaoAnrP1JkdjUxPHHuuLvLLqZs3wUkZT2qtB2FxKLP7NhG4ipbScQcgr4KPvFMxJPOiz3JXXCVBI6fVf/S45941v1MBxSEva0+0tZ9827nW1pII//5o5xdJrx3bRyBo1y69ms7RJi2TwXANKqN9+AoEUWkPz5ptv5i/J/ihA03Vd5syZw/XXX89dd93FSSedxAc/+EEA7r33Xm666Sa+973v8ZOf/IR7772XX/ziF4AGQj/0oQ/x1re+lbvuuovVq1fzyU9+0s/3W9/6FqOjo9x6661cc801XHvttfT16ZXlCy+8wFe/+lW+/OUvc8stt7Br1y6uu+66V6r+f7KNPjbq/96aboycK7aewT65D2LBR9ZtXxR89X0Wth2dmF4pK8TyvpYfRAHNTD7QhXGKUBB2TUCNOhNcx1LQtkeXYWtmEo94lMxCISZqyvTpMmCF5za55jn4+xtGue79iq98UiHz8RlhjXmAZrl7J2idxpkAWbrbqAQ0YwmWztVuxDNi9Rajtv4I69lYpPmDn+VfPqFoH9Z6n+kaBp1duUAw6sRpDzE0Hx0K5oUm4+ExEEsQj0FdDcpWaE5GXM49m228BncmZgbQnBNaHz61NVhkzxRDEwKGJsDvnw4+dGZi88CzsBzJrx4Kjs+UhqYQWlbBDa2M9sRTMwtoJogwNPc9sQ83F3zS1DW9Cl2BD9pBm2a7/PLL6al7zER2jp6rxtR6QG0i2VX5Ulp/zFy+/Z1vhy6eGg3w8m3dVmJ/QYEARKlEPDM16Pkf//Ef/Di5j8W39EOxyCGHHsob3vCGqTNUMMAIk2vbaC0LLHnBqSnuufduPLaXt5y1LYvPXaL/Sie98gvCIKPEJd9atjOaewEIwOJqbwghQNoWj8zV3yciJED5hz/8gfkLFvD9hOe+L4Jbmua9PhkG1LyQOaG2Lw35Xp6W9sMmQH+iDE0lA0Dz/AvOBxQPxsYNa7KkF8SlER8c9Pm4If08lIL0mqByQHJ1Ly0tLXjuwAFRNbh/VuV5yTLReqX021YpxX2NXSAEjzoTbLEyrDtyLbmzDiEWi+Gzy8wzsZQX/RzCLr/KgDNzVNqU3rAErQJHHnm0LurwbaZtdZRzp2jytCzY+S86qFBp1C8bSrHHi2ReZpYlOO01JxrQwzjCC0wgjzC6rRma3tF+xti9qLq3VwyHY6XZMRQOsf04FTz22GMsX72Kf/yHqyLHlYILL7wgaN+Qay25LSzoUvzjW0XZNRpgVEqxua5yvBpnWLxI6GEIOWwa0FQGCBMw9rBm86kA0PRy1H3FCzxWGRQokUgYgMawh71H4gNygsMOP4LQCWRCkF3UZsqo+Ld/+3df7zhiQtBvlRASxi3Xb4NyW3jvBOCya1eViKN+G+gyvhRPoIRi2fLlvPGNb/RTPOKMe/Q5w/jVAF3rdt0Wg4zzENu1azpa59ZSnlKxnpvCtnbdWp49Lm4Ymvo5fvzjHwfgLa8pf666eCq3hYApH65nMMcJBbJ+LYKEDyqq0GaU8OYcOcmY5QRdXCkULis2jIby9W4MqBIWgh8k9pJ6pp/ESwNoZqtmD1tKg9YikyW1O8uNyQGiLueeu7ZtoO2oVIaNhSuCDRLvqnvjY/zTR/+JtrYO/umy1ZxpdGCFX5sSDXty/jUKSNfrRZCLy/xHclrmwpvzyqw9/nyZbIfOZenSpUELCOju6iLz1mOMjq5OayGQSLqaQ+DMwE341EqlQVIbDQh7utHh+U6D3+YmwgCu4e0jj+lpHrFAsH379op6/DnbHwVoplIpLrnkEjo7O7Ftm7e85S3s2rWLkZERbr31Vs4//3x6enpob2/nHe94B7fdpl8mjzzyCKlUinPPPZdEIsGll17KM88847M0b731Vi677DLq6+tZt24dJ510Er/61a8AuP322zn99NNZuXIl9fX1XHLJJX6+1axQKDAxMRH5L5fLIaWclv/qV9az6l9X0HxeEzcXytCmznfpf0OAZmujmraySCmRiTzpyWAwDuYL/rmh8eBFHTcamo3paS6PlNQ3WhTNRNy5Ww86qaAQ090vlQcrzbSXI/zfrGbdRrtDGmyl50s4UgOv406Mtqbpb5vy/zqadfs8XN9OsYzpMGbH6WqrfZk6WxQDFYBmkkWza/vMImVqT/vPLjEeo8fuMeLsGtBMJWrXTsvmKUbtWCS41EODUUDTBYadOC31+kU03WUqtKd8IDVss81aaWe8jsYajzkpZSRK92Obg3mqrXHm+tLcjuCD/tch+aWu1tqPNe+/VQuCthkIfTd2ttS+TDFHMbtNl+fa1YdjNzk8Ut/GplQT7U0z99xSCZiwYwx7AujPlWieDFD6ZGOs5mWC6W2Pg3bQDmS2bXPeabO0+6Af6dnCtuCtZQtgbdFwNJ4tmSuYNasrBGTur/+FGIcHADRVSNexml166aWRtFO5pUfvrQGtj/91NN9TDxfMnzcXfEaPdpO2LJu6pKC1UXDVhSZxeZGUMgBbyHZ/0+B2hkFWZeEb1rZTZWmOOuoozjzzTE45dT3XXPP58EWo0d8BOvDEeeef558aEJWafkGehs0GbLGyuo4eIJLoMW6PujzLly7ny1/5SpCFNBp5suBxrgAvKFCZlqgIgEolXZ6al2TN2jW6LRGsvD2jAaxYuw/gTqgMj1n7aO/ooKmpOVx4s/gXKEvwiDNMrMEh21qHF/wEYTQ0Tfr6hgYedzJli3hdpFZlwEJVIj3kcnNiiPWH4XsPaXk5l51WhtXPaeDFtgQUdmnm2eAGkAboKMu/3H7yk58YMDlghwkFFnbIaV4zNH+S2AcI8ipPIe3Q212Z7zCj/Mrq86+zqrgbe7ZkyRIWLlpEW2tzxTnhUfCE0DIDQrA7noKdX2d1r6K7jNlcKmmXYikEtl0JAwifyWfGqpsjsTdbka5Q8Egypu7SBUPWsbFwVdE/X86Kk6H1zfr161m5cqVhsAVsvQt+ofudTNik03URjVFLisg78XkxzOKjlleU0bQMZDcjihluTO6rmgagoV+70KdS1V28VAW0K5Blc8A2K0+EKY3wNTQBChTpF+P0/j5nGI1aquNJe4JyrWCAC04RzJ49Cyk9mQv47Gc/O2UdPImKcNAZDSh7LaF8IF6Wdmkw2itvuC7e5ohyebyu3o/o3ryjoAMsRSKFBfODxGyiCO3GbpUC8FGqMGCq/3/ccv17P+JolqSURSxTV1cobBXAiC4u26xJXW6h7+jZR//powgBpx8V46STTsYHbwElC8y/fzASuby7u5ve3l7/neQzUadgVKsIoKmDarW0tEaaC9BzcGgOtRDYjs3t3z07yGz89waYDNjwNyZ2UqSI7Tg8FpvgeXcb37If8QF9u2BYxkoHuQre78GGjt4AEyBsH2z9S7EDfSns15544glaW1tpbm5m69atnHXWWf65pUuXatcXYMuWLREdmlQqRU9PD1u2bCGdTjM4OBg5v3TpUp5++mn/2jB9eMmSJezcuZNcLudHOgzb9ddfz7e//e3IsQsuuIALL7ywIu0rZifA6Pwe7vh4GX2m9XUQ7wEnWMVPjm6jr1Blm/wVMjc+SUMmAOle2LWHvqJ2Y3h2+07/uGNczkcG+5gcrcjmFTVVamTScmhyi/TsgifKzidzYKfxWbm1MCmhLjGXybzNPtumw3VpKjT758ftGIXMTvr6aiuq68g6oINRJ87jzTmOGAlcKsecGDK7g76+/Yvuv9Lm5iwK1lxG7BjNrv5AGYglaUyO09c3dICrp8e6O9vYHR9ieVZ33jXOWv9cfyzJ6FDtnp0oOow4syIami9OBK5DzWOKETuGFBb1ySJ9fVPt/r5ylmuur8rQ7N6ryFo2Q04CWRiir69Komm0hEgDep785R+yYETa6+Oj9PWN1LQsni2fG3y8PrIpOJ62dtHXNzPyJi1xG6jUcyhmttHXN33vj6msu7WTnQNJ7pct7P3qCj75FaN9Wj9GX99wzcsDUMg1A038uqmb8wf7sEoWa0uz/fNFNTEjfWo6d8V7e3unLe+D9udjQpiIsv7CzMay4OiVgh/fFZo/zIJwKo/YfEmAMsEbDxDsx2fplKoz3IJUxjVuauzGFE34uU5lP0nsYxn7F4P2XWB96cdofYUQCBFaqIZuWO4i+JnPfIbbtioTUdsiMR6OrF21EggFK2/L8JBh36VSSQ499BCWLNHXrntG8XAvyPFHEMwHIbj00st45plN8Lzif5IDcAAQGPABv4C0o/zFcjqdxl3ciDMraBTlBtFzPWttaWagPkVpXz4EcCjEyB3QthwPEFFKMbenh09/7tM8cO3zvmbe1mQDRbE39OQEb3jDG0ilkvzXf/0XX/7HncREo8FWHKAAwirrC5qhKVQQNuS0007jmWeeZsv2kDag97gMRqOQLP7tOL9LE5EmUELgygL7rByHPK3XRl7AICElShbpfmqSvYc0BbqBU3TOlpYWbNuO4PdCehCcFx1IMzRHLdewqvQ4fN95lXlKJZkUJf+6qvFgQqZsUe51zDnHB9qyGgzSANGAk4SJh4hVWeWXSiVfC1WIypsunasg36dBEreEHPoNbfcvrEznAybG3b9U9AF1rY3qGtzfg8x1LxZCQIg9/Otf/9qMQwGhnp4ogoqVaHx+AsuK4VgKRMxnKEsVbNrsEmOI5kqvjOS4ZNIwkYW7/+85T9d0+fLqwKjHvJXm/koQ0pSFltZW2GnYn0IHevEqI4AR71mHBp10iyDh9/EJQOn+FbJjVwssoSokRKqX34yHyOan54rs/b8K+u6mn9GeXMi+7ma8Xrz6Vh2URqGD1SBEKKo3zH9o3N/I0OnKTJXrZAo/lZLFEOPQm6u8zQHJxtgER9GpWavCMpxx/CBKtm3zpX/7Eld87nHOpAuP1Tr7ybwPmk41hry5cNgqMUYG1BBnLl+OeHgwqIU336F1Zz9+UbS9Xa/eyiu3ywXH7+HerT0cukS3/+5BQd9L5ry53MLi6s9ezbx5c6qUK2Ca5oUGSd/1rndx440/JjM4wj5rmKNMi815Mk+xUTBpJ1BKRpireJKCCtTk8whh8eEPf7h6Y/yZ2v81oDkxMcE111zDe9/7XgAmJyeprw/YEel0mslJvajPZrOR6IPe+Ww2y+TkJLZtR8DJ/V3r3SObzVYFNC+++GL+6q/+KlpJx5nWSJRSSr55S4AK1ieLTORi+oU998M+QzMeg5XL5h3wQ+5PsVTLYzSEoi2rhkbmz58PwLPDY4DeZXOKYCctliyaP32FMbZgLj6guWJ3klvLzidz0NCdZv78zqrXT5et6oWHnoOdiUY6JqOL8jE7xroVc/zgHDUr02jwInLffAp8N/A3HXdiHL6mhwMSFl5hmyt13+2PpXxAc5+T5JgFDcyfP82CkFVMSkk6MeHLBQCsja3zf++LJVm6qDXi3jyd1tgKk5bCKgkaxxVjZW5vTWMwaIIqdbbF/PE4nda8SBLPCpJZRS6ly9Mwrlj7tGZnIgSrl7Yyf37rtJclbGuXBb//8FwAJJ5waBPz5zfVtCyg+9KyvbsrjsdjcNpxs6suBmphc+dCfQomQqSI1b2wbMm8qS+aRls2X/GwAXuf2tXlH1+3rJH58xunuGp6rdsszn/S0cvpA8/SJOoi52fNbmH+/LoqV06PSSnZvn07c+fOnSJS6UE7aDU0w3RTwCWXXoZHxLr8HP0+OP21ryX1q8186h8/NeU36fJ5aD02YH8MzWQigb8oHLvnQAVDvCznMK0nth/SGmOWG9x3CuTTJx0p795RFmXodkD0eF1dGgi+DT/84Q8zvPZXPCddBtc0cNgXX+IeuxJnUH6RNCAQyytIRQto25pF86anUjzcO2a0I4OLr/3Ctdz8pn/zC++Ula25uZn2jnYwXhdZoUUnPaDPjelAIg/FRzj1nNdDXQzb+1yzhAZSrACsUCguufQStg11cONTgSSYUJIcJfaR8yvnLcJf+7rT+cO1m/20m5ONdKGYEPq5fOjDH6ZoNwNw9tlv4B0f/ReOVKCU0MCfUqxZszYAnQ2zSaEZmndb23nXpW8kuWAB6XSaLXfICD/TNi7RGdvx+3uFCUC6qFgjj6VbISOwTLp4TqKUS/uLBfauM8xUU66pLOBmmuyzLxmNvICh+dOf3sR5H3zBpHergoYVuW3/Aunk+invCzC4qA2nzC3dC0blmZQFDcztZ9yUSiUU0g/EU24r5gP5bdRtHkck45DbiowtqEi3atUqvvSlL/H8F83c4JZ8FuFP43vMs4QfiUdpEJZhwIHrCGSxYIBt4Y/HUknrRHr9a9SOIQaGaSjksOYkcWwFVkyPYQ/Q9JmIErfKFLXs15M8sFYDWrF8cHzevOi31KmvOY11//MijmNzwQUXVOSjg8To5+XjWSLaT970pjei/u3WaF8UupwK+O/kAIznwTKsYqHdvL3u9s53nM+s1kp5AoEG3vEZrFObZmhqgHmXnQcUP+Jh3sYcfV/DRrYUqGKBeMmNXGcX/G2LYG+EgAGoXc5D49BsCAH0PpDlIcKbLzqP+8Q2klY7UpYiTeb/HP6l/5dCbxgJ0y8HRI73/v17ufH+OO+OL+KtbzmUKz73OJ6Pt5JSa7HWCerrBJ+4qHqrKBXc+6xz3sCKOcdTaF0MIUDT2/TyoNrWxtDGiNKhy4QJ6JRBs5NPOnoh926Fzlad9q/PhJ//ytTO3M/CIpGqfK5P2ZNaQ9NjhiK47/77uemhBnoX9vLUi8prcr9tQBgZA+W3ke5rgW4v4w/z8U98sgJ3+3O3/6uv7nw+zwc/+EFOOOEEzj33XEALFk9MBEhaJpOhrk4vJlKpFJlMJpJHJpMhlUpRV1eH67rkcrmXda13j6ko4fF4nPr6+sh/yWQSy7Km9b/fPRGU5z8/PAQlw3zq+huoPwTQOnG2Pb3lqG+DhhDparhQ9M+NZ4PVcbwEifT0lsX7r7VBMGlrZKCnCjktlYfmzul/RuX/eRG6dyYqB/24HaOtSdS8TLPbgiG5Kd2EU6+/XrKWTbI9Tjxe2/JYloXjWPR0aKDQs8FYgjkdtW8f779UQmmXGmNz7GDna18sRUNd7crW2iiwbaUjnYfczj1rHo1GOK9JmZot+uNJ3nGTYuEWSeq/N/DFqxVtI/BSUm8KHbGs9s/v0CXBB0IukPTl0CUz15fmdZQqdE3XLoLEDIw17z/HsVhdRoh4x2tnro0WhhZNYbf8xXNmrkxpA9Rn7Bg/FBsrxl262a55mWB6x/dBO2gvx4TRK1NCcH1yD0uWrvCBwWXz9I/Vq1excsUKXnPq+ikBzRXzBRT3sOrWTMSFrtwOXT3HXzz9x3/8x5TplAkdKxDUD3xxv3Ww8IJI/GkMgCACO3jUunKA6ZpLhQbZTDCSLXaOe+69F8uKokfxeJyWpiZUNkvzi5P+SrMc/9JEMxGAAgIf4Dj9CP2vYwEEEWxlGQM25jicdNJJeC7Mbyh6G/5BezQ2NHLZZZeRTqe5tbukXSdN3fqOmkCqIksuOB2xMEoWUMIwwxC0bi2So8j6C87k2GOOwmNLYcBYpKJkScZE0Xdt9AAnERMUfWaiBwMIE9E9cAmuaB8C6tp5573JP3/2UTqS9DZrEqEgJ0q87R1vRwiYNauD//n5z1m6dBkdPes0UKxspNLfgh4b8Oxzzq14GLJUgHgHh2S0G43n2t22JYskxCiTJtCG3F+0cWWiGHsEM8kQGV5gL79IDIKweNMbzwmBq4pqruSe/qRvcrJquvK62PvR2Vx585gvJaD8SyrzLBaLejirykAlEDCTG54aNpG/S7hTbGj8wz/8Q8D4Gxij/e4dCGDYlnggS4Zoe/b+btTX+uzq6vaPn3LKKWaE6rFwV3O3zwa0LItUXPP1bkoM4Lvd+uayf1UWSccL+p6XX345J5xwQuTs6tWrKSzt5N57f0dra+VG/4XHPBe4nAtQk09jCcHq9A1+mqamJn5/WCue9qHv8Bwup5wAK61BQoF+XgpQih9c968sqCJNIITUeqQiYDtWM2Vu580ltyRGQCkyaCT38vM7Awa9BEUJLwDUXfYOBpQeHxudCcKR0iOAJkFgHi8fzxr3Sh9MBWho1Dsoz4p+wwovIZRgm+31BzMPjPw6Wo8QUP0HZ5BLPnIZr33beSHcRxiX8zCQp80xcR0SCYcA4hJIVfD/Ovvss7noootY0CV48JCWoE2VCTZVpa9LKf2+KIAfice57bbbKgLRgQ4uFg6WJBCI8p0I4IH4mNayReCM6me2bu0aU/6EfzUQ2aDQEqKBBIFpND+5VLLi3fWXYH/0F3KpVOKjH/0oHR0dXHnllf7x3t7eSMTzTZs2sXChXpEtXLgwci6bzbJjxw4WLlxIY2MjbW1tL/vazZs3M2fOnKrszJmy0Ql4eJPufEt64Jz1nTj7vqlPWgEq31YDIkt7m0VsMnisA/mAYj86GQCaTgkSdbVZIDWldRRogLbhyvOtQ9DYXvvBt2qBniHCTD/P3LQzbYGb9mde9HWAPcOCo245inuaOvna7JV0zpq5Be3cWQEQBrAtkZ6RACWe1SVlRP/UMwkMOgnSNYxyLoSgqa7AiBOP6Gh61jQWgMHTHeHcs65WwZ5YHafcD5/5Ehx9804azL5QX6KelgZY0L3/PKalXG2CBV3RY6lEoHc1E2ZZsKY3euzwV4H0zOqyMr39tJkpBwSRzgEeDbnlL6r0oKmZNYX2oX4dG6KgCpHz6ca/vA+6g3bQfDPgjLQEV14QBEL07JN/rZkeljW1J6MHhsQKsD+G5qf+JsWTTz7J0mXLIhqY1cxbGFvsDzSCBDYFCsxt2rbfdJoJM/UiXxrgRiiYIIdUlS72yYTAlQKUi11S3BUf4dBD1lXND/CBVhH2PZ7CfFbQWa8H4Mxj9M0tS0QXpCHWU31KByuqT6e58C0XVtxDGZmAPYd0861vfYuukw+nuaVZs6dCddOBX6oVSgPeWIKex/OUcDnsdSdobUmIADCenqayU/jQhtH6c+ocbrJf8DFWNR7dWJKuyxf+VnDKoYJESI40CMIEtmX7Zfzg376WE088gV/FB3y2VNgF9+RTTqS1pYWE0IGREtgUvYRK0t09m0WLojuBms1UijDKwgWJBBpSEiwb+j5epdG0bXbygOA36QbN2HJhhEm2MUS/pUHiQIMSQFZlGXuA5o1OwHCtyhwO10VBFclL35yiMhqa+++Vq1at0pqIStHa2sK8WdH7euXQeogKVCkEaFWzQGfXUoIFD2TxgHgXhW2bwFYm39SIixeV/u7/fI2fy9e//nV+0zBEvxoI+pRx347HE7zhyAHIvcCwVUIpiClBzDJkmZ7ZVRmawn8eEg/y+OY3v1mRbkmPRUNrK6tXrahaw3SiTMs23w8CLN+NHP7hrQIpNPglDMMcKwq8vv28E2Hsbu6NjZp2lgeaQhBIrU9qXOenssNftE2eAVh+1Qeu4pT1J7Nu3To+dtWb8DR3hRIIJZFmgpqwXF/X9OHYRFS+wptXNIIf0UEuZyx70iSXXHopf3/F3/Ppz1wNykWZjQUBqLw0Y6+aKb9vVG0Lf4dI4fUxr4xhS6cSnLz+dK8BUUQlyJSC918gcGOGkW1c6wuiRJZiRdAopRRZCmxnxDSt5IwzzgDgLadGy5qZmMR70z3qTDAh8lh1U7h7mfK33j0WqfORRxxBPBF4FguzQeaZlKXQxlwAdAt0wC31f8dX/H/a/ugaf/7znyefz/PpT386MvmeddZZ/PSnP2Xnzp0MDAxwww03cOaZZwJw+OGHk81m2bBhA4VCgeuuu46VK1fS3d3tX/ud73yHTCbDk08+yd13383pp+uOeMYZZ3DnnXfy3HPPMTExwXe/+10/31eL3fEw+mMIOOsYvbu1vOF2kPlIulpE8u1qj2FPBgNnKBTZfCzE0LSLUJeuTYdvrocfdSzkxWQDloLel4JB2TimOOFui7bm2oOHAUOzEhizmqtHJZxuq6+DdFJPcHsGIdfdwLU9a7mnqWtGAcSeDvhF2zx+1jaPf529kl2J9IxEXPesLqGqAtFDTgInadU8+nprvcuoHY10DvoDs6s/iBJfK0BzToeOQu3Z0bFj/N99iXoOW3rgj+fpsmNXR/9e3cuMbB6Ebc2i6N+HL5vZ8gCRAEoAcztnrky9U4DfUx2vhYXB1GzdPB4tPhI5n27+y/ugO2gHzTflmuCxinhMVMz3zQ0B+2aqmSVyzQE0NHt7e0k37f8Fd+655zKqJnjRGuWSSy7Zb9qYATSXtz8zdaLSEM3b9Xd2tajFYCLDomh/scj/8Bh5clU18rpaXJBZVt2cqThXJdeplvMR80oUc2IsW7Ykcm5ep4CsAbOE0NqHxo5fIzjpEIEQ4Lqa6VaqWP4Lxrs1S2L3utmGvKWIorWBO2v46vo9RaQsRsruSUd6jFZ9BwMEWQJht+hAPSb/L71HaPdnwwTyGVsBckh3dzcxR/CawwWJuHdCGjdsjLtqgEXYts3NG/5XZ+KxQEP1EZbw0zr9Y9j7MuRsj9zi0tjYWAFW62jbLhR2mIYo+W7bAmXATkHn80Wfgbc/uycxhlCC3SYkuQ4Q5OIvp0fLJBeU8l3cw3bccccBMC5KUOgHoKdn/zu7QsAJa6c42f9DtPZf0TA0DWBchdL59a9/nVmxNLPteq7462O48sLqgKZSLigLpBtohFaxB4RuWw20WzTu1eyx0dERrL97PYcddigMjtG+UX8ga/jFZfiEJSxZOMvPp6uri/dccYXuc36/1fd97WtPx3VDoJSCREGRKun6ve+K91QFND0QSMsJTFkFrjjPRJre72dDyOWcygBSs9tNf0YZAMq7pWRjLEMsHuOGH3wLspt51skaBrSr+3p+6o0bIRQSV2smbvvMlOnOfjiGZiMGDfHlL32Rq668Ctu2I2PJAiwfwgzcyYOaBhssQhkwzTBJvU2AnycGiO0cI7E1CLQDksWLl9DQUI+lIN3YAGitUyn181txWybE/TRtN3u2XwYlS6GyBmWabA3WNMKvoz7fPTv6MdrTAT+4/ht+El/SA/2MZWQ61U9KKHhQ7GCb6mf1rEcj+bmuS5Y8D4ntRnIgmK+PXhntB8VSCVCs+cUEj8YmeNf/+UfsefVUM2/DSKJA2P7clEgkueOOO3QbeVOrBJ+xqcqlLEIVKhZxppS5+PO1P6rGu3fvZsOGDWzcuJH169dz4okncuKJJ7Jx40ZOOOEE3vzmN3PRRRdxwQUXcPzxx3POOecA2k3ji1/8IjfccAPr16/n8ccf5zOfCQbl5ZdfTn19PWeccQYf+chH+MhHPsKCBQsAWLx4MVdeeSVXXXUVZ511Fp2dnbz73e9+5VrgFbDbHwx+n2V2X1cv64KJ6AKrFnqMPZ0JZC7YCh0sBAzNsRBD03IF9TVisTU3wLN1zfz9omMYFS5HbtQDr2FU8rGvKpJjMdqbZg7QLAfGBp04g4tmDq1rb9IT5a5B2Bl6T8wkgDh3lo4ofF3XMu5o0UjCTAKsDSnJmB0jY0V3vfbFkszvmuKiabT2Zh3FvH0ouug4+lFIZ7UbPEBrrQDNdiIu+WtiwVdwX1IDmjNlx62KjvV1i6dIWENbW+bePZPt49lbThX+4uzHn55ZgLUag7a7DeqSM1euxWF2aHIx9xbujZyvb/zL+6A7aAcNPJdzF/UyFjVCHJihqe3AYM8Lr9n/ZP6Wt7yFSz94OT2nHcE//dM/7b9cSrO6pgIqAdh+DfMfykC+j2OXVXH/IQDonIJmpP3+97/n7y+s3Aw9+5gMlIZ9RmU8Bq89svptpZLMeiKDQvFvnzyKlQumqgSENQLDtqpXQO7FIE9KFXiLnFevXQ+V4supl0yeOtVEvMpDC7Gq1t40qiNZq4pTzPtDxmgtRgtrCVjSPQ4yWDcoGQA3llRgC+Y07sJxDKApYmYtrWDkDtIDmnn7n/91A+l0NQ1jBXu+6wOj5U1jCUBYZvGufBarUmA5gq2vW0Kv9X3sgQn2DuxlxKkL8p2iq0jlIlSJn8cHYOgWjvM3VRVSlXjIGaX7mYIOVHOAMaOUcTmXOqhTLOuCkpz+ujNIplJ890tBJOPt1gTbCs+wfM5oRT6nnXYa73//lZFjBwI0ARrqphisEw9rsQC3QASoruJSPnv2bP75mn/mYx/9CO8+uwqhw1zjReBWTO1yDvC02G0w6DDIZ9HQkKaxuQmBxHIl8VFNsNHAa4mBhkqwVYXYZow9ACjWn7Kez7+nnbVr19LRocXxlVI42wdY8USBnyUH6e7qxK2y5+IzCb1sxx+pTGRspKeJ/Sq7KMmCP0x6uJ5f53KTyvUBTc2vVDwcm+C886ppc5a03MWur09529bUMEqVSIzuP9DphvhgsLFhzJvfM7PS/jzkFBRCgq0U7pSfcKHNmtxWQLH47kn0e0DnP2iVsCZLxMayket8Z2up9IBWrvG81y7nAtinhnnc2utf9cgjwXMRyDL2urbtR80zVTOsfKEZmrGYw79c/bZI2rOOFczrtNjs5MxOTYkSJc477zwsi7K+ooLyonBicb791Ssi+ckKPYOpx8O8Oe2AiUgOzJ+/oCLNNddco+8stb6qxipjEY3c/rFGaH9TUEoRbD+qCEMz3A8F1uAEje4BaL9/hvZHhTzo7u7m4YcfnvL8xRdfzMUXX1z13KpVq7jxxhurnksmk3zuc5+bMt+zzz6bs88+e8rzM2lKKW77vf5dl4STjJfK8uXL4Q/3Q+NxftpaMDTndad5VgjSmUkyacFANmBojkxMQKPe0RUlQUON4iU0hzYm9trwhjtg1XMunXsV9XmLrQmnJu745TZ3FjTUwV6ZomBZxM2E9fm5h7CyfYaigQC9XUX69sYYy0T16sKRG2ttc2eFPjKARBxaZyYWCADzO7WezDN1TRw5Efh598eSLJwRV2qL4ViChWUMzdN/q9sscDmvzTPsmQV7qjBYM5bDgJPg8KUz15fKGZrrFs08GzLM0Iw5le7eM2GregX3/zuMZuB1R81sG3W3waLuIi/uDjbLZtLdHPQOfDwGhSKI9BIeLP4+cr4xPfP96qAdtJkyHV15/2lKCQfHnpqV5DO1UOxPQ9O3A2gACiG44u+u4OYHoG4qYEYnNDQupQOF7C9PJUFmmdVcPZ1tQWNawRi0tDSxcuXyqUGhkMUcwQlrFX190eMjaRuQtG3RkXX/7r2XV1z7D28VbNggQoymqe1Ze9IAI5XlV6fNofNJxemnn8Ydm0Y4km6aHtvHZH6Qe060OT2SOopML7pnkntwtZ4bAXnzkEMPRdy3BVdFGZpCCLpa4cQVe9GR7c03n8f0BebfPcozE+Os7X4GeCPxGCBinicqSmZYfPckv03BkUceyW+iHugGWAAmnkKIU2DPd+jpuArHhgtOCQOcXrAigW0QppijSyQti5iVw4uaHTSWnLKdtSaj4D+Te/26+o2C5AlngqPdWdEgM/sxAcjSIAJo35IFJOeffyGrjuvg4otNYw3djOS9qNI+FnVNVOYhBO973/v42n/+fcDAOsC9D1w0gaQEFojMPqA6oKnzsvxgLtXKBoEWo5KlCo3XiHnpcAkH/BK+5qNEx37X97OxcKtwjr06gGFTKpe4cKhrbjIeKjEefvhh5p/y3+bRaVB50CpxzvFEZA08e8rORIHufT8EbqhMCOxd1XVAhmbTrlC5qzwQpTRD0hOk0NOYZP36U+nuLgt8KzSgVUYXrLC2ugFkPse8e0d5YD/pSib0uqTEggcmeAj9DIRQ7Dq8ByF0BLGVt2bYeizkVY5+ka3KbIuwlYtaAiA9KBkkAyjuj41VXKPnAUXJY1KvaEY0W6Bcuh7LsF0VsUxVsxTIikn/2q6uLhCCVTcPsSPhhomJEW9yD9AUSvmbT3V1ad76muqD43exEY6kBalKNF1xJG0d83Bsyti8igdjY/SoJCjFhg0bmDevJZLPxz72MW65+4MEbNap34d/f+4gN1wTLXN5V/nwhz/MtT/5LmpA5yeNC71tC849AXbug/WHCei/EdQFuj2cVrBdoICrXLAsVt0ywROn21FJiFdAe/r/RTtIYfgT7bHNsMeAGOsP1Vo8YADN0fsiaWsBaM6f00DGjvmRzsMu5yMTgSuNqCFDM6x1tifmYClYtE1Qn9fdb9J2aKtB25SbEIJVvVCyLL7VuQx7RRNXzzuE5+uaah7dPGzHrQi0pf7zl8EkNZOMyLmzon/Pbjvwx9d02qJuzSD4TteyyPExJ87C2bUvz+yOGINOglkD0eOLXtL/1trlvLsN9iQqB/i2RBqEmFEG4tpFWjfTs1cDQ3PNwujvRDX2ywzYMavEjIOZnp24Jhv5eyY2DsJm2yIoQ2IhGTXJ7Uk9dz7Q0FGz99tBO2ivSjMaifuzresXccTywP38ABm+IsXav5O2thOXbOL7sS2AYu3aqXxsvfwqXZPD1t0ueGjDe5k9ezZf/sqXp7x3o9nsP1DhHl9Uh0sJ26d8VZq3+dz03BDsHsJFcdrh0Yy98j5nT1LuJuqZh0XdcssGv2BWUYIrOfywwyJpt+TPQVmEIvV6DNcgL6ngnecuMgGXygFUxWGe1IqSpIc8MCsINOTkldHl1JnGHMCKs8PK+/fbr/ngqllwTz7LRWcImhsEx64WoTrrKOcIx38X//NlwsdDvfL6LepOgnLZvLgywGf75rwPFueF4v777/fPCQ+w9RyDlcQS1gG+bTVDU+39PiilAXXlIpUVBS1Gf2uSywN/K5tKvRwNzf2ZQPhSAt236gisUwGaOtB89fsFgGZJs8xkkWGRrZpWmwsK+hnhRTFU5bzSfc785WDhqsIUFRKgFKkRyXPWECNyjImlQZAeLzq59koPQNameuGvvz371Kc+xQPx8ZcN7biyEngqr4f3/8qysKpEIfLcw3VH9tIrnCpBYUAYhuaBy6YoYh0IslE6mBrCpWl3sPb3HrP3XAUgFAyoYR6xB6g+K4c2DCzhP6ufW0+DUhSWz6azq8vk5218AUgeOqxJ70m1JCAdA1xatuY14zfUZMuXLwME559/vrmlwinISHAzvzS+BIH5fwVaWsHlkZb9b3rpupVoaKzn7OMEy+YGeIwym05POBk/cFwiURmj5dhjj+Xqz31RzzWmnlPZkUcewfr16xGW4JxztadyBRPdspg9Zw5Kar3QHXYetn8egJMPEbz9dKEJMPsC8H0CRdHfi9FSGU4Rzdz1+6I3t//lwXt/eTV+hW3vMMw3my5nBjJ1GtAcvz+SthZu1bM6WpkQ0gc0x1yXgtmKGAxraBasmi346pL4NOo9sUptyknLqQnYW81WLdD/3t7awyOXH82DDdqdoaN5ZsoDcNzKANB8amtw/FUFaM5gWQBaGyTtTbAjkebHCwN07qm65khE5lpZV5vDsJOgZxccsVHR4tpc+S39IVVE+kGxasVqjTkCt6NygPcl62mom1l2XcwRvstXzNEA50xbSwN86G26X3/8olcHgPhqsxNXRxc0i+bMfDstNh56ykpBvJt/bxJcsegYrpm79iCgedD+ok1J6bv17s9e9sbk8B1/Yom0VWOrlNuPr/8U85Ys4vwLzuftb3/7AXI0eo/7yXTp0qV0d3XRM7t7ynt7UWVPLOz/Y1QBOXIkcbiNp6dM1+xsIT7hIvM5ftQ0ylnHBjf+9MWBG/qLdlazuKSrF9R7vu2ns4TRttQV9I9f8XdX0NoWjcS8MHEzYnicxhdHAY8ZFoAlMRuKJfjARfNZs3oNLsUIw9FjcnqBShbfrb9DldHQxM81cG+sSwDjj3JbYtgndIbLXjXqtDDsrykehFfeti1FGPhvP2CNbQssKwxshEAYdxyQDLVUUvS6n85pF2CT9thjjwW0y6fynD2FMJBHARt7v31JKaEBTaMHqHUmpwpiIsC4H1cz77Dl7h+U/2PMi4btPYqpAU0x5ViwbZtjjz2WEaHBdpTkRTHED3/4wyluWmL2k3kyapKtYqTidJO1OQA0BQxaRSQumUylXq0yDM1ld2W519rJmBqj2F4GVBtkW6rifsHKT3/609iOo7umgE32/kBZzz17PzmayUuhdNC1XLF6MtclMaaZnIvuzqAMG9XL+ec//3mkxvulcKPHm+7DLwOyUcLoMgaDr8l4SUb0aCVggK9ld2gQ+h3vfAcPN+RY0NurXfqzZlPDEgGlUbksXbaUN5x9DmNjY1WKrl3B33VmSB/XMFb18xIQ16DJRRddxL9+ZA033GBAu9wWXW4TAGnxbydBJEgmyqYLpWjfPAnCQkmXvvTL2GxTOlDS+sMER64QfjR5PZd5+gFB+avZytVHgMyG8qtuQgh+/etfs27tOhYtmnqBozV8tc7xHqsIpeGKfExCQPCHhEve33MKXM7n3TOKKhTofjpvgqAdWDrjz9H+8mr8CtsZRwtevBF+9c87ufCU4PiyZctobYgOsnQNArO3tLQwQcEHNAGGjI7mUDEYgMmJ2gGaQgjf7XxvvFIYN2PPjMs5wCGLg1ny1t8HU/NMaHp6tnxusSrAO+cgoBmxFfP1vz9IzuOZN6/i37uXc19j54wwNGc1CwZjCQRw5X8o/vfJLlY+ps8NWK6/sKyVhiZAR5fD86nowHopUc+K+SbC6gzal94jOOsY+P8+IGiqn3lgDOAL77HY+TOLN5306ijPq82OXh4NcjcT46zcIjqaqcW4TpqtyQaksGomqXLQDtqr0ZTHDBt5ZYDIl8PQfDlMI3lAFpSWt/qbv7mEb/zb/5kSkPHs5c7WSniARfXzXvCUdhWDXf+2v5xMgAnBTjE8Zar5qXvxVvSqzLXXk8O48cYb+U18FIR2E53z2ARkn/fTCQHXXu4BT0HBlyyJBhg65VDtVkomR3LA2xDXQJQ0AUsdG0qud6aSoamkx54Ml1WYACAhrbaQrmkiLvjxN/86khaAiYc0I7S8y2z7rE4XAhjLLZUAtl9LLK+gOEAyYXHk8oBZ5uVZ4S2tXFxZ6XYsELhV3Pk/8pGPcOyxx7Bly4uAhQJKsoSFOECfkwhlgu+Yv7XD6FTXTA1oerbmZQWigr8+4wC9XQg/onsUoK40lXYQTfGq5wDuvPNOXmAflgIli6xdu5q3vOUt1RMrl44tRXRbWPw0OUgiGSx4HTUcuJwr+J/4blCSRKLa/UPIuNLBVSqeh1Lo/0nSk+XXR60+XY8HVt0dH91v2gPPXwFDM/3MMMkt+6pqaKqRcTofHkQB9YPSMJLhC3+rn8Ub3/hGA6LrcXig+0qpA2kdiKH5s8RAQLZUyg9QdfwaUXEPofABzeS4Lt9nP/MZTnnfxSxc2ItCsuj2EZ3YQgO4AMrlsY0bEUKQnZzECxAE8HBsXD8bJVgblpIy412pkg4slpgDQuA4NuecthDHMRJvu/8d0O2lhKBuWMLQLRGswnM5d4pSV6Lqrkm4oh4CqPtSuWnw1zDOc7rxpgpSevgyBZmN5q/931cIPY/EbCiUDJu9iqn9SGUE0hj4G0FeySQh5rf5d9ZmLzq7i1B/efDeX16Np8GEgMWzSxG36WQyyYYNG0jHghdVugYAYjKZJCPKAE3jdj6qgkGanLBrymDxdoj2JJorzu2LJWfE5RzgmFXB7/ueDH7PFGMUtKfC+sMqj88kiNjaGHUTnskARZ4tN4AmQvDd3GxuaZ2LEmJGgJaOZh1h3bP+x/qpQ+8qD6aaAa33Vx5Nezptdgd8et6h/K5R74a6CB6tb5tx7UOAQ5cKbvmixd+84SB4+P+K1SWin109HTNUkJAtDrFEr/roN1iy/FBAz6HJqddqB+2g/QWYWXAN//JPyuUf//EfsSyb7373uwdM+3IIZgr2H3jDWHE/i8BofgdmaHpmWVOX0bv+/ekXIP/S1PczC2r9z9SLWiGEAQKnThMGiBSu0WOMltdxKgHN8rq+8UTfD1GDC/5UHWhoOk4AaKKUz5YasIqGkRSd3z1YSQOdBXDHTN4qAuJceOGFWCaCsg9o7vux9lItr7A7iqcrOpUJIUBm/NpalsXbTjOApsnTdV0cBEV3BEoDeExIheCay6JtI5QwbFQiD18IQdMxC+iZ0017h/cy08FI9s/QNK0jSyY/6d+7Un9Rg8r775vVGqq6HbJk/31cYDQ0EUwNk5i06RhWy9Qvybq6Os1CU7q3r1m9amqg12OrmUAtw6LIlz+u41584ELBpk2bjCSBzxsFJEuWVGoflVzLgE+AKvGud11MtW0LqbRL/Gtvq86S9IsWAiH/dNPIkpejQFREke+t/4MfkVynFr5rvOOE6jHyG9MdDwxolkolw7qb+vlfccUVDFn62XsgO4M/j6SJXK/0mNGBdcJpgrp6QGXzU6NYA6Mo4MorryCZjKMUNHgxOcwVjzkZNGytj0hp5vriHtM3NbB5fecS3TLVqqMIWM0CyDxGzBG89VTB371J0NYIbzlpVN9HsF+mZDRfF7uKQOpH/sqvOe1b9FzoTCGk2t0moDTi5/dy7J8vFxyzsrouf3fy6UB+Yz/PtmNzIbJJoQApXITZrLJM24JmXitenhbwn5sdBDSn0Y477jh++4160ilYPg/OPaE29804+QigOZDXE344InRiwn5ZwuivlHkMzT2pylXwwy0zp3e2dlH1he/SubUvS9hOLQM0e7tnFmQVQkQAjJkMUOTZinnB72f7gt+9M6DtN6sFhpygIw0/NOL/3uPol/4ph+wnQuU02Jx2rSn6xblrefIDx3D54uPYmUiz6FXArDto/2/azz+vP1BX98Lxa2a6NIHLOcBLoyvpG2wG9Fw5kxq/B+2gzaR54NKcB18e82t/9sUvfpG2d581ZcDPP9Zmt00dPTxsmax6eV5NZpGXTlfqJ5ab4MCMzhec3H7P+y6KHpg1hb3//e/XgKaSnHzSSQcomI5KXw67BNp3XunN8SortyAAi5dUg2keWHL0CjjE6FVvWd6MiwaN/icxCCJOV4teELte+N8ws0lIUDkflCpnpYnQ/QBWrlxJSwNVtbpnP5VH2TA55+VR6MOAkRBw5HJBqVRiM7t5ml2gJMvvzIABS8Lz/nXXXWf0Qo2r657vRTM/vgtLwPHHn8gLTs6v1/4ZmjoYifJBPAmTz3Dy2iLXXl7Wu4RgfwxNUfbvn2KnnXYaT9sZ8BiaB8j05Ug/oHRUalBYYj+MNFUyXU+73s+dN48r3q4/0HtmCd7+9rfjosiKghmENv/xrW/S2tpSkdU7TsuCO+Hn+4Uv/HPl/QZ+ilIeU/pAdYj++PKXv3ygK6pnY8a919WlkSrw2YXG2hMvIZEG0DSNrCRjo2Xs0KGbSYxJpFs4YLy1uXPnggm4tG7duqppvvrVrwKYKOJGSiFkQhApq1AYMLMESK5439/755bN2hGRhYiPFhGFIq2trZx80gl+f54zZ44P2oZaCsvWNGkvyDkTj5q/S1hSIXd+DQp7WdtbTfvSMFoNg9Wzo1YKlszV7MkbfvAN3YGn1LUIF8ejN7pVPdNOPGYFX/nKVwhGoT0loBnWIGVi6gDZno3OacKyBD2zqnui9aSfwojBglI8+OCDVfOZ/XShwg1elYqkd+U0Fqo8pqmXlYt8mTjvn5MdBDSn2Y5YLhjcIHjq+4JU4pV4bR3YJuJ5GiaCD47BgmZo5mPB12EsU1uGpucauK8s8vI+J8FQV9OMLT7jMcHh0bgydLXCkctnpDi+vflEXQ7Lgne+Dn77dTHjbsJht/NXg8u5z9AMWXtTbUFDzzqaoWjZjNv6gyElg8HlRTh/w3G1LVcYgP5lfwO7E3rszYTG6EH787BzjofBDYKN1wlizsz3o7DL+c/v0RHPAd591syU56AdtFeLKSVp3rF/9tLLtdysSqmgavbWUw88J9TXiZf1DiqU9PfZ/uxnP/sZloAzzjiDVatW7Tft5tOWsGaR9pSoZnV1wbfpWWcdYAKRRcDaL0vnhBNO4Nxz38hFf/1OFi1eMmU6z6pFOQ88CstYh/vRR/NAAMORQikd6b29WdDerI+OtsQDkA9g5A7WLtTrhImJCVMew0ZzNZASrCgksgJE0FCxx4b73//9X5obBMevqXx+HS8UUXGHsUX719/x7hcGYSxL8LbTBBdeeCGT5JlElzkxoTR4W7akvfjii5nT0+Ozl5h8MnLesfU39r9+aAn7Dp+HshSW2v9mmFJgKc3Q7Hwux+/EiyAnaW9S1V1V98PQ7GgGRu58RdiD119/PffHx42UgDhgnoqXQ+JytV6oKmGJ/SAkmSdMT9IMzdNOOy1y+uqrr2bV64/iftHHkrsmQdi88x1vrxqzrKcjVHLj1l9Rl/EHQCqUXYew9g+MK6V8sD+RTHLllVdOmTbiJl1mrusaV3fPfVthYVUFv5VhNwY6r4qBvkrpjwX3TKAK+apu62G77LLLOPSwdfTXw09+8pOqaRzHoaExNKaqZJkMyQAIJUA4vPc9l3L66adz9XsXM6cDlvQIVnS9pCVLgtSA5O7ZQTwMgAULFrCTEbaqfv/YypUrme8FbgqB5haGKe15ipYGWbMw2qdmz57NNjGCNBqaaopebNs2dXUplC2gdOB3XGtfEVSJ+kT14EEf+MBVLOjVFMqG+NCUMTS8caxAR34/gPWv7drveSEMS9b0zSOPrL7TJzytlNKQ/85RE+O0PzMBqoyhSWiz5S/MDgKaNbBEfGpNhumwXF2uzOVcD/hSSu9gJ3IKSrUFNP/1fYJDFxdwyz7E7mvspHUG9SoBji37Dj7n+JnXGGxvhhdvFAxsEPzgYxbzOmcePIgAmq8Cl/MVVQDNmdL1816Ag05l0Kv+uP6IeP2xNSwQUdD57ieC368G7cOD9v+uNTeIqOvUDNr8zugHNmiG9if++tVRvoN20GbCXNdFMbVO4XTZUStfufudefSB83rTm97E+tPWc+uttx44Q8eio3nqjWHLsnjmmWdYf+p6fvCDH0yZjVIKVJ5HYpOQ3bzfWy7oXcgJxx93wO9JYZh85SjEiVMEeLcti0vL5Frmxe+MAACeS7xSVDAHlQrcYD3zgJnNmzeXpdURmzVkqcGZagCMAFAuHe3tLF68uHrBvXRCMfeXe6ZME0lfBXV7z3vew+te97oyRE6hyvq7EIK6uropNTttW6dZ0C20a7VQCPf/b+++45uq+j+Af26S7klL6WYvCyIgS4GWUgoyCmgBARFBpijDB1yoDBUQXI8+P9Eqy0dk+PA4KLKnKC5kKg8iyi6lFCjQmSb3/P5Ic9vQrELaJO3n/XqhbXJy77mnJzc33/s959jO7pcgAXIxIv+nxZ+4BADw9LQwH6SVocL+vhKQ/z+r+7JXTEwMevV6AMZMVVtDzu2Z7xaiZKEq6CFZyUYO8S+ZKkEuwGsL3kJwsOlwMkmS8PzzMwEhw/e6DEANtbp8vzTUy1AxY3+Sy65JdUv9L0g38Ie39cxsJXNNFoiNjS03RLysx/vaTFmFYcZF49JF5rN5ZSFDBVXp+1HIiG92xqSMh4dHmeHo1vfr6emJbbu2oN3zj6NpUzNpz2VIsgRhWJoev/76q8lzfn5+GDt2LG5I+pK5G/IRFlgISQJCAg03qZ8YKBluWAgBX1E2+1TCdS/T66029zRHp77dcAk5pcPODx1S+vs9jQ03nYOCgvCt5iqKRIFhmLQx0/GW98WmTZuwVTph9T1TVuCJa5DMLCxl4tpWxB7UAtDjrpjrFoslJ/dAdHQ0ft7+DhpEWc/QdNTHqizLJfOjquB5Y4PFcsbAuLi2ozQDW+igKomnFEmyydQKQujsHolfnTCgWQ3JAbcOOdca3jgBhrs3QTeBIqlqA5oRoRK2vGX4wDdmsQHAj4FhqB1cdfUwp9MtF+HKfERO5ustoVaAa9QFAFJKMgzDgoH2dzm3LoAhA9H3liFpzgrWBfsDapXANTMBzcsePrirXtVnRpZdREpf5sOtoROG5BNVBo1GMvnSr1IBaTMk+Hq7znmTqKoZAprCaSNfHKFnB/vqrht5l8OO86677kLr1q0RGmrjjq3Q4aBHAVD4l/Vish03x0tWpDYXJPTzMX1t6ClDVqWnpyfuqm/6XID6rMnvK7wvAZBxd0yGhczB0kBKt27dSoa1As8++ywAYI13FprszjccREn76iUBlZDMDDkvydAUehyyZ25lnQ6aPMvfuLds2QI/P3+L87Z6eHjgiScmwjSyIGAu0iAEIGA+M8t04TgBXLuO0KM3bK90XZK1aBhlbcgS9fEp/4Wq7v4C2LMokKMCJAJQFnuytYRXs1ggzkxSgOkG9Qg+q4UQeqtDznfv3o1r0YFY8q/n8eyjtcyWMZ0SQQW1CmZvjBqzfw0BeR30MszMTWp4v+SKfGR5aIBTz1qsm7r4tJLtdyeniVatWgEQWOGdCZ8LWsMwXwvnWONCOaUZmjLGjx9vUuabb74pmRNWtpmhCRiubWQbxYqKihD2YxZUF7OBugFo27b8Ygwff/wxPve+bGjgotPo0Phyue4nyzJykQu1MURUZr/G6UK6tZYwb5yER0aMQNl5YD08SlPgG0VLiKwtYe7cuTitKTBkKwthMZreqlUrPDxkEISsg5CAPOixatUqs2UlCPidvQFJWwxvyUq2ZM5W5UdrU0n4+/sjPCIczZtbHp5pskiPA+j1eiXg7lN8wHJBUTI3pijNRpVRuup9nWn9UYhCpWrCjoWmqiMGNKshrxAt/G6WnqKuFhUj6+pVwN8wbCjoBqCVVPCv4lVgQ4OA0EA9PohoDh0kHPALwW++tZy2wrlRp1syNG+dv5IMUrtJOL5SwonPJKcM676VSgXE3zKdjLMCmiqVhLBgyWyG5iUPbyS0rvo6mVu0xdMDiHaBxVyIHOWzlyV8MF3Cpy9JOPZvCcntnX9uInImlUqlZKWVHWZYHamrOFs8MtJ4R1Cgd+/etl9gM+lLlEyzZ34V3rJiDhcBAFQlEZ6yN7wNmT4l2YMC0JUsAz5qYEy57QgYhzoa7NixQ/lZo9GguLgYuZKM2Gtqw9DTkqDrNx6ZKEBhuXkDNVdXI3JvJpCdg3M2bsILALiYjdq/3bBYpmfPnlA/1dfqvK2SuYWMzASXzkf5lAQCyj+X0Lr0MQFA0hbB67rO+hyaeYdQ62Q+JJ3WsE1RjEWLFpl9n9U6r7M65NzRhDKPJWxmaDaJNQSbrLqxF965hvkYPT0st8ndd9+N2FF9MWbM4xanohGiTEATKovBRWNA84hHHiCKDQFNM0mVpccqAWamazDyzVlRku15Z/NqN2vWDLNnz4YsSQj+NQ+G3idZDWgaczn79OmDTp06mZRJTk5G06bNDDcMbEWfYciMrGVmHsaytL7xkIQKkpCx5PxOk+dufaVhlXPjgmqmzwUEBMCYF1j2qACh3KAZ0NVw7CrjMGwJgD7HbL3GjRuH5nfFAZBLhpwb9uvvX34qE5VKNrSfEFjtk41hw4aZ3eZ5j+uGGgqBhl7rzZa5lbV5lnvZeQMNAFpszLVdyA46nc6QoSuE1cxhwJgVXnoTSggdVJDwqfclkz+gYUS/3ua8rNURA5rVUJ0QGXJh6V2S7CIt/rp0Wfk98CZQrFIhwAkL8TSKLMae4EgMuSsRL9drCyFJiHTy8OXoMAnd2hh+njbYMEUAmdesroRgF8oa/exlCaPKfKdIbue8uoUFA9c8TAOaWR7eyPD0RYv6VV8vc4HLBpHOn06ByJEia0uYOEDCiJ4SmtVl3yZ69tlnIXlIUENCenq6s6tTqSys33Dbure1fg6JjIzAvHnz8FDb/UhLS7NaVo7xg6q2F14ba+u8JClfzlNSUqwVw4/SWXg0MmQBlJ1ao06dOspiJMboxf/93/+VZJaZMmSElc6Rd2sAzxiwjC8OKpnPzjDk/Iakhwx9maBuSfnC3yDJhkCKPdlmArLtOK/G+h/WMP+c6b6iQ/LLlTsb5QchdAg/XmR9f2UWe7Ia+MpaCRVU0BuzpbSZeOaZZywUVtkcPlu3bl1ckIosDFm/DSWRjFxrc17aS58LtaSGThSjRbR9UwQAloeIwzgvY9E5i21iDGj+5JFrmPfQp3QxK9PtCUNQXmX9i6xQJnIUaB6w2e5jMOexx0Ya6gjgMnKRg/LDnQ3Z8YbjFEJguXcmvvlmg9nj9fXxRUmOps19e3pImDHMxrsmazUMb359uSDvwom3TMcgG4+kfEDzwQcfhKenJ25KZbchmZ+7t+xCOWdfM1stX19fdOx4X+kUBqeex8qVK03mLTZSlQyftnV++N73TEnI1Xrk7qOPPgIANG3aFJ07d7ZYzp6ApvFvqNHaLGoXvV4PUayF+kqh1YCmZNg5yh6rLPSQJBWKpJLzVklBUZIpb7sFqx8GNKuhmDpqaItKAytXCrU4feWa8ruSoemMgGaU4SKgSKVWToQd7nL+G2/LmxKOLJfw1pPOrwvZLyRQwvIXVDi+UsLh5RK6tXFuQPPWDM19AXUASUKLBlVfnwBfIDzY9KKGw82JiKq3iIgIpG9Yj1Yt7i63QEdZ9sxT6epunUP3TtmzeN/MmTPx33VrlGHalujrB0Jdx7vc0HETZ18t+cEwO9/HH39svlzxJUAAhZIOkmf5r27z58+HxscTGpQ0iCThySefNLspIQwZmsLGoX7lmV2aYSgAQEKrVq3KZU4aMzhtL0Wj1MAB87uqYPyCv19zEwDQ797z5fckDPOARh63HoUwBnkByWqGZmZmJtRQQS+0hu8wub9Y2aohCGEtWLFr1y7kJDbHwYMHrdbPPoZjaLwnH8c1BZgxY8Ydb1EtVJBFMby9rL/RysaWzc6NWfJfAQAZ71rcTnR0NLy8DNfRfXrdj5BACYlmbjL4/F0ICD1W1LE8XytgCJB6ZxVAysmFn+aa1bL2kiHwp3QZ53GlXKBSr9eXzKGphoBsdbX567W9oYfe9lhye51fWJJ9LXDrJIomw/slyZDKVxL8Lk40HdoWGhqKQwcPYq3XxZJHSnK/zQRlzR3eEwPNTf2gAoS2pCPIeOSRR8weggoyIMmGgKu1myPCME+oZOMGyrhx4xDXogUOHTpkMwvyXMe6Vp8ve16wtNp8WfUjrJ/jdDodoNNBdaO4XNZ7WcuNWZhl/qZqqfS2kNIEwtC8l8U16L1rXoomA5rVUNuWUbip94Km2NDLz9wswJmc68rzQTeBYkld5UPOAUOG5q1uXZTHGTw9JNzdyPkridPtaVZXsrpCYVUIDwGu3hrQDDSspOSMgCYAPNbzpsnvjaItFCQiomojOjYSvt7WL/LsnZ5hjM3FMpzH3gzNh+1Ygd0edzes2HZsltZfByQJspARem8DhIeHmy93/g2rW6xTpw4+XrMM38H6vJ6lZNT7udBqCWXF3JKAJSQJe/fuMZknz/CwBCGVDLK1IzYjjEOF70BwgMqw6i+AQx6GTDnLc5/arlS45+GSykvljs+kXHg4fIfdj3xh77BT68NJGzZsiE6dOiEuLs7O7VnZk+EPBr9rhuN94403rL/ADoWSDBk6mxmkZWNd5ufGBACB3zTWF3Hx8PDA0aNHkZycjLUfTba8P60heKvTWw9SyrIM/79vQMrNtz6VQAXIZTp6WJjpUCi9Xo8CFGK96g94XSiwup1zTYOhQzFkR054KKlgLkPThBAliz2VhJnrBZQrUq9eLG59j5r7fmxs07KHYG6kjF4YpmeQbByqJJUMObfxnpUgK8FRW9QhAWbnuL1VYS3rZSRJws8//4zIyEi7Rj5MGWT9HKfX6yGX5OdaC2jqVAAgQcilx3pNzsFXGsO8yUJSA6JYmcq0QORBroEjTRnQrIbua98MVzWeaHjG8PuZwkJszis9uQXeEChSOSlD85aAZu0gBlmoeogJA3I0phd9//MNRu0goE4t53y4PJpkGtAMd1I9iIio6qhUEjLudczFVYsGrvu5YW+MoqODVmAf3cf+7dgbp5BKCp9sYDmL8JtvvoGvnx8mTJxgsYxPgB+ycBMNfiiwuvOokEJA6BB8wUrQo6RiQpYBSWVYIAilc+aZFJMkyJCgQpnhj2YkJSVht2cOhLjzDM2OcRJw82djBTB48GB06NDBQmnbAdQHE7yhhmHho759+1ote/jMXxbn5SzL+KytzDBHSWl1AHZNyGinV155BSu9MgEh2zdfrBXGIec/etoOBDdp0gRxcXFm51g00kMAchEgrE8lIMslPVPoHRPQlExXkH/ppZdMnu7RoweE0CNX0qHWz1YWqyndILzOO2gMc8n2IGTUrWv93F92yLm5PB7D29wwfUWBVIxiyFCpyvdj4+kgKNP6FAfGrHBbAU1/r3yI7MuI/u6q9YKQ4Qk1tMJ2252Od1xGSfv27REZFWkzO98er7/+upK5vGTJErNlVqxYoZzLBfQl/wcg9NCXNH5oaDjuvbc1jqrzlOfkmpegyYBmdVS/fj1cVWnRf3PpmeM3demE1YYMTdcIaN7X4s4maiZyFbF1JJz18oO2ZJ6Z9SGxkJ003NzIz1tg0cTS37vaHiVBRERuTiUBuXUsBwSqC0fPoelo9l3eSiVZi5a/hfbp0wfNmzdD1y7xFrepUkmAJCHQRnBhQIeLJfMZSsDltVbLCqGDJEnwzZEByQOeZpIX9XrDiruysL6gzr///W9kBKrhBQ9oJb3V6RBsUTLDSn7//PPPrR0EbAUfn3jiCSQldkd4ZCTefvttq2VlgZIMOMvbHDt2rPKzI7Iv7eHjWQzj8GBHePbZZ9G7Xwr27fu+XCbirVJsTNUQEgj0Su4CCGF1sSej8f2tb0+WAOQdBs7Os1rOEDw3ZAU7JKApShfLWb58BYKDg02efvzxx/Hw8FGAKFQCUJYYg4bqXAfMdwqgY8eOOKbKwTU5B74+VjJqJalk8bCSgKa5qTFLK4g9qjPIxFV4e5Vf9NQ4r2aDn6xnexsDrbaSpWOCMiFkHTQ6YePkKQwBTRRWeQzBVlDWXi1atMDyTz7BsEeGIT4+3myZxx57DJJKVTLkvOzngwxIauDaJozuI2Hft9vwk8fNkua1Z1bW6sdyjiu5LZVKhVxPHe75HWj8t8DJW4bIBN4EtCoV/Jyw+GVUqOmJ+76WDGZS9RATBtzUeGJO3dboG3YTn+QaVhdtUd+59Xp6iGGhKx+v8qvCExFR9SNJjpuazZXd19LZNbAs6V7Ap3wMwCxbAc2yLH1/1+tRbu48y0qyFi3NAVl0CgIRELKsDCfH9e/gYeZb48CBA3FtiwoCeozoZTkbMSoqCuPHj0fhziu4diIE79lYVMkaY3DK+6YMFGVYKWk9a9TIw8MDs1+dhT3rbiAkJMRqWb0sWR/SC+Dtt9/GO0cO4cDGA1ZXV3YkR2eCenl54a7mcehgx9QU5ua5LKt1EwkbV83AqFeuYMks2yvBxtlYSFMJ2VxabrWcXq+HpBFKYN4RjO9SjZmpCdRqNT778GmsXaKBXMf6yemh+65imVxodZ7Ninj88ccxYe7vAHLRq2ei5YJCwP+yrJwrrGZolkxjAAC9ku4tV66oWAJEUbk10W/VOKoQgIBk42AlSYIEgUR9DD7HOYvlfLS/4IhohRvydYtlKurRnvb9If7q3shh+2zZrhVyvYWNvlkyQ7Fc9txuyJxHzg40jJKAkrmTlblqa8Bn/61c/N4m3S5doGG62NQN5Xt10A0g18cLanXVBxNvvRPUvnmVV4GoUsSU3MA+7B+KBYX1Uag2XPk7e7ieSmWYy2Vcio3VO4mIqFqwdz5Dd1crwHU/0+rUkhDga7t+hgwyQGUr9cfG01odAFlrM0FPry8ZumitXMb7WF4y3FiSDJmfuLbR7DXE66+/jjrhkejS5T78Y5z5TCMjSQL+8c/ncdeT/VG/fn3rFbXCGNBsviMfuPCWjdICYbLtVcS9on1ws7WFOUzLiIquB8iFWOdleUhxQEAAQiPqoE2bNja356j36UMPPaQM007u2dMh25SF/dM62KJSqVC7dqhDMiXLhnasba9Ro0aGpZmEHg0bNrzj/QKwGYA0fLeWIUNvNeAaE6YHIBuGzzvAmDFj0KdvP8yYMQNvvviA5YKSBP9sGcZWNJuhaQxolvhm4ybMHVt+WOeALgByD9jMWnzo/hwYFvGxcRAANEKFuggErm6yWEYlCvA3LkEL61MOVESbpvZ9lui9HJcLaJjRw/p+SxPMBSABngUyALVhyoVbqHP1QMFfCPS2Pn9rdcSAZjXlHWG4c9Tyf0BMluld36AbQF6gE8abl5iSavh/7SDXWBCIyBFiyozIKXuB6swh50REVPNIUs0IaFYbQgdbGZqFwdav2/UyAJRkDl7baLFcnTp1lJ+9vS0P1ZIl46JAqpJVwM2Ljo5GuzkjMe/jBVYX1AEMfVKlkSA7aK4AW108OjoGgMAHPhl4+umnrZa1NzT+zHAPQH8TOSrr2bAnk6yvwO1ogYGB2LRpE5o0aYKRDznmy5UQrjct2KpVq5S0wpCQEOzZs8di2Q8++ACeGg/UCQ/FP/7xDwfsXeC3kgVmrL0nAEMQFfm/W3zeuACYABATE3PHNVOr1UhK6oEpk5+CRmMlW/fmLyad3WqGZkkNLWUZ+/moAKFDnN56FrJk/ECyuSiQhFxxA79IF4Gc7RbLDRs2DIAMCBn9+vWzus3nH3Gt/luWgH03DAwhch1abshF3JZ8oPgScOGf+PTTT03K1d55AxBFUNs4N1VHDGhWU2GNDauWSQASdprOW+lTCBQEOWG8eYlXxgBLnpWw610Jfj6ue6Ihqog6tQBz1xB3O+amMBERkV0Y0HQfMQfyDUPOhfWA5rn76lp9XpZRGjTI2WmxXIsWLTBgwAB4eHhi9+7dZsv885//BACI3FxE7r5kdb8AoIdk16gvSSrNSK0KAf7e2LdvH9omd8Orr77qmG366GHPEdjKvDIa2ctx34Oio6NxM74ZRvR0zNf70CDHfkdzxMKUw4YNw31PPAJZlnHp0iV06dLFYtmOHTti9KhR+CBtsWOG/p96HkXhjwC5B1CvjvUFaWQbc2hGRETgvffeg7ZBHWzZsuXO6wbAUwPobMWyLq9RflSr1Vbn0Gy5IReAZHaF87Ka6m2vEG5PhqYkSShCIc5LN6yWe+GFFzBwwAA8NflJk/lqzXH0oqyO/FyVZftupEgAhKyDurj0zPP66wswfPjw0kJXN0AuaWBXuwlRFTiHZjXV/O46yFedg6+sx337JHze4xKKa4ej4WkBraSCCLI9/KKyBPgCY/rVvDcbVW9qtYSo2gJny1z71w0HQgLZ14mIiKi80DPFEEJne8g5gLj6hpun5hi+aAubX5AlScJXX32FxSnH0bGj+XmfpkyZgrmfroDI0kNTLGx+W9Tr7VugyRhvtRXrc1RW1YLxEtTq+3DPrzL8/KxXUGfnMRgz6wDDPJOW2Bv4sHeoq71ywwMctq2XH3Ns3Z5z0N9V5ecNSZKg0dgOY3h5eMDTwzEB3vj4zvj23DtA0Wm0aRFptaxsx3y2kydPxt+QERfnmPpNHADYNZVqSd/09vaG3kqGploHQFJBfYfTBBiyWQUkDzszUW3c3PHx8cHUqZPRujGqfPo8R8YKha21jwBAfxNASLn5kXv37m063cL13ZADDAFOhyyA5WZq3hHXEM0aBuGor+GqJ7hYg3pvrUHqF1o8tVQgy8MbAX4MshA5WswtC0G2rtoRR0RERACA+hHOrgHZR4KAHsHeV2yWbNNUQnSY+et3QwBNxm+aPLv2ejK5ieUaSRJCQ0MNq0Pb8VVRL9sXDJQk+7KS7M2q2uZ5zerzxmDHO1YWQTfS6mB2FfdbxcbGYu7cuYiIjMR3331nTzXJwSoSVJKEgErjmO+8q1atQvsOHbBt2zYEBFgPHF+G9SzDyqDR2DlXfkkRLy8vsxmaKhWA3F+VwrbiY3atqy0EgjPsCzt9Lh22WUaSHDe/q7MIe+aoPTPHcN6EzmZ2u3F+15oY0GSGZjUVVVvCruBIdMw1TFrdO6s9Om4z/Ll/9fOBv/Om0CSqtmLrmP7e2vL3BSIiokozdbCza0D2kCQVhNAjxMd2QNMaPx/g5Zn/wIdf3MDX739ts7ywEfgQQkAWMqSSgOb9999vsay9AU3DdgG7Vgexwxm1fYuCPN7HdpmGUUBUbfv2O2vWLOSEyGjXzvJB18BRny5J3aE2PEMdMyoxMjISu1dEwdfb9h/3DOx7P1f11CAJCQnACcPPTZo0QXBw+TKSJAGX1wIRKYCkgspGZ37D9zxw1fLzxiHnPpf/trqd1q1bAwBuIA+NGllfTVyC7UzvymBtetKKkoV9Q86FChB6HQSA5d6ZFssZF5jikHOqNiJDgZ8CwpCvUsNX1qOjZyfluSxPbwY0iSpB+QzNmvehQkRERPYyfNm3tciILT3aSejRbgByfWX07287umjzO68QAPRQQcJlVTHWrVtnsahetm+o68KJEv7OEFUe7Avyt13GQyPBg9+Kqx11jB88HDB9ppE9wUwAJQt92RZXv2rfDCtXrsTivv/Dl4u/RGhoqO0XaC8iyN/6+eRbT+vZqLJhgl+beZwJCQno0KEDTlwNwLr/WD7fAEDHOPsyqh3t9QmO+3v5eNl3boJKBVkuxkbPq0oW5q2eeuopbP3a0Ofuueceh9XRXdS8nNQaok4wUKxW47vA8HLPZXkwQ5OoMsTcMhSMQ86JiIjIHGV1YyGbrD7uCgQMGZqQVNgdrkNkpOU5A+2dQ9NDI6FIa1i8xN01i3XNG9YT+ju7Bq5FkuzPHnaUHTt2ID6+M3788UebZcf3r9p+FBMTg9jYGAwcONC+F1z9BvUjLTfgiy++CE9PDyxdutRiGZ3OvuCul5cXfvrpJ3yyfImSrWmxrKedw+sdzNYCSRXRooGEfvfbN0WA0OuQoS5diKp2bdN08gULFiD2AUOfCwwMdFgd3UU1+EghczQaCdG1BXblRqJnTobJc5c8vNGSAU0ih4u55ftIfetzhhMREVENtWbNGvx78N+oX78eJk6c6JBtOmoI6733tseO7wVUALp0trySNAD06WRY8NMeTWKA3u3zANiRHeYg97d0fOBjwgDr25z8kHMCnk1jnbLbKhXsb3/bqlR2LpTjQN27d0eeVyI6dnTNoHdFWZuT8bXXXkNeuIzHH7dcRl3BP4Ajh3VXCyoJslxsiM4Lgfnz5yMqKsqkiL+/P1q1uhvt2wNnzpxxUkWdhwHNaqxlQ2BLVi1c1nghTFc6z0yWp4/dFx5EZL9at8wRXhPnMSEiIiLbOnfujA3j78Lvzw2Dj4/1r2Rj+lbt9cSLY6ORFLUA17dqcLFpU6tl2zazv25enkCg751HXVUqFWRJspo5ajSoW9VfizWI4vVfZZk1yv62lVD1GZpw0j7t9Vd3+4aPGVv5TheZad68ubLBJ554wmb5Fg3uaHfVyvDhw3HtaA6O6bXK3aoXXnjBybVyPS78dqM7dXdDw6Tfu4NNP+yzPLzh78MPWiJH63BXaVBz4US+x4iIiMgyfXgwPD1spyS1aFC11xT3NJbQpev9iImKcckFbo4ePYpOnTph7969zq4KuTCVyjnBxS6tqn6f9pI97UuBPKkuBHDnAU1vb28cPXoUXq0aYeHChTbL14twwROOk7z77rtoesUTArLhgdxfnFshF8WAZjV2d0PDCWFXUGlAs1iScFXjxQxNokoQ4Cvh5zQJX8+X8PQQZ9eGiIiIXJksG4IujvJQvH3BgPp2BA1UtTxxs2fdO61SpYiLi8N993WyuRoy1WySVPVDzgEg0M/9g3K7PHMA2B5tZs85p2XLlvDs1wEBAQE2y1Kp2rVrI7FbN9SvHwtc24SP5iVZLNuttfv3udvFIefVWMuSlO0z3v64HB2MsAs5OO4TBCFJaBzt3LoRVVeNYyQ0jnF2LYiIiMjVycKOFccroOs99m1syiDb5SRJAjzUgM31iYlck8oJiwLVNPaec+j2SJCwdcdW5N48i7i4OIvl+neRIMs181zNt3g1dle90ru+S1rdgx0JLbAg9h4Ahvk1iYiIiIjIeVx1vm1Jcu1Q5vgU12w3ch2NY+xfsKqmGNDF9vtm1qxZAICUlJTKrg7ZIAkBfz8fq8HMmo4ZmtWYt5eEJjECf5wFfsn0xOmgKFzXGE7ssXVsv56IiIiIiCqHO8y33bWVa9axeT3XrBe5jrBg9pFbJdgxNHnu3Lk4q7mGpS8+XQU1ImskIaDWsB9bwwzNau7ukkzMIi1w/rLh55YNXPduMBERERFRTeDhwl9UtcWApwZ40M55OYmo+nh5TPAdLwhUVsNInkduS5SvU+aBdScMaFZzLc2sing3h5sTEREREZEFEaHAfS2cXQsicoaGUY4NQD6VyoDmbekdywxNGzjkvJpLaF3+sZYN+aYgIiIiIiLzwoIlhAU7uxZERDWXSjL8I8uYoVnNJbQG4uqbPmZc/ZyIiIiIiIiIiFyLJJUu8kzmsXmqOUmSMOWWFG+ucE5ERERERERE5JokZmjaxIBmDfBor9Kfo8O44hsRERERERERkatqEsMMTVvYPDWAr7eE9NclJN0LvD+NwUwiIiIiIiIiIlfVKFqCJDF+Yw0XBaoh+t0vod/9fDMQEREREREREZF7Y4YmERERERERERERuQ0GNImIiIiIiIiIiMhtMKBJREREREREREREboMBTSIiIiIiIiIiInIbDGgSERERkVtJS0vD4MGD0b59e2zZskV5PD09HR07dkTXrl2Vf5mZmcrzv//+O4YNG4bOnTtj/PjxuHjxovJcYWEhXn75ZcTHx6Nv377YvHmzyT7T09PRp08fJCQkYO7cuSguLq78AyUiIiIisxjQJCIiIiK3Ehsbi+nTp6NFixblnuvQoQP27t2r/IuIiAAAaLVaPPvssxg6dCh27tyJli1bYtasWcrr0tLScP36dWzcuBHz58/H66+/jjNnzgAATp48iXfeeQdvvvkmvvnmG2RkZGDp0qVVc7BEREREVI7G2RUgIiIiIqqIPn36AACWLVtm92t+/fVX+Pj4YMCAAQCAcePGoUePHrh48SIiIyOxceNGvPXWW/D398c999yD+Ph4bN26FePGjcPmzZuRnJyMuLg4AMDYsWPx2muvYeLEiWb3pdVqodVqTR7TaDTw9PS8ncO1myzLJv+n28N2rBxs18rBdq08bFvHY5tWjqpsV5XKdfIiGdAkIiIiomrj8OHDSEpKQkhICB5++GEMGjQIAPD333+jcePGSjkfHx/ExMTg77//hp+fH65cuWLyfNOmTfH7778rr73vvvuU55o0aYILFy6gsLAQ3t7e5eqwfPlyfPzxxyaPDR48GEOGDHHosVpy7ty5KtlPdcd2rBxs18rBdq08bFvHY5tWjqpo1wYNGlT6PuzFgCYRERERVQtt27bFmjVrEBERgWPHjmHGjBkIDQ1FYmIiCgoK4OfnZ1Lez88PBQUFyM/Ph1qtNglO+vn5IT8/HwDKvdbf31953FxAc/To0XjkkUdMHquqDM1z584hNjbWpTIo3A3bsXKwXSsH27XysG0dj21aOWpquzKgSURERETVQnR0tPJzy5YtMXToUOzatQuJiYnw8fFBXl6eSfm8vDz4+PjA19cXer3eJOMyLy8Pvr6+AFDutbm5ucrj5nh6elZ68NIalUpVo77QVBa2Y+Vgu1YOtmvlYds6Htu0ctS0dq05R0pERERENYokScrPDRs2xMmTJ5XfCwoKcP78eTRs2BCBgYEIDQ01ef7EiRNo2LCh2df++eefiI6ONpudSURERESVjwFNIiIiInIrOp0ORUVFEEIoP8uyjH379uHatWsAgOPHj2Pt2rXo2rUrAODee+9FQUEB0tPTodVqsXTpUsTFxSEyMhKAYaGhJUuWIC8vD0ePHsW3336L5ORkAMADDzyA7du34/jx48jNzcWyZcvQu3dv5xw8EREREUESQghnV4KIiIiIyF5z5szBhg0bTB778MMPsXfvXmzcuBGFhYUICwvDkCFDMHToUKXM77//jldffRXnzp1DXFwcXnnlFSWgWVhYiNdeew179uxBYGAgJk+ejAceeEB5bXp6OhYvXoy8vDx0794dM2fOdOqwciIiIqKajAFNIiIiIiIiIiIichscck5ERERERERERERugwFNIiIiIiIiIiIichsMaBIREREREREREZHbYECTiIiIiIiIiIiI3AYDmkREREREREREROQ2GNAkIiIiIiIiIiIit8GAJhEREREREREREbkNBjSJiIiIiIiIiIjIbTCgSURERERERERERG6DAU0iIiIiIiKiaiAjIwP333+/s6tBRFTpGNCsgJSUFBw9etTZ1XAL165dw9SpU9G5c2c89NBD+PnnnwEAu3fvRmpqKhISEtCrVy+8/fbb0Ov1Tq6tc1hqo/T0dHTs2BFdu3ZV/mVmZjq5ts5jqZ3mz59v0kYdO3bE008/7eTaOoelNiosLMS8efOQnJyMnj174tNPP3VyTZ0nLS0NgwcPRvv27bFlyxbl8QMHDmDcuHHo0qULJk+e7MQaugZL7cRzdylLbcRzNzmaVqvF3Llz0adPHyQkJGD8+PE4efKk8vyKFSvQo0cPdO/eHe+++y6EEAAAnU6HZ555Br1790a7du2QnZ1tst0hQ4aY9NP27dtj5cqVVXpszpaSkoKEhAQUFhYqj+Xm5qJz585ITU11Ys3cE9uz6vD7qGMdOHAAo0aNQkJCApKSkjBhwgRcuHDB2dVyWykpKejXrx+Ki4uVx+bPn4+0tDQn1sr9VNbn/4ULF/Dkk0+iW7du6N27N5YvX16lx1UZGNCkSrFw4UKEhYVhx44dmDJlCp5//nncuHEDcXFxWLJkCfbs2YP//Oc/OHnyJL788ktnV9cpLLURAHTo0AF79+5V/kVERDi5ts5jqZ1mzpxp0kaNGzdGQkKCs6vrFJbaaOnSpcjIyMCXX36Jf//73/jiiy/www8/OLu6ThEbG4vp06ejRYsWJo97e3sjNTUVo0aNck7FXIylduK5u5SlNgJ47ibH0uv1iI6OxvLly7Fz507Ex8dj+vTpAIDvvvsO69atw4oVK/D555/ju+++w/r165XXtm3bFosWLTK73c8//1zpo+np6dBoNDXy8zM0NBTffvut8vuuXbsQHh5e4e3odDpHVsttOao9iapKbm4uZsyYgVGjRmHXrl1IT0/H0KFDoVarnV01t5afn4/09HRnV8OtVdbn/xtvvIHo6Ghs374dS5Yswdq1a5VEGHfFgOZtOHLkCEaOHImEhAT069cPa9asUZ5LS0vDrFmz8NxzzyE+Ph6jRo3CxYsXnVjbqpefn489e/Zg4sSJ8Pb2Rrdu3dCoUSN8++23qFOnDmrVqmVSvibeBbPWRlTK3nY6deoUTp06hR49ejipps5jrY1++OEHDB8+HP7+/oiIiED//v3xzTffOLvKTtGnTx906tQJnp6eJo/HxcXhgQce4JeuEpbaiefuUpbaiMjRfHx8MHbsWISHh0OtVuPhhx9GRkYGcnJysHHjRgwaNAgxMTGoXbs2RowYgU2bNgEANBoNhg0bhrvvvtvmPrZv347mzZsjNja2sg/H5fTq1UtpMwDYtGkTevXqpfy+ZMkS9OvXDwkJCRg9ejT+/PNP5bmUlBR88skneOihhzB48OAqrberut323LRpEyZMmGCyrZdeeqnGZQ1X1Jw5c7BixQrl9/T0dI40qaAzZ84o184qlQq+vr5ITExEREQE9Ho90tLS0K9fP/Tq1QvvvPOOcvMiLS0NL730EqZNm4aEhARMmjQJV65ccfLRuI7hw4dj+fLlZm/2rFmzBgMGDECPHj0wa9Ys5ObmAgCeeOIJbNiwQSmXn5+P+Pj4GtuulfX5f/HiRfTs2RMajQbR0dFo3bo1/v7776o8NIdjQPM2aDQazJw5E7t27cKiRYvwwQcf4Pjx48rzu3btwtChQ7Fz507UrVsXH3/8sRNrW/XOnj0Lf39/1K5dW3msSZMmypvl0KFDSEhIQPfu3XHy5EkMGDDAWVV1GlttdPjwYSQlJWHw4MFYt26ds6rpdLbayWjTpk3o0qUL/P39q7qKTmerjYxDEIw/u/uHFjkPz9228dxNlenIkSMICQlBcHAwTp06hcaNGyvPNW3a9LbO75s2bcIDDzzgyGq6jY4dO+KPP/7A9evXkZ2djXPnzqFt27bK8w0aNMCnn36KHTt2oGPHjpg9e7bJ6/fs2YMlS5aYJDbUZLfbnomJiTh+/DguX74MwDBdzt69e9GzZ0+nHAfVHPXq1VOmZ9q3b58SXAOAzz77DIcPH8bKlSuxbt06HD9+3ORzfceOHRg6dCi2bt2K8PBwLFy40BmH4JI6duyIsLCwclmaP/zwAz755BP885//RHp6OgoKCvDOO+8AAJKTk7F9+3al7LfffosWLVogNDS0Suvuqhz1+T948GBs2bIFWq0WZ8+exdGjR9GuXbvKqnaVYEDzNsTFxaF58+ZQqVSIi4tD586dcfjwYeX5Tp06oU2bNtBoNOjZs6fJHd2aoKCgAH5+fiaP+fn5oaCgAADQunVr7NmzB19//TVSU1MREBDgjGo6lbU2atu2LdasWYNt27Zh9uzZWLJkCXbt2uWkmjqXrb5ktGXLFvTu3bsqq+YyrLVRp06dsHr1aty8eRMZGRnYsGGDyfxWRBXBc7d1PHdTZcrNzcX8+fMxadIkAIbslbI38fz8/JCfn1+hbWZkZOD3339HcnKyQ+vqLtRqNRISErB9+3Zs3boVPXr0gCRJyvNJSUmoVasWNBqNklFYto2HDx+OkJAQeHl5OaP6Lud229Pb2xvx8fHYunUrAEMgo3nz5qhTp46zDoVqCH9/f3z00UcoLCzE3LlzkZycjJdffhl5eXn4+uuvMWnSJAQHByMgIAAjRozAzp07lde2bdsWnTp1gpeXFyZOnIg9e/Zw+okyxo8fXy5Lc+vWrUhNTUWDBg3g4+ODJ598Unnfd+/eHfv378fNmzcBANu2bauxn023cuTn/z333IOjR4+ia9eueOihhzBgwACT4Kg7YkDzNvz111+YNGkSevTogYSEBOzatQvXr19Xni87LM/b27vCF5juzsfHB3l5eSaP5eXlwcfHx+Sx6OhoNGrUCG+99VZVVs8lWGuj6OhoREVFQaVSoWXLlhg6dGiN/VJsT186fPgwbty4gc6dO1d19VyCtTYaM2YMoqKiMGjQIEyZMgVJSUkICwtzUk2puqjJ525reO6mylJUVITp06ejS5cuSma0r6+vSTZRXl4efH19K7TdzZs3o0OHDggJCXFofd1J7969sWXLFmzevLlcpuqXX36JIUOGKIuhCSFMrvcZcCvvdtuzT58+SmDD3GuJKkvjxo3x6quvYsuWLVi2bBmOHDmCZcuWITMzU1k8pVu3bnjppZdw7do15XVl3/916tSBEAI5OTlOOALX1KlTJ9SuXdtkGHl2drbJ3OKRkZEoKChAbm4ugoOD0aZNG+zevRu5ubn45Zdf0L17d2dU3aU48vNfr9dj6tSpGDhwIL7//nusX78e27dvN8mMdUcMaN6GRYsWoXXr1tiwYQP27NmDxMREk2GdNV3dunWRm5trsqrWn3/+iYYNG5YrK4TA+fPnq7J6LqEibVT27nZNY087bd68GUlJSTV2PjtrbeTj44MXX3wRW7Zswbp16yBJEuLi4pxYW6ouauq5uyJq8rmbHEen02HmzJkICwvDtGnTlMcbNGhgsuLpiRMnzF5DWLN58+YaO7rBqFWrVsjKykJBQQGaNWumPJ6RkYF33nkHr7zyCnbv3o3NmzdDpVKZXO/zPV7e7bZnhw4dkJmZif/973/Yv38/kpKSnHUIbsPHx8dk1E1NnWvQke666y4kJibir7/+Qp06dbBkyRLs3r0bu3fvVhZFNMrKyjL5WZIkBAcHO6HWrmvcuHEmWZq1a9dGZmam8nxmZia8vb2VbEPjsPM9e/bgnnvuqfHt6ejP/xs3buDy5csYNGgQNBoNoqKi0K1bN/z666+VUf0qw4DmbTCm+Xp5eeHgwYP4/vvvnV0ll+Lr64v4+HikpaWhsLAQe/bswV9//YX4+Hhs375dOZGdO3cOK1ascPt5G26HtTbat2+fcgfw+PHjWLt2Lbp27erkGjuHtXYCDCf6bdu21eg7+dba6NKlS8jOzoZer8ePP/6I9PR0DB8+3NlVdgqdToeioiIIIZSfZVmGLMsoKiqCTqcz+bmmstROPHeXstRGPHdTZZg3bx6KioowZ84ckwBanz598N///hcXLlxAdnY2PvvsM5PgpFarRVFREQCguLhY+dnojz/+wMWLF9GtW7cqOQ5X9sYbb2DBggUmj+Xn50OSJAQFBUGn0yEtLY3JC3a6nfZUq9Xo2bMnZs2ahXbt2iEwMLCqq+12mjZtim+//Ra5ubk4f/68ySrHZJ/Tp0/js88+U+ZvPXPmjDJ344ABA7B48WJkZ2dDCIGMjAyTwM/Bgwfx008/QavV4qOPPkJ8fDw0Go2zDsUl3XfffQgJCcGePXsAAD169MAXX3yB06dPo6CgAIsXLzaZKzcxMREHDx7El19+yeHmcPznf61atRAeHo6vvvoKsizj0qVL2LNnDxo1alS1B+ZgfNdVkCRJmDx5MubNm4cPP/wQHTt2VIIrVOr555/H7NmzkZSUhPDwcCxYsACBgYE4e/Ys3n77bdy4cQNBQUHo0aNHuZUNawpLbfTTTz9h9uzZKCwsRFhYGEaOHFmjT+qW2gkAfvzxR3h5eZlMOl8TWWqjEydOYPbs2cjJyUH9+vUxf/78Gjvk/LXXXlOGvRw8eBCzZ8/Ghx9+CACYOHGiUq5z587o168f5syZ44xqOp2lduK5u5SlNuK5mxzt4sWLSE9Ph5eXFxITE5XH33vvPXTp0gV//vknRo4cCVmWMXDgQPTv318pk5qaiosXLwIwrMgNAPv371ee37x5MxISEspNB1QTNWnSpNxjjRs3xoMPPoihQ4cqq816eHg4oXbu53bbs3fv3li9ejXGjRtXVVV1W5IkoU+fPvjxxx/Rt29f1K9fH7169cJvv/3m7Kq5FV9fXxw5cgT//ve/kZeXh6CgICQlJWHUqFGQJAk6nQ5jxoxBTk4OIiIi8Nhjjymv7d69O1avXo1nnnkGLVq0wKuvvurEI3Fd48aNw5QpUwAYrrEfffRRTJkyBXl5ebj//vvx9NNPK2UDAgJw77334ocffsDbb7/trCq7hMr6/F+4cCHeeust/Otf/4K3tzd69uyJBx98sAqPzPEkwduNdktKSsLy5ctRt25dZ1eFiIiIiIioWsjOzkZqaiq2bNkCb29vZ1fHZfH7qPOlpaXhypUrmDlzprOrQlTjcci5nYxR7cjISCfXhIiIiIiIqHqQZRmfffYZkpOTGcy0gt9HiYhMcci5HebNm4cff/wRL774IoebEBEREREROUjPnj0RGBiIxYsXO7sqLovfR4mIyuOQcyIiIiIiIiIiInIbHHJOREREREREREREboMBTSIiIiIiIiIiInIbDGgSERERERERERGR22BAk4iIiIiIiIiIiNwGVzknIiKiakmr1WLBggX46aefkJeXh2bNmuHZZ59F48aNAQArVqzAypUrIcsyBgwYgClTpkCSJOh0Orzwwgv47bffcPnyZWzevBm1a9dWtjtkyBBcvHhR+b2wsBBTp07FiBEjzNYjLS0NV65cwcyZMyv3gImIiIiIaghmaBKR29q/fz/atWuHdu3aISMjw9nVISIXo9frER0djeXLl2Pnzp2Ij4/H9OnTAQDfffcd1q1bhxUrVuDzzz/Hd999h/Xr1yuvbdu2LRYtWmR2u59//jn27t2LvXv3Ij09HRqNBgkJCVVyTERE5Hp4TUpEVPWYoUlELiklJcUkA8qcrl27omXLlgAAT0/PqqiWTfv378fEiRMBAOvXr0dUVJSTa0RUc/n4+GDs2LHK7w8//DDeffdd5OTkYOPGjRg0aBBiYmIAACNGjMCmTZswYMAAaDQaDBs2zK59bN++Hc2bN0dsbKxd5WVZxnPPPYdDhw5Br9ejffv2mDlzJoKCgpCRkYFBgwbhmWeewYcffggAmDJlCvr27VvBIyciIkfhNSkRkWtiQJOIXFKzZs0QGhoKAMjKykJWVhYAoGnTpsqFYkJCAgYOHOisKhKRmzly5AhCQkIQHByMU6dOoU+fPspzTZs2xfvvv1/hbW7atAkPPPBAhV6TmJiIV155BXq9Hi+88AKWLFmiZI4WFxfjzJkz2LBhA3799Vc899xzSEpKgre3d4XrRkREd47XpERErokBTSJySW+++abyc1paGj7++GPlceMdZuPwHqD0zvOcOXOwYcMGREZGYsKECfjggw+Qm5uL/v3748knn8T777+P9evXIyAgAKNGjcKgQYOU/Vy+fBmLFy/GDz/8gJycHISHhyMlJQWjRo2CRmM4XR49ehSLFy/GiRMnkJ+fj1q1aqFZs2aYPn06vvnmG6WeANC/f38AQL9+/TBnzhx8+umn2LRpEzIzM5GXl4fAwEC0bt0aTz31FOrVqwcASE9Px9y5cwEAr7/+OpYtW4YzZ87g3nvvxdy5c7F7924sWbIEhYWFSE5OxowZM5S6Gdti2rRpOHbsGPbu3Qtvb2+kpqZiwoQJkCTJ8X8oIjeRm5uL+fPnY9KkSQCA/Px8+Pv7K8/7+fkhPz+/QtvMyMjA77//jjfeeMPu16hUKpNA6vDhw7F48WLldyEExo4dCw8PD3Tq1Amenp44f/68Mu8nERFVLV6T8pqUiFwTA5pEVC1lZ2fj9ddfR+3atZGXl4fVq1fjxx9/RFZWFvz9/ZGZmYlFixbh3nvvRYMGDZCTk4NRo0bh0qVL8PPzQ4MGDfD333/jww8/xIULFzB79mzIsoxp06bh+vXrCA0NRYMGDXD58mXs3bsXjzzyCMLDw9GgQQOcOnUKQOmde+OQ1l9//RXnzp1DREQEwsLCcPr0aezatQvHjh3DF198AS8vL5NjmD17NiIjI6HVarFv3z6MHz8e586dQ1RUFC5duoR169ahSZMmSE1NNXnd4sWLERQUhICAAGRlZWHJkiUIDg7G0KFDq6bxiVxMUVERpk+fji5dumDAgAEAAF9fX+Tm5ipl8vLy4OvrW6Htbt68GR06dEBISIjyWNkFg/7zn/8gIiLC5DU6nQ7vvvsudu3ahZs3b0IIgeDgYOV5T09Pk0Crt7c3CgoKKlQvIiJyHbwm5TUpEVUOLgpERNVScXEx/u///g9ffPEFwsPDAQDnzp3D6tWrsW7dOnh5eUGWZfz6668ADIt8XLp0CaGhofjqq6+wevVqLFy4EACwYcMGnDt3Djdu3MD169cBAMuXL8eqVauwbds2rF27Fg0bNsTAgQPx3HPPKXV48803sWLFCmUOv8mTJ2PXrl34z3/+g7Vr1+K9994DAFy6dAmHDx8udwyPP/441q1bpwxnPXXqFGbPno0vvvgCrVu3BmDICLhVixYtkJ6ejvXr16NNmzZKfYlqIp1Oh5kzZyIsLAzTpk1THm/QoAFOnjyp/H7ixAk0bNiwQtvevHkzevfubfJY2QWDbg1mGl9z8OBBLF++HHv27MHChQshhKjYQRERkdvgNSmvSYmocjBDk4iqJePQGQCIiIjApUuX0KhRI2VoUK1atZCZmYmrV68CAH7//XcAwJUrV5CcnGyyLSEEfvvtN/Tu3RutWrXCkSNHMGjQIMTGxqJRo0bo0qWLXXPoZWZmYv78+Th58iTy8/NNghiXL18uVz4+Ph4AEBkZqTzWtWtXAEB0dDQOHTqk1L+spKQkZchPUlISDh48iCtXruDatWuoVauWzXoSVSfz5s1DUVERFi5caDLErU+fPli4cCGSk5Ph5eWFzz77DI888ojyvFarVd6jxcXFKCoqMslY+eOPP3Dx4kV069atQvXJy8uDp6cnAgICkJOTg08//fTODpCIiFwar0l5TUpElYMBTSKqlvz8/JSf1Wp1uceMgQ3jBZzx/8ahPbcyLsixePFibN68GYcPH8apU6ewY8cObN26FdnZ2Rg5cqTF+pw/fx4zZsxAcXEx/Pz8cNddd0Gn0+HEiRMADCsfWzoGY/0BKENRb60/EZV38eJFpKenw8vLC4mJicrj7733Hrp06YI///wTI0eOhCzLGDhwoDLHGACkpqYqQ8dTUlIAmGafbN68GQkJCfDx8bGrLsb3bN++ffH9998jOTkZ4eHhGDhwINauXXvHx0pERK6J16RERJWDAU0iIhiGxOzbtw9qtRrz589X7prn5eVh165dSExMhBACR44cQUpKirKS5SuvvIL169fj4MGDGDlypMlKxGXnvfvjjz9QXFwMAPjXv/6FVq1aYcuWLXjxxRcdfiw7duxQJpbfuXMnACA0NJR3wqnGiYyMNDsEzmj06NEYPXq02efS09Otbnvq1Kl216OgoACBgYEADF8AjUP7jEaMGAEAiIqKwr59+ypUDyIiql54TUpEZB8GNImIYFjI4+uvv0ZWVhZSU1PRoEED5OXl4dKlS9DpdOjXrx/0ej0mTZoEPz8/hIeHQ5IkZbJ14wrEMTEx0Gg00Ol0mDRpEiIjIzFixAg0btwYarUaer0ekydPRkREBK5cuVIpx3L8+HGkpKRAkiRkZWUBAB577LFK2RcRWZebm4sffvgB48ePd3ZViIjIDfCalIjIPlwUiIgIhvmLli9fjpSUFAQFBeGvv/5CUVER2rRpg3/84x8ADMNsUlNTERUVhaysLJw/fx6RkZF49NFHMW7cOABAcHAwZsyYgfDwcFy9ehW//fYbrly5gvr16+Pll19GdHQ0dDodgoODMW/evEo5lkmTJqFdu3bIzc1FUFAQHn/8ca4mSeQEBw8eRP/+/dGiRQskJCQ4uzpEROQGeE1KRGQfSXCyCyKiaqFdu3YAgNmzZytz/hERERERVSVekxJRVWCGJhEREREREREREbkNBjSJiIiIiIiIiIjIbXDIOREREREREREREbkNZmgSERERERERERGR22BAk4iIiIiIiIiIiNwGA5pERERERERERETkNhjQJCIiIiIiIiIiIrfBgCYRERERERERERG5DQY0iYiIiIiIiIiIyG0woElERERERERERERugwFNIiIiIiIiIiIichsMaBIREREREREREZHbYECTiIiIiIiIiIiI3AYDmkREREREREREROQ2GNAkIiIiIiIiIiIit8GAJhEREREREREREbkNBjSJiIiIiIiIiIjIbTCgSURERERERERERG6DAU0iBxo1ahSmTZvm7GoQmcX+Sa6M/ZOIyDF4PiVXxv5Jroz9070woFlJ+EZwX71798ZTTz1V7vEbN27A19cXu3btckKtSp0+fRqSJKFDhw4QQiiP//Of/0S3bt2U37t16wYvLy/4+/sr/2rXrm31+YyMDIfUce7cuQgPD0dgYCAeeeQR5Obm3nb5OXPmQKPRmNRz7dq1DqmnO2L/vHMV6Z/29L+K9vfqjP3zzlWkP2VlZWHo0KEICwtDWFgYZsyYAb1erzzP8yfxetR98Xx653g9WnnYP+8cr0crD/vnnXOX61EGNK3gG6FmGjt2LFatWoWioiKTx1evXo3IyEiTtnWmv//+G+vWrbNaZuHChcjNzVX+ZWdnW30+Kirqjuu1fPlyLF26FHv37sXZs2dx5coVTJky5Y7K9+vXz6SeDz/88B3X012xf96ZivZPwHr/u53tVWfsn3emov3p0UcfhZeXF86cOYPDhw9jx44dWLhwoUkZnj/dH69HayaeT+8Mr0crF/vnneH1aOVi/7wz7nQ9yoCmFXwj1Ez9+/eHRqPBV199ZfL48uXLMXLkSPTs2RNhYWGoVasW+vbti9OnT5vdzu7duxEcHGzy2MCBAzFnzhzl9wMHDiAxMREhISFo3LgxPv74Y7vrOXPmTLz00kvQ6XR2v8YRcnJyMGTIEAQHB6N58+Z47733IEmS8vyyZcswZcoUNG3aFMHBwXj11VexatUqFBQUmN1eRcvXdOyf1jm6f9rC/muK/dM6R/bPvLw8bNu2DbNnz4avry+ioqIwbdo0fPTRR1V5SFQFeD1aM/F8ah2vR52L/dM6Xo86F/unddXpelRTJXuxU7t27ZCZmVkl+4qIiMD+/futlunfvz+eeOIJfPXVV+XugBjfCIcOHYJOp8P999+P999/H/Xr1y+3nd27d2PgwIHIyclRHhs4cCBat26tvBkOHDiA6dOn4/DhwwgJCcFzzz2HcePG2XUsxjfCgw8+CI3Gpf6kdmk3Tkbm1arZV0QIsP9j63F8Dw8PPProo1i2bJnydz927Bj279+Pt956Cx06dEBiYiK0Wi3GjBmDcePGYdu2bRWuS2ZmJpKTk/HBBx8gNTUV//vf/9CzZ080bNgQSUlJNl//2GOPYenSpVi6dCkmTJhQ4f0DwGuvvYZXXnkF9erVw9NPP42RI0fafM2UKVOQk5OD06dPIz8/H/379zd5/siRI5g9e7bye+vWrVFUVIQTJ07gnnvuKbc9e8rv3LkToaGhCA0NxeDBg/Hyyy/D29v7to65or7r/gO0WUW2CzqAZx0vdNl5n9Uy7J/WObp/Atb73+1sz5G6b/sRlwq1lb4fAAj39sTO5E5Wy7B/WufI/inLMoQQJhlxsizjzJkzuH79OoKCggA49/zprng9WjOvR7XFAmcvVf5+6oYDnh6SzXI8n1pX065HZa2MgvOVH5zyifGBytN2zhP7p3U17XpUq5dxPr+w0vcT4+sNTzX7Z1nO7p/Ovh51qauNzMxMXLhwwdnVUPCNUDUyrwIXLlfZ7uwyZswY3H333Th37hxiY2OxbNky9OrVC507d1bKeHt748UXX0THjh0hyzJUqoolPH/66aeIj4/HkCFDAAAtW7bE6NGjsWrVKrv+7mq1GvPnz8cTTzyBRx991GyZF154weQOUvv27ZU+umDBAsTFxcHX1xc7d+7EkCFDEBAQgAcffNDiPvV6PdauXYu9e/ciODgYwcHBeOaZZzB06FClTG5ursmdLA8PD/j6+uLmzZtmt2mr/ODBgzF27FhERUXh2LFjGDFiBHJzc/Huu+/aaiKH0GYVofBi1QQ07cX+aV5l9E9b/a+i23O0S4VaXCxg/6yJ/TMgIAAJCQmYPXs2PvzwQ1y9elXplzdv3kRQUJDTz5/uitejNfN61BXxfGpeTbwedUXsn+bVxOtRV8T+aV51ux51qYBmRESEy+2Lb4TKFxFSJbup0L7i4uLQoUMHfPLJJ3j++eexcuVKLF68GJcvX8bUqVOxd+9eXL9+HQCg1WqVN2tFnD59Ghs3bjQ5Wej1enTt2tXubQwYMACLFi3Cu+++Cx8fn3LPL1iwwOJiAPfdV5oJ2KtXL0yYMAFr1661+nfPzs6GVqtFvXr1lMfK/gwA/v7+StsAgE6nQ35+PgICAsxu01b5Fi1aKM+1bNkS8+fPx+OPP15lF5CedbyqZD8V2Rf7p3mV0T9t9b+Kbs/Rwr09q2Q/FdkX+6d5ldE/P/vsM0ydOhWNGzdGYGAgxo4diyNHjqBWrVoAnH/+dFe8Hq2Z16OeHhIax1TJruzG86l5NfF6VOWpgl9DvyrZl73YP82ridejnmoVGgb4Vsm+7MX+aV51ux51qYCmrSE3zsA3QuWzNQTcWcaMGYPXX38dLVu2hCzLSElJwRNPPIH8/HwcOHAAYWFhOHToENq0aWOSYm3k7++PgoICCCGUOSkuXryI1q1bAwBiY2Px4IMPYs2aNXdUz4ULFyIlJQWTJ0++o+3Y88Wndu3a8PDwwJkzZxAeHg4AOHv2rEmZVq1a4dChQ8qXn0OHDsHLywtNmzY1u82Klq/oF7Q7ZWsIuLOwf5ZXGf3TVj3udHt3ytYQcGdh/yyvMvpndHS0yZyFH3zwAdq1awc/P/Nfeqv6/OmueD0arDxWk65HXRXPp+XVxOtRV8X+WV5NvB51Veyf5VW361Geie0wZswYrFixAhs2bFDeCC+88ILyRrhx4wa+/fZbALD5RjC6ePGi8rPxjZCTk6P8u3nzJjZu3Fihei5cuBCLFi3C1at3NiElP6ANhg4diszMTGXIk4eHh7KiaHBwMK5cuYK5c+dafH3Tpk3h4eGBVatWQa/XY82aNTh48KDy/KOPPoqdO3fiv//9L4qLi1FcXIxDhw7hl19+qVA9u3Tpgi5dumDx4sV2vyYnJwcbN25Efn4+9Ho9duzYgbS0NKSmplp9nVqtxpAhQzBr1izk5OQgIyMDb7zxhkmZ0aNH47333sOff/6J69evY9asWRg+fLjZLzb2lP/yyy9x5coVAMAff/yBmTNn2qxnTcD+WV5l9E9b/a+i26sp2D/Lq4z+efz4ceTk5ECv12P37t3KcF0jnj+rF16P1kw8n5bH61HXwf5ZHq9HXQf7Z3nV7npUkE03b94Ufn5+on79+mL69OlCCCEGDx4shg0bJrRarcjOzhYDBw4UAMS1a9eEEEI89thjYurUqUIIIa5fvy78/PzEypUrhU6nE6tXrxYeHh5i9uzZQgghzp8/L8LCwsS6deuEVqsVWq1WHDx4UPz8889W63Xq1CmTfQohRL9+/URoaKhISEhQHktISBDvvPOO2W1cu3ZNfPPNNyIvL0/odDqxfft2ERwcLD7//PPbaapqZ/To0QKAOHbsmBBCiGPHjon27dsLPz8/0axZM5GWlmbx7y6EEKtWrRIxMTEiKChIPPnkk6Jfv37K310IIQ4cOCCSk5NFaGioqFWrlrj//vvF9u3brdbJ3N/9t99+EyqVqtzf3dPTU/j5+Zn8y87OFllZWaJDhw4iICBABAQEiLvvvlssXbrUrja5evWqSE1NFYGBgaJZs2bi3XffFbeeSubMmSPCwsKEv7+/GDZsmLhx44by3Lx588QDDzxgd/lhw4aJ0NBQ4evrKxo0aCCef/55kZ+fb1ddqzv2z/Ic3T/t6X/WtleTsX+W5+j+uXjxYlGnTh3h4+MjWrVqJb766iuTbfH8Wb3werTm4vm0PF6Pug72z/J4Peo62D/Lq07Xowxo2olvBCLzDh48WO4ESOQq2D/JlbF/UkXxepTIPJ5PyZWxf5Irc+f+KQlhZkwKEZGdrM07QuRs7J/kytg/iYgcg+dTcmXsn+TK3Ll/cnIaIhfUu3dv+Pv7l/vXu3fvSt/33r17ze7b398fe/furfT9k+tj/yRXxv5JROQYPJ+SK2P/JFfG/lk1mKHp4nr37m2203Xt2hWbNm1yQo2IiIiIqCbh9SgRERG5GgY0iYiIiIiIiIiIyG1wyDkRERERERERERG5DQY0iYiIiIiIiIiIyG0woElERERERERERERugwFNIiIiIiIiIiIichsMaBIREREREREREZHbYECTiIiIiIiIiIiI3AYDmkREREREREREROQ2GNAkIiIiIiIiIiIit8GAJhEREREREREREbkNBjSJiIiIiIiIiIjIbTCgSURERERERERERG6DAU0iIiIiIiIiIiJyG/8P7+XqZ2DFuS0AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# probabilistic regression model (with quantiles)\n", + "model = LinearRegressionModel(\n", + " lags=input_length,\n", + " output_chunk_length=horizon,\n", + " likelihood=\"quantile\",\n", + " quantiles=quantiles,\n", + ").fit(train)\n", + "\n", + "# conformalized quantile regression model\n", + "cp_model = ConformalQRModel(model=model, quantiles=quantiles, cal_length=four_weeks)\n", + "hfcs = cp_model.historical_forecasts(\n", + " series=cal_test,\n", + " forecast_horizon=horizon,\n", + " start=test.start_time(),\n", + " last_points_only=True,\n", + " stride=horizon,\n", + " **pred_kwargs,\n", + ")\n", + "plot_historical_forecasts(hfcs)\n", + "\n", + "bt = cp_model.backtest(\n", + " cal_test,\n", + " historical_forecasts=hfcs,\n", + " last_points_only=True,\n", + " metric=[metrics.mic, metrics.miw],\n", + " metric_kwargs={\"q_interval\": q_interval},\n", + ")\n", + "pd.DataFrame({\"Interval\": q_range, \"Coverage\": bt[0], \"Width\": bt[1]})" + ] + }, + { + "cell_type": "markdown", + "id": "98998cdf-3c8e-48d6-86e0-b0ad908a988f", + "metadata": {}, + "source": [ + "Same coverage, but slightly larger intervals than in the naive conformal prediction case." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "02734a93194d4fbaa50d7489b79e3bf7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "031935c0e55647eb87fd638454710ebb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "032ca57dec0c498798ba4db557df0326": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "035e6c4e6bf844b2ad856f6e1331457a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "03c3336072334c52b1c8b9ed8691f91a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_7585b109b9854c4ca17275fbdd2a13fc", + "max": 1, + "style": "IPY_MODEL_1c2bf34914014874905f10aeadc62a78", + "value": 1 + } + }, + "03f79ddd66f84399aaa02edd0f89429a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_190fed71fcc34a4b98c95de252805e44", + "IPY_MODEL_d01c9a9d8f2347cbb7dba9d0d03b1199", + "IPY_MODEL_862c3c1d244f4b658d39be7d181d1aae" + ], + "layout": "IPY_MODEL_4754fdcc3f794a07a3684e87d27348d0" + } + }, + "042fb62065f74e5a88e3bf29a71069f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_902b08529b1c4cd1bed5a71abb5b6454", + "style": "IPY_MODEL_afd3129aa14240bf83d49147e1dd2f0d", + "value": " 1/1 [00:15<00:00, 15.53s/it]" + } + }, + "050695bb79ae42f8bfb6e47a520112fe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "0643a2e4c65b46c4967e73a5286e76cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_653543634b0d4b1a87cb764bb06f77e4", + "IPY_MODEL_33a4abb53c5d4ef08191dd179855b045", + "IPY_MODEL_fbe84311611a48b48da1acaf4ff11405" + ], + "layout": "IPY_MODEL_bf31a40bf5fa47849abd83630ac77925" + } + }, + "06dce4ff5a09498abadb90800a4b296d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "0a180449c919489f91009fba92bf3a3f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0ba0ad81dcb7449480aaa0eb5604b479": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "0d41c14b643b45a9884fe3d38d6144ed": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "0e34600f9d4641a0b9ff5b88d81b913c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "0fcd3c5e2b5b48edbc0c15a0b734e5ff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "100384b4a5fe447f90b761cb9e41cb3a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1133df19e7264dbfb4041f5cab4e4e04": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "11f1766ff8f343999a843bb49949004b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "134beb5cda3e43c09b5488830abc7440": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_96bf108b79174b1d8835fe8fff4de047", + "IPY_MODEL_a6926c440a4349258b6673a505bf172d", + "IPY_MODEL_e3dc9f72076e4f339a74fea4b62f6989" + ], + "layout": "IPY_MODEL_162d5ec4609442c3aed84b865b798c08" + } + }, + "14cb41d472cb41598d839c132ee146fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "162d5ec4609442c3aed84b865b798c08": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "190fed71fcc34a4b98c95de252805e44": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_4ff859b0d5004391bb2465ef667871d2", + "style": "IPY_MODEL_3fb79582133f48c6851387d8d1d08dc6", + "value": "historical forecasts: 100%" + } + }, + "194d51daa3904a59a809a25cc82ac066": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "19ce5739b023449a9b53102cd9bf4500": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1c2bf34914014874905f10aeadc62a78": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "2126f8684e0b454991611f56606e92d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_26fd6c94f91443efb29636cb48639a59", + "max": 1, + "style": "IPY_MODEL_8b7015dde4e542989d9533c3ad077fe1", + "value": 1 + } + }, + "24663c64d6de45349849637e057b2cf0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_c328d545f8c446c18f7dd4d0630e30bb", + "style": "IPY_MODEL_260b8e78c7b841cd87b0cddae6754f4f", + "value": " 1/1 [00:00<00:00,  2.25it/s]" + } + }, + "260b8e78c7b841cd87b0cddae6754f4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "26fd6c94f91443efb29636cb48639a59": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "2bd9e1609a534702bc010c6528cba52d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_035e6c4e6bf844b2ad856f6e1331457a", + "max": 1, + "style": "IPY_MODEL_cb69dd95e0054084b83ce6b36129d560", + "value": 1 + } + }, + "3036b375398a4208a0cdc12d9fccba3b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "31c3969fdfc8437c942f9e1086a96743": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_c1e53a9530184df6978a812de6cea6bf", + "max": 1, + "style": "IPY_MODEL_f147d20a7eac48acb0216e0144c1880b", + "value": 1 + } + }, + "33a4abb53c5d4ef08191dd179855b045": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_bf6713873ea143ff81b51d74258b8f88", + "max": 1, + "style": "IPY_MODEL_45f2e69c1e8745e29e4eaa7a5d0c109f", + "value": 1 + } + }, + "34ee120772074375aa9363965665998e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "35d4b34b1fa34fb89547b31944163561": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "36659c4477804191936984e5c00f0e55": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_5ca5de714ea2410c94c51336520037a6", + "style": "IPY_MODEL_ab944cfc8b1b42debc1cba16059b217d", + "value": " 8761/8761 [00:00<00:00, 27925.26it/s]" + } + }, + "3a734f69319041b292823a0cc05b3e71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3aad5a2d827343bcb70ae32108a9f929": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3c0c14944f804ea583571abcdcc8f179": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_14cb41d472cb41598d839c132ee146fd", + "max": 8761, + "style": "IPY_MODEL_41ecc953be7b4003a504d3d670f00eb6", + "value": 8761 + } + }, + "3c83c59e02fb42929d9ab1aa59e834a0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "3d3cd15057784fc7820c4035f2288fce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "3dbd8c2a106645ba9e2c8568686ec2dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_cb865043d2db45199e32c11edc51316f", + "style": "IPY_MODEL_87cfe6056cba481f93dad0c094db79d6", + "value": "historical forecasts: 100%" + } + }, + "3ed4aaf4fa10446ab0fb927944ac34da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "3f7d4ca675e9447b81435d9693f53ee5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "3fb79582133f48c6851387d8d1d08dc6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "41ecc953be7b4003a504d3d670f00eb6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "4450f86af0634a8399b4c67f46a44a6f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_8fdba63d51944d58abacbeadfa6f6caa", + "IPY_MODEL_2bd9e1609a534702bc010c6528cba52d", + "IPY_MODEL_d9039974750e4162889ea97a4532cca9" + ], + "layout": "IPY_MODEL_bfdd66cd185b4c9da69c78d4f1daaae0" + } + }, + "4525b25c3e844b9ab79da68a6561235b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "45f2e69c1e8745e29e4eaa7a5d0c109f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "464e873e809d487ebd6393613a629fd8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "4754fdcc3f794a07a3684e87d27348d0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "482043b2b67b4502baa02117e090560e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "4aeca2f3a47648cea0208cdfbfe7ca76": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "4ff859b0d5004391bb2465ef667871d2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "520a279de08140fd89a6f80b417f65fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_032ca57dec0c498798ba4db557df0326", + "style": "IPY_MODEL_35d4b34b1fa34fb89547b31944163561", + "value": "historical forecasts: 100%" + } + }, + "5581bbe9a69240718e7e746c28ccbb5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_3dbd8c2a106645ba9e2c8568686ec2dd", + "IPY_MODEL_dac15bc3968342d1beb89a6f1fb519b4", + "IPY_MODEL_ad581670893d45c288ac736680eafbce" + ], + "layout": "IPY_MODEL_3d3cd15057784fc7820c4035f2288fce" + } + }, + "57929b061122419088b7ce5f489c4c5a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5ca5de714ea2410c94c51336520037a6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "5cc3b206f2584cd7b0e829d1ae7ae786": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_b8e0ce61252d409da591a510c75fdca4", + "style": "IPY_MODEL_3a734f69319041b292823a0cc05b3e71", + "value": "conformal forecasts: 100%" + } + }, + "5d813fc2b0ba4706a2d88e0f99a73c4e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "5dbc8cb42fbf4b2ba848389e610544aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5dd3247eccfe4d5a80a483584dc4d563": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_e013a2fbfa8a4301ad4b6b9a840e111b", + "style": "IPY_MODEL_9888722983334f638d96cb3bd1be3710", + "value": " 1/1 [00:00<00:00, 13.98it/s]" + } + }, + "616db6058650441cb3f33fdec3c078b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_e8ff5bc2e38c4683be402fa2bae255b2", + "style": "IPY_MODEL_100384b4a5fe447f90b761cb9e41cb3a", + "value": "conformal forecasts: 100%" + } + }, + "653543634b0d4b1a87cb764bb06f77e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_8a63ad4c472c4a22bb669436501c85e4", + "style": "IPY_MODEL_8690b88a37384a409df7022e622c47ac", + "value": "historical forecasts: 100%" + } + }, + "6642103db63e423997c6813cdb3183d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "66c5a4b34ced44deaa32f461d4d1091e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_936c2736e3fa4b8d966a3b7244875188", + "IPY_MODEL_e0021ae748604ca4853a08431a353f8e", + "IPY_MODEL_36659c4477804191936984e5c00f0e55" + ], + "layout": "IPY_MODEL_bcb12187551d4530a394926d950a3d1d" + } + }, + "6a51687381bb4207b5c3249190917084": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "6b1cccc2e3bd441382af4022099b735e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_520a279de08140fd89a6f80b417f65fc", + "IPY_MODEL_2126f8684e0b454991611f56606e92d5", + "IPY_MODEL_24663c64d6de45349849637e057b2cf0" + ], + "layout": "IPY_MODEL_031935c0e55647eb87fd638454710ebb" + } + }, + "6d28945875f54979beac33fc825d79e9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "6d46914fa82045bf8db060e025373631": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_3f7d4ca675e9447b81435d9693f53ee5", + "style": "IPY_MODEL_6642103db63e423997c6813cdb3183d9", + "value": "historical forecasts: 100%" + } + }, + "6f1d228446304cadacfc27e9ca1be4ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_f40fc450a1ee4218a0d4f4dc5756a9f9", + "IPY_MODEL_31c3969fdfc8437c942f9e1086a96743", + "IPY_MODEL_5dd3247eccfe4d5a80a483584dc4d563" + ], + "layout": "IPY_MODEL_c569b1b985a04dc497dc57d070147eef" + } + }, + "7585b109b9854c4ca17275fbdd2a13fc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "769c5712392843fdae22fdf33fb8b73e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "79816ea46c714a799519fa627754f2a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_769c5712392843fdae22fdf33fb8b73e", + "style": "IPY_MODEL_5dbc8cb42fbf4b2ba848389e610544aa", + "value": " 1/1 [00:00<00:00,  3.03it/s]" + } + }, + "79bf64810a64492b824b7af3004bf302": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "7b59568f487044edbe7402a614b48248": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7c4672858a2840079abacc535e6376b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7e0b9e683abc439c8951bc47f83c148d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_d831950134744e499580c235d5a3fbec", + "style": "IPY_MODEL_194d51daa3904a59a809a25cc82ac066", + "value": "conformal forecasts: 100%" + } + }, + "8082a47fb6e64764a50e0acc43a2041c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_0fcd3c5e2b5b48edbc0c15a0b734e5ff", + "style": "IPY_MODEL_7c4672858a2840079abacc535e6376b0", + "value": " 1/1 [00:00<00:00, 234.65it/s]" + } + }, + "8220be72db524c5abc7493b78bcc3e30": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "83a738780a7f4b29951f52771f7e70a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_bdebef6fab784be082f44507c4fc1e0b", + "max": 1, + "style": "IPY_MODEL_79bf64810a64492b824b7af3004bf302", + "value": 1 + } + }, + "83af5f1740ad4771ac3fda66d5a098b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_3036b375398a4208a0cdc12d9fccba3b", + "style": "IPY_MODEL_88490242bf394ae5ba05cb40d4bd0769", + "value": "historical forecasts: 100%" + } + }, + "862c3c1d244f4b658d39be7d181d1aae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_4525b25c3e844b9ab79da68a6561235b", + "style": "IPY_MODEL_c42773b48f394255869b71cbce7371be", + "value": " 1/1 [00:00<00:00,  3.42it/s]" + } + }, + "8690b88a37384a409df7022e622c47ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "86beef51610845cea4f9b49e9247b983": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_5cc3b206f2584cd7b0e829d1ae7ae786", + "IPY_MODEL_83a738780a7f4b29951f52771f7e70a1", + "IPY_MODEL_954014f5451f4686bb255980500cdc97" + ], + "layout": "IPY_MODEL_1133df19e7264dbfb4041f5cab4e4e04" + } + }, + "87cfe6056cba481f93dad0c094db79d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "88490242bf394ae5ba05cb40d4bd0769": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8a63ad4c472c4a22bb669436501c85e4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "8b7015dde4e542989d9533c3ad077fe1": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "ProgressStyleModel", "state": { - "children": [ - "IPY_MODEL_da0ea0405a89477fa56f452a60194789", - "IPY_MODEL_8a8d50f3a88c4f29b0e2b5eba86adc9d", - "IPY_MODEL_c3e21021a388404ab7bcbb10ab2f8963" - ], - "layout": "IPY_MODEL_7bf5adea7d914c67b2a9a95867c43d9b" + "description_width": "" } }, - "03caca835e154a0b85c3d0008f127866": { + "8fdba63d51944d58abacbeadfa6f6caa": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { - "layout": "IPY_MODEL_fe3caca7e6ec473981fd126defc803a3", - "style": "IPY_MODEL_6e5b45695f4a4815bf289251628e5539", - "value": " 1/1 [00:04<00:00,  4.06s/it]" + "layout": "IPY_MODEL_5d813fc2b0ba4706a2d88e0f99a73c4e", + "style": "IPY_MODEL_7b59568f487044edbe7402a614b48248", + "value": "conformal forecasts: 100%" } }, - "058d4c250d464958b05c09ee2ed499eb": { + "902b08529b1c4cd1bed5a71abb5b6454": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "936c2736e3fa4b8d966a3b7244875188": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { - "layout": "IPY_MODEL_90d1e145713c433e8ca195e10b428ea6", - "style": "IPY_MODEL_3b55aac6712e491ebb0e37ec0c9f6c87", - "value": "historical forecasts:   0%" + "layout": "IPY_MODEL_06dce4ff5a09498abadb90800a4b296d", + "style": "IPY_MODEL_b88844e00e044ccc8e91b5c392f69b07", + "value": "conformal forecasts: 100%" } }, - "10b8d7ecf0284f41a16d82235a8b21a9": { + "954014f5451f4686bb255980500cdc97": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { - "layout": "IPY_MODEL_d5dd3401a8f64245a33dd517e5784bd4", - "style": "IPY_MODEL_62822d972503475595e6ea6263ea290d", - "value": " 0/1 [00:00<?, ?it/s]" + "layout": "IPY_MODEL_464e873e809d487ebd6393613a629fd8", + "style": "IPY_MODEL_57929b061122419088b7ce5f489c4c5a", + "value": " 1/1 [00:00<00:00, 202.55it/s]" } }, - "11943bf241664740bd1053f67dbe8564": { + "95ac5cad39e545bc812d370a64e868d8": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} }, - "1296f2037fee46fd83348c7d2fa1c87e": { + "96bf108b79174b1d8835fe8fff4de047": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLModel", "state": { - "description_width": "" + "layout": "IPY_MODEL_0ba0ad81dcb7449480aaa0eb5604b479", + "style": "IPY_MODEL_11f1766ff8f343999a843bb49949004b", + "value": "conformal forecasts: 100%" } }, - "137fc19c91bf4b64b7a515453093b66a": { + "979deef91d9e43079c5793ca74a9124e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { - "layout": "IPY_MODEL_11943bf241664740bd1053f67dbe8564", - "style": "IPY_MODEL_b6b5a49421334963a4955f739ef9a31d", - "value": "historical forecasts:   0%" + "children": [ + "IPY_MODEL_616db6058650441cb3f33fdec3c078b1", + "IPY_MODEL_3c0c14944f804ea583571abcdcc8f179", + "IPY_MODEL_b9cb09dbc1fd4e9db6e415298d379c5f" + ], + "layout": "IPY_MODEL_c6c975ba154f4e5eb3176b9e08b0d85d" } }, - "1c4f38597cc545539de6e0ee478bbcb1": { + "981029fee74546bd8b1b1d664789b4b4": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLModel", "state": { - "description_width": "" + "layout": "IPY_MODEL_95ac5cad39e545bc812d370a64e868d8", + "style": "IPY_MODEL_d31a8292c5754064a4043e5f9cee9c23", + "value": " 365/365 [00:00<00:00, 1783.39it/s]" } }, - "1e2c668e9cef4f67b636126ce872cde2": { + "9888722983334f638d96cb3bd1be3710": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -842,13 +2439,25 @@ "text_color": null } }, - "209a43c2798f4069a7f056fced6fee77": { + "9f6a8d62e599415ba7ce6959c4123e6b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} }, - "22c2a074ea454b7ab79cf043a9008d98": { + "a6926c440a4349258b6673a505bf172d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_3c83c59e02fb42929d9ab1aa59e834a0", + "max": 8761, + "style": "IPY_MODEL_c24918b5434c4bba993aa8bda8e118d7", + "value": 8761 + } + }, + "a72dfaf21046461abc24e9609dcd7032": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -856,66 +2465,61 @@ "description_width": "" } }, - "2d73109fc900495e82b057f0f6cb9604": { + "a94e80e2856947ca9842ec2b7948e41a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} }, - "3130234afc9a4c21bc9896ca209199b1": { - "model_module": "@jupyter-widgets/base", + "ab3550f073174336bcd81ffdf713ed49": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } }, - "32539f19f91e41a5ba6b273a2a64cf5d": { + "ab944cfc8b1b42debc1cba16059b217d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLStyleModel", "state": { - "children": [ - "IPY_MODEL_137fc19c91bf4b64b7a515453093b66a", - "IPY_MODEL_6035795ca3c440dba5118015de4b973d", - "IPY_MODEL_10b8d7ecf0284f41a16d82235a8b21a9" - ], - "layout": "IPY_MODEL_dda9eec3a6684099a1d5c87206f7614d" + "description_width": "", + "font_size": null, + "text_color": null } }, - "3277bf058d534088a1986ccec9f28e5e": { + "ad581670893d45c288ac736680eafbce": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { - "layout": "IPY_MODEL_5ddfbdb6966a452e9a74e802235e3446", - "style": "IPY_MODEL_b686cede79d24eb2b99fb9312d8c8c3b", - "value": "conformal forecasts: 100%" + "layout": "IPY_MODEL_a94e80e2856947ca9842ec2b7948e41a", + "style": "IPY_MODEL_b0fc52a6ac5a43418c451cfd0b9c492f", + "value": " 696/696 [00:01<00:00, 657.06it/s]" } }, - "33dee21d622c47a6a936ffa4f83e3534": { + "ae57545ceb814176900a79d215d3a3f5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "ProgressStyleModel", "state": { - "bar_style": "danger", - "layout": "IPY_MODEL_559e83fe281142638a7675f4f0c8294c", - "max": 1, - "style": "IPY_MODEL_c46f1ffc6c064902a87133dfbf7d94cb" + "description_width": "" } }, - "38ce5c256b1c4436886a2cba707e07a0": { + "afd3129aa14240bf83d49147e1dd2f0d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLStyleModel", "state": { - "children": [ - "IPY_MODEL_8c4f3e5fe95d4967bcb9b032ddd7cdc8", - "IPY_MODEL_e7aee37700254593be130f114d7c1539", - "IPY_MODEL_03caca835e154a0b85c3d0008f127866" - ], - "layout": "IPY_MODEL_d394490469e5468591e0f3f5ec3c0316" + "description_width": "", + "font_size": null, + "text_color": null } }, - "3b55aac6712e491ebb0e37ec0c9f6c87": { + "b0fc52a6ac5a43418c451cfd0b9c492f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -925,124 +2529,118 @@ "text_color": null } }, - "47bbcbd7d54248249477c3bdaecf2011": { - "model_module": "@jupyter-widgets/base", + "b1ef578b93df4031a4b97b123323f63f": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } }, - "4c1f0d94db0344529a8449b44be3f18f": { + "b5299dcd5946432b840fae9dcc43a645": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HBoxModel", "state": { - "bar_style": "success", - "layout": "IPY_MODEL_dc59909465b540e29b432f2916688fd7", - "max": 1, - "style": "IPY_MODEL_991cd91551ee45858cccbbfab649e07d", - "value": 1 + "children": [ + "IPY_MODEL_bd7c460b490f442faf36866b88f567cc", + "IPY_MODEL_d57bf06d54d043d2b2793025d6104067", + "IPY_MODEL_981029fee74546bd8b1b1d664789b4b4" + ], + "layout": "IPY_MODEL_fb4b214d8c0d4eada9330509047b1cbd" } }, - "4e828a795e26409482288d4523bb48b2": { + "b88844e00e044ccc8e91b5c392f69b07": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "layout": "IPY_MODEL_9a469e862e5542c1bdccbdbc2191dc3f", - "style": "IPY_MODEL_99c1229b14c345a2b5bb831e99f5991a", - "value": " 0/1 [00:00<?, ?it/s]" + "description_width": "", + "font_size": null, + "text_color": null } }, - "522a06e4c65c4bed8f437ae91e073555": { + "b8a59a6a88a848758564bd96780ea495": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", "state": { "bar_style": "success", - "layout": "IPY_MODEL_2d73109fc900495e82b057f0f6cb9604", + "layout": "IPY_MODEL_8220be72db524c5abc7493b78bcc3e30", "max": 1, - "style": "IPY_MODEL_22c2a074ea454b7ab79cf043a9008d98", + "style": "IPY_MODEL_3ed4aaf4fa10446ab0fb927944ac34da", "value": 1 } }, - "52ab2d9d95e34e5f8da0260cd59978dc": { + "b8e0ce61252d409da591a510c75fdca4": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} }, - "559e83fe281142638a7675f4f0c8294c": { - "model_module": "@jupyter-widgets/base", + "b9cb09dbc1fd4e9db6e415298d379c5f": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_34ee120772074375aa9363965665998e", + "style": "IPY_MODEL_3aad5a2d827343bcb70ae32108a9f929", + "value": " 8761/8761 [00:00<00:00, 15922.19it/s]" + } }, - "5c613752ead44de8bca546b0df625c7f": { + "bbb54ccaca20416aa1d61682cbbd7f75": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} }, - "5ddfbdb6966a452e9a74e802235e3446": { + "bcb12187551d4530a394926d950a3d1d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} }, - "6035795ca3c440dba5118015de4b973d": { + "bd7c460b490f442faf36866b88f567cc": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { - "bar_style": "danger", - "layout": "IPY_MODEL_957e3a42996d4fa5ade679f5e013888f", - "max": 1, - "style": "IPY_MODEL_7c7458c42e614d4c818641a190289ac2" + "layout": "IPY_MODEL_f0c7032036a843f8be42e9330322e4a5", + "style": "IPY_MODEL_0a180449c919489f91009fba92bf3a3f", + "value": "conformal forecasts: 100%" } }, - "62822d972503475595e6ea6263ea290d": { - "model_module": "@jupyter-widgets/controls", + "bdebef6fab784be082f44507c4fc1e0b": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } + "model_name": "LayoutModel", + "state": {} }, - "6e5b45695f4a4815bf289251628e5539": { - "model_module": "@jupyter-widgets/controls", + "bf31a40bf5fa47849abd83630ac77925": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } + "model_name": "LayoutModel", + "state": {} }, - "70db0b349be64e1a81ff96489f3bdd08": { - "model_module": "@jupyter-widgets/controls", + "bf6713873ea143ff81b51d74258b8f88": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_7a561d8b38a54be58362655deabbc3e7", - "style": "IPY_MODEL_a73503ffc6014fafb6bfae8be9b5dc9d", - "value": " 1/1 [00:00<00:00, 51.18it/s]" - } + "model_name": "LayoutModel", + "state": {} }, - "7a561d8b38a54be58362655deabbc3e7": { + "bfdd66cd185b4c9da69c78d4f1daaae0": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} }, - "7bf5adea7d914c67b2a9a95867c43d9b": { + "c1e53a9530184df6978a812de6cea6bf": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} }, - "7c7458c42e614d4c818641a190289ac2": { + "c24918b5434c4bba993aa8bda8e118d7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -1050,58 +2648,13 @@ "description_width": "" } }, - "8568f2ee147147cb8f4bbc549ba340f0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8808260dc5614e889700e6ae856bf905": { + "c328d545f8c446c18f7dd4d0630e30bb": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} }, - "8a8d50f3a88c4f29b0e2b5eba86adc9d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_47bbcbd7d54248249477c3bdaecf2011", - "max": 1, - "style": "IPY_MODEL_1296f2037fee46fd83348c7d2fa1c87e", - "value": 1 - } - }, - "8afff452de3e444f8459f9769e2c564f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_058d4c250d464958b05c09ee2ed499eb", - "IPY_MODEL_33dee21d622c47a6a936ffa4f83e3534", - "IPY_MODEL_4e828a795e26409482288d4523bb48b2" - ], - "layout": "IPY_MODEL_8808260dc5614e889700e6ae856bf905" - } - }, - "8c4f3e5fe95d4967bcb9b032ddd7cdc8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_b68282625b71498aa81ec2653ec4d57f", - "style": "IPY_MODEL_908523b4798d426ab7d534985d19e93c", - "value": "historical forecasts: 100%" - } - }, - "908523b4798d426ab7d534985d19e93c": { + "c42773b48f394255869b71cbce7371be": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -1111,19 +2664,19 @@ "text_color": null } }, - "90d1e145713c433e8ca195e10b428ea6": { + "c569b1b985a04dc497dc57d070147eef": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} }, - "957e3a42996d4fa5ade679f5e013888f": { + "c6c975ba154f4e5eb3176b9e08b0d85d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} }, - "991cd91551ee45858cccbbfab649e07d": { + "c803eade6b564d4eaa2ba7346ad07e14": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -1131,36 +2684,31 @@ "description_width": "" } }, - "99c1229b14c345a2b5bb831e99f5991a": { + "cb69dd95e0054084b83ce6b36129d560": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "ProgressStyleModel", "state": { - "description_width": "", - "font_size": null, - "text_color": null + "description_width": "" } }, - "9a469e862e5542c1bdccbdbc2191dc3f": { + "cb865043d2db45199e32c11edc51316f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} }, - "9da79419a6c84b06bd57b07e843cea12": { + "cb8bce0e65de43988dfd982ecb85cdca": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLStyleModel", "state": { - "children": [ - "IPY_MODEL_c324252091684b009e1943267ece0ae4", - "IPY_MODEL_522a06e4c65c4bed8f437ae91e073555", - "IPY_MODEL_70db0b349be64e1a81ff96489f3bdd08" - ], - "layout": "IPY_MODEL_e02393c0493747bfa22633199b7e56ea" + "description_width": "", + "font_size": null, + "text_color": null } }, - "a73503ffc6014fafb6bfae8be9b5dc9d": { + "cd0fc6bec3ff46c0b52919d60e4d267d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -1170,29 +2718,31 @@ "text_color": null } }, - "b06eae10c3b84586bbf9c2ecab1f350a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "b68282625b71498aa81ec2653ec4d57f": { - "model_module": "@jupyter-widgets/base", + "ce79a001eb0645c4ad584084fa66a4e2": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_f687ca0b1d284cbbbb966ad371086c61", + "max": 1, + "style": "IPY_MODEL_e19ad4ded4424e0caafd267946273637", + "value": 1 + } }, - "b686cede79d24eb2b99fb9312d8c8c3b": { + "d01c9a9d8f2347cbb7dba9d0d03b1199": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "FloatProgressModel", "state": { - "description_width": "", - "font_size": null, - "text_color": null + "bar_style": "success", + "layout": "IPY_MODEL_4aeca2f3a47648cea0208cdfbfe7ca76", + "max": 1, + "style": "IPY_MODEL_ae57545ceb814176900a79d215d3a3f5", + "value": 1 } }, - "b6b5a49421334963a4955f739ef9a31d": { + "d31a8292c5754064a4043e5f9cee9c23": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -1202,140 +2752,178 @@ "text_color": null } }, - "c324252091684b009e1943267ece0ae4": { + "d57bf06d54d043d2b2793025d6104067": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { - "layout": "IPY_MODEL_209a43c2798f4069a7f056fced6fee77", - "style": "IPY_MODEL_d8e32bbb4aaa406eab210f07e0d385b2", - "value": "conformal forecasts: 100%" + "bar_style": "success", + "layout": "IPY_MODEL_050695bb79ae42f8bfb6e47a520112fe", + "max": 365, + "style": "IPY_MODEL_b1ef578b93df4031a4b97b123323f63f", + "value": 365 } }, - "c3e21021a388404ab7bcbb10ab2f8963": { + "d831950134744e499580c235d5a3fbec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "d89437eb2ec14fa997bdc230faa8e1e5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { - "layout": "IPY_MODEL_5c613752ead44de8bca546b0df625c7f", - "style": "IPY_MODEL_1e2c668e9cef4f67b636126ce872cde2", - "value": " 1/1 [00:04<00:00,  4.06s/it]" + "children": [ + "IPY_MODEL_6d46914fa82045bf8db060e025373631", + "IPY_MODEL_ce79a001eb0645c4ad584084fa66a4e2", + "IPY_MODEL_79816ea46c714a799519fa627754f2a2" + ], + "layout": "IPY_MODEL_bbb54ccaca20416aa1d61682cbbd7f75" } }, - "c46f1ffc6c064902a87133dfbf7d94cb": { + "d8b9235cd73e4b7eabb5906cea008567": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HBoxModel", "state": { - "description_width": "" + "children": [ + "IPY_MODEL_7e0b9e683abc439c8951bc47f83c148d", + "IPY_MODEL_03c3336072334c52b1c8b9ed8691f91a", + "IPY_MODEL_8082a47fb6e64764a50e0acc43a2041c" + ], + "layout": "IPY_MODEL_0e34600f9d4641a0b9ff5b88d81b913c" } }, - "d394490469e5468591e0f3f5ec3c0316": { - "model_module": "@jupyter-widgets/base", + "d9039974750e4162889ea97a4532cca9": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_0d41c14b643b45a9884fe3d38d6144ed", + "style": "IPY_MODEL_ab3550f073174336bcd81ffdf713ed49", + "value": " 1/1 [00:00<00:00, 181.72it/s]" + } }, - "d40df78c6c98420a9d64c0e118211cd1": { + "dac15bc3968342d1beb89a6f1fb519b4": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "FloatProgressModel", "state": { - "description_width": "", - "font_size": null, - "text_color": null + "bar_style": "success", + "layout": "IPY_MODEL_6d28945875f54979beac33fc825d79e9", + "max": 696, + "style": "IPY_MODEL_a72dfaf21046461abc24e9609dcd7032", + "value": 696 } }, - "d47be6489e08407ba64475239b2dc30a": { - "model_module": "@jupyter-widgets/base", + "e0021ae748604ca4853a08431a353f8e": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_02734a93194d4fbaa50d7489b79e3bf7", + "max": 8761, + "style": "IPY_MODEL_c803eade6b564d4eaa2ba7346ad07e14", + "value": 8761 + } }, - "d5dd3401a8f64245a33dd517e5784bd4": { + "e013a2fbfa8a4301ad4b6b9a840e111b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} }, - "d8e32bbb4aaa406eab210f07e0d385b2": { + "e19ad4ded4424e0caafd267946273637": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "ProgressStyleModel", "state": { - "description_width": "", - "font_size": null, - "text_color": null + "description_width": "" } }, - "da0ea0405a89477fa56f452a60194789": { + "e3dc9f72076e4f339a74fea4b62f6989": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { - "layout": "IPY_MODEL_b06eae10c3b84586bbf9c2ecab1f350a", - "style": "IPY_MODEL_d40df78c6c98420a9d64c0e118211cd1", - "value": "historical forecasts: 100%" + "layout": "IPY_MODEL_9f6a8d62e599415ba7ce6959c4123e6b", + "style": "IPY_MODEL_cb8bce0e65de43988dfd982ecb85cdca", + "value": " 8761/8761 [00:00<00:00, 34584.39it/s]" } }, - "dc59909465b540e29b432f2916688fd7": { + "e82011a926c44c29ad85d070ce0996a1": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} }, - "dda9eec3a6684099a1d5c87206f7614d": { + "e8ff5bc2e38c4683be402fa2bae255b2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} }, - "ddd1815131d246bab164c6d4d41e51ca": { + "ec085a67dc854b55a80d5ab3f9256734": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", "state": { "children": [ - "IPY_MODEL_3277bf058d534088a1986ccec9f28e5e", - "IPY_MODEL_4c1f0d94db0344529a8449b44be3f18f", - "IPY_MODEL_e457294c8d0a4424b640aa2b8bbd61a7" + "IPY_MODEL_83af5f1740ad4771ac3fda66d5a098b9", + "IPY_MODEL_b8a59a6a88a848758564bd96780ea495", + "IPY_MODEL_042fb62065f74e5a88e3bf29a71069f4" ], - "layout": "IPY_MODEL_3130234afc9a4c21bc9896ca209199b1" + "layout": "IPY_MODEL_e82011a926c44c29ad85d070ce0996a1" } }, - "e02393c0493747bfa22633199b7e56ea": { + "f0c7032036a843f8be42e9330322e4a5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} }, - "e457294c8d0a4424b640aa2b8bbd61a7": { + "f147d20a7eac48acb0216e0144c1880b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", "state": { - "layout": "IPY_MODEL_d47be6489e08407ba64475239b2dc30a", - "style": "IPY_MODEL_8568f2ee147147cb8f4bbc549ba340f0", - "value": " 1/1 [00:00<00:00, 43.37it/s]" + "description_width": "" } }, - "e7aee37700254593be130f114d7c1539": { + "f40fc450a1ee4218a0d4f4dc5756a9f9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { - "bar_style": "success", - "layout": "IPY_MODEL_52ab2d9d95e34e5f8da0260cd59978dc", - "max": 1, - "style": "IPY_MODEL_1c4f38597cc545539de6e0ee478bbcb1", - "value": 1 + "layout": "IPY_MODEL_482043b2b67b4502baa02117e090560e", + "style": "IPY_MODEL_19ce5739b023449a9b53102cd9bf4500", + "value": "historical forecasts: 100%" } }, - "fe3caca7e6ec473981fd126defc803a3": { + "f687ca0b1d284cbbbb966ad371086c61": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "fb4b214d8c0d4eada9330509047b1cbd": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {} + }, + "fbe84311611a48b48da1acaf4ff11405": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_6a51687381bb4207b5c3249190917084", + "style": "IPY_MODEL_cd0fc6bec3ff46c0b52919d60e4d267d", + "value": " 1/1 [00:00<00:00, 95.67it/s]" + } } }, "version_major": 2, From d6c10d0dd7434569f13e0a9a1d5d9463ada04c1c Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 20 Dec 2024 17:19:56 +0100 Subject: [PATCH 76/78] apply suggestions from PR review --- darts/models/forecasting/conformal_models.py | 42 +++++++++++--------- 1 file changed, 23 insertions(+), 19 deletions(-) diff --git a/darts/models/forecasting/conformal_models.py b/darts/models/forecasting/conformal_models.py index ab13cc5b59..a6bc1ba409 100644 --- a/darts/models/forecasting/conformal_models.py +++ b/darts/models/forecasting/conformal_models.py @@ -84,10 +84,10 @@ def __init__( follows: - Extract a calibration set: The calibration set for each conformal forecast is automatically extracted from - the past of your input series relative to the forecast start point. The number of calibration examples - (forecast errors / non-conformity scores) to consider can be defined at model creation - with parameter `cal_length`. Note that when using `cal_stride>1`, a longer history is required since - the calibration examples are generated with stridden historical forecasts. + the most recent past of your input series relative to the forecast start point. The number of calibration + examples (forecast errors / non-conformity scores) to consider can be defined at model creation with + parameter `cal_length`. Note that when using `cal_stride>1`, a longer history is required since the + calibration examples are generated with stridden historical forecasts. - Generate historical forecasts on the calibration set (using the forecasting model) with a stride `cal_stride`. - Compute the errors/non-conformity scores (specific to each conformal model) on these historical forecasts - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model @@ -191,7 +191,7 @@ def fit( Notes ----- - Conformal Models do not required calling `fit()`, since they use pre-trained global forecasting models. + Conformal Models do not require calling `fit()`, since they use pre-trained global forecasting models. You can call `predict()` directly. Also, make sure that the input series used in `predict()` corresponds to a calibration set, and not the same as used during training with `fit()`. @@ -257,8 +257,8 @@ def predict( horizon `n` is as follows (note: `cal_length` and `cal_stride` can be set at model creation): - Extract a calibration set: The calibration set for each conformal forecast is automatically extracted from - the past of your input series relative to the forecast start point. The number of calibration examples - (forecast errors / non-conformity scores) to consider can be defined at model creation + the most recent past of your input series relative to the forecast start point. The number of calibration + examples (forecast errors / non-conformity scores) to consider can be defined at model creation with parameter `cal_length`. Note that when using `cal_stride>1`, a longer history is required since the calibration examples are generated with stridden historical forecasts. - Generate historical forecasts on the calibration set (using the forecasting model) with a stride `cal_stride`. @@ -274,7 +274,8 @@ def predict( Forecast horizon - the number of time steps after the end of the series for which to produce predictions. series A series or sequence of series, representing the history of the target series whose future is to be - predicted. Will use the past of this series for calibration. + predicted. Will use the past of this series for calibration. The series should not have any overlap with + the series used to train the forecasting model. past_covariates Optionally, a (sequence of) past-observed covariate time series for every input time series in `series`. Their dimension must match that of the past covariates used for training. Will use this series for @@ -457,7 +458,8 @@ def historical_forecasts( ---------- series A (sequence of) target time series used to successively compute the historical forecasts. Will use the past - of this series for calibration. + of this series for calibration. The series should not have any overlap with the series used to train the + forecasting model. past_covariates Optionally, a (sequence of) past-observed covariate time series for every input time series in `series`. Their dimension must match that of the past covariates used for training. Will use this series for @@ -670,7 +672,8 @@ def backtest( ---------- series A (sequence of) target time series used to successively compute the historical forecasts. Will use the past - of this series for calibration. + of this series for calibration. The series should not have any overlap with the series used to train the + forecasting model. past_covariates Optionally, a (sequence of) past-observed covariate time series for every input time series in `series`. Their dimension must match that of the past covariates used for training. Will use this series for @@ -893,7 +896,8 @@ def residuals( ---------- series A (sequence of) target time series used to successively compute the historical forecasts. Will use the past - of this series for calibration. + of this series for calibration. The series should not have any overlap with the series used to train the + forecasting model. past_covariates Optionally, a (sequence of) past-observed covariate time series for every input time series in `series`. Their dimension must match that of the past covariates used for training. Will use this series for @@ -1059,8 +1063,8 @@ def _calibrate_forecasts( - Generate historical forecasts for `series` with stride `cal_stride` (using the forecasting model) - Extract a calibration set: The forecasts from the most recent past to use as calibration for one conformal prediction. The number of examples to use can be defined at model creation with parameter `cal_length`. It - automatically extracts the calibration set from the past of your input series (`series`, `past_covariates`, - ...). + automatically extracts the calibration set from the most recent past of your input series (`series`, + `past_covariates`, ...). - Compute the errors/non-conformity scores (specific to each conformal model) on these historical forecasts - Compute the quantile values from the errors / non-conformity scores (using our desired quantiles set at model creation with parameter `quantiles`). @@ -1535,8 +1539,8 @@ def __init__( follows: - Extract a calibration set: The calibration set for each conformal forecast is automatically extracted from - the past of your input series relative to the forecast start point. The number of calibration examples - (forecast errors / non-conformity scores) to consider can be defined at model creation + the most recent past of your input series relative to the forecast start point. The number of calibration + examples (forecast errors / non-conformity scores) to consider can be defined at model creation with parameter `cal_length`. Note that when using `cal_stride>1`, a longer history is required since the calibration examples are generated with stridden historical forecasts. - Generate historical forecasts on the calibration set (using the forecasting model) with a stride `cal_stride`. @@ -1670,10 +1674,10 @@ def __init__( follows: - Extract a calibration set: The calibration set for each conformal forecast is automatically extracted from - the past of your input series relative to the forecast start point. The number of calibration examples - (forecast errors / non-conformity scores) to consider can be defined at model creation - with parameter `cal_length`. Note that when using `cal_stride>1`, a longer history is required since - the calibration examples are generated with stridden historical forecasts. + the most recent past of your input series relative to the forecast start point. The number of calibration + examples (forecast errors / non-conformity scores) to consider can be defined at model creation with + parameter `cal_length`. Note that when using `cal_stride>1`, a longer history is required since the + calibration examples are generated with stridden historical forecasts. - Generate historical forecasts (quantile predictions) on the calibration set (using the forecasting model) with a stride `cal_stride`. - Compute the errors/non-conformity scores (as defined above) on these historical quantile predictions From c5f9561ae6e179f37c6a98367116014e24661ec4 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 20 Dec 2024 17:49:36 +0100 Subject: [PATCH 77/78] update notebook --- .../23-Conformal-Prediction-examples.ipynb | 1381 +---------------- 1 file changed, 11 insertions(+), 1370 deletions(-) diff --git a/examples/23-Conformal-Prediction-examples.ipynb b/examples/23-Conformal-Prediction-examples.ipynb index 59ae686263..09277e879c 100644 --- a/examples/23-Conformal-Prediction-examples.ipynb +++ b/examples/23-Conformal-Prediction-examples.ipynb @@ -83,10 +83,10 @@ "#### Disadvantages\n", "\n", "- **Requires a Calibration Set**: Conformal prediction requires another data / hold-out set that is used solely to compute the calibrated prediction intervals. This can be inefficient for small datasets.\n", - "- **Exchangeability of Calibration Data (*)**: The accuracy of the prediction intervals depends on the representativeness of the calibration data (or rather the forecast errors produced on the calibration set). The coverage is not guaranteed anymore if there is a **distribution shift** in forecast errors (e.g. series with a trend but forecasting model is not able to predict the trend).\n", - "- **Conservativeness (*)**: May produce wider intervals than necessary, leading to conservative predictions.\n", + "- **Exchangeability of Calibration Data** (a): The accuracy of the prediction intervals depends on the representativeness of the calibration data (or rather the forecast errors produced on the calibration set). The coverage is not guaranteed anymore if there is a **distribution shift** in forecast errors (e.g. series with a trend but forecasting model is not able to predict the trend).\n", + "- **Conservativeness** (a): May produce wider intervals than necessary, leading to conservative predictions.\n", "\n", - "(*) Darts conformal models have some parameters to control the extraction of the calibration set for more adaptiveness (see more infos [here](#Darts'-features-to-make-your-Conformal-Models-more-adaptive))." + "(a) Darts conformal models have some parameters to control the extraction of the calibration set for more adaptiveness (see more infos [here](#Darts-features-to-make-your-Conformal-Models-more-adaptive))." ] }, { @@ -123,7 +123,7 @@ "\n", "### Workflow behind the hood\n", "\n", - "> Note: `cal_length` and `cal_stride` will be further explained [below](#Darts'-features-to-make-your-Conformal-Models-more-adaptive).\n", + "> Note: `cal_length` and `cal_stride` will be further explained [below](#Darts-features-to-make-your-Conformal-Models-more-adaptive).\n", "\n", "In general, the workflow of the models to produce one calibrated forecast/prediction is as follows (using `predict()`):\n", "\n", @@ -153,10 +153,10 @@ "\n", "- `symmetric=True`:\n", " - The lower and upper interval bounds are calibrated with the same magnitude.\n", - " - Non-conformity scores: uses the [absolute error `ae()`](https://unit8co.github.io/darts/generated_api/darts.metrics.metrics.html#darts.metrics.metrics.ae) to compute the non-conformity scores on the calibration set.\n", + " - Non-conformity scores: uses the [absolute error](https://unit8co.github.io/darts/generated_api/darts.metrics.metrics.html#darts.metrics.metrics.ae) `ae()` to compute the non-conformity scores on the calibration set.\n", "- `symmetric=False`\n", " - The lower and upper interval bounds are calibrated separately.\n", - " - Non-conformity scores: uses the [error `err()`](https://unit8co.github.io/darts/generated_api/darts.metrics.metrics.html#darts.metrics.metrics.err) to compute the\n", + " - Non-conformity scores: uses the [error](https://unit8co.github.io/darts/generated_api/darts.metrics.metrics.html#darts.metrics.metrics.err) `err()` to compute the\n", " non-conformity scores on the calibration set for the upper bounds, and `-err()` for the lower bounds.\n", "\n", "#### `ConformalQRModel` (Conformalized Quantile Regression Model)\n", @@ -165,12 +165,12 @@ "\n", "- `symmetric=True`:\n", " - The lower and upper quantile predictions are calibrated with the same magnitude.\n", - " - Non-conformity scores: uses the [Non-Conformity Score for Quantile Regression `incs_qr(symmetric=True)`](https://unit8co.github.io/darts/generated_api/darts.metrics.metrics.html#darts.metrics.metrics.incs_qr) on the calibration set.\n", + " - Non-conformity scores: uses the [Non-Conformity Score for Quantile Regression](https://unit8co.github.io/darts/generated_api/darts.metrics.metrics.html#darts.metrics.metrics.incs_qr) `incs_qr(symmetric=True)` on the calibration set.\n", "- `symmetric=False`\n", " - The lower and upper quantile predictions are calibrated separately.\n", - " - Non-conformity scores: uses the [Asymmetric Non-Conformity Score for Quantile Regression `incs_qr(symmetric=False)`](https://unit8co.github.io/darts/generated_api/darts.metrics.metrics.html#darts.metrics.metrics.incs_qr) for the upper and lower bound on the calibration set.\n", + " - Non-conformity scores: uses the [Asymmetric Non-Conformity Score for Quantile Regression](https://unit8co.github.io/darts/generated_api/darts.metrics.metrics.html#darts.metrics.metrics.incs_qr) `incs_qr(symmetric=False)` for the upper and lower bound on the calibration set.\n", "\n", - "### Darts' features to make your Conformal Models more adaptive\n", + "### Darts features to make your Conformal Models more adaptive\n", "\n", "As mentioned in [Split Conformal Prediction - Disadvantages](#Disadvantages), the calibration set has a large impact on the effectiveness of our conformal prediction technique.\n", "\n", @@ -195,7 +195,7 @@ "id": "eacf6328-6b51-43e9-8b44-214f5df15684", "metadata": {}, "source": [ - "## Examples:\n", + "## Examples\n", "\n", "We will show four examples:\n", "\n", @@ -1566,1366 +1566,7 @@ }, "widgets": { "application/vnd.jupyter.widget-state+json": { - "state": { - "02734a93194d4fbaa50d7489b79e3bf7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "031935c0e55647eb87fd638454710ebb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "032ca57dec0c498798ba4db557df0326": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "035e6c4e6bf844b2ad856f6e1331457a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "03c3336072334c52b1c8b9ed8691f91a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_7585b109b9854c4ca17275fbdd2a13fc", - "max": 1, - "style": "IPY_MODEL_1c2bf34914014874905f10aeadc62a78", - "value": 1 - } - }, - "03f79ddd66f84399aaa02edd0f89429a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_190fed71fcc34a4b98c95de252805e44", - "IPY_MODEL_d01c9a9d8f2347cbb7dba9d0d03b1199", - "IPY_MODEL_862c3c1d244f4b658d39be7d181d1aae" - ], - "layout": "IPY_MODEL_4754fdcc3f794a07a3684e87d27348d0" - } - }, - "042fb62065f74e5a88e3bf29a71069f4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_902b08529b1c4cd1bed5a71abb5b6454", - "style": "IPY_MODEL_afd3129aa14240bf83d49147e1dd2f0d", - "value": " 1/1 [00:15<00:00, 15.53s/it]" - } - }, - "050695bb79ae42f8bfb6e47a520112fe": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "0643a2e4c65b46c4967e73a5286e76cf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_653543634b0d4b1a87cb764bb06f77e4", - "IPY_MODEL_33a4abb53c5d4ef08191dd179855b045", - "IPY_MODEL_fbe84311611a48b48da1acaf4ff11405" - ], - "layout": "IPY_MODEL_bf31a40bf5fa47849abd83630ac77925" - } - }, - "06dce4ff5a09498abadb90800a4b296d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "0a180449c919489f91009fba92bf3a3f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "0ba0ad81dcb7449480aaa0eb5604b479": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "0d41c14b643b45a9884fe3d38d6144ed": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "0e34600f9d4641a0b9ff5b88d81b913c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "0fcd3c5e2b5b48edbc0c15a0b734e5ff": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "100384b4a5fe447f90b761cb9e41cb3a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "1133df19e7264dbfb4041f5cab4e4e04": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "11f1766ff8f343999a843bb49949004b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "134beb5cda3e43c09b5488830abc7440": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_96bf108b79174b1d8835fe8fff4de047", - "IPY_MODEL_a6926c440a4349258b6673a505bf172d", - "IPY_MODEL_e3dc9f72076e4f339a74fea4b62f6989" - ], - "layout": "IPY_MODEL_162d5ec4609442c3aed84b865b798c08" - } - }, - "14cb41d472cb41598d839c132ee146fd": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "162d5ec4609442c3aed84b865b798c08": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "190fed71fcc34a4b98c95de252805e44": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_4ff859b0d5004391bb2465ef667871d2", - "style": "IPY_MODEL_3fb79582133f48c6851387d8d1d08dc6", - "value": "historical forecasts: 100%" - } - }, - "194d51daa3904a59a809a25cc82ac066": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "19ce5739b023449a9b53102cd9bf4500": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "1c2bf34914014874905f10aeadc62a78": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "2126f8684e0b454991611f56606e92d5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_26fd6c94f91443efb29636cb48639a59", - "max": 1, - "style": "IPY_MODEL_8b7015dde4e542989d9533c3ad077fe1", - "value": 1 - } - }, - "24663c64d6de45349849637e057b2cf0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_c328d545f8c446c18f7dd4d0630e30bb", - "style": "IPY_MODEL_260b8e78c7b841cd87b0cddae6754f4f", - "value": " 1/1 [00:00<00:00,  2.25it/s]" - } - }, - "260b8e78c7b841cd87b0cddae6754f4f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "26fd6c94f91443efb29636cb48639a59": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "2bd9e1609a534702bc010c6528cba52d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_035e6c4e6bf844b2ad856f6e1331457a", - "max": 1, - "style": "IPY_MODEL_cb69dd95e0054084b83ce6b36129d560", - "value": 1 - } - }, - "3036b375398a4208a0cdc12d9fccba3b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "31c3969fdfc8437c942f9e1086a96743": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_c1e53a9530184df6978a812de6cea6bf", - "max": 1, - "style": "IPY_MODEL_f147d20a7eac48acb0216e0144c1880b", - "value": 1 - } - }, - "33a4abb53c5d4ef08191dd179855b045": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_bf6713873ea143ff81b51d74258b8f88", - "max": 1, - "style": "IPY_MODEL_45f2e69c1e8745e29e4eaa7a5d0c109f", - "value": 1 - } - }, - "34ee120772074375aa9363965665998e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "35d4b34b1fa34fb89547b31944163561": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "36659c4477804191936984e5c00f0e55": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_5ca5de714ea2410c94c51336520037a6", - "style": "IPY_MODEL_ab944cfc8b1b42debc1cba16059b217d", - "value": " 8761/8761 [00:00<00:00, 27925.26it/s]" - } - }, - "3a734f69319041b292823a0cc05b3e71": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "3aad5a2d827343bcb70ae32108a9f929": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "3c0c14944f804ea583571abcdcc8f179": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_14cb41d472cb41598d839c132ee146fd", - "max": 8761, - "style": "IPY_MODEL_41ecc953be7b4003a504d3d670f00eb6", - "value": 8761 - } - }, - "3c83c59e02fb42929d9ab1aa59e834a0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "3d3cd15057784fc7820c4035f2288fce": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "3dbd8c2a106645ba9e2c8568686ec2dd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_cb865043d2db45199e32c11edc51316f", - "style": "IPY_MODEL_87cfe6056cba481f93dad0c094db79d6", - "value": "historical forecasts: 100%" - } - }, - "3ed4aaf4fa10446ab0fb927944ac34da": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "3f7d4ca675e9447b81435d9693f53ee5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "3fb79582133f48c6851387d8d1d08dc6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "41ecc953be7b4003a504d3d670f00eb6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "4450f86af0634a8399b4c67f46a44a6f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_8fdba63d51944d58abacbeadfa6f6caa", - "IPY_MODEL_2bd9e1609a534702bc010c6528cba52d", - "IPY_MODEL_d9039974750e4162889ea97a4532cca9" - ], - "layout": "IPY_MODEL_bfdd66cd185b4c9da69c78d4f1daaae0" - } - }, - "4525b25c3e844b9ab79da68a6561235b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "45f2e69c1e8745e29e4eaa7a5d0c109f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "464e873e809d487ebd6393613a629fd8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "4754fdcc3f794a07a3684e87d27348d0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "482043b2b67b4502baa02117e090560e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "4aeca2f3a47648cea0208cdfbfe7ca76": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "4ff859b0d5004391bb2465ef667871d2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "520a279de08140fd89a6f80b417f65fc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_032ca57dec0c498798ba4db557df0326", - "style": "IPY_MODEL_35d4b34b1fa34fb89547b31944163561", - "value": "historical forecasts: 100%" - } - }, - "5581bbe9a69240718e7e746c28ccbb5f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_3dbd8c2a106645ba9e2c8568686ec2dd", - "IPY_MODEL_dac15bc3968342d1beb89a6f1fb519b4", - "IPY_MODEL_ad581670893d45c288ac736680eafbce" - ], - "layout": "IPY_MODEL_3d3cd15057784fc7820c4035f2288fce" - } - }, - "57929b061122419088b7ce5f489c4c5a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5ca5de714ea2410c94c51336520037a6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "5cc3b206f2584cd7b0e829d1ae7ae786": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_b8e0ce61252d409da591a510c75fdca4", - "style": "IPY_MODEL_3a734f69319041b292823a0cc05b3e71", - "value": "conformal forecasts: 100%" - } - }, - "5d813fc2b0ba4706a2d88e0f99a73c4e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "5dbc8cb42fbf4b2ba848389e610544aa": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5dd3247eccfe4d5a80a483584dc4d563": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_e013a2fbfa8a4301ad4b6b9a840e111b", - "style": "IPY_MODEL_9888722983334f638d96cb3bd1be3710", - "value": " 1/1 [00:00<00:00, 13.98it/s]" - } - }, - "616db6058650441cb3f33fdec3c078b1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_e8ff5bc2e38c4683be402fa2bae255b2", - "style": "IPY_MODEL_100384b4a5fe447f90b761cb9e41cb3a", - "value": "conformal forecasts: 100%" - } - }, - "653543634b0d4b1a87cb764bb06f77e4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_8a63ad4c472c4a22bb669436501c85e4", - "style": "IPY_MODEL_8690b88a37384a409df7022e622c47ac", - "value": "historical forecasts: 100%" - } - }, - "6642103db63e423997c6813cdb3183d9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "66c5a4b34ced44deaa32f461d4d1091e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_936c2736e3fa4b8d966a3b7244875188", - "IPY_MODEL_e0021ae748604ca4853a08431a353f8e", - "IPY_MODEL_36659c4477804191936984e5c00f0e55" - ], - "layout": "IPY_MODEL_bcb12187551d4530a394926d950a3d1d" - } - }, - "6a51687381bb4207b5c3249190917084": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "6b1cccc2e3bd441382af4022099b735e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_520a279de08140fd89a6f80b417f65fc", - "IPY_MODEL_2126f8684e0b454991611f56606e92d5", - "IPY_MODEL_24663c64d6de45349849637e057b2cf0" - ], - "layout": "IPY_MODEL_031935c0e55647eb87fd638454710ebb" - } - }, - "6d28945875f54979beac33fc825d79e9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "6d46914fa82045bf8db060e025373631": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_3f7d4ca675e9447b81435d9693f53ee5", - "style": "IPY_MODEL_6642103db63e423997c6813cdb3183d9", - "value": "historical forecasts: 100%" - } - }, - "6f1d228446304cadacfc27e9ca1be4ef": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_f40fc450a1ee4218a0d4f4dc5756a9f9", - "IPY_MODEL_31c3969fdfc8437c942f9e1086a96743", - "IPY_MODEL_5dd3247eccfe4d5a80a483584dc4d563" - ], - "layout": "IPY_MODEL_c569b1b985a04dc497dc57d070147eef" - } - }, - "7585b109b9854c4ca17275fbdd2a13fc": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "769c5712392843fdae22fdf33fb8b73e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "79816ea46c714a799519fa627754f2a2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_769c5712392843fdae22fdf33fb8b73e", - "style": "IPY_MODEL_5dbc8cb42fbf4b2ba848389e610544aa", - "value": " 1/1 [00:00<00:00,  3.03it/s]" - } - }, - "79bf64810a64492b824b7af3004bf302": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "7b59568f487044edbe7402a614b48248": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7c4672858a2840079abacc535e6376b0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7e0b9e683abc439c8951bc47f83c148d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_d831950134744e499580c235d5a3fbec", - "style": "IPY_MODEL_194d51daa3904a59a809a25cc82ac066", - "value": "conformal forecasts: 100%" - } - }, - "8082a47fb6e64764a50e0acc43a2041c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_0fcd3c5e2b5b48edbc0c15a0b734e5ff", - "style": "IPY_MODEL_7c4672858a2840079abacc535e6376b0", - "value": " 1/1 [00:00<00:00, 234.65it/s]" - } - }, - "8220be72db524c5abc7493b78bcc3e30": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "83a738780a7f4b29951f52771f7e70a1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_bdebef6fab784be082f44507c4fc1e0b", - "max": 1, - "style": "IPY_MODEL_79bf64810a64492b824b7af3004bf302", - "value": 1 - } - }, - "83af5f1740ad4771ac3fda66d5a098b9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_3036b375398a4208a0cdc12d9fccba3b", - "style": "IPY_MODEL_88490242bf394ae5ba05cb40d4bd0769", - "value": "historical forecasts: 100%" - } - }, - "862c3c1d244f4b658d39be7d181d1aae": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_4525b25c3e844b9ab79da68a6561235b", - "style": "IPY_MODEL_c42773b48f394255869b71cbce7371be", - "value": " 1/1 [00:00<00:00,  3.42it/s]" - } - }, - "8690b88a37384a409df7022e622c47ac": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "86beef51610845cea4f9b49e9247b983": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_5cc3b206f2584cd7b0e829d1ae7ae786", - "IPY_MODEL_83a738780a7f4b29951f52771f7e70a1", - "IPY_MODEL_954014f5451f4686bb255980500cdc97" - ], - "layout": "IPY_MODEL_1133df19e7264dbfb4041f5cab4e4e04" - } - }, - "87cfe6056cba481f93dad0c094db79d6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "88490242bf394ae5ba05cb40d4bd0769": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8a63ad4c472c4a22bb669436501c85e4": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "8b7015dde4e542989d9533c3ad077fe1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "8fdba63d51944d58abacbeadfa6f6caa": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_5d813fc2b0ba4706a2d88e0f99a73c4e", - "style": "IPY_MODEL_7b59568f487044edbe7402a614b48248", - "value": "conformal forecasts: 100%" - } - }, - "902b08529b1c4cd1bed5a71abb5b6454": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "936c2736e3fa4b8d966a3b7244875188": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_06dce4ff5a09498abadb90800a4b296d", - "style": "IPY_MODEL_b88844e00e044ccc8e91b5c392f69b07", - "value": "conformal forecasts: 100%" - } - }, - "954014f5451f4686bb255980500cdc97": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_464e873e809d487ebd6393613a629fd8", - "style": "IPY_MODEL_57929b061122419088b7ce5f489c4c5a", - "value": " 1/1 [00:00<00:00, 202.55it/s]" - } - }, - "95ac5cad39e545bc812d370a64e868d8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "96bf108b79174b1d8835fe8fff4de047": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_0ba0ad81dcb7449480aaa0eb5604b479", - "style": "IPY_MODEL_11f1766ff8f343999a843bb49949004b", - "value": "conformal forecasts: 100%" - } - }, - "979deef91d9e43079c5793ca74a9124e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_616db6058650441cb3f33fdec3c078b1", - "IPY_MODEL_3c0c14944f804ea583571abcdcc8f179", - "IPY_MODEL_b9cb09dbc1fd4e9db6e415298d379c5f" - ], - "layout": "IPY_MODEL_c6c975ba154f4e5eb3176b9e08b0d85d" - } - }, - "981029fee74546bd8b1b1d664789b4b4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_95ac5cad39e545bc812d370a64e868d8", - "style": "IPY_MODEL_d31a8292c5754064a4043e5f9cee9c23", - "value": " 365/365 [00:00<00:00, 1783.39it/s]" - } - }, - "9888722983334f638d96cb3bd1be3710": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "9f6a8d62e599415ba7ce6959c4123e6b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "a6926c440a4349258b6673a505bf172d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_3c83c59e02fb42929d9ab1aa59e834a0", - "max": 8761, - "style": "IPY_MODEL_c24918b5434c4bba993aa8bda8e118d7", - "value": 8761 - } - }, - "a72dfaf21046461abc24e9609dcd7032": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "a94e80e2856947ca9842ec2b7948e41a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "ab3550f073174336bcd81ffdf713ed49": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ab944cfc8b1b42debc1cba16059b217d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ad581670893d45c288ac736680eafbce": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_a94e80e2856947ca9842ec2b7948e41a", - "style": "IPY_MODEL_b0fc52a6ac5a43418c451cfd0b9c492f", - "value": " 696/696 [00:01<00:00, 657.06it/s]" - } - }, - "ae57545ceb814176900a79d215d3a3f5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "afd3129aa14240bf83d49147e1dd2f0d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b0fc52a6ac5a43418c451cfd0b9c492f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b1ef578b93df4031a4b97b123323f63f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "b5299dcd5946432b840fae9dcc43a645": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_bd7c460b490f442faf36866b88f567cc", - "IPY_MODEL_d57bf06d54d043d2b2793025d6104067", - "IPY_MODEL_981029fee74546bd8b1b1d664789b4b4" - ], - "layout": "IPY_MODEL_fb4b214d8c0d4eada9330509047b1cbd" - } - }, - "b88844e00e044ccc8e91b5c392f69b07": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b8a59a6a88a848758564bd96780ea495": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_8220be72db524c5abc7493b78bcc3e30", - "max": 1, - "style": "IPY_MODEL_3ed4aaf4fa10446ab0fb927944ac34da", - "value": 1 - } - }, - "b8e0ce61252d409da591a510c75fdca4": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "b9cb09dbc1fd4e9db6e415298d379c5f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_34ee120772074375aa9363965665998e", - "style": "IPY_MODEL_3aad5a2d827343bcb70ae32108a9f929", - "value": " 8761/8761 [00:00<00:00, 15922.19it/s]" - } - }, - "bbb54ccaca20416aa1d61682cbbd7f75": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "bcb12187551d4530a394926d950a3d1d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "bd7c460b490f442faf36866b88f567cc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_f0c7032036a843f8be42e9330322e4a5", - "style": "IPY_MODEL_0a180449c919489f91009fba92bf3a3f", - "value": "conformal forecasts: 100%" - } - }, - "bdebef6fab784be082f44507c4fc1e0b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "bf31a40bf5fa47849abd83630ac77925": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "bf6713873ea143ff81b51d74258b8f88": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "bfdd66cd185b4c9da69c78d4f1daaae0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "c1e53a9530184df6978a812de6cea6bf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "c24918b5434c4bba993aa8bda8e118d7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "c328d545f8c446c18f7dd4d0630e30bb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "c42773b48f394255869b71cbce7371be": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "c569b1b985a04dc497dc57d070147eef": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "c6c975ba154f4e5eb3176b9e08b0d85d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "c803eade6b564d4eaa2ba7346ad07e14": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "cb69dd95e0054084b83ce6b36129d560": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "cb865043d2db45199e32c11edc51316f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "cb8bce0e65de43988dfd982ecb85cdca": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "cd0fc6bec3ff46c0b52919d60e4d267d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ce79a001eb0645c4ad584084fa66a4e2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_f687ca0b1d284cbbbb966ad371086c61", - "max": 1, - "style": "IPY_MODEL_e19ad4ded4424e0caafd267946273637", - "value": 1 - } - }, - "d01c9a9d8f2347cbb7dba9d0d03b1199": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_4aeca2f3a47648cea0208cdfbfe7ca76", - "max": 1, - "style": "IPY_MODEL_ae57545ceb814176900a79d215d3a3f5", - "value": 1 - } - }, - "d31a8292c5754064a4043e5f9cee9c23": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "d57bf06d54d043d2b2793025d6104067": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_050695bb79ae42f8bfb6e47a520112fe", - "max": 365, - "style": "IPY_MODEL_b1ef578b93df4031a4b97b123323f63f", - "value": 365 - } - }, - "d831950134744e499580c235d5a3fbec": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "d89437eb2ec14fa997bdc230faa8e1e5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_6d46914fa82045bf8db060e025373631", - "IPY_MODEL_ce79a001eb0645c4ad584084fa66a4e2", - "IPY_MODEL_79816ea46c714a799519fa627754f2a2" - ], - "layout": "IPY_MODEL_bbb54ccaca20416aa1d61682cbbd7f75" - } - }, - "d8b9235cd73e4b7eabb5906cea008567": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_7e0b9e683abc439c8951bc47f83c148d", - "IPY_MODEL_03c3336072334c52b1c8b9ed8691f91a", - "IPY_MODEL_8082a47fb6e64764a50e0acc43a2041c" - ], - "layout": "IPY_MODEL_0e34600f9d4641a0b9ff5b88d81b913c" - } - }, - "d9039974750e4162889ea97a4532cca9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_0d41c14b643b45a9884fe3d38d6144ed", - "style": "IPY_MODEL_ab3550f073174336bcd81ffdf713ed49", - "value": " 1/1 [00:00<00:00, 181.72it/s]" - } - }, - "dac15bc3968342d1beb89a6f1fb519b4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_6d28945875f54979beac33fc825d79e9", - "max": 696, - "style": "IPY_MODEL_a72dfaf21046461abc24e9609dcd7032", - "value": 696 - } - }, - "e0021ae748604ca4853a08431a353f8e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_02734a93194d4fbaa50d7489b79e3bf7", - "max": 8761, - "style": "IPY_MODEL_c803eade6b564d4eaa2ba7346ad07e14", - "value": 8761 - } - }, - "e013a2fbfa8a4301ad4b6b9a840e111b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "e19ad4ded4424e0caafd267946273637": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "e3dc9f72076e4f339a74fea4b62f6989": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_9f6a8d62e599415ba7ce6959c4123e6b", - "style": "IPY_MODEL_cb8bce0e65de43988dfd982ecb85cdca", - "value": " 8761/8761 [00:00<00:00, 34584.39it/s]" - } - }, - "e82011a926c44c29ad85d070ce0996a1": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "e8ff5bc2e38c4683be402fa2bae255b2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "ec085a67dc854b55a80d5ab3f9256734": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_83af5f1740ad4771ac3fda66d5a098b9", - "IPY_MODEL_b8a59a6a88a848758564bd96780ea495", - "IPY_MODEL_042fb62065f74e5a88e3bf29a71069f4" - ], - "layout": "IPY_MODEL_e82011a926c44c29ad85d070ce0996a1" - } - }, - "f0c7032036a843f8be42e9330322e4a5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "f147d20a7eac48acb0216e0144c1880b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "f40fc450a1ee4218a0d4f4dc5756a9f9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_482043b2b67b4502baa02117e090560e", - "style": "IPY_MODEL_19ce5739b023449a9b53102cd9bf4500", - "value": "historical forecasts: 100%" - } - }, - "f687ca0b1d284cbbbb966ad371086c61": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "fb4b214d8c0d4eada9330509047b1cbd": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "fbe84311611a48b48da1acaf4ff11405": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_6a51687381bb4207b5c3249190917084", - "style": "IPY_MODEL_cd0fc6bec3ff46c0b52919d60e4d267d", - "value": " 1/1 [00:00<00:00, 95.67it/s]" - } - } - }, + "state": {}, "version_major": 2, "version_minor": 0 } From 0b2c1cf165165bb822ac7e2cabc0af7535e90238 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 20 Dec 2024 19:04:26 +0100 Subject: [PATCH 78/78] update changelog --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 90e68ed022..92d7fb06e2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,7 +13,7 @@ but cannot always guarantee backwards compatibility. Changes that may **break co - 🚀🚀 Introducing Conformal Prediction to Darts: Add calibrated prediction intervals to any pre-trained global forecasting model with our first two conformal prediction models : [#2552](https://github.com/unit8co/darts/pull/2552) by [Dennis Bader](https://github.com/dennisbader). - `ConformalNaiveModel`: It uses past point forecast errors to produce calibrated forecast intervals with a specified coverage probability. - - `ConformalQRModel`: It combines quantile regression (or any probabilistic model) with conformal prediction techniques. It adjusts quantile estimates (using non-conformity scores `metrics.incs_qr()`) to generate calibrated prediction intervals with a specified coverage probability. + - `ConformalQRModel`: It combines quantile regression (or any probabilistic model) with conformal prediction techniques. It adjusts quantile estimates to generate calibrated prediction intervals with a specified coverage probability. - Both models offer the following support: - use any pre-trained global forecasting model as the base forecaster - uni and multivariate forecasts