From d381d5ee7e9d38bbea58a911d6cbd9c1303e6505 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 24 May 2025 14:43:02 +0100 Subject: [PATCH 01/76] arima first --- aeon/forecasting/_arima.py | 456 +++++++++++++++++++++++++++++++++++++ 1 file changed, 456 insertions(+) create mode 100644 aeon/forecasting/_arima.py diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py new file mode 100644 index 0000000000..54ebc47fe3 --- /dev/null +++ b/aeon/forecasting/_arima.py @@ -0,0 +1,456 @@ +"""ARIMAForecaster. + +An implementation of the ARIMA forecasting algorithm. +""" + +__maintainer__ = ["alexbanwell1", "TonyBagnall"] +__all__ = ["ARIMAForecaster"] + +from math import comb + +import numpy as np + +from aeon.forecasting._utils import calc_seasonal_period, kpss_test +from aeon.forecasting.base import BaseForecaster + +NOGIL = False +CACHE = True + + +class ARIMAForecaster(BaseForecaster): + """AutoRegressive Integrated Moving Average (ARIMA) forecaster. + + Implements the Hyndman-Khandakar automatic ARIMA algorithm for time series + forecasting with optional seasonal components. The model automatically selects + the orders of the non-seasonal (p, d, q) and seasonal (P, D, Q, m) components + based on information criteria, such as AIC. + + Parameters + ---------- + horizon : int, default=1 + The forecasting horizon, i.e., the number of steps ahead to predict. + + Attributes + ---------- + data_ : list of float + Original training series values. + differenced_data_ : list of float + Differenced version of the training data used for stationarity. + residuals_ : list of float + Residual errors from the fitted model. + aic_ : float + Akaike Information Criterion for the selected model. + p_, d_, q_ : int + Orders of the ARIMA model: autoregressive (p), differencing (d), + and moving average (q) terms. + ps_, ds_, qs_ : int + Orders of the seasonal ARIMA model: seasonal AR (P), seasonal differencing (D), + and seasonal MA (Q) terms. + seasonal_period_ : int + Length of the seasonal cycle. + constant_term_ : float + Constant/intercept term in the model. + c_ : float + Estimated constant term (internal use). + phi_ : array-like + Coefficients for the non-seasonal autoregressive terms. + phi_s_ : array-like + Coefficients for the seasonal autoregressive terms. + theta_ : array-like + Coefficients for the non-seasonal moving average terms. + theta_s_ : array-like + Coefficients for the seasonal moving average terms. + + References + ---------- + .. [1] R. J. Hyndman and G. Athanasopoulos, + Forecasting: Principles and Practice. OTexts, 2014. + https://otexts.com/fpp3/ + """ + + def __init__(self, horizon=1): + super().__init__(horizon=horizon, axis=1) + self.data_ = [] + self.differenced_data_ = [] + self.residuals_ = [] + self.aic_ = 0 + self.p_ = 0 + self.d_ = 0 + self.q_ = 0 + self.ps_ = 0 + self.ds_ = 0 + self.qs_ = 0 + self.seasonal_period_ = 0 + self.constant_term_ = 0 + self.c_ = 0 + self.phi_ = 0 + self.phi_s_ = 0 + self.theta_ = 0 + self.theta_s_ = 0 + + def _fit(self, y, exog=None): + """Fit AutoARIMA forecaster to series y. + + Fit a forecaster to predict self.horizon steps ahead using y. + + Parameters + ---------- + y : np.ndarray + A time series on which to learn a forecaster to predict horizon ahead + exog : np.ndarray, default =None + Optional exogenous time series data assumed to be aligned with y + + Returns + ------- + self + Fitted ARIMAForecaster. + """ + self.data_ = np.array(y.squeeze(), dtype=np.float64) + ( + self.differenced_data_, + self.aic_, + self.p_, + self.d_, + self.q_, + self.ps_, + self.ds_, + self.qs_, + self.seasonal_period_, + self.constant_term_, + parameters, + ) = auto_arima(self.data_) + (self.c_, self.phi_, self.phi_s_, self.theta_, self.theta_s_) = extract_params( + parameters, self.p_, self.q_, self.ps_, self.qs_, self.constant_term_ + ) + ( + self.aic_, + self.residuals_, + ) = arima_log_likelihood( + parameters, + self.differenced_data_, + self.p_, + self.q_, + self.ps_, + self.qs_, + self.seasonal_period_, + self.constant_term_, + ) + return self + + def _predict(self, y=None, exog=None): + """ + Predict the next horizon steps ahead. + + Parameters + ---------- + y : np.ndarray, default = None + A time series to predict the next horizon value for. If None, + predict the next horizon value after series seen in fit. + exog : np.ndarray, default =None + Optional exogenous time series data assumed to be aligned with y + + Returns + ------- + float + single prediction self.horizon steps ahead of y. + """ + y = np.array(y, dtype=np.float64) + value = calc_arima( + self.differenced_data_, + self.p_, + self.q_, + self.ps_, + self.qs_, + self.seasonal_period_, + len(self.differenced_data_), + self.c_, + self.phi_, + self.phi_s_, + self.theta_, + self.theta_s_, + self.residuals_, + ) + history = self.data_[::-1] + differenced_history = np.diff(self.data_, n=self.d_)[::-1] + # Step 1: undo seasonal differencing on y^(d) + for k in range(1, self.ds_ + 1): + lag = k * self.seasonal_period_ + value += (-1) ** (k + 1) * comb(self.ds_, k) * differenced_history[lag - 1] + + # Step 2: undo ordinary differencing + for k in range(1, self.d_ + 1): + value += (-1) ** (k + 1) * comb(self.d_, k) * history[k - 1] + + if y is None: + return np.array([value]) + else: + return np.insert(y, 0, value)[:-1] + + +# Define the ARIMA(p, d, q) likelihood function +def arima_log_likelihood( + params, data, p, q, ps, qs, seasonal_period, include_constant_term +): + """Calculate the log-likelihood of an ARIMA model given the parameters.""" + c, phi, phi_s, theta, theta_s = extract_params( + params, p, q, ps, qs, include_constant_term + ) # Extract parameters + + # Initialize residuals + n = len(data) + residuals = np.zeros(n) + for t in range(n): + y_hat = calc_arima( + data, + p, + q, + ps, + qs, + seasonal_period, + t, + c, + phi, + phi_s, + theta, + theta_s, + residuals, + ) + residuals[t] = data[t] - y_hat + # Calculate the log-likelihood + variance = np.mean(residuals**2) + liklihood = n * (np.log(2 * np.pi) + np.log(variance) + 1) + k = len(params) + aic = liklihood + 2 * k + return ( + aic, + residuals, + ) # Return negative log-likelihood for minimization + + +def extract_params(params, p, q, ps, qs, include_constant_term): + """Extract ARIMA parameters from the parameter vector.""" + # Extract parameters + c = params[0] if include_constant_term else 0 # Constant term + # AR coefficients + phi = params[include_constant_term : p + include_constant_term] + # Seasonal AR coefficients + phi_s = params[include_constant_term + p : p + ps + include_constant_term] + # MA coefficients + theta = params[include_constant_term + p + ps : p + ps + q + include_constant_term] + # Seasonal MA coefficents + theta_s = params[ + include_constant_term + p + ps + q : include_constant_term + p + ps + q + qs + ] + return c, phi, phi_s, theta, theta_s + + +def calc_arima( + data, p, q, ps, qs, seasonal_period, t, c, phi, phi_s, theta, theta_s, residuals +): + """Calculate the ARIMA forecast for time t.""" + # AR part + ar_term = 0 if (t - p) < 0 else np.dot(phi, data[t - p : t][::-1]) + # Seasonal AR part + ars_term = ( + 0 + if (t - seasonal_period * ps) < 0 + else np.dot(phi_s, data[t - seasonal_period * ps : t : seasonal_period][::-1]) + ) + # MA part + ma_term = 0 if (t - q) < 0 else np.dot(theta, residuals[t - q : t][::-1]) + # Seasonal MA part + mas_term = ( + 0 + if (t - seasonal_period * qs) < 0 + else np.dot( + theta_s, residuals[t - seasonal_period * qs : t : seasonal_period][::-1] + ) + ) + y_hat = c + ar_term + ma_term + ars_term + mas_term + return y_hat + + +def nelder_mead( + data, + p, + q, + ps, + qs, + seasonal_period, + include_constant_term, + tol=1e-6, + max_iter=500, +): + """Implement the nelder-mead optimisation algorithm.""" + num_params = include_constant_term + p + ps + q + qs + points = np.full((num_params + 1, num_params), 0.5) + for i in range(num_params): + points[i + 1][i] = 0.6 + values = np.array( + [ + arima_log_likelihood( + v, data, p, q, ps, qs, seasonal_period, include_constant_term + )[0] + for v in points + ] + ) + for _iteration in range(max_iter): + # Order simplex by function values + order = np.argsort(values) + points = points[order] + values = values[order] + + # Centroid of the best n points + centre_point = points[:-1].sum(axis=0) / len(points[:-1]) + + # Reflection + # centre + distance between centre and largest value + reflected_point = centre_point + (centre_point - points[-1]) + reflected_value = arima_log_likelihood( + reflected_point, + data, + p, + q, + ps, + qs, + seasonal_period, + include_constant_term, + )[0] + # if between best and second best, use reflected value + if len(values) > 1 and values[0] <= reflected_value < values[-2]: + points[-1] = reflected_point + values[-1] = reflected_value + continue + # Expansion + # Otherwise if it is better than the best value + if reflected_value < values[0]: + expanded_point = centre_point + 2 * (reflected_point - centre_point) + expanded_value = arima_log_likelihood( + expanded_point, + data, + p, + q, + ps, + qs, + seasonal_period, + include_constant_term, + )[0] + # if less than reflected value use expanded, otherwise go back to reflected + if expanded_value < reflected_value: + points[-1] = expanded_point + values[-1] = expanded_value + else: + points[-1] = reflected_point + values[-1] = reflected_value + continue + # Contraction + # Otherwise if reflection is worse than all current values + contracted_point = centre_point - 0.5 * (centre_point - points[-1]) + contracted_value = arima_log_likelihood( + contracted_point, + data, + p, + q, + ps, + qs, + seasonal_period, + include_constant_term, + )[0] + # If contraction is better use that otherwise move to shrinkage + if contracted_value < values[-1]: + points[-1] = contracted_point + values[-1] = contracted_value + continue + + # Shrinkage + for i in range(1, len(points)): + points[i] = points[0] - 0.5 * (points[0] - points[i]) + values[i] = arima_log_likelihood( + points[i], + data, + p, + q, + ps, + qs, + seasonal_period, + include_constant_term, + )[0] + + # Convergence check + if np.max(np.abs(values - values[0])) < tol: + break + return points[0], values[0] + + +# def calc_moving_variance(data, window): +# X = np.lib.stride_tricks.sliding_window_view(data, window_shape=window) +# return X.var() + + +def auto_arima(data): + """ + Implement the Hyndman-Khandakar algorithm. + + For automatic ARIMA model selection. + """ + seasonal_period = calc_seasonal_period(data) + difference = 0 + while not kpss_test(data)[1]: + data = np.diff(data, n=1) + difference += 1 + seasonal_difference = 1 if seasonal_period > 1 else 0 + if seasonal_difference: + data = data[seasonal_period:] - data[:-seasonal_period] + include_c = 1 if difference == 0 else 0 + model_parameters = [ + [2, 2, 0, 0, include_c], + [0, 0, 0, 0, include_c], + [1, 0, 0, 0, include_c], + [0, 1, 0, 0, include_c], + ] + model_points = [] + for p in model_parameters: + points, aic = nelder_mead(data, p[0], p[1], p[2], p[3], seasonal_period, p[4]) + p.append(aic) + model_points.append(points) + current_model = min(model_parameters, key=lambda item: item[5]) + current_points = model_points[model_parameters.index(current_model)] + while True: + better_model = False + for param_no in range(4): + for adjustment in [-1, 1]: + if (current_model[param_no] + adjustment) < 0: + continue + model = current_model.copy() + model[param_no] += adjustment + for constant_term in [0, 1]: + points, aic = nelder_mead( + data, + model[0], + model[1], + model[2], + model[3], + seasonal_period, + constant_term, + ) + if aic < current_model[5]: + current_model = model + current_points = points + current_model[5] = aic + current_model[4] = constant_term + better_model = True + if not better_model: + break + return ( + data, + current_model[5], + current_model[0], + difference, + current_model[1], + current_model[2], + seasonal_difference, + current_model[3], + seasonal_period, + current_model[4], + current_points, + ) From 3a0552b469de39ff3f0dada1696c20081a17aa27 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 24 May 2025 17:29:04 +0100 Subject: [PATCH 02/76] move utils --- aeon/forecasting/_arima.py | 49 ++++++++++++++++++++- aeon/utils/forecasting/__init__.py | 1 + aeon/utils/forecasting/_hypo_tests.py | 63 +++++++++++++++++++++++++++ 3 files changed, 111 insertions(+), 2 deletions(-) create mode 100644 aeon/utils/forecasting/__init__.py create mode 100644 aeon/utils/forecasting/_hypo_tests.py diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 54ebc47fe3..76f4859557 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -9,9 +9,10 @@ from math import comb import numpy as np +from numba import njit -from aeon.forecasting._utils import calc_seasonal_period, kpss_test from aeon.forecasting.base import BaseForecaster +from aeon.utils.forecasting._hypo_tests import kpss_test NOGIL = False CACHE = True @@ -393,7 +394,7 @@ def auto_arima(data): For automatic ARIMA model selection. """ - seasonal_period = calc_seasonal_period(data) + seasonal_period = _calc_seasonal_period(data) difference = 0 while not kpss_test(data)[1]: data = np.diff(data, n=1) @@ -454,3 +455,47 @@ def auto_arima(data): current_model[4], current_points, ) + + +@njit(cache=True, fastmath=True) +def _acf(X, max_lag): + length = len(X) + X_t = np.zeros(max_lag, dtype=float) + for lag in range(1, max_lag + 1): + lag_length = length - lag + x1 = X[:-lag] + x2 = X[lag:] + s1 = np.sum(x1) + s2 = np.sum(x2) + m1 = s1 / lag_length + m2 = s2 / lag_length + ss1 = np.sum(x1 * x1) + ss2 = np.sum(x2 * x2) + v1 = ss1 - s1 * m1 + v2 = ss2 - s2 * m2 + v1_is_zero, v2_is_zero = v1 <= 1e-9, v2 <= 1e-9 + if v1_is_zero and v2_is_zero: # Both zero variance, + # so must be 100% correlated + X_t[lag - 1] = 1 + elif v1_is_zero or v2_is_zero: # One zero variance + # the other not + X_t[lag - 1] = 0 + else: + X_t[lag - 1] = np.sum((x1 - m1) * (x2 - m2)) / np.sqrt(v1 * v2) + return X_t + + +@njit(cache=True, fastmath=True) +def _calc_seasonal_period(data): + """Estimate the seasonal period based on the autocorrelation of the series.""" + lags = _acf(data, 24) + lags = np.concatenate((np.array([1.0]), lags)) + peaks = [] + mean_lags = np.mean(lags) + for i in range(1, len(lags) - 1): # Skip the first (lag 0) and last elements + if lags[i] >= lags[i - 1] and lags[i] >= lags[i + 1] and lags[i] > mean_lags: + peaks.append(i) + if not peaks: + return 1 + else: + return peaks[0] diff --git a/aeon/utils/forecasting/__init__.py b/aeon/utils/forecasting/__init__.py new file mode 100644 index 0000000000..a168fa0f11 --- /dev/null +++ b/aeon/utils/forecasting/__init__.py @@ -0,0 +1 @@ +"""Forecasting utils.""" diff --git a/aeon/utils/forecasting/_hypo_tests.py b/aeon/utils/forecasting/_hypo_tests.py new file mode 100644 index 0000000000..73d4521e5e --- /dev/null +++ b/aeon/utils/forecasting/_hypo_tests.py @@ -0,0 +1,63 @@ +import numpy as np + + +def kpss_test(y, regression="c", lags=None): # Test if time series is stationary + """ + Implement the KPSS test for stationarity. + + Parameters + ---------- + y (array-like): Time series data + regression (str): 'c' for constant, 'ct' for constant + trend + lags (int): Number of lags for HAC variance estimation (default: sqrt(n)) + + Returns + ------- + kpss_stat (float): KPSS test statistic + stationary (bool): Whether the series is stationary according to the test + """ + y = np.asarray(y) + n = len(y) + + # Step 1: Fit regression model to estimate residuals + if regression == "c": # Constant + X = np.ones((n, 1)) + elif regression == "ct": # Constant + Trend + X = np.column_stack((np.ones(n), np.arange(1, n + 1))) + else: + raise ValueError("regression must be 'c' or 'ct'") + + beta = np.linalg.lstsq(X, y, rcond=None)[0] # Estimate regression coefficients + residuals = y - X @ beta # Get residuals (u_t) + + # Step 2: Compute cumulative sum of residuals (S_t) + S_t = np.cumsum(residuals) + + # Step 3: Estimate long-run variance (HAC variance) + if lags is None: + # lags = int(12 * (n / 100)**(1/4)) # Default statsmodels lag length + lags = int(np.sqrt(n)) # Default lag length + + gamma_0 = np.sum(residuals**2) / (n - X.shape[1]) # Lag-0 autocovariance + gamma = [np.sum(residuals[k:] * residuals[:-k]) / n for k in range(1, lags + 1)] + + # Bartlett weights + weights = [1 - (k / (lags + 1)) for k in range(1, lags + 1)] + + # Long-run variance + sigma_squared = gamma_0 + 2 * np.sum([w * g for w, g in zip(weights, gamma)]) + + # Step 4: Calculate the KPSS statistic + kpss_stat = np.sum(S_t**2) / (n**2 * sigma_squared) + + if regression == "ct": + # p. 162 Kwiatkowski et al. (1992): y_t = beta * t + r_t + e_t, + # where beta is the trend, r_t a random walk and e_t a stationary + # error term. + crit = 0.146 + else: # hypo == "c" + # special case of the model above, where beta = 0 (so the null + # hypothesis is that the data is stationary around r_0). + crit = 0.463 + + return kpss_stat, kpss_stat < crit From 0ac5380b4e6a14be8df57c103ca6eabe2a3b7cd1 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 24 May 2025 17:38:05 +0100 Subject: [PATCH 03/76] make functions private --- aeon/forecasting/_arima.py | 47 +++++++++++++++----------------------- 1 file changed, 19 insertions(+), 28 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 76f4859557..337444f827 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -119,14 +119,14 @@ def _fit(self, y, exog=None): self.seasonal_period_, self.constant_term_, parameters, - ) = auto_arima(self.data_) - (self.c_, self.phi_, self.phi_s_, self.theta_, self.theta_s_) = extract_params( + ) = _auto_arima(self.data_) + (self.c_, self.phi_, self.phi_s_, self.theta_, self.theta_s_) = _extract_params( parameters, self.p_, self.q_, self.ps_, self.qs_, self.constant_term_ ) ( self.aic_, self.residuals_, - ) = arima_log_likelihood( + ) = _arima_log_likelihood( parameters, self.differenced_data_, self.p_, @@ -156,7 +156,7 @@ def _predict(self, y=None, exog=None): single prediction self.horizon steps ahead of y. """ y = np.array(y, dtype=np.float64) - value = calc_arima( + value = _calc_arima( self.differenced_data_, self.p_, self.q_, @@ -181,19 +181,15 @@ def _predict(self, y=None, exog=None): # Step 2: undo ordinary differencing for k in range(1, self.d_ + 1): value += (-1) ** (k + 1) * comb(self.d_, k) * history[k - 1] - - if y is None: - return np.array([value]) - else: - return np.insert(y, 0, value)[:-1] + return value # Define the ARIMA(p, d, q) likelihood function -def arima_log_likelihood( +def _arima_log_likelihood( params, data, p, q, ps, qs, seasonal_period, include_constant_term ): """Calculate the log-likelihood of an ARIMA model given the parameters.""" - c, phi, phi_s, theta, theta_s = extract_params( + c, phi, phi_s, theta, theta_s = _extract_params( params, p, q, ps, qs, include_constant_term ) # Extract parameters @@ -201,7 +197,7 @@ def arima_log_likelihood( n = len(data) residuals = np.zeros(n) for t in range(n): - y_hat = calc_arima( + y_hat = _calc_arima( data, p, q, @@ -228,7 +224,7 @@ def arima_log_likelihood( ) # Return negative log-likelihood for minimization -def extract_params(params, p, q, ps, qs, include_constant_term): +def _extract_params(params, p, q, ps, qs, include_constant_term): """Extract ARIMA parameters from the parameter vector.""" # Extract parameters c = params[0] if include_constant_term else 0 # Constant term @@ -245,7 +241,7 @@ def extract_params(params, p, q, ps, qs, include_constant_term): return c, phi, phi_s, theta, theta_s -def calc_arima( +def _calc_arima( data, p, q, ps, qs, seasonal_period, t, c, phi, phi_s, theta, theta_s, residuals ): """Calculate the ARIMA forecast for time t.""" @@ -271,7 +267,7 @@ def calc_arima( return y_hat -def nelder_mead( +def _nelder_mead( data, p, q, @@ -289,7 +285,7 @@ def nelder_mead( points[i + 1][i] = 0.6 values = np.array( [ - arima_log_likelihood( + _arima_log_likelihood( v, data, p, q, ps, qs, seasonal_period, include_constant_term )[0] for v in points @@ -307,7 +303,7 @@ def nelder_mead( # Reflection # centre + distance between centre and largest value reflected_point = centre_point + (centre_point - points[-1]) - reflected_value = arima_log_likelihood( + reflected_value = _arima_log_likelihood( reflected_point, data, p, @@ -326,7 +322,7 @@ def nelder_mead( # Otherwise if it is better than the best value if reflected_value < values[0]: expanded_point = centre_point + 2 * (reflected_point - centre_point) - expanded_value = arima_log_likelihood( + expanded_value = _arima_log_likelihood( expanded_point, data, p, @@ -347,7 +343,7 @@ def nelder_mead( # Contraction # Otherwise if reflection is worse than all current values contracted_point = centre_point - 0.5 * (centre_point - points[-1]) - contracted_value = arima_log_likelihood( + contracted_value = _arima_log_likelihood( contracted_point, data, p, @@ -366,7 +362,7 @@ def nelder_mead( # Shrinkage for i in range(1, len(points)): points[i] = points[0] - 0.5 * (points[0] - points[i]) - values[i] = arima_log_likelihood( + values[i] = _arima_log_likelihood( points[i], data, p, @@ -383,12 +379,7 @@ def nelder_mead( return points[0], values[0] -# def calc_moving_variance(data, window): -# X = np.lib.stride_tricks.sliding_window_view(data, window_shape=window) -# return X.var() - - -def auto_arima(data): +def _auto_arima(data): """ Implement the Hyndman-Khandakar algorithm. @@ -411,7 +402,7 @@ def auto_arima(data): ] model_points = [] for p in model_parameters: - points, aic = nelder_mead(data, p[0], p[1], p[2], p[3], seasonal_period, p[4]) + points, aic = _nelder_mead(data, p[0], p[1], p[2], p[3], seasonal_period, p[4]) p.append(aic) model_points.append(points) current_model = min(model_parameters, key=lambda item: item[5]) @@ -425,7 +416,7 @@ def auto_arima(data): model = current_model.copy() model[param_no] += adjustment for constant_term in [0, 1]: - points, aic = nelder_mead( + points, aic = _nelder_mead( data, model[0], model[1], From 44b36a7b2d34c6b3452fdef97446a4ee83fe5789 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 28 May 2025 13:49:51 +0100 Subject: [PATCH 04/76] Modularise SARIMA model --- aeon/forecasting/_arima.py | 363 +++++++----------------- aeon/utils/forecasting/_seasonality.py | 101 +++++++ aeon/utils/optimisation/__init__.py | 1 + aeon/utils/optimisation/_nelder_mead.py | 106 +++++++ 4 files changed, 313 insertions(+), 258 deletions(-) create mode 100644 aeon/utils/forecasting/_seasonality.py create mode 100644 aeon/utils/optimisation/__init__.py create mode 100644 aeon/utils/optimisation/_nelder_mead.py diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 337444f827..00d35ec55c 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -9,10 +9,11 @@ from math import comb import numpy as np -from numba import njit from aeon.forecasting.base import BaseForecaster from aeon.utils.forecasting._hypo_tests import kpss_test +from aeon.utils.forecasting._seasonality import calc_seasonal_period +from aeon.utils.optimisation._nelder_mead import nelder_mead NOGIL = False CACHE = True @@ -83,11 +84,13 @@ def __init__(self, horizon=1): self.qs_ = 0 self.seasonal_period_ = 0 self.constant_term_ = 0 + self.model_ = [] self.c_ = 0 self.phi_ = 0 self.phi_s_ = 0 self.theta_ = 0 self.theta_s_ = 0 + self.parameters_ = [] def _fit(self, y, exog=None): """Fit AutoARIMA forecaster to series y. @@ -109,32 +112,28 @@ def _fit(self, y, exog=None): self.data_ = np.array(y.squeeze(), dtype=np.float64) ( self.differenced_data_, + self.d_, + self.ds_, + self.model_, + self.parameters_, self.aic_, + ) = _auto_arima(self.data_) + ( + self.constant_term_, self.p_, - self.d_, self.q_, self.ps_, - self.ds_, self.qs_, self.seasonal_period_, - self.constant_term_, - parameters, - ) = _auto_arima(self.data_) + ) = self.model_ (self.c_, self.phi_, self.phi_s_, self.theta_, self.theta_s_) = _extract_params( - parameters, self.p_, self.q_, self.ps_, self.qs_, self.constant_term_ + self.parameters_, self.model_ ) ( self.aic_, self.residuals_, - ) = _arima_log_likelihood( - parameters, - self.differenced_data_, - self.p_, - self.q_, - self.ps_, - self.qs_, - self.seasonal_period_, - self.constant_term_, + ) = _arima_model( + self.parameters_, _calc_sarima, self.differenced_data_, self.model_ ) return self @@ -156,19 +155,11 @@ def _predict(self, y=None, exog=None): single prediction self.horizon steps ahead of y. """ y = np.array(y, dtype=np.float64) - value = _calc_arima( + value = _calc_sarima( self.differenced_data_, - self.p_, - self.q_, - self.ps_, - self.qs_, - self.seasonal_period_, + self.model_, len(self.differenced_data_), - self.c_, - self.phi_, - self.phi_s_, - self.theta_, - self.theta_s_, + _extract_params(self.parameters_, self.model_), self.residuals_, ) history = self.data_[::-1] @@ -184,78 +175,86 @@ def _predict(self, y=None, exog=None): return value +def _aic(residuals, num_params): + """Calculate the log-likelihood of a model.""" + variance = np.mean(residuals**2) + liklihood = len(residuals) * (np.log(2 * np.pi) + np.log(variance) + 1) + return liklihood + 2 * num_params + + # Define the ARIMA(p, d, q) likelihood function -def _arima_log_likelihood( - params, data, p, q, ps, qs, seasonal_period, include_constant_term -): +def _arima_model(params, base_function, data, model): """Calculate the log-likelihood of an ARIMA model given the parameters.""" - c, phi, phi_s, theta, theta_s = _extract_params( - params, p, q, ps, qs, include_constant_term - ) # Extract parameters + formatted_params = _extract_params(params, model) # Extract parameters # Initialize residuals n = len(data) residuals = np.zeros(n) for t in range(n): - y_hat = _calc_arima( + y_hat = base_function( data, - p, - q, - ps, - qs, - seasonal_period, + model, t, - c, - phi, - phi_s, - theta, - theta_s, + formatted_params, residuals, ) residuals[t] = data[t] - y_hat - # Calculate the log-likelihood - variance = np.mean(residuals**2) - liklihood = n * (np.log(2 * np.pi) + np.log(variance) + 1) - k = len(params) - aic = liklihood + 2 * k - return ( - aic, - residuals, - ) # Return negative log-likelihood for minimization + return _aic(residuals, len(params)), residuals -def _extract_params(params, p, q, ps, qs, include_constant_term): - """Extract ARIMA parameters from the parameter vector.""" - # Extract parameters - c = params[0] if include_constant_term else 0 # Constant term - # AR coefficients - phi = params[include_constant_term : p + include_constant_term] - # Seasonal AR coefficients - phi_s = params[include_constant_term + p : p + ps + include_constant_term] - # MA coefficients - theta = params[include_constant_term + p + ps : p + ps + q + include_constant_term] - # Seasonal MA coefficents - theta_s = params[ - include_constant_term + p + ps + q : include_constant_term + p + ps + q + qs - ] - return c, phi, phi_s, theta, theta_s +# Define the SARIMA(p, d, q)(P, D, Q) likelihood function -def _calc_arima( - data, p, q, ps, qs, seasonal_period, t, c, phi, phi_s, theta, theta_s, residuals -): +def _extract_params(params, model): + """Extract ARIMA parameters from the parameter vector.""" + if len(params) != np.sum(model): + previous_length = np.sum(model) + model = model[:-1] # Remove the seasonal period + if len(params) != np.sum(model): + raise ValueError( + f"Expected {previous_length} parameters for a non-seasonal model or \ + {np.sum(model)} parameters for a seasonal model, got {len(params)}" + ) + starts = np.cumsum([0] + model[:-1]) + return [params[s : s + l].tolist() for s, l in zip(starts, model)] + + +def _calc_arima(data, model, t, formatted_params, residuals): """Calculate the ARIMA forecast for time t.""" + if len(model) != 3: + raise ValueError("Model must be of the form (c, p, q)") # AR part + p = model[1] + phi = formatted_params[1] ar_term = 0 if (t - p) < 0 else np.dot(phi, data[t - p : t][::-1]) + + # MA part + q = model[2] + theta = formatted_params[2] + ma_term = 0 if (t - q) < 0 else np.dot(theta, residuals[t - q : t][::-1]) + + c = formatted_params[0][0] if model[0] else 0 + y_hat = c + ar_term + ma_term + return y_hat + + +def _calc_sarima(data, model, t, formatted_params, residuals): + """Calculate the SARIMA forecast for time t.""" + if len(model) != 6: + raise ValueError("Model must be of the form (c, p, q, ps, qs, seasonal_period)") + arima_forecast = _calc_arima(data, model[:3], t, formatted_params, residuals) + seasonal_period = model[5] # Seasonal AR part + ps = model[3] + phi_s = formatted_params[3] ars_term = ( 0 if (t - seasonal_period * ps) < 0 else np.dot(phi_s, data[t - seasonal_period * ps : t : seasonal_period][::-1]) ) - # MA part - ma_term = 0 if (t - q) < 0 else np.dot(theta, residuals[t - q : t][::-1]) # Seasonal MA part + qs = model[4] + theta_s = formatted_params[4] mas_term = ( 0 if (t - seasonal_period * qs) < 0 @@ -263,120 +262,20 @@ def _calc_arima( theta_s, residuals[t - seasonal_period * qs : t : seasonal_period][::-1] ) ) - y_hat = c + ar_term + ma_term + ars_term + mas_term - return y_hat + return arima_forecast + ars_term + mas_term -def _nelder_mead( - data, - p, - q, - ps, - qs, - seasonal_period, - include_constant_term, - tol=1e-6, - max_iter=500, -): - """Implement the nelder-mead optimisation algorithm.""" - num_params = include_constant_term + p + ps + q + qs - points = np.full((num_params + 1, num_params), 0.5) - for i in range(num_params): - points[i + 1][i] = 0.6 - values = np.array( - [ - _arima_log_likelihood( - v, data, p, q, ps, qs, seasonal_period, include_constant_term - )[0] - for v in points - ] - ) - for _iteration in range(max_iter): - # Order simplex by function values - order = np.argsort(values) - points = points[order] - values = values[order] - - # Centroid of the best n points - centre_point = points[:-1].sum(axis=0) / len(points[:-1]) - - # Reflection - # centre + distance between centre and largest value - reflected_point = centre_point + (centre_point - points[-1]) - reflected_value = _arima_log_likelihood( - reflected_point, - data, - p, - q, - ps, - qs, - seasonal_period, - include_constant_term, - )[0] - # if between best and second best, use reflected value - if len(values) > 1 and values[0] <= reflected_value < values[-2]: - points[-1] = reflected_point - values[-1] = reflected_value - continue - # Expansion - # Otherwise if it is better than the best value - if reflected_value < values[0]: - expanded_point = centre_point + 2 * (reflected_point - centre_point) - expanded_value = _arima_log_likelihood( - expanded_point, - data, - p, - q, - ps, - qs, - seasonal_period, - include_constant_term, - )[0] - # if less than reflected value use expanded, otherwise go back to reflected - if expanded_value < reflected_value: - points[-1] = expanded_point - values[-1] = expanded_value - else: - points[-1] = reflected_point - values[-1] = reflected_value - continue - # Contraction - # Otherwise if reflection is worse than all current values - contracted_point = centre_point - 0.5 * (centre_point - points[-1]) - contracted_value = _arima_log_likelihood( - contracted_point, - data, - p, - q, - ps, - qs, - seasonal_period, - include_constant_term, - )[0] - # If contraction is better use that otherwise move to shrinkage - if contracted_value < values[-1]: - points[-1] = contracted_point - values[-1] = contracted_value - continue - - # Shrinkage - for i in range(1, len(points)): - points[i] = points[0] - 0.5 * (points[0] - points[i]) - values[i] = _arima_log_likelihood( - points[i], - data, - p, - q, - ps, - qs, - seasonal_period, - include_constant_term, - )[0] - - # Convergence check - if np.max(np.abs(values - values[0])) < tol: - break - return points[0], values[0] +def make_arima_llf(base_function, data, model): + """ + Return a parameterized log-likelihood function for ARIMA. + + This can then be used with an optimization algorithm. + """ + + def loss_fn(v): + return _arima_model(v, base_function, data, model)[0] + + return loss_fn def _auto_arima(data): @@ -385,7 +284,7 @@ def _auto_arima(data): For automatic ARIMA model selection. """ - seasonal_period = _calc_seasonal_period(data) + seasonal_period = calc_seasonal_period(data) difference = 0 while not kpss_test(data)[1]: data = np.diff(data, n=1) @@ -395,98 +294,46 @@ def _auto_arima(data): data = data[seasonal_period:] - data[:-seasonal_period] include_c = 1 if difference == 0 else 0 model_parameters = [ - [2, 2, 0, 0, include_c], - [0, 0, 0, 0, include_c], - [1, 0, 0, 0, include_c], - [0, 1, 0, 0, include_c], + [include_c, 2, 2, 0, 0, seasonal_period], + [include_c, 0, 0, 0, 0, seasonal_period], + [include_c, 1, 0, 0, 0, seasonal_period], + [include_c, 0, 1, 0, 0, seasonal_period], ] model_points = [] + model_scores = [] for p in model_parameters: - points, aic = _nelder_mead(data, p[0], p[1], p[2], p[3], seasonal_period, p[4]) - p.append(aic) + points, aic = nelder_mead(make_arima_llf(_calc_sarima, data, p), np.sum(p[:5])) model_points.append(points) - current_model = min(model_parameters, key=lambda item: item[5]) - current_points = model_points[model_parameters.index(current_model)] + model_scores.append(aic) + best_score = min(model_scores) + best_index = model_scores.index(best_score) + current_model = model_parameters[best_index] + current_points = model_points[best_index] while True: better_model = False - for param_no in range(4): + for param_no in range(1, 5): for adjustment in [-1, 1]: if (current_model[param_no] + adjustment) < 0: continue model = current_model.copy() model[param_no] += adjustment for constant_term in [0, 1]: - points, aic = _nelder_mead( - data, - model[0], - model[1], - model[2], - model[3], - seasonal_period, - constant_term, + model[0] = constant_term + points, aic = nelder_mead( + make_arima_llf(_calc_sarima, data, model), np.sum(model[:5]) ) - if aic < current_model[5]: - current_model = model + if aic < best_score: + current_model = model.copy() current_points = points - current_model[5] = aic - current_model[4] = constant_term + best_score = aic better_model = True if not better_model: break return ( data, - current_model[5], - current_model[0], difference, - current_model[1], - current_model[2], seasonal_difference, - current_model[3], - seasonal_period, - current_model[4], + current_model, current_points, + best_score, ) - - -@njit(cache=True, fastmath=True) -def _acf(X, max_lag): - length = len(X) - X_t = np.zeros(max_lag, dtype=float) - for lag in range(1, max_lag + 1): - lag_length = length - lag - x1 = X[:-lag] - x2 = X[lag:] - s1 = np.sum(x1) - s2 = np.sum(x2) - m1 = s1 / lag_length - m2 = s2 / lag_length - ss1 = np.sum(x1 * x1) - ss2 = np.sum(x2 * x2) - v1 = ss1 - s1 * m1 - v2 = ss2 - s2 * m2 - v1_is_zero, v2_is_zero = v1 <= 1e-9, v2 <= 1e-9 - if v1_is_zero and v2_is_zero: # Both zero variance, - # so must be 100% correlated - X_t[lag - 1] = 1 - elif v1_is_zero or v2_is_zero: # One zero variance - # the other not - X_t[lag - 1] = 0 - else: - X_t[lag - 1] = np.sum((x1 - m1) * (x2 - m2)) / np.sqrt(v1 * v2) - return X_t - - -@njit(cache=True, fastmath=True) -def _calc_seasonal_period(data): - """Estimate the seasonal period based on the autocorrelation of the series.""" - lags = _acf(data, 24) - lags = np.concatenate((np.array([1.0]), lags)) - peaks = [] - mean_lags = np.mean(lags) - for i in range(1, len(lags) - 1): # Skip the first (lag 0) and last elements - if lags[i] >= lags[i - 1] and lags[i] >= lags[i + 1] and lags[i] > mean_lags: - peaks.append(i) - if not peaks: - return 1 - else: - return peaks[0] diff --git a/aeon/utils/forecasting/_seasonality.py b/aeon/utils/forecasting/_seasonality.py new file mode 100644 index 0000000000..356b1a40d2 --- /dev/null +++ b/aeon/utils/forecasting/_seasonality.py @@ -0,0 +1,101 @@ +"""Seasonality Tools. + +Includes autocorrelation function (ACF) and seasonal period estimation. +""" + +import numpy as np +from numba import njit + + +@njit(cache=True, fastmath=True) +def acf(X, max_lag): + """ + Compute the sample autocorrelation function (ACF) of a time series. + + Up to a specified maximum lag. + + The autocorrelation at lag k is defined as the Pearson correlation + coefficient between the series and a lagged version of itself. + If both segments at a given lag have zero variance, the function + returns 1 for that lag. If only one segment has zero variance, + the function returns 0. + + Parameters + ---------- + X : array-like, shape (n_samples,) + The input time series data. + max_lag : int + The maximum lag (number of steps) for which to + compute the autocorrelation. + + Returns + ------- + acf_values : np.ndarray, shape (max_lag,) + The autocorrelation values for lags 1 through `max_lag`. + + Notes + ----- + The function handles cases where the lagged segments have zero + variance to avoid division by zero. + The returned values correspond to + lags 1, 2, ..., `max_lag` (not including lag 0). + """ + length = len(X) + X_t = np.zeros(max_lag, dtype=float) + for lag in range(1, max_lag + 1): + lag_length = length - lag + x1 = X[:-lag] + x2 = X[lag:] + s1 = np.sum(x1) + s2 = np.sum(x2) + m1 = s1 / lag_length + m2 = s2 / lag_length + ss1 = np.sum(x1 * x1) + ss2 = np.sum(x2 * x2) + v1 = ss1 - s1 * m1 + v2 = ss2 - s2 * m2 + v1_is_zero, v2_is_zero = v1 <= 1e-9, v2 <= 1e-9 + if v1_is_zero and v2_is_zero: # Both zero variance, + # so must be 100% correlated + X_t[lag - 1] = 1 + elif v1_is_zero or v2_is_zero: # One zero variance + # the other not + X_t[lag - 1] = 0 + else: + X_t[lag - 1] = np.sum((x1 - m1) * (x2 - m2)) / np.sqrt(v1 * v2) + return X_t + + +@njit(cache=True, fastmath=True) +def calc_seasonal_period(data): + """ + Estimate the seasonal period of a time series using autocorrelation analysis. + + This function computes the autocorrelation function (ACF) of + the input series up to lag 24. It then identifies peaks in the + ACF above the mean value, treating the first such peak + as the estimated seasonal period. If no peak is found, + a period of 1 is returned. + + Parameters + ---------- + data : array-like, shape (n_samples,) + The input time series data. + + Returns + ------- + period : int + The estimated seasonal period (lag) of the series. Returns 1 if no significant + peak is detected in the autocorrelation. + """ + lags = acf(data, 24) + lags = np.concatenate((np.array([1.0]), lags)) + peaks = [] + mean_lags = np.mean(lags) + for i in range(1, len(lags) - 1): # Skip the first (lag 0) and last elements + if lags[i] >= lags[i - 1] and lags[i] >= lags[i + 1] and lags[i] > mean_lags: + peaks.append(i) + if not peaks: + return 1 + else: + return peaks[0] diff --git a/aeon/utils/optimisation/__init__.py b/aeon/utils/optimisation/__init__.py new file mode 100644 index 0000000000..11eddea791 --- /dev/null +++ b/aeon/utils/optimisation/__init__.py @@ -0,0 +1 @@ +"""Optimisation utils.""" diff --git a/aeon/utils/optimisation/_nelder_mead.py b/aeon/utils/optimisation/_nelder_mead.py new file mode 100644 index 0000000000..36dfe732ab --- /dev/null +++ b/aeon/utils/optimisation/_nelder_mead.py @@ -0,0 +1,106 @@ +"""Optimisation algorithms for automatic parameter tuning.""" + +import numpy as np + + +def nelder_mead( + loss_function, + num_params, + tol=1e-6, + max_iter=500, +): + """ + Perform optimisation using the Nelder–Mead simplex algorithm. + + This function minimises a given loss (objective) function using the Nelder–Mead + algorithm, a derivative-free method that iteratively refines a simplex of candidate + solutions. The implementation supports unconstrained minimisation of functions + with a fixed number of parameters. + + Parameters + ---------- + loss_function : callable + The objective function to minimise. Should accept a 1D NumPy array of length + `num_params` and return a scalar value. + num_params : int + The number of parameters (dimensions) in the optimisation problem. + tol : float, optional (default=1e-6) + Tolerance for convergence. The algorithm stops when the maximum difference + between function values at simplex vertices is less than `tol`. + max_iter : int, optional (default=500) + Maximum number of iterations to perform. + + Returns + ------- + best_params : np.ndarray, shape (`num_params`,) + The parameter vector that minimises the loss function. + best_value : float + The value of the loss function at the optimal parameter vector. + + Notes + ----- + - The initial simplex is constructed by setting each parameter to 0.5, + with one additional point per dimension at 0.6 for that dimension. + - This implementation does not support constraints or bounds on the parameters. + - The algorithm does not guarantee finding a global minimum. + + Examples + -------- + >>> def sphere(x): + ... return np.sum(x**2) + >>> x_opt, val = nelder_mead(sphere, num_params=2) + """ + points = np.full((num_params + 1, num_params), 0.5) + for i in range(num_params): + points[i + 1][i] = 0.6 + values = np.array([loss_function(v) for v in points]) + for _iteration in range(max_iter): + # Order simplex by function values + order = np.argsort(values) + points = points[order] + values = values[order] + + # Centroid of the best n points + centre_point = points[:-1].sum(axis=0) / len(points[:-1]) + + # Reflection + # centre + distance between centre and largest value + reflected_point = centre_point + (centre_point - points[-1]) + reflected_value = loss_function(reflected_point) + # if between best and second best, use reflected value + if len(values) > 1 and values[0] <= reflected_value < values[-2]: + points[-1] = reflected_point + values[-1] = reflected_value + continue + # Expansion + # Otherwise if it is better than the best value + if reflected_value < values[0]: + expanded_point = centre_point + 2 * (reflected_point - centre_point) + expanded_value = loss_function(expanded_point) + # if less than reflected value use expanded, otherwise go back to reflected + if expanded_value < reflected_value: + points[-1] = expanded_point + values[-1] = expanded_value + else: + points[-1] = reflected_point + values[-1] = reflected_value + continue + # Contraction + # Otherwise if reflection is worse than all current values + contracted_point = centre_point - 0.5 * (centre_point - points[-1]) + contracted_value = loss_function(contracted_point) + # If contraction is better use that otherwise move to shrinkage + if contracted_value < values[-1]: + points[-1] = contracted_point + values[-1] = contracted_value + continue + + # Shrinkage + for i in range(1, len(points)): + points[i] = points[0] - 0.5 * (points[0] - points[i]) + values[i] = loss_function(points[i]) + + # Convergence check + if np.max(np.abs(values - values[0])) < tol: + break + return points[0], values[0] From 6d18de9c7c7dea345e2accedd7ef16be65e83ac7 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 28 May 2025 14:05:57 +0100 Subject: [PATCH 05/76] Add ARIMA forecaster to forecasting package --- aeon/forecasting/__init__.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/aeon/forecasting/__init__.py b/aeon/forecasting/__init__.py index 7a331f69e6..f6983cb89c 100644 --- a/aeon/forecasting/__init__.py +++ b/aeon/forecasting/__init__.py @@ -5,8 +5,10 @@ "BaseForecaster", "RegressionForecaster", "ETSForecaster", + "ARIMAForecaster", ] +from aeon.forecasting._arima import ARIMAForecaster from aeon.forecasting._ets import ETSForecaster from aeon.forecasting._naive import NaiveForecaster from aeon.forecasting._regression import RegressionForecaster From b7e642432fc931d09a3f1b35b77e4f74c9a63f3b Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 28 May 2025 14:06:31 +0100 Subject: [PATCH 06/76] Add example to ARIMA forecaster, this also tests the forecaster is producing the expected results --- aeon/forecasting/_arima.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 00d35ec55c..4c0e383140 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -68,6 +68,17 @@ class ARIMAForecaster(BaseForecaster): .. [1] R. J. Hyndman and G. Athanasopoulos, Forecasting: Principles and Practice. OTexts, 2014. https://otexts.com/fpp3/ + + Examples + -------- + >>> from aeon.forecasting import ARIMAForecaster + >>> from aeon.datasets import load_airline + >>> y = load_airline() + >>> forecaster = ARIMAForecaster() + >>> forecaster.fit(y) + ARIMAForecaster() + >>> forecaster.predict() + 450.74890401954826 """ def __init__(self, horizon=1): From e33fa4d3d33121b30f30ca903c49ac996c6dd5b8 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 28 May 2025 18:24:08 +0100 Subject: [PATCH 07/76] Basic ARIMA model --- aeon/forecasting/_arima.py | 168 +++++-------------------------------- 1 file changed, 21 insertions(+), 147 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 4c0e383140..29c42bffe5 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -11,8 +11,6 @@ import numpy as np from aeon.forecasting.base import BaseForecaster -from aeon.utils.forecasting._hypo_tests import kpss_test -from aeon.utils.forecasting._seasonality import calc_seasonal_period from aeon.utils.optimisation._nelder_mead import nelder_mead NOGIL = False @@ -22,10 +20,8 @@ class ARIMAForecaster(BaseForecaster): """AutoRegressive Integrated Moving Average (ARIMA) forecaster. - Implements the Hyndman-Khandakar automatic ARIMA algorithm for time series - forecasting with optional seasonal components. The model automatically selects - the orders of the non-seasonal (p, d, q) and seasonal (P, D, Q, m) components - based on information criteria, such as AIC. + The model automatically selects the parameters of the model based + on information criteria, such as AIC. Parameters ---------- @@ -45,23 +41,14 @@ class ARIMAForecaster(BaseForecaster): p_, d_, q_ : int Orders of the ARIMA model: autoregressive (p), differencing (d), and moving average (q) terms. - ps_, ds_, qs_ : int - Orders of the seasonal ARIMA model: seasonal AR (P), seasonal differencing (D), - and seasonal MA (Q) terms. - seasonal_period_ : int - Length of the seasonal cycle. constant_term_ : float Constant/intercept term in the model. c_ : float Estimated constant term (internal use). phi_ : array-like Coefficients for the non-seasonal autoregressive terms. - phi_s_ : array-like - Coefficients for the seasonal autoregressive terms. theta_ : array-like Coefficients for the non-seasonal moving average terms. - theta_s_ : array-like - Coefficients for the seasonal moving average terms. References ---------- @@ -74,33 +61,27 @@ class ARIMAForecaster(BaseForecaster): >>> from aeon.forecasting import ARIMAForecaster >>> from aeon.datasets import load_airline >>> y = load_airline() - >>> forecaster = ARIMAForecaster() + >>> forecaster = ARIMAForecaster(2,1,1,0) >>> forecaster.fit(y) ARIMAForecaster() >>> forecaster.predict() - 450.74890401954826 + 550.9147246631134 """ - def __init__(self, horizon=1): + def __init__(self, p=1, d=0, q=1, constant_term=0, horizon=1): super().__init__(horizon=horizon, axis=1) self.data_ = [] self.differenced_data_ = [] self.residuals_ = [] self.aic_ = 0 - self.p_ = 0 - self.d_ = 0 - self.q_ = 0 - self.ps_ = 0 - self.ds_ = 0 - self.qs_ = 0 - self.seasonal_period_ = 0 - self.constant_term_ = 0 + self.p = p + self.d = d + self.q = q + self.constant_term = constant_term self.model_ = [] self.c_ = 0 self.phi_ = 0 - self.phi_s_ = 0 self.theta_ = 0 - self.theta_s_ = 0 self.parameters_ = [] def _fit(self, y, exog=None): @@ -121,30 +102,17 @@ def _fit(self, y, exog=None): Fitted ARIMAForecaster. """ self.data_ = np.array(y.squeeze(), dtype=np.float64) - ( - self.differenced_data_, - self.d_, - self.ds_, - self.model_, - self.parameters_, - self.aic_, - ) = _auto_arima(self.data_) - ( - self.constant_term_, - self.p_, - self.q_, - self.ps_, - self.qs_, - self.seasonal_period_, - ) = self.model_ - (self.c_, self.phi_, self.phi_s_, self.theta_, self.theta_s_) = _extract_params( + self.model_ = [self.constant_term, self.p, self.q] + self.differenced_data_ = np.diff(self.data_, n=self.d) + (self.parameters_, self.aic_) = nelder_mead( + make_arima_llf(_calc_arima, self.data_, self.model_), + np.sum(self.model_[:3]), + ) + (self.c_, self.phi_, self.theta_) = _extract_params( self.parameters_, self.model_ ) - ( - self.aic_, - self.residuals_, - ) = _arima_model( - self.parameters_, _calc_sarima, self.differenced_data_, self.model_ + (self.aic_, self.residuals_) = _arima_model( + self.parameters_, _calc_arima, self.differenced_data_, self.model_ ) return self @@ -166,7 +134,7 @@ def _predict(self, y=None, exog=None): single prediction self.horizon steps ahead of y. """ y = np.array(y, dtype=np.float64) - value = _calc_sarima( + value = _calc_arima( self.differenced_data_, self.model_, len(self.differenced_data_), @@ -174,15 +142,9 @@ def _predict(self, y=None, exog=None): self.residuals_, ) history = self.data_[::-1] - differenced_history = np.diff(self.data_, n=self.d_)[::-1] - # Step 1: undo seasonal differencing on y^(d) - for k in range(1, self.ds_ + 1): - lag = k * self.seasonal_period_ - value += (-1) ** (k + 1) * comb(self.ds_, k) * differenced_history[lag - 1] - # Step 2: undo ordinary differencing - for k in range(1, self.d_ + 1): - value += (-1) ** (k + 1) * comb(self.d_, k) * history[k - 1] + for k in range(1, self.d + 1): + value += (-1) ** (k + 1) * comb(self.d, k) * history[k - 1] return value @@ -249,33 +211,6 @@ def _calc_arima(data, model, t, formatted_params, residuals): return y_hat -def _calc_sarima(data, model, t, formatted_params, residuals): - """Calculate the SARIMA forecast for time t.""" - if len(model) != 6: - raise ValueError("Model must be of the form (c, p, q, ps, qs, seasonal_period)") - arima_forecast = _calc_arima(data, model[:3], t, formatted_params, residuals) - seasonal_period = model[5] - # Seasonal AR part - ps = model[3] - phi_s = formatted_params[3] - ars_term = ( - 0 - if (t - seasonal_period * ps) < 0 - else np.dot(phi_s, data[t - seasonal_period * ps : t : seasonal_period][::-1]) - ) - # Seasonal MA part - qs = model[4] - theta_s = formatted_params[4] - mas_term = ( - 0 - if (t - seasonal_period * qs) < 0 - else np.dot( - theta_s, residuals[t - seasonal_period * qs : t : seasonal_period][::-1] - ) - ) - return arima_forecast + ars_term + mas_term - - def make_arima_llf(base_function, data, model): """ Return a parameterized log-likelihood function for ARIMA. @@ -287,64 +222,3 @@ def loss_fn(v): return _arima_model(v, base_function, data, model)[0] return loss_fn - - -def _auto_arima(data): - """ - Implement the Hyndman-Khandakar algorithm. - - For automatic ARIMA model selection. - """ - seasonal_period = calc_seasonal_period(data) - difference = 0 - while not kpss_test(data)[1]: - data = np.diff(data, n=1) - difference += 1 - seasonal_difference = 1 if seasonal_period > 1 else 0 - if seasonal_difference: - data = data[seasonal_period:] - data[:-seasonal_period] - include_c = 1 if difference == 0 else 0 - model_parameters = [ - [include_c, 2, 2, 0, 0, seasonal_period], - [include_c, 0, 0, 0, 0, seasonal_period], - [include_c, 1, 0, 0, 0, seasonal_period], - [include_c, 0, 1, 0, 0, seasonal_period], - ] - model_points = [] - model_scores = [] - for p in model_parameters: - points, aic = nelder_mead(make_arima_llf(_calc_sarima, data, p), np.sum(p[:5])) - model_points.append(points) - model_scores.append(aic) - best_score = min(model_scores) - best_index = model_scores.index(best_score) - current_model = model_parameters[best_index] - current_points = model_points[best_index] - while True: - better_model = False - for param_no in range(1, 5): - for adjustment in [-1, 1]: - if (current_model[param_no] + adjustment) < 0: - continue - model = current_model.copy() - model[param_no] += adjustment - for constant_term in [0, 1]: - model[0] = constant_term - points, aic = nelder_mead( - make_arima_llf(_calc_sarima, data, model), np.sum(model[:5]) - ) - if aic < best_score: - current_model = model.copy() - current_points = points - best_score = aic - better_model = True - if not better_model: - break - return ( - data, - difference, - seasonal_difference, - current_model, - current_points, - best_score, - ) From f613f7e4cd40990f577c3e7ce286bf14c59abdd8 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 28 May 2025 18:42:25 +0100 Subject: [PATCH 08/76] Convert ARIMA to numba version --- aeon/forecasting/_arima.py | 53 +++++++++++++------------ aeon/utils/optimisation/_nelder_mead.py | 14 ++++--- 2 files changed, 37 insertions(+), 30 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 29c42bffe5..4ca197f3f0 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -9,6 +9,7 @@ from math import comb import numpy as np +from numba import njit from aeon.forecasting.base import BaseForecaster from aeon.utils.optimisation._nelder_mead import nelder_mead @@ -65,7 +66,7 @@ class ARIMAForecaster(BaseForecaster): >>> forecaster.fit(y) ARIMAForecaster() >>> forecaster.predict() - 550.9147246631134 + 550.9147246631135 """ def __init__(self, p=1, d=0, q=1, constant_term=0, horizon=1): @@ -102,11 +103,13 @@ def _fit(self, y, exog=None): Fitted ARIMAForecaster. """ self.data_ = np.array(y.squeeze(), dtype=np.float64) - self.model_ = [self.constant_term, self.p, self.q] + self.model_ = np.array((self.constant_term, self.p, self.q), dtype=np.int32) self.differenced_data_ = np.diff(self.data_, n=self.d) (self.parameters_, self.aic_) = nelder_mead( - make_arima_llf(_calc_arima, self.data_, self.model_), + _arima_model_wrapper, np.sum(self.model_[:3]), + self.data_, + self.model_, ) (self.c_, self.phi_, self.theta_) = _extract_params( self.parameters_, self.model_ @@ -148,6 +151,7 @@ def _predict(self, y=None, exog=None): return value +@njit(cache=True, fastmath=True) def _aic(residuals, num_params): """Calculate the log-likelihood of a model.""" variance = np.mean(residuals**2) @@ -155,7 +159,13 @@ def _aic(residuals, num_params): return liklihood + 2 * num_params +@njit(fastmath=True) +def _arima_model_wrapper(params, data, model): + return _arima_model(params, _calc_arima, data, model)[0] + + # Define the ARIMA(p, d, q) likelihood function +@njit(cache=True, fastmath=True) def _arima_model(params, base_function, data, model): """Calculate the log-likelihood of an ARIMA model given the parameters.""" formatted_params = _extract_params(params, model) # Extract parameters @@ -175,9 +185,7 @@ def _arima_model(params, base_function, data, model): return _aic(residuals, len(params)), residuals -# Define the SARIMA(p, d, q)(P, D, Q) likelihood function - - +@njit(cache=True, fastmath=True) def _extract_params(params, model): """Extract ARIMA parameters from the parameter vector.""" if len(params) != np.sum(model): @@ -188,37 +196,32 @@ def _extract_params(params, model): f"Expected {previous_length} parameters for a non-seasonal model or \ {np.sum(model)} parameters for a seasonal model, got {len(params)}" ) - starts = np.cumsum([0] + model[:-1]) - return [params[s : s + l].tolist() for s, l in zip(starts, model)] - - + starts = np.cumsum(np.concatenate((np.zeros(1, dtype=np.int32), model[:-1]))) + n = len(starts) + max_len = np.max(model) + result = np.full((n, max_len), np.nan, dtype=params.dtype) + for i in range(n): + length = model[i] + start = starts[i] + result[i, :length] = params[start : start + length] + return result + + +@njit(cache=True, fastmath=True) def _calc_arima(data, model, t, formatted_params, residuals): """Calculate the ARIMA forecast for time t.""" if len(model) != 3: raise ValueError("Model must be of the form (c, p, q)") # AR part p = model[1] - phi = formatted_params[1] + phi = formatted_params[1][:p] ar_term = 0 if (t - p) < 0 else np.dot(phi, data[t - p : t][::-1]) # MA part q = model[2] - theta = formatted_params[2] + theta = formatted_params[2][:q] ma_term = 0 if (t - q) < 0 else np.dot(theta, residuals[t - q : t][::-1]) c = formatted_params[0][0] if model[0] else 0 y_hat = c + ar_term + ma_term return y_hat - - -def make_arima_llf(base_function, data, model): - """ - Return a parameterized log-likelihood function for ARIMA. - - This can then be used with an optimization algorithm. - """ - - def loss_fn(v): - return _arima_model(v, base_function, data, model)[0] - - return loss_fn diff --git a/aeon/utils/optimisation/_nelder_mead.py b/aeon/utils/optimisation/_nelder_mead.py index 36dfe732ab..749187541d 100644 --- a/aeon/utils/optimisation/_nelder_mead.py +++ b/aeon/utils/optimisation/_nelder_mead.py @@ -1,11 +1,15 @@ """Optimisation algorithms for automatic parameter tuning.""" import numpy as np +from numba import njit +@njit(fastmath=True) def nelder_mead( loss_function, num_params, + data, + model, tol=1e-6, max_iter=500, ): @@ -53,7 +57,7 @@ def nelder_mead( points = np.full((num_params + 1, num_params), 0.5) for i in range(num_params): points[i + 1][i] = 0.6 - values = np.array([loss_function(v) for v in points]) + values = np.array([loss_function(v, data, model) for v in points]) for _iteration in range(max_iter): # Order simplex by function values order = np.argsort(values) @@ -66,7 +70,7 @@ def nelder_mead( # Reflection # centre + distance between centre and largest value reflected_point = centre_point + (centre_point - points[-1]) - reflected_value = loss_function(reflected_point) + reflected_value = loss_function(reflected_point, data, model) # if between best and second best, use reflected value if len(values) > 1 and values[0] <= reflected_value < values[-2]: points[-1] = reflected_point @@ -76,7 +80,7 @@ def nelder_mead( # Otherwise if it is better than the best value if reflected_value < values[0]: expanded_point = centre_point + 2 * (reflected_point - centre_point) - expanded_value = loss_function(expanded_point) + expanded_value = loss_function(expanded_point, data, model) # if less than reflected value use expanded, otherwise go back to reflected if expanded_value < reflected_value: points[-1] = expanded_point @@ -88,7 +92,7 @@ def nelder_mead( # Contraction # Otherwise if reflection is worse than all current values contracted_point = centre_point - 0.5 * (centre_point - points[-1]) - contracted_value = loss_function(contracted_point) + contracted_value = loss_function(contracted_point, data, model) # If contraction is better use that otherwise move to shrinkage if contracted_value < values[-1]: points[-1] = contracted_point @@ -98,7 +102,7 @@ def nelder_mead( # Shrinkage for i in range(1, len(points)): points[i] = points[0] - 0.5 * (points[0] - points[i]) - values[i] = loss_function(points[i]) + values[i] = loss_function(points[i], data, model) # Convergence check if np.max(np.abs(values - values[0])) < tol: From 9eb00f69f2d98640ea5765ff062feff57aaf1211 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 28 May 2025 19:21:07 +0100 Subject: [PATCH 09/76] Adjust parameters to allow modification in fit --- aeon/forecasting/_arima.py | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 4ca197f3f0..412efde4f3 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -64,7 +64,7 @@ class ARIMAForecaster(BaseForecaster): >>> y = load_airline() >>> forecaster = ARIMAForecaster(2,1,1,0) >>> forecaster.fit(y) - ARIMAForecaster() + ARIMAForecaster(d=1, p=2) >>> forecaster.predict() 550.9147246631135 """ @@ -79,6 +79,10 @@ def __init__(self, p=1, d=0, q=1, constant_term=0, horizon=1): self.d = d self.q = q self.constant_term = constant_term + self.p_ = 0 + self.d_ = 0 + self.q_ = 0 + self.constant_term_ = 0 self.model_ = [] self.c_ = 0 self.phi_ = 0 @@ -102,6 +106,10 @@ def _fit(self, y, exog=None): self Fitted ARIMAForecaster. """ + self.p_ = self.p + self.d_ = self.d + self.q_ = self.q + self.constant_term_ = self.constant_term self.data_ = np.array(y.squeeze(), dtype=np.float64) self.model_ = np.array((self.constant_term, self.p, self.q), dtype=np.int32) self.differenced_data_ = np.diff(self.data_, n=self.d) @@ -146,8 +154,8 @@ def _predict(self, y=None, exog=None): ) history = self.data_[::-1] # Step 2: undo ordinary differencing - for k in range(1, self.d + 1): - value += (-1) ** (k + 1) * comb(self.d, k) * history[k - 1] + for k in range(1, self.d_ + 1): + value += (-1) ** (k + 1) * comb(self.d_, k) * history[k - 1] return value From d4ed4b1fc3845d6c9c23c7788527a91e6f1f4431 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 28 May 2025 20:19:15 +0100 Subject: [PATCH 10/76] Update example and return native python type --- aeon/forecasting/_arima.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 412efde4f3..5c1933def8 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -62,7 +62,7 @@ class ARIMAForecaster(BaseForecaster): >>> from aeon.forecasting import ARIMAForecaster >>> from aeon.datasets import load_airline >>> y = load_airline() - >>> forecaster = ARIMAForecaster(2,1,1,0) + >>> forecaster = ARIMAForecaster(p=2,d=1) >>> forecaster.fit(y) ARIMAForecaster(d=1, p=2) >>> forecaster.predict() @@ -156,7 +156,7 @@ def _predict(self, y=None, exog=None): # Step 2: undo ordinary differencing for k in range(1, self.d_ + 1): value += (-1) ** (k + 1) * comb(self.d_, k) * history[k - 1] - return value + return value.item() @njit(cache=True, fastmath=True) From 2893e1b935d612caaf41610164c22736544756ab Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 28 May 2025 21:16:35 +0100 Subject: [PATCH 11/76] Fix examples for tests --- aeon/forecasting/_arima.py | 2 +- aeon/utils/optimisation/_nelder_mead.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 5c1933def8..94b6c51af8 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -66,7 +66,7 @@ class ARIMAForecaster(BaseForecaster): >>> forecaster.fit(y) ARIMAForecaster(d=1, p=2) >>> forecaster.predict() - 550.9147246631135 + 550.9147246631132 """ def __init__(self, p=1, d=0, q=1, constant_term=0, horizon=1): diff --git a/aeon/utils/optimisation/_nelder_mead.py b/aeon/utils/optimisation/_nelder_mead.py index 749187541d..767fbde506 100644 --- a/aeon/utils/optimisation/_nelder_mead.py +++ b/aeon/utils/optimisation/_nelder_mead.py @@ -50,9 +50,9 @@ def nelder_mead( Examples -------- - >>> def sphere(x): + >>> def sphere(x, data, model): ... return np.sum(x**2) - >>> x_opt, val = nelder_mead(sphere, num_params=2) + >>> x_opt, val = nelder_mead(sphere, num_params=2, data=None, model=None) """ points = np.full((num_params + 1, num_params), 0.5) for i in range(num_params): From 9801e8bdb0d7b34d7f149b116b96dd43f1b89183 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 28 May 2025 21:55:28 +0100 Subject: [PATCH 12/76] Fix Nelder-Mead Optimisation Algorithm Example --- aeon/utils/optimisation/_nelder_mead.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/aeon/utils/optimisation/_nelder_mead.py b/aeon/utils/optimisation/_nelder_mead.py index 767fbde506..6d3058a7d1 100644 --- a/aeon/utils/optimisation/_nelder_mead.py +++ b/aeon/utils/optimisation/_nelder_mead.py @@ -50,7 +50,9 @@ def nelder_mead( Examples -------- - >>> def sphere(x, data, model): + >>> from numba import njit + >>> @njit(fastmath=True) + ... def sphere(x, data, model): ... return np.sum(x**2) >>> x_opt, val = nelder_mead(sphere, num_params=2, data=None, model=None) """ From 2f928c7533b19299d0d39ef542afa9fc439cb117 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 28 May 2025 22:12:44 +0100 Subject: [PATCH 13/76] Fix Nelder-Mead Optimisation Algorithm Example #2 --- aeon/utils/optimisation/_nelder_mead.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/aeon/utils/optimisation/_nelder_mead.py b/aeon/utils/optimisation/_nelder_mead.py index 6d3058a7d1..9ef5a6ad01 100644 --- a/aeon/utils/optimisation/_nelder_mead.py +++ b/aeon/utils/optimisation/_nelder_mead.py @@ -51,7 +51,7 @@ def nelder_mead( Examples -------- >>> from numba import njit - >>> @njit(fastmath=True) + >>> @njit(cache=False, fastmath=True) ... def sphere(x, data, model): ... return np.sum(x**2) >>> x_opt, val = nelder_mead(sphere, num_params=2, data=None, model=None) From 94cd5b33a9534c90a57c2e9d7c1bd51a99822c83 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 28 May 2025 22:22:52 +0100 Subject: [PATCH 14/76] Remove Nelder-Mead Example due to issues with numba caching functions --- aeon/utils/optimisation/_nelder_mead.py | 8 -------- 1 file changed, 8 deletions(-) diff --git a/aeon/utils/optimisation/_nelder_mead.py b/aeon/utils/optimisation/_nelder_mead.py index 9ef5a6ad01..3bc90ecb93 100644 --- a/aeon/utils/optimisation/_nelder_mead.py +++ b/aeon/utils/optimisation/_nelder_mead.py @@ -47,14 +47,6 @@ def nelder_mead( with one additional point per dimension at 0.6 for that dimension. - This implementation does not support constraints or bounds on the parameters. - The algorithm does not guarantee finding a global minimum. - - Examples - -------- - >>> from numba import njit - >>> @njit(cache=False, fastmath=True) - ... def sphere(x, data, model): - ... return np.sum(x**2) - >>> x_opt, val = nelder_mead(sphere, num_params=2, data=None, model=None) """ points = np.full((num_params + 1, num_params), 0.5) for i in range(num_params): From 0d0d63fe106f99efb48ac10eb722d0ffd48b09aa Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 28 May 2025 22:39:30 +0100 Subject: [PATCH 15/76] Fix return type issue --- aeon/forecasting/_arima.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 94b6c51af8..4644f27ab6 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -156,7 +156,7 @@ def _predict(self, y=None, exog=None): # Step 2: undo ordinary differencing for k in range(1, self.d_ + 1): value += (-1) ** (k + 1) * comb(self.d_, k) * history[k - 1] - return value.item() + return float(value) @njit(cache=True, fastmath=True) From 39a3ed205ca1dfe8b16f16d3be9705325a188a8b Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 28 May 2025 23:21:37 +0100 Subject: [PATCH 16/76] Address PR Feedback --- aeon/forecasting/_arima.py | 17 +++++---- aeon/utils/forecasting/_hypo_tests.py | 51 ++++++++++++++++++++++--- aeon/utils/optimisation/_nelder_mead.py | 15 ++++++++ 3 files changed, 69 insertions(+), 14 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 4644f27ab6..48b27d94da 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -14,9 +14,6 @@ from aeon.forecasting.base import BaseForecaster from aeon.utils.optimisation._nelder_mead import nelder_mead -NOGIL = False -CACHE = True - class ARIMAForecaster(BaseForecaster): """AutoRegressive Integrated Moving Average (ARIMA) forecaster. @@ -31,24 +28,28 @@ class ARIMAForecaster(BaseForecaster): Attributes ---------- - data_ : list of float + data_ : np.ndarray Original training series values. - differenced_data_ : list of float + differenced_data_ : np.ndarray Differenced version of the training data used for stationarity. - residuals_ : list of float + residuals_ : np.ndarray Residual errors from the fitted model. aic_ : float Akaike Information Criterion for the selected model. + p, d, q : int + Parameters passed to the forecaster see p_, d_, q_. p_, d_, q_ : int Orders of the ARIMA model: autoregressive (p), differencing (d), and moving average (q) terms. + constant_term : int + Parameters passed to the forecaster see constant_term_. constant_term_ : float Constant/intercept term in the model. c_ : float Estimated constant term (internal use). - phi_ : array-like + phi_ : np.ndarray Coefficients for the non-seasonal autoregressive terms. - theta_ : array-like + theta_ : np.ndarray Coefficients for the non-seasonal moving average terms. References diff --git a/aeon/utils/forecasting/_hypo_tests.py b/aeon/utils/forecasting/_hypo_tests.py index 73d4521e5e..664d0c76e5 100644 --- a/aeon/utils/forecasting/_hypo_tests.py +++ b/aeon/utils/forecasting/_hypo_tests.py @@ -3,18 +3,56 @@ def kpss_test(y, regression="c", lags=None): # Test if time series is stationary """ - Implement the KPSS test for stationarity. + Perform the KPSS (Kwiatkowski-Phillips-Schmidt-Shin) test for stationarity. + + The KPSS test evaluates the null hypothesis that a time series is + (trend or level) stationary against the alternative of a unit root + (non-stationarity). It can test for either stationarity around a + constant (level stationarity) or arounda deterministic trend + (trend stationarity). Parameters ---------- - y (array-like): Time series data - regression (str): 'c' for constant, 'ct' for constant + trend - lags (int): Number of lags for HAC variance estimation (default: sqrt(n)) + y : array-like + Time series data to test for stationarity. + regression : str, default="c" + Indicates the null hypothesis for stationarity: + - "c" : Stationary around a constant (level stationarity) + - "ct" : Stationary around a constant and linear trend (trend stationarity) + lags : int or None, optional + Number of lags to use for the + HAC (heteroskedasticity and autocorrelation consistent) variance estimator. + If None, defaults to sqrt(n), where n is the sample size. Returns ------- - kpss_stat (float): KPSS test statistic - stationary (bool): Whether the series is stationary according to the test + kpss_stat : float + The KPSS test statistic. + stationary : bool + True if the series is judged stationary at the 5% significance level + (i.e., test statistic is below the critical value); False otherwise. + + Notes + ----- + - Uses asymptotic 5% critical values from Kwiatkowski et al. (1992): 0.463 for level + stationarity, 0.146 for trend stationarity. + - Returns True for stationary if the test statistic is below the 5% critical value. + + References + ---------- + Kwiatkowski, D., Phillips, P.C.B., Schmidt, P., & Shin, Y. (1992). + "Testing the null hypothesis of stationarity against the alternative + of a unit root." + Journal of Econometrics, 54(1–3), 159–178. + https://doi.org/10.1016/0304-4076(92)90104-Y + + Examples + -------- + >>> from aeon.utils.forecasting._hypo_tests import kpss_test + >>> from aeon.datasets import load_airline + >>> y = load_airline() + >>> kpss_test(y) + (1.1966313813502716, False) """ y = np.asarray(y) n = len(y) @@ -50,6 +88,7 @@ def kpss_test(y, regression="c", lags=None): # Test if time series is stationar # Step 4: Calculate the KPSS statistic kpss_stat = np.sum(S_t**2) / (n**2 * sigma_squared) + # 5% critical values for KPSS test if regression == "ct": # p. 162 Kwiatkowski et al. (1992): y_t = beta * t + r_t + e_t, # where beta is the trend, r_t a random walk and e_t a stationary diff --git a/aeon/utils/optimisation/_nelder_mead.py b/aeon/utils/optimisation/_nelder_mead.py index 3bc90ecb93..e59a70c5dd 100644 --- a/aeon/utils/optimisation/_nelder_mead.py +++ b/aeon/utils/optimisation/_nelder_mead.py @@ -28,6 +28,14 @@ def nelder_mead( `num_params` and return a scalar value. num_params : int The number of parameters (dimensions) in the optimisation problem. + data : np.ndarray + The input data used by the loss function. The shape and content depend on the + specific loss function being minimised. + model : np.ndarray + The model or context in which the loss function operates. This could be any + other object that the `loss_function` requires to compute its value. + The exact type and structure of `model` should be compatible with the + `loss_function`. tol : float, optional (default=1e-6) Tolerance for convergence. The algorithm stops when the maximum difference between function values at simplex vertices is less than `tol`. @@ -47,6 +55,13 @@ def nelder_mead( with one additional point per dimension at 0.6 for that dimension. - This implementation does not support constraints or bounds on the parameters. - The algorithm does not guarantee finding a global minimum. + + References + ---------- + .. [1] Nelder, J. A. and Mead, R. (1965). + A Simplex Method for Function Minimization. + The Computer Journal, 7(4), 308–313. + https://doi.org/10.1093/comjnl/7.4.308 """ points = np.full((num_params + 1, num_params), 0.5) for i in range(num_params): From 05a27850a44b1a2b804ec562b72576394d4bfb78 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 28 May 2025 23:28:55 +0100 Subject: [PATCH 17/76] Ignore small tolerances in floating point value in output of example --- aeon/forecasting/_arima.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 48b27d94da..42d1dece25 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -67,7 +67,7 @@ class ARIMAForecaster(BaseForecaster): >>> forecaster.fit(y) ARIMAForecaster(d=1, p=2) >>> forecaster.predict() - 550.9147246631132 + 550.914724663113... """ def __init__(self, p=1, d=0, q=1, constant_term=0, horizon=1): From 73966ab32a8dca49a5a10cc5aac5d2111d932d2e Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 28 May 2025 23:37:12 +0100 Subject: [PATCH 18/76] Fix kpss_test example --- aeon/utils/forecasting/_hypo_tests.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/aeon/utils/forecasting/_hypo_tests.py b/aeon/utils/forecasting/_hypo_tests.py index 664d0c76e5..cfa86a70fc 100644 --- a/aeon/utils/forecasting/_hypo_tests.py +++ b/aeon/utils/forecasting/_hypo_tests.py @@ -52,7 +52,7 @@ def kpss_test(y, regression="c", lags=None): # Test if time series is stationar >>> from aeon.datasets import load_airline >>> y = load_airline() >>> kpss_test(y) - (1.1966313813502716, False) + (np.float64(1.1966313813502716), np.False_) """ y = np.asarray(y) n = len(y) From a0f090d48e6ae066527acd38c43b15da63f17414 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 28 May 2025 23:58:28 +0100 Subject: [PATCH 19/76] Fix kpss_test example #2 --- aeon/utils/forecasting/_hypo_tests.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/aeon/utils/forecasting/_hypo_tests.py b/aeon/utils/forecasting/_hypo_tests.py index cfa86a70fc..2d581e971e 100644 --- a/aeon/utils/forecasting/_hypo_tests.py +++ b/aeon/utils/forecasting/_hypo_tests.py @@ -52,7 +52,7 @@ def kpss_test(y, regression="c", lags=None): # Test if time series is stationar >>> from aeon.datasets import load_airline >>> y = load_airline() >>> kpss_test(y) - (np.float64(1.1966313813502716), np.False_) + (np.float64(1.1966313813...), np.False_) """ y = np.asarray(y) n = len(y) From 68847033b6b4f0f9fdfab5c55f68292a438c9b24 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Mon, 2 Jun 2025 21:01:28 +0100 Subject: [PATCH 20/76] Update documentation for ARIMAForecaster, change constant_term to be bool, and fix bug with it not operating on differemced data --- aeon/forecasting/_arima.py | 33 +++++++++++++++++++++++++-------- 1 file changed, 25 insertions(+), 8 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 42d1dece25..103fbc6d4c 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -23,6 +23,14 @@ class ARIMAForecaster(BaseForecaster): Parameters ---------- + p : int, default=1, + Autoregressive (p) order of the ARIMA model + d : int, default=0, + Differencing (d) order of the ARIMA model + q : int, default=1, + Moving average (q) order of the ARIMA model + constant_term: bool = False, + Presence of a constant/intercept term in the model. horizon : int, default=1 The forecasting horizon, i.e., the number of steps ahead to predict. @@ -41,10 +49,10 @@ class ARIMAForecaster(BaseForecaster): p_, d_, q_ : int Orders of the ARIMA model: autoregressive (p), differencing (d), and moving average (q) terms. - constant_term : int + constant_term : bool Parameters passed to the forecaster see constant_term_. - constant_term_ : float - Constant/intercept term in the model. + constant_term_ : bool + Whether to include a constant/intercept term in the model. c_ : float Estimated constant term (internal use). phi_ : np.ndarray @@ -67,10 +75,17 @@ class ARIMAForecaster(BaseForecaster): >>> forecaster.fit(y) ARIMAForecaster(d=1, p=2) >>> forecaster.predict() - 550.914724663113... + 474.49449... """ - def __init__(self, p=1, d=0, q=1, constant_term=0, horizon=1): + def __init__( + self, + p: int = 1, + d: int = 0, + q: int = 1, + constant_term: bool = False, + horizon: int = 1, + ): super().__init__(horizon=horizon, axis=1) self.data_ = [] self.differenced_data_ = [] @@ -83,7 +98,7 @@ def __init__(self, p=1, d=0, q=1, constant_term=0, horizon=1): self.p_ = 0 self.d_ = 0 self.q_ = 0 - self.constant_term_ = 0 + self.constant_term_ = False self.model_ = [] self.c_ = 0 self.phi_ = 0 @@ -112,12 +127,14 @@ def _fit(self, y, exog=None): self.q_ = self.q self.constant_term_ = self.constant_term self.data_ = np.array(y.squeeze(), dtype=np.float64) - self.model_ = np.array((self.constant_term, self.p, self.q), dtype=np.int32) + self.model_ = np.array( + (1 if self.constant_term else 0, self.p, self.q), dtype=np.int32 + ) self.differenced_data_ = np.diff(self.data_, n=self.d) (self.parameters_, self.aic_) = nelder_mead( _arima_model_wrapper, np.sum(self.model_[:3]), - self.data_, + self.differenced_data_, self.model_, ) (self.c_, self.phi_, self.theta_) = _extract_params( From 9af3a56f52ecae0e3dc1294fc1aa052026f81e8d Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Sun, 8 Jun 2025 19:38:49 +0100 Subject: [PATCH 21/76] Modify ARIMA to allow predicting multiple values by updating the state without refitting the model --- aeon/forecasting/_arima.py | 78 ++++++++++++++++++++++++-------------- 1 file changed, 49 insertions(+), 29 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 103fbc6d4c..e176e3bb8e 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -6,8 +6,6 @@ __maintainer__ = ["alexbanwell1", "TonyBagnall"] __all__ = ["ARIMAForecaster"] -from math import comb - import numpy as np from numba import njit @@ -84,12 +82,12 @@ def __init__( d: int = 0, q: int = 1, constant_term: bool = False, - horizon: int = 1, ): - super().__init__(horizon=horizon, axis=1) + super().__init__(horizon=1, axis=1) self.data_ = [] self.differenced_data_ = [] self.residuals_ = [] + self.fitted_values_ = [] self.aic_ = 0 self.p = p self.d = d @@ -140,8 +138,12 @@ def _fit(self, y, exog=None): (self.c_, self.phi_, self.theta_) = _extract_params( self.parameters_, self.model_ ) - (self.aic_, self.residuals_) = _arima_model( - self.parameters_, _calc_arima, self.differenced_data_, self.model_ + (self.aic_, self.residuals_, self.fitted_values_) = _arima_model( + self.parameters_, + _calc_arima, + self.differenced_data_, + self.model_, + np.empty(0), ) return self @@ -159,22 +161,28 @@ def _predict(self, y=None, exog=None): Returns ------- - float - single prediction self.horizon steps ahead of y. + array[float] + Predictions len(y) steps ahead of the data seen in fit. + If y is None, then predict 1 step ahead of the data seen in fit. """ - y = np.array(y, dtype=np.float64) - value = _calc_arima( - self.differenced_data_, + if y is not None: + combined_data = np.concatenate((self.data_, y.flatten())) + else: + combined_data = self.data_ + n = len(self.data_) + differenced_data = np.diff(combined_data, n=self.d) + _aic, _residuals, predicted_values = _arima_model( + self.parameters_, + _calc_arima, + differenced_data, self.model_, - len(self.differenced_data_), - _extract_params(self.parameters_, self.model_), self.residuals_, ) - history = self.data_[::-1] - # Step 2: undo ordinary differencing - for k in range(1, self.d_ + 1): - value += (-1) ** (k + 1) * comb(self.d_, k) * history[k - 1] - return float(value) + init = combined_data[n - self.d_ : n] + x = np.concatenate((init, predicted_values)) + for _ in range(self.d_): + x = np.cumsum(x) + return x[self.d_ :] @njit(cache=True, fastmath=True) @@ -187,28 +195,35 @@ def _aic(residuals, num_params): @njit(fastmath=True) def _arima_model_wrapper(params, data, model): - return _arima_model(params, _calc_arima, data, model)[0] + return _arima_model(params, _calc_arima, data, model, np.empty(0))[0] # Define the ARIMA(p, d, q) likelihood function @njit(cache=True, fastmath=True) -def _arima_model(params, base_function, data, model): +def _arima_model(params, base_function, data, model, residuals): """Calculate the log-likelihood of an ARIMA model given the parameters.""" formatted_params = _extract_params(params, model) # Extract parameters # Initialize residuals n = len(data) - residuals = np.zeros(n) - for t in range(n): - y_hat = base_function( + m = len(residuals) + num_predictions = n - m + 1 + residuals = np.concatenate((residuals, np.zeros(num_predictions - 1))) + expect_full_history = m > 0 # I.e. we've been provided with some residuals + fitted_values = np.zeros(num_predictions) + for t in range(num_predictions): + fitted_values[t] = base_function( data, model, - t, + m + t, formatted_params, residuals, + expect_full_history, ) - residuals[t] = data[t] - y_hat - return _aic(residuals, len(params)), residuals + if t != num_predictions - 1: + # Only calculate residuals for the predictions we have data for + residuals[m + t] = data[m + t] - fitted_values[t] + return _aic(residuals, len(params)), residuals, fitted_values @njit(cache=True, fastmath=True) @@ -234,17 +249,22 @@ def _extract_params(params, model): @njit(cache=True, fastmath=True) -def _calc_arima(data, model, t, formatted_params, residuals): +def _calc_arima(data, model, t, formatted_params, residuals, expect_full_history=False): """Calculate the ARIMA forecast for time t.""" if len(model) != 3: raise ValueError("Model must be of the form (c, p, q)") - # AR part p = model[1] + q = model[2] + if expect_full_history and (t - p < 0 or t - q < 0): + raise ValueError( + f"Insufficient data for ARIMA model at time {t}. " + f"Expected at least {p} past values for AR and {q} for MA." + ) + # AR part phi = formatted_params[1][:p] ar_term = 0 if (t - p) < 0 else np.dot(phi, data[t - p : t][::-1]) # MA part - q = model[2] theta = formatted_params[2][:q] ma_term = 0 if (t - q) < 0 else np.dot(theta, residuals[t - q : t][::-1]) From e898f2f8a263bc43dd5d2a43e1ef41d6f05b8f0f Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Mon, 9 Jun 2025 21:35:38 +0100 Subject: [PATCH 22/76] Fix bug using self.d rather than self.d_ --- aeon/forecasting/_arima.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index e176e3bb8e..a0dd2cb052 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -170,7 +170,7 @@ def _predict(self, y=None, exog=None): else: combined_data = self.data_ n = len(self.data_) - differenced_data = np.diff(combined_data, n=self.d) + differenced_data = np.diff(combined_data, n=self.d_) _aic, _residuals, predicted_values = _arima_model( self.parameters_, _calc_arima, From 3c644a02a15a8827d763749d1a2d5d077c29c54f Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Wed, 11 Jun 2025 19:55:11 +0100 Subject: [PATCH 23/76] refactor ARIMA --- aeon/forecasting/_arima.py | 129 ++++++++++++++----------------------- 1 file changed, 50 insertions(+), 79 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index a0dd2cb052..0a6a2caec8 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -16,8 +16,8 @@ class ARIMAForecaster(BaseForecaster): """AutoRegressive Integrated Moving Average (ARIMA) forecaster. - The model automatically selects the parameters of the model based - on information criteria, such as AIC. + ARIMA with fixed model structure and fitted parameters found with an + nelder mead optimizer to minimise the AIC. Parameters ---------- @@ -27,36 +27,19 @@ class ARIMAForecaster(BaseForecaster): Differencing (d) order of the ARIMA model q : int, default=1, Moving average (q) order of the ARIMA model - constant_term: bool = False, + use_constant: bool = False, Presence of a constant/intercept term in the model. - horizon : int, default=1 - The forecasting horizon, i.e., the number of steps ahead to predict. Attributes ---------- - data_ : np.ndarray - Original training series values. - differenced_data_ : np.ndarray - Differenced version of the training data used for stationarity. residuals_ : np.ndarray Residual errors from the fitted model. aic_ : float - Akaike Information Criterion for the selected model. - p, d, q : int - Parameters passed to the forecaster see p_, d_, q_. - p_, d_, q_ : int - Orders of the ARIMA model: autoregressive (p), differencing (d), - and moving average (q) terms. - constant_term : bool - Parameters passed to the forecaster see constant_term_. - constant_term_ : bool - Whether to include a constant/intercept term in the model. - c_ : float - Estimated constant term (internal use). + Akaike Information Criterion for the fitted model. phi_ : np.ndarray - Coefficients for the non-seasonal autoregressive terms. + Coefficients for the non-seasonal autoregressive terms (length p). theta_ : np.ndarray - Coefficients for the non-seasonal moving average terms. + Coefficients for the non-seasonal moving average terms (length q). References ---------- @@ -76,80 +59,68 @@ class ARIMAForecaster(BaseForecaster): 474.49449... """ - def __init__( - self, - p: int = 1, - d: int = 0, - q: int = 1, - constant_term: bool = False, - ): - super().__init__(horizon=1, axis=1) - self.data_ = [] - self.differenced_data_ = [] - self.residuals_ = [] - self.fitted_values_ = [] - self.aic_ = 0 + _tags = { + "capability:horizon": False, + } + + def __init__(self, p: int = 1, d: int = 0, q: int = 1, use_constant: bool = False): self.p = p self.d = d self.q = q - self.constant_term = constant_term - self.p_ = 0 - self.d_ = 0 - self.q_ = 0 - self.constant_term_ = False - self.model_ = [] - self.c_ = 0 + self.use_constant = use_constant self.phi_ = 0 self.theta_ = 0 - self.parameters_ = [] + self._series = [] + self._differenced_series = [] + self.residuals_ = [] + self.fitted_values_ = [] + self.aic_ = 0 + self._model = [] + self._c = 0 + self._parameters = [] + super().__init__(horizon=1, axis=1) def _fit(self, y, exog=None): - """Fit AutoARIMA forecaster to series y. - - Fit a forecaster to predict self.horizon steps ahead using y. + """Fit ARIMA forecaster to series y to predict one ahead using y. Parameters ---------- y : np.ndarray A time series on which to learn a forecaster to predict horizon ahead exog : np.ndarray, default =None - Optional exogenous time series data assumed to be aligned with y + Not allowed for this forecaster Returns ------- self Fitted ARIMAForecaster. """ - self.p_ = self.p - self.d_ = self.d - self.q_ = self.q - self.constant_term_ = self.constant_term - self.data_ = np.array(y.squeeze(), dtype=np.float64) - self.model_ = np.array( - (1 if self.constant_term else 0, self.p, self.q), dtype=np.int32 + self._series = np.array(y.squeeze(), dtype=np.float64) + self._model = np.array( + (1 if self.use_constant else 0, self.p, self.q), dtype=np.int32 ) - self.differenced_data_ = np.diff(self.data_, n=self.d) - (self.parameters_, self.aic_) = nelder_mead( + self._differenced_series = np.diff(self._series, n=self.d) + (self._parameters, self.aic_) = nelder_mead( _arima_model_wrapper, - np.sum(self.model_[:3]), - self.differenced_data_, - self.model_, + np.sum(self._model[:3]), + self._differenced_series, + self._model, ) (self.c_, self.phi_, self.theta_) = _extract_params( - self.parameters_, self.model_ + self._parameters, self._model ) (self.aic_, self.residuals_, self.fitted_values_) = _arima_model( - self.parameters_, + self._parameters, _calc_arima, - self.differenced_data_, - self.model_, + self._differenced_series, + self._model, np.empty(0), ) return self def _predict(self, y=None, exog=None): """ - Predict the next horizon steps ahead. + Predict the next step ahead for training data or y. Parameters ---------- @@ -161,28 +132,28 @@ def _predict(self, y=None, exog=None): Returns ------- - array[float] - Predictions len(y) steps ahead of the data seen in fit. - If y is None, then predict 1 step ahead of the data seen in fit. + float + Prediction 1 step ahead of the data seen in fit or passed as y. """ if y is not None: - combined_data = np.concatenate((self.data_, y.flatten())) + series = y.squeeze() else: - combined_data = self.data_ - n = len(self.data_) - differenced_data = np.diff(combined_data, n=self.d_) - _aic, _residuals, predicted_values = _arima_model( - self.parameters_, + series = self._series + n = len(series) + differenced_series = np.diff(series, n=self.d) + _, _, predicted_values = _arima_model( + self._parameters, _calc_arima, - differenced_data, - self.model_, + differenced_series, + self._model, self.residuals_, ) - init = combined_data[n - self.d_ : n] + # Invert differences + init = series[n - self.d : n] x = np.concatenate((init, predicted_values)) - for _ in range(self.d_): + for _ in range(self.d): x = np.cumsum(x) - return x[self.d_ :] + return x[self.d :][0] @njit(cache=True, fastmath=True) From b91d135453b6e83d074866e38434305d21fc0dd2 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 16 Jun 2025 23:14:46 +0100 Subject: [PATCH 24/76] docstring --- aeon/forecasting/_arima.py | 49 ++++++++++++++++++++++++++++++-------- 1 file changed, 39 insertions(+), 10 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 0a6a2caec8..353137569d 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -36,10 +36,12 @@ class ARIMAForecaster(BaseForecaster): Residual errors from the fitted model. aic_ : float Akaike Information Criterion for the fitted model. + c_ : float, default = 0 + Intercept term. phi_ : np.ndarray - Coefficients for the non-seasonal autoregressive terms (length p). + Coefficients for autoregressive terms (length p). theta_ : np.ndarray - Coefficients for the non-seasonal moving average terms (length q). + Coefficients for moving average terms (length q). References ---------- @@ -53,9 +55,7 @@ class ARIMAForecaster(BaseForecaster): >>> from aeon.datasets import load_airline >>> y = load_airline() >>> forecaster = ARIMAForecaster(p=2,d=1) - >>> forecaster.fit(y) - ARIMAForecaster(d=1, p=2) - >>> forecaster.predict() + >>> forecaster.forecast(y) 474.49449... """ @@ -70,13 +70,13 @@ def __init__(self, p: int = 1, d: int = 0, q: int = 1, use_constant: bool = Fals self.use_constant = use_constant self.phi_ = 0 self.theta_ = 0 + self.c_ = 0 self._series = [] self._differenced_series = [] self.residuals_ = [] self.fitted_values_ = [] self.aic_ = 0 self._model = [] - self._c = 0 self._parameters = [] super().__init__(horizon=1, axis=1) @@ -100,6 +100,7 @@ def _fit(self, y, exog=None): (1 if self.use_constant else 0, self.p, self.q), dtype=np.int32 ) self._differenced_series = np.diff(self._series, n=self.d) + (self._parameters, self.aic_) = nelder_mead( _arima_model_wrapper, np.sum(self._model[:3]), @@ -137,10 +138,14 @@ def _predict(self, y=None, exog=None): """ if y is not None: series = y.squeeze() - else: - series = self._series - n = len(series) - differenced_series = np.diff(series, n=self.d) + # Difference the series using numpy + differenced_series = np.diff(self._series, n=self.d) + pred = _single_forecast(differenced_series, self.c_, self.phi_, self.theta_) + forecast = pred + series[-self.d :].sum() if self.d > 0 else pred + return forecast + + n = len(self._series) + differenced_series = np.diff(self._series, n=self.d) _, _, predicted_values = _arima_model( self._parameters, _calc_arima, @@ -242,3 +247,27 @@ def _calc_arima(data, model, t, formatted_params, residuals, expect_full_history c = formatted_params[0][0] if model[0] else 0 y_hat = c + ar_term + ma_term return y_hat + + +@njit(cache=True, fastmath=True) +def _single_forecast(series, c, phi, theta): + """Calculate the ARIMA forecast with fixed model. + + This is equivalent to filter in statsmodels. + """ + p = len(phi) + q = len(theta) + n = len(series) + residuals = np.zeros(n) + max_lag = max(p, q) + # Compute in-sample residuals + for t in range(max_lag, n): + ar_part = np.dot(phi, series[t - np.arange(1, p + 1)]) if p > 0 else 0.0 + ma_part = np.dot(theta, residuals[t - np.arange(1, q + 1)]) if q > 0 else 0.0 + pred = c + ar_part + ma_part + residuals[t] = series[t] - pred + # Forecast next value using most recent p values and q residuals + ar_forecast = np.dot(phi, series[-p:][::-1]) if p > 0 else 0.0 + ma_forecast = np.dot(theta, residuals[-q:][::-1]) if q > 0 else 0.0 + f = c + ar_forecast + ma_forecast + return f From 149c0ad972ad2e36f505363f695fd76c001e1b4d Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 21 Jun 2025 20:31:02 +0100 Subject: [PATCH 25/76] find forecast_ in fit --- aeon/forecasting/_arima.py | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 353137569d..094517dff5 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -60,7 +60,7 @@ class ARIMAForecaster(BaseForecaster): """ _tags = { - "capability:horizon": False, + "capability:horizon": False, # cannot fit to a horizon other than 1 } def __init__(self, p: int = 1, d: int = 0, q: int = 1, use_constant: bool = False): @@ -112,11 +112,19 @@ def _fit(self, y, exog=None): ) (self.aic_, self.residuals_, self.fitted_values_) = _arima_model( self._parameters, - _calc_arima, + _calc_arma, self._differenced_series, self._model, np.empty(0), ) + self.forecast_ = _calc_arma( + self._differenced_series, + self._model, + len(y), + self._parameters, + self.residuals_, + ) + return self def _predict(self, y=None, exog=None): @@ -148,7 +156,7 @@ def _predict(self, y=None, exog=None): differenced_series = np.diff(self._series, n=self.d) _, _, predicted_values = _arima_model( self._parameters, - _calc_arima, + _calc_arma, differenced_series, self._model, self.residuals_, @@ -160,6 +168,11 @@ def _predict(self, y=None, exog=None): x = np.cumsum(x) return x[self.d :][0] + def _forecast(self, y, exog=None): + """Forecast one ahead for time series y.""" + self.fit(y, exog) + return self.forecast_ + @njit(cache=True, fastmath=True) def _aic(residuals, num_params): @@ -171,7 +184,7 @@ def _aic(residuals, num_params): @njit(fastmath=True) def _arima_model_wrapper(params, data, model): - return _arima_model(params, _calc_arima, data, model, np.empty(0))[0] + return _arima_model(params, _calc_arma, data, model, np.empty(0))[0] # Define the ARIMA(p, d, q) likelihood function @@ -225,8 +238,8 @@ def _extract_params(params, model): @njit(cache=True, fastmath=True) -def _calc_arima(data, model, t, formatted_params, residuals, expect_full_history=False): - """Calculate the ARIMA forecast for time t.""" +def _calc_arma(data, model, t, formatted_params, residuals, expect_full_history=False): + """Calculate the ARMA forecast for time t.""" if len(model) != 3: raise ValueError("Model must be of the form (c, p, q)") p = model[1] From 9d8b24f243aaa1b38001df90d185d86c9aa21179 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 10 Jul 2025 19:53:06 +0100 Subject: [PATCH 26/76] remove optional y --- aeon/forecasting/__init__.py | 4 +++- aeon/forecasting/_arima.py | 18 +----------------- 2 files changed, 4 insertions(+), 18 deletions(-) diff --git a/aeon/forecasting/__init__.py b/aeon/forecasting/__init__.py index 0b134857dd..5b54dd2a19 100644 --- a/aeon/forecasting/__init__.py +++ b/aeon/forecasting/__init__.py @@ -1,13 +1,15 @@ """Forecasters.""" __all__ = [ - "NaiveForecaster", "BaseForecaster", + "NaiveForecaster", "RegressionForecaster", "ETSForecaster", "TVPForecaster", + "ARIMAForecaster", ] +from aeon.forecasting._arima import ARIMAForecaster from aeon.forecasting._ets import ETSForecaster from aeon.forecasting._naive import NaiveForecaster from aeon.forecasting._regression import RegressionForecaster diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 094517dff5..aed8c91f31 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -127,7 +127,7 @@ def _fit(self, y, exog=None): return self - def _predict(self, y=None, exog=None): + def _predict(self, y, exog=None): """ Predict the next step ahead for training data or y. @@ -152,22 +152,6 @@ def _predict(self, y=None, exog=None): forecast = pred + series[-self.d :].sum() if self.d > 0 else pred return forecast - n = len(self._series) - differenced_series = np.diff(self._series, n=self.d) - _, _, predicted_values = _arima_model( - self._parameters, - _calc_arma, - differenced_series, - self._model, - self.residuals_, - ) - # Invert differences - init = series[n - self.d : n] - x = np.concatenate((init, predicted_values)) - for _ in range(self.d): - x = np.cumsum(x) - return x[self.d :][0] - def _forecast(self, y, exog=None): """Forecast one ahead for time series y.""" self.fit(y, exog) From d9b1e7a6cd9c8405d209d24fd5f05e4712b527d1 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 10 Jul 2025 20:37:45 +0100 Subject: [PATCH 27/76] add iterative --- aeon/forecasting/_arima.py | 30 +++++++++++++++++++++--------- 1 file changed, 21 insertions(+), 9 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index aed8c91f31..f19445c02e 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -144,19 +144,31 @@ def _predict(self, y, exog=None): float Prediction 1 step ahead of the data seen in fit or passed as y. """ - if y is not None: - series = y.squeeze() - # Difference the series using numpy - differenced_series = np.diff(self._series, n=self.d) - pred = _single_forecast(differenced_series, self.c_, self.phi_, self.theta_) - forecast = pred + series[-self.d :].sum() if self.d > 0 else pred - return forecast + series = y.squeeze() + # Difference the series using numpy + differenced_series = np.diff(self._series, n=self.d) + pred = _single_forecast(differenced_series, self.c_, self.phi_, self.theta_) + forecast = pred + series[-self.d :].sum() if self.d > 0 else pred + # Need to undifference it! + return forecast def _forecast(self, y, exog=None): """Forecast one ahead for time series y.""" self.fit(y, exog) return self.forecast_ + def iterative_forecast(self, y, prediction_horizon): + self.fit(y) + preds = np.zeros(prediction_horizon) + preds[0] = self.forecast_ + differenced_series = np.diff(self._series, n=self.d) + for i in range(1, prediction_horizon): + differenced_series = np.append(differenced_series, preds[i - 1]) + preds[i] = _single_forecast( + differenced_series, self.c_, self.phi_, self.theta_ + ) + return preds + @njit(cache=True, fastmath=True) def _aic(residuals, num_params): @@ -248,9 +260,9 @@ def _calc_arma(data, model, t, formatted_params, residuals, expect_full_history= @njit(cache=True, fastmath=True) def _single_forecast(series, c, phi, theta): - """Calculate the ARIMA forecast with fixed model. + """Calculate the ARMA forecast with fixed model. - This is equivalent to filter in statsmodels. + This is equivalent to filter in statsmodels. Assumes differenced if necessary. """ p = len(phi) q = len(theta) From 2a962d8b36f2b3935ab9f665679f02f6fe445f9f Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Wed, 16 Jul 2025 17:55:15 +0100 Subject: [PATCH 28/76] typo --- aeon/forecasting/_arima.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index f19445c02e..2187ca6f74 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -174,8 +174,8 @@ def iterative_forecast(self, y, prediction_horizon): def _aic(residuals, num_params): """Calculate the log-likelihood of a model.""" variance = np.mean(residuals**2) - liklihood = len(residuals) * (np.log(2 * np.pi) + np.log(variance) + 1) - return liklihood + 2 * num_params + likelihood = len(residuals) * (np.log(2 * np.pi) + np.log(variance) + 1) + return likelihood + 2 * num_params @njit(fastmath=True) From c7616a4725d0b0327d34b98f7104897643c61e6d Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 17 Jul 2025 10:05:19 +0100 Subject: [PATCH 29/76] typo --- aeon/forecasting/_arima.py | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 2187ca6f74..960265e8e5 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -96,20 +96,23 @@ def _fit(self, y, exog=None): Fitted ARIMAForecaster. """ self._series = np.array(y.squeeze(), dtype=np.float64) + # Model is an array of the (c,p,q) self._model = np.array( (1 if self.use_constant else 0, self.p, self.q), dtype=np.int32 ) self._differenced_series = np.diff(self._series, n=self.d) - + # Nelder Mead returns the parameters in a single array (self._parameters, self.aic_) = nelder_mead( _arima_model_wrapper, np.sum(self._model[:3]), self._differenced_series, self._model, ) + # Extract the parameter values (self.c_, self.phi_, self.theta_) = _extract_params( self._parameters, self._model ) + # (self.aic_, self.residuals_, self.fitted_values_) = _arima_model( self._parameters, _calc_arma, @@ -117,13 +120,13 @@ def _fit(self, y, exog=None): self._model, np.empty(0), ) - self.forecast_ = _calc_arma( - self._differenced_series, - self._model, - len(y), - self._parameters, - self.residuals_, - ) + # self.forecast_ = _calc_arma( + # self._differenced_series, + # self._model, + # len(y), + # self._parameters, + # self.residuals_, + # ) return self From f29c809940512282c994ea0f3cc3bd1d9643984e Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 17 Jul 2025 11:57:57 +0100 Subject: [PATCH 30/76] calculate forecast_ --- aeon/forecasting/_arima.py | 44 +++++++++++++------------ aeon/utils/optimisation/_nelder_mead.py | 4 +-- 2 files changed, 25 insertions(+), 23 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 960265e8e5..a24391bd65 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -120,14 +120,23 @@ def _fit(self, y, exog=None): self._model, np.empty(0), ) - # self.forecast_ = _calc_arma( - # self._differenced_series, - # self._model, - # len(y), - # self._parameters, - # self.residuals_, - # ) + formatted_params = _extract_params(self._parameters, self._model) # Extract + # parameters + differenced_forecast = _calc_arma( + self._differenced_series, + self._model, + len(self._series), + formatted_params, + self.residuals_, + expect_full_history=True, + ) + if self.d == 0: + self.forecast_ = differenced_forecast + elif self.d == 1: + self.forecast_ = differenced_forecast + self._series[-1] + else: + self.forecast_ = differenced_forecast + np.sum(self._series[-self.d :]) return self def _predict(self, y, exog=None): @@ -152,7 +161,6 @@ def _predict(self, y, exog=None): differenced_series = np.diff(self._series, n=self.d) pred = _single_forecast(differenced_series, self.c_, self.phi_, self.theta_) forecast = pred + series[-self.d :].sum() if self.d > 0 else pred - # Need to undifference it! return forecast def _forecast(self, y, exog=None): @@ -218,13 +226,7 @@ def _arima_model(params, base_function, data, model, residuals): def _extract_params(params, model): """Extract ARIMA parameters from the parameter vector.""" if len(params) != np.sum(model): - previous_length = np.sum(model) model = model[:-1] # Remove the seasonal period - if len(params) != np.sum(model): - raise ValueError( - f"Expected {previous_length} parameters for a non-seasonal model or \ - {np.sum(model)} parameters for a seasonal model, got {len(params)}" - ) starts = np.cumsum(np.concatenate((np.zeros(1, dtype=np.int32), model[:-1]))) n = len(starts) max_len = np.max(model) @@ -239,15 +241,15 @@ def _extract_params(params, model): @njit(cache=True, fastmath=True) def _calc_arma(data, model, t, formatted_params, residuals, expect_full_history=False): """Calculate the ARMA forecast for time t.""" - if len(model) != 3: - raise ValueError("Model must be of the form (c, p, q)") + # if len(model) != 3: + # raise ValueError("Model must be of the form (c, p, q)") p = model[1] q = model[2] - if expect_full_history and (t - p < 0 or t - q < 0): - raise ValueError( - f"Insufficient data for ARIMA model at time {t}. " - f"Expected at least {p} past values for AR and {q} for MA." - ) + # if expect_full_history and (t - p < 0 or t - q < 0): + # raise ValueError( + # f"Insufficient data for ARIMA model at time {t}. " + # f"Expected at least {p} past values for AR and {q} for MA." + # ) # AR part phi = formatted_params[1][:p] ar_term = 0 if (t - p) < 0 else np.dot(phi, data[t - p : t][::-1]) diff --git a/aeon/utils/optimisation/_nelder_mead.py b/aeon/utils/optimisation/_nelder_mead.py index e59a70c5dd..47c629aeec 100644 --- a/aeon/utils/optimisation/_nelder_mead.py +++ b/aeon/utils/optimisation/_nelder_mead.py @@ -4,14 +4,14 @@ from numba import njit -@njit(fastmath=True) +@njit(cache=True, fastmath=True) def nelder_mead( loss_function, num_params, data, model, tol=1e-6, - max_iter=500, + max_iter=50, ): """ Perform optimisation using the Nelder–Mead simplex algorithm. From 5a2ee8daa75c5ad0f94346aaf3f7fc19cb7ece4e Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 17 Jul 2025 12:21:37 +0100 Subject: [PATCH 31/76] use differenced --- aeon/forecasting/_arima.py | 2 +- aeon/utils/optimisation/_nelder_mead.py | 2 +- pyproject.toml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index a24391bd65..4b1449a2c8 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -126,7 +126,7 @@ def _fit(self, y, exog=None): differenced_forecast = _calc_arma( self._differenced_series, self._model, - len(self._series), + len(self._differenced_series), formatted_params, self.residuals_, expect_full_history=True, diff --git a/aeon/utils/optimisation/_nelder_mead.py b/aeon/utils/optimisation/_nelder_mead.py index 47c629aeec..263365ef6f 100644 --- a/aeon/utils/optimisation/_nelder_mead.py +++ b/aeon/utils/optimisation/_nelder_mead.py @@ -11,7 +11,7 @@ def nelder_mead( data, model, tol=1e-6, - max_iter=50, + max_iter=500, ): """ Perform optimisation using the Nelder–Mead simplex algorithm. diff --git a/pyproject.toml b/pyproject.toml index b27cc4d00f..8965ccd402 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -169,7 +169,7 @@ testpaths = "aeon" doctest_optionflags = [ "NORMALIZE_WHITESPACE", "ELLIPSIS", - "FLOAT_CMP", +# "FLOAT_CMP", ] addopts = [ "--durations=20", From 42e699c4f0c764354a41bc5b8c6ae3b14aa72f6c Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 17 Jul 2025 12:56:51 +0100 Subject: [PATCH 32/76] example --- aeon/forecasting/_arima.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 4b1449a2c8..59ca908648 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -56,7 +56,7 @@ class ARIMAForecaster(BaseForecaster): >>> y = load_airline() >>> forecaster = ARIMAForecaster(p=2,d=1) >>> forecaster.forecast(y) - 474.49449... + np.float64(474.4944911737508) """ _tags = { From d1caed36bc1327141210e78e5d23650b9c040ba3 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 17 Jul 2025 15:48:11 +0100 Subject: [PATCH 33/76] iterative --- aeon/forecasting/_arima.py | 117 +++++++++++++++++++++++++++++-------- 1 file changed, 93 insertions(+), 24 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 59ca908648..cdaf56ea38 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -108,10 +108,6 @@ def _fit(self, y, exog=None): self._differenced_series, self._model, ) - # Extract the parameter values - (self.c_, self.phi_, self.theta_) = _extract_params( - self._parameters, self._model - ) # (self.aic_, self.residuals_, self.fitted_values_) = _arima_model( self._parameters, @@ -137,31 +133,72 @@ def _fit(self, y, exog=None): self.forecast_ = differenced_forecast + self._series[-1] else: self.forecast_ = differenced_forecast + np.sum(self._series[-self.d :]) + # Extract the parameter values + self.c_ = formatted_params[0][0] + self.phi_ = formatted_params[1][: self.p] + self.theta_ = formatted_params[2][: self.q] + return self def _predict(self, y, exog=None): """ - Predict the next step ahead for training data or y. + Predict the next step ahead for y. Parameters ---------- y : np.ndarray, default = None - A time series to predict the next horizon value for. If None, - predict the next horizon value after series seen in fit. + A time series to predict the value of. y can be independent of the series + seen in fit. exog : np.ndarray, default =None Optional exogenous time series data assumed to be aligned with y Returns ------- float - Prediction 1 step ahead of the data seen in fit or passed as y. + Prediction 1 step ahead of the last value in y. """ - series = y.squeeze() - # Difference the series using numpy - differenced_series = np.diff(self._series, n=self.d) - pred = _single_forecast(differenced_series, self.c_, self.phi_, self.theta_) - forecast = pred + series[-self.d :].sum() if self.d > 0 else pred - return forecast + y = y.squeeze() + p, q, d = self.p, self.q, self.d + phi, theta = self.phi_, self.theta_ + c = 0.0 + if self.use_constant: + c = self.c_ + + # Apply differencing + if d > 0: + if len(y) <= d: + raise ValueError("Series too short for differencing.") + y_diff = np.diff(y, n=d) + else: + y_diff = y + + n = len(y_diff) + if n < max(p, q): + raise ValueError("Series too short for ARMA(p,q) with given order.") + + # Estimate in-sample residuals using model (fixed parameters) + residuals = np.zeros(n) + for t in range(max(p, q), n): + ar_part = np.dot(phi, y_diff[t - np.arange(1, p + 1)]) if p > 0 else 0.0 + ma_part = ( + np.dot(theta, residuals[t - np.arange(1, q + 1)]) if q > 0 else 0.0 + ) + pred = c + ar_part + ma_part + residuals[t] = y_diff[t] - pred + + # Use most recent p values of y_diff and q values of residuals to forecast t+1 + ar_forecast = np.dot(phi, y_diff[-np.arange(1, p + 1)]) if p > 0 else 0.0 + ma_forecast = np.dot(theta, residuals[-np.arange(1, q + 1)]) if q > 0 else 0.0 + + forecast_diff = c + ar_forecast + ma_forecast + + # Undifference the forecast + if d == 0: + return forecast_diff + elif d == 1: + return forecast_diff + y[-1] + else: + return forecast_diff + np.sum(y[-d:]) def _forecast(self, y, exog=None): """Forecast one ahead for time series y.""" @@ -170,15 +207,47 @@ def _forecast(self, y, exog=None): def iterative_forecast(self, y, prediction_horizon): self.fit(y) - preds = np.zeros(prediction_horizon) - preds[0] = self.forecast_ - differenced_series = np.diff(self._series, n=self.d) - for i in range(1, prediction_horizon): - differenced_series = np.append(differenced_series, preds[i - 1]) - preds[i] = _single_forecast( - differenced_series, self.c_, self.phi_, self.theta_ - ) - return preds + n = len(self._differenced_series) + p, q = self.p, self.q + phi, theta = self.phi_, self.theta_ + h = prediction_horizon + c = 0.0 + if self.use_constant: + c = self.c_ + + # Start with a copy of the original series and residuals + residuals = np.zeros(len(self.residuals_) + h) + residuals[: len(self.residuals_)] = self.residuals_ + forecast_series = np.zeros(n + h) + forecast_series[:n] = self._differenced_series + for i in range(h): + # Get most recent p values (lags) + t = n + i + ar_term = 0.0 + if p > 0: + ar_term = np.dot(phi, forecast_series[t - np.arange(1, p + 1)]) + # Get most recent q residuals (lags) + ma_term = 0.0 + if q > 0: + ma_term = np.dot(theta, residuals[t - np.arange(1, q + 1)]) + next_value = c + ar_term + ma_term + # Append prediction and a zero residual (placeholder) + forecast_series[n + i] = next_value + # Can't compute real residual during prediction, leave as zero + + # Correct differencing using forecast values + y_forecast_diff = forecast_series[n : n + h] + d = self.d + if d == 0: + return y_forecast_diff + else: # Correct undifferencing + # Start with last d values from original y + undiff = list(self._series[-d:]) + for i in range(h): + # Take the last d values and sum them + reconstructed = y_forecast_diff[i] + sum(undiff[-d:]) + undiff.append(reconstructed) + return np.array(undiff[d:]) @njit(cache=True, fastmath=True) @@ -263,7 +332,7 @@ def _calc_arma(data, model, t, formatted_params, residuals, expect_full_history= return y_hat -@njit(cache=True, fastmath=True) +# @njit(cache=True, fastmath=True) def _single_forecast(series, c, phi, theta): """Calculate the ARMA forecast with fixed model. From 9f2a85da39eb572cd73717de667602da0e660391 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 17 Jul 2025 16:05:47 +0100 Subject: [PATCH 34/76] arima tests --- aeon/forecasting/__init__.py | 4 +- aeon/forecasting/_arima.py | 12 ++--- aeon/forecasting/tests/test_arima.py | 77 ++++++++++++++++++++++++++++ 3 files changed, 85 insertions(+), 8 deletions(-) create mode 100644 aeon/forecasting/tests/test_arima.py diff --git a/aeon/forecasting/__init__.py b/aeon/forecasting/__init__.py index 5b54dd2a19..7d7cb7e6c4 100644 --- a/aeon/forecasting/__init__.py +++ b/aeon/forecasting/__init__.py @@ -6,10 +6,10 @@ "RegressionForecaster", "ETSForecaster", "TVPForecaster", - "ARIMAForecaster", + "ARIMA", ] -from aeon.forecasting._arima import ARIMAForecaster +from aeon.forecasting._arima import ARIMA from aeon.forecasting._ets import ETSForecaster from aeon.forecasting._naive import NaiveForecaster from aeon.forecasting._regression import RegressionForecaster diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index cdaf56ea38..0ede9d27b9 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -1,10 +1,10 @@ -"""ARIMAForecaster. +"""ARIMA. An implementation of the ARIMA forecasting algorithm. """ __maintainer__ = ["alexbanwell1", "TonyBagnall"] -__all__ = ["ARIMAForecaster"] +__all__ = ["ARIMA"] import numpy as np from numba import njit @@ -13,7 +13,7 @@ from aeon.utils.optimisation._nelder_mead import nelder_mead -class ARIMAForecaster(BaseForecaster): +class ARIMA(BaseForecaster): """AutoRegressive Integrated Moving Average (ARIMA) forecaster. ARIMA with fixed model structure and fitted parameters found with an @@ -51,10 +51,10 @@ class ARIMAForecaster(BaseForecaster): Examples -------- - >>> from aeon.forecasting import ARIMAForecaster + >>> from aeon.forecasting import ARIMA >>> from aeon.datasets import load_airline >>> y = load_airline() - >>> forecaster = ARIMAForecaster(p=2,d=1) + >>> forecaster = ARIMA(p=2,d=1) >>> forecaster.forecast(y) np.float64(474.4944911737508) """ @@ -93,7 +93,7 @@ def _fit(self, y, exog=None): Returns ------- self - Fitted ARIMAForecaster. + Fitted ARIMA. """ self._series = np.array(y.squeeze(), dtype=np.float64) # Model is an array of the (c,p,q) diff --git a/aeon/forecasting/tests/test_arima.py b/aeon/forecasting/tests/test_arima.py new file mode 100644 index 0000000000..f0093aba93 --- /dev/null +++ b/aeon/forecasting/tests/test_arima.py @@ -0,0 +1,77 @@ +"""Test the ARIMA forecaster.""" + +import numpy as np +import pytest + +from aeon.forecasting import ARIMA as ARIMAForecaster + +y = np.array( + [112, 118, 132, 129, 121, 135, 148, 148, 136, 119, 104, 118], dtype=np.float64 +) + + +def test_arima_zero_orders(): + """Test ARIMA(0,0,0) which should return the mean if constant is used.""" + model = ARIMAForecaster(p=0, d=0, q=0, use_constant=True) + model.fit(y) + forecast = model.predict(y) + assert np.isfinite(forecast) + assert abs(forecast - np.mean(y)) < 10 + + +@pytest.mark.parametrize( + "p, d, q, use_constant", + [ + (1, 0, 1, True), # basic ARIMA + (2, 1, 1, False), # no constant + (1, 2, 1, True), # higher-order differencing + ], +) +def test_arima_fit_and_predict_variants(p, d, q, use_constant): + """Test ARIMA fit and predict for various (p,d,q) and use_constant settings.""" + model = ARIMAForecaster(p=p, d=d, q=q, use_constant=use_constant) + model.fit(y) + forecast = model.forecast_ + assert isinstance(forecast, float) + assert np.isfinite(forecast) + + +def test_arima_iterative_forecast(): + """Test multi-step forecasting using iterative_forecast method.""" + model = ARIMAForecaster(p=1, d=1, q=1) + horizon = 3 + preds = model.iterative_forecast(y, prediction_horizon=horizon) + assert preds.shape == (horizon,) + assert np.all(np.isfinite(preds)) + + +def test_predict_too_short_for_d(): + """Test error is raised when input series is too short for differencing.""" + model = ARIMAForecaster(p=1, d=2, q=1) + model.fit(y) + with pytest.raises(ValueError, match="Series too short for differencing"): + model._predict(np.array([1.0, 2.0])) + + +def test_predict_too_short_for_pq(): + """Test error is raised when input series is too short for AR/MA terms.""" + model = ARIMAForecaster(p=5, d=0, q=0) + model.fit(y) + with pytest.raises(ValueError, match="Series too short for ARMA"): + model._predict(np.array([1.0, 2.0, 3.0])) + + +def test_forecast_attribute_set(): + """Test that calling _forecast sets the internal forecast_ attribute.""" + model = ARIMAForecaster(p=1, d=1, q=1) + forecast = model._forecast(y) + assert hasattr(model, "forecast_") + assert np.isclose(forecast, model.forecast_) + + +def test_iterative_forecast_with_d2(): + """Test iterative forecast output shape and validity with d=2.""" + model = ARIMAForecaster(p=1, d=2, q=1) + preds = model.iterative_forecast(y, prediction_horizon=5) + assert preds.shape == (5,) + assert np.all(np.isfinite(preds)) From ca30d178354c123010fd04311c8ca6a10aee2687 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 17 Jul 2025 16:09:22 +0100 Subject: [PATCH 35/76] revert to float --- aeon/forecasting/_arima.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 0ede9d27b9..1ac062994e 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -56,7 +56,7 @@ class ARIMA(BaseForecaster): >>> y = load_airline() >>> forecaster = ARIMA(p=2,d=1) >>> forecaster.forecast(y) - np.float64(474.4944911737508) + 474.4944911737508 """ _tags = { @@ -203,7 +203,7 @@ def _predict(self, y, exog=None): def _forecast(self, y, exog=None): """Forecast one ahead for time series y.""" self.fit(y, exog) - return self.forecast_ + return float(self.forecast_) def iterative_forecast(self, y, prediction_horizon): self.fit(y) From 46d5ebc64e1325c74c40c33d0fff1e04afe54e4b Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 17 Jul 2025 16:19:30 +0100 Subject: [PATCH 36/76] switch nelder_mead version --- aeon/forecasting/_arima.py | 52 ++--------- aeon/forecasting/_nelder_mead.py | 119 ++++++++++++++++++++++++ aeon/forecasting/tests/test_arima.py | 16 ++-- aeon/utils/optimisation/_nelder_mead.py | 2 +- 4 files changed, 135 insertions(+), 54 deletions(-) create mode 100644 aeon/forecasting/_nelder_mead.py diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 1ac062994e..16129cfedd 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -9,8 +9,8 @@ import numpy as np from numba import njit +from aeon.forecasting._nelder_mead import nelder_mead from aeon.forecasting.base import BaseForecaster -from aeon.utils.optimisation._nelder_mead import nelder_mead class ARIMA(BaseForecaster): @@ -48,15 +48,6 @@ class ARIMA(BaseForecaster): .. [1] R. J. Hyndman and G. Athanasopoulos, Forecasting: Principles and Practice. OTexts, 2014. https://otexts.com/fpp3/ - - Examples - -------- - >>> from aeon.forecasting import ARIMA - >>> from aeon.datasets import load_airline - >>> y = load_airline() - >>> forecaster = ARIMA(p=2,d=1) - >>> forecaster.forecast(y) - 474.4944911737508 """ _tags = { @@ -111,7 +102,7 @@ def _fit(self, y, exog=None): # (self.aic_, self.residuals_, self.fitted_values_) = _arima_model( self._parameters, - _calc_arma, + _in_sample_forecast, self._differenced_series, self._model, np.empty(0), @@ -119,7 +110,7 @@ def _fit(self, y, exog=None): formatted_params = _extract_params(self._parameters, self._model) # Extract # parameters - differenced_forecast = _calc_arma( + differenced_forecast = _in_sample_forecast( self._differenced_series, self._model, len(self._differenced_series), @@ -260,7 +251,7 @@ def _aic(residuals, num_params): @njit(fastmath=True) def _arima_model_wrapper(params, data, model): - return _arima_model(params, _calc_arma, data, model, np.empty(0))[0] + return _arima_model(params, _in_sample_forecast, data, model, np.empty(0))[0] # Define the ARIMA(p, d, q) likelihood function @@ -308,17 +299,12 @@ def _extract_params(params, model): @njit(cache=True, fastmath=True) -def _calc_arma(data, model, t, formatted_params, residuals, expect_full_history=False): +def _in_sample_forecast( + data, model, t, formatted_params, residuals, expect_full_history=False +): """Calculate the ARMA forecast for time t.""" - # if len(model) != 3: - # raise ValueError("Model must be of the form (c, p, q)") p = model[1] q = model[2] - # if expect_full_history and (t - p < 0 or t - q < 0): - # raise ValueError( - # f"Insufficient data for ARIMA model at time {t}. " - # f"Expected at least {p} past values for AR and {q} for MA." - # ) # AR part phi = formatted_params[1][:p] ar_term = 0 if (t - p) < 0 else np.dot(phi, data[t - p : t][::-1]) @@ -330,27 +316,3 @@ def _calc_arma(data, model, t, formatted_params, residuals, expect_full_history= c = formatted_params[0][0] if model[0] else 0 y_hat = c + ar_term + ma_term return y_hat - - -# @njit(cache=True, fastmath=True) -def _single_forecast(series, c, phi, theta): - """Calculate the ARMA forecast with fixed model. - - This is equivalent to filter in statsmodels. Assumes differenced if necessary. - """ - p = len(phi) - q = len(theta) - n = len(series) - residuals = np.zeros(n) - max_lag = max(p, q) - # Compute in-sample residuals - for t in range(max_lag, n): - ar_part = np.dot(phi, series[t - np.arange(1, p + 1)]) if p > 0 else 0.0 - ma_part = np.dot(theta, residuals[t - np.arange(1, q + 1)]) if q > 0 else 0.0 - pred = c + ar_part + ma_part - residuals[t] = series[t] - pred - # Forecast next value using most recent p values and q residuals - ar_forecast = np.dot(phi, series[-p:][::-1]) if p > 0 else 0.0 - ma_forecast = np.dot(theta, residuals[-q:][::-1]) if q > 0 else 0.0 - f = c + ar_forecast + ma_forecast - return f diff --git a/aeon/forecasting/_nelder_mead.py b/aeon/forecasting/_nelder_mead.py new file mode 100644 index 0000000000..263365ef6f --- /dev/null +++ b/aeon/forecasting/_nelder_mead.py @@ -0,0 +1,119 @@ +"""Optimisation algorithms for automatic parameter tuning.""" + +import numpy as np +from numba import njit + + +@njit(cache=True, fastmath=True) +def nelder_mead( + loss_function, + num_params, + data, + model, + tol=1e-6, + max_iter=500, +): + """ + Perform optimisation using the Nelder–Mead simplex algorithm. + + This function minimises a given loss (objective) function using the Nelder–Mead + algorithm, a derivative-free method that iteratively refines a simplex of candidate + solutions. The implementation supports unconstrained minimisation of functions + with a fixed number of parameters. + + Parameters + ---------- + loss_function : callable + The objective function to minimise. Should accept a 1D NumPy array of length + `num_params` and return a scalar value. + num_params : int + The number of parameters (dimensions) in the optimisation problem. + data : np.ndarray + The input data used by the loss function. The shape and content depend on the + specific loss function being minimised. + model : np.ndarray + The model or context in which the loss function operates. This could be any + other object that the `loss_function` requires to compute its value. + The exact type and structure of `model` should be compatible with the + `loss_function`. + tol : float, optional (default=1e-6) + Tolerance for convergence. The algorithm stops when the maximum difference + between function values at simplex vertices is less than `tol`. + max_iter : int, optional (default=500) + Maximum number of iterations to perform. + + Returns + ------- + best_params : np.ndarray, shape (`num_params`,) + The parameter vector that minimises the loss function. + best_value : float + The value of the loss function at the optimal parameter vector. + + Notes + ----- + - The initial simplex is constructed by setting each parameter to 0.5, + with one additional point per dimension at 0.6 for that dimension. + - This implementation does not support constraints or bounds on the parameters. + - The algorithm does not guarantee finding a global minimum. + + References + ---------- + .. [1] Nelder, J. A. and Mead, R. (1965). + A Simplex Method for Function Minimization. + The Computer Journal, 7(4), 308–313. + https://doi.org/10.1093/comjnl/7.4.308 + """ + points = np.full((num_params + 1, num_params), 0.5) + for i in range(num_params): + points[i + 1][i] = 0.6 + values = np.array([loss_function(v, data, model) for v in points]) + for _iteration in range(max_iter): + # Order simplex by function values + order = np.argsort(values) + points = points[order] + values = values[order] + + # Centroid of the best n points + centre_point = points[:-1].sum(axis=0) / len(points[:-1]) + + # Reflection + # centre + distance between centre and largest value + reflected_point = centre_point + (centre_point - points[-1]) + reflected_value = loss_function(reflected_point, data, model) + # if between best and second best, use reflected value + if len(values) > 1 and values[0] <= reflected_value < values[-2]: + points[-1] = reflected_point + values[-1] = reflected_value + continue + # Expansion + # Otherwise if it is better than the best value + if reflected_value < values[0]: + expanded_point = centre_point + 2 * (reflected_point - centre_point) + expanded_value = loss_function(expanded_point, data, model) + # if less than reflected value use expanded, otherwise go back to reflected + if expanded_value < reflected_value: + points[-1] = expanded_point + values[-1] = expanded_value + else: + points[-1] = reflected_point + values[-1] = reflected_value + continue + # Contraction + # Otherwise if reflection is worse than all current values + contracted_point = centre_point - 0.5 * (centre_point - points[-1]) + contracted_value = loss_function(contracted_point, data, model) + # If contraction is better use that otherwise move to shrinkage + if contracted_value < values[-1]: + points[-1] = contracted_point + values[-1] = contracted_value + continue + + # Shrinkage + for i in range(1, len(points)): + points[i] = points[0] - 0.5 * (points[0] - points[i]) + values[i] = loss_function(points[i], data, model) + + # Convergence check + if np.max(np.abs(values - values[0])) < tol: + break + return points[0], values[0] diff --git a/aeon/forecasting/tests/test_arima.py b/aeon/forecasting/tests/test_arima.py index f0093aba93..ea78088021 100644 --- a/aeon/forecasting/tests/test_arima.py +++ b/aeon/forecasting/tests/test_arima.py @@ -3,7 +3,7 @@ import numpy as np import pytest -from aeon.forecasting import ARIMA as ARIMAForecaster +from aeon.forecasting import ARIMA y = np.array( [112, 118, 132, 129, 121, 135, 148, 148, 136, 119, 104, 118], dtype=np.float64 @@ -12,7 +12,7 @@ def test_arima_zero_orders(): """Test ARIMA(0,0,0) which should return the mean if constant is used.""" - model = ARIMAForecaster(p=0, d=0, q=0, use_constant=True) + model = ARIMA(p=0, d=0, q=0, use_constant=True) model.fit(y) forecast = model.predict(y) assert np.isfinite(forecast) @@ -29,7 +29,7 @@ def test_arima_zero_orders(): ) def test_arima_fit_and_predict_variants(p, d, q, use_constant): """Test ARIMA fit and predict for various (p,d,q) and use_constant settings.""" - model = ARIMAForecaster(p=p, d=d, q=q, use_constant=use_constant) + model = ARIMA(p=p, d=d, q=q, use_constant=use_constant) model.fit(y) forecast = model.forecast_ assert isinstance(forecast, float) @@ -38,7 +38,7 @@ def test_arima_fit_and_predict_variants(p, d, q, use_constant): def test_arima_iterative_forecast(): """Test multi-step forecasting using iterative_forecast method.""" - model = ARIMAForecaster(p=1, d=1, q=1) + model = ARIMA(p=1, d=1, q=1) horizon = 3 preds = model.iterative_forecast(y, prediction_horizon=horizon) assert preds.shape == (horizon,) @@ -47,7 +47,7 @@ def test_arima_iterative_forecast(): def test_predict_too_short_for_d(): """Test error is raised when input series is too short for differencing.""" - model = ARIMAForecaster(p=1, d=2, q=1) + model = ARIMA(p=1, d=2, q=1) model.fit(y) with pytest.raises(ValueError, match="Series too short for differencing"): model._predict(np.array([1.0, 2.0])) @@ -55,7 +55,7 @@ def test_predict_too_short_for_d(): def test_predict_too_short_for_pq(): """Test error is raised when input series is too short for AR/MA terms.""" - model = ARIMAForecaster(p=5, d=0, q=0) + model = ARIMA(p=5, d=0, q=0) model.fit(y) with pytest.raises(ValueError, match="Series too short for ARMA"): model._predict(np.array([1.0, 2.0, 3.0])) @@ -63,7 +63,7 @@ def test_predict_too_short_for_pq(): def test_forecast_attribute_set(): """Test that calling _forecast sets the internal forecast_ attribute.""" - model = ARIMAForecaster(p=1, d=1, q=1) + model = ARIMA(p=1, d=1, q=1) forecast = model._forecast(y) assert hasattr(model, "forecast_") assert np.isclose(forecast, model.forecast_) @@ -71,7 +71,7 @@ def test_forecast_attribute_set(): def test_iterative_forecast_with_d2(): """Test iterative forecast output shape and validity with d=2.""" - model = ARIMAForecaster(p=1, d=2, q=1) + model = ARIMA(p=1, d=2, q=1) preds = model.iterative_forecast(y, prediction_horizon=5) assert preds.shape == (5,) assert np.all(np.isfinite(preds)) diff --git a/aeon/utils/optimisation/_nelder_mead.py b/aeon/utils/optimisation/_nelder_mead.py index 263365ef6f..e59a70c5dd 100644 --- a/aeon/utils/optimisation/_nelder_mead.py +++ b/aeon/utils/optimisation/_nelder_mead.py @@ -4,7 +4,7 @@ from numba import njit -@njit(cache=True, fastmath=True) +@njit(fastmath=True) def nelder_mead( loss_function, num_params, From 9648b996b597e2f2f7e318527e482d692a91992f Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 17 Jul 2025 17:07:01 +0100 Subject: [PATCH 37/76] isolate loss function --- aeon/forecasting/_arima.py | 11 +---- aeon/forecasting/_loss_functions.py | 67 +++++++++++++++++++++++++++++ aeon/forecasting/_nelder_mead.py | 7 ++- 3 files changed, 72 insertions(+), 13 deletions(-) create mode 100644 aeon/forecasting/_loss_functions.py diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 16129cfedd..9336d3e526 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -94,7 +94,6 @@ def _fit(self, y, exog=None): self._differenced_series = np.diff(self._series, n=self.d) # Nelder Mead returns the parameters in a single array (self._parameters, self.aic_) = nelder_mead( - _arima_model_wrapper, np.sum(self._model[:3]), self._differenced_series, self._model, @@ -102,7 +101,6 @@ def _fit(self, y, exog=None): # (self.aic_, self.residuals_, self.fitted_values_) = _arima_model( self._parameters, - _in_sample_forecast, self._differenced_series, self._model, np.empty(0), @@ -249,14 +247,9 @@ def _aic(residuals, num_params): return likelihood + 2 * num_params -@njit(fastmath=True) -def _arima_model_wrapper(params, data, model): - return _arima_model(params, _in_sample_forecast, data, model, np.empty(0))[0] - - # Define the ARIMA(p, d, q) likelihood function @njit(cache=True, fastmath=True) -def _arima_model(params, base_function, data, model, residuals): +def _arima_model(params, data, model, residuals): """Calculate the log-likelihood of an ARIMA model given the parameters.""" formatted_params = _extract_params(params, model) # Extract parameters @@ -268,7 +261,7 @@ def _arima_model(params, base_function, data, model, residuals): expect_full_history = m > 0 # I.e. we've been provided with some residuals fitted_values = np.zeros(num_predictions) for t in range(num_predictions): - fitted_values[t] = base_function( + fitted_values[t] = _in_sample_forecast( data, model, m + t, diff --git a/aeon/forecasting/_loss_functions.py b/aeon/forecasting/_loss_functions.py new file mode 100644 index 0000000000..e8d1e21b00 --- /dev/null +++ b/aeon/forecasting/_loss_functions.py @@ -0,0 +1,67 @@ +"""Loss functions for optimiser.""" + +import numpy as np +from numba import njit + + +@njit(cache=True, fastmath=True) +def _arima_fit(params, data, model): + """Calculate the AIC of an ARIMA model given the parameters.""" + formatted_params = _extract_params(params, model) # Extract parameters + + # Initialize residuals + n = len(data) + residuals = np.zeros(n) + fitted_values = np.zeros(n) + for t in range(n): + fitted_values[t] = _in_sample_forecast( + data, + model, + t, + formatted_params, + residuals, + ) + residuals[t] = data[t] - fitted_values[t] + return _aic(residuals, len(params)) + + +@njit(cache=True, fastmath=True) +def _in_sample_forecast(data, model, t, formatted_params, residuals): + """Calculate the ARMA forecast for time t.""" + p = model[1] + q = model[2] + # AR part + phi = formatted_params[1][:p] + ar_term = 0 if (t - p) < 0 else np.dot(phi, data[t - p : t][::-1]) + + # MA part + theta = formatted_params[2][:q] + ma_term = 0 if (t - q) < 0 else np.dot(theta, residuals[t - q : t][::-1]) + + c = formatted_params[0][0] if model[0] else 0 + y_hat = c + ar_term + ma_term + return y_hat + + +@njit(cache=True, fastmath=True) +def _extract_params(params, model): + """Extract ARIMA parameters from the parameter vector.""" + if len(params) != np.sum(model): + model = model[:-1] # Remove the seasonal period + starts = np.cumsum(np.concatenate((np.zeros(1, dtype=np.int32), model[:-1]))) + n = len(starts) + max_len = np.max(model) + result = np.full((n, max_len), np.nan, dtype=params.dtype) + for i in range(n): + length = model[i] + start = starts[i] + result[i, :length] = params[start : start + length] + return result + + +@njit(cache=True, fastmath=True) +def _aic(residuals, num_params): + """Calculate the log-likelihood of a model.""" + variance = np.mean(residuals**2) + likelihood = len(residuals) * (np.log(2 * np.pi) + np.log(variance) + 1) + return likelihood + 2 * num_params diff --git a/aeon/forecasting/_nelder_mead.py b/aeon/forecasting/_nelder_mead.py index 263365ef6f..a5688989bb 100644 --- a/aeon/forecasting/_nelder_mead.py +++ b/aeon/forecasting/_nelder_mead.py @@ -3,10 +3,11 @@ import numpy as np from numba import njit +from aeon.forecasting._loss_functions import _arima_fit + @njit(cache=True, fastmath=True) def nelder_mead( - loss_function, num_params, data, model, @@ -23,9 +24,6 @@ def nelder_mead( Parameters ---------- - loss_function : callable - The objective function to minimise. Should accept a 1D NumPy array of length - `num_params` and return a scalar value. num_params : int The number of parameters (dimensions) in the optimisation problem. data : np.ndarray @@ -63,6 +61,7 @@ def nelder_mead( The Computer Journal, 7(4), 308–313. https://doi.org/10.1093/comjnl/7.4.308 """ + loss_function = _arima_fit points = np.full((num_params + 1, num_params), 0.5) for i in range(num_params): points[i + 1][i] = 0.6 From e8157d634b9101cd0e12aefc886cfc750d5d639a Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 17 Jul 2025 18:03:03 +0100 Subject: [PATCH 38/76] isolate loss function --- aeon/forecasting/_arima.py | 1 + aeon/forecasting/_loss_functions.py | 29 +++++++++++++++++++---------- aeon/forecasting/_nelder_mead.py | 26 +++++++++++++++++++------- 3 files changed, 39 insertions(+), 17 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 9336d3e526..42335fe7d4 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -94,6 +94,7 @@ def _fit(self, y, exog=None): self._differenced_series = np.diff(self._series, n=self.d) # Nelder Mead returns the parameters in a single array (self._parameters, self.aic_) = nelder_mead( + 0, np.sum(self._model[:3]), self._differenced_series, self._model, diff --git a/aeon/forecasting/_loss_functions.py b/aeon/forecasting/_loss_functions.py index e8d1e21b00..94edd410ce 100644 --- a/aeon/forecasting/_loss_functions.py +++ b/aeon/forecasting/_loss_functions.py @@ -13,20 +13,31 @@ def _arima_fit(params, data, model): n = len(data) residuals = np.zeros(n) fitted_values = np.zeros(n) + c = formatted_params[0][0] if model[0] else 0 + p = model[1] + q = model[2] + # AR part + phi = formatted_params[1][:p] + theta = formatted_params[2][:q] for t in range(n): - fitted_values[t] = _in_sample_forecast( - data, - model, - t, - formatted_params, - residuals, - ) + ar_term = 0 if (t - p) < 0 else np.dot(phi, data[t - p : t][::-1]) + ma_term = 0 if (t - q) < 0 else np.dot(theta, residuals[t - q : t][::-1]) + fitted_values[t] = c + ar_term + ma_term residuals[t] = data[t] - fitted_values[t] return _aic(residuals, len(params)) @njit(cache=True, fastmath=True) -def _in_sample_forecast(data, model, t, formatted_params, residuals): +def _in_sample_forecast( + data, + model, + t, + formatted_params, + residuals, + p, + q, + phi, +): """Calculate the ARMA forecast for time t.""" p = model[1] q = model[2] @@ -46,8 +57,6 @@ def _in_sample_forecast(data, model, t, formatted_params, residuals): @njit(cache=True, fastmath=True) def _extract_params(params, model): """Extract ARIMA parameters from the parameter vector.""" - if len(params) != np.sum(model): - model = model[:-1] # Remove the seasonal period starts = np.cumsum(np.concatenate((np.zeros(1, dtype=np.int32), model[:-1]))) n = len(starts) max_len = np.max(model) diff --git a/aeon/forecasting/_nelder_mead.py b/aeon/forecasting/_nelder_mead.py index a5688989bb..f617aa5727 100644 --- a/aeon/forecasting/_nelder_mead.py +++ b/aeon/forecasting/_nelder_mead.py @@ -6,8 +6,17 @@ from aeon.forecasting._loss_functions import _arima_fit +@njit(cache=True, fastmath=True) +def dispatch_loss(fn_id, params, data, model): + if fn_id == 0: + return _arima_fit(params, data, model) + else: + raise ValueError("Unknown loss function ID") + + @njit(cache=True, fastmath=True) def nelder_mead( + loss_id, num_params, data, model, @@ -24,6 +33,8 @@ def nelder_mead( Parameters ---------- + loss_id : int + ID for loss function to optimise, used by dispatch_loss. num_params : int The number of parameters (dimensions) in the optimisation problem. data : np.ndarray @@ -61,12 +72,13 @@ def nelder_mead( The Computer Journal, 7(4), 308–313. https://doi.org/10.1093/comjnl/7.4.308 """ - loss_function = _arima_fit points = np.full((num_params + 1, num_params), 0.5) for i in range(num_params): points[i + 1][i] = 0.6 - values = np.array([loss_function(v, data, model) for v in points]) - for _iteration in range(max_iter): + values = np.empty(len(points), dtype=np.float64) + for i in range(len(points)): + values[i] = dispatch_loss(loss_id, points[i].copy(), data, model) + for i in range(max_iter): # Order simplex by function values order = np.argsort(values) points = points[order] @@ -78,7 +90,7 @@ def nelder_mead( # Reflection # centre + distance between centre and largest value reflected_point = centre_point + (centre_point - points[-1]) - reflected_value = loss_function(reflected_point, data, model) + reflected_value = dispatch_loss(0, reflected_point, data, model) # if between best and second best, use reflected value if len(values) > 1 and values[0] <= reflected_value < values[-2]: points[-1] = reflected_point @@ -88,7 +100,7 @@ def nelder_mead( # Otherwise if it is better than the best value if reflected_value < values[0]: expanded_point = centre_point + 2 * (reflected_point - centre_point) - expanded_value = loss_function(expanded_point, data, model) + expanded_value = dispatch_loss(0, expanded_point, data, model) # if less than reflected value use expanded, otherwise go back to reflected if expanded_value < reflected_value: points[-1] = expanded_point @@ -100,7 +112,7 @@ def nelder_mead( # Contraction # Otherwise if reflection is worse than all current values contracted_point = centre_point - 0.5 * (centre_point - points[-1]) - contracted_value = loss_function(contracted_point, data, model) + contracted_value = dispatch_loss(0, contracted_point, data, model) # If contraction is better use that otherwise move to shrinkage if contracted_value < values[-1]: points[-1] = contracted_point @@ -110,7 +122,7 @@ def nelder_mead( # Shrinkage for i in range(1, len(points)): points[i] = points[0] - 0.5 * (points[0] - points[i]) - values[i] = loss_function(points[i], data, model) + values[i] = dispatch_loss(0, points[i], data, model) # Convergence check if np.max(np.abs(values - values[0])) < tol: From f45400c4bb7f0d7a7f52e6f8a666e9a42e386f0d Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 17 Jul 2025 18:19:30 +0100 Subject: [PATCH 39/76] remove the utils version of nelder mead --- aeon/utils/optimisation/__init__.py | 1 - aeon/utils/optimisation/_nelder_mead.py | 119 ------------------------ 2 files changed, 120 deletions(-) delete mode 100644 aeon/utils/optimisation/__init__.py delete mode 100644 aeon/utils/optimisation/_nelder_mead.py diff --git a/aeon/utils/optimisation/__init__.py b/aeon/utils/optimisation/__init__.py deleted file mode 100644 index 11eddea791..0000000000 --- a/aeon/utils/optimisation/__init__.py +++ /dev/null @@ -1 +0,0 @@ -"""Optimisation utils.""" diff --git a/aeon/utils/optimisation/_nelder_mead.py b/aeon/utils/optimisation/_nelder_mead.py deleted file mode 100644 index e59a70c5dd..0000000000 --- a/aeon/utils/optimisation/_nelder_mead.py +++ /dev/null @@ -1,119 +0,0 @@ -"""Optimisation algorithms for automatic parameter tuning.""" - -import numpy as np -from numba import njit - - -@njit(fastmath=True) -def nelder_mead( - loss_function, - num_params, - data, - model, - tol=1e-6, - max_iter=500, -): - """ - Perform optimisation using the Nelder–Mead simplex algorithm. - - This function minimises a given loss (objective) function using the Nelder–Mead - algorithm, a derivative-free method that iteratively refines a simplex of candidate - solutions. The implementation supports unconstrained minimisation of functions - with a fixed number of parameters. - - Parameters - ---------- - loss_function : callable - The objective function to minimise. Should accept a 1D NumPy array of length - `num_params` and return a scalar value. - num_params : int - The number of parameters (dimensions) in the optimisation problem. - data : np.ndarray - The input data used by the loss function. The shape and content depend on the - specific loss function being minimised. - model : np.ndarray - The model or context in which the loss function operates. This could be any - other object that the `loss_function` requires to compute its value. - The exact type and structure of `model` should be compatible with the - `loss_function`. - tol : float, optional (default=1e-6) - Tolerance for convergence. The algorithm stops when the maximum difference - between function values at simplex vertices is less than `tol`. - max_iter : int, optional (default=500) - Maximum number of iterations to perform. - - Returns - ------- - best_params : np.ndarray, shape (`num_params`,) - The parameter vector that minimises the loss function. - best_value : float - The value of the loss function at the optimal parameter vector. - - Notes - ----- - - The initial simplex is constructed by setting each parameter to 0.5, - with one additional point per dimension at 0.6 for that dimension. - - This implementation does not support constraints or bounds on the parameters. - - The algorithm does not guarantee finding a global minimum. - - References - ---------- - .. [1] Nelder, J. A. and Mead, R. (1965). - A Simplex Method for Function Minimization. - The Computer Journal, 7(4), 308–313. - https://doi.org/10.1093/comjnl/7.4.308 - """ - points = np.full((num_params + 1, num_params), 0.5) - for i in range(num_params): - points[i + 1][i] = 0.6 - values = np.array([loss_function(v, data, model) for v in points]) - for _iteration in range(max_iter): - # Order simplex by function values - order = np.argsort(values) - points = points[order] - values = values[order] - - # Centroid of the best n points - centre_point = points[:-1].sum(axis=0) / len(points[:-1]) - - # Reflection - # centre + distance between centre and largest value - reflected_point = centre_point + (centre_point - points[-1]) - reflected_value = loss_function(reflected_point, data, model) - # if between best and second best, use reflected value - if len(values) > 1 and values[0] <= reflected_value < values[-2]: - points[-1] = reflected_point - values[-1] = reflected_value - continue - # Expansion - # Otherwise if it is better than the best value - if reflected_value < values[0]: - expanded_point = centre_point + 2 * (reflected_point - centre_point) - expanded_value = loss_function(expanded_point, data, model) - # if less than reflected value use expanded, otherwise go back to reflected - if expanded_value < reflected_value: - points[-1] = expanded_point - values[-1] = expanded_value - else: - points[-1] = reflected_point - values[-1] = reflected_value - continue - # Contraction - # Otherwise if reflection is worse than all current values - contracted_point = centre_point - 0.5 * (centre_point - points[-1]) - contracted_value = loss_function(contracted_point, data, model) - # If contraction is better use that otherwise move to shrinkage - if contracted_value < values[-1]: - points[-1] = contracted_point - values[-1] = contracted_value - continue - - # Shrinkage - for i in range(1, len(points)): - points[i] = points[0] - 0.5 * (points[0] - points[i]) - values[i] = loss_function(points[i], data, model) - - # Convergence check - if np.max(np.abs(values - values[0])) < tol: - break - return points[0], values[0] From 150998907d852c8265d10e529166bec433999344 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 19 Jul 2025 09:45:55 +0100 Subject: [PATCH 40/76] set self.c_ correctly --- aeon/forecasting/_arima.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 42335fe7d4..cdd0ab30d2 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -124,7 +124,8 @@ def _fit(self, y, exog=None): else: self.forecast_ = differenced_forecast + np.sum(self._series[-self.d :]) # Extract the parameter values - self.c_ = formatted_params[0][0] + if self.use_constant: + self.c_ = formatted_params[0][0] self.phi_ = formatted_params[1][: self.p] self.theta_ = formatted_params[2][: self.q] From a2578d9a8685e2b2713582f0ebea0a78cfac5815 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 19 Jul 2025 12:12:56 +0100 Subject: [PATCH 41/76] numba optimise --- aeon/forecasting/_arima.py | 33 ++++------------ aeon/forecasting/_loss_functions.py | 58 +++++++---------------------- 2 files changed, 22 insertions(+), 69 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index cdd0ab30d2..1a974d1930 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -104,19 +104,11 @@ def _fit(self, y, exog=None): self._parameters, self._differenced_series, self._model, - np.empty(0), ) formatted_params = _extract_params(self._parameters, self._model) # Extract # parameters + differenced_forecast = self.fitted_values_[-1] - differenced_forecast = _in_sample_forecast( - self._differenced_series, - self._model, - len(self._differenced_series), - formatted_params, - self.residuals_, - expect_full_history=True, - ) if self.d == 0: self.forecast_ = differenced_forecast elif self.d == 1: @@ -251,29 +243,22 @@ def _aic(residuals, num_params): # Define the ARIMA(p, d, q) likelihood function @njit(cache=True, fastmath=True) -def _arima_model(params, data, model, residuals): +def _arima_model(params, data, model): """Calculate the log-likelihood of an ARIMA model given the parameters.""" formatted_params = _extract_params(params, model) # Extract parameters # Initialize residuals n = len(data) - m = len(residuals) - num_predictions = n - m + 1 - residuals = np.concatenate((residuals, np.zeros(num_predictions - 1))) - expect_full_history = m > 0 # I.e. we've been provided with some residuals + num_predictions = n + 1 + residuals = np.zeros(num_predictions - 1) fitted_values = np.zeros(num_predictions) for t in range(num_predictions): fitted_values[t] = _in_sample_forecast( - data, - model, - m + t, - formatted_params, - residuals, - expect_full_history, + data, model, t, formatted_params, residuals ) if t != num_predictions - 1: # Only calculate residuals for the predictions we have data for - residuals[m + t] = data[m + t] - fitted_values[t] + residuals[t] = data[t] - fitted_values[t] return _aic(residuals, len(params)), residuals, fitted_values @@ -294,10 +279,8 @@ def _extract_params(params, model): @njit(cache=True, fastmath=True) -def _in_sample_forecast( - data, model, t, formatted_params, residuals, expect_full_history=False -): - """Calculate the ARMA forecast for time t.""" +def _in_sample_forecast(data, model, t, formatted_params, residuals): + """Calculate the ARMA forecast for time t for fitted model.""" p = model[1] q = model[2] # AR part diff --git a/aeon/forecasting/_loss_functions.py b/aeon/forecasting/_loss_functions.py index 94edd410ce..546846eb09 100644 --- a/aeon/forecasting/_loss_functions.py +++ b/aeon/forecasting/_loss_functions.py @@ -12,46 +12,24 @@ def _arima_fit(params, data, model): # Initialize residuals n = len(data) residuals = np.zeros(n) - fitted_values = np.zeros(n) c = formatted_params[0][0] if model[0] else 0 p = model[1] q = model[2] - # AR part - phi = formatted_params[1][:p] - theta = formatted_params[2][:q] for t in range(n): - ar_term = 0 if (t - p) < 0 else np.dot(phi, data[t - p : t][::-1]) - ma_term = 0 if (t - q) < 0 else np.dot(theta, residuals[t - q : t][::-1]) - fitted_values[t] = c + ar_term + ma_term - residuals[t] = data[t] - fitted_values[t] - return _aic(residuals, len(params)) - - -@njit(cache=True, fastmath=True) -def _in_sample_forecast( - data, - model, - t, - formatted_params, - residuals, - p, - q, - phi, -): - """Calculate the ARMA forecast for time t.""" - p = model[1] - q = model[2] - # AR part - phi = formatted_params[1][:p] - ar_term = 0 if (t - p) < 0 else np.dot(phi, data[t - p : t][::-1]) - - # MA part - theta = formatted_params[2][:q] - ma_term = 0 if (t - q) < 0 else np.dot(theta, residuals[t - q : t][::-1]) - - c = formatted_params[0][0] if model[0] else 0 - y_hat = c + ar_term + ma_term - return y_hat + ar_term = 0 + max_ar = min(p, t) + for j in range(max_ar): + ar_term += formatted_params[1, j] * data[t - j - 1] + ma_term = 0 + max_ma = min(q, t) + for j in range(max_ma): + ma_term += formatted_params[2, j] * residuals[t - j - 1] + y_hat = c + ar_term + ma_term + residuals[t] = data[t] - y_hat + variance = np.mean(residuals**2) + LOG_2PI = 1.8378770664093453 + likelihood = n * (LOG_2PI + np.log(variance) + 1.0) + return likelihood + 2 * len(params) @njit(cache=True, fastmath=True) @@ -66,11 +44,3 @@ def _extract_params(params, model): start = starts[i] result[i, :length] = params[start : start + length] return result - - -@njit(cache=True, fastmath=True) -def _aic(residuals, num_params): - """Calculate the log-likelihood of a model.""" - variance = np.mean(residuals**2) - likelihood = len(residuals) * (np.log(2 * np.pi) + np.log(variance) + 1) - return likelihood + 2 * num_params From 35e5b1c1a12bfd1fd992cea91c91f8d3baf293f0 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 19 Jul 2025 12:17:05 +0100 Subject: [PATCH 42/76] numba optimise --- aeon/forecasting/_loss_functions.py | 34 ++++++++++++++++++++--------- 1 file changed, 24 insertions(+), 10 deletions(-) diff --git a/aeon/forecasting/_loss_functions.py b/aeon/forecasting/_loss_functions.py index 546846eb09..ef4fb30e55 100644 --- a/aeon/forecasting/_loss_functions.py +++ b/aeon/forecasting/_loss_functions.py @@ -3,6 +3,8 @@ import numpy as np from numba import njit +LOG_2PI = 1.8378770664093453 + @njit(cache=True, fastmath=True) def _arima_fit(params, data, model): @@ -16,31 +18,43 @@ def _arima_fit(params, data, model): p = model[1] q = model[2] for t in range(n): - ar_term = 0 + ar_term = 0.0 max_ar = min(p, t) for j in range(max_ar): ar_term += formatted_params[1, j] * data[t - j - 1] - ma_term = 0 + ma_term = 0.0 max_ma = min(q, t) for j in range(max_ma): ma_term += formatted_params[2, j] * residuals[t - j - 1] y_hat = c + ar_term + ma_term residuals[t] = data[t] - y_hat - variance = np.mean(residuals**2) - LOG_2PI = 1.8378770664093453 + sse = 0.0 + for i in range(n): + sse += residuals[i] ** 2 + variance = sse / n likelihood = n * (LOG_2PI + np.log(variance) + 1.0) - return likelihood + 2 * len(params) + k = len(params) + return likelihood + 2 * k @njit(cache=True, fastmath=True) def _extract_params(params, model): """Extract ARIMA parameters from the parameter vector.""" - starts = np.cumsum(np.concatenate((np.zeros(1, dtype=np.int32), model[:-1]))) - n = len(starts) + n_parts = len(model) + starts = np.zeros(n_parts, dtype=np.int32) + for i in range(1, n_parts): + starts[i] = starts[i - 1] + model[i - 1] + max_len = np.max(model) - result = np.full((n, max_len), np.nan, dtype=params.dtype) - for i in range(n): + result = np.empty((n_parts, max_len), dtype=params.dtype) + for i in range(n_parts): + for j in range(max_len): + result[i, j] = np.nan + + for i in range(n_parts): length = model[i] start = starts[i] - result[i, :length] = params[start : start + length] + for j in range(length): + result[i, j] = params[start + j] + return result From 79c8c2d521f1f191c510995df858b637be455b79 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 19 Jul 2025 13:01:26 +0100 Subject: [PATCH 43/76] numba optimise --- aeon/forecasting/_arima.py | 58 ++++++++++++++--------------- aeon/forecasting/_loss_functions.py | 27 ++------------ 2 files changed, 31 insertions(+), 54 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 1a974d1930..941e97d694 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -9,6 +9,7 @@ import numpy as np from numba import njit +from aeon.forecasting._extract_paras import _extract_arma_params from aeon.forecasting._nelder_mead import nelder_mead from aeon.forecasting.base import BaseForecaster @@ -27,8 +28,10 @@ class ARIMA(BaseForecaster): Differencing (d) order of the ARIMA model q : int, default=1, Moving average (q) order of the ARIMA model - use_constant: bool = False, + use_constant : bool = False, Presence of a constant/intercept term in the model. + iterations : int, default = 200 + Maximum number of iterations to use in the Nelder-Mead parameter search. Attributes ---------- @@ -54,11 +57,19 @@ class ARIMA(BaseForecaster): "capability:horizon": False, # cannot fit to a horizon other than 1 } - def __init__(self, p: int = 1, d: int = 0, q: int = 1, use_constant: bool = False): + def __init__( + self, + p: int = 1, + d: int = 0, + q: int = 1, + use_constant: bool = False, + iterations: int = 200, + ): self.p = p self.d = d self.q = q self.use_constant = use_constant + self.iterations = iterations self.phi_ = 0 self.theta_ = 0 self.c_ = 0 @@ -98,6 +109,7 @@ def _fit(self, y, exog=None): np.sum(self._model[:3]), self._differenced_series, self._model, + max_iter=self.iterations, ) # (self.aic_, self.residuals_, self.fitted_values_) = _arima_model( @@ -105,7 +117,9 @@ def _fit(self, y, exog=None): self._differenced_series, self._model, ) - formatted_params = _extract_params(self._parameters, self._model) # Extract + formatted_params = _extract_arma_params( + self._parameters, self._model + ) # Extract # parameters differenced_forecast = self.fitted_values_[-1] @@ -245,7 +259,7 @@ def _aic(residuals, num_params): @njit(cache=True, fastmath=True) def _arima_model(params, data, model): """Calculate the log-likelihood of an ARIMA model given the parameters.""" - formatted_params = _extract_params(params, model) # Extract parameters + formatted_params = _extract_arma_params(params, model) # Extract parameters # Initialize residuals n = len(data) @@ -262,35 +276,19 @@ def _arima_model(params, data, model): return _aic(residuals, len(params)), residuals, fitted_values -@njit(cache=True, fastmath=True) -def _extract_params(params, model): - """Extract ARIMA parameters from the parameter vector.""" - if len(params) != np.sum(model): - model = model[:-1] # Remove the seasonal period - starts = np.cumsum(np.concatenate((np.zeros(1, dtype=np.int32), model[:-1]))) - n = len(starts) - max_len = np.max(model) - result = np.full((n, max_len), np.nan, dtype=params.dtype) - for i in range(n): - length = model[i] - start = starts[i] - result[i, :length] = params[start : start + length] - return result - - @njit(cache=True, fastmath=True) def _in_sample_forecast(data, model, t, formatted_params, residuals): - """Calculate the ARMA forecast for time t for fitted model.""" + """Efficient ARMA one-step forecast at time t for fitted model.""" p = model[1] q = model[2] - # AR part - phi = formatted_params[1][:p] - ar_term = 0 if (t - p) < 0 else np.dot(phi, data[t - p : t][::-1]) + c = formatted_params[0][0] if model[0] else 0.0 + + ar_term = 0.0 + for j in range(min(p, t)): + ar_term += formatted_params[1, j] * data[t - j - 1] - # MA part - theta = formatted_params[2][:q] - ma_term = 0 if (t - q) < 0 else np.dot(theta, residuals[t - q : t][::-1]) + ma_term = 0.0 + for j in range(min(q, t)): + ma_term += formatted_params[2, j] * residuals[t - j - 1] - c = formatted_params[0][0] if model[0] else 0 - y_hat = c + ar_term + ma_term - return y_hat + return c + ar_term + ma_term diff --git a/aeon/forecasting/_loss_functions.py b/aeon/forecasting/_loss_functions.py index ef4fb30e55..ec2c5faaa4 100644 --- a/aeon/forecasting/_loss_functions.py +++ b/aeon/forecasting/_loss_functions.py @@ -3,13 +3,15 @@ import numpy as np from numba import njit +from aeon.forecasting._extract_paras import _extract_arma_params + LOG_2PI = 1.8378770664093453 @njit(cache=True, fastmath=True) def _arima_fit(params, data, model): """Calculate the AIC of an ARIMA model given the parameters.""" - formatted_params = _extract_params(params, model) # Extract parameters + formatted_params = _extract_arma_params(params, model) # Extract parameters # Initialize residuals n = len(data) @@ -35,26 +37,3 @@ def _arima_fit(params, data, model): likelihood = n * (LOG_2PI + np.log(variance) + 1.0) k = len(params) return likelihood + 2 * k - - -@njit(cache=True, fastmath=True) -def _extract_params(params, model): - """Extract ARIMA parameters from the parameter vector.""" - n_parts = len(model) - starts = np.zeros(n_parts, dtype=np.int32) - for i in range(1, n_parts): - starts[i] = starts[i - 1] + model[i - 1] - - max_len = np.max(model) - result = np.empty((n_parts, max_len), dtype=params.dtype) - for i in range(n_parts): - for j in range(max_len): - result[i, j] = np.nan - - for i in range(n_parts): - length = model[i] - start = starts[i] - for j in range(length): - result[i, j] = params[start + j] - - return result From fc4f7044b900bc724286d312638e9b38f060880e Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Wed, 23 Jul 2025 13:37:04 +0100 Subject: [PATCH 44/76] Add missing _extract_paras file --- aeon/forecasting/_extract_paras.py | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 aeon/forecasting/_extract_paras.py diff --git a/aeon/forecasting/_extract_paras.py b/aeon/forecasting/_extract_paras.py new file mode 100644 index 0000000000..2e38a3e4dd --- /dev/null +++ b/aeon/forecasting/_extract_paras.py @@ -0,0 +1,27 @@ +"""ARIMA Utility Function.""" + +import numpy as np +from numba import njit + + +@njit(cache=True, fastmath=True) +def _extract_arma_params(params, model): + """Extract ARIMA parameters from the parameter vector.""" + n_parts = len(model) + starts = np.zeros(n_parts, dtype=np.int32) + for i in range(1, n_parts): + starts[i] = starts[i - 1] + model[i - 1] + + max_len = np.max(model) + result = np.empty((n_parts, max_len), dtype=params.dtype) + for i in range(n_parts): + for j in range(max_len): + result[i, j] = np.nan + + for i in range(n_parts): + length = model[i] + start = starts[i] + for j in range(length): + result[i, j] = params[start + j] + + return result From 724992b3d045b1d2aafc55a1648b6af459a92eec Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 26 Jul 2025 14:41:28 +0100 Subject: [PATCH 45/76] initial residuals bug and proper differencing d>1 --- aeon/forecasting/_arima.py | 19 ++++++--- aeon/forecasting/tests/test_arima.py | 62 ++++++++++++++++++++++------ 2 files changed, 62 insertions(+), 19 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 941e97d694..6f08af4325 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -124,12 +124,18 @@ def _fit(self, y, exog=None): differenced_forecast = self.fitted_values_[-1] if self.d == 0: - self.forecast_ = differenced_forecast + forecast_value = differenced_forecast elif self.d == 1: - self.forecast_ = differenced_forecast + self._series[-1] - else: - self.forecast_ = differenced_forecast + np.sum(self._series[-self.d :]) - # Extract the parameter values + forecast_value = differenced_forecast + self._series[-1] + else: # for d > 1, iteratively undifference + forecast_value = differenced_forecast + last_vals = self._series[-self.d :] + for _ in range(self.d): + forecast_value += last_vals[-1] - last_vals[-2] + # Shift values to avoid appending to list (efficient) + last_vals = np.roll(last_vals, -1) + last_vals[-1] = forecast_value # Extract the parameter values + self.forecast_ = forecast_value if self.use_constant: self.c_ = formatted_params[0][0] self.phi_ = formatted_params[1][: self.p] @@ -266,7 +272,8 @@ def _arima_model(params, data, model): num_predictions = n + 1 residuals = np.zeros(num_predictions - 1) fitted_values = np.zeros(num_predictions) - for t in range(num_predictions): + # Leave first max(p,q) residuals and fitted as zero. + for t in range(max(model[1], model[2]), num_predictions): fitted_values[t] = _in_sample_forecast( data, model, t, formatted_params, residuals ) diff --git a/aeon/forecasting/tests/test_arima.py b/aeon/forecasting/tests/test_arima.py index ea78088021..50528a81cf 100644 --- a/aeon/forecasting/tests/test_arima.py +++ b/aeon/forecasting/tests/test_arima.py @@ -45,20 +45,19 @@ def test_arima_iterative_forecast(): assert np.all(np.isfinite(preds)) -def test_predict_too_short_for_d(): - """Test error is raised when input series is too short for differencing.""" - model = ARIMA(p=1, d=2, q=1) - model.fit(y) - with pytest.raises(ValueError, match="Series too short for differencing"): - model._predict(np.array([1.0, 2.0])) - - -def test_predict_too_short_for_pq(): - """Test error is raised when input series is too short for AR/MA terms.""" - model = ARIMA(p=5, d=0, q=0) +@pytest.mark.parametrize( + "y_input, error_match", + [ + (np.array([1.0, 2.0]), "Series too short for differencing"), + (np.array([1.0, 2.0, 3.0]), "Series too short for ARMA"), + ], +) +def test_arima_too_short_series_errors(y_input, error_match): + """Test errors raised for too short input series.""" + model = ARIMA(p=3, d=2, q=3) model.fit(y) - with pytest.raises(ValueError, match="Series too short for ARMA"): - model._predict(np.array([1.0, 2.0, 3.0])) + with pytest.raises(ValueError, match=error_match): + model._predict(y_input) def test_forecast_attribute_set(): @@ -75,3 +74,40 @@ def test_iterative_forecast_with_d2(): preds = model.iterative_forecast(y, prediction_horizon=5) assert preds.shape == (5,) assert np.all(np.isfinite(preds)) + + +@pytest.mark.parametrize( + "p, d, q, use_constant, expected_forecast", + [ + (1, 0, 1, False, 118.47506756), # precomputed from known ARIMA implementation + (2, 1, 1, False, 202.1120270), # precomputed + (3, 0, 0, True, 125.2778775), # precomputed + ], +) +def test_arima_fixed_paras(p, d, q, use_constant, expected_forecast): + """Test ARIMA fit/predict accuracy against known forecasts. + + expected values calculated with values fitted by Nelder-Mead: + + 1. phi = [0.99497524] theta [0.0691515] + 2. phi = [ 0.02898788 -0.4330671 ] theta [1.26699252] + 3. phi = [ 0.19202414 0.05207654 -0.07367897] theta [], constant 105.970867164 + + """ + model = ARIMA(p=p, d=d, q=q, use_constant=use_constant) + model.fit(y) + forecast = model.forecast_ + assert isinstance(forecast, float) + assert np.isfinite(forecast) + assert np.isclose(forecast, expected_forecast, atol=0.5) + + +def test_arima_known_output(): + """Test ARIMA for fixed parameters. + + Test ARMIMA with forecast generated externally. + """ + model = ARIMA(p=1, d=0, q=1) + model.fit(y) + f = model.forecast_ + assert np.isclose(118.47506756, f) From 755f927e6ef9fcd55defa03b377c4d7290f0e210 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sun, 27 Jul 2025 17:33:28 +0100 Subject: [PATCH 46/76] loss function ignores zeroed start points --- aeon/forecasting/_loss_functions.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/aeon/forecasting/_loss_functions.py b/aeon/forecasting/_loss_functions.py index ec2c5faaa4..c88211b645 100644 --- a/aeon/forecasting/_loss_functions.py +++ b/aeon/forecasting/_loss_functions.py @@ -31,9 +31,10 @@ def _arima_fit(params, data, model): y_hat = c + ar_term + ma_term residuals[t] = data[t] - y_hat sse = 0.0 - for i in range(n): - sse += residuals[i] ** 2 - variance = sse / n - likelihood = n * (LOG_2PI + np.log(variance) + 1.0) + start = max(p, q) + for i in range(start, n): + sse += residuals[i] * residuals[i] + variance = sse / (n - start) + likelihood = (n - start) * (LOG_2PI + np.log(variance) + 1.0) k = len(params) return likelihood + 2 * k From f2181067204390a9c43cb4b57115878d5cc67810 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 28 Jul 2025 09:27:47 +0100 Subject: [PATCH 47/76] fix test --- aeon/forecasting/tests/test_arima.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/aeon/forecasting/tests/test_arima.py b/aeon/forecasting/tests/test_arima.py index 50528a81cf..73d99d7b50 100644 --- a/aeon/forecasting/tests/test_arima.py +++ b/aeon/forecasting/tests/test_arima.py @@ -80,8 +80,8 @@ def test_iterative_forecast_with_d2(): "p, d, q, use_constant, expected_forecast", [ (1, 0, 1, False, 118.47506756), # precomputed from known ARIMA implementation - (2, 1, 1, False, 202.1120270), # precomputed - (3, 0, 0, True, 125.2778775), # precomputed + (2, 1, 1, False, 209.1099231455), # precomputed + (3, 0, 0, True, 137.47368045155), # precomputed ], ) def test_arima_fixed_paras(p, d, q, use_constant, expected_forecast): @@ -99,7 +99,7 @@ def test_arima_fixed_paras(p, d, q, use_constant, expected_forecast): forecast = model.forecast_ assert isinstance(forecast, float) assert np.isfinite(forecast) - assert np.isclose(forecast, expected_forecast, atol=0.5) + assert np.isclose(forecast, expected_forecast, atol=1e-6) def test_arima_known_output(): From 6a13e4f6b11e8d3f0ab39ac151f6d6e2988ce061 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 28 Jul 2025 09:41:43 +0100 Subject: [PATCH 48/76] revert FLOAT_CMP --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 8965ccd402..b27cc4d00f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -169,7 +169,7 @@ testpaths = "aeon" doctest_optionflags = [ "NORMALIZE_WHITESPACE", "ELLIPSIS", -# "FLOAT_CMP", + "FLOAT_CMP", ] addopts = [ "--durations=20", From 9721a5ca64b81c60b61cad1ff75e775da8758590 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 28 Jul 2025 10:16:52 +0100 Subject: [PATCH 49/76] refactor into forecasting --- aeon/{utils => }/forecasting/_hypo_tests.py | 2 +- aeon/{utils => }/forecasting/_seasonality.py | 0 aeon/utils/forecasting/__init__.py | 1 - 3 files changed, 1 insertion(+), 2 deletions(-) rename aeon/{utils => }/forecasting/_hypo_tests.py (98%) rename aeon/{utils => }/forecasting/_seasonality.py (100%) delete mode 100644 aeon/utils/forecasting/__init__.py diff --git a/aeon/utils/forecasting/_hypo_tests.py b/aeon/forecasting/_hypo_tests.py similarity index 98% rename from aeon/utils/forecasting/_hypo_tests.py rename to aeon/forecasting/_hypo_tests.py index 2d581e971e..664d0c76e5 100644 --- a/aeon/utils/forecasting/_hypo_tests.py +++ b/aeon/forecasting/_hypo_tests.py @@ -52,7 +52,7 @@ def kpss_test(y, regression="c", lags=None): # Test if time series is stationar >>> from aeon.datasets import load_airline >>> y = load_airline() >>> kpss_test(y) - (np.float64(1.1966313813...), np.False_) + (1.1966313813502716, False) """ y = np.asarray(y) n = len(y) diff --git a/aeon/utils/forecasting/_seasonality.py b/aeon/forecasting/_seasonality.py similarity index 100% rename from aeon/utils/forecasting/_seasonality.py rename to aeon/forecasting/_seasonality.py diff --git a/aeon/utils/forecasting/__init__.py b/aeon/utils/forecasting/__init__.py deleted file mode 100644 index a168fa0f11..0000000000 --- a/aeon/utils/forecasting/__init__.py +++ /dev/null @@ -1 +0,0 @@ -"""Forecasting utils.""" From 0f5caa65c3ab14771e732b9800062875bf608c8a Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 28 Jul 2025 10:24:52 +0100 Subject: [PATCH 50/76] refactor into stats and utils --- aeon/forecasting/__init__.py | 6 +++--- aeon/forecasting/stats/__init__.py | 9 +++++++++ aeon/forecasting/{ => stats}/_arima.py | 0 aeon/forecasting/{ => stats}/_ets.py | 12 ++++++------ aeon/forecasting/stats/tests/__init__.py | 1 + aeon/forecasting/{ => stats}/tests/test_arima.py | 0 aeon/forecasting/{ => stats}/tests/test_ets.py | 2 +- aeon/forecasting/utils/__init__.py | 1 + aeon/forecasting/{ => utils}/_extract_paras.py | 0 aeon/forecasting/{ => utils}/_hypo_tests.py | 0 aeon/forecasting/{ => utils}/_loss_functions.py | 0 aeon/forecasting/{ => utils}/_nelder_mead.py | 0 aeon/forecasting/{ => utils}/_seasonality.py | 0 13 files changed, 21 insertions(+), 10 deletions(-) create mode 100644 aeon/forecasting/stats/__init__.py rename aeon/forecasting/{ => stats}/_arima.py (100%) rename aeon/forecasting/{ => stats}/_ets.py (98%) create mode 100644 aeon/forecasting/stats/tests/__init__.py rename aeon/forecasting/{ => stats}/tests/test_arima.py (100%) rename aeon/forecasting/{ => stats}/tests/test_ets.py (97%) create mode 100644 aeon/forecasting/utils/__init__.py rename aeon/forecasting/{ => utils}/_extract_paras.py (100%) rename aeon/forecasting/{ => utils}/_hypo_tests.py (100%) rename aeon/forecasting/{ => utils}/_loss_functions.py (100%) rename aeon/forecasting/{ => utils}/_nelder_mead.py (100%) rename aeon/forecasting/{ => utils}/_seasonality.py (100%) diff --git a/aeon/forecasting/__init__.py b/aeon/forecasting/__init__.py index 7d7cb7e6c4..b081a01553 100644 --- a/aeon/forecasting/__init__.py +++ b/aeon/forecasting/__init__.py @@ -4,14 +4,14 @@ "BaseForecaster", "NaiveForecaster", "RegressionForecaster", - "ETSForecaster", + "ETS", "TVPForecaster", "ARIMA", ] -from aeon.forecasting._arima import ARIMA -from aeon.forecasting._ets import ETSForecaster from aeon.forecasting._naive import NaiveForecaster from aeon.forecasting._regression import RegressionForecaster from aeon.forecasting._tvp import TVPForecaster from aeon.forecasting.base import BaseForecaster +from aeon.forecasting.stats._arima import ARIMA +from aeon.forecasting.stats._ets import ETS diff --git a/aeon/forecasting/stats/__init__.py b/aeon/forecasting/stats/__init__.py new file mode 100644 index 0000000000..1b320e5caf --- /dev/null +++ b/aeon/forecasting/stats/__init__.py @@ -0,0 +1,9 @@ +"""Stats based forecasters.""" + +__all__ = [ + "ETS", + "ARIMA", +] + +from aeon.forecasting.stats._arima import ARIMA +from aeon.forecasting.stats._ets import ETS diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/stats/_arima.py similarity index 100% rename from aeon/forecasting/_arima.py rename to aeon/forecasting/stats/_arima.py diff --git a/aeon/forecasting/_ets.py b/aeon/forecasting/stats/_ets.py similarity index 98% rename from aeon/forecasting/_ets.py rename to aeon/forecasting/stats/_ets.py index 9758d3535b..010abc4495 100644 --- a/aeon/forecasting/_ets.py +++ b/aeon/forecasting/stats/_ets.py @@ -1,4 +1,4 @@ -"""ETSForecaster class. +"""ETS class. An implementation of the exponential smoothing statistics forecasting algorithm. Implements additive and multiplicative error models. We recommend using the AutoETS @@ -6,7 +6,7 @@ """ __maintainer__ = [] -__all__ = ["ETSForecaster"] +__all__ = ["ETS"] from typing import Union @@ -19,7 +19,7 @@ MULTIPLICATIVE = "multiplicative" -class ETSForecaster(BaseForecaster): +class ETS(BaseForecaster): """Exponential Smoothing (ETS) forecaster. Implements the ETS (Error, Trend, Seasonality) forecaster, supporting additive @@ -77,10 +77,10 @@ class ETSForecaster(BaseForecaster): Examples -------- - >>> from aeon.forecasting import ETSForecaster + >>> from aeon.forecasting import ETS >>> from aeon.datasets import load_airline >>> y = load_airline() - >>> forecaster = ETSForecaster( + >>> forecaster = ETS( ... alpha=0.4, beta=0.2, gamma=0.5, phi=0.8, ... error_type='additive', trend_type='multiplicative', ... seasonality_type='multiplicative', seasonal_period=4 @@ -143,7 +143,7 @@ def _fit(self, y, exog=None): Returns ------- self - Fitted ETSForecaster. + Fitted ETS. """ _validate_parameter(self.error_type, False) _validate_parameter(self.seasonality_type, True) diff --git a/aeon/forecasting/stats/tests/__init__.py b/aeon/forecasting/stats/tests/__init__.py new file mode 100644 index 0000000000..ee0e57c2f1 --- /dev/null +++ b/aeon/forecasting/stats/tests/__init__.py @@ -0,0 +1 @@ +"""Stats forecaster tests.""" diff --git a/aeon/forecasting/tests/test_arima.py b/aeon/forecasting/stats/tests/test_arima.py similarity index 100% rename from aeon/forecasting/tests/test_arima.py rename to aeon/forecasting/stats/tests/test_arima.py diff --git a/aeon/forecasting/tests/test_ets.py b/aeon/forecasting/stats/tests/test_ets.py similarity index 97% rename from aeon/forecasting/tests/test_ets.py rename to aeon/forecasting/stats/tests/test_ets.py index 176df75d26..83841b6e42 100644 --- a/aeon/forecasting/tests/test_ets.py +++ b/aeon/forecasting/stats/tests/test_ets.py @@ -68,7 +68,7 @@ ], ) def test_ets_forecaster(params, expected): - """Test ETSForecaster for multiple parameter combinations.""" + """Test ETS for multiple parameter combinations.""" data = np.array([3, 10, 12, 13, 12, 10, 12, 3, 10, 12, 13, 12, 10, 12]) forecaster = ETSForecaster(**params) p = forecaster.forecast(data) diff --git a/aeon/forecasting/utils/__init__.py b/aeon/forecasting/utils/__init__.py new file mode 100644 index 0000000000..87f6460e36 --- /dev/null +++ b/aeon/forecasting/utils/__init__.py @@ -0,0 +1 @@ +"""Utils for forecasting.""" diff --git a/aeon/forecasting/_extract_paras.py b/aeon/forecasting/utils/_extract_paras.py similarity index 100% rename from aeon/forecasting/_extract_paras.py rename to aeon/forecasting/utils/_extract_paras.py diff --git a/aeon/forecasting/_hypo_tests.py b/aeon/forecasting/utils/_hypo_tests.py similarity index 100% rename from aeon/forecasting/_hypo_tests.py rename to aeon/forecasting/utils/_hypo_tests.py diff --git a/aeon/forecasting/_loss_functions.py b/aeon/forecasting/utils/_loss_functions.py similarity index 100% rename from aeon/forecasting/_loss_functions.py rename to aeon/forecasting/utils/_loss_functions.py diff --git a/aeon/forecasting/_nelder_mead.py b/aeon/forecasting/utils/_nelder_mead.py similarity index 100% rename from aeon/forecasting/_nelder_mead.py rename to aeon/forecasting/utils/_nelder_mead.py diff --git a/aeon/forecasting/_seasonality.py b/aeon/forecasting/utils/_seasonality.py similarity index 100% rename from aeon/forecasting/_seasonality.py rename to aeon/forecasting/utils/_seasonality.py From 6418e4ed607295532abf6efd86cb538d43717238 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 28 Jul 2025 10:26:53 +0100 Subject: [PATCH 51/76] API --- docs/api_reference/forecasting.md | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/docs/api_reference/forecasting.md b/docs/api_reference/forecasting.md index cdfae27341..ab5c9d7776 100644 --- a/docs/api_reference/forecasting.md +++ b/docs/api_reference/forecasting.md @@ -10,6 +10,17 @@ BaseForecaster NaiveForecaster RegressionForecaster - ETSForecaster TVPForecaster ``` + +Statistical Forecasters +----------------------- + +.. currentmodule:: aeon.forecasting.stats + +.. autosummary:: + :toctree: auto_generated/ + :template: class.rst + + ARIMA + ETS From 6d99d76a4be4cdbe29e458897751a199f69d9421 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 28 Jul 2025 10:28:36 +0100 Subject: [PATCH 52/76] remove example --- aeon/forecasting/_hypo_tests.py | 8 -------- 1 file changed, 8 deletions(-) diff --git a/aeon/forecasting/_hypo_tests.py b/aeon/forecasting/_hypo_tests.py index 664d0c76e5..198a4472a8 100644 --- a/aeon/forecasting/_hypo_tests.py +++ b/aeon/forecasting/_hypo_tests.py @@ -45,14 +45,6 @@ def kpss_test(y, regression="c", lags=None): # Test if time series is stationar of a unit root." Journal of Econometrics, 54(1–3), 159–178. https://doi.org/10.1016/0304-4076(92)90104-Y - - Examples - -------- - >>> from aeon.utils.forecasting._hypo_tests import kpss_test - >>> from aeon.datasets import load_airline - >>> y = load_airline() - >>> kpss_test(y) - (1.1966313813502716, False) """ y = np.asarray(y) n = len(y) From 9d6055c10a67e1e79abf75cd21b5d71711ae59c4 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 28 Jul 2025 15:57:57 +0100 Subject: [PATCH 53/76] fix test --- aeon/forecasting/stats/tests/test_arima.py | 2 +- aeon/forecasting/stats/tests/test_ets.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/aeon/forecasting/stats/tests/test_arima.py b/aeon/forecasting/stats/tests/test_arima.py index 73d99d7b50..005a5a14ac 100644 --- a/aeon/forecasting/stats/tests/test_arima.py +++ b/aeon/forecasting/stats/tests/test_arima.py @@ -3,7 +3,7 @@ import numpy as np import pytest -from aeon.forecasting import ARIMA +from aeon.forecasting.stats._arima import ARIMA y = np.array( [112, 118, 132, 129, 121, 135, 148, 148, 136, 119, 104, 118], dtype=np.float64 diff --git a/aeon/forecasting/stats/tests/test_ets.py b/aeon/forecasting/stats/tests/test_ets.py index 83841b6e42..58bd4f34ed 100644 --- a/aeon/forecasting/stats/tests/test_ets.py +++ b/aeon/forecasting/stats/tests/test_ets.py @@ -7,7 +7,7 @@ import pytest from aeon.forecasting import ETSForecaster -from aeon.forecasting._ets import _validate_parameter +from aeon.forecasting.stats._ets import _validate_parameter @pytest.mark.parametrize( From b8e4abdf1001475b67dfdb30d965fcd5f23ebfba Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 28 Jul 2025 16:07:24 +0100 Subject: [PATCH 54/76] fix test --- aeon/forecasting/stats/tests/test_ets.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/aeon/forecasting/stats/tests/test_ets.py b/aeon/forecasting/stats/tests/test_ets.py index 58bd4f34ed..c3e714eee5 100644 --- a/aeon/forecasting/stats/tests/test_ets.py +++ b/aeon/forecasting/stats/tests/test_ets.py @@ -6,7 +6,7 @@ import numpy as np import pytest -from aeon.forecasting import ETSForecaster +from aeon.forecasting import ETS from aeon.forecasting.stats._ets import _validate_parameter @@ -70,7 +70,7 @@ def test_ets_forecaster(params, expected): """Test ETS for multiple parameter combinations.""" data = np.array([3, 10, 12, 13, 12, 10, 12, 3, 10, 12, 13, 12, 10, 12]) - forecaster = ETSForecaster(**params) + forecaster = ETS(**params) p = forecaster.forecast(data) assert np.isclose(p, expected) @@ -84,12 +84,12 @@ def test_incorrect_parameters(): _validate_parameter(None, True) _validate_parameter(10, False) _validate_parameter("Foo", True) - forecaster = ETSForecaster() + forecaster = ETS() forecaster.horizon = 2 data = np.array([3, 10, 12, 13, 12, 10, 12, 3, 10, 12, 13, 12, 10, 12]) with pytest.raises(ValueError, match="Horizon is set >1, but"): forecaster.fit(data) - forecaster = ETSForecaster() + forecaster = ETS() with pytest.raises( ValueError, match="This forecaster cannot be used with the " "direct strategy" ): From 574533cc5a1cad2f8e30d1046b2422bcbd5a3f16 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 28 Jul 2025 17:54:36 +0100 Subject: [PATCH 55/76] notebook --- examples/forecasting/forecasting.ipynb | 40 ++++++-------------------- 1 file changed, 8 insertions(+), 32 deletions(-) diff --git a/examples/forecasting/forecasting.ipynb b/examples/forecasting/forecasting.ipynb index 3e2bafc622..d9c23d5865 100644 --- a/examples/forecasting/forecasting.ipynb +++ b/examples/forecasting/forecasting.ipynb @@ -325,49 +325,25 @@ "cell_type": "code", "metadata": { "collapsed": false, - "ExecuteTime": { - "end_time": "2025-07-04T14:06:53.435103Z", - "start_time": "2025-07-04T14:06:49.740533Z" + "jupyter": { + "is_executing": true } }, "source": [ - "from aeon.forecasting import ETSForecaster\n", + "from aeon.forecasting import ETS\n", "\n", - "ets = ETSForecaster()\n", + "ets = ETS()\n", "ets.forecast(y)" ], - "outputs": [ - { - "data": { - "text/plain": [ - "460.302772481884" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 8 - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2024-11-16T19:21:27.095665Z", - "start_time": "2024-11-16T19:21:27.077715Z" - } - }, "outputs": [], - "source": [] + "execution_count": null }, { - "cell_type": "code", - "execution_count": null, "metadata": {}, + "cell_type": "code", "outputs": [], - "source": [] + "execution_count": null, + "source": "" } ], "metadata": { From 37c3b9161a5e759214c7690452a35b325f8bc4f4 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 28 Jul 2025 17:56:36 +0100 Subject: [PATCH 56/76] notebook --- examples/forecasting/forecasting.ipynb | 21 +++++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/examples/forecasting/forecasting.ipynb b/examples/forecasting/forecasting.ipynb index d9c23d5865..5a5070308d 100644 --- a/examples/forecasting/forecasting.ipynb +++ b/examples/forecasting/forecasting.ipynb @@ -325,8 +325,9 @@ "cell_type": "code", "metadata": { "collapsed": false, - "jupyter": { - "is_executing": true + "ExecuteTime": { + "end_time": "2025-07-28T16:55:44.260522Z", + "start_time": "2025-07-28T16:55:41.254946Z" } }, "source": [ @@ -335,8 +336,20 @@ "ets = ETS()\n", "ets.forecast(y)" ], - "outputs": [], - "execution_count": null + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'y' is not defined", + "output_type": "error", + "traceback": [ + "\u001B[31m---------------------------------------------------------------------------\u001B[39m", + "\u001B[31mNameError\u001B[39m Traceback (most recent call last)", + "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[1]\u001B[39m\u001B[32m, line 4\u001B[39m\n\u001B[32m 1\u001B[39m \u001B[38;5;28;01mfrom\u001B[39;00m\u001B[38;5;250m \u001B[39m\u001B[34;01maeon\u001B[39;00m\u001B[34;01m.\u001B[39;00m\u001B[34;01mforecasting\u001B[39;00m\u001B[38;5;250m \u001B[39m\u001B[38;5;28;01mimport\u001B[39;00m ETS\n\u001B[32m 3\u001B[39m ets = ETS()\n\u001B[32m----> \u001B[39m\u001B[32m4\u001B[39m ets.forecast(\u001B[43my\u001B[49m)\n", + "\u001B[31mNameError\u001B[39m: name 'y' is not defined" + ] + } + ], + "execution_count": 1 }, { "metadata": {}, From 047aa60c39714be00cd2cb01c7bf8483cceb9c60 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 28 Jul 2025 21:16:39 +0100 Subject: [PATCH 57/76] notebook --- examples/forecasting/iterative.ipynb | 254 ++++++++++++++------------- 1 file changed, 129 insertions(+), 125 deletions(-) diff --git a/examples/forecasting/iterative.ipynb b/examples/forecasting/iterative.ipynb index c0f8d8dd8a..e294c22914 100644 --- a/examples/forecasting/iterative.ipynb +++ b/examples/forecasting/iterative.ipynb @@ -7,8 +7,8 @@ "source": [ "# Iterative forecasting\n", "\n", - "Iterative forecasting (sometimes called recursive) involves repeatedly predicting \n", - "with a forecaster by adding predicted values to the actual values. Suppose you have a series of length $n$ and \n", + "Iterative forecasting (sometimes called recursive) involves repeatedly predicting\n", + "with a forecaster by adding predicted values to the actual values. Suppose you have a series of length $n$ and\n", "you want to forecast the next 20 steps, the pseudocode for this is as follows.\n", "\n", "```\n", @@ -18,7 +18,7 @@ " y.append(preds[i - 1])\n", "end for\n", "```\n", - " In contrast to [direct forecasting](./direct.ipynb), the iterative forecast only \n", + " In contrast to [direct forecasting](./direct.ipynb), the iterative forecast only\n", " ever fits a single model. You can visualise the process as follows\n", "\n", "\"iterative\n", @@ -29,56 +29,43 @@ }, { "cell_type": "code", - "execution_count": 1, "id": "e1a1ad0e8e30b77e", "metadata": { "ExecuteTime": { - "end_time": "2025-06-16T16:14:58.605948Z", - "start_time": "2025-06-16T16:14:58.412664Z" + "end_time": "2025-07-28T20:16:18.398137Z", + "start_time": "2025-07-28T20:16:14.848290Z" } }, + "source": [ + "from aeon.datasets import load_airline\n", + "from aeon.visualisation import plot_series\n", + "\n", + "airline = load_airline()\n", + "_ = plot_series(airline)" + ], "outputs": [ { "data": { - "image/png": "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", "text/plain": [ "
" - ] + ], + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "source": [ - "from aeon.datasets import load_airline\n", - "from aeon.visualisation import plot_series\n", - "\n", - "airline = load_airline()\n", - "_ = plot_series(airline)" - ] + "execution_count": 1 }, { "cell_type": "code", - "execution_count": 2, "id": "512d5683fca427e7", "metadata": { "ExecuteTime": { - "end_time": "2025-06-16T16:14:59.858569Z", - "start_time": "2025-06-16T16:14:59.692652Z" + "end_time": "2025-07-28T20:16:18.524475Z", + "start_time": "2025-07-28T20:16:18.411686Z" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -97,7 +84,20 @@ "plt.ylabel(\"Value\")\n", "plt.title(\"Train/Test Split of Time Series\")\n", "plt.show()" - ] + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 2 }, { "cell_type": "markdown", @@ -105,38 +105,38 @@ "metadata": {}, "source": [ "We want to train a forecaster on the train set and forecast predictions for the\n", - "subsequent test steps. The `RegressionForecaster` is a window based forecaster that \n", - "by default uses linear regression to predict one step ahead. It requires a window \n", - "parameter. See the [forecasting with regression](./regression.ipynb) notebook for \n", - "details. The `forecast()` method makes a single forecast `horizon` steps ahead. " + "subsequent test steps. The `RegressionForecaster` is a window based forecaster that\n", + "by default uses linear regression to predict one step ahead. It requires a window\n", + "parameter. See the [forecasting with regression](./regression.ipynb) notebook for\n", + "details. The `forecast()` method makes a single forecast `horizon` steps ahead." ] }, { "cell_type": "code", - "execution_count": 3, "id": "ff55e38056585c73", "metadata": { "ExecuteTime": { - "end_time": "2025-06-16T16:15:02.833697Z", - "start_time": "2025-06-16T16:15:02.824630Z" + "end_time": "2025-07-28T20:16:18.767439Z", + "start_time": "2025-07-28T20:16:18.715835Z" } }, + "source": [ + "from aeon.forecasting import RegressionForecaster\n", + "\n", + "reg = RegressionForecaster(horizon=1, window=10)\n", + "p1 = reg.forecast(y_train)\n", + "print(\" First forecast = \", p1)" + ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " First forecast = 376.1051346580682\n" + " First forecast = 376.10513465806844\n" ] } ], - "source": [ - "from aeon.forecasting import RegressionForecaster\n", - "\n", - "reg = RegressionForecaster(horizon=1, window=10)\n", - "p1 = reg.forecast(y_train)\n", - "print(\" First forecast = \", p1)" - ] + "execution_count": 3 }, { "cell_type": "markdown", @@ -145,36 +145,36 @@ "source": [ "what if we want to predict further ahead? The direct strategy, described [here](./direct.ipynb)\n", "retrains the model for each set, changing the forecasting horizon. This can\n", - " be computationally intensive. As an alternative, the iterative \n", + " be computationally intensive. As an alternative, the iterative\n", " strategy uses the predicted value and predicts without refitting." ] }, { "cell_type": "code", - "execution_count": 4, "id": "5b091fcecbd3f267", "metadata": { "ExecuteTime": { - "end_time": "2025-06-16T16:15:05.268365Z", - "start_time": "2025-06-16T16:15:05.257150Z" + "end_time": "2025-07-28T20:16:18.842346Z", + "start_time": "2025-07-28T20:16:18.834569Z" } }, + "source": [ + "y_new = np.append(y_train, p1)\n", + "p2 = reg.predict(y_new)\n", + "y_new = np.append(y_new, p2)\n", + "p3 = reg.predict(y_new)\n", + "print(f\" second forecast = {p2} third forecast = {p3}\")" + ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " second forecast = 427.18613539195076 third forecast = 418.4059582875235\n" + " second forecast = 427.1861353919512 third forecast = 418.40595828752396\n" ] } ], - "source": [ - "y_new = np.append(y_train, p1)\n", - "p2 = reg.predict(y_new)\n", - "y_new = np.append(y_new, p2)\n", - "p3 = reg.predict(y_new)\n", - "print(f\" second forecast = {p2} third forecast = {p3}\")" - ] + "execution_count": 4 }, { "cell_type": "markdown", @@ -186,26 +186,13 @@ }, { "cell_type": "code", - "execution_count": 5, "id": "1b2267b78b0cdfef", "metadata": { "ExecuteTime": { - "end_time": "2025-06-16T16:15:10.611791Z", - "start_time": "2025-06-16T16:15:10.451442Z" + "end_time": "2025-07-28T20:16:20.466064Z", + "start_time": "2025-07-28T20:16:20.337037Z" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "y_hat = reg.iterative_forecast(y=y_train, prediction_horizon=20)\n", "\n", @@ -228,7 +215,20 @@ "plt.ylabel(\"Value\")\n", "plt.title(\"Train/Test/Pedicted\")\n", "plt.show()" - ] + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 5 }, { "cell_type": "markdown", @@ -240,113 +240,99 @@ }, { "cell_type": "code", - "execution_count": 6, "id": "30d6ed16e3eaa898", "metadata": { "ExecuteTime": { - "end_time": "2025-06-16T16:15:27.178701Z", - "start_time": "2025-06-16T16:15:27.018119Z" + "end_time": "2025-07-28T20:16:21.967306Z", + "start_time": "2025-07-28T20:16:21.759223Z" } }, + "source": [ + "plt.plot(y_test, label=\"Actual\", color=\"orange\")\n", + "plt.plot(y_hat, label=\"Predicted iterative\", color=\"green\", linestyle=\":\")\n", + "plt.legend()\n", + "plt.xlabel(\"Time\")\n", + "plt.ylabel(\"Value\")\n", + "plt.title(\"Pedicted and Actual over the test interval\")\n", + "plt.show()" + ], "outputs": [ { "data": { - "image/png": "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", "text/plain": [ "
" - ] + ], + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "source": [ - "plt.plot(y_test, label=\"Actual\", color=\"orange\")\n", - "plt.plot(y_hat, label=\"Predicted iterative\", color=\"green\", linestyle=\":\")\n", - "plt.legend()\n", - "plt.xlabel(\"Time\")\n", - "plt.ylabel(\"Value\")\n", - "plt.title(\"Pedicted and Actual over the test interval\")\n", - "plt.show()" - ] + "execution_count": 6 }, { "cell_type": "markdown", "id": "3e97b9b31693702d", "metadata": {}, "source": [ - "It seems to be underestimating the peaks and troughs. Contrast this to the direct \n", - "strategy which results in very different forecasts " + "It seems to be underestimating the peaks and troughs. Contrast this to the direct\n", + "strategy which results in very different forecasts" ] }, { "cell_type": "code", - "execution_count": 7, "id": "bc5ed962ad010b89", "metadata": { "ExecuteTime": { - "end_time": "2025-06-16T16:15:33.914963Z", - "start_time": "2025-06-16T16:15:33.788410Z" + "end_time": "2025-07-28T20:16:23.264541Z", + "start_time": "2025-07-28T20:16:23.163486Z" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "y_hat2 = reg.direct_forecast(y=y_train, prediction_horizon=20)\n", "plt.plot(y_hat2, label=\"Predicted direct\", color=\"blue\", linestyle=\":\")\n", "plt.plot(y_test, label=\"Actual\", color=\"orange\")\n", "plt.plot(y_hat, label=\"Predicted iterative\", color=\"green\", linestyle=\":\")\n", "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "5e283827ebb7141b", - "metadata": {}, + ], "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Alpha: 0.2550646708489574, Beta: 0.02550646708489574, Gamma: 0.7448608356181274, Phi: 1.0\n", - "Alpha: 0.25508210344031595, Beta: 2.5508210344031598e-05, Gamma: 0.7448434047700282, Phi: N/A\n" - ] - }, { "data": { - "image/png": "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", "text/plain": [ "
" - ] + ], + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], + "execution_count": 7 + }, + { + "cell_type": "code", + "id": "5e283827ebb7141b", + "metadata": { + "jupyter": { + "is_executing": true + }, + "ExecuteTime": { + "start_time": "2025-07-28T20:16:23.888457Z" + } + }, "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from statsmodels.tsa.exponential_smoothing.ets import ETSModel\n", "\n", "from aeon.datasets import load_airline\n", - "from aeon.forecasting import ETSForecaster\n", + "from aeon.forecasting import ETS\n", "\n", "airline = load_airline()\n", "y_train = airline[:100]\n", "y_test = airline[100:120]\n", "\n", - "ets = ETSForecaster(\n", + "ets = ETS(\n", " error_type=\"additive\",\n", " trend_type=\"additive\",\n", " seasonality_type=\"additive\",\n", @@ -397,7 +383,25 @@ ")\n", "plt.legend()\n", "plt.show()" - ] + ], + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "a587370d0a01b4be" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "c4cf7f1cb294d317" } ], "metadata": { From 2820b458c29b4660cdafa7c245589664460e0924 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Wed, 30 Jul 2025 10:11:14 +0100 Subject: [PATCH 58/76] imports and API --- aeon/forecasting/__init__.py | 4 ---- docs/api_reference/forecasting.md | 26 --------------------- docs/api_reference/forecasting.rst | 36 ++++++++++++++++++++++++++++++ docs/getting_started.md | 2 +- 4 files changed, 37 insertions(+), 31 deletions(-) delete mode 100644 docs/api_reference/forecasting.md create mode 100644 docs/api_reference/forecasting.rst diff --git a/aeon/forecasting/__init__.py b/aeon/forecasting/__init__.py index b081a01553..e02673cf2f 100644 --- a/aeon/forecasting/__init__.py +++ b/aeon/forecasting/__init__.py @@ -4,14 +4,10 @@ "BaseForecaster", "NaiveForecaster", "RegressionForecaster", - "ETS", "TVPForecaster", - "ARIMA", ] from aeon.forecasting._naive import NaiveForecaster from aeon.forecasting._regression import RegressionForecaster from aeon.forecasting._tvp import TVPForecaster from aeon.forecasting.base import BaseForecaster -from aeon.forecasting.stats._arima import ARIMA -from aeon.forecasting.stats._ets import ETS diff --git a/docs/api_reference/forecasting.md b/docs/api_reference/forecasting.md deleted file mode 100644 index ab5c9d7776..0000000000 --- a/docs/api_reference/forecasting.md +++ /dev/null @@ -1,26 +0,0 @@ -# Forecasting - -```{eval-rst} -.. currentmodule:: aeon.forecasting - -.. autosummary:: - :toctree: auto_generated/ - :template: class.rst - - BaseForecaster - NaiveForecaster - RegressionForecaster - TVPForecaster -``` - -Statistical Forecasters ------------------------ - -.. currentmodule:: aeon.forecasting.stats - -.. autosummary:: - :toctree: auto_generated/ - :template: class.rst - - ARIMA - ETS diff --git a/docs/api_reference/forecasting.rst b/docs/api_reference/forecasting.rst new file mode 100644 index 0000000000..238a8c66e0 --- /dev/null +++ b/docs/api_reference/forecasting.rst @@ -0,0 +1,36 @@ +.. _forecasting_ref: + +Forecasting +=========== + +The :mod:`aeon.forecasting` module contains algorithms for forecasting. + +All clusterers in `aeon` can be listed using the `aeon.registry.all_estimators` +utility, using `estimator_types="forecasting"`, optionally filtered by tags. +Valid tags can be listed using `aeon.registry.all_tags`. + +Forecasting Models +------------------ + +.. currentmodule:: aeon.forecasting + +.. autosummary:: + :toctree: auto_generated/ + :template: class.rst + + BaseForecaster + NaiveForecaster + RegressionForecaster + TVPForecaster + +Statistical Models +------------------ + +.. currentmodule:: aeon.forecasting.stats + +.. autosummary:: + :toctree: auto_generated/ + :template: class.rst + + ARIMA + ETS diff --git a/docs/getting_started.md b/docs/getting_started.md index 3debff0d7d..35997c404e 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -27,7 +27,7 @@ classical techniques for the following learning tasks: ([more details](examples/similarity_search/similarity_search.ipynb)). - [**Anomaly detection**](api_reference/anomaly_detection), where the goal is to find values or areas of a single time series that are not representative of the whole series. -- [**Forecasting**](api_reference/forecasting), where the goal is to predict future values +- [**Forecasting**](api_reference/forecasting.rst), where the goal is to predict future values of a single time series ([more details](examples/forecasting/forecasting.ipynb)). - [**Segmentation**](api_reference/segmentation), where the goal is to split a single time From 794d44ecaa91c1bb70c3f31838bf5c1c12522e80 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Wed, 30 Jul 2025 10:19:27 +0100 Subject: [PATCH 59/76] example --- aeon/forecasting/stats/_ets.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/aeon/forecasting/stats/_ets.py b/aeon/forecasting/stats/_ets.py index 010abc4495..a8fc70220a 100644 --- a/aeon/forecasting/stats/_ets.py +++ b/aeon/forecasting/stats/_ets.py @@ -77,7 +77,7 @@ class ETS(BaseForecaster): Examples -------- - >>> from aeon.forecasting import ETS + >>> from aeon.forecasting.stats import ETS >>> from aeon.datasets import load_airline >>> y = load_airline() >>> forecaster = ETS( From e3e3f2f81ece078b87e35530f419b39b44e17687 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Wed, 30 Jul 2025 10:22:00 +0100 Subject: [PATCH 60/76] notebook --- aeon/forecasting/stats/tests/test_ets.py | 6 +- examples/forecasting/forecasting.ipynb | 2 +- examples/forecasting/iterative.ipynb | 223 ++++++----------------- 3 files changed, 55 insertions(+), 176 deletions(-) diff --git a/aeon/forecasting/stats/tests/test_ets.py b/aeon/forecasting/stats/tests/test_ets.py index c3e714eee5..9256c43d99 100644 --- a/aeon/forecasting/stats/tests/test_ets.py +++ b/aeon/forecasting/stats/tests/test_ets.py @@ -1,13 +1,9 @@ """Test ETS.""" -__maintainer__ = [] -__all__ = [] - import numpy as np import pytest -from aeon.forecasting import ETS -from aeon.forecasting.stats._ets import _validate_parameter +from aeon.forecasting.stats._ets import ETS, _validate_parameter @pytest.mark.parametrize( diff --git a/examples/forecasting/forecasting.ipynb b/examples/forecasting/forecasting.ipynb index 5a5070308d..f8a42d90c8 100644 --- a/examples/forecasting/forecasting.ipynb +++ b/examples/forecasting/forecasting.ipynb @@ -331,7 +331,7 @@ } }, "source": [ - "from aeon.forecasting import ETS\n", + "from aeon.forecasting.stats import ETS\n", "\n", "ets = ETS()\n", "ets.forecast(y)" diff --git a/examples/forecasting/iterative.ipynb b/examples/forecasting/iterative.ipynb index e294c22914..31d0f5638f 100644 --- a/examples/forecasting/iterative.ipynb +++ b/examples/forecasting/iterative.ipynb @@ -1,9 +1,8 @@ { "cells": [ { - "cell_type": "markdown", - "id": "d7f79f17fc5714df", "metadata": {}, + "cell_type": "markdown", "source": [ "# Iterative forecasting\n", "\n", @@ -25,17 +24,14 @@ "\n", "\n", "We will demonstrate direct forecasting with the airline data" - ] + ], + "id": "719611871cb4703e" }, { + "metadata": {}, "cell_type": "code", - "id": "e1a1ad0e8e30b77e", - "metadata": { - "ExecuteTime": { - "end_time": "2025-07-28T20:16:18.398137Z", - "start_time": "2025-07-28T20:16:14.848290Z" - } - }, + "outputs": [], + "execution_count": null, "source": [ "from aeon.datasets import load_airline\n", "from aeon.visualisation import plot_series\n", @@ -43,29 +39,13 @@ "airline = load_airline()\n", "_ = plot_series(airline)" ], - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 1 + "id": "f32071b620802ac4" }, { + "metadata": {}, "cell_type": "code", - "id": "512d5683fca427e7", - "metadata": { - "ExecuteTime": { - "end_time": "2025-07-28T20:16:18.524475Z", - "start_time": "2025-07-28T20:16:18.411686Z" - } - }, + "outputs": [], + "execution_count": null, "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -85,41 +65,25 @@ "plt.title(\"Train/Test Split of Time Series\")\n", "plt.show()" ], - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAdjBJREFUeJztnQm8TPX/xj9351quLVuWFFmyZUna+CFCZWuTkJ/4Jy0oSUl7SutPaVPRJqVSEdlpQaEsISEia1mu/a7zfz3fc7+zmbl39nNm5nm/XseZOXPuzJkz1z3PPJ8twWaz2YQQQgghJEZJNPsACCGEEELCCcUOIYQQQmIaih1CCCGExDQUO4QQQgiJaSh2CCGEEBLTUOwQQgghJKah2CGEEEJITEOxQwghhJCYhmKHEEIIITENxQ4hEeDWW2+Vc845x+zDiFratm2rFs2OHTskISFBpkyZEpHX/+CDD6RevXqSkpIiZcqUCfn7iTfi/f2TyEOxQ+IaXDB9WZYsWWL2ocrhw4clOTlZGjRo4NMxh+piMnv2bHn00Ud93j8/P1/ef/99adWqlZQrV05KlSol559/vvTr109WrFgRkmMKxXH6yu+//67E6nnnnSeTJk2St95664x9tPjyZcG+VmT9+vVy3XXXSc2aNaVYsWJy9tlny5VXXimvvPKK2YdGSNAkcDYWiWc+/PBDl/u4SM+fP199k3cGf/QrVaoU8Ovk5OQoEZCWlhbwc0ybNk369u0rCxculJ07d9q3Hz9+XIYMGSI9evSQnj172rfjeHHcwXLnnXfKxIkTxdc/FXr/bt26Sbt27ZRA27x5s8yZM0duvvnmgASJFm5adOJYsrKylNOSlJQU0HH6yhtvvKHO75YtW6R27doe9zlx4oTMmDHDZdsLL7wgf//9t7z00ksu2/E54bhBamqqWIFly5bJf/7zH6lRo4b0799fKleuLLt27VLidNu2bbJ169aQvl52dral3j+JfZLNPgBCzOSWW25xuY8/7hA77tvdOXnypKSnp/v8OvriFqxzcemll8oVV1zhsv3ff/9VF+PGjRsXedzhZv/+/fLaa6/JoEGDznBAXn75Zfnnn39C8jpwSOA+RIIDBw6odWHhqxIlSpxx7iFO4caZ/Zn4wlNPPSUZGRmycuXKM96nfv+hQP+/ocghkYZhLEJ8cBUaNmwoq1evVkIDf6wffPBB9dhXX30lXbt2lapVqyrXBqGOJ554QvLy8grN2dFhj+eff16JAvwcfr5ly5bqguMOXKFvv/1WvZY/4ReEJRBKgjBo0aKFfP3112c4To899pjUqVNH7VO+fHm57LLLlODTxw23BDiHYryxfft25axAlLmDn6tYsaL9PvJtsO27776T//u//1OvXbp0aRXugkgoDPecHX+PUwNhdsEFF6hzj89w6NChcuTIEfvj+MweeeQRdfuss85SzxmKUJl7zgocKzz3p59+qj4PhJAQ/sPnl5mZqVysYcOGqfNXsmRJGTBggNrmyals3ry5FC9eXH3uN910k3JoigLuDc6DJ0Hn/Jn58zqF/b/xlLOD94NzDfcMn0f16tXl/vvvP+N94ncTv6M4VpyLunXr2p+XEG/Q2SHEBw4ePCidO3dWf9TxTV2HtHCxxR/cESNGqPWiRYtk7NixcvToUXnuueeKfN6pU6fKsWPH1MUeF7vx48erUNSff/7p4gZBAMEV6dKli0/Hu2HDBiU4cNF84IEHlPOAC2n37t3l888/V6EUgAv3uHHj5LbbbpOLLrpIHfeqVavkl19+USEwHNeePXs8hvY8gXwPMH36dLn++ut9cr8QfsKFC8eCcNfrr78uf/31l10A+IK/xwnwehAWHTp0UM6Yfm2c6x9//FGdf7hRCG0iRIXH8BnDQQsX+CwgIPCZIXSEfBkcR2JiohKAOGa4j/i9q1Wrlvpdc3ZnHn74YbnhhhvU54nfF/w8hMavv/5aqDOFz2358uXy22+/KYFSGP68jrf/N57E/LXXXis//PCDDB48WOrXr69yiBAC/OOPP+TLL7+0/15fffXV6jN4/PHHlSjCecLnRUihIGeHEGIwdOhQJHy4bGvTpo3a9sYbb5yx/8mTJ8/Y9n//93+29PR02+nTp+3b+vfvb6tZs6b9/vbt29Vzli9f3nbo0CH79q+++kptnzlzpstzPvzwwy4/78w///yjfuaRRx6xb2vfvr2tUaNGLseQn59vu+SSS2x16tSxb2vSpImta9eufp+TwujXr5/av2zZsrYePXrYnn/+edumTZvO2G/y5Mlqv+bNm9uys7Pt28ePH6+241w4fwZY3M8fniOQ4zxw4IAtNTXV1rFjR1teXp59+6uvvqqe491337Vvw3nFNpxnf8B59faZub+fxYsXq9do2LChy7no3bu3LSEhwda5c2eXn2/durXLc+/YscOWlJRke+qpp1z2W79+vS05OfmM7e7MmzdP/TwWPPf9999vmzt3rsux+Ps6hf2/cX//H3zwgS0xMdH2/fffu+yHn8Vz/Pjjj+r+Sy+9FNBnQQjDWIT4AL5BInTgDr6Fa+DQIH/m8ssvV7kJCCMVxY033ihly5a138fPAjg77vk6voawDh06pBwmfPPWx4QF37I7deqkEm13796t9sW3cHxbxrZQMXnyZHn11VeV8wBH5L777lPf1Nu3b29/XWfwTd7ZxYLLgqRmvOdwsWDBApUki9AQXBMNco0QSvvmm2/EDBDCcz4XqGhDWPC///2vy37YjrBRbm6uuv/FF18odwSfuf68sSDRGCHKxYsXF/q6cPHg7MBdWbt2rXIY8bsCZ9A59Onv63j7f+MOnED8jqC83/l5keAO9PNq1wjhYxwHIb5CsUOID+CPvqekSggFhISQ3ImLJPI6dEIqci2KAtUvzmjh45yzsm/fPhVW8lXswNbHBRKhBhyP86LzT3TSKUIByFFBaXijRo1k5MiRsm7dOgkGiAfkviBXAxcsXJgQyoAAQzjDHVwknUGoqEqVKmEt0UaYDCDfwxl8xueee6798Ujj/vuA3yuA/BX37bjY698xiFV85jiX7p/5pk2bfEoyRr4YxAx+937++WcZPXq0EsvIG9q4cWNAr+Pt/407eF78X3J/TvxeAv28+HKA8CzCZwiJ4fcJ4VkKH1IUzNkhxAecHRwNREKbNm2UyIFoQJIxknwhTEaNGuXTH2BdNu2Oc/k0SrbxvCgN9gX9unBU8O3cE7qEGnkWSE6FIJk3b568/fbbKk8C5da4oAQLko7hFmBBQurSpUuVkNC5PcS334eifk/wmSO/Cb8rnvaFgPQViBMIHywQG3Bm4LxAKPv7Op7+33gCzwux/eKLL3p8XIs9PB8S2uH0wH1D0v4nn3yiHCD8/no7T4RQ7BASIEigRWgI34ady8FRkRRK8EcdQsfXCwecCYBwCJJviwLVNLigYUHPHrwXJMJqseNrknBRoBoMYmfv3r0uYgff6p2FHI4B+/iajK3x5zj16yMpWZ8vgNAWPj9fzpuVgNCG8EHoULshofrMAD6PcL4OnhfhM4Q6i/oc4RxiPywQR08//bQ89NBDSgBF2+dGIgfDWIQEiP4W6ezC4GKJcuZQgdJwVBj5U3KOUmG4KG+++ab9IuWMc68biDX3b+ZwfZzLfVHJBZxLsr2BkJsOeTiD84JmiLhQuTfmQ+k93qcGVU/IRUHoyx/8OU5cFOFgTJgwweXze+edd1RoyJ/zbQVQwYffR1SXuTdVxH33z9kdCAVPzRh13pQO9wX7Ot5ADhDyudCh2p1Tp06ppo06H82dpk2bqrWnUnxCNHR2CAmQSy65ROXYoOPs3Xffrb6Rouw5lB18UYqLcnB/L77oOYNeJAgNIOkW7gUa/iEJFV198S0aYPQEhBF6psDhQdn5Z599psrBNXgM4D0iLIaLnafcG4DnRgk7wgr45o3EVeRbfPzxx+o1kRBcoUKFM4QQ9sUFD04LxCKOHaEvf/DnOJEPgpwUXLSvuuoq9Vr6tRG+iYZGgO7OyJNPPqneE3Kd0GIAfXrgUiFJHEngCGt646677lJJ9cg/Q5IwPhN0VUaICL2GdJJxsK/jDXQGR+7N7bffroQX8nLQqwpJ/tg+d+5c5TIhXIwwFv4/wJ3D7xY+s2rVqqnfGUK8YnY5GCHRUHp+wQUXeNwfJbEXX3yxrXjx4raqVavaS3bxHCgnLqr0/LnnnjvjOZ3LyO+77z5bgwYNCj1mT6XnYNu2baoMvHLlyraUlBTb2Wefbbv66qttn332mX2fJ5980nbRRRfZypQpo95DvXr1VPmwc8lxbm6u7a677rKdddZZqgy6sD8bR48etf3vf/+zderUyVatWjX1uqVKlVLlzJMmTVLl7+6l50uXLrUNHjxYlaqXLFnS1qdPH9vBgwddnteX0nN/jtO51BzvGcdZqVIl25AhQ2yHDx922SeSpefTp0932U+fo5UrV/p0TJ9//rntsssus5UoUUIteG/4nd68eXOhxzpnzhzbf//7X7U/PgOU5deuXVudz/3795+xvy+vU9j/G/f3D/A79+yzz6qfSUtLU78PaEvw2GOP2TIzM9U+CxcutHXr1k39X8MxYo3y/D/++KPQ90cIZ2MRYmHgvKCJGkqBYw00xoNjgCZ+OjeEEELCAcNYhFgUhBJQaovwDiGEkMCh2CHEoiCBVvfFIYQQEjisxiKEEEJITMOcHUIIIYTENHR2CCGEEBLTUOwQQgghJKZhgnLBXJY9e/ao5lihao1PCCGEkPCCTBwMrK1atarq0O4Nih0RJXTcpwoTQgghJDrYtWuX6qTtDYodEeXo6JOFCdaEEEIIsT4YpwOzQl/HvUGx4zQtGUKHYocQQgiJLopKQWGCMiGEEEJiGoodQgghhMQ0FDuEEEIIiWmYs+NHeToGM5LASElJkaSkJLMPgxBCSBxCseMDEDnbt29XgocETpkyZaRy5crsZUQIISSiUOz40LBo7969ypVAeVthTYuI93N48uRJOXDggLpfpUoVsw+JEEJIHEGxUwS5ubnqQo3ujOnp6WYfTtRSvHhxtYbgqVixIkNahBBCIgZtiiLIy8tT69TUVLMPJerRYjEnJ8fsQyGEEBJHUOz4CPNMgofnkBBCiBlQ7BBCCCEkpqHYIT5zzjnnyMsvv2z2YRBCCCF+QbETo+GiwpZHH300oOdduXKlDB48OOTHSwghhIQTVmPFICiV13zyyScyduxY2bx5s31byZIlXcrCkYSdnFz0r8JZZ50VhqMlhBBiefJzRBKS8W1aohE6OzEIGvfpJSMjQ7k5+v7vv/8upUqVkjlz5kjz5s0lLS1NfvjhB9m2bZt069ZNKlWqpMRQy5YtZcGCBYWGsfC8b7/9tvTo0UNVWtWpU0e+/vprE94xIYSQsJF7QuSbhiILLpdoxVSxg3CKe4ilXr169sdPnz4tQ4cOlfLly6sLcK9evWT//v0uz7Fz507p2rWrutiif8vIkSNVb5xwYbOJnDhhzoLXDhUPPPCAPPPMM7Jp0yZp3LixHD9+XLp06SILFy6UX3/9Va666iq55ppr1PktjMcee0xuuOEGWbdunfr5Pn36yKFDh0J3oIQQQsxlz2yRY3+I/POj4fBEIaaHsS644AIXB8E5nDJ8+HD55ptvZPr06cqhuPPOO6Vnz57y448/qscRfoHQgWOxbNkyFb7p16+fmsP09NNPh+V4T55EGEhM4fhxkRIlQvNcjz/+uFx55ZX2++XKlZMmTZrY7z/xxBMyY8YM5dTgvHvj1ltvld69e6vbOOcTJkyQn3/+WYklQgghMcDOz11dntQyEm2YLnYgbiBW3MnMzJR33nlHpk6dKu3atVPbJk+eLPXr15cVK1bIxRdfLPPmzZONGzcqsYTwS9OmTdVFetSoUco1YiNA77Ro0cLlPpwdnDOIS4hGuGOnTp0q0tmBK6QpUaKElC5d2j4WghBCSJSTd1pkzzeO+7nHKXYCYcuWLWoUQ7FixaR169Yybtw4qVGjhqxevVp12u3QoYN9X4S48Njy5cuV2MG6UaNGSuhoOnXqJEOGDJENGzbIhRde6PE1s7Ky1KI5evSoz8eLJsBwWMwglNMqIEycue+++2T+/Pny/PPPS+3atdV4h+uuu67ISe9w0ZxBKJIDUwkhJEbYO98QOM7OThRiqthp1aqVTJkyRerWravcBOR/XH755fLbb7/Jvn37lDODSdnOQNjgMYC1s9DRj+vHvAFBhdcKBCSihyqUZCUQGkRICsnG2unZsWOH2YdFCCHETHY5hbCAs/CJIkwVO507d3YJh0D81KxZUz799FP74MhwMHr0aBkxYoSLs4OJ5vEMKqm++OILlZQMd+bhhx+mQ0MIIfFMfo7I7oIK24REEVt+1Do7lio9h4tz/vnny9atW1UeD0IoR44ccdkH1Vg6xwdr9+osfd9THpAG5dbILXFe4p0XX3xRypYtK5dccokSPAgHNmvWzOzDIoQQYhb7l4hkHxYpVlEko5GxLYfOTtAgdIJ+L3379lU9YJAPglJolJwDNMZDwixyewDWTz31lEqIRdk5QN4JxEuDBg1MfS9WAaEpLJq2bduqRoLuoIfOokWLXLah7N8Z97CWp+dxF6eEEEKiPIRVrbtI5ibjdh6dHb9BUuzSpUvVRRSl48gXSUpKUqXMKDUfOHCgCjctXrxYJSwPGDBACRwkJ4OOHTsqUQNxtHbtWpk7d66MGTNGXaTh3hBCCCEkAPLzRP6eYdyu3kskuaDnCp0d//n777+VsDl48KAaRXDZZZepsnI9luCll16SxMRE5eygegqhlddee83+8xBGs2bNUtVXEEGoMOrfv7/qIUMIIYSQAPl3mcjpAyIpZUQqthXZOsnYHqU5O6aKnWnTphX6OMrRJ06cqBZvIKF59uzZYTg6QgghJN5DWNeKJKWKpBQ4OwxjEUIIISQm2DPHWFfvaayTSkR1GItihxBCCCGunNptrDMuMNba2YnSMBbFDiGEEEIc5J5yiJq0s1ydnShtKkixQwghhBAHWf8a68QUkZSCPnR0dgghhBASM2T9Y6zTKhgzkkAynR1CCCGExAqn/3ENYQHdZ4fODiGEEEJix9k5y7GNzg6xGhjkWdjy6KOPBvXcX375ZUiPlxBCiAVzdorFjrNjqdlYJDTs3bvXfvuTTz6RsWPHqrlimpIlC35pCSGEkMJydjR0dojVwMR3vWDGGNwY523oXF2/fn3VobpevXouIzgwaf7OO++UKlWqqMfRoXrcuHH2YaEAM8zwnPo+IYSQWM/ZKWGs6ezECZj0nXfSnNdOSndkxgfIRx99pJyeV199VS688EL59ddfZdCgQfa5YhMmTJCvv/5aPv30U6lRo4bs2rVLLWDlypVquvzkyZPlqquuUrPJCCGExBhZDGMRCJ1PTQoD3XDcoa4D5JFHHpEXXnhBevY0WoDXqlVLNm7cKG+++aYSOzt37pQ6deqooaxwb+DsaPSA1jJlyiiHiBBCSJyFsfJOitjyRRKiKzBEsRNHnDhxQrZt2yYDBw5Ubo4mNzdXhbvArbfeKldeeaXUrVtXuTdXX321dOzY0cSjJoQQYn41VknH7dyTjiaDUQLFTiChJDgsZr12EBw/bhz3pEmTpFWrVq5PXRCSatasmWzfvl3mzJkjCxYskBtuuEE6dOggn332WVCvTQghJMrCWGlOYiepOOpxkcthJClT7MQ4yJkJMpRkFpUqVZKqVavKn3/+KX369PG6X+nSpeXGG29Uy3XXXaccnkOHDkm5cuUkJSVF8vLyInrchBBCIkR+nkjWoTPDWPraB6EThXk7FDtxxmOPPSZ33323CltBxGRlZcmqVavk8OHDMmLECHnxxRdVJRaSlxMTE2X69OkqPwd5OgAVWAsXLpRLL71U0tLSpGzZsma/JUIIIaEi+6Dh3oC08q6P2cVO9JWfR1eGEQma2267Td5++21VUdWoUSNp06aNTJkyRSUqg1KlSsn48eOlRYsW0rJlS9mxY4fMnj1bCR+A5Ob58+dL9erVlSAihBASgyGs1HIiiW5+SBRXZCXYbKiljm+OHj2qnI7MzEwVwnHm9OnTKocFYgB9Z0jg8FwSQojF2b9UZGFbkVLni1zjaEarmN1E5Mg6kf/MFanS0fLXb2fo7BBCCCHEtRLLucdODDg7FDuEEEJIpMg9JXJwpdGrJlrKzmNgZATFDiGEEBJuTu0TWTdW5KsaInMvEvnDMabHUpz+98xKrBgYGcFqLEIIISRcQBisHiay/X2R/GzH9qO/S/Q5OyWjVuzQ2fER5nEHD88hISTu+PsrkW1vG0Kn/MUi1Y1RPZJd0MsmqnJ2ShhrhrFiD91ZGNPASXCcPGkMUEVjQkIIiQtO/GWsa94k0mm5yNnXWlzs/BuTzg7DWEWQnJws6enp8s8//6iLtO43Q/xzdCB0Dhw4oJoTclo6ISRuOLXHWJeo5dqoLwvN+yzIaQ9DQGPA2aHYKQJM/kZHYfSH+euvAoVOAoLT0gkhccfJ3cY6/WxHsz5LOzv/xGTpOcWOD6SmpkqdOnUYygoCuGJ0dAghccepArFT3E3sWNHZsdmKCGPR2Yl5EL5i119CCCFBOTs6jJWTKZKfe+ZIBjPJPeaoGPMYxopeZ4cJKIQQQki4Joif3ufm7DgNT84+IpbM10lKF0lOjylnh2KHEEIICQen94vY8kQSkkSKVTK2wclJKe00YdxCZP3rPV8H0NkhhBBCiMd8nWKVRRKdchZTdUXWIYs2FKzg+XHt7OTQ2QmYZ555RlU+DRs2zL6tbdu2apvzcvvtt7v83M6dO6Vr166qPLxixYoycuRIyc3NNeEdEEIIIYXk62jSLFqRdbqQ7skgpcDZyYs+Z8cSmVErV66UN998Uxo3bnzGY4MGDZLHH3/cfh+iRpOXl6eEDsqZly1bJnv37pV+/fqpyp+nn346YsdPCCGEFFmJdYazY9EwVpoXsZMUvbOxTHd2jh8/Ln369JFJkyZJ2bJOiVtO4gZiRi+lSxfEOkVk3rx5snHjRvnwww+ladOm0rlzZ3niiSdk4sSJLBMnhBBiLtHm7GT5GMZCgnKUjf8xXewMHTpUuTMdOnTw+PhHH30kFSpUkIYNG8ro0aPtIwfA8uXLpVGjRlKpUkHil4h06tRJjh49Khs2bPD6mllZWWof54UQQgiJjLNj0V47WYU0FHQOY9nyRfKzJJowNYw1bdo0+eWXX1QYyxM333yz1KxZU6pWrSrr1q2TUaNGyebNm+WLL75Qj+/bt89F6AB9H495Y9y4cfLYY4+F9L0QQgghHp2d4lVdt+teO9GWs5NU4OzoJOWk6Ok9Z5rY2bVrl9xzzz0yf/58r836Bg8ebL8NBwdjG9q3by/btm2T8847L+DXhkM0YsQI+304O9WrVw/4+QghhBCvzo57GMuqIyOyiig9R0UZBE7e6YIkZS/hLgtiWhhr9erVajBks2bN1LBNLEuXLpUJEyao20g+dqdVq1ZqvXXrVrVGDs/+/ftd9tH3C5vBlJaWpnJ/nBdCCCEkPM5OlIWx0goRMVFafm6a2IFDs379elmzZo19adGihUpWxm1Pc5SwHcDhAa1bt1bPAdGkgVME8dKgQYMIvhtCCCHEiZxjxvgFjwnKURrGiuLGgqaFsUqVKqWSjp0pUaKElC9fXm1HqGrq1KnSpUsXtQ05O8OHD5crrrjCXqLesWNHJWr69u0r48ePV3k6Y8aMUUnPcG8IIYQQUzi1x1gnlxJJKeXF2bGQ2MnLcogzb2GsKB4ZYYk+O94mjS9YsEBefvllOXHihMqp6dWrlxIzGrg/s2bNkiFDhiiXB2Kpf//+Ln15CCGEEMuUnbs4Owetl6+TkCSSkuF9Pzo7wbNkyRL7bYgb5PAUBaq1Zs+eHeYjI4QQQkJQdu7s7OQcFcnPEUlMEUvl6yQkxpyzY3qfHUIIISSunJ3UMo7b2YclKronR7mzQ7FDCCGERNLZUZPPy1grb+e0D5VYLs4OxQ4hhBAS3xTm7FhxZERWEd2TNQxjEUIIIaRIZ8eKvXayGMYihBBCSEidHYv12jntbxiLzg4hhBASv+TniZze53kullVHRmT966PYobNDCCGEkNP7RWx5Rgl3Mddh1Wc4O1YJY2UfdhVh3qCzQwghhBB7vk6xykblVTQ4OzlHziyL9wSdHUIIIYR4HQBq5QTlbF/FDp0dQgghhJwqIjnZignKOQViR/f/8QadHUIIIYT45+xYQOzYbHR2CCGEEBJqZ0fn7FggjJV7wkioBqllC9+Xzg4hhBBC5NQeH5yd8tZxdnIKXB0MJE0qXvi+HBdBCCGEkCIbCjo7O7nHjMnnZpLtlK+TkOCjs8MwFiGEEBK/FDUqwp4InGANdyfbx3wdZ2cnP9t8keYHFDuEEEJIqMg5LpJztGhnJzHJIS7MrsjK8bESy1nsRFkoi2KHEEIICRWn9jpEQUqpwve1Sq+dbD+cncRUkYSCRokUO4QQQkgcol0anYBcGFbptZPth9hBTk8Ulp9T7BBCCCGhQgsXnYBcGFYZGZF92PcwVpSWn1PsEEIIISEfqFlEvxorhbFy/HB2AJ0dQgghJI7xR+xEYxgL0NkhhBBC4hi72PEjjJUVRdVYgM4OIYQQEt4xTpZGCxe/nJ0oqsYCdHYIIYSQ8DBypMg554hs2SLWJSeQnB2rhLHK+rZ/FI6MoNghhBASFUybJrJzp8i990qM5OxYZBhojp9hrJToGxlBsUMIIcTy5OaK7CmYrzlzpsjChRIDOTsWGQaa7WcYK4nODiGEEBJyIHTy8x33R4wQycuTKM/ZsUCfHZvN/9Jz7exgNEaUQLFDCCHE8iB8BSpVEilTRmTdOpHJkyU2+uwgHJSXLaaQe1zElu9fGEs7O3l0dgghhJCQi5369UXGjjVujxkjcuyYWFPs+NRB2WnyuVnuTvYRx8yrpGL+JSjT2SGEEEJCx65dxrp6dZGhQ0Vq1xbZv19k3DixDnlZInknfXd2EhId+5kldnKcQliYe+VPGIvODiGEEBJ6Z6dGDZHUVJHnnjPuv/SSyOnTYi1XB25NSoZvP6N77Zg1MiLbz0os5zAWnR3/eeaZZyQhIUGGDRtm33b69GkZOnSolC9fXkqWLCm9evWS/ZDyTuzcuVO6du0q6enpUrFiRRk5cqTkIm2fEEJITIod0K2bSFqaIXT27RNrYB+omWG4Nr5g9nysbD+Tk0FKKWOda7UYosXFzsqVK+XNN9+Uxo0bu2wfPny4zJw5U6ZPny5Lly6VPXv2SM+ePe2P5+XlKaGTnZ0ty5Ytk/fee0+mTJkiY3VAlxBCSEyFsbTYQcQFycrAcmLHl3wdTVoFY531r0TFxHNQrODEn7LKiY8CsXP8+HHp06ePTJo0ScqWdcQ4MzMz5Z133pEXX3xR2rVrJ82bN5fJkycrUbNixQq1z7x582Tjxo3y4YcfStOmTaVz587yxBNPyMSJE5UAIoQQElvODnJ2NFrsuBn+5qHzbnztRGwFsZMTgLNTvKqxPr03CuZ3WETsIEwFd6ZDhw4u21evXi05OTku2+vVqyc1atSQ5cuXq/tYN2rUSCrp33gR6dSpkxw9elQ2bNjg9TWzsrLUPs4LIYQQa3L8uMjhw9EgdvwoO9cUO8tkZ+eI/2JHOzv5OeaF36JJ7EybNk1++eUXGechnX7fvn2SmpoqZdBQwQkIGzym93EWOvpx/Zg38HoZGRn2pbrz/x5CCCGWDGHhclC6tGN75cpWFTvRFMY6EkCCcqpIWoFIO1XQ1trimCZ2du3aJffcc4989NFHUqyYj7X9IWL06NEqTKYXHAshhJDoCWHFjLNjFzv/iLlhrLL+/ZwOZVHsFA7CVAcOHJBmzZpJcnKyWpCEPGHCBHUbDg3ybo4cKfggCkA1VuUCOY+1e3WWvq/38URaWpqULl3aZSGEEBIdlViWFTv+jIrQaIckmsJYgGLHN9q3by/r16+XNWvW2JcWLVqoZGV9OyUlRRY6TXvbvHmzKjVv3bq1uo81ngOiSTN//nwlXho0aGDK+yKEEBKnYicoZ8fkBOUUf8VOFWN9aq9EA8lmvXCpUqWkYcOGLttKlCiheuro7QMHDpQRI0ZIuXLllIC56667lMC5+OKL1eMdO3ZUoqZv374yfvx4laczZswYlfQM94YQQkhsdU92xrKl54Hk7Jw2KYyVHR/OjmlixxdeeuklSUxMVM0EUUGFSqvXXnvN/nhSUpLMmjVLhgwZokQQxFL//v3l8ccfN/W4CSGExKOzcyjwaiw06MO4iaS06BA76RQ7AbNkyRKX+0hcRs8cLN6oWbOmzJ49OwJHRwghxEpiR6dmonsIOilHuNYlNGEs1W05ScSWZ5RxaxFh+TBW1agSO6b32SGEEEK8kZ8v8vffnsNYGRnGnCzLuDuBdFDGWAn7fKwIh7Js+SI5mYE5O8WiK2eHYocQQohl+ecfNII1xkOcfbbrY84jI0wXO+gkHIizY2ZFVu5xQ/AEFcba63gOC0OxQwghxPIhrKpVRVJSznzcMmIn75RIflaAYsekiqzsghBWYppIkp8xQNVFOUHElmteJZkfUOwQQgiJukosy1VkaVcH+TfJBVPBrV6RlX04MFcHJKY4kqujIG+HYocQQkjUJSdbztlxDmEhvhYNYazsACuxzkhStn7eDsUOIYQQyxKVYsdfzApj5QRYiRWFFVkUO4QQQqJuLpblhoEG0mPH7PlY2QHOxXIXOycpdgghhJCgc3aix9nxo+xcUyxaw1hVjDWdHUIIISRwGMaKgjDWaebsEEIIIQGB/jq6yqqoaizTxU4gE88tE8YqE9jPM4xFCCGEBMfu3cYaYyAqFOgBb2LnyBFjZETUOztoThhpZyeVCcqEEEKI6SEsb9XcZcs6mg0eOCDRmbOjxU5+jjEQNNLOTkqQOTun94nk54mVodghhBASlZVYlhoZEYyzk5wukpQe+caC2UE6O/YuynmW76JMsUMIISQqK7E01hA7QeTsmJWknBOks5OYXCB4rB/KotghhBASlaMirCV2Aph4bnb5eXaQzk4U5e1Q7BBCCLEkWrzoxoFRIXaiydnJDoXYiY5eOxQ7hBBCLMm/Bdf9swpMD2+YPgwUFVQhEzsRytmx5YvkZAYXxoqi+VgUO4QQQizJPwXXfW9l55ZxdnKPi9hygxQ7EQ5j5RyF4jFuM4xFCCGEmCt2fHV2TBM72tVJTHVUVVk9jJVdEMJKKi6SlBb48zCMRQghhARGbq7I4cO+OTumDwN1DmF5awjkq9iJVOl5TgjydQCdHUIIISQwDh1yNBMuX97qzk6QZedmVGNlB1l2rklnzg4hhBASVAirXDmR5GTfxA6coOxsia7uyWaHsVJD5OxYvIsyxQ4hhMQZBw+KNG0qMm6cWL4Sq6gQlh4ZoQWRKSMjgq3EMqMaKydEzk5aRZGERKO6K8vMeR2FQ7FDCCFxxsKFImvXiowfL5KXF93JySAxUaRiRRPLz0Mids5yPFd+QWVXsGAa+cmCaaruZB001qkZwb1GYlJUdFGm2CGEkDhDCwJMCv/lF4l6sWN63k5WCHJ21M8muOYABQOGis5tKTLnwoIyczf++d5Yl64f/GtFQa8dih1CCIkznAXBggUS9WEs0yuyQpGzgzlTWiyFoiILLgsWhMV2z3Z9LO+0yN75xu2zrwn+taKgIotihxBC4gznUI9VxU5UOTuhCGOFuiLLOXy163PXx/YtEsk7KZJeTaRs0+BfS/faQdjMolDsEEJIHIudH34QOXlSLEdcip1QVmQ5uyx7ZovkOn3Iu7821lWvDrwvkMeKLIaxCCGEWARnQYBSbQieaA9jhVPsIIl7wwZH358z0Dk2gU48D0dFlrPYyTspsneecRtvYves0IWwgE5QPm3mJNbCodghhJA4dXYaNbJuKMtKzs7774s0bChy773hdnbCEcYqcG50KOvwryKndhtjLSq3k5BQrCBh6pRZk1iLhmKHEELiiPx8hyC45ZbYETs6QTkcpee6Ym3CBJGNG6MsjKXdm90zRfKyjTWo0lEkqZiEhOKVHY0FLYqpYuf111+Xxo0bS+nSpdXSunVrmTNnjv3xtm3bSkJCgsty++23uzzHzp07pWvXrpKeni4VK1aUkSNHSi6GqhBCCDkDdBnWfyJ79zbWv/7qCBtZAURarBTG0sIL4ayRIz3sUL2XSLUeRoO9YAjlfCwtdmpcZzgvOZki+xc6xE6oQljuYSyvsb44FjvVqlWTZ555RlavXi2rVq2Sdu3aSbdu3WQDgqMFDBo0SPbu3WtfxqMLVgF5eXlK6GRnZ8uyZcvkvffekylTpsjYsWNNekeEEGJttPOBMQzVqztCWYsWiWU4dswx9sFfZwcztUI9MkKLHTB7tsi8gvQXO63eErniC5FiPiqzSISxEKoCqLiq3sO4vfkVkUOrjdBW1a4ScrGDknZPPX3iXexcc8010qVLF6lTp46cf/758tRTT0nJkiVlxYoV9n3g2FSuXNm+wAHSzJs3TzZu3CgffvihNG3aVDp37ixPPPGETJw4UQkgQgghrmjnQ4uDDh2sF8rS4iI93Vh8IZwjI/TxYMQGGDHC4Y6FlFCGsXQZOCqlqvcybu8tiJyUv0ikeIFACQXJ6SLJpSwdyrJMzg5cmmnTpsmJEydUOEvz0UcfSYUKFaRhw4YyevRoOelUI7l8+XJp1KiRVNL+pYh06tRJjh496uIOuZOVlaX2cV4IISSenB39Z9OKYsffEJYeGaHfU6jzdrTYefFFwxHD5eWddyT0hKoaK+eYSO4xh9ipeIVrw8Nq10rIseftWLMiy3Sxs379euXmpKWlqXycGTNmSIMGDdRjN998s3JtFi9erITOBx98ILfojDr1C73PRegAfR+PeWPcuHGSkZFhX6rDyyWEkDhA/2nUzs4VV4ikpIhs3y7y558SlcnJ4UxSds4fqlNH5NFHjdsPPyySmSmhJVRNBXW+DtyWlFIiiSki1bo5Hg9lvk6UVGSZLnbq1q0ra9askZ9++kmGDBki/fv3V6EpMHjwYOXUwL3p06ePvP/++0oMbdu2LajXhHDKzMy0L7t27QrRuyGEkOgKY5UsKaLN9PkFEwSiVeyEI0kZ88N0yArHgxqZunWNY3zuOQmPs5N3yrUJYKBiJ72g2R+ocYNaScnzRDIaSsixeK8d08VOamqq1K5dW5o3b64clyZNmsj//vc/j/u2atVKrbdu3arWyOHZ7/Zbre/jMW/ARdIVYHohhJB4DGOBNm2M9U8/SdSGscLl7GjhVaoUrh2GC4Zw1l13iQwfLqEluaSjHDwY0WDP1znbsa1KJ5FLpopcMSM0XZOjrPzcdLHjTn5+vsqp8QQcIFClijGHA7k9CIMdcMpGmz9/vhIvOhRGCCHEexgLnH++sUYoKxbCWKF0djwdS5cuRs+d8uUltECE6NELzrOtAq3E0s+ln/uc3iJlCsrv4iyMVZC7bg4IJ6GCqkaNGnLs2DGZOnWqLFmyRObOnatCVbiPaq3y5cvLunXrZPjw4XLFFVeo3jygY8eOStT07dtXlaQjT2fMmDEydOhQ5d4QQghxRQsBZ2enVq3YEDvhSFAO9FgCBqXix/8UOfl38GEsZ7ETbiwexjJV7MCR6devn+qfg0RhiBgInSuvvFLl0SxYsEBefvllVaGFJOJevXopMaNJSkqSWbNmqVwfuDwlSpRQOT+PP/64mW+LEEKiytnRYgfpizk5RqjGTKwYxoqY2NGhJ+3ORIvYKW7tMJapYuedQmr3IG6WLl1a5HPUrFlTZqPLEyGEkEJBB2B98XYWO7gNMxwZBBA8554rpmKlMJbOkoioswOCcXZ0CCzdKWcn3OgwlkWdHcvl7BBCCAmfY4LZWEjfcHZN0KPmnHOsE8qK+zCWr87OtndF5rYWObLeWmEsW75YDYodQgiJE7QIwIVbdxu2Yt5OsGEs9Ik9dSrKw1iFOTto/rN2jMhPA0UOrhDZNtn1MVPETkVjnZ/jGIxqISh2CCEkjpOTrSZ2EErTTe39FRjoIqJrU0IVyjLN2fFWjYXJ5StuFdnwlGPboVWO29mHRPILxiUVNyqXI0JSmmPqu3soa/uHIn9/LZId6i6MvkOxQwghcZycbDWxo12dpCSRMmX8+1mE50KdpBx5saMTlPeI5Oe5PpZ7SmTp1SLb3xdJSBKpf7+x/fAvjn21SEKDQgiQSFLMS/n5L8NFvusmcjy4hsDBQLFDCCFxQjSJHfSwQS6Rv0S92IFgSEgUseWKZLlNNP1rqsi++SLJJUTazBRp8rTRiDD3hMjRTcY+ZoSwCqvIOn2gYPxFgkjpemIWFDuEEBInFBbG0hVYZoudYMVFKEdGIP0l4mInMdnhkLiHsnQicu3/E6naWSQxSaRcc9dQlplip5iHXjuZBUO5S9YypqObBMUOIYTECb44OxAJJ4MYyxQswYqLUDo7x46JZGdHWOwUVn5+bIuxLlXQ8hqUb2msD640r+y8sDDWkQKxk3GBmAnFDiGExAmFiZ2yZUUyMozbO3ZI1FVihaPXjhZexYuLlCghkcNbY0G72Knj2FauhavYsUQYa/+Zzg7FDiGEELPDWM7uzp9/StSHsULh7OhjqVhQVW2qs4OSboyRAKU9ODtH1hqVWpYIY+1zbKPYIYQQYhVnxypJylYKY0U8X6ew8vPjO0RseSJJxV2FTIlaIqnljHLzzPVOQ0AtEMay2Sh2CCGERA7MvDp40Ddnxwpix0phrIiLHXsY62/PISxUaznX2zuHsrSzk26BBOXT+42+PzheEyuxAMUOIYTEAXrGE/rXoKzbqmJH5+yEIowFYyFmnJ1jf5yZr+Meyvp3hUNomJmzk3XA6PuTudG4X+JckeTiYiYUO4QQEgfosA7EgLf+NVYQO6HK2UFF2fHj5h5LwOhKKuTsaMXmKTlZo52dvXOMuVRoOJgW6UQjEUnDiUowjgG9dXQIq4y5ISxAsUMIIXFAUcnJ7mInWFfErDBWyZKOyqlgQ1mmh7HyTorkHPFedu7u7KCBn86dQQ+eSJOYbHRuVsey3zL5OgGLndzcXFmwYIG8+eabcgyNCERkz549cjxYGU0IISQsFJWcDPTkc8ymOmzCLEdMZNd5RcEIjFAlKZsmdhDyQdKxcyirsDAWQlY6OVjfN4viTl2Uo1ns/PXXX9KoUSPp1q2bDB06VP4p+G149tln5b777gvHMRJCCImA2ElPdzg/ZoSyILAgeIJxdmJC7LiXn+edFjmx07vYQZKydnfUz5oodoo5VWRFs9i55557pEWLFnL48GEpjk5LBfTo0UMWLlwY6uMjhBASoTCW2WMjtLjA9PLU1MCfJ1QjI0wVO86NBVV/HZtISmmRYl5ycco5iR0zys7dK7IOrxHJPlxQiVVXzCbZ3x/4/vvvZdmyZZLq9pt4zjnnyO7dXkbSE0IIsbyzo/N2li83R+wEW4kVs87OUacQFlwcT5QvSFK2Shhr/yJjXfI8kaRiEnViJz8/X/Ly3MbOi8jff/8tpUqVCtVxEUIIMcHZMbMiK9jk5FD22kE1l54RZq7Y2S2SlO49hOVekWW22ClWydHR2SIhrIDCWB07dpSXX37Zfj8hIUElJj/yyCPSpUuXUB8fIYSQCDs74RQ7X34p8tprjtwcDe5PnWrcrlIluNcIxcgILbwQxDDle7xz+XlhlViaYmcZ3ZRBiRoROEAvOCdKW0js+O3svPDCC9KpUydp0KCBnD59Wm6++WbZsmWLVKhQQT7++OPwHCUhhJCoFzsICtx8s8ipUyKLF4t88IFIsWJGmfuwYSKffSaSkmLcNjuM5RzC8hY5CivFqzlydlCCXpSzAy56Q2T/EpGKbcT0MFa0i51q1arJ2rVrZdq0abJu3Trl6gwcOFD69OnjkrBMCCHEGpw+LZKZ6V8YC5PP4bZ4a0AYCBAfEDoAwgb3v/pK5M03RV55xdj+/vsibdpENoyVnS1y/fUi5cqJvPuuIW5Mzddxd3bQoM8XsVOlo7GYSbFKsSF21A8lJ8stt9wS+qMhhBAScrTDgZBMmTKF71u9ujFSIitLZO9ekbNDWNiza5ej2gqC4ocfRBo3FtG1LS+9JHLTTcG/jvvIiKKcmSlTRL7+2rh9770iDRtaQewUODuYLaUpSuxYgWJOzg46OVugEisgsfM+ZHch9OvXL5jjIYQQEmL2FMyGrFq16At/crIheODsIJQVDrEDMfHGGyKdOzuEzqhRwYev3MUOHJsjR0TKlvW+L/Z56inH/c8/t4jYSckwEpN1CCutvEhaQaNBK5NW3hA5mNBeqrZIUppEpdhBnx1ncnJy5OTJk6oUPT09nWKHEEIsBhwaLXZ8AaEsLXYuuyz0YgdiqlEjkRUrRO68U+SCC0SefDJ0r4M8oIwMI3SHUFZhYmfyZJGdBf36tNh55BELiB2oUrg7unNyyShwdQD66qAX0Km9lglhAb+jsWgm6LwgZ2fz5s1y2WWXMUGZEEIs7uz4gh4b4SwCQi12QLVqRnUWnJVQJwH7kqSMUJ12dR591AjfrV8vsmWLBcSOc94OKF1IJZZVQ1kZUSx2PFGnTh155plnznB9CCGEWEfs+FrSXaNGeMTO33+7ip1w4ovYQTIyBBhEIMJo//mPsf2LLywidnRFVrTk62hK1zfWFVqLVQhZnj2SljEMlBBCSHQ7OzVrGuu//gqvsxNOihoZAVfn6aeN26NHG6GvXr0coSzLOTvRJHZaThRpv0ikylViFfzO2flap6wXYLPZZO/evfLqq6/KpZdeGspjI4QQYkLOTricnUiKnaKcnXfeMZwmJGDfdpuxrXt3kTvuEFm50sj5MV/sODs7URTGSi0jUqnAJrMIfoud7vhtcAIdlM866yxp166dajhICCEkdpwdX0q3fSEnxyG6Iil29Gu68+qrxvqBBwxXR/8MErK//97Rl6iil7mbkRc7tU08kOgnMZDZWM4L5mTt27dPpk6dKlX87PH9+uuvS+PGjaV06dJqad26tcyZM8f+ODo0Dx06VMqXLy8lS5aUXr16yX43T3Lnzp3StWtXVQlWsWJFGTlypOTm5vr7tgghJGbxN2cHicMAs6EOHQrdMUA4oddPJNwS7U55CsXhEvFHQZFTt26uj/Xs6XrfVGcHQzRBeg2RFM6eDIYQ9sb0H3RjRmLz6tWrZdWqVcod6tatm2zYsEE9Pnz4cJk5c6ZMnz5dli5dqnKCejr9JkJoQehkZ2erSezvvfeeTJkyRcaOHWviuyKEEOuAjsWHD/vn7MDp0Dkvocrb0SEsCKlQdmUOZOwFwlcYXYHRFO7nxFnsoOdQUU0Yw0qZhiKt3ha5tGBoGAmYBBuSbopgxIgRPj/hiy++GPjRYHBruXLy3HPPyXXXXafCY3CMcBv8/vvvUr9+fVm+fLlcfPHFygW6+uqrlQiqVPA/84033pBRo0bJP//8o3r/+MLRo0clIyNDMjMzlcNECCG+gtJlNMj79lujX4zVwMX+3HMNAQOnxteQVKtWIj//LDJjhpHLEizoTIK5WBgFsWSJhB2EryBkIKwwLgPCRoO5XO3aoZLY4fA4c9FFRt4OwlrewmDEGvh6/fYpZ+fXX3/16UWRvxMocGng4Jw4cUKFs+D2oGFhhw4d7PvUq1dPatSoYRc7WDdq1MgudACGlA4ZMkS5QxdeeGHAx0MIIb5exOEUPPigMefJyiEsf/5EIwwEsRNqZycS+ToAQgUCD0IHidbnFUSEnN0e7f64A3cHYsfUEBYJKT6JncWQwWFi/fr1StwgPwd5OTNmzFAT1desWaOcmTJuHiKEDXKEANbOQkc/rh/zRlZWllqclSEhhPgLfHEtBlCounq1SPPmEtXJye5JyqGqyIq02IGwQ3PE3383xI0/YmfgQJEFC0RuvDEyx0piPGcH1K1bVwmbn376STky/fv3l40bN4b1NceNG6dsL71Uj9T/PkJITIG5S8ePO+4/9phEfdm5Lwm+0SB2CsvbKUrswNGB2Bk0KMwHSKw99RzJxJ9++qmqhEJysDNfoPWkH8C9qV3bKKlr3ry5rFy5Uv73v//JjTfeqJ77yJEjLu4OqrEqF9QUYv0zfFYndLWW3scTo0ePdslDgrNDwUMI8RctBIoXN5rUzZyJv48iLVqIZbCas6Mrvawsdkjs4bezM23aNLnkkktk06ZNKuSEvBrkxyxatEi5JMGCcnaEmCB8UlJSZOHChfbHMIMLAgthL4A1wmAHDhyw7zN//nyVpIRQmDfS0tLs5e56IYQQf9FCAH9ukHyrZyxFc9l5uBoLRpOzQ2IPv8XO008/LS+99JIqCYcrAxcGVVI33HCDSh72Bzgs3333nezYsUOJFtxfsmSJ9OnTRwmngQMHKgcGOUNIWB4wYIASOEhOBh07dlSipm/fvrJ27VqZO3eujBkzRvXmgaAhhJBwooUAXJCHHzYqf775xkhujRVnB2Y5knyDAT+vxy+YLXZQiq9DexQ78YPfYmfbtm2qtw2A2EH1FKqw0BPnrbfe8uu54Mj069dP5e20b99ehbAgWK688kr1OEQVSsvRTPCKK65QoSnnMFlSUpLMmjVLrSGCbrnlFvV8jz/+uL9vixBCAg5j4Xve+eeL3HKL9dydQHN2ypYVKVHC1ZUJdgAown3lyompYkd/ZiVLipQvH7ljIVGWs1O2bFk5duyYun322WfLb7/9psq/kVtzEk0c/OAdDCcphGLFisnEiRPV4o2aNWvK7Nmz/XpdQggJtbMDxowR+fBDEfxJgqPir8CwUhgL1Ux4X6gXgUBAT5pQhLBCMXrCX7GDTIcTJwzx5hzCiuSxkChxdiBqABwW5MWA66+/Xu655x4ZNGiQ9O7dW7kzhBASj84OgCBAAz+wZYuYDr5/omIMBCK8QpW3Y0a+jnandCrpjh3G+s8/jbX+nEh84LPYwQyrVq1aKRcHIgc89NBDKqcGFVAINRXl1BBCSCyhRYBzuqK+iOqLqhVCWAgfBVI/4jwQNBRhLDOKXt1DWUxOjk98DmNhNtXkyZNVj5qnnnpKiZvbbrtNHsDIWEIIiTNQaq7FhBYFVhU7cHUCCdlEu7OjP481ayh24h2fnZ3LL79c3n33Xdm7d6+88sorqoKqTZs2cv7558uzzz5baMdiQgiJNZyTbitUsKbYCTRfJ9TOjplih84OCagaq0SJEqoEHE7PH3/8oUJaSCBG2fm1117Ls0oIibt8HWfXxIpiJ9BE6VhwdrSo0Z8HxU58EtS4CHQ+fvDBB1Vvm1KlSsk3aDBBCCFxmq8Tq2IHYiU/P7rFDkQOkrV1wjbmZpH4IWCxg2aAt956q+p9M3LkSOnZs6f8+OOPoT06QgiJkrJzd7GDcmfnuVnR1GNHc/bZRqNETAUqmMRTJJ99ZggM/d0XJd+HD1tD7GhXB7Ov0GeHxA9+iZ09e/aoDsrI02nbtq1s3bpVJkyYoLZPmjTJ3tmYEELirexcg6on3TjPfUxBtOXsJCcbgsfXUBZ68vTvb5R5DxggcvCgw9XBVB4zJvNoBwft4TCVHjCEFX/4LHY6d+6sGvghOblHjx5qNtYPP/yg8neQx0MIIfGEN2fHSqGsYMNY/iQpw8FBVxLdWxbjIYYPN2cAqDNIINdzoRctMtYUO/GHz6XnGMr52WefqfENGM9ACCHxjDdnR4sdTD83W+wEG8byNUnZZhO54w7D2YGL9MYbIt27i3zwgVGib1YISwNxg4JhLXbYUDD+8NnZ+frrr6Vbt24UOoSQuAcXd28JylZxduC0ZGYGF8by1dmZPFnk/feN/J6PPxZBYe499xiPffqpNcQO0HlHdHbij6CqsQghJB5B8jEcC5ScewrPWEHsaFcnPT24XJminB3kJQ0datx+4gmRNm2M208+6VrxZAWx4+0+iX0odgghxE/0hR+OSWqqNcWOc75OMAMvi3J2Fi4UOX1apGVLEeeG+kjlfOstx32KHWImFDuEEOIn+sLvKTnZWezA9QimP43Z+Tq+ODs6AblZMyOM5cyVVxoCCEKnQwcxDWdxg2P0FHoksQ3FDiGE+Elh+ToAF3ekNyLUpR2WaCs71+j3iF45KN/2NjbDW7XVuHHG+bKKs4PjTEkx71iIOVDsEEJICMvOdX8a/ZhZoaxQlJ2DUqVEypb1HsoqSuxYAS0+AUNY8QnFDiHEkqxdK9K6taMTb7SUnWvOOy82xE5ReTta7Jjp3BQFxKc+Poqd+IRihxBiOZDnMmiQyIoVIm++KVHn7FghSTlUYSygq6o8iR2zmwb6ihY5FDvxic9NBQkhJFJMnSqycqU1Ri4E6uxEWuzs3i3yxRciy5cbC0Y2hNvZOXrUkcejx0pYlV69RH79VeSqq8w+EmIGFDuEEEuBcQOjRzvuQ+ygiV8w5dOhbtaHmU9WETuY9/TSSyKffCKSm+vYjvN12WUirVqFTuxoAeUewipTxvqDNdELCF2erfJ7RCILxQ4hxFK88IJxEYWQQIgE4uLff41J1VYKYaFRHy7yZokdnKNbbhFZutSx7dJLRTp1MnKd0PcGQ0lDgTdnJxrydZyh0IlfKHYIIZYBeSbPPGPcHj9e5N57jfAM3B2riZ2ierVosYMRBRBsoZ6XjLlTEDpIvr3pJpFhw0SaN5ew4C1nJ1rydQhhgjIhxDI89JARxoIzccMNjmRSK+XtFNVQUAPXR5dsh+P4t2411mPGGMInXELH+b1imCa6JUdT2TkhgGKHEGIJtmwRee894zZyUBBysKLY8dXZCXcoSz9n7doSdsqVczhTzp2UKXZItECxQwixBIsXG4nIGCSpk2q12DFzxpQnUebcR8dssaNfI5xAeHoKZUVbzg6JXyh2CCGW4KefjPUllzi2WdHZ2bzZWJ9/vnliJzvbkS8TCbHjLUmZOTskWqDYIYRYSuw4l0pbTeyg2aF2durWNU/sQHDABUtPF6lYUSKCp/JzhrFItECxQwgxHTSn27jRu9hBnkhenpgOKsOQQI0KKF868Wqxs21b+EJYkSqndnd20EwwM9O4TbFDrA7FDiHEdFatMpwKJP1WruzYjq68mFCdk2MIDbP54w+HyPBlcrbO64EzFUqxFsl8HY17zo7+PNBvCMNCCbEyFDuEEEuGsAAmVeuqJyuEsnS+ji8hLIBjT0sTycryPFcqmsSOexhL5+swOZlEAxQ7hBDLih2r5e34k5ysxZouDdeuULSLHTg6cNqYr0OiCVPFzrhx46Rly5ZSqlQpqVixonTv3l02678mBbRt21YSEhJclttvv91ln507d0rXrl0lPT1dPc/IkSMl13lIDCHEsiB8pcXOxRdbW+xoweKrs+O8r9uftqgTO5UqGS4VkrQheCh2SDRhqthZunSpDB06VFasWCHz58+XnJwc6dixo5xAb3UnBg0aJHv37rUv49FHvoC8vDwldLKzs2XZsmXy3nvvyZQpU2Ts2LEmvCNCiL8gHILOvEj6bdbszMf1BT0anR3nfUPl7EAcmiF2EhMdIUWEsih2SDRh6mysb7/91uU+RAqcmdWrV8sVV1xh3w7HprJz1qIT8+bNk40bN8qCBQukUqVK0rRpU3niiSdk1KhR8uijj0pqamrY3wchJHBWrDDWjRuLFC9uXWcHeTc6X8VMZ+fQIaN6zTlpOJKhLJTeI/+IOTskmrBUzk5mQR1jOfQmd+Kjjz6SChUqSMOGDWX06NFyErWfBSxfvlwaNWqkhI6mU6dOcvToUdmwYUMEj54QEup8HSt1UcYsKrgqqD5y+nMTcbGjz0PVqp7FYaTKz+nskGjCMlPP8/PzZdiwYXLppZcqUaO5+eabpWbNmlK1alVZt26dcmyQ1/PFF1+ox/ft2+cidIC+j8c8kZWVpRYNhBEhxNpiBxPRMYSyWDExPYTlT28bHcaCOAjF9HMzQlieys8pdkg0YRmxg9yd3377TX744QeX7YMHD7bfhoNTpUoVad++vWzbtk3O82U4jZfE6MceeyzoYyaEBAeqelavLlzsVKhgCAQIBVxk/QkhmZ2cDMqXN5aDB40QUNOm0St2tLODBpCHDxu3KXZINGCJMNadd94ps2bNksWLF0u1Iv7ntCr4i7gVnrKgAVll2b9/v8s++r63PB+EwhAy08suHXwmhESU9esNtyYjw3vSr1Wmn/vbY8cZ/d5CEcqygtjRAhXNBPHZEWJ1TBU7NptNCZ0ZM2bIokWLpJYP/dfXrFmj1nB4QOvWrWX9+vVy4MAB+z6o7CpdurQ0aNDA43OkpaWpx50XQoh5IayLLjKqfbxhBbGjnR1/KrE0WiCFoiLLCmEsOHKArg6JFpLNDl1NnTpVvvrqK9VrR+fYZGRkSPHixVWoCo936dJFypcvr3J2hg8friq1GqN0Q0SVqkPU9O3bV5Wk4znGjBmjnhuihhASvfk6VhI7wTg7oUxSNlPsICkajRL16AuKHRItmOrsvP766yqMhMaBcGr08sknn6jHUTaOknIImnr16sm9994rvXr1kpkzZ9qfIykpSYXAsIbLc8stt0i/fv3k8ccfN/GdEUJiSewg3wYLqFPH/58PVa+d7GxjKKpZYge9kJwFDsUOiRaSzQ5jFUb16tVV48GiQLXW7NmzQ3hkhMQWb78t8vvvIs89F7kp2UWxd69xTNEgdrRIwcU9kGoqZ2cHf/Z8/QyeftrIaUI9BX4GQgcdjFGR5iUlMSJ5O3rOF3vskGjBMtVYhJDwgHS2IUNEMEHlxhtFWrYUSzBjhkPonHWWtcVOMCEsgMJRiBV0uUD9hC9CZdMmkYcecozR6NLFNYRllmhF3s533xm36eyQaMES1ViEkPDx0UeG0AEFRYyWoKBVlvTqVfS+Wuyge3BB79GoSU4GcGJ0cq+voayPP3bcfvRR88ZEeKvIAhQ7JFqg2CEkhsEFcvJkx/1t28QSIP9lyRLjds+eRe+PEmf0qjHL3QnW2fE3SRmfm7PYWblSBJF6ih1CAoNih5AY5tdfjV42Gqs4O199ZVT0NGlihHh8wcxQVrDOjvPP+iJ20McGnxXGQSAEqd0dLVbNFDvO87godki0QLFDSAwzZYqx1o3fwu3sIMT03/+K3HOPyLRpRiKrpzoEf0JYGn2Bj7RggyhD5+NQOTu+hLG0q3PttYbISU8XWbXKcHfMFju6Gg1OW5ky5h0HIf5AsUNIjILxb8jXAffeGxmxg4s0wmYTJoj07m24AHBkvv/esQ+SdOfP91/sXHCBsQ7HfF9UO0FYHDt25mOogMK5TE11DeGEy9lBtVVB9w11DitWRJd54z4qs8wWOzVqGMcHwWqVyj5CioJih5AYZdYsI6EXjeD+7/8c5d4nT4bvNXVJMpqXt2hh9GXBtuuuM15bHxf6xcDpqF/f9+fW84Gdw3KhAM7T+PEiaN/17LNnPl7QtF1q1zYa6gXr7CDvRncg9gSE4e7dhmty1VXGtvvucy1596HZfFi54QaRK64w9xgI8QeKHUJiPITVr59R2q1DWTrJNRzoMXP9+xtJtRBbaHaO8ne4FKgKcw5h+eMMNGrkGEKpO/iGguPHHQLwhRccTfu0k/Lgg8btdu2Ce52zzzbCUTgHheUd6RAWzo9uAo/PT7s7KFvH8xBCfIdih5AYBJNX5swxbt96qyEqdCJwOENZWuzoZnOoopo+XaRkSRH0Bx01ynFc/oSwdOgGCbsQIKF8D9pxAnju0aMd9596ymh8CIERbFN2zP7S+S7eQllwfD77zLgNcejM/feLdO1qnENCiH9Q7BASg3z4oeF+tG7tCJ8gDBNpsaNzVSZNMm6/+KLhoiCX58IL/XtuhJD0bN/ffgu92ME8YIjCqVONMRbr1ok884zx2KuvipQtG/xrFZWkjFwmlOVDXLVt6/pYuXJGCHDYsOCPg5B4g2KHkBjurQNXRxNuZweJtX//7XmMwE03idx+u+M+eusEktwajrydgvnD0rSp43xBUAwcaIScevTw34UKNElZh7CQExNMfhAhxBWKHUJiDJQoI68FXXsxHiJSYgd5OQjDQMQgKdqdl14ykpZxEe/bN7DX0Hk74XB24KY8+aSRCLxihXEekec0cWLoXqtePWONz8cT/jRaJIT4DsUOITGGdnVwwdRJyZEQOzqEVaWKSErKmY9DfKHSCAnScFGCETvhcHZw3BBpzjkxSFjG9lChnSmINff+Q0eOOJyxQM8PIcQzHARKSAyBBFsdChkwwPUxLXZ27DDCMygLD3e+jifBgz4twYoFNPnDe8XzhcrZ0aIGPYmWLzeEDxokhhI4O3C20HwR5eXOHYi1W4Xz4yxSCSHBQ2eHkBgCYxjgEEBw/Oc/Z5Y+o5QZQkcLk0iLnWCBIEGiLvKDMBU81GEsgLJudCp+++3QN83D+dd5O+7ulL6vBR0hJHRQ7BASg7110OfGPcEVpc+6GV04QlmREDsQH86hoFCHsSKBt7wjfV8/TggJHRQ7hMQICIvMm+cQO57QoaxwzJeKhNgJR96Ou7MTbrwdP50dQsIHxQ4hMcIHHxjhncsvd/TUcSecScqREjuhdHYwtuLffyPr7Hg6fiQr09khJHxQ7BASw7113AlnY8FodHZQLg+QrI0p3pHAeewF8qfAnj0ihw8boUddnk4ICR0UO4TEAOgLg668SK69/nrv+4XL2cFFGxfsSIgdPf0cZdpIxg5FCKtSJSOnKRIgbwqfEyap689BuzpIXtbzsAghoYNih5AYQM+b6t7dmEfli9hx7/MSrGhACA0OCYRDOME0cC2ogg1luZedRwKIKi3YtDvFfB1CwgvFDiExgHYImjQpfD/MpEJF04kTjhBOKENYKG+PxJiDUHVSjnQllre8HS12mK9DSHig2CEkBti+3Vjr0nJvIESiXZFQhrK8zcSyepJypCuxvIk1vaazQ0h4oNghJI7ETrjydiKVnBzqJGWznR0cP6bT61lZdHYICQ8UO4REOadOOS7a8SJ2CpsxZfWcHWdRg35HeA8YfVG8uG+fHyHEfyh2CIlyMOsKIDEZoxTiQezoGVOHDjkESzSFsZDEXaGCkdQ9fbqxDUnLkch3IiQeodghJIZCWL7McgpHr51Iix0MANXvQ4eAoimM5Tz2Qg9uZb4OIeGDYoeQOMrXcXZ2MDk8VOXnWuw4T/EON3qgJt5HIOC9a7ETaWfHOZT155+u9wkhoYdih5A4Ezt164qkpBhjEvTPBjtyYf/+yDo7oE6d4MQOQmA4drPEjruTQ2eHkPBBsUNIlKMFy7nn+rY/uvdedJFxe/Hi0AwghUuCsvazzpKIOzvoHB0I2tVBnpMZXYvdnRw6O4SED4odQqIcHQbxp5LnP/8x1kuWhDaE5UvOkFWcHbOSkzW6i7IWXGYdByHxgKliZ9y4cdKyZUspVaqUVKxYUbp37y6bN2922ef06dMydOhQKV++vJQsWVJ69eol+7VnXsDOnTula9eukp6erp5n5MiRkqsn7BES4/gbxgJt2zrETrB5O5FOTnYXOxB7hf13R8XTK68Y4uKbb8xPTtaULi1Ss6bD1YmkUCQk3jBV7CxdulQJmRUrVsj8+fMlJydHOnbsKCfQy76A4cOHy8yZM2X69Olq/z179kjPnj3tj+fl5Smhk52dLcuWLZP33ntPpkyZImPHjjXpXRESOTApOzPTMQrCV1q3NvJ20Pk42Koss8QORlOgNw2Eji6/dwd9bOBi3X23UbX10kvm99jxlKfDfB1CwozNQhw4cADfMW1Lly5V948cOWJLSUmxTZ8+3b7Ppk2b1D7Lly9X92fPnm1LTEy07du3z77P66+/bitdurQtKyvLp9fNzMxUz4k1IdHE6tXwZWy2ihX9/9nLLzd+dtKk4I7hjjuM53nwQVvEadTIeO3Zs8987JVXbLbixY3H9To11WY7dsx4fPhwY9t999lM47PPbLaqVW22gj9nhBA/8fX6bamcncyCr6jlCjqjrV69Wrk9HTp0sO9Tr149qVGjhixfvlzdx7pRo0ZSyWnUcqdOneTo0aOyYcMGj6+TlZWlHndeCImXEJanUFY0OjvOoSz3JOXvvxe56y6ju3S7doarg3OE6iudlG12GAv06mUkeF98sXnHQEg8YBmxk5+fL8OGDZNLL71UGhZ4uvv27ZPU1FQpU6aMy74QNnhM7+MsdPTj+jFvuUIZGRn2pboZf6VJVIB8j+HDRa66yrFcfXVoqpisInbwXoLJ2zFT7HjrtbNokbHu1k1kwQIjxIfPDnz7rTUSlAkhkSNZLAJyd3777Tf54Ycfwv5ao0ePlhEjRtjvw9mh4CGegIH48stnbt+zR+SXXySqxQ7ydlJTjfeC3BbtksSCs/PTT8a6fXtH4m/nziKvvy4yZ44h7qyQs0MIiSNn584775RZs2bJ4sWLpZpTC9bKlSurxOMjR4647I9qLDym93GvztL39T7upKWlSenSpV0WQjyxYoWxRpjh/fdF3n7buHj++quR3BvNYgfJvTp84k8oC834Vq40lmXLRA4eNF/sODs7EDI//2zcdg4PIVEZSdk4Z9jfCmEsQkgciB2bzaaEzowZM2TRokVSy+0vdvPmzSUlJUUWLlxo34bSdJSat8bXUvXttLWsX79eDhw4YN8HlV0QMA0aNIjguyGxiHYIEA7p21dk4EDHBXTWLIlqseMeyioKTOe+7TaRqlWNpoRYLr3UeKxECRG3aHNEw1h//YVcPOM2qssgwNAosEkTx74lS4pcfrlxe8YMRxUbw1iExD6JZoeuPvzwQ5k6darqtYMcGyynkFUoovJpBg4cqEJOcH2QsDxgwAAlcC4uuOKgVB2ipm/fvrJ27VqZO3eujBkzRj03HBxCQiF2WrVybLvmGmM9c6aYChwMXXIdqNhxbi7oLW9n7Vr8PzN6wbzzjiEqIHjQI0Yv995rTp+YihWNae84dl1Crz+zCy80wnTOIJQFJk92DBTNyIjkERNCTMFmInh5T8vkyZPt+5w6dcp2xx132MqWLWtLT0+39ejRw7Z3716X59mxY4etc+fOtuLFi9sqVKhgu/fee205OTk+HwdLz4kn9uwxSpMTEmy2o0cd29evN7anpdlsx4+H7/VnzLDZRo+22bKzCz++xETv+xTFqVPG+8DzbN7seZ/LLnO8znXX2Ww//miz5efbLEOzZsbxffmlcf+uu4z799xz5r76s9NLrVoRP1xCSAjx9fptaoKyoXcKp1ixYjJx4kS1eKNmzZoye/bsEB8diXe0Q4DOu3APNLgPJwUhpPnzRbp3D/1rnz4t0r8/kueN1+vTx3sIC7kyyEUJBDgbMEmXLjVCWTospMnJEVm1ypGsrWdqWQkcM5LFdd6OJzdOg3OJtECdb8UQFiHxgSUSlAmxIt4umgjXhDuUBe2u2z9NmRK6mViFhbI85e2gVRWEF0I9LVqIJXGuyEKIbc0a72IHn50uQQdMTiYkPqDYIcQLhTkEWuxg1hJ68YSajz923EZ+/s6doU9O1rRp42jE5262alcHQifRon8tnCuyIHTQOLBCBe/nhWKHkPjDon++CDGXvDyjtBp46m57xRXGIEd0OdD7hQo4OrrSC8m/ECAoew+X2IGYQxgM/Xb0c2r0e7OqqwN06A3Ojm4VgPfkLWEaDdmTkozbDGMREh9Q7BDigU2bRI4fN8qVPXUwQJWPdghCHcr66isjdFS3rsjjjztCWe6uS6jEDvrtaDEDd8eTs9OypVgW7exArOnOyZ7cOA1CcroEPdhzRwiJDih2CCkkhAURoF0Ab6Gsr78O7WvrEFbv3sbsJCRHo6zaXYiESuwAffF3fg0IrnXrrC92MEqvYJye6o4Mipo1NWmSyPPPi9xwQ/iPjxBiPhQ7hHjAORziDfRsQR7L+vVGU7tQ8M8/IvPmOcQOmvXpC7JzojKqpPSYhlCIncsuO1PsoL9Obq7IWWeZ0x05kFAWzosv4qx2baM3UKBVbISQ6IJihxA/k5M15cs7OgiHqpvyZ58Z+ULNmjku4Lfeaqw//dQIrQEIHSRGo29mKPJO9PtA3ouevuIcwjKjYaA/OM/1qlfPnG7OhBDrQrFDiBsQFCi5Lkrs6GRX3YMm1CEsZyECJ+LECSNR+bXXHJ2A4eqEokoKYaCGDY3behZvNCQnexI7RX1mhJD4g2KHEDfgaMA1QegGYxEKQ4dLQlGRBbdGh5FuvNGxHa6KdneGDjUWODBItB01SkKGe96Ofk9WztfRODdDpNghhLhDsUNIACEsjRYCEB96sGSgfPKJo6zdPUemXz9Hfsl554lMmGB0AdYiKNRiB+4WKtIAnR1CSLRj6rgIQiIFEm0R7vEl5OOP2EHzunPOMQZyrl4t0q5dYMeHRngQMMDTaAiIn+++MwSVc5+YUKLFDhrzYXwESt0xWiEaetEgT6dSJSOHCQNLCSHEGTo7JOb5/XejX86IEb419NM5K746BNr50Am9gfDuu0YYCx19+/b1vA/KqTt1Co/QARA2EG4I4b3ySvSEsEB6usivv4r8/DMrrAghZ0KxQ2Keb781Zia9/bbRO8YbcDJuu80o/0bnYl+HXgabt4Nje/pp4/YDDxhN/sxCuztz50ZPCEsDoQh3hxBC3KHYITGPzj1BNdOSJd73Q5XT9OkiyclG/gxCIr6gBUGgYke7OkiGHjxYTEWLHU20ODuEEFIYFDskbsROYaMdkG+jw1zjx/uX5Nq8ubFGY0G4QoG6OqNHixQrJqaimwu6vzdCCIlmKHZIzLNxo6vYcZ8xdeSIyPXXG0nC3buLDBvm3/OjBBxzrALJ23nnHaOq6uyzjRCaFRJ9kXStq770GAZCCIlmKHZITAOn5eBBo1cNcmEQLsIYBGfuvtuYM4XkXISUAukWHEiSstVcHYD3rt0dhrAIIbECS89JxIDo+OIL4yKvQSKwHqgZzhAWhAxKkjG0E+5O06YO1+fDDx3di8uWDex1IAw++si/vJ0HHxTZvds6ro4GTQsR1rPSMRFCSDBQ7JCIgW6/CNu4s3ixSNu24Q1h1a9viCotdh5+2Nj++ONGWKtHj6InZfuapIznK8odeuEFkRdfNG5j7WsydCRAH5+dO80+CkIICR0MY5GIgUZ1oH17I0dGN3/zJIBC7exA7HTt6hAke/ca868wXBM8+mhwr3PhhUb/m337RPbsKXxfOEn33edIhtZTzQkhhIQHih0SEf79V2TrVuM2BAaWSZOM+59/bjTzC6fYadDA6MOi81AwpVy7Or16iTRuHHxTuwsuMG4XFspCz58BA4zbqP7SoocQQkj4oNghEQGdbfUMI13hg6Z9qP45dcrhsIQzjAV0fhBGM6CnDhg7NjSvVVS/HbhJ111njK7ASIjnngssGZoQQoh/UOyQiOBp3hQu9NrlmDIl9K8JtwgJwM5i59prjfVvvxmuDsRHsK6ORrtG3iqy5s0zGhsifIeqL1/mdBFCCAke/rklERU77knAt9xiXPR//NGYHB7qmVgAgyzLlDFuQ9g4TxQPlavjXn7u3ssHLFtmrK+6SiQ1NXSvSwghpHAodkjYwYVfh7HcOxNjRAIu/uC998ITwkK+jrObhMaBwDlJOhRASEHEHDpk9O3xJnYuuSR0r0kIIaRoKHZI2NmyReTwYaO82lPI6NZbHWInLy88lVjOIDH55ZdF3npLQgqEDqqywHffndmlGdVfoHXr0L4uIYSQwqHYIRELYTVr5jl8gzwaNPNDfs3CheEXOwhp3XOPI7QVSq680lF15X4O4HBhBAMncxNCSGSh2CGmJCc7A8fn5puN25MnhzeMFW50SA7JyM4ulQ5h0dUhhJDIQ7FDTBc7QFdlzZjhOk4iUE6fduTNuDs74QTvEY4RwnbOJejLlxtr5usQQkjkodghYQWiQw/eLEzsIMSFUBaEjg4/BQMqu/LzDeERybBRcrIjlDVnjrGGw7NihXGbYocQQiIPxQ4JK7/+KpKTI1KxojGM0xuoktLJy+5TyYMNYUW6cZ8OZem8HSQmHzsmUrKkSMOGkT0WQgghJoud7777Tq655hqpWrWqJCQkyJdffuny+K233qq2Oy9X6StJAYcOHZI+ffpI6dKlpUyZMjJw4EA5fvx4hN8J8SWEVZTo0GJn3brwJSdHAv0rijAWxmTofB30GML8LEIIIXEkdk6cOCFNmjSRiRMnet0H4mbv3r325eOPP3Z5HEJnw4YNMn/+fJk1a5YSUIMHD47A0RNf0OGbwkJYmiZNYkPsoHcQhBuqr5CozP46hBBiLslmvnjnzp3VUhhpaWlSGS1wPbBp0yb59ttvZeXKldKioH3tK6+8Il26dJHnn39eOUbE+snJGucwFoRCMOEnMyqx3N0diDaEsih2CCHEXCyfs7NkyRKpWLGi1K1bV4YMGSIHDx60P7Z8+XIVutJCB3To0EESExPlJ32V9UBWVpYcPXrUZSGh58ABkR07DNGi50YVBqaGY3TEP/+I7N8f+OsiRwiNDM1ydoDW8F9/LbJtm++CjxBCSJyJHYSw3n//fVm4cKE8++yzsnTpUuUE5RU0MNm3b58SQs4kJydLuXLl1GPeGDdunGRkZNiX6s7DkkjI0HoTk80zMorePz3dmIoeTCgLjtDdd4tkZxvT1WvUEFOAi4OE5MxMh5ALRxNDQgghUS52brrpJrn22mulUaNG0r17d5WTg5AV3J5gGD16tGRmZtqXXbt2SbSVc8PMQrKrXtCZ+NFHxVKsXm2sL7rI958JNkn5iSdE3njDcJPefNO8yeL4PNq3d9xnCIsQQszD0mLHnXPPPVcqVKggW7duVfeRy3MAsRIncnNzVYWWtzwfnQeE6i3nJZqYNcsQEugjoxeEbp5/XsRKhWhr1hhrPS/KF4IpP8esq0ceMW4j5/2668RUnNPRKHYIIcQ8okrs/P333ypnp0qVKup+69at5ciRI7JaWwgismjRIsnPz5dWMZwgoQvSMN9pzx5jOf98VLeJTJ8uluqxE6jY8dfZQdeCIUOM2w8/7LhtJs5dEjgmghBC4lTsoB/OmjVr1AK2b9+ubu/cuVM9NnLkSFmxYoXs2LFD5e1069ZNateuLZ06dVL7169fX+X1DBo0SH7++Wf58ccf5c4771Thr1itxEIOyDffOEYsQPdh0ZPDp0wRS3DokMjOna4l5b6g90XpOPJufAETxm+6yXC4Bg0SeewxsQQ1ayI/TGTsWEOMEkIIMQmbiSxevNiGQ3Bf+vfvbzt58qStY8eOtrPOOsuWkpJiq1mzpm3QoEG2ffv2uTzHwYMHbb1797aVLFnSVrp0aduAAQNsx44d8+s4MjMz1etibXWmTEEKrs1Wv77Nlp/v2L5rl82WmGg8tnWrzXQWLTKOpVYt/34O76l0aeNn160ren/sk5Fh7N+tm82WkxPwIRNCCIkyfL1+m9pnp23bthBbXh+fO3dukc+ByqupU6dKvKBDWL17u/ahqVbNmMmEU/beeyKPPx6e18fHdeqUUTnlS75O06b+Pb8eG/HDD0beTqNG3vdFWTtMPrhdl11mnBvMpiKEEEKiNmcn3kH/mQULHGLHHR3KgthBSCccIHSGav+lS0Ofr+NPJ2WMYYDQ2bvXmDeFfjbFi/v/WoQQQmIfip0oAsnHaDGEsvPatc98vHt3o5cLcmUWLw7962OYJdwTJEIjR6awxn+BOju+JimPGmVMNkeLJEwXx8R0QgghxBMUO1EawvJEsWKOx8KRqDx/viNpGD0b+/QxxJenPkB6NlW4xI4ewfDaa0YIjxBCCPEGxU6UALcGeSzIabnxRu/76VDW5587uveGipkzjfXVVxs5OwsXijz5pOe5VLm5IuXLByZEEJbC+0SICqE7T2JKj4No1sz/5yeEEBJfUOxECdOmGesrrhA5+2zv+2EGFYZfIok4lD134OCgmSEYMcLoUgxQ5g3R4ylfB65OIMM8MWbhvPO8uzu//24cD0JXBS2XCCGEEK9Q7ESZ2PEWwtJAXNxyi6sTE6o5V0gKxowrVD717SsycKBRnYVwlnPn5mDydXwJZf32m7FGpVYwk9EJIYTEBxQ7UcCffxpuCWZg9epV9P4FPRdVkjLGSIQCLZwwAiElxbj9yiuGA4NE5cmTwyN2PI2NWL/eEe4ihBBCioJixyTgiLz+utEXpyiQfwPatBGpUKHo/SEyMPEb1VMrV0pIxc411zi2odT73nuN2y+9ZOTpoORdC5RAys7dy891SMybs0MIIYQUBcWOSUDA3HGHMT/p5puNEJE3vvjCWPvi6gBM+tYTt3VfnmCdpQ0bDGfJebgl6N/fSETevl1kxgxjDZGVliZSt27gr6lHm8HFcU+0prNDCCHEHyh2TOKzz1xLyi+4wCFqnPn7b5EVK4zclB49fH/+Dh1CJ3a0q3P55Wf2s0FV1tChxu3nnnM4MXBdgulmjMRjhMjggOkycwDhs2uXcZtihxBCiC9Q7JgASqf1ME/0iUH11IEDhnPz/POu+8It0VOz/ak80mJn+XLX5OFQhbCcgdiBk4OQ2auvBp+vo4G4At9/f2YICyXtaKBICCGEFAXFjgnMm2cIEFywb79d5JdfRO67z3jskUdEdu8OPISlOfdckVq1jDwaTAUPFDgpejSEN7GD8REIZwG9bzD5Or6IHebrEEII8RWKHRPQAqZnTyM8BVdk/HiRSy4ROXlS5KGHjMfRUE8LFezrL6EIZSGBGoKpXj2ROnW87zd8uOv9UDo7P/9suGGA+TqEEEL8hWInwqAUHEMr3d0aiB5UNOlBnqtXi3z5pVHdhC7B55xjjtjR/X28uToaiCG9D95LKJwXzP+qVMkYUaGryrTYobNDCCHEVyh2Igx63xw+bIR+Lr3U9bGLLjIa9Okuxbrk3N8QlqZdO4dAwCwrf0E4TQszHaYqjPvvN4RO8+YipUpJ0OC5nENZSFbWYSw6O4QQQnyFYsekEBYmlKOU251x44yBnghf6R48gYod9OTRuTOLFvn/85MmGWMZIDhQLVYU6KwMBwaOVKhwFjuYlXXokHHe6tcP3WsQQgiJbSh2IgiEg66u8iZgqld3JCsDVGoF069Gh7IwsdzfcBvEDhgyxPefg6tT2OyuQMUOys91s0LkDkEQEkIIIb5AsRNBfvzRKDFHyXTbtt73GzXKUWYeqKvjKW8HYSB/ys337DHCbYEkR4cKjI0oXVrk6FGRqVONbQxhEUII8QeKHRNCWNdeK5KaWvjU708+ERkwQOSee4J7TYSW8FpoTvjHH77/HPr/AAz7RLWYWSBkhSo18OmnxprJyYQQQvyBYidCoKLIn4RjhG/efdcYxRAM6HAMwQO+/fbMx7OyjAnmCFUdPGhsgyhauNBIEB48WExHh7JwDgGdHUIIIf5AsRMhHnjAcFcwoPPKKyP72l27unZCdgadnD/8UOSNN4z8ILhPuA26dAms5D1cYkdDZ4cQQog/UOxEAFQn6R4677xjTAuPJLr/Dbobuw/V1KE1hLr0yIoJE4xtGFRqBVq2dIT9cO7QHZoQQgjxFYqdMIMp4Lfe6ugyjJLzSIPqJVR0oROycygLISzt9syZY3RuRo4Mqsbg6HTqJJYAlVfoQQTgPnkq2SeEEEK8QbETRpBjcuONhpvSqpXIM8+Ydyza3XEOZSEvB1VOqPxCddiTT4r89JORwzN5srVEha5eC8XMLUIIIfFFstkHEMuMHGk02Stb1qiuKqwCK9ygAgwT1WfPNhye5GRHCKtHD5HEREefnPffF8uBcnwkW/vSyZkQQghxhs5OmEBlEwQOgHioWdPc42nd2kiOxqgKNOiD4NGdjs3so+MrKMcfPVqkalWzj4QQQki0QbETJlAyvmaNyNtvi1x9tdlHYzg5qK7SoSyMo4Agw3G2aWP20RFCCCHhg2InjFSubDTlswrOeTs6hNWtmyGECCGEkFiFl7k4AtVVKSkimzcboyBCMY6CEEIIsTp0duKIjAxHyOrYMWPmVPv2Zh8VIYQQEl4oduIMHcoCyCUyc+4VIYQQEvNi57vvvpNrrrlGqlatKgkJCfKlLg8qwGazydixY6VKlSpSvHhx6dChg2zZssVln0OHDkmfPn2kdOnSUqZMGRk4cKAcP348wu8kOsUOQ1iEEELiAVPFzokTJ6RJkyYyceJEj4+PHz9eJkyYIG+88Yb89NNPUqJECenUqZOcPn3avg+EzoYNG2T+/Pkya9YsJaAGW2F6pUWpVcuYpv6f/4h07mz20RBCCCHhJ8EG+8QCwNmZMWOGdC+Yp4DDguNz7733yn333ae2ZWZmSqVKlWTKlCly0003yaZNm6RBgwaycuVKadGihdrn22+/lS5dusjff/+tft4Xjh49KhkZGer54RARQgghxPr4ev22bM7O9u3bZd++fSp0pcEbatWqlSxfvlzdxxqhKy10APZPTExUTpA3srKy1AlyXgghhBASm1hW7EDoADg5zuC+fgzrihUrujyenJws5cqVs+/jiXHjxinhpJfq1auH5T0QQgghxHwsK3bCyejRo5XlpZddu3aZfUiEEEIIiTexUxnth0Vk//79LttxXz+G9YEDB1wez83NVRVaeh9PpKWlqdie80IIIYSQ2MSyYqdWrVpKsCxcuNC+Dbk1yMVpjamWarhlazly5IisXr3avs+iRYskPz9f5fYQQgghhJg6LgL9cLZu3eqSlLxmzRqVc1OjRg0ZNmyYPPnkk1KnTh0lfh5++GFVYaUrturXry9XXXWVDBo0SJWn5+TkyJ133qkqtXytxCKEEEJIbGOq2Fm1apX8Bw1fChgxYoRa9+/fX5WX33///aoXD/rmwMG57LLLVGl5sWLF7D/z0UcfKYHTvn17VYXVq1cv1ZuHEEIIIcRSfXbMhH12CCGEkOgj6vvsEEIIIYSEAoodQgghhMQ0FDuEEEIIiWkodgghhBAS01DsEEIIISSmodghhBBCSExjap8dq6Cr7zn9nBBCCIke9HW7qC46FDsicuzYMbXm9HNCCCEkOq/j6LfjDTYVFFGztPbs2SOlSpWShISEkCpOCChMVWezwqLh+fIPni//4PnyHZ4r/+D5Mu98QcJA6GBEFKYoeIPODhKXEhOlWrVqYXt+Tlb3D54v/+D58g+eL9/hufIPni9zzldhjo6GCcqEEEIIiWkodgghhBAS01DshJG0tDR55JFH1JoUDc+Xf/B8+QfPl+/wXPkHz5f1zxcTlAkhhBAS09DZIYQQQkhMQ7FDCCGEkJiGYocQQgghMQ3FDiGEEEJiGoqdMDJx4kQ555xzpFixYtKqVSv5+eefJd4ZN26ctGzZUnWrrlixonTv3l02b97sss/p06dl6NChUr58eSlZsqT06tVL9u/fb9oxW4lnnnlGdfkeNmyYfRvPlyu7d++WW265RZ2P4sWLS6NGjWTVqlX2x1GTMXbsWKlSpYp6vEOHDrJlyxaJR/Ly8uThhx+WWrVqqXNx3nnnyRNPPOEyZyhez9d3330n11xzjerMi/9zX375pcvjvpyXQ4cOSZ8+fVTjvDJlysjAgQPl+PHjEm/nKycnR0aNGqX+L5YoUULt069fPzW5IFLni2InTHzyyScyYsQIVV73yy+/SJMmTaRTp05y4MABiWeWLl2qLswrVqyQ+fPnq/8EHTt2lBMnTtj3GT58uMycOVOmT5+u9sd/iJ49e0q8s3LlSnnzzTelcePGLtt5vhwcPnxYLr30UklJSZE5c+bIxo0b5YUXXpCyZcva9xk/frxMmDBB3njjDfnpp5/UH1/834RojDeeffZZef311+XVV1+VTZs2qfs4P6+88orE+/nC3yT83caXVk/4cl5w4d6wYYP6Wzdr1iwlCAYPHizxdr5OnjyproMQ1lh/8cUX6kvutdde67JfWM8XSs9J6LnoootsQ4cOtd/Py8uzVa1a1TZu3DhTj8tqHDhwAF8hbUuXLlX3jxw5YktJSbFNnz7dvs+mTZvUPsuXL7fFK8eOHbPVqVPHNn/+fFubNm1s99xzj9rO8+XKqFGjbJdddpnXx/Pz822VK1e2Pffcc/ZtOIdpaWm2jz/+2BZvdO3a1fbf//7XZVvPnj1tffr0Ubd5vgzw/2nGjBn2+76cl40bN6qfW7lypX2fOXPm2BISEmy7d++2xdP58sTPP/+s9vvrr78icr7o7ISB7OxsWb16tbI1nedv4f7y5ctNPTarkZmZqdblypVTa5w3uD3O565evXpSo0aNuD53cMO6du3qcl4Az5crX3/9tbRo0UKuv/56FSa98MILZdKkSfbHt2/fLvv27XM5X5irgzBzPJ6vSy65RBYuXCh//PGHur927Vr54YcfpHPnzuo+z5dnfDkvWCMUg99HDfbHtQBOULyTmZmpwl04R5E4XxwEGgb+/fdfFQuvVKmSy3bc//333007LitOm0fuCcIODRs2VNvwByQ1NdX+H8D53OGxeGTatGnK+kUYyx2eL1f+/PNPFZZBCPnBBx9U5+zuu+9W56h///72c+Lp/2Y8nq8HHnhATaCGQE5KSlJ/t5566ikVTgA8X57x5bxgDcHtTHJysvpiF8/nDiDUhxye3r172weBhvt8UewQU92K3377TX2TJJ7ZtWuX3HPPPSqGjUR3UrSAxjfDp59+Wt2Hs4PfMeRVQOwQVz799FP56KOPZOrUqXLBBRfImjVr1BcQJJDyfJFwACf6hhtuUAne+GISKRjGCgMVKlRQ35LcK2Jwv3LlyqYdl5W48847VQLa4sWLpVq1avbtOD8IAx45csRl/3g9dwhTIam9WbNm6lsOFiQhIzESt/FNkufLASpjGjRo4LKtfv36snPnTnVbnxP+3zQYOXKkcnduuukmVSnTt29flfCOqknA8+UZX84L1u4FKbm5uariKF7PXU6B0Pnrr7/UFzjt6kTifFHshAFY5s2bN1excOdvnLjfunVriWeg5iF0ZsyYIYsWLVIlr87gvKGSxvncIWsfF6t4PHft27eX9evXq2/ceoFzgTCDvs3z5QAhUfdWBshHqVmzprqN3zf84XQ+XwjjICcgHs8XqmSQE+EMvqjh7xXg+fKML+cFa3wJwRcWDf7m4dwitydehc6WLVtkwYIFqjWEM2E/X0GnOBOPTJs2TWXmT5kyRWWZDx482FamTBnbvn37bPHMkCFDbBkZGbYlS5bY9u7da19Onjxp3+f222+31ahRw7Zo0SLbqlWrbK1bt1YLMXCuxgI8X64VHsnJybannnrKtmXLFttHH31kS09Pt3344Yf2fZ555hn1f/Grr76yrVu3ztatWzdbrVq1bKdOnbLFG/3797edffbZtlmzZtm2b99u++KLL2wVKlSw3X///bZ4P1+ogPz111/Vgkvliy++qG7r6iFfzstVV11lu/DCC20//fST7YcfflAVlb1797bF2/nKzs62XXvttbZq1arZ1qxZ4/K3PysrKyLni2InjLzyyivqIpSamqpK0VesWGGLd/CfwNMyefJk+z74Y3HHHXfYypYtqy5UPXr0UP8piGexw/PlysyZM20NGzZUXzbq1atne+utt1weR9nwww8/bKtUqZLap3379rbNmzfb4pGjR4+q3yX8nSpWrJjt3HPPtT300EMuF6B4PV+LFy/2+LcKAtHX83Lw4EF1sS5ZsqStdOnStgEDBihREG/na/v27V7/9uPnInG+EvBP8P4QIYQQQog1Yc4OIYQQQmIaih1CCCGExDQUO4QQQgiJaSh2CCGEEBLTUOwQQgghJKah2CGEEEJITEOxQwghhJCYhmKHEBL13HrrrdK9e3ezD4MQYlE49ZwQYmkSEhIKffyRRx6R//3vf2ruGiGEeIJihxBiafbu3Wu//cknn8jYsWNdhn2WLFlSLYQQ4g2GsQghlgbTpfWSkZGhnB7nbRA67mGstm3byl133SXDhg2TsmXLSqVKlWTSpEly4sQJGTBggJQqVUpq164tc+bMcXmt3377TTp37qyeEz/Tt29f+ffff01414SQUEKxQwiJSd577z2pUKGC/Pzzz0r4DBkyRK6//nq55JJL5JdffpGOHTsqMXPy5Em1/5EjR6Rdu3Zy4YUXyqpVq+Tbb7+V/fv3yw033GD2WyGEBAnFDiEkJmnSpImMGTNG6tSpI6NHj5ZixYop8TNo0CC1DeGwgwcPyrp169T+r776qhI6Tz/9tNSrV0/dfvfdd2Xx4sXyxx9/mP12CCFBwJwdQkhM0rhxY/vtpKQkKV++vDRq1Mi+DWEqcODAAbVeu3atEjae8n+2bdsm559/fkSOmxASeih2CCExSUpKist95Po4b9NVXvn5+Wp9/Phxueaaa+TZZ58947mqVKkS9uMlhIQPih1CCBGRZs2ayeeffy7nnHOOJCfzTyMhsQRzdgghRESGDh0qhw4dkt69e8vKlStV6Gru3LmqeisvL8/swyOEBAHFDiGEiEjVqlXlxx9/VMIGlVrI70HpepkyZSQxkX8qCYlmEmxsO0oIIYSQGIZfVwghhBAS01DsEEIIISSmodghhBBCSExDsUMIIYSQmIZihxBCCCExDcUOIYQQQmIaih1CCCGExDQUO4QQQgiJaSh2CCGEEBLTUOwQQgghJKah2CGEEEJITEOxQwghhBCJZf4fT/F53WG4lJsAAAAASUVORK5CYII=" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 2 + "id": "832c18cea5cbda5a" }, { - "cell_type": "markdown", - "id": "d1a59c9017081cf4", "metadata": {}, + "cell_type": "markdown", "source": [ "We want to train a forecaster on the train set and forecast predictions for the\n", "subsequent test steps. The `RegressionForecaster` is a window based forecaster that\n", "by default uses linear regression to predict one step ahead. It requires a window\n", "parameter. See the [forecasting with regression](./regression.ipynb) notebook for\n", "details. The `forecast()` method makes a single forecast `horizon` steps ahead." - ] + ], + "id": "dd1f93ccadb8d3d2" }, { + "metadata": {}, "cell_type": "code", - "id": "ff55e38056585c73", - "metadata": { - "ExecuteTime": { - "end_time": "2025-07-28T20:16:18.767439Z", - "start_time": "2025-07-28T20:16:18.715835Z" - } - }, + "outputs": [], + "execution_count": null, "source": [ "from aeon.forecasting import RegressionForecaster\n", "\n", @@ -127,37 +91,24 @@ "p1 = reg.forecast(y_train)\n", "print(\" First forecast = \", p1)" ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " First forecast = 376.10513465806844\n" - ] - } - ], - "execution_count": 3 + "id": "14f7c8cf4c01d9ff" }, { - "cell_type": "markdown", - "id": "2106d4593aee61de", "metadata": {}, + "cell_type": "markdown", "source": [ "what if we want to predict further ahead? The direct strategy, described [here](./direct.ipynb)\n", "retrains the model for each set, changing the forecasting horizon. This can\n", " be computationally intensive. As an alternative, the iterative\n", " strategy uses the predicted value and predicts without refitting." - ] + ], + "id": "138307e51f440ac4" }, { + "metadata": {}, "cell_type": "code", - "id": "5b091fcecbd3f267", - "metadata": { - "ExecuteTime": { - "end_time": "2025-07-28T20:16:18.842346Z", - "start_time": "2025-07-28T20:16:18.834569Z" - } - }, + "outputs": [], + "execution_count": null, "source": [ "y_new = np.append(y_train, p1)\n", "p2 = reg.predict(y_new)\n", @@ -165,34 +116,19 @@ "p3 = reg.predict(y_new)\n", "print(f\" second forecast = {p2} third forecast = {p3}\")" ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " second forecast = 427.1861353919512 third forecast = 418.40595828752396\n" - ] - } - ], - "execution_count": 4 + "id": "8004e44812825ccd" }, { - "cell_type": "markdown", - "id": "5e1aafb6bc8b5f98", "metadata": {}, - "source": [ - "there is a function in the base class to make iterative forecasting easier." - ] + "cell_type": "markdown", + "source": "there is a function in the base class to make iterative forecasting easier.", + "id": "799932bd07bd2fe0" }, { + "metadata": {}, "cell_type": "code", - "id": "1b2267b78b0cdfef", - "metadata": { - "ExecuteTime": { - "end_time": "2025-07-28T20:16:20.466064Z", - "start_time": "2025-07-28T20:16:20.337037Z" - } - }, + "outputs": [], + "execution_count": null, "source": [ "y_hat = reg.iterative_forecast(y=y_train, prediction_horizon=20)\n", "\n", @@ -216,37 +152,19 @@ "plt.title(\"Train/Test/Pedicted\")\n", "plt.show()" ], - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 5 + "id": "ea622fab1e005a0a" }, { - "cell_type": "markdown", - "id": "9bf1c1e6d500cbd7", "metadata": {}, - "source": [ - "Looking closer, we can see the errors our forecaster is making." - ] + "cell_type": "markdown", + "source": "Looking closer, we can see the errors our forecaster is making.", + "id": "e5618ccf611b1ee3" }, { + "metadata": {}, "cell_type": "code", - "id": "30d6ed16e3eaa898", - "metadata": { - "ExecuteTime": { - "end_time": "2025-07-28T20:16:21.967306Z", - "start_time": "2025-07-28T20:16:21.759223Z" - } - }, + "outputs": [], + "execution_count": null, "source": [ "plt.plot(y_test, label=\"Actual\", color=\"orange\")\n", "plt.plot(y_hat, label=\"Predicted iterative\", color=\"green\", linestyle=\":\")\n", @@ -256,38 +174,22 @@ "plt.title(\"Pedicted and Actual over the test interval\")\n", "plt.show()" ], - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAlUBJREFUeJztnQd8E3Ubx3907xbaQoGWvfeeCsieIqIIIqACviIi4ELcoLJUBBciMlyIgqDsvffeQzYUSgfQTXfez/O/Xpp00ZHkRp4vnyPp5XL3v9wl97tnljAYDAYwDMMwDMPoFAelB8AwDMMwDGNNWOwwDMMwDKNrWOwwDMMwDKNrWOwwDMMwDKNrWOwwDMMwDKNrWOwwDMMwDKNrWOwwDMMwDKNrWOwwDMMwDKNrWOwwDMMwDKNrWOwwqqZDhw5ikrl27RpKlCiBRYsWQa1jVBr6bOgzos9Kr6jxPLAWH3/8sdjXqKgo2Bv2dJzt4XurJCx2mGJ9MeXJzc0NNWrUwKuvvorw8HCojb1794qLRnR0tNJDUSVvv/22OI7PPPNMkddx9uxZ8Rnzj3XRmDJlCv755x/df0dstZ+JiYlif7Zv3271bTHqh8UOUywmT56MX3/9Fd9++y3atGmDOXPmoHXr1uKHxhpUrFgRDx48wJAhQwr9Qz5p0iQWO7lA7fH++OMPVKpUCatWrUJcXFyRxQ59xix2tCt2bPEdKcx+FvX7TtBvEO0Pix2GYLHDFIsePXrgueeew4gRI4S1Z9y4cbh69Sr+/fdfq2xPtiI5OjpaZf32CF0MQkNDsWDBAqSlpWH58uVKD0mX0GebkpKi9DA0hRq/7wkJCUoPgSkCLHYYi9KxY0fxSIJH5rfffkPTpk3h7u6OUqVKYeDAgbh582aO9/7444+oWrWqWK5FixbYtWtXgX3458+fx4ABAxAYGCjeX7NmTbz33nviNTJlv/XWW+J55cqVja43UwuEJceYFwsXLhSfT+nSpeHq6oo6deoIS1h2yMLSu3dv7N69W2yDfuyrVKmCX375JceyZ86cEeuk8QQHB+PTTz9FRkYGCsPvv/8uxvLYY4+hc+fO4u/cuHXrFoYPH45y5cqJ8dNnOWrUKHEBp+Px9NNPi+VoPfJnLN9V03M6Drnt6/PPP2/8+969e3jzzTdRv359eHl5wcfHRwjqEydOoKhcuXJFjI2Oq4eHB1q1aoU1a9YYXye3q5OTk7ACZOfChQti7GS5lCHLB4n6kJAQ8TlUq1YN06dPN/vc5fP0iy++wKxZs8Q5Q8uS9Ss3aFm6iP7888/Gz870c5G3S/P8/Pzg6+uLF154IVcLakHPZVMs9R25ePEi+vfvj6CgIHHe0jlJy8XExBR4Px/2fafl6dyg8/GJJ54Qz+l7T+dNenq68X00j6DjKm/L9Byk34ynnnpK7AuNtVmzZli5cmWu7vodO3bglVdeEd9d2qdly5YZ52dn7ty54rXTp0+Lv0+ePCnGTN9h2g59Ni+++CLu3r2b7zFhLIuThdfH2DmXL18Wj/7+/uLxs88+wwcffCCECFl/IiMj8c0336Bdu3Y4duyY+OEm5s+fj//973/CFUYXErpAPf744+KHiC4q+UE/Jo8++iicnZ3x0ksviQsojYNcMrT9J598Ev/9959w1Xz11VcICAgQ75N/DG0xRoKETd26dcV76OJK46MfULpIjh492mzZS5cuiR9iEhfDhg0TVhf6waSLDa2DuHPnjhAWZDF455134OnpKcQYXYwKSnJyMv7++2+88cYb4u9BgwaJiyitm36UZW7fvi2EF11w6TOuVauWuNjQjz5dcOmzeu211/D111/j3XffRe3atcX75MeCQp8puThInNBFl4QIXTzat28vhAIJrcJA76fjRWOk8dF5SRdaOgY09n79+qFMmTJi/X/99Rc++ugjs/f/+eefwqogCzlaDy1L+07nQoUKFYT7Z+LEiQgLCxPCJrvATUpKEp8ZiR06V3KDXMF07tFnTMsSJJBMofOTPpOpU6fi6NGj+Omnn8TFl4SWTEHP5exY4jtCordbt27inBozZow4f+hzWr16tThvSKAVZD8LAoka2lbLli2FoNy8eTO+/PJLsS4S4DRu+r7RczrGtH9EgwYNjDcJbdu2Rfny5Y3fHTr+JJ7o+0DvMYW+p7TODz/8UIi1Xr16CZFF76HzIfs5Q9/RevXqib83bdokzmv6XtFnQtum7yk97t+/XwgjxgYYGKYILFy40ECnz+bNmw2RkZGGmzdvGpYsWWLw9/c3uLu7G0JDQw3Xrl0zODo6Gj777DOz9546dcrg5ORknJ+SkmIoXbq0oVGjRobk5GTjcj/++KPYRvv27Y3zrl69KubR9mXatWtn8Pb2Nly/ft1sOxkZGcbnn3/+uXgfvd8Ua4wxLxITE3PM69atm6FKlSpm8ypWrCjWuXPnTuO8iIgIg6urq+GNN94wzhs3bpxY7sCBA2bL+fr65rqvubFs2TKx7MWLF8XfsbGxBjc3N8NXX31lttzQoUMNDg4OhkOHDuVYh/w5L126VKxr27ZtOZah+R999FGO+bSvw4YNM/6dlJRkSE9PN1uG9oP2ffLkyfmeB7khf0a7du0yzouLizNUrlzZUKlSJeO25s6dK5aj425KnTp1DB07djT+/cknnxg8PT0N//33n9ly77zzjjiPbty4YTY+Hx8fcUwKAq3X9LOQoc+N1vXiiy+aze/Xr5/4vhX2XM6L4n5Hjh07Jt5P50FR9jM3cjvO9F6aZ3o+EI0bNzY0bdrU+Df9LuV13nXq1MlQv359cb6Znsdt2rQxVK9ePcfv3COPPGJIS0szW8egQYPEb4Lp/LCwMPE9MR1bbt/7P/74I8d3XN5WQb63TOFhNxZTLMjtQXc8ZNkgczXd7axYsULcMVHsB1kt6G6Q0mblie5uqlevjm3btol1HD58GBEREXj55Zfh4uJiXDdZMuhuMD/oDnPnzp3CLEx32aYU5I7JFmOUMbW4kFmftkN3hXTXJ5v5ZcitRNYqGfqMyTVHy8qsXbtWuGToLtl0ucGDB6OgkMuKzPfkiiG8vb3FXaupK4s+H7K29OnTRyybHUvemZL1w8HBwXj3TqZ+Oqdo38maUVjoM6LP55FHHjHOo/WRVYFcHbJbie78ydpGd+Uy5Iag100z1JYuXSqOS8mSJc3OF/oe0HjpXDSFXDqydaS40LlnCo2DPp/Y2NhCncuFpaDrlb8HGzZssFqCwsM+D9PvR16Qq3Tr1q1ifygYX94f+izJWkSuOLJImTJy5MgccUN0XtBvgmkANFkL6bMyPWdMv/dk5aNt0feWKMo5zRQNdmMxxeK7774TKed0oSB3AF2U5IsV/WjQTT39IOYGuZ2I69evi8fsy9Hr5OfOD/nHTTYZFxZbjFFmz549wk2yb9++HBcDEjumoim7cCPoAnv//n3j3zQmMuNnh45BQSDXAokBKhdAbjMZMu+TKZ/cGnRsSVDSBbWon3FhoAvF7Nmz8f3334u4LzkGw9Q1Whjy+oxk9xq9TvtFbptOnToJt8Qnn3wiXiPhQ+e17AKRzxdym+YlYOjiZwq5nSxF9nOCzgeCzgmKbSrouVxYCrpe2tfXX38dM2fOFGKZxAe5CymBoaA3BAWFYl+yH4Ps34+8oHOd9ofccjTldRzphi2/49i9e3exX3Se0LlD0PNGjRqJ742puKK4oSVLluQ4P7Lf5DDWg8UOUyzorjm3u335wkV3/evWrcs1m4LusJXGVmOkGCL6QaRYF7oYkCWMLEQkNihGIntQcV7ZJ5JHyDKQlYLiKyjWgabs0AUrt6BdS2IqZuS0ZLoAkaWORAfFuJB4phipwgZeFxayTFJcxfHjx8UFi4QPHTM5foWgMXTp0kXUJcoN04scUZj4qYfxsHPCWudyYdZL5xFZOykbc+PGjSJOimKMKDaFAnstRXGys+TziAKayZKTG7KlM7/jSFZIivEhSzaJc4oPoxsaOodNIQsSxXVRADidV/R50RhILFn7nGayYLHDWA0KFqQfYroryn4RyF5LQ76DlLO5iNTUVHF337BhwzzfK1tV5MyHvMjL1WKLMRIUjEzCgrI9TO/Qi+pakMdE48ktg6ggkJghq0b2oFyCgoIXL14sxA7dQZPloKifsXzXnb1+CwW0UlCvKeQGoKBrCgY3hd5rKjoK8xnl9nlQJo78ugxduCjoWHZlkWWLAo+zny/x8fHCbWVpiusOLOi5XNjtF3a9lElH0/vvvy8u8mQp/OGHH0SmYH7bsTR5bUf+zSCLVHGPI7mrKOB9y5YtOHfunPicTF1YZGmi1+h7RMHNMrl9bxnrwjE7jNUg8z/dgdEXPbtFgv6WUy/JMkQXVPpBNK1DQmmfDytwRu+jjBDKVrpx40aObchQtgWRfX22GKPpnajpNsiETdk6RaVnz57ijvngwYPGeeRyyit13BRKGab4ErrrpKyv7BNZOMjcf+DAAWFZISFAgo1il7Ij71Nen7F8wcwez0IZKdktO/Q5ZT8OZIHKHkNRmM+IPh9yHcpQNg1tm7L2KDZKhjKK6E6fLDrkciDLG+23KfR50booLiU7tN+UGVdU6PMrTkG/gp7L+W2/ON8RcnVm338SPXT+kNA33Y4tintSmQEi+7Yog43au5Cgzy625e9QQSGxRNZHEsg0kaXb1OWV2/eeyJ61x1gftuwwVoMucHQ3R3fHFAxKFw4KgCVLCJl+KUiUTMl0h0XL0V01WU3ozoiWISFQkHgYSnemANQmTZqIddKPDW2PaqmQS4KglG2Cau+Qu4K2SQG3thpj165dxcWTtknrIOvAvHnzxA9vbj+4BYFcKZTKS+bwsWPHGlPPyVpBcSX5QVYb+gGmmIq8RALFq5BwopgXMs2TW4ICqukzoZgXGjcJEaoHREKBTPT0406p0CTkyMwv1xWidGMKKKWAXXIDUd0cEgzZrTVUX4iqcpPYopTxU6dOiTEUNC4qO5RWTOnUVKuHXCp0YaI7cTp2FJckx5fJ0HGlGBNyS5DwyZ6qTa4Iss7ROOVSACSeaJxklaJzqCgWKILWRSnU5OakFHs6j3OLN8qLgp7L+W2/ON8RCvql+C9K0ycLEAkfOj/pnKDjbqn9LCjkeiIxSyKExkPHniyZNFGsIf1mkBij4GM6v8gNRUKWCmwWtK4TfUYkBkkc03lAafCmkEWUbsZmzJghrMAUB0TfI9M6ZIyNKEIGF8MY0yRzS0XOzt9//y1SNynllKZatWoZRo8ebbhw4YLZct9//71ICaY042bNmom0TErpfljqOXH69GmRiuvn5ydSp2vWrGn44IMPzJahtOHy5cuL1NDsKZ6WHGNerFy50tCgQQMxPkp7nj59umHBggU5xkLp2L169crx/ty2c/LkSTGP1kn7Rvs4f/78h6awUtpthQoV8h1vhw4dRGptamqq+JtS+ykFPTAwUOw/pczTZ2Saij9v3jwxn1KVTdPQKcV7woQJhoCAAIOHh4dIub906VKuqeeUXl+2bFlRwqBt27aGffv2Ffg8yI3Lly8bnnrqKeO50aJFC8Pq1atzXZZS72m7tO7ffvst12UodX3ixImGatWqGVxcXMQ+UcryF198IUoUmI6P0rkLyvnz50UZBXn78ucip55TKrUpeaUqF/Rczo3ifEeuXLki0uOrVq0qPudSpUoZHnvsMVGeoiD7WZjUc9p+duTPyZS9e/eKdHQ6TtnT0Om8oPM5KCjI4OzsLPa7d+/eohxDYX7nNm3aJJYpUaKEKMGRHSrDIf82UVmIp59+2nD79u0c4+HUc+tSgv6zlbBiGIZhGIaxNRyzwzAMwzCMrmGxwzAMwzCMrmGxwzAMwzCMrmGxwzAMwzCMrmGxwzAMwzCMrmGxwzAMwzCMruGigpm9Um7fvi0KZdmqlDnDMAzDMMWDqudQ93oqUJm9SKgpLHYAIXSoMSPDMAzDMNqDWuDk12yWxQ4gLDryh0XlvRmGYRiGUT/Uk42MFfJ1PC9Y7Jh0xyWhw2KHYRiGYbTFw0JQOECZYRiGYRhdw2KHYRiGYRhdw2KHYRiGYRhdwzE7BSQ9PR2pqalKD4NhCo2zszMcHR2VHgbDMIxisNgpQA7/nTt3EB0drfRQGKbI+Pn5ISgoiOtIMQxjl7DYeQiy0CldujQ8PDz4YsFoTqwnJiYiIiJC/F22bFmlh8QwDGNzWOw8xHUlCx1/f3+lh8MwRcLd3V08kuChc5ldWgzD2BscoJwPcowOWXQYRsvI5zDHnTEMY4+w2CkA7LpitA6fwwzD2DMsdhiGYRiG0TUsdhhFrAz//POP0sNgGIZh7AQWOzpn3759IiC1V69ehXpfpUqVMGvWLKuNi2EYhmFsBYsdnTN//nyMGTMGO3fuxO3bt5UeDsMwjDJkpAHpKUqPglEIFjs6Jj4+Hn/++SdGjRolLDuLFi0ye33VqlVo3rw53NzcEBAQgH79+on5HTp0wPXr1zF+/HjhcpKDWz/++GM0atTIbB1k/SErkMyhQ4fQpUsXsT5fX1+0b98eR48etcn+MgzD5Er8VWB1bWB1DSA9SenRMArAYqewGAxAWoIyE227EPz111+oVasWatasieeeew4LFiwQReaINWvWCHHTs2dPHDt2DFu2bEGLFi3Ea8uXL0dwcDAmT56MsLAwMRWUuLg4DBs2DLt378b+/ftRvXp1sQ2azzAMY3PirwCbOwDxl4CE60DsBaVHxCgAFxUsLOmJwF9eymx7QDzg5FkoFxaJHKJ79+6IiYnBjh07hOXms88+w8CBAzFp0iTj8g0bNhSPpUqVEnE+3t7eosVAYejYsaPZ3z/++KNoVUDb7d27d6HWxTAMUyziLgNbOgCJoSbzLgElpd86xn5gy45OuXDhAg4ePIhBgwaJv52cnPDMM88IAUQcP34cnTp1svh2w8PDMXLkSGHRITeWj4+PcKfduHHD4ttiGIbJExI1m9tLQsenNhDURZpPFh7G7mDLTmFx9JAsLEptu4CQqElLS0O5cuWM88iF5erqim+//dbYQqAwODg4GN1gMtkr8pIL6+7du5g9ezYqVqwotte6dWukpHBgIMMwNiL2P2DLY8CD24BvHaDjVuDiHODOJkkEMXaHopYdCniVA2DliWJMZJKSkjB69GjRl8rLywv9+/cXlgNTyGJAwbdUDp/6/rz11lviIm81KFiXXElKTAWsgkv7/8svv+DLL78UFhx5OnHihBA/f/zxBxo0aCDidPLCxcVF9AYzJTAwUDRGNRU8tF5T9uzZg9dee03E6dStW1eInaioqEJ/zAzDMEWCYnLIdSWETl2g0zbAvQzgXVV6ncWOXaK4ZYcuiJs3bzb+Te4WGcoGokDapUuXCpfIq6++iieffFJcUAm6GJPQobiSvXv3ikDaoUOHwtnZGVOmTIG9snr1aty/fx/Dhw8Xn5spJBjJ6vP5558LN1bVqlVF7A4JpLVr12LChAliOcqwonR1eo0EC2VXUaxPZGQkZsyYgaeeegrr16/HunXrhKtKhtxXv/76K5o1a4bY2FghPotiRWIYhik0Mecli07SHcCvPtBxC+AWKL3mVU16jL+s6BAZO43ZIXFDYkWe6KJKUDAtXZRnzpwpgl6bNm2KhQsXClFDWT7Exo0bcfbsWfz2228iJbpHjx745JNP8N1339m124Q+t86dO+cQOrLYOXz4sAhCJhG5cuVK8dnRZ0wxPjKUiXXt2jUhhsiiQ9SuXRvff/+9+HwpmJmWf/PNN3Nsm4RWkyZNMGTIEGHlIYsbwzCMVYk5J1l0hNBpILmuZKFDeGeKncSbQNoDxYbJKEMJQ/YgDBu7scjCQBdlqvVCsR1Tp05FhQoVsHXrVmF5oAsnZfPIUBzIuHHjhNXnww8/FBdrU1fK1atXUaVKFVHbpXHjxrluNzk5WUwyZIEICQkRAsvUSkFuNFpf5cqVxfgYRqvwuczomugzwNaOQFIEULIR0HEz4Opvvgxd6pb5AamxQK8zUiwPo3no+k0aIvv1W1WWnZYtW4pCd+QOmTNnjvgxfvTRR0VNFooNobgRU6FDlClTRrxG0CP9nf11+bW8IEFFH448kdBhGIZhNEj06UzXFQmdxrkLHYJiHmVXFsft2B2KxuyQ20mGAmZJ/JDlhorhWTPOY+LEiXj99ddzWHYYhmEYDRF9CtjSEUiOAko1BR7bCLiWynt5ClK+f5TFjh2ieMyOKWTFqVGjBi5duiTidyjuJjo62mwZysaSC93RY/bsLPnv/IrhUcAtmbtMJ4ZhGEZD3D8hWXSE0GkGdNyUv9AxC1JmsWNvqErsUPG5y5cvo2zZsiIgmbKqTNOjqVAepZpTbA9Bj6dOnUJERIRxmU2bNgnxUqcO+2MZhmF0yf3jmRadu0Cp5pLQcSn58PfJQcpUWZmxKxR1Y1EmT58+fYTrijpyf/TRR6JNAVX9pVgaSp0mdxNlDpGAoe7dJHBatWol3t+1a1chaijrh9KhKU7n/fffF7V5yHrDMAzD6Ix7R4GtnYGU+4B/S+CxDYBLzszTfMUOW3bsDkXFTmhoqBA2VHGX0psfeeQRkVYupzp/9dVXomovpUtT9lS3bt1E6rMMCSOqKUNdvUkEeXp6igq+lDbNMAzD6Ix7R4AtnYHUaMC/FfDY+oILHVM3VsI1ID0FcHSx2lAZdaFo6rnaU9c4XZfRC3wuM5rn7iFga1dJ6AS0AR5bBzgXMt6SLnd/eQLpD4De/wE+1a01WsZGaCL1nGEYhmEeStRBYGsXSegEtpUsOoUVOsb088y2EezKsitY7DAMwzDqJeoAsI2ETgwQ+CjQgSw63kVfHwcp2yUsdphi8/zzz+OJJ54w/k09tKjKta3Zvn27aCabvVyBKfT6P//8AzVRkHEzjF0SuS/TohMLlG4PdFhbPKFDcJCyXcJiR8cCRO4kT5Woq1WrJgK3rdoRPpPly5eLHmVqvNBTs1i5mCX1/qJtZ+/cbk1yE4Jt2rQR48qtlxnD2C2Re4BtXYG0OKB0B6DDGsDZq/jr5SrKdoniXc8Z69G9e3fRPJUy2aijOaXkU+0iqiCdHSrgSKLIElCpALWSX7HJ4pCamio+26JAn7u1xsUwmiRiN7C9B5AWD5TpCLRfBTh5WGbdbNmxS9iyo2Oo1hBdRKmOEaXnUyd0apxq6nr67LPPUK5cOdSsWVPMv3nzJgYMGCCqWZNo6du3r7CAyKSnp4vaR/S6v78/3n77bWRP6MtuvSCxNWHCBNGSg8ZEVibqjk7rfeyxx8QyJUuWFFYWGheRkZEhephR9hC1DqEu68uWLTPbDgk4qrhNr9N6TMdZEDcWrZughrE0n8Yt89NPP4ku75S5VKtWLbOSB7JF6M8//0T79u3FMr///rsooUClFMqXLw8PDw/Ur18ff/zxh/F9tG87duzA7NmzjVY3WpepdYsyC2h/1q1bZzbuFStWwNvbG4mJiQU6TgyjWSJ2Atu7S0InqLNlhQ5hDFC+AmSkW269jKphsVNEElISxGR6oU9JTxHzktOSc102w5BhnJeanirmJaUlFWhZS0AXUbLgyFB1aqpKTVWnqV4RWSeolhFdVHft2oU9e/bAy8tLWIjk93355ZeieeuCBQuwe/du3Lt3T1yI82Po0KHiov/111/j3LlzmDt3rlgviZ+///5bLEPjIFcOCQGChM4vv/yCH374AWfOnBFd7p977jkhFuSL/ZNPPimKUpIbasSIEXjnnXcK9XkcPHhQPG7evFlsm9xvBAmXDz/8UAhBGu+UKVPwwQcf4OeffzZ7P21v7NixYhn63Ci9myp/r1mzBqdPn8ZLL70kCl7K26F9o3pQI0eOFNujKXtPNkqd7N27NxYvXmw2n8ZE4pREVEGOE8NokvAdwDay6CQAQV2AdistK3QIjxDAwRnISAUehFp23Yx6oTo79k5MTAwpFvFoyoMHDwxnz54Vj9nBxxBTRHyEcd6nOz4V80b8O8JsWY/PPMT8q/evGud9te8rMe/Zv581WzZgRoCYfzr8tHHej4d/LPQ+DRs2zNC3b1/xPCMjw7Bp0yaDq6ur4c033zS+XqZMGUNycrLxPb/++quhZs2aYnkZet3d3d2wYcMG8XfZsmUNM2bMML6emppqCA4ONm6LaN++vWHs2LHi+YULF8RnS9vPjW3btonX79+/b5yXlJRk8PDwMOzdu9ds2eHDhxsGDRoknk+cONFQp04ds9cnTJiQY13ZoddXrFghnl+9elX8fezYMbNlqlatali8eLHZvE8++cTQunVrs/fNmjXL8DB69epleOONN3L9bPL6DGh8Xl5ehoSEBPE3nZdubm6GdevWFfg4ZSe/c5lhVEH4LoNhiYfB8DsMhq3dDIbUROtta1VNaTthm623DUbR63d2OGZHx5C1hu74yRJAbqFnn30WH3/8sfF1crOYxumcOHFCNGEli4EpZLGgnmVUtImsEdSdXsbJyQnNmjXL4cqSIasLVbomd09BoTGQu6ZLly5m88lqQS4ngqwppuMg5J5pxSEhIUHsK7UqIQuMDAV2Zw8gpv02hVx8ZAX666+/cOvWLTFecuGRNaYw9OzZU8T/kMtx4MCBwvpFFh9yQxbkODGMJjkxEUhPBMp2B9qtABytWPySgpRjL0hBykGdrLcdRjWw2Cki8RPjxaOHc9aF7K22b2Fcq3FwcjD/WCPelBqVuju7G+eNbj4aI5uMhKODo9my18Zey7Hs842kOJbCQnEsc+bMEYKG4nJImJhC7TXM9ik+XrhhyGWSHbmFR1FcZ4WFxkGQO4jiX0yxds8zedvz5s3LIaZItOX3+X3++efCVTVr1iwhJOl1il0qrGuJjtdTTz0lXFkkdujxmWeeMR4/axwnhlGU1Hggar/0vPn31hU6BAcp2x0sdoqIp4v5hY5wcXQRU0GWdXZ0FlNBly3SGD09RTBwQWnSpIkIui1dunSeZbepI/2BAwfQrl07o8XjyJEj4r25QRd9sipRrI1smTBFtiyRVUSGmruSqKEO93lZhCh4WA62lqG+aoUht22XKVNGCMMrV65g8ODBhVofxc5QoDDFFhG03//995/YH9Ntmm4vL2jbZNmieKWtW7fi008/LdRxYhhNEbUXMKQBnhUBLylxwKrIQcqcfm43cIAyY3aBDQgIEBdsCnylXkqUKfTaa6+Jpq0EBeROmzZNZDSdP38er7zySr41cipVqiSas7744oviPfI6ydVDUKYYZSKRyy0yMlJYLcg98+abb4qgZAoKJtfM0aNH8c033xiDhF9++WVcvHgRb731lghuJusHBU4XBhILZHlav349wsPDhZuOmDRpkgiQpoBqEiunTp0SKfwzZ87Md33Vq1cXwd579+4Vbrb//e9/Yr3ZPw8Si5Q5FRUVJQRRbpCYpEw6OiaUNWZqZSrIcWIYTRG+TXqkejq2wGjZYbevvcBihzFCsSU7d+5EhQoVRKYTWU8odoViQWQLwhtvvCEyjEjAUIwMCZN+/frlu15ypZFbhoQRpXFTLAzFxhDkpiJxQZlNZFV59dVXxXwqSkgZUCQ6aByUaURuLTldnMZIsSwkoCgtnbK2KF6mMJBbiAQNZYeRNYfEA0GZXZR6TgKHLFNkXSIhJW87L95//31hdaFMKUpjJ7FiWlmaIBFH7jCy9pDLiaxXuUECkNLYKT4nu4WpIMeJYTRF+HbpsYxUisLqmBYW5F7YdgF3Peeu54wdwOcyo1pS44BlJQFDOtD3muTKsjbpKcBfHtI2n7gFeJSz/jYZq8BdzxmGYRhttIUg0eFZ2TZCh6DYSnlbHKRsF7DYYRiGYZSP17GVC0uGg5TtChY7DMMwjArEjo2Ck2U4SNmuYLHDMAzDKENqLHD/iG0zsWS4+7ldwWKnAHAMN6N1+BxmVEnELoD6AJJLydO8T5zNLDssduwCFjv5QCX7CbnTNMNoFfkcls9phlEFETZOOc+rijLfDOgerqCcD1QPxc/PDxEREcb6JlT/hGG0ZNEhoUPnMJ3L2VteMIxdFRM0hbK/ZFdachTgxq1W9AyLnYdAheEIWfAwjBYhoSOfywyjClKigfvHlLPsOLkDHsFAYqgUpMxiR9ew2HkIZMmhflDUWoC6hzOM1iDXFVt0GNXG63jXUK6oHwUpk9ihuJ2AVsqMgbEJLHYKCF0s+ILBMAyj8ZTz7HE7FDfEQcq6hwOUGYZhGOWCk0sr4MLKLUiZ0TUsdhiGYRjbknwPuH9cel6mvXLj4CrKdgOLHYZhGMa2RO6iXEHApxbgXla5cXAVZbuBxQ7DMAxjPynnuVl2KPWcssMY3cJih2EYhrEt4QoWEzTF2RtwKyM9Z+uOrmGxwzAMw9iO5LtA9AnlM7FkuG2EXcBih2EYhrEdETukR986gFtppUfDDUHtBNWInWnTpokCfuPGjRN/X7t2Tfyd27R06VLj+3J7fcmSJQruCcMwDPNQF5aSKee5xe2wG0vXqKKo4KFDhzB37lw0aNDAOC8kJARhYWFmy/3444/4/PPP0aNHD7P5CxcuRPfu3c1K4zMMwzAqRA3FBE1hN5ZdoLjYiY+Px+DBgzFv3jx8+umnxvlUrTh7L58VK1ZgwIAB8PLyMpvPfX8YhmE0QFIkEHNaHZlYMlxY0C5Q3I01evRo9OrVC507d853uSNHjuD48eMYPnx4rusICAhAixYtsGDBAtHpOT+Sk5MRGxtrNjEMwzA2itfxqw+4BUBVYudBGJCWoPRoGD1adii25ujRo8KN9TDmz5+P2rVro02bNmbzJ0+ejI4dO8LDwwMbN27EK6+8IqxFr732Wp7rmjp1KiZNmmSRfWAYhmE0Vl/HFJeSgEspIOUeEHcZKJkVTsHoB8XEzs2bNzF27Fhs2rQJbm5u+S774MEDLF68GB988EGO10znNW7cGAkJCSKuJz+xM3HiRLz++uvGv8myQzFCDMMwjA36YSldXye3IOV796QgZRY7ukQxNxa5pSIiItCkSRM4OTmJaceOHfj666/F8/T0dOOyy5YtQ2JiIoYOHfrQ9bZs2RKhoaHCVZUXrq6u8PHxMZsYhmEYK/IgHIg5Szm0QOl2UBUcpKx7FLPsdOrUCadOnTKb98ILL6BWrVqYMGGCCFA2dWE9/vjjCAwMfOh6Ka6nZMmSQtAwDMMwaovXaQC4+kNVcJCy7lFM7Hh7e6NevXpm8zw9PeHv7282/9KlS9i5cyfWrl2bYx2rVq1CeHg4WrVqJVxh5BKbMmUK3nzzTZvsA8MwDKPRlHNTuLCg7lE89fxhUHZVcHAwunbtmuM1Z2dnfPfddxg/frzIwKpWrRpmzpyJkSNHKjJWhmEYRmPxOgS7sXRPCcPD8rTtAApQ9vX1RUxMDMfvMAzDWBpK615RTorXeequlAGltniiFVSrrQTwzAPAkcMg9Hb9VrzODsMwDGMnLSJKNlKf0CGoR5cTFas1APFXlR4NYwVY7DAMwzD268IiSpTgIGWdw2KHYRiGsb9igtnhIGVdw2KHYRiGsR6Jt4C4i0AJB/XV1zGFg5R1DYsdhmEYxgbxOk0AF1+oFqqiTFAVZUZ3qD71nNEhqfHSD0oJR8DPvNYSwzB6jddRsQuLYMuOrmGxw1iH1FipqR6ZryngL06eLgJJd7KW67oPCGil5EgZhrFJvI5Kg5Ozi52Ea0BGKuDgrPSIGAvCYocpOinRWSLGKGgyxU1SRP7vJauOIR24vZ7FDsPolYSbWVbc0o9A1biXAxzdgPQkIOEG4J3p1mJ0AYsdJn+S75mImYvm4iY5Kv/3ugZKd0ve1aVMB2+T6foS4NArQNReW+0JwzBKubBKNQWcVV6wlQKoKW4n5oz0G8diR1ew2GFyJ2InsHsAkBSe/3JuQVkCxihoSNxUzT8YMaC19Hj3AGDIkH5oGIbRF1pIOTdFFjscpKw7WOwwuXN+ZpbQIfOuUcxUNxE3VQFn76Kt37eeVLGUYntiznKgMsPoORNLrcUEs8NByrqFxQ6Tk9Q4KZaG6H4EKNXE8ttwcAL8WwDhWyVXFosdhtEXCdeBhKtSvE6gyuN1ZLiKsm5h3wGTk1trgIxkyYpTsrH1thPQRnqM2me9bTAMo6xVp1RzwJn6TmkArqKsW1jsMDm5uUx6DHlK6hljLeS4nUgOUmYY3cbraMWFZWbZuSLFEjK6gcUOY05aAnB7rfS8wtPW3Zacch73H5B817rbYhjGdhgMJmJHI8HJhEeIVF+HLNvU5oLRDSx2GHNurwPSHwBeVYCSjay7LddSgE8t6XnUfutui2EY20GF+RJvACWcgMC20AwUS+hZSXrOcTu6gsUOY84NG7mwsruyuN4Ow+gH2apDSQhOntAUHLejS1jsMFmkPQBur5aeV3jKNtvkIGWG0R9aSzk3hdPPdQmLHSaLsA1SzI5HBaBUM9ts02jZOQBkpNlmmwzDWDdeJ0KDwckynH6uS1jsMFncWJpl1bGFC4vwrQ04+wLpiUD0Kdtsk2EY60HVhxNDpUBf+WZGS7AbS5ew2GEkqPndrVVZ8Tq2gtpEyFlZ7MpiGP24sPxbAU4e0BxyTywSbWSlYnQBix1GImwTkBYHuJcHAlradtscpMww+kGLKeemUDYW3YSRS/9hvQEZzcBih8lWSLC/7ZtycpAyw+goXkfDwcmEo6sUt0iwK0s3sNhhgPQUIPRf22ZhmSIsSSWkqqUP+E6KYTRL3EXgwW3AwVWb8ToyHKSsO1jsMED4FiA1BnAvq0wBMGcfwLeu9JytOwyjXWSrDsXhObpBs3CQsu5gscNkFRIMftL2LiyZQHZlMYzm0WI/rIcFKTO6gMWOvZORCoT+o5wLS4aDlBlGP/2wSms0OFmGLTu6g8WOvUNpoin3ANdAIPBR5cYhBynfOyzFEDEMoy1iL0jZS+S+snVGp9WqKF/k9HOdwGLH3jFmYT0JODgqNw7v6oCrv1Tv5/5x5cbBMEzRkKsmk5VWy/E6BDVCJiiWkW4GGc3DYseeofYMN1co78IiqGIzFSEjOG6HYbRbTLC0xuN1CCqGSDXHCHZl6QIWO/ZMxE4gOVKyqJRur/RoOEiZYbSKHurrZIeDlHWFasTOtGnTUKJECYwbN844r0OHDmKe6fTyyy+bve/GjRvo1asXPDw8ULp0abz11ltIS+OGkoVyYQU/IfWxURoOUmYYbRJ7DkiKABzdAf/m0AUcpKwrnKACDh06hLlz56JBgwY5Xhs5ciQmT55s/JtEjUx6eroQOkFBQdi7dy/CwsIwdOhQODs7Y8qUKTYbvybJSAduLrd9L6z8KNUcKOEIJN6UGgl6BCs9IoZhCoKchUV1uqgCsR4wBimz2NEDilt24uPjMXjwYMybNw8lS5bM8TqJGxIz8uTj42N8bePGjTh79ix+++03NGrUCD169MAnn3yC7777DikpnNGTL1F7pMwJZz+gTEeoAmcvwC9T8LIri2G0g15Szk3hKsq6QnGxM3r0aGGd6dy5c66v//777wgICEC9evUwceJEJCYmGl/bt28f6tevjzJlyhjndevWDbGxsThz5kye20xOThbLmE52W0gw5AnA0QWqQXZlRbLYYRhNYMgAInboK16HYDeWrlDUjbVkyRIcPXpUuLFy49lnn0XFihVRrlw5nDx5EhMmTMCFCxewfLnkfrlz546Z0CHkv+m1vJg6dSomTZoEu/5xuvm3ulxYpvV2Ln7PcTsMoxVizgDJUYCjh37idUwDlCmJIzVWamvDaBbFxM7NmzcxduxYbNq0CW5uuddkeOmll4zPyYJTtmxZdOrUCZcvX0bVqpknYhEgC9Hrr79u/JssOyEhIbAbovZLzfroyxuUu0VNMQIzLTv3j0o1d7Rer4Nh7CXlPPARdSQ6WAr6faRiqyR24i4DpRorPSJGi26sI0eOICIiAk2aNIGTk5OYduzYga+//lo8p+Dj7LRsKVXlvHRJMitSDE94uHmXbPlvei0vXF1dReyP6WSXLqzyj6svmNCzMuBWRmpjce+o0qNhGMZe+mHlBsft6AbFxA5ZaE6dOoXjx48bp2bNmolgZXru6Jizmi/NJ8jCQ7Ru3Vqsg0STDFmKSLzUqVPHhnujsXoYcsq50oUE8youyCnoDKPBeB0dBSfLcNyOblDMjeXt7S2Cjk3x9PSEv7+/mE+uqsWLF6Nnz55iHsXsjB8/Hu3atTOmqHft2lWImiFDhmDGjBkiTuf9998XQc9kvWFy4e4hKbXbyQsI6gpVQmKHmpNyRhbDqJvoU1I7Bfo9KdUUuoPTz3WDKurs5IaLiws2b96MWbNmISEhQcTU9O/fX4gZGbL+rF69GqNGjRJWHhJLw4YNM6vLw2RDtuqU7w04uUOVyE1BI/dKliiy9jAMo+L6OjqL15Hx4irKekFVYmf79sxAN0oSCgkRMTwPg7K11q5da+WR6QQSDjeWqjMLyxS6QyzhBCTdARKuA16VlB4RwzC5obcWEdlhy45uULzODmNDKMMp4ZqUIlquB1QLWZxKNZGesyuLYdRbhT1ch/V1chM7D24BaVk13hjtwWLHHrOwyvWUuvqqGQ5SZhh1E30SSI0GnLyBkjpNy3YpJVWZJ+KvKD0aphiw2LErF5achfU0VI9R7LBlh2GU5m7iXTz797OISMjKfN11ej6m3ANOezYGHFQVEWE5KF6QXVm6gMWOPd2FUa0IKtJHlh21Iwcp3z8OpCUoPRqGsWue//d5/HH6Dwz6e5Bx3u/nV+G9u8CP0eY10cLjzWuf6afWDgcpaxkWO/aCbNUp20NquKl2PEMA9/KAIR24e1jp0TCMXTOz60w0KdsEX3f/WpqRkY4ODpHo6wn0qZslgC7du4SgL4PQfF5zpFNMj54ystiyo2l0antkchYSXKreQoJ5EdhGyh4jV1aZ9kqPhmHsCoPBgBKZZR+q+1fH4ZGHjX/j/jEM9HiAgb6+QIOXje85fPswSqAEvFy84OiQVRj2052fwtvFGwPrDUQZL/N+hqqHqyjrArbs2AMxZ4HYC4CDi1RfRytwkDLDKMKd+Dtov6g9Ttw5YZxnFDqmKeel2wEmoobETPib4fi+5/fGeanpqZi+ZzrGbRiH0NhQ4/yoxChEJ0VD9XAVZV3AYseeCgmW7aatzr2mQcpknWIYxia8velt7LqxC8P+GYYMaglRiH5YgZ6BqB1Y2/h3SnoKPmz3IfrV6ofGZbOytmbtn4WAGQH4aNtH0IRlJ/EGkJ6i9GiYIsJuLHuK11FzIcHcoHRWB1cgOUq6q/KprvSIGMYu+KbHN0hMTcT0ztPhUCLbPXFGGhCxS3pe+uH9sDxdPPFW27dyzL947yLSDemoUrKK2XwSRy6OLlAN1JjYyVNKlKA6ZT41lB4RUwTYsqN3Ys4DMaelUu7BfaApqCO73G+HU9AZxqqQu0nG180XywYsQ9VSmcG5ptw7CqTFAS4lgZINi7y9P5/6E9fGXkO/2v2M2/9w24do9mMzPEh9ANVA7jsOUtY8LHbsxYVVprP046Q1KEiZYLHDMFbjRswN1J9TH8vPLX/4whHbsuJ1slt9CklFv4rwcZVc67HJsZh3dB5ORZzCsrOZv1tqgYOUNQ+7sfSOsZCgxlxYMhykzDBW57uD3+HC3Qt4d8u76FOjD5wd82nqGS4HJ1u2RYS/hz8W9V0kgpafqfcMVAUHKWseFjt6JvYiEH1CaqoZ/AQ0LXbIFZcaq60Aa4bRCFM6TRGPr7Z4NX+hk5EKRO6yWj+sbtW6QZVwFWXNw24sPXPzb+mxTEfAtRQ0iXtZwLMSQBkhdw8qPRqG0Q33HtwzPqeaONO7TEeIb8hD3nRECtR19Qf86ll1fBS3s/jUYqgCrqKseVjs2EO8jlZdWNmtO5Ect8MwluDi3Yto+ENDTN4xuXBvlFPOS7cvdrxOfiSnJaPlTy0xePnggsURWRs5QDnhqpSNxmgOFjt6Jf6qdBdGP0hadWFl75PFQcoMYxG2XN0iCvwtOb0ECSmF6D1njNd5eMp5cXB1ckXvGr0R5BUET2dPKI5HsFQGg9x4iTeVHg1TBDhmR+8uLPpRcguEpgk0LS6YYdU7SoaxB15u9jKcHZzRp2YfUQenQFBBvcjdVovXyc7HHT7GG63fEIHLikO/OV5VgNhzUtyOV2WlR8QUEr5q6BWtZ2GZ4tcAcHQHUqOlthcMwxSaq/evmtXSGd5kOEp7li74Cu4dAtITAdcAwLcOrA0VFjQVOtSrS1E4/VzTsNjRIwk3gLsH6HYECJYKdmkaKojo30J6zinoDFNoTkecFjEwzy5/1kzwFApj1WTrxuvkxq7ru9BobiNcuX8Fyqefc5CyFmGxo0duZgb0lX4UcA+CLjDtk8UwTKG4FXsLMckxQiwkpBYiRseU+0elR/+WsCVk0flw+4c4GX4S7299H4rhnRmkzJYdTcIxO3rOwtJaL6z84CBlhilW/Zp1g9ehcVBj+Ln5FW0l1CaCKNUEtoS6rS94fAFm7Jkh0uMVgwsLahq27OiNxFtA5B7peciT0A0BraTHmLNAyn2lR8MwqufEnRO4m3jX+HfHyh1R0r2ILWNSorNqzNhY7BCVS1bGnN5zjK0lFK+1k1sneEbVsNjRqwuLLCEe5aEbKKNMvrOKongkhmHy4vDtw+jwcwd0/rWzWfHAInP/mPToWVkVPfa2Xd0mavHYFM+KUjX69CTgwW3bbpspNix2dFtI8GnoDmNTUA5SZpj88HD2ENlM9OjkYIFoBYVcWLnx3pb30PGXjvh4+8e23TB9jlTNneAgZc3BYkdPPLiTlTGhJxeWDAcpM0yBqBNYBzuf34n1g9dbxvWjIrHTrFwz8ZiakWr7dHQOUtYsHKCsJ0JXUO6ClC3hWQG6wxikfADISAccHJUeEcOohhsxN+Dm5GasnVMzoKblVn7/iPRYUnmx0692P5x55YwQdDZHuNI3cJCyBmHLjp7QUyHB3PCtCzh5A2lxQMwZpUfDMKohw5Ah+kjV/b6uiGexKKlxQOx/qrHsEIoIHYK7n2sWFjt6ISkSiMjsWxPSH7qELDnG4oLsymIYmYiECMQmxyIpLUlkLlmU+yckizH1h3IrRMVlG3D/wX08t/w5rPlvjW02yFWUNQuLHb0Q+o+UDlmqqb77tnCQMsPkgBpmHhp5CFuHbkUlv8wgWkshFxNUgQsrO7P2z8Lvp37H/1b/zzbZWaZVlJVuX8EUChY7enNh6amQYG5wkDLD5AplXzUv39zyK1ZRcHJ2Jj46EX1r9sXfA/4WndKtjriRLCG50pMjrb89xmJwgLKG2R+6H4Eegajq6QeEb9G3Cyt7ccG4i0BSFOAWoPSIGEYx5h6eK4KShzYcKioNW4V7mcHJZDVWGbTv/wz8x3YbdHQFPEKAxBtS3I7K3HqMBiw706ZNE1/WcePGib/v3buHMWPGoGbNmnB3d0eFChXw2muvISYmxux99J7s05IlS2APRcPazG+Dmt/WxIaDUwBDOuDXEPCpDl1DBc18akvP2brD2DGX713GuA3j8Py/z2PdpXXW2UhaIhB7VrVurOyEx4fjdpyVC/5xkLImUYXYOXToEObOnYsGDRoY592+fVtMX3zxBU6fPo1FixZh/fr1GD58eI73L1y4EGFhYcbpiSeegN6pHVAbrzR/BemGdDyafFrfWVjZYVcWw6CiX0V82O5D9K7RGz2q9bDORqJPSbGAbmUA97JQM1uvbkW9OfUwZMUQkZ1mNThIWZMoLnbi4+MxePBgzJs3DyVLZpUhr1evHv7++2/06dMHVatWRceOHfHZZ59h1apVSEtLM1uHn58fgoKCjJObmxv0jqeLJ77t+S0ix16ER1RmqmmFp0XAXlhcGHQNBykzjKiMTDErKweutJ4LyzQ42VrbsBAhPiFITE0U/cCiEqNsE6TMaAbFxc7o0aPRq1cvdO7c+aHLkgvLx8cHTk5OOdYREBCAFi1aYMGCBQ+tqpmcnIzY2FizSasE3NsLZKQCvvWw+s5FjN8wHvXn1BdpqLq37Nw9BGSYC1+G0TvU68r0N85qQscsXkf9Lqzq/tWxechmHBhxwFhY0SqwZUeTKBqgTLE1R48eFW6shxEVFYVPPvkEL730ktn8yZMnC6uPh4cHNm7ciFdeeUVYiyi+Jy+mTp2KSZMmQavsur4LJ8NPomf1nqhs7IX1lLizaVG+BTpU7KBsd2Br41MLcPYDUqOB6JOa+CFmGEuQnpGOXot7wcvFCwv7LkSwT7B1N2jMxFJfcHJutA7JvBGyJl6ZLSM4ZkdTKCZ2bt68ibFjx2LTpk0PdTuR5YWsP3Xq1MHHH5s3f/vggw+Mzxs3boyEhAR8/vnn+YqdiRMn4vXXXzdbf0hICLTCguMLsOj4Irx5bww+j94gzQx5Cg396mLvi3uRZmLtIJcWubY+aP+B+IHUBSUcpKyssPVA5F4WO4zdcPzOcZy4cwLOjs7W7wuVngzEZMYDauw7Rp/Nryd/FQHLb7V9yzr9sVLuAcn3ANdSll0/oy831pEjRxAREYEmTZoItxRNO3bswNdffy2ep6eni+Xi4uLQvXt3eHt7Y8WKFXB2ds53vS1btkRoaKhwVeWFq6urcIeZTlqiVflW6FCpA3r6egMZKZKlw1cqn+7o4GhWb4KyNWbsnYGhK4ZCV3CQMmOHNC3XFCdePoHFTy5GiK+Vb9CoJQu5yF1KAR7a6rW368YuDPtnGCZumSjEoUVx8swK1o7nuB2toJhlp1OnTjh16pTZvBdeeAG1atXChAkT4OjoKCwu3bp1E+Jk5cqVBQo8Pn78uAh0pvfolf81+5+YsPPJrEKCefjtX2j0Ao6FHcOH7T+EruAgZcZOodgUmqyOabyOyoOTs9OuYjsMaTAEtQJqoW7putYJUn4QJrmy/K1QyJHRj9ghSw1lXJni6ekJf39/MZ+ETteuXZGYmIjffvvNLJA4MDBQiCHKzAoPD0erVq2EECKX2JQpU/Dmm29C96TGA2HrHppy3r1ad5wbfU5YfGQWHlsoghzHthorMjo0ieiRVQJIuCb96Kg8LZZhisOfp/8UVp1qpTKDY22BxuJ1svPzEz9bL3ibgpQjd7FlR0Oo9kpHgcsHDhwQz6tVM/+CX716FZUqVRIure+++w7jx48XPlpabubMmRg5ciT0CgUm092KS8ROID0J8KoC+GXVJ8oNU6ETmRApMrZikmMQ6BkoKq9qEmcfwK++FKBMrqyQTCsXw+iMs5FnhUvGoYQDjrx0BLUDM4tqWhsV98QqCKZCh+ruhMaGooKvhdxxHKSsOVQldrZvz+zaDaBDhw4PDcCjWB6a7AWqIdFiXgsRnHiu40iIPIzARwplYvb38McXXb/A0rNLMbj+YGg+bofFDqNzPJ090bZCW9EagW50bALF6ohu59oLTs6tI/zg5YNxPuo8To06BT83v+KvlNPPNYfidXaYgnPp3iV4u3qLL2v5hHMm7pyCQ3eHI5qMwPrB640WH7rreXrp0/jrzF/Wz/CwJBykzNhJpeRNQzZhSf8l1q2pY0rseSAjWbKgkvVY42LxWvQ1UWzw4K2Dllkpt4zQHKqy7DD506BMA4S/GY5bMaEosaVJkcSOjOmP5h+n/sCys8uw7uI6tK/YHmW8ykATBGQGKd89DKSnAI4uSo+IYSwG3YTQzQlBj3SjYzPk4OSSjaVSDxqvNv/nU38K0VMzoKZl3VhJ4UBqHOBsw2PDFAkWOxqDfvRCnNKA5LuAg8tD43UKQv86/YXViFxcpkKHrDw2u5Ms6t2VawCQHAXcPwYEtFR6RAxjEahW1mM/P4be1XvjjTZv2D6RQOPBydlpUtbCrjgXv6zfnvgrQMmGll0/Y3G0LdntlahMU2zJRoBj8VPsKRbgow4f4dUWrxrnnYs8h6Y/NhXBkaqFhJjRlcUp6Ix+WHpmKXbf2I1pe6ZZt8+TToOT84Nu7CiGJyEloXgr4iBlTcFiRyNQunjzec3x09GfgLsHi+XCKgjvb3sfx+4cw6g1o6BqOG6H0SED6w3EgscXYE6vOQjyCrLtxjPSgfvHdRGcnFu7jd6Le2PxqcWi4GCx4CBlTcFuLI2w7tI6HL59GD2r9QTSrC92vunxDfxc/TCl0xSoGhY7jA4h9/ELjV9QZuNx/wFpCVKlYO8a0BOUlEECctKOSXi77dsW6n7OYkcLsNjRCLO6zxKNP1uS73n751YXO+W8y2F+3/lQPVS9tIQjkBgKJNwEPLXT44xhcmvy2yq4lSgvoRhyvA65yU1qdOmFxyo/JtrtFDsekTOyNAW7sTQCiY/nGz2P2i4ZQPoDwNkX8LZByfhMyKpEdX5UB919+mUGB7J1h9Ewp8JPodMvndDipxa4/+C+cgPRcbyOjKnQORp2tGjxO0Y3FldR1gIsdrSGMV6HLBq2OXxf7P0CLX9qife2vAdVwn2yGB1wO+62SC+nKr8WKXxX7Ews/Yod01jIVj+1wph1Y4oeoJx4E0h7YPGxMZaFxY4GmLJriuiNE58Sb5Pg5OzUDawran7cfXBXPKoOjtthdEC3at1w5pUz+LH3j8qVfKDvtx1YdmQql6yMdEM6YpNjkUK1ugoDpZ5T0UUi4apVxscoHLOTlpYmWjtcvnwZzz77rGjqefv2bfj4+MDLy8uCw2Oik6Lx4bYPxRfy+rjr8FJA7PSo3kP05LF4rQpLix2qtUN3WE7uSo+IYYqEzTOvskM1Y1JjAUc3wLcO9A7F7uwfvh/NyjUrvMCk5SlImcQhxe3YwedlV5ad69evo379+ujbty9Gjx6NyMhIMX/69On20W3cxiSnJWNsy7HoW7MvKniUAmLO2FzsEKoVOoRnJcAtSOrnI1d+ZRgNkJqeimf/fhaHbh2CKpBdWFSs1NaFDBWiefnmZkKnUC1zOEhZv2Jn7NixaNasGe7fvw9396w76H79+mHLli2WHp/dQxWNv+z2Jf4Z+I90B0FmZo9gwL2sIuOhIOVx68dhy5UtKi0uyK4sRjvM3DcTf5z+A73/6I0HqSqI+7AjF1ZuVasnbp6I4SuHF/xNHKSsGQot3Xft2oW9e/fCxcW8D1GlSpVw69YtS46NyY4CLqzsTN89HbMPzMY/5//BhVcvwNWp+BWcLRakHLqCg5QZTUFNeU+En0CfGn3g7qwC96sdBSdn51jYMczYO0PEJb7U9CVRAuChcBVl/YqdjIwMpKen55gfGhoqYncYyxGZEInIxEjUDqgtmVlVIHbeavsWtl/fjomPTFSP0CFMLTtkhlZzTy+GyYT60S3uvxiqgL43shvYDsUOubM+7/I5QnxCCiZ0CK6irF83VteuXTFr1izj33QRjo+Px0cffYSePXtaenx2zZLTS1D3+7oY+PdAaYYKxI6Xixd2PL8D3at1h6qghoUOzlIX4oRrSo+GYfLlVqwKreCJN4CUe9L3yLce7JHXW7+Op+s+XfgqyvSbU9hsLkbdYufLL7/Enj17UKdOHSQlJYlsLNmFRUHKjOWgBoDUpLNp2abAA7qIXyd5qapOxHHJcYhJilF6GFL2iBxnEMmuLEbd7pIqX1fB+PXjRZyIapBdWCR0LNBgWOtQocH5Rx9SRZ5iJx3dpVhK8fvM6MaNFRwcjBMnTmDJkiU4efKksOoMHz4cgwcPNgtYZorPpMcm4Z1H3kEqZRlF7ZRm+tbOqu2gMNSV+bnlz4n0zUVPLFKHK+vuAcmVVXmw0qNhmFxZe3GtqOlyM/YmHKnViVqw43id7NDxaTW/FU5HnBb9tKh6fa6Qu5xcWdGnpCBlH9tVtWcKR5FyC52cnPDcc88V5a1MIaGgRfqnBhdWdhxKOIgf7J3Xd4ry9iXdSyofpHxhFgcpM6rmvXbviVIOTcs1Va54YG7YcSZWdlwcXfBM3Wdw78E9VClZ5eGuLBI7HKSsL7Hzyy+/5Pv60KFDizMexqTWg9kPoQrFTpuQNlj29DJ0qdpFxPKoJkg5+mRW12aGUSFUqFNVmAUnq8dNriTvPvouRjUbJYLI88U7MyOLg5T1JXaozo4pqampSExMFKnoHh4eLHYsxCMLH4GPqw9mdZuFmv41VCl2iH61+0E1UP0hmqgD+t1DQJkOSo+IYYzsD92P+qXrw9NFhSL8QZgU3E9uNSooyAjLtanQoZYS9JucZ5AyW3b0FaBMxQRNJ4rZuXDhAh555BH88ccf1hmlnREeH469N/di/aX1kmuIfMEp9wEHV8C3PtTKmv/WYPV/q5UdRAA3BWXUB/W16/l7T1SYVQHnIs9BdcguLJ/a3G4lF8hVX/u72lh0PJfYRE4/t59GoNWrV8e0adNyWH2YolHaszROvnwSC/suFM+NVp2SjQFH82KOamH5ueWiCuwL/76AiIQI5V1ZkVxJmVEPV+9fRSn3UmKqQZZatcHByfmy6/ou0ZX+24Pf5myGbBQ7V4GMnDXoGHVgseYnFLRMzUCZ4kOxOvXL1BeTQKUuLFN6Ve+FRkGN0LFSR3i7eCtv2bnLxQUZ9UDfZao4fiPmhsjuUR1yvA4HJ+fKxEelIqovN3tZuLfMcA8GHFyAjBTgQSjgWVGpYTKWFDsrV67MEUgbFhaGb7/9Fm3bti3s6piCoAGxQz8E1D1Y8arKJRtJNXeS7wJxFwEfFd5FM3YJiZzKJStDlchuLA5OzhUSOG+2yaPRNYlXr8pA7AUpbofFjioptNh54oknclghAgMD0bFjR1FwkCkeZyPPCr9w7xq90a5iu8xO3kdVL3aI7EInKS1JFEW0KeTmox/syD1SvR0WO4yC0M3gnpt70DakrbrSzE1JipCC+qlgacmGSo9GEyw9s1TU4hncYHBWkLIsdoI6KT08xlK9sRjr8e/5f/H53s9x4e4FSexQ/YaMZMDZL8s3rIHKz6+ufVV0SP934L+2/5EnV5YQO3uBKsNsu22GMWHL1S3o8msXIXZ2vrAzpwtEDdw7Jj3SjYEz9zd8GBsubcCAZQPg7uQu+mmJGCwOUrafmB3GMrQMbolhDYehc5XO2VxYzTUTf3In/g5WnF+B9Ix00dGZYnkUawrKMApy5f4VeDh7iCKCqhQ6xH2O1ykMVFeMegM2KtMIlf0qZ0s/v6zo2Jhiip3XX38dBWXmzJkFXpbJScfKHcWkpXid7NQrXQ8/9PpBBGXaXOiYFRc8DaREAy5+th8DwwB4qelL6F+7f84MHlVmYnG8TkEg0bpq0Co4OZhcPmXLDhU0ZbQrdo4dyzRzPgTV+qS1jAbFDvFC4xeU27h7EOBdXQpQjtwNlO+t3FgYu+ehFXiVhtPOC42p0KG4rPMl/FGbMrKoJlrMecC3lqLjY4oodrZt21aQxZhicujWIYT4hiDIK0iakRoHxJzNcmNpFHJrnQw/ia5Vu9puo6U7SGInYgeLHUaRc/5B6gP1Zl/JULHShKtZdbyYQkFxiUNXDBXNXQ82bIF6sbuB0BWA70Slh8ZkQzVOZCpKSJahcePGGeclJSVh9OjR8Pf3h5eXF/r374/w8HCz9924cQO9evUSrSpKly6Nt956C2lpadAig5cPRtkvy2Lzlc0mtS8MgEcI4F4WWoSqxdb9vi76/9Uf16Kv2W7DpdtLj+HbbbdNhslk+u7pqPZNNUzbPQ2qRg5O9qrC7t4iQNmmcSlxSMtIwwnXzMzP0H+UHhZjqQDlw4cP46+//hJCIyUlxey15cuXF3p9hw4dwty5c9GggXlPlvHjx2PNmjVYunQpfH198eqrr+LJJ5/Enj17xOvp6elC6AQFBWHv3r2i3g/15nJ2dsaUKVOgJeKS4+Dt6g1nB2e0KN9C0y4sUyhToXZAbXEHlJyWbLsNl2mfVT8kNRZwzqWnDcNYAXJr3Iy9KeJ0Ggep3FrCxQSLHb/zW7/fxI1c81IhwIqF0u924i3Ao7zSw2NMMRSSP/74w+Ds7Gzo3bu3wcXFRTzWqFHD4Ovra3j++ecLuzpDXFycoXr16oZNmzYZ2rdvbxg7dqyYHx0dLbazdOlS47Lnzp0z0JD37dsn/l67dq3BwcHBcOfOHeMyc+bMMfj4+BiSk5MLPIaYmBixXnpUmvsP7mf9sfMpg+F3GAxnphu0THh8uCElLcX2G/63qvT5ha6x/bYZu+d0+GlDRkaGQdXsHih9R05PVXok+mBDG8POn2AY/ksbQ2hMqNKjsQtiCnj9LrQbiywmX331FVatWiU6nc+ePRvnz5/HgAEDUKFChcKuTripyDrTuXNmqnUmR44cER3VTefXqlVLbGPfPimlmB7r16+PMmXKGJfp1q0bYmNjcebMmTy3mZycLJYxndSCn5uJKVkHlh2C+ns5Ozqb3fnaZsOZ1h2K22EYG1O3dF31J21wcLJFMZTvi7ejgPlX9mLq7qlKD4cxodBi5/Lly0KcECR2EhISxBeaXE4//vhjoda1ZMkSHD16FFOn5jwp7ty5I9bv52fuRyZhQ6/Jy5gKHfl1+bW8oO2RW0yeQkJCoCRk7s4hAB7cARJvSFVNdZISSvu44NgCPL7kcduk4pbpID1GcNwOY7sK6OSy1QTk3o37T3rOwckWoURIP8wMALp5lMD7rV41zo9JihEV5RkNiZ2SJUsiLi5OPC9fvjxOnz4tnkdHRyMxseBf8ps3b4ou6b///jvc3GzbUmDixImIiYkxTjQWJdl7c68ITB63Pis4G3cPSY++dXRT1ZQyVMauH4vV/63G4lOLbWfZobgEymxjGCtCAr7fn/1QcVZF7A/dD9Vz/7j0SAkQboFKj0Yf+FRH66C6WF/egKCYzHgoAO9sfgc1v62JdRfXKTo8e6bAYkcWNe3atcOmTZvE86effloIlpEjR2LQoEHo1KngPUHITRUREYEmTZqIjuk07dixA19//bV4ThYaCn4mEWUKZWNRQDJBj9mzs+S/5WVyw9XVFT4+PmaTkmy6vAnhCeFi0psLy5Sy3mUxu/tszOg8A4PqDbL+Bj0rAJ6VAUM6ELnX+ttj7BrqaJ6aniqmuoF1oXq4mKB1CH7CLCuLLDrrL68X5wdV02ZUno1FmVLNmzcXjUBJ5BDvvfeeyHyiTChKC3///fcLvGESRqdOnTKb98ILL4i4nAkTJgjXEq17y5YtYt3EhQsXRAZY69ZShVx6/Oyzz4RoorRzgoQYiZc6depAK7z76LvoUKmDyMbSs9ghXmz8om03SFlZV65Krqxy3Wy7bcauqORXCf+N+U+UWzD7Lqtd7HAmlmUJ6Qec+QwIWwekPYCbkzvOvnIWq/5bhfaVMq3NgKjNE+ARkJV9y1iVEhSlXJAFd+3ahYULF2LZsmWiGSgJkBEjRuDRRx+12GA6dOiARo0aYdasWeLvUaNGYe3atVi0aJEQMGPGjBHzSVzJqee0fLly5TBjxgwRpzNkyBAxrsKknlOAMsXukEtLaSuPgA7JslJAajTQ/Yhugwfp1ItIiEAZL/O4K4ty5Wdg//NSC4mubN1hGCNr6gExZ4D2q4HyUhwmY6Hf738rSJ3k26/KtagpxXVV+7oawuLDsHLgSvSp2UeRoeqBgl6/C+zGIlGzYMECUcvmm2++wbVr19C+fXvUqFED06dPzzcguKhQ1lfv3r2FsCL3GbmmTOv4ODo6YvXq1eKRrDzPPfecqLMzefJkaJq4S5LQcXAF/OpDj1y9fxWPLHwEree3FmZ/q8ftUAxUWoL1tsPYNVQh3GZZhpYgLRGIPSc91+nNlGJQBl42V1Z2qLo2NROtWrKqWWV5TZ1DerXs5MalS5eEtefXX38VYqd79+5YuXIltIaSlp2Z+2aK6psUw0KtIgRXfwf2Padra0RCSgKqfF0Fscmx2D5su+j2bjX+qShltj22ESjbxXrbYeyS81HnUfu72mhWrhl2vbBLVNVVPZH7gE1tpMrs/W4rPRr9cWcrsLUT4BoI9AsDHBxzXYwsPHIcD12K+y7pi4ZlGuKttm/Bx1UFXgZ7tOzkRrVq1fDuu++KWB1vb29R7ZgpOHRyf7nvS0zYPEH8YOo9XscUTxdPLOm/BFdeu2JdoUNwCjpjRY6FHYO7kzvKeZfThtCRK4sTHK9jHUo/CriUBJIjgai8b1hNA5b33Nwj4npm7J2B+w/uQ08kqqAcQ5HFzs6dO/H8888L1xL1ozJt48AUDLLovNP2HfSt2RePVnzUrsQO8Vjlx0SGltXh4oKMFRlUfxBujL+BWd2kWENNwMUErYuDM1AuM1bn5ooCvaVtSFssH7AcUztNRUW/imZi2iZ1yYpws37vwT1xHZOhkgvj14/HD4d/MFu2wRzzVlCqFzu3b98Wgb8Up0PBxOTGolRxmj9v3jy0atXKeiPVIVRVeEzLMfhn4D9Zd4TpKcD9Y3YhdkyhtEzTL41VLDskIilWgWEsDGXVqL7DuSls2bFNVpYct1OAaBEqztuvdj+83vp1s99Fimts+mNTISxkyPJDhQrTM9ItPuwMQ4aZuKJ4tCm7puC3k7+ZLRfyVQj8Z/iL7EMZ8lDMOjAL/5w3j1Wi65vS1p0Ci50ePXqgYsWKIji5X79+OHfuHHbv3i3SxT09Pa07Snsi5hSQkSyZQL2qwh54d8u7IjPh95O/W2cDVGvHIxjISAWipFYjDFNc4lPixcVIc6QnAdFS3TS27FiRsl0BRzcg4SoQbV5mpaCQ0HB1chVthEq6lTTOr/5NdfhN98OFuxeM83488iOcP3HG00ul0jAyzec1R/DMYJy4c8I4b81/a9Doh0YYvWa02bKN5zaG66euOBOR1W7paNhRvLf1Pfx68lezZUu6S+OhjFqZJmWb4O02b2Now6Fmyx556YjiNYYKLHao5g2lnYeGhorsq5o1a1p3ZDqHovGpmmYOtWvqwlJ7Xx0LQV/k1IxU7LqxyzoboM+xtBy3w64sxjL8dPQnVJldBe9teQ+agoSOIQ1wDZCqJzPWwckTCMrMtAotmCsrO71r9Mbl1y7jpz4/mfVZk63gTg5OZvNoyp5zdDvuNm7F3TKz1kQlRuFE+Alcib5itixZimgdlBIvU790fbzQ6AX0qWGeHr95yGY8eO8BOlXJKibcoEwDTO8yHc/Wf9ZsWRJsmikqqMUsKzWz8/pO9FzcE9VKVcPFMRftLl7HlFeav4LWwa3N45asEbdz7TcgnIOUGctAF4t0Q7pZfIXmXFh2ckOlqCvr1krJlVX/oyK7SGky5e7bd8W5Zyp2nm/0PJ6o9QRcHF3Mlt00ZJOo4lwzIMtA0aVqF2x8bqPROiOz9OmlwgJjGkvZtFxTLOi7IMe4rFofTUmxw1iWmOQYVPCtgPYVsypq2qvY8XLxsq7QMYvbOSCqmsLJ3brbY3TPwr4LMabFGNQJ1E61dgEHJ9sOClIu4SD1IYu/BnhVsshqHR0cQf9MIZGSm6sot/OznHc5MWXHVBDpjWKlnjNFZ0DdAbg29hq+7vG1eRfiGLnQV3PYI3QHciEqyw9tMSj+yb0ckJEC3NVAk0ZGE1CMgmbSzWVY7NgOtwAg8NF8CwwytoHFjoKQD9ZMiVN3bhgAz4qAu7ZMhJbgyO0jqPp1VTy+5HHLZxmIuJ1MK1o4x+0wRYeCkinmTpNQkH70Sek5NwC1DcEmWVmMYrDYUYAUSi/PDTt0YZlSw7+GsOxQ0PaV++aBcxaBiwsyFuDFf19ExVkVsfHyRmiOmLNStqezr5SlyFif4L7SY+QuIClK6dHYLSx2FGDIiiGo810dkY1lhp2LHeoUTRH+l8ZcQnX/6pbfgGzZidovpd8yTCGh+iaX7l0SNU9q+mswvsHUhcXBybaB4nRKNgYoG+rWKqVHY7ew2LExlBa47eo2nIs6l7P3iZ2LHaJx2cbWS1P0rgG4BUl3tlEHrLMNRtdQ9gplT+54fof2srAILiaoDA9pDMpYHxY7CsTpXHj1gkjxM+sJlXgbSAyVIvf5h0iw58Yey8bumMbtcL0dphiVz9tWaAtNIuICOThZMbFzZyOQlqD0aOwSFjsK3R0+VecpsxoJuHdIevStCzh7wd558s8n8cjCR/DXmb+sFLfDYocpHBRHlr1gm6agGwdKgSY4ONm2+NUHvKpI7vOwDUqPxi5hsaMW2IWVI6WXimNZvBy/MW5nL5CebNl1M7rlbuJd1J9THy1/aimqz2qSuAtAOtWY8gK8rRATx+RvVZatOzfZlaUELHZsCDVuG7hsIBYcW5Cziy2LHTPGthwryqRPeGSCZVfsUwtwKy3dYd3NtKYxzEM4cOuAcKlSWxN/d39oEjk4uWQjyV3O2BZZ7FCQMpUAYGwKn/E2ZMvVLfjzzJ+YsWcGHEx/bEj4yBdeFjvGzKxgn2DLr9gsbodT0JmC0bN6T9wYfwOL+i4y61GkyXgdjglUhoA2gGsgkBoNROxUejR2B4sdG1KvdD180O4DvNzsZfMX4i4CqTGAo7sUs8OYERobKgoOWgxuCsoUgdKepdEwqCE0i5yJxfE6yuDgCAQ/Lj3nrCybw2LHxkXzJj82GeNajcvdhUUZEg7OioxNray9uFZUVR72z7Ccrr+iIlt2IvcAeRV4ZJjMLtAktjUPfXfuHZOecyaWOlLQtRzsrkFY7KgBo9hhF1Z22oS0gbuTO/w9/C0XGOpbB3ANkII17x22zDoZXfLvhX9ReXZljF03Fpom7jKQFgc4uklxa4wyBHUGnDylMiOyW5GxCSx2bMShW4fElKt1whicbJ/NP/PDz80Pp0adEkXcyI1gEThuhykgO6/vRFpGmogh0zSyC8uvIWBa8oKxLSQ2y/aQnrMry6aw2LERk3ZMQoufWmDW/lnmL1D6s1z7goOTcyXEN8TyK+WmoEwBmNV9Fg6OOIjXWr4GTcPFBFXoylqh9EjsChY7Niwk6O3ijU6VO5m/QB2IM1IAl1JS0SkmT5LTkvH7yd8tE7sjFxeM2sNpoEy+NC/f3HJWRcV7YnFwsuKU7wWUcJKassb+p/Ro7Aa2Z9qIX/v9itT0VPOqydnr62g1pdUGkMBpNq8ZTkechruzO56s/WTxVkhZbyQwU+5Jd70BrSw1VEYnRQQ9XTzh5uQGzUOBsNwTSz24+AFlHgPubJJcWXXeVnpEdgFbdmzcUydHjQ4uJlggqC5Rv1r9UM67nIihKDZU54j7ZDF58Pamt1FpViUsP7ccmifhOpByX8r05NIW6iCkn/TIcTs2g8WODUhMTcz7RRY7BWZC2wmiqvKAugMsHLfDQcpMFinpKdhxfQfCE8JR1qssNI8cr+NbH3B0UXo0DFE+s95O1H7gQZjSo7ELWOxYmfD4cPhN80OHRR3Ej6gZKTFA7HnpOWdiPRSLuxXkuJ3I3YAlrEWMLqCebOdGn8PqQavROqQ1NA8XE1QfHuUzb3ANQOhKpUdjF7DYsTK7buwS/XRik2PFj2iud1yelaR+TUyB2X1jt5iK3YnYpSSQFp8VwMkwmS7nXjV6QRcYg5M5XkdVBLMry5aw2LEyT9V5Srhe5vSak/NFdmEViZ+O/oRHFz6KMevGwFCcKqQUtxP4qPSc43aYTBFtkZgwtUDfD+6Jpe4U9PAtQGqs0qPRPSx2bECVklXQMrhlzhdY7BQJClQu5V4KLcq1yD8eqjCuLC4uaPdsvrJZuJt7L+6NB6kPoAse3AaSI4ESjpIlk1EPvrUAn5pS6Ytba5Ueje5hsaMkLHaKBLWOuDHuBub2mSvieCzTJ4vidtItMj5GmySkJMDVyRWBnoH6SDk3C06uCzi5Kz0aJjvsyrIPsTNnzhw0aNAAPj4+YmrdujXWrVsnXrt27ZpI085tWrp0qXEdub2+ZMkSqIH5R+dj9JrROBB6IOeLibeAB7ckVwr70gtNsUWODJXPd/aVzMjRmZWsGbukb62+ODDiAOb1mZezRIRW4Xgdbbiybq+Vqukz+hQ7wcHBmDZtGo4cOYLDhw+jY8eO6Nu3L86cOYOQkBCEhYWZTZMmTYKXlxd69MjsLZLJwoULzZZ74onME0hhfj/1O74//D0O3T6U88W7mfN860mN4ZgiERYXhs/3fF702B0Hx6y4HU5Btzuo0CclD8jUK11PP1YdgosJqhvKwnUvKzVpDd+q9Gh0jaIVlPv06WP292effSasPfv370fdunURFBRk9vqKFSswYMAAIXhM8fPzy7GsGnizzZuoHVAbPav3zPkiu7As0j6iwQ8NRDf02oG10btG76LH7dxeLQUp137D0sNkVAoJ5FfXvoo9N/dg1aBVqFyyMnQHW3bUDVn2ybpzcY7kyipnfiPP6DBmJz09XbifEhIShDsrO2T9OX78OIYPH57jtdGjRyMgIAAtWrTAggULHnqXn5ycjNjYWLPJGpDI+a7XdyJAOQcsdooNxVe82OhFtAlpIwKWi4yxkvJOjtuxIyITI7H64mqcjTyLM5FnoDsehEuucpSQ3LWMyhuD/su/P3rujXXq1CkhbpKSkoTFhqw3derUybHc/PnzUbt2bbRp08Zs/uTJk4X7y8PDAxs3bsQrr7yC+Ph4vPZa3l2Kp06dKlxiikGNLO9lurFY7BSLTzp+AmeHXNpwFIaSjQBnHyA1RmrMWqqxJYfIqBRq7kkdzbdd21Z0q6AWXFg+tQBnc2s4oyJKd5DiBpPCgbsHgEDzaxyjE8tOzZo1hcXmwIEDGDVqFIYNG4azZ8+aLfPgwQMsXrw4V6vOBx98gLZt26Jx48aYMGEC3n77bXz++ef5bnPixImIiYkxTjdv3oRNoU63FBDr6M69aooJFWosdjApNWcNfER6zinousfU8lvepzyea/AcdAm7sLQBFZstl1nAkrOy9Ct2XFxcUK1aNTRt2lRYXBo2bIjZs2ebLbNs2TIkJiZi6NChD11fy5YtERoaKlxVeeHq6mrMAJMnmyK7sKh8e/Yu6EyRA00p+23b1W1FWwE3BbULKL6r7YK22HtzL3QPBydrh5BMV9bNFVIhSEZ/Yic7GRkZOYQKubAef/xxBAYGPvT9ZCUqWbKkEDSqheN1LM603dMwYtUIvLPlnaJlZpEpWY7bITcjo0s+2PoB9oXuw4iVI5Cu9/gItuxoh7LdAQdXIP4SEGPu2WAsg6JmBXInURp5hQoVEBcXJ1xV27dvx4YNG4zLXLp0CTt37sTatTkrTK5atQrh4eFo1aoV3NzcsGnTJkyZMgVvvvkmVA2LHYvzv2b/w6ITi/BM3WeQbkiHU4lCntp0QXDyAlLuA9GngJIc0KlHvuj6BRLTEjGh7QQ4UtkBvZJ8F0i4Jj0vyTFoqsfZGwjqDNxeI7my/Di8QVdiJyIiQrimqDaOr6+vKDBIQqdLly7GZSi7iurxdO3aNcf7nZ2d8d1332H8+PHibp7cYTNnzsTIkSOhWqhwlFy8jsWORYNNL465CAdK5SxO3E7YesmVxWJHt8Uof37iZ+ie+8ekR69qgIuv0qNhCpqVJcTOCqDee0qPRneUMBSrk6I+oNRzElsUrGz1+J2og8DGloBrAPBkBJWAtu72mIJzZhpwYqJUwr3dcqVHw1iI1f+tRlxyHAbVHwS74ewM4PgEoMIA4JE/lR4NUxCSIoDlVC/OAPS9AXiGKD0iXV2/VRezo3tMXVgsdKzC/tD9eGPDG4WP3ZGbgkZy3I5euHzvMgb9PQjPLn8Wqy6sgt3A8Traw600ENg2q+YOY1FY7NgajtexKvcf3EfHnzti5v6Z2HRlU+HeTNlx1LqD4h1idFhkzg6p5FcJo5qNQsfKHdG9WnfYDXIDUM7E0miBwRVKj0R3cN6zrbnHYsealHQviVdbvCpSjKuXql64Nzs4AwFtgTsbgfAdgF99aw2TsREUhDyjywykpKfA2dEZdkFKjJTVQ7BlR3ti59ibUtxg8j3AtRiV4Rkz2LJjS1KigdgL0vNSzZUejW6Z3nk6FvRdULReR2XkejtcXFCrkPtyxbkVZm5MKj5pN9zPTIDwrAi4+is9GqYweFeVbrIM6cCt1UqPRlew2LEl9w5Lj15VALcApUejW7JXVKaCg0UqLsix+5pk+p7pePKvJzH0n6FFq7mkdbiYoE5cWVxN2ZKw2LElHK9jUxJSEjBm7Rj0Wtyr4Bc9srhRG4/kKC7upVECPQLh5OCENsFtit9KRMvxOuzC0iaUDUpQGYy0RKVHoxtY7NgSFjs2JSw+DPOPzReByjuv7yzYm8jdEZDZiI9bR2iS4U2G4+wrZzGq+SjYJcZMrKZKj4QpamNijwpA+gPgTiGTLJg8YbFjK8iyEHVAes5ixyZUK1UNc3rNwYbnNqB9pUz3VGFS0FnsaIbIhEgkpSUZ/67uX8jgdL2QlgDEnpeesxtLm5A1kl1ZFofFjq14cAtIugOUcOTy7TZkWKNh6Fo1Z/XtgsXtbOe4HQ3wIPUBev/RW5QcCI8Ph11z/4RUlM69HOBeRunRMEUlJNOVdWsVkJGm9Gh0AYsdW7uwKNLeyUPp0dglMUkx2HJly8MXJMubo5tU0VTOnmNUy393/xPThbsXEJcSB7tGdmGxVUfbUOsal1JSza/I3UqPRhew2LEVHK+jKDdibqDenHp4fMnjuHQvswZJXji6AgGtpeecgq56GgY1xIERB7By4ErhurRr7nNwsi6gXn3l+0jP2ZVlEVjs2AoWO4oS7BMsigyW9SorLDwPpTTH7aid9Ix04/Ma/jXQtkJmqX17hoOT9efKIrHD7vRiw2LHFtCP8t3MGjtcTFARqBv64v6LceLlE2harmnB43bCOW5HjRy6dQgNfmiA0xGnlR6KekhPympzwpYd7RPURSqDkXA9q1AkU2RY7NiCuAtAWhzg6AH41lF6NHZLkFcQPF08C7ZwQEvAwVUKKo+7aO2hMYWAaia9sfENnI08i093fqr0cNQBCfIj46XKu+5lAffySo+IKS4U21k2s58bu7KKDYsdW7qwyLRMvlhGcVZeWImn/nrKzBViBgUoB7SSnnPcjqIkpiZi3cV1WHpmqfibCgWueGYFXmryEn7s86NlN3ZzBbC+hWTR0xInJgKXfqBPB2g6W0pfZrQPNwa1GCx2bAHH66iKu4l38dzy5/D3ub+x4NiCAriyOG6nOGQYMsRnHpccZ9ad/ou9X+SwzLy96W2U/bIsvjnwjXEevbfn4p54dvmzxkrY/h7+mNtnLnxcfSw72FOTgHuHgO09gTtboQnOTAXOTpeet/gRqPC00iNiLEX53lK5kuhTQNxlpUejaVjs2AIWO6qCLpSzus/C223expCGQwpWXJDjdgoEdRf/bOdnZvOGrBiCgM8DMO/oPOO8+JR4vLXpLUzaMcmslQfVzLkTf0dMMgEeAWgU1AjtK7ZHcnqy9QZPF5PoE5nxLw+AHb2AO5uhai58C5x4V3re+Eug2gilR8RYEup6Lt90hf6r9Gg0DftUbBE0KAp9sdhREy82fvHhC/m3AhxcpIKQ8ZcBbztPa34I5BIkYbP83HK8++i7xr5U/u5S521Tyw4JmMH1B4vXUjNSjV3JX2/9umj3EOITYlzW3dkdx/53zPo7ILsKAh8FnH2A22uAHX2Adv8CZQtZmNIWXPkFODJGel7vQ6D260qPiLGWKyt8q3R+8jEuMmzZsTYURW9IA1wDAc+KSo+GyQMqSpcDJ3fAv6X0nFPQHwq1a6AKxiVQQhT4k5naaSqS30/GRx0+MhMwvz35G2b3mG0UOkTlkpWFFYesbzbn5nLpseJA4NG/pTondLOy43Hg9gaoCootOvCC9LzmWKD+x0qPiLEWwX2lx8g9UqFTpkiw2LGlC4uDBlUHuU0GLB2A+nPqi+yefFPQmXyhTLd1g9dh89DNqBVQy2y+qaBRJYm3gah9WXfSVFjykWXShSYjGdjZF7i9DqogbBOwZyBgyACqvAA0mcm/LXrGs0Jm3SQDELpS6dFoFhY71ubuIemRXViqxM3JDQmpCSKIdn/o/pwLcNzOQzkfdd7MYtOuYjtoDtmFRZWzPcpJz0mgtf0LCO6XKXieAG6tUXSY4u6expGRAoQ8BbSYB5Tgn3HdUz7TunN7tdIj0Sz8LbE2HJysaiiu5MfeP4p2A7nG8dDFz8EZSLwJJFxVYoiqZs6hOaj7fV3MO5IVfKxJZBdWyJPm80nwPPInENJfEhi7+gGhqxQZIu4dA7b3AtITpforbX4HHByVGQtjW8r3kh4pYN6aQfo6hsWONUm5D8RlxoL4c+VktVLepzyalG2Sd2EvWahyCnoOToafFFaxm7E3oVmSorJisrKLHYLEbts/JEtKRiqwu7/t3Qkx54Ft3YDUGCmAmmKK1O4aZCxHyUaAWxCQlsCNQYsIix1rIreI8KoKuCoQcMkUmttxt/HGhjeQmp6aM26Hg5Rz8H2v7/HvwH8xqcMkaJZbq6TKw3RB8aqS+zJC8CwGKgzIFDxPATdtVNWW2gVs6wIkR0qxG+1XSSKcsR/IVVmuh/T89lqlR6NJWOxYE3ZhaYq0jDS0W9gOM/fPxPQ9mUXazMQOBykTV+9fNdbGITfg4zUfN6aZa9qFFZyLVSe74CHXEWVrCcHzdNZ7rcWDO8CWzkBiqNRqpsN6wMXXuttk1AmLnWLBYseasNjRFE4OTsJC0axcM/SrldlxmAhoA5Rwku6w46/Bnjl8+7BowDlu/TjhvtI8qXHAnY15u7CyQ+1eWv8KVHxWKimxewBwY5l1xpZ8D9jaBYi/BHhWBh7bBLgFWGdbjDYag1I15djzQPwVpUejOVjsWAu68717QHrOYkczPFv/Wewbvg91S9fNmunsBZRqJj23c1fW8TvHRfXjUxGnzF19WoWyqyjw2LtGwZv0CsHzC1DpOcn9RWngN6S+XRYVYdt7ADGnAfdyQKfNWVlijH3i4gcEtpWeq6UMgoZgsWMtUqMBJ0/JIlCysdKjYQoIuWPIwiNDF/YcKeh2zIgmI7Bq0CoRp+Pq5ArNE2qShVUYVxxlQbVaBFQemil4BgHX/7TMmNKoVcXjkmWYYv06bso7loixL8r1lB5Z7BQaFjvWwqUk8PhloH+kVImX0RQUk0Lp1BW+qoBjYcfsurhgZEIkktOy0l171+gNb1dvaB4SFXL8A6WWFxYSPC0XAFWelwTP3meBa4uLNyYRCzRAig9z8gYe21BwixNjP2KH2kfQ+csUGBY7tjA9Mppk45WNuJ90H98f+l4yH5O/nGrtJNyAvXDvwT10/KUj+vzRBwkpCdAVdzZJqbweIZkValFEwTMfqPKiVNF43xDg6u9FW1dGOrBvqFQ4ztEN6LC66ONi9IlvPcC9vNSo1s6tzIWFxQ7D5OHO+r7n95jdfTZ+6P0D4OyddeGxox8Zqo5M2VenI04jMjESusK0kGBxsskoLbjlPKDqCEnw7B8KXP218DF+h0YB15dIWV+PLgdKa7ASNWNd6Dw1urI4K0szYmfOnDlo0KABfHx8xNS6dWusW5fli+zQoYO46JhOL7/8stk6bty4gV69esHDwwOlS5fGW2+9hbS0NAX2htEbgZ6BeK3la3CUq9SWtr+4nTYhbUSvq41DNqKSXyXoBnIX3VpZ8CysggieFnOBai9lWniGAVd+LrjQOf42cDmz9QOlt8tpxgyTHRY7RSIrElMBgoODMW3aNFSvXl3ESPz888/o27cvjh07hrp1pWyYkSNHYvLkycb3kKiRSU9PF0InKCgIe/fuRVhYGIYOHQpnZ2dMmTJFkX1i9AmlWf8cnYJnMwBXnVdSpnpDMUkxxs7jrYJbQXdQ7BVVOHcrDQRkZrgUFxIqzedI7s6Lc4D9L0jCp2pmd/K8OPMZcO4L6XmLn4AKT1tmPIw+CeokWf/iLwOxFwGf6kqPSBMoatnp06cPevbsKcROjRo18Nlnn8HLywv79+83EzckZuSJLEAyGzduxNmzZ/Hbb7+hUaNG6NGjBz755BN89913SElJUWivGD0ycNlAvLhzFibdpxStS0DiLehV1I1YOQJtFrTBjRgdxyYZCwk+Ydn+UiR4mn0HVB8tdak+MBy4PD/v5S98DZz8QHreZNbDhRHDkEs9MNPFydYd7cXskJVmyZIlSEhIEO4smd9//x0BAQGoV68eJk6ciMTERONr+/btQ/369VGmTBnjvG7duiE2NhZnzpzJc1vJycliGdOJYfJjUL1B8HLxQiXfirp2ZUUkRGDbtW24fO8yToWfgi6hQGC5y/nDqiYXNa6i2TdAjTGZgmcEcCmXRqlXFgFHxkrP608CamU+Z5iHwdWUteXGIk6dOiXETVJSkrDqrFixAnXqSKmWzz77LCpWrIhy5crh5MmTmDBhAi5cuIDly6W7sjt37pgJHUL+m17Li6lTp2LSJA338mFsTr/a/XClwhUEXpgOnP9ScoNUehZ6I8grCHte3IODtw6iV43MTst64+5+ICkccPYFyjxmnW2Q4Gk6W7L0XJgNHMyM5an+P+n1G39LVh+i1utAvUzrDsMUNG7n2JtSiQLKKKSaboy6xU7NmjVx/PhxxMTEYNmyZRg2bBh27NghBM9LL71kXI4sOGXLlkWnTp1w+fJlVK1atcjbJAvR66+/bvybLDshISHF3hdG/wHLorjg+S9hCN8ODXeDyjXFvJR7KfE82CdYTLqFhAZRvo91O4eT4GnylWRAv/AVcIiSKzIAzyrA3kGZ8TwjgMZfFC8bjLE/fGoBnpWAhGvAna1AcB+lR6R6FHdjubi4oFq1amjatKmwuDRs2BCzZ8/OddmWLVuKx0uXLolHiuEJDw83W0b+m17LC1dXV2MGmDwxTIEIfATnUoC25y5i13826nptZRYdX4RqX1fD3pt7oXso88m0arK1EYLnS6DWG9Lfh14BdvaVssEqPAM0/4GFDlO8FPQwrqasCbGTnYyMDBFTkxtkASLIwkOQ+4vcYBEREcZlNm3aJMSL7ApjGIvi4ocvE/2xLwmYufsz6CEgmcQOFU9cdWEVdM/9Y1JDV0cPoGw3212YGn8O1H5b+jsjWbpQUX8tSwZHM/abgk4inlGvG4vcSZRBVaFCBcTFxWHx4sXYvn07NmzYIFxV9Ddla/n7+4uYnfHjx6Ndu3aiNg/RtWtXIWqGDBmCGTNmiDid999/H6NHjxbWG4axBl80GYDw3XMws4r2Uz4dSjhgzbNrMP/YfIxpQQG1OkfOwqIAT6esMhY2ETyNpgGeFYC4y0DDz6zrQmP0D8WbObhK4j32HLcVUbPYIYsM1cWh+ji+vr5CxJDQ6dKlC27evInNmzdj1qxZIkOLYmr69+8vxIyMo6MjVq9ejVGjRgkrj6enp4j5Ma3LwzCWxi+4B1aVmwNE75HuqEqUwLTd00QPqcmPTYani/qDBWOTY+HjKrlvabxUPNEuMK2abGtI8NSglHSGsQAk1imGMGyDZN1hsZMvJQxUzc/OoQBlElsUJM3xO8xDoQZ8y0sDafFA1/0Ic62AyrMrIzk9GX899ReerqvuonBHw46i22/d8GXXLzG04VDYDTHngDV1pIJsT0YCLr5Kj4hhigfVaaLyBWTl6bQV9khsAa/fqovZYRjVQ13syz8uPb/xF8p6l8XyZ5ZjROMReKrOU8bF1HofcTbyLKISozDv6DykU80Ze0G26pTpzEKH0VfcTuRuIJXrxeUHix2GKQoVB0iPN5aKFOKe1Xti3uPzRP82IiU9BY/9/Bh+Pv6zoqKHtr35ymbsvrHbOO+Zus8IYbZq0Kqsvl/2JHYq9Fd6JAxjGbyrAd7Vpey+O1uUHo2qYbHDMEWBMnmcvIHEm0DUgRwvzz86Hzuu78Bbm95CTHIMlOKbg9+gy69d8ObGN42iy9nRWQgzPzc/2A3x14D7R6Uif7JVjmH0QFmuplwQWOwwTFFwdAOC+0rPb/yV4+URTUZgeufp+Lbnt2aiwtpWngepD4SLytSKQ8UCW5RvIaxNdovcHoJ6CrkFKj0ahrEcnIJeIFjsMExRqWDuyjKFrCdvt30bA+oOyOrldnMfmv7YFIduHbLKcFacW4FKsysJa5JMGa8yuPX6LXzd42u4OtlxOYabfyuXhcUw1qRMe8DRHXhwG4g+qfRoVAuLHYYpKmW7As4+wINbQNS+hy4+cctEHLtzDN8f/t4qwynnXU408qT4HFMrjpuTG+yaB2FA5N6sLucMozcrc5lO0vPbXE05L1jsMExRcXTNunhez+nKys7Sp5fi5aYv44suXxjnFTUb6r+7/+HFf1/EV/uo95JEy+CWWDd4Hc6+chYuXLAui9B/pe7j/i0AT+6Bx+iQ8iauLCZXWOwwjCVcWTeXAg8RLtRIdE7vOfD38DfOG7d+HAb9PQjh8eY93h4G9bFaeHwhZuydYWbF6V6tu3ChMbkVEuQsLEbnQcpRe4GU+0qPRpWw2GGY4hDUBXD2lVwlUXsK9dbQ2FDMPTIXS04vwemI03kuR0HNay+uNUsff7b+s3ix0YtYPmA5W3HyI/keEL5Neh7cT+nRMIx18KoE+NQGDOlA2CalR6NKWOwwTHEgoRHSr8CuLFOCfYKxf8R+fPrYp+hUJdPnDiA1PdVsuZn7ZqLX4l6YsHmCcR4JnPl956N1SGuogvQkIGwjcGQ8sLYBsPe5HEHbinBrFWBIA/zqAz7a72XGMAXKymJywGKHYSzmylr2UFdWdpqUbYL32r1n1rOqzvd1sODYAmOaOllxAjwC0Dq4dQ4hpChxl4AL3wDbewHLSgHbugEXZgHRp4BrvwOXflSPCyuYs7AYOxE7YevVcaOhMhRtBMowuoAyIVxKAknhQOQuqTlfEfnlxC+4dO8S9tzYgxcbvyjmUTuK0PGhyqeOpyUA4duljA/6QY2/bP66e3mgXHfAwQ24+B1w7G2gfG/AI1iZ8abGS00SCU45Z/RO4COAk5f0O3T/GFCqqdIjUhUsdhjGIq6sJ4HL86UCg8UQO6ObjxZFCJeeXSqsOHKwsSJChyxLseezxE3ETiAjOet1aqhJP7AUHEkix7ee1NmbrFv3jgB39wOHXgHa/SvNtzVh66TxelWT3FgMo/ffIYohpAKat9ay2MkGdz3nrueMJaB4FXLjuJUGnrgFOGj0PiI1TuqxQ+KGpoTr5q97VswSN2U6As7eua8n+gywvrHUs6ftn1m9xGzJnkHA9SVA7beBxtNtv32GsTWX5gEHXwL8WwHdHl77y2Yk3wVcSlnlpqeg12+N/iIzjMoo8xjg6g8kRUgWkKCO0AR0r0MxNiRsyIJD3ZMpoFfGwRUo3V4SNyRyfGoW7AfLry5QZyJwejJwZAwQ1BlwLQWbBkzfWi09ZxcWYy+Uy0xBv3sASIoC3AKUHhGEpXfTI4B7WaDlfMCrsiLDYLHDMJaAXDoUBHt5nuTKUrPYkYWA7J6iMvOmeFWVfjRJ3FApeifPom2n7rtSK43Yc8CxN4FWC2Az7mwG0uKlOCL/5rbbLsMoCcXH+TWQ2kbc2QhUelbpEQHXfpPc4XQjSDeECsHZWAxjKWRXDfVhyjCxjqjNkrO9N7D7aeDKAknoUF8dyuRo+g3Q5yLw+CWg2TdSVdaiCh25wnTLn8hbDlxZKAkQmxcS7Cd1OmcYe0FNKejpycCpj6TndSdK7XUUgn8FGMZSlO4AuAYAyVFZhezURsQOIHyL5J6qOQ54bAPw1D2gwxqg5quAdzXLbi+wDVBjtPT8wEtAWiKsDglN0SKCqyYzdp6CXsR2NBbj8k9S3B+5sKpn/g4oBIsdhrEUFJQsX1zJlaVGzn0uPVZ9EWj6ldTMlBoJWpOGUyTzesLVrLs8a0IxUyn3JOFJ2WIMY08EtJaqulNQ8L1DypaqOP2J9LzeB4CTu3JjYbHDMNYqMLhcykRSE5QhJUzbJYCa4223XcrYav6D9Pz8TODuYetuj9yIRHBf7WbFMUxRoXOebmKUdmX9961U88ezMlBlOJSGxQ7DWJLS7aT0c7Is3NkKVXH+y6w4Flu3TijfC6g4SKrsemCE9YQgrZ/qjBBcNZmBvcftrFNm+ynRwNnMcg8NJkk1gBSGxQ7D2IMrK/G2lBVB1H5LmTE0nSXV2og+AZz7wjrbiDogNWWlQMigrH5jDGNXlO0uPd47DDwIt/32z30pdV/3rQNUVEFGGIsdhrGiK4ssDOkpUAX/fSNZUwLbAgGtlBkDWbxI8BCnJgGx/1l+G6GZWVjlekvZYAxjj7gHZVVQpkBlW0Ip5he+kp43+BRwcIQaYLHDMJYm8FHALUi6s6HMJzVURb44R1mrjkyl54CgrlIbB6r0asmGhZRWb0w5ZxcWY+dQnSwl4nbOTJOCk0s1A4KfgFpgscMwlobuZCo8pR5XFvXsSo0BvGsA5fsoOxaqvtxiLuDoIaXBU2qqpSD3WPwVKbuMKj4zjD1jTEHfaLu6Xwk3gYvfZ2VhKtETLw9Y7DCMVbOyFHZlkevqfKZJufYb6iiw51UJaPiZ9PzYW1I8kSWQrToUr1CcYogMowf8W0gxcqnRQNR+22yTUs3Jaks1x6hFjIpQwS8fw+gQio2hQlpkUaGy7UpB7RoSb0jxMpWHQjXUGCP9GKfGAodHSy6o4sIuLIYxtzDLgcq3beDKir0oVWUn6GZGRVYdgsUOw1gDsqCEPC09v66QK4sEhJz1ROLC2sUDC/tDTK0kSjgBof9kCZWiEnsBiDkjrU9pVx3D2GPriFMfAYZ0KTmAKqerDBY7DGPtXlm3/pWab9qa8K3A/WNSfEz1UVAdfvWBOu9Izw+/KgV0FxVyFxKUbu7iZ5nxMYzWKdtNKiIafQJIvGW97dw/AVz/Q3re8FOoERY7DGPNsu3UdZtcNRQkqGRrCAW7DedLvfcAn5pA0h0pfqeosAuLYXLiFiC5i61dYPDkB9JjxYFAyYZQIyx2GMaarqwKTyuTlXX/JBC2QRpDLRu2higs5Fpr8VNW1lhRqk4n3MjsAVQCKN/X4kNkGH1kZa2zzvoj9wG3VgElHIH6k6BWFBU7c+bMQYMGDeDj4yOm1q1bY9066YDcu3cPY8aMQc2aNeHu7o4KFSrgtddeQ0xMjNk6SpQokWNasmSJQnvEMHkVGPwXSHugQGuI/oBXFaia0o9kudmo9k5hPyfZhUVNP93LWH58DKMLsbPJ8pmhFBd44l3peZUXAJ8aUCuKip3g4GBMmzYNR44cweHDh9GxY0f07dsXZ86cwe3bt8X0xRdf4PTp01i0aBHWr1+P4cNzNhRbuHAhwsLCjNMTT6inkBFj5wS0BDxCgLR4ydJiCxJDgWuL1VFEsKA0mia5/OIvA6c+LlrVZLlNB8MwWZRqImVjpsUBUXssu24qmhqxHXBwAep9CDWjqNjp06cPevbsierVq6NGjRr47LPP4OXlhf3796NevXr4+++/xTJVq1YVQoheX7VqFdLSzAsk+fn5ISgoyDi5uako64Sxb5RwZV34GjCkAaXbA/7NoQmol1Xz77OsUveOFux91PcnYldWg1OGYXL+BpW1QjVlsuocz7TqVH8F8AyBmlFNzE56erpwPyUkJAh3Vm6QC4vcXU5OTmbzR48ejYCAALRo0QILFiyA4SE1O5KTkxEbG2s2MYzVqPCM9HhrpfVdWRQMfWmu9Lz2m9AUwY9Lbj9KXxWd0QtQ9ZU+Uxik0vSeFWwxSobRHuWsIHbINU+xclTAs+5EqB3Fxc6pU6eENcfV1RUvv/wyVqxYgTp16uRYLioqCp988gleeukls/mTJ0/GX3/9hU2bNqF///545ZVX8M033+S7zalTp8LX19c4hYSoW5EyGoesK54VpX4x1q53celHSfD41M7y1WuJpl8DLiWllPnzMx++/M2/pUfOwmKYvCnbVbLwxJwFEq4Xf30Z6cDJ96XnNcdJbjKVU8LwMDOIlUlJScGNGzeE1WbZsmX46aefsGPHDjPBQ5aXLl26oFSpUli5ciWcnZ3zXN+HH34oYnhu3ryZr2WHJtP1k+CRLUcMY3GOvS2lgpPl4pE/rbMNCj5cWQV4cAtoOV9KOdciVxYB+1+QMrV6ngK8q+W+XEo08Heg5LLrfV5KYWcYJnc2PQpE7gaazwGqv1y8dV39Ddg3BHD2A/peVbS2FV2/yWjxsOu34pYdFxcXVKtWDU2bNhUWl4YNG2L27NnG1+Pi4tC9e3d4e3sLq09+Qodo2bIlQkNDzcRMdsiKJGeAyRPD2CQr69ZqycJjDW78KQkd6rheaTA0S+VhUl8dKsQoOqPncT9GnyUJHd86LHQYxlbVlNNTpGrJRJ0JminiqbjYyU5GRoZRqJBi69q1qxBEZNEpSODx8ePHUbJkSSFoGEY1lGoKeFYG0hOt48oSrSEyiwjWfA1w1PD5b+yM7g6Eb8vqt5NnIUHOwmKYAoudO1uKV9Gdvo/xVwC3MkDNMdAKioqdiRMnYufOnbh27ZqI3aG/t2/fjsGDBxuFDgUsz58/X/x9584dMVEwM0GZWeT2otT0S5cuibo9U6ZMEfV5GEZ1F3C5fYQ1emXd2QREn5KCBYtrolYDVBuowSfS86NvAg/CzF8n61jYeuk5x+swzMPxawC4l5NuuCJ2Fm0dlGBxerL0vO770u+NRjBPa7IxERERGDp0qKiNQz43KjC4YcMGEZ9DoufAgQNiOXJzmXL16lVUqlRJuLS+++47jB8/XmRg0XIzZ87EyJEjFdojhnmIK+vsdOD2GiA1HnD2skJriBFSgK8eqDkWuL4EuHcYODwGeHRZ1mu31wPpDyRrmZ86y9MzjOpuuMr1kCqVU+sIClouLBe/k248KOGimraus4oHKKuBggY4MUyxoK/aqupS4by2S4CKmSnpxeX+cWBdY6lce59LgFcl6AZqMLi+mRSb8+jyrFo6ewYD1xcDtd4AmmR2dmcYJn9uLgd29Qe8awB9LhTuvZTlSQkQyXeBVguBKs9DDWgmQJlh7OrOSg5UtmSBwXOZF3sqXqgnoUNQU8E6b0vPD4+WMrDSk4Hbq6V57MJimIIT1Bko4QTE/QfEXSrce89/JQkdn1pApeegNVjsMIwtkeN2KEg5Na7466MmmOTq0VJriMJS7wPpTpTM58cnAOFbpbtM97JAQCulR8cw2sHZByj9aOG7oCdFAecy++1RLJ2DohEwRYLFDsPYEoov8a4uZUNQp+DicmG2VHG4TEepB44eoXo7LedlFU08+YH0PLifVCiNYZiCU7YI1ZTPTZd6a5VsollrKv9SMIzNXVnPWMaVRS4duvhrsTVEYSndDqj2P+n5vSPSo0Z/dBlGFSnoEduBtMSHL594C/jvW+l5w880e4OhzVEzjC5cWeskd0xRoR5Y1E3dtx5Qtjt0T6PpUuos4VJKEkAMwxQO3zqARwXJuhy+/eHLn/5UWjbwUaBsN2gVFjsMY2tInFCQX0YKEEqNLItYxZRcWLJVhyxGesfFF2gxD3BwllLs6ZFhmCKkoPcsmCsr7jJw+ScTq452f2dY7DCMFrOyKO2aAnbJ0lFxEOyG8j2Bp6KBRtOUHgnDaJdysthZk3c7FuLUx1LZB4rzkQObNQqLHYZRAlnshG2QYm8K3Rrii6zCe44usCucPDR9h8kwihPUEXBwARKuAbF51NuJPg1c+1163vBTaB0WOwyjBH51Jd95UVxZ1CYh5gzg5J0VtMswDFNQnDyB0u2l52F5pKCLrEeDVL9LB5meLHYYRimK6sqSW0NQuXaKY2EYhiks5fKJ24k6CIT+I2Ve1c/shaVxWOwwjFLQHRNxZyOQcr9g76G0a+oETlVQa46z6vAYhrGHFPQdUq8+U06+Jz1WHgr41oIeYLHDMEpBbizKzMpIBUL/Ldh75FidigMBzxCrDo9hGB3jXR3wqir9/oRvyZp/ZytwZ7OU7VjvI+gFFjsMowZX1vU/H75s/DXgxlL7KCLIMIxtuqCburIo+eFEplWH4gF11GuPxQ7DqMKVtVlqsvewRnzUGiKoi9Qgk2EYxiJxO+skoXNrNXB3P+DoDtTNFD06gcUOwygJ+cP9Gki1LCggMC+S7wFX5uu74SfDMLaldAep91ziTSD6VFasDpW0cA+CnmCxwzBKUzGzV9b1fLKyLv0ApCVIjUSDOttsaAzD6Bgnd6mJMHHwJUnwOPvq8oaKxQ7DKE1IpiuLggSTonK+np4MXPjavlpDMAxjW1fW3QPSIwkd11LQGyx2GEZpfKoDJRtL8TihK3K+fu03ICkc8AjOsgIxDMNYgnKZQcqEa6DkwtIhLHYYRs0FBg0ZJq0hxnHzS4ZhLItXFakMBkFByc5e0CMsdhhGTVlZ4VuBpMis+ZQSGnsecPaRKiYzDMNYmta/AU2/AWqMhl5hscMwasC7KlCqqWTJubk8l9YQ/5MED8MwjKUp1Rio+Srg4AS9wmKHYVTnyvozqz9NxE7JdaVTPzrDMIwtYLHDMGpzZVGvmgd3gPNya4hnAY/yig6NYRhGy7DYYRi14FUZKNU8Kyj55t/S/NpvKD0yhmEYTcNih2HURMVMV9b5LyXRU7Y74Fdf6VExDMNoGhY7DKNGV5aMDiuZMgzD2BoWOwyjJjwrAv6tpOdUaLDMY0qPiGEYRvOw2GEYtVH3XcCzEtD4C24NwTAMYwH0m1TPMFoluI80MQzDMBaBLTsMwzAMw+gaFjsMwzAMw+gaRcXOnDlz0KBBA/j4+IipdevWWLdunfH1pKQkjB49Gv7+/vDy8kL//v0RHh5uto4bN26gV69e8PDwQOnSpfHWW28hLS1Ngb1hGIZhGEaNKCp2goODMW3aNBw5cgSHDx9Gx44d0bdvX5w5c0a8Pn78eKxatQpLly7Fjh07cPv2bTz55JPG96enpwuhk5KSgr179+Lnn3/GokWL8OGHHyq4VwzDMAzDqIkSBoPBABVRqlQpfP7553jqqacQGBiIxYsXi+fE+fPnUbt2bezbtw+tWrUSVqDevXsLEVSmTBmxzA8//IAJEyYgMjISLi4uBdpmbGwsfH19ERMTIyxMDMMwDMOon4Jev1UTs0NWmiVLliAhIUG4s8jak5qais6dOxuXqVWrFipUqCDEDkGP9evXNwodolu3bmLnZetQbiQnJ4tlTCeGYRiGYfSJ4mLn1KlTIh7H1dUVL7/8MlasWIE6dergzp07wjLj5+dntjwJG3qNoEdToSO/Lr+WF1OnThVKUJ5CQkKssm8MwzAMwyiP4mKnZs2aOH78OA4cOIBRo0Zh2LBhOHv2rFW3OXHiRGHykqebN29adXsMwzAMw9hxUUGy3lSrVk08b9q0KQ4dOoTZs2fjmWeeEYHH0dHRZtYdysYKCgoSz+nx4MGDZuuTs7XkZXKDrEg0MQzDMAyjfxS37GQnIyNDxNSQ8HF2dsaWLVuMr124cEGkmlNMD0GP5AaLiIgwLrNp0yYRpESuMIZhGIZhGEUtO+RO6tGjhwg6jouLE5lX27dvx4YNG0QszfDhw/H666+LDC0SMGPGjBEChzKxiK5duwpRM2TIEMyYMUPE6bz//vuiNg9bbhiGYRiGUVzskEVm6NChCAsLE+KGCgyS0OnSpYt4/auvvoKDg4MoJkjWHsq0+v77743vd3R0xOrVq0WsD4kgT09PEfMzefJkBfeKYRiGYRg1obo6O0rAdXYYhmEYRntors4OwzAMwzCMLrOx1IBs3OLiggzDMAyjHeTr9sOcVCx2ABEcTXBxQYZhGIbR5nWc3Fl5wTE7menu1F/L29sbJUqUsKjiJAFFRQv1HgtkT/tqb/vL+6pf7Gl/eV/1CUkYEjrlypUTCU15wZYdClxycBAd2K0FnWx6P+HscV/tbX95X/WLPe0v76v+yM+iI8MBygzDMAzD6BoWOwzDMAzD6BoWO1aEqjh/9NFHdlHN2Z721d72l/dVv9jT/vK+2jccoMwwDMMwjK5hyw7DMAzDMLqGxQ7DMAzDMLqGxQ7DMAzDMLqGxQ7DMAzDMLqGxU4x+e6771CpUiW4ubmhZcuWOHjwYL7LL126FLVq1RLL169fH2vXroXamTp1Kpo3by4qTJcuXRpPPPEELly4kO97Fi1aJKpRm060z1rg448/zjF2OmZ6O64EnbvZ95Wm0aNH6+K47ty5E3369BHVVWms//zzj9nrlJ/x4YcfomzZsnB3d0fnzp1x8eJFi3/vld7X1NRUTJgwQZybnp6eYpmhQ4eKyvGW/i6o4bg+//zzOcbdvXt3TR7Xguxvbt9hmj7//HPNHVtrwWKnGPz55594/fXXRYrf0aNH0bBhQ3Tr1g0RERG5Lr93714MGjQIw4cPx7Fjx4RooOn06dNQMzt27BAXv/3792PTpk3ih7Nr165ISEjI931UuTMsLMw4Xb9+HVqhbt26ZmPfvXt3nstq9bgShw4dMttPOr7E008/rYvjSucofS/pIpYbM2bMwNdff40ffvgBBw4cEEKAvsNJSUkW+96rYV8TExPFWD/44APxuHz5cnHD8vjjj1v0u6CW40qQuDEd9x9//JHvOtV6XAuyv6b7SdOCBQuEeOnfv7/mjq3VoNRzpmi0aNHCMHr0aOPf6enphnLlyhmmTp2a6/IDBgww9OrVy2xey5YtDf/73/8MWiIiIoLKFRh27NiR5zILFy40+Pr6GrTIRx99ZGjYsGGBl9fLcSXGjh1rqFq1qiEjI0N3x5XO2RUrVhj/pn0MCgoyfP7558Z50dHRBldXV8Mff/xhse+9GvY1Nw4ePCiWu379usW+C2rZ12HDhhn69u1bqPVo4bgW9NjSvnfs2DHfZT7SwLG1JGzZKSIpKSk4cuSIMHub9tiiv/ft25fre2i+6fIE3TnktbxaiYmJEY+lSpXKd7n4+HhUrFhRNKTr27cvzpw5A61ArgwyGVepUgWDBw/GjRs38lxWL8eVzunffvsNL774Yr4NcbV8XE25evUq7ty5Y3bsqMcOuS/yOnZF+d6r+XtMx9nPz89i3wU1sX37duF2r1mzJkaNGoW7d+/muayejmt4eDjWrFkjLM0P46JGj21RYLFTRKKiopCeno4yZcqYzae/6Qc0N2h+YZZXa4f4cePGoW3btqhXr16ey9EPDJlS//33X3EBpfe1adMGoaGhUDt0saPYlPXr12POnDniovjoo4+Kzrp6Pa4ExQFER0eLeAc9HtfsyMenMMeuKN97NUJuOorhIfdrfo0iC/tdUAvkwvrll1+wZcsWTJ8+Xbjie/ToIY6dno8r8fPPP4v4yieffDLf5Vpq9NgWFe56zhQKit2hWJSH+XZbt24tJhm6INauXRtz587FJ598AjVDP4oyDRo0ED8KZMn466+/CnS3pFXmz58v9p3u9PR4XBkJirkbMGCACM6mi5wevwsDBw40PqegbBp71apVhbWnU6dO0DN0M0JWmoclDvTQ6LEtKmzZKSIBAQFwdHQUJkNT6O+goKBc30PzC7O82nj11VexevVqbNu2DcHBwYV6r7OzMxo3boxLly5Ba5CZv0aNGnmOXevHlaAg482bN2PEiBF2c1zl41OYY1eU770ahQ4dbwpGz8+qU5TvglohNw0du7zGrfXjKrNr1y4ReF7Y77GWj21BYbFTRFxcXNC0aVNhJpUhkz79bXrnawrNN12eoB+cvJZXC3QHSEJnxYoV2Lp1KypXrlzodZCJ+NSpUyLFV2tQjMrly5fzHLtWj6spCxcuFPENvXr1spvjSucxXchMj11sbKzIysrr2BXle682oUNxGiRs/f39Lf5dUCvkZqWYnbzGreXjmt06S/tBmVv2cmwLjNIR0lpmyZIlInNj0aJFhrNnzxpeeuklg5+fn+HOnTvi9SFDhhjeeecd4/J79uwxODk5Gb744gvDuXPnRDS8s7Oz4dSpUwY1M2rUKJGBs337dkNYWJhxSkxMNC6TfV8nTZpk2LBhg+Hy5cuGI0eOGAYOHGhwc3MznDlzxqB23njjDbGvV69eFcesc+fOhoCAAJGFpqfjapp1UqFCBcOECRNyvKb14xoXF2c4duyYmOjnbubMmeK5nIE0bdo08Z39999/DSdPnhRZLJUrVzY8ePDAuA7Kavnmm28K/L1X476mpKQYHn/8cUNwcLDh+PHjZt/j5OTkPPf1Yd8FNe4rvfbmm28a9u3bJ8a9efNmQ5MmTQzVq1c3JCUlae64FuQ8JmJiYgweHh6GOXPm5LqOjho5ttaCxU4xoZOHLhQuLi4idXH//v3G19q3by9SIE3566+/DDVq1BDL161b17BmzRqD2qEvV24TpSHnta/jxo0zfi5lypQx9OzZ03D06FGDFnjmmWcMZcuWFWMvX768+PvSpUu6O64yJF7oeF64cCHHa1o/rtu2bcv13JX3idLPP/jgA7EvdKHr1KlTjs+hYsWKQsAW9Huvxn2lC1pe32N6X177+rDvghr3lW7CunbtaggMDBQ3HbRPI0eOzCFatHJcC3IeE3PnzjW4u7uL8gm5UVEjx9ZalKD/Cm4HYhiGYRiG0RYcs8MwDMMwjK5hscMwDMMwjK5hscMwDMMwjK5hscMwDMMwjK5hscMwDMMwjK5hscMwDMMwjK5hscMwDMMwjK5hscMwjOahTu1PPPGE0sNgGEalcNdzhmFUTYkSJfJ9/aOPPsLs2bNFDzeGYZjcYLHDMIyqCQsLMz7/888/8eGHH4rOzjJeXl5iYhiGyQt2YzEMo2qoM7k8+fr6CkuP6TwSOtndWB06dMCYMWMwbtw4lCxZEmXKlMG8efOQkJCAF154Ad7e3qhWrRrWrVtntq3Tp0+jR48eYp30niFDhiAqKkqBvWYYxpKw2GEYRpf8/PPPCAgIwMGDB4XwGTVqFJ5++mm0adMGR48eRdeuXYWYSUxMFMtHR0ejY8eOaNy4MQ4fPoz169cjPDwcAwYMUHpXGIYpJix2GIbRJQ0bNsT777+P6tWrY+LEiXBzcxPiZ+TIkWIeucPu3r2LkydPiuW//fZbIXSmTJmCWrVqiecLFizAtm3b8N9//ym9OwzDFAOO2WEYRpc0aNDA+NzR0RH+/v6oX7++cR65qYiIiAjxeOLECSFscov/uXz5MmrUqGGTcTMMY3lY7DAMo0ucnZ3N/qZYH9N5cpZXRkaGeIyPj0efPn0wffr0HOsqW7as1cfLMIz1YLHDMAwDoEmTJvj7779RqVIlODnxTyPD6AmO2WEYhgEwevRo3Lt3D4MGDcKhQ4eE62rDhg0ieys9PV3p4TEMUwxY7DAMwwAoV64c9uzZI4QNZWpRfA+lrvv5+cHBgX8qGUbLlDBw2VGGYRiGYXQM364wDMMwDKNrWOwwDMMwDKNrWOwwDMMwDKNrWOwwDMMwDKNrWOwwDMMwDKNrWOwwDMMwDKNrWOwwDMMwDKNrWOwwDMMwDKNrWOwwDMMwDKNrWOwwDMMwDKNrWOwwDMMwDKNrWOwwDMMwDAM9838cKmCBYUr3aAAAAABJRU5ErkJggg==" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 6 + "id": "cf58a5e25bda0d8a" }, { - "cell_type": "markdown", - "id": "3e97b9b31693702d", "metadata": {}, + "cell_type": "markdown", "source": [ "It seems to be underestimating the peaks and troughs. Contrast this to the direct\n", "strategy which results in very different forecasts" - ] + ], + "id": "1d51be43aeac0859" }, { + "metadata": {}, "cell_type": "code", - "id": "bc5ed962ad010b89", - "metadata": { - "ExecuteTime": { - "end_time": "2025-07-28T20:16:23.264541Z", - "start_time": "2025-07-28T20:16:23.163486Z" - } - }, + "outputs": [], + "execution_count": null, "source": [ "y_hat2 = reg.direct_forecast(y=y_train, prediction_horizon=20)\n", "plt.plot(y_hat2, label=\"Predicted direct\", color=\"blue\", linestyle=\":\")\n", @@ -295,38 +197,20 @@ "plt.plot(y_hat, label=\"Predicted iterative\", color=\"green\", linestyle=\":\")\n", "plt.show()" ], - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 7 + "id": "8bf67ba4ca4dc638" }, { + "metadata": {}, "cell_type": "code", - "id": "5e283827ebb7141b", - "metadata": { - "jupyter": { - "is_executing": true - }, - "ExecuteTime": { - "start_time": "2025-07-28T20:16:23.888457Z" - } - }, + "outputs": [], + "execution_count": null, "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from statsmodels.tsa.exponential_smoothing.ets import ETSModel\n", "\n", "from aeon.datasets import load_airline\n", - "from aeon.forecasting import ETS\n", + "from aeon.forecasting.stats import ETS\n", "\n", "airline = load_airline()\n", "y_train = airline[:100]\n", @@ -384,8 +268,7 @@ "plt.legend()\n", "plt.show()" ], - "outputs": [], - "execution_count": null + "id": "5df42f33db2a1fc4" }, { "metadata": {}, @@ -393,7 +276,7 @@ "outputs": [], "execution_count": null, "source": "", - "id": "a587370d0a01b4be" + "id": "d6c25b89e7bfb60a" }, { "metadata": {}, @@ -401,7 +284,7 @@ "outputs": [], "execution_count": null, "source": "", - "id": "c4cf7f1cb294d317" + "id": "16daa98ba602f01e" } ], "metadata": { From a8a056456a113feae9ec22ea735cd2f9ffbc5490 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Wed, 30 Jul 2025 12:56:57 +0100 Subject: [PATCH 61/76] remove duplicate test --- aeon/forecasting/tests/test_arima.py | 113 --------------------------- 1 file changed, 113 deletions(-) delete mode 100644 aeon/forecasting/tests/test_arima.py diff --git a/aeon/forecasting/tests/test_arima.py b/aeon/forecasting/tests/test_arima.py deleted file mode 100644 index 73d99d7b50..0000000000 --- a/aeon/forecasting/tests/test_arima.py +++ /dev/null @@ -1,113 +0,0 @@ -"""Test the ARIMA forecaster.""" - -import numpy as np -import pytest - -from aeon.forecasting import ARIMA - -y = np.array( - [112, 118, 132, 129, 121, 135, 148, 148, 136, 119, 104, 118], dtype=np.float64 -) - - -def test_arima_zero_orders(): - """Test ARIMA(0,0,0) which should return the mean if constant is used.""" - model = ARIMA(p=0, d=0, q=0, use_constant=True) - model.fit(y) - forecast = model.predict(y) - assert np.isfinite(forecast) - assert abs(forecast - np.mean(y)) < 10 - - -@pytest.mark.parametrize( - "p, d, q, use_constant", - [ - (1, 0, 1, True), # basic ARIMA - (2, 1, 1, False), # no constant - (1, 2, 1, True), # higher-order differencing - ], -) -def test_arima_fit_and_predict_variants(p, d, q, use_constant): - """Test ARIMA fit and predict for various (p,d,q) and use_constant settings.""" - model = ARIMA(p=p, d=d, q=q, use_constant=use_constant) - model.fit(y) - forecast = model.forecast_ - assert isinstance(forecast, float) - assert np.isfinite(forecast) - - -def test_arima_iterative_forecast(): - """Test multi-step forecasting using iterative_forecast method.""" - model = ARIMA(p=1, d=1, q=1) - horizon = 3 - preds = model.iterative_forecast(y, prediction_horizon=horizon) - assert preds.shape == (horizon,) - assert np.all(np.isfinite(preds)) - - -@pytest.mark.parametrize( - "y_input, error_match", - [ - (np.array([1.0, 2.0]), "Series too short for differencing"), - (np.array([1.0, 2.0, 3.0]), "Series too short for ARMA"), - ], -) -def test_arima_too_short_series_errors(y_input, error_match): - """Test errors raised for too short input series.""" - model = ARIMA(p=3, d=2, q=3) - model.fit(y) - with pytest.raises(ValueError, match=error_match): - model._predict(y_input) - - -def test_forecast_attribute_set(): - """Test that calling _forecast sets the internal forecast_ attribute.""" - model = ARIMA(p=1, d=1, q=1) - forecast = model._forecast(y) - assert hasattr(model, "forecast_") - assert np.isclose(forecast, model.forecast_) - - -def test_iterative_forecast_with_d2(): - """Test iterative forecast output shape and validity with d=2.""" - model = ARIMA(p=1, d=2, q=1) - preds = model.iterative_forecast(y, prediction_horizon=5) - assert preds.shape == (5,) - assert np.all(np.isfinite(preds)) - - -@pytest.mark.parametrize( - "p, d, q, use_constant, expected_forecast", - [ - (1, 0, 1, False, 118.47506756), # precomputed from known ARIMA implementation - (2, 1, 1, False, 209.1099231455), # precomputed - (3, 0, 0, True, 137.47368045155), # precomputed - ], -) -def test_arima_fixed_paras(p, d, q, use_constant, expected_forecast): - """Test ARIMA fit/predict accuracy against known forecasts. - - expected values calculated with values fitted by Nelder-Mead: - - 1. phi = [0.99497524] theta [0.0691515] - 2. phi = [ 0.02898788 -0.4330671 ] theta [1.26699252] - 3. phi = [ 0.19202414 0.05207654 -0.07367897] theta [], constant 105.970867164 - - """ - model = ARIMA(p=p, d=d, q=q, use_constant=use_constant) - model.fit(y) - forecast = model.forecast_ - assert isinstance(forecast, float) - assert np.isfinite(forecast) - assert np.isclose(forecast, expected_forecast, atol=1e-6) - - -def test_arima_known_output(): - """Test ARIMA for fixed parameters. - - Test ARMIMA with forecast generated externally. - """ - model = ARIMA(p=1, d=0, q=1) - model.fit(y) - f = model.forecast_ - assert np.isclose(118.47506756, f) From 2f70e54305c6743a1557ea5bb854b7cead1bfa38 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Thu, 31 Jul 2025 18:49:59 +0100 Subject: [PATCH 62/76] Add inverse differencing to differencing series transformer --- aeon/transformations/series/_diff.py | 97 +++++++++++++++++++ .../transformations/series/tests/test_diff.py | 15 +++ 2 files changed, 112 insertions(+) diff --git a/aeon/transformations/series/_diff.py b/aeon/transformations/series/_diff.py index 221987b7bd..1fd2249986 100644 --- a/aeon/transformations/series/_diff.py +++ b/aeon/transformations/series/_diff.py @@ -1,4 +1,7 @@ +"""Difference Transformer.""" + import numpy as np +from numba import njit from aeon.transformations.series.base import BaseSeriesTransformer @@ -59,6 +62,7 @@ class DifferenceTransformer(BaseSeriesTransformer): _tags = { "capability:multivariate": True, + "capability:inverse_transform": True, "X_inner_type": "np.ndarray", "fit_is_empty": True, } @@ -90,3 +94,96 @@ def _transform(self, X, y=None): Xt = diff_X return Xt + + def _inverse_transform(self, X, y=None): + """ + Inverse transform to reconstruct the original time series. + + Parameters + ---------- + X : Time series to inverse transform. With shape (n_channels, n_timepoints). + y : ignored argument for interface compatibility + + Returns + ------- + Xt : np.ndarray + Reconstructed original time series. + """ + if y is None or y.shape[1] < self.order: + raise ValueError( + f"Inverse transformm requires first {self.order} original \ + data values supplied as y, but inverse_transform called with y=None" + ) + if y.shape[0] != X.shape[0]: + raise ValueError( + f"y must have the same number of channels as X. " + f"Got X.shape[0]={X.shape[0]}, y.shape[0]={y.shape[0]}" + ) + X = np.array(X, dtype=np.float64) + y = np.array(y, dtype=np.float64) + initial_values = y[:, : self.order] + + return np.array( + [ + _undifference(diff_X, initial_value) + for diff_X, initial_value in zip(X, initial_values) + ] + ) + + +@njit(cache=True, fastmath=True) +def _comb(n, k): + """ + Calculate the binomial coefficient C(n, k) = n! / (k! * (n - k)!). + + Parameters + ---------- + n : int + The total number of items. + k : int + The number of items to choose. + + Returns + ------- + int + The binomial coefficient C(n, k). + """ + if k < 0 or k > n: + return 0 + if k > n - k: + k = n - k # Take advantage of symmetry + c = 1 + for i in range(k): + c = c * (n - i) // (i + 1) + return c + + +@njit(cache=True, fastmath=True) +def _undifference(diff, initial_values): + """ + Reconstruct original time series from an n-th order differenced series. + + Parameters + ---------- + diff : array-like + n-th order differenced series of length N - n + initial_values : array-like + The first n values of the original series before differencing (length n) + + Returns + ------- + original : np.ndarray + Reconstructed original series of length N + """ + n = len(initial_values) + kernel = np.array( + [(-1) ** (k + 1) * _comb(n, k) for k in range(1, n + 1)], + dtype=initial_values.dtype, + ) + original = np.empty((n + len(diff)), dtype=initial_values.dtype) + original[:n] = initial_values + + for i, d in enumerate(diff): + original[n + i] = np.dot(kernel, original[i : n + i][::-1]) + d + + return original diff --git a/aeon/transformations/series/tests/test_diff.py b/aeon/transformations/series/tests/test_diff.py index 9f54fccf7d..5ac4b39be9 100644 --- a/aeon/transformations/series/tests/test_diff.py +++ b/aeon/transformations/series/tests/test_diff.py @@ -12,26 +12,41 @@ def test_diff(): dt1 = DifferenceTransformer(order=1) Xt1 = dt1.fit_transform(X) expected1 = np.array([[3.0, 5.0, 7.0, 9.0, 11.0]]) + X_hat1 = dt1.inverse_transform(Xt1, X) np.testing.assert_allclose( Xt1, expected1, equal_nan=True, err_msg="Value mismatch for order 1" ) + np.testing.assert_allclose( + X_hat1, X, equal_nan=True, err_msg="Inverse transform failed for order 1" + ) dt2 = DifferenceTransformer(order=2) Xt2 = dt2.fit_transform(X) expected2 = np.array([[2.0, 2.0, 2.0, 2.0]]) + X_hat2 = dt2.inverse_transform(Xt2, X) np.testing.assert_allclose( Xt2, expected2, equal_nan=True, err_msg="Value mismatch for order 2" ) + np.testing.assert_allclose( + X_hat2, X, equal_nan=True, err_msg="Inverse transform failed for order 2" + ) Y = np.array([[1, 2, 3, 4], [5, 3, 1, 8]]) Yt1 = dt1.fit_transform(Y) expected3 = np.array([[1, 1, 1], [-2, -2, 7]]) + Y_hat1 = dt1.inverse_transform(Yt1, Y) np.testing.assert_allclose( Yt1, expected3, equal_nan=True, err_msg="Value mismatch for order 1,multivariate", ) + np.testing.assert_allclose( + Y_hat1, + Y, + equal_nan=True, + err_msg="Inverse transform failed for order 1,multivariate", + ) From 25c5191b590ecb3ff626ffaafd59ae6a9e09c5d2 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Thu, 31 Jul 2025 18:51:22 +0100 Subject: [PATCH 63/76] Fix undifferencing in ARIMA --- aeon/forecasting/_arima.py | 36 ++++++------------------------------ 1 file changed, 6 insertions(+), 30 deletions(-) diff --git a/aeon/forecasting/_arima.py b/aeon/forecasting/_arima.py index 6f08af4325..a6e07e5270 100644 --- a/aeon/forecasting/_arima.py +++ b/aeon/forecasting/_arima.py @@ -12,6 +12,7 @@ from aeon.forecasting._extract_paras import _extract_arma_params from aeon.forecasting._nelder_mead import nelder_mead from aeon.forecasting.base import BaseForecaster +from aeon.transformations.series._diff import _undifference class ARIMA(BaseForecaster): @@ -123,19 +124,9 @@ def _fit(self, y, exog=None): # parameters differenced_forecast = self.fitted_values_[-1] - if self.d == 0: - forecast_value = differenced_forecast - elif self.d == 1: - forecast_value = differenced_forecast + self._series[-1] - else: # for d > 1, iteratively undifference - forecast_value = differenced_forecast - last_vals = self._series[-self.d :] - for _ in range(self.d): - forecast_value += last_vals[-1] - last_vals[-2] - # Shift values to avoid appending to list (efficient) - last_vals = np.roll(last_vals, -1) - last_vals[-1] = forecast_value # Extract the parameter values - self.forecast_ = forecast_value + self.forecast_ = _undifference( + np.array([differenced_forecast]), self._series[-self.d :] + )[0] if self.use_constant: self.c_ = formatted_params[0][0] self.phi_ = formatted_params[1][: self.p] @@ -196,12 +187,7 @@ def _predict(self, y, exog=None): forecast_diff = c + ar_forecast + ma_forecast # Undifference the forecast - if d == 0: - return forecast_diff - elif d == 1: - return forecast_diff + y[-1] - else: - return forecast_diff + np.sum(y[-d:]) + return _undifference(np.array([forecast_diff]), self._series[-self.d :])[0] def _forecast(self, y, exog=None): """Forecast one ahead for time series y.""" @@ -240,17 +226,7 @@ def iterative_forecast(self, y, prediction_horizon): # Correct differencing using forecast values y_forecast_diff = forecast_series[n : n + h] - d = self.d - if d == 0: - return y_forecast_diff - else: # Correct undifferencing - # Start with last d values from original y - undiff = list(self._series[-d:]) - for i in range(h): - # Take the last d values and sum them - reconstructed = y_forecast_diff[i] + sum(undiff[-d:]) - undiff.append(reconstructed) - return np.array(undiff[d:]) + return _undifference(np.array([y_forecast_diff]), self._series[-self.d :]) @njit(cache=True, fastmath=True) From 5042fff0550bbcf0f4d316f2e9a39996df2cd3b7 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Thu, 31 Jul 2025 18:54:29 +0100 Subject: [PATCH 64/76] Add as maintainer --- aeon/transformations/series/_diff.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/aeon/transformations/series/_diff.py b/aeon/transformations/series/_diff.py index 1fd2249986..b53cd12143 100644 --- a/aeon/transformations/series/_diff.py +++ b/aeon/transformations/series/_diff.py @@ -5,7 +5,7 @@ from aeon.transformations.series.base import BaseSeriesTransformer -__maintainer__ = ["TinaJin0228"] +__maintainer__ = ["TinaJin0228", "Alex Banwell"] __all__ = ["DifferenceTransformer"] From d98cc99692acc6e358f68f6893d2d4fa4db835a4 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Thu, 31 Jul 2025 19:08:45 +0100 Subject: [PATCH 65/76] Revert unwanted changes from other PR --- aeon/forecasting/utils/_hypo_tests.py | 94 ----------------------- aeon/forecasting/utils/_seasonality.py | 101 ------------------------- docs/api_reference/forecasting.rst | 1 + 3 files changed, 1 insertion(+), 195 deletions(-) delete mode 100644 aeon/forecasting/utils/_hypo_tests.py delete mode 100644 aeon/forecasting/utils/_seasonality.py diff --git a/aeon/forecasting/utils/_hypo_tests.py b/aeon/forecasting/utils/_hypo_tests.py deleted file mode 100644 index 198a4472a8..0000000000 --- a/aeon/forecasting/utils/_hypo_tests.py +++ /dev/null @@ -1,94 +0,0 @@ -import numpy as np - - -def kpss_test(y, regression="c", lags=None): # Test if time series is stationary - """ - Perform the KPSS (Kwiatkowski-Phillips-Schmidt-Shin) test for stationarity. - - The KPSS test evaluates the null hypothesis that a time series is - (trend or level) stationary against the alternative of a unit root - (non-stationarity). It can test for either stationarity around a - constant (level stationarity) or arounda deterministic trend - (trend stationarity). - - Parameters - ---------- - y : array-like - Time series data to test for stationarity. - regression : str, default="c" - Indicates the null hypothesis for stationarity: - - "c" : Stationary around a constant (level stationarity) - - "ct" : Stationary around a constant and linear trend (trend stationarity) - lags : int or None, optional - Number of lags to use for the - HAC (heteroskedasticity and autocorrelation consistent) variance estimator. - If None, defaults to sqrt(n), where n is the sample size. - - Returns - ------- - kpss_stat : float - The KPSS test statistic. - stationary : bool - True if the series is judged stationary at the 5% significance level - (i.e., test statistic is below the critical value); False otherwise. - - Notes - ----- - - Uses asymptotic 5% critical values from Kwiatkowski et al. (1992): 0.463 for level - stationarity, 0.146 for trend stationarity. - - Returns True for stationary if the test statistic is below the 5% critical value. - - References - ---------- - Kwiatkowski, D., Phillips, P.C.B., Schmidt, P., & Shin, Y. (1992). - "Testing the null hypothesis of stationarity against the alternative - of a unit root." - Journal of Econometrics, 54(1–3), 159–178. - https://doi.org/10.1016/0304-4076(92)90104-Y - """ - y = np.asarray(y) - n = len(y) - - # Step 1: Fit regression model to estimate residuals - if regression == "c": # Constant - X = np.ones((n, 1)) - elif regression == "ct": # Constant + Trend - X = np.column_stack((np.ones(n), np.arange(1, n + 1))) - else: - raise ValueError("regression must be 'c' or 'ct'") - - beta = np.linalg.lstsq(X, y, rcond=None)[0] # Estimate regression coefficients - residuals = y - X @ beta # Get residuals (u_t) - - # Step 2: Compute cumulative sum of residuals (S_t) - S_t = np.cumsum(residuals) - - # Step 3: Estimate long-run variance (HAC variance) - if lags is None: - # lags = int(12 * (n / 100)**(1/4)) # Default statsmodels lag length - lags = int(np.sqrt(n)) # Default lag length - - gamma_0 = np.sum(residuals**2) / (n - X.shape[1]) # Lag-0 autocovariance - gamma = [np.sum(residuals[k:] * residuals[:-k]) / n for k in range(1, lags + 1)] - - # Bartlett weights - weights = [1 - (k / (lags + 1)) for k in range(1, lags + 1)] - - # Long-run variance - sigma_squared = gamma_0 + 2 * np.sum([w * g for w, g in zip(weights, gamma)]) - - # Step 4: Calculate the KPSS statistic - kpss_stat = np.sum(S_t**2) / (n**2 * sigma_squared) - - # 5% critical values for KPSS test - if regression == "ct": - # p. 162 Kwiatkowski et al. (1992): y_t = beta * t + r_t + e_t, - # where beta is the trend, r_t a random walk and e_t a stationary - # error term. - crit = 0.146 - else: # hypo == "c" - # special case of the model above, where beta = 0 (so the null - # hypothesis is that the data is stationary around r_0). - crit = 0.463 - - return kpss_stat, kpss_stat < crit diff --git a/aeon/forecasting/utils/_seasonality.py b/aeon/forecasting/utils/_seasonality.py deleted file mode 100644 index 356b1a40d2..0000000000 --- a/aeon/forecasting/utils/_seasonality.py +++ /dev/null @@ -1,101 +0,0 @@ -"""Seasonality Tools. - -Includes autocorrelation function (ACF) and seasonal period estimation. -""" - -import numpy as np -from numba import njit - - -@njit(cache=True, fastmath=True) -def acf(X, max_lag): - """ - Compute the sample autocorrelation function (ACF) of a time series. - - Up to a specified maximum lag. - - The autocorrelation at lag k is defined as the Pearson correlation - coefficient between the series and a lagged version of itself. - If both segments at a given lag have zero variance, the function - returns 1 for that lag. If only one segment has zero variance, - the function returns 0. - - Parameters - ---------- - X : array-like, shape (n_samples,) - The input time series data. - max_lag : int - The maximum lag (number of steps) for which to - compute the autocorrelation. - - Returns - ------- - acf_values : np.ndarray, shape (max_lag,) - The autocorrelation values for lags 1 through `max_lag`. - - Notes - ----- - The function handles cases where the lagged segments have zero - variance to avoid division by zero. - The returned values correspond to - lags 1, 2, ..., `max_lag` (not including lag 0). - """ - length = len(X) - X_t = np.zeros(max_lag, dtype=float) - for lag in range(1, max_lag + 1): - lag_length = length - lag - x1 = X[:-lag] - x2 = X[lag:] - s1 = np.sum(x1) - s2 = np.sum(x2) - m1 = s1 / lag_length - m2 = s2 / lag_length - ss1 = np.sum(x1 * x1) - ss2 = np.sum(x2 * x2) - v1 = ss1 - s1 * m1 - v2 = ss2 - s2 * m2 - v1_is_zero, v2_is_zero = v1 <= 1e-9, v2 <= 1e-9 - if v1_is_zero and v2_is_zero: # Both zero variance, - # so must be 100% correlated - X_t[lag - 1] = 1 - elif v1_is_zero or v2_is_zero: # One zero variance - # the other not - X_t[lag - 1] = 0 - else: - X_t[lag - 1] = np.sum((x1 - m1) * (x2 - m2)) / np.sqrt(v1 * v2) - return X_t - - -@njit(cache=True, fastmath=True) -def calc_seasonal_period(data): - """ - Estimate the seasonal period of a time series using autocorrelation analysis. - - This function computes the autocorrelation function (ACF) of - the input series up to lag 24. It then identifies peaks in the - ACF above the mean value, treating the first such peak - as the estimated seasonal period. If no peak is found, - a period of 1 is returned. - - Parameters - ---------- - data : array-like, shape (n_samples,) - The input time series data. - - Returns - ------- - period : int - The estimated seasonal period (lag) of the series. Returns 1 if no significant - peak is detected in the autocorrelation. - """ - lags = acf(data, 24) - lags = np.concatenate((np.array([1.0]), lags)) - peaks = [] - mean_lags = np.mean(lags) - for i in range(1, len(lags) - 1): # Skip the first (lag 0) and last elements - if lags[i] >= lags[i - 1] and lags[i] >= lags[i + 1] and lags[i] > mean_lags: - peaks.append(i) - if not peaks: - return 1 - else: - return peaks[0] diff --git a/docs/api_reference/forecasting.rst b/docs/api_reference/forecasting.rst index 35df6c8871..e725e808b8 100644 --- a/docs/api_reference/forecasting.rst +++ b/docs/api_reference/forecasting.rst @@ -5,6 +5,7 @@ Forecasting The :mod:`aeon.forecasting` module contains algorithms for forecasting. + All forecasters in ``aeon`` can be listed using the ``aeon.utils.discovery .all_estimators`` function using ``type_filter="forecaster"``, optionally filtered by tags. Valid tags for forecasters can be found with ``aeon.utils.tags From 1c7f0d8f077cd368fa51cadd138dfa766478c80d Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Thu, 31 Jul 2025 19:09:41 +0100 Subject: [PATCH 66/76] #2 --- docs/api_reference/forecasting.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/api_reference/forecasting.rst b/docs/api_reference/forecasting.rst index e725e808b8..d964507a17 100644 --- a/docs/api_reference/forecasting.rst +++ b/docs/api_reference/forecasting.rst @@ -5,12 +5,12 @@ Forecasting The :mod:`aeon.forecasting` module contains algorithms for forecasting. - All forecasters in ``aeon`` can be listed using the ``aeon.utils.discovery .all_estimators`` function using ``type_filter="forecaster"``, optionally filtered by tags. Valid tags for forecasters can be found with ``aeon.utils.tags .all_tags_for_estimator`` function with the argument ``"forecaster"``. + Forecasting Models ------------------ From 653f0f656079fb99ae03a1aead5ef544150eb0e4 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Fri, 1 Aug 2025 16:04:52 +0100 Subject: [PATCH 67/76] Temporarily exclude check_transform_inverse_transform_equivalent from testing for DifferenceTransformer. This is tested in test_diff.py anyway, and it currently doesn't pass in the initial values to y required to undifference a series --- aeon/testing/testing_config.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/aeon/testing/testing_config.py b/aeon/testing/testing_config.py index d199fbf59b..047491e7c6 100644 --- a/aeon/testing/testing_config.py +++ b/aeon/testing/testing_config.py @@ -62,6 +62,9 @@ # Unknown issue not producing the same results "RDSTRegressor": ["check_regressor_against_expected_results"], "RISTRegressor": ["check_regressor_against_expected_results"], + # Requires y to be passed in invers_transform, + # but this is not currently enabled/supported + "DifferenceTransformer": ["check_transform_inverse_transform_equivalent"], } # Exclude specific tests for estimators here only when numba is disabled From bbb2ef3e4275badb6aed03094573a826534f08a1 Mon Sep 17 00:00:00 2001 From: alexbanwell1 <31886108+alexbanwell1@users.noreply.github.com> Date: Fri, 1 Aug 2025 16:14:34 +0100 Subject: [PATCH 68/76] Convert to github name --- aeon/transformations/series/_diff.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/aeon/transformations/series/_diff.py b/aeon/transformations/series/_diff.py index b53cd12143..8d496ffedf 100644 --- a/aeon/transformations/series/_diff.py +++ b/aeon/transformations/series/_diff.py @@ -5,7 +5,7 @@ from aeon.transformations.series.base import BaseSeriesTransformer -__maintainer__ = ["TinaJin0228", "Alex Banwell"] +__maintainer__ = ["TinaJin0228", "alexbanwell1"] __all__ = ["DifferenceTransformer"] From 0a092cd68c696e8b7e3410fea290a15170eb3a1c Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Mon, 4 Aug 2025 18:11:27 +0100 Subject: [PATCH 69/76] Move undifferencing function to forecasting utils --- aeon/forecasting/stats/_arima.py | 2 +- aeon/forecasting/utils/_undifference.py | 64 +++++++++++++++++ aeon/transformations/series/_diff.py | 95 ------------------------- 3 files changed, 65 insertions(+), 96 deletions(-) create mode 100644 aeon/forecasting/utils/_undifference.py diff --git a/aeon/forecasting/stats/_arima.py b/aeon/forecasting/stats/_arima.py index c8e70e311b..ea6617f78d 100644 --- a/aeon/forecasting/stats/_arima.py +++ b/aeon/forecasting/stats/_arima.py @@ -12,7 +12,7 @@ from aeon.forecasting.base import BaseForecaster from aeon.forecasting.utils._extract_paras import _extract_arma_params from aeon.forecasting.utils._nelder_mead import nelder_mead -from aeon.transformations.series._diff import _undifference +from aeon.forecasting.utils._undifference import _undifference class ARIMA(BaseForecaster): diff --git a/aeon/forecasting/utils/_undifference.py b/aeon/forecasting/utils/_undifference.py new file mode 100644 index 0000000000..289098255e --- /dev/null +++ b/aeon/forecasting/utils/_undifference.py @@ -0,0 +1,64 @@ +"""Undifferencing Code.""" + +import numpy as np +from numba import njit + +# Needs to be move to DifferenceTransformer at some point + + +@njit(cache=True, fastmath=True) +def _comb(n, k): + """ + Calculate the binomial coefficient C(n, k) = n! / (k! * (n - k)!). + + Parameters + ---------- + n : int + The total number of items. + k : int + The number of items to choose. + + Returns + ------- + int + The binomial coefficient C(n, k). + """ + if k < 0 or k > n: + return 0 + if k > n - k: + k = n - k # Take advantage of symmetry + c = 1 + for i in range(k): + c = c * (n - i) // (i + 1) + return c + + +@njit(cache=True, fastmath=True) +def _undifference(diff, initial_values): + """ + Reconstruct original time series from an n-th order differenced series. + + Parameters + ---------- + diff : array-like + n-th order differenced series of length N - n + initial_values : array-like + The first n values of the original series before differencing (length n) + + Returns + ------- + original : np.ndarray + Reconstructed original series of length N + """ + n = len(initial_values) + kernel = np.array( + [(-1) ** (k + 1) * _comb(n, k) for k in range(1, n + 1)], + dtype=initial_values.dtype, + ) + original = np.empty((n + len(diff)), dtype=initial_values.dtype) + original[:n] = initial_values + + for i, d in enumerate(diff): + original[n + i] = np.dot(kernel, original[i : n + i][::-1]) + d + + return original diff --git a/aeon/transformations/series/_diff.py b/aeon/transformations/series/_diff.py index 8d496ffedf..767927041a 100644 --- a/aeon/transformations/series/_diff.py +++ b/aeon/transformations/series/_diff.py @@ -1,7 +1,6 @@ """Difference Transformer.""" import numpy as np -from numba import njit from aeon.transformations.series.base import BaseSeriesTransformer @@ -62,7 +61,6 @@ class DifferenceTransformer(BaseSeriesTransformer): _tags = { "capability:multivariate": True, - "capability:inverse_transform": True, "X_inner_type": "np.ndarray", "fit_is_empty": True, } @@ -94,96 +92,3 @@ def _transform(self, X, y=None): Xt = diff_X return Xt - - def _inverse_transform(self, X, y=None): - """ - Inverse transform to reconstruct the original time series. - - Parameters - ---------- - X : Time series to inverse transform. With shape (n_channels, n_timepoints). - y : ignored argument for interface compatibility - - Returns - ------- - Xt : np.ndarray - Reconstructed original time series. - """ - if y is None or y.shape[1] < self.order: - raise ValueError( - f"Inverse transformm requires first {self.order} original \ - data values supplied as y, but inverse_transform called with y=None" - ) - if y.shape[0] != X.shape[0]: - raise ValueError( - f"y must have the same number of channels as X. " - f"Got X.shape[0]={X.shape[0]}, y.shape[0]={y.shape[0]}" - ) - X = np.array(X, dtype=np.float64) - y = np.array(y, dtype=np.float64) - initial_values = y[:, : self.order] - - return np.array( - [ - _undifference(diff_X, initial_value) - for diff_X, initial_value in zip(X, initial_values) - ] - ) - - -@njit(cache=True, fastmath=True) -def _comb(n, k): - """ - Calculate the binomial coefficient C(n, k) = n! / (k! * (n - k)!). - - Parameters - ---------- - n : int - The total number of items. - k : int - The number of items to choose. - - Returns - ------- - int - The binomial coefficient C(n, k). - """ - if k < 0 or k > n: - return 0 - if k > n - k: - k = n - k # Take advantage of symmetry - c = 1 - for i in range(k): - c = c * (n - i) // (i + 1) - return c - - -@njit(cache=True, fastmath=True) -def _undifference(diff, initial_values): - """ - Reconstruct original time series from an n-th order differenced series. - - Parameters - ---------- - diff : array-like - n-th order differenced series of length N - n - initial_values : array-like - The first n values of the original series before differencing (length n) - - Returns - ------- - original : np.ndarray - Reconstructed original series of length N - """ - n = len(initial_values) - kernel = np.array( - [(-1) ** (k + 1) * _comb(n, k) for k in range(1, n + 1)], - dtype=initial_values.dtype, - ) - original = np.empty((n + len(diff)), dtype=initial_values.dtype) - original[:n] = initial_values - - for i, d in enumerate(diff): - original[n + i] = np.dot(kernel, original[i : n + i][::-1]) + d - - return original From 6827358090edc42033ace69c0bcf255af76935c4 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Mon, 4 Aug 2025 18:51:29 +0100 Subject: [PATCH 70/76] Correct undifferencing function call --- aeon/forecasting/stats/_arima.py | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/aeon/forecasting/stats/_arima.py b/aeon/forecasting/stats/_arima.py index ea6617f78d..71c86c3bea 100644 --- a/aeon/forecasting/stats/_arima.py +++ b/aeon/forecasting/stats/_arima.py @@ -126,9 +126,12 @@ def _fit(self, y, exog=None): # parameters differenced_forecast = self.fitted_values_[-1] - self.forecast_ = _undifference( - np.array([differenced_forecast]), self._series[-self.d :] - )[0] + if self.d == 0: + self.forecast_ = differenced_forecast + else: + self.forecast_ = _undifference( + np.array([differenced_forecast]), self._series[-self.d :] + )[self.d] if self.use_constant: self.c_ = formatted_params[0][0] self.phi_ = formatted_params[1][: self.p] @@ -189,7 +192,12 @@ def _predict(self, y, exog=None): forecast_diff = c + ar_forecast + ma_forecast # Undifference the forecast - return _undifference(np.array([forecast_diff]), self._series[-self.d :])[0] + if self.d == 0: + return forecast_diff + else: + return _undifference(np.array([forecast_diff]), self._series[-self.d :])[ + self.d + ] def _forecast(self, y, exog=None): """Forecast one ahead for time series y.""" @@ -228,7 +236,10 @@ def iterative_forecast(self, y, prediction_horizon): # Correct differencing using forecast values y_forecast_diff = forecast_series[n : n + h] - return _undifference(np.array([y_forecast_diff]), self._series[-self.d :]) + if self.d == 0: + return y_forecast_diff + else: + return _undifference(y_forecast_diff, self._series[-self.d :])[self.d :] @njit(cache=True, fastmath=True) From ab563a5fc89f40c145a010f056cca79fabf4e171 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Mon, 4 Aug 2025 19:03:08 +0100 Subject: [PATCH 71/76] Convert DifferenceTransformer to store X values in .transform and use them in inverse_transform if no y provided --- aeon/transformations/series/_diff.py | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/aeon/transformations/series/_diff.py b/aeon/transformations/series/_diff.py index 8d496ffedf..6519a1a960 100644 --- a/aeon/transformations/series/_diff.py +++ b/aeon/transformations/series/_diff.py @@ -70,6 +70,7 @@ class DifferenceTransformer(BaseSeriesTransformer): def __init__(self, order=1): self.order = order super().__init__(axis=1) + self.x_ = None def _transform(self, X, y=None): """ @@ -88,6 +89,7 @@ def _transform(self, X, y=None): raise ValueError( f"`order` must be a positive integer, but got {self.order}" ) + self.x_ = X diff_X = np.diff(X, n=self.order, axis=1) @@ -102,17 +104,24 @@ def _inverse_transform(self, X, y=None): Parameters ---------- X : Time series to inverse transform. With shape (n_channels, n_timepoints). - y : ignored argument for interface compatibility + y : If provided, should contain the first `order` values of the original series. + If None, the first `order` values will be taken from values + stored in _transform. Returns ------- Xt : np.ndarray Reconstructed original time series. """ + if y is None: + y = self.x_ if y is None or y.shape[1] < self.order: raise ValueError( - f"Inverse transformm requires first {self.order} original \ - data values supplied as y, but inverse_transform called with y=None" + f"Inverse transform requires first {self.order} original \ + data values. If y is supplied, then those values will be used. \ + If not if .transform() has been called, the X series from that \ + shall be used. But inverse_transform called with y=None and \ + no previous .transform() call." ) if y.shape[0] != X.shape[0]: raise ValueError( From 0e58877dc34c0f7f6d433e4b934325d48f09b24a Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Mon, 4 Aug 2025 19:10:38 +0100 Subject: [PATCH 72/76] Use new _undifference version --- aeon/forecasting/stats/_arima.py | 2 +- aeon/forecasting/utils/_undifference.py | 64 ------------------------- 2 files changed, 1 insertion(+), 65 deletions(-) delete mode 100644 aeon/forecasting/utils/_undifference.py diff --git a/aeon/forecasting/stats/_arima.py b/aeon/forecasting/stats/_arima.py index 71c86c3bea..c7bf349865 100644 --- a/aeon/forecasting/stats/_arima.py +++ b/aeon/forecasting/stats/_arima.py @@ -12,7 +12,7 @@ from aeon.forecasting.base import BaseForecaster from aeon.forecasting.utils._extract_paras import _extract_arma_params from aeon.forecasting.utils._nelder_mead import nelder_mead -from aeon.forecasting.utils._undifference import _undifference +from aeon.transformations.series._diff import _undifference class ARIMA(BaseForecaster): diff --git a/aeon/forecasting/utils/_undifference.py b/aeon/forecasting/utils/_undifference.py deleted file mode 100644 index 289098255e..0000000000 --- a/aeon/forecasting/utils/_undifference.py +++ /dev/null @@ -1,64 +0,0 @@ -"""Undifferencing Code.""" - -import numpy as np -from numba import njit - -# Needs to be move to DifferenceTransformer at some point - - -@njit(cache=True, fastmath=True) -def _comb(n, k): - """ - Calculate the binomial coefficient C(n, k) = n! / (k! * (n - k)!). - - Parameters - ---------- - n : int - The total number of items. - k : int - The number of items to choose. - - Returns - ------- - int - The binomial coefficient C(n, k). - """ - if k < 0 or k > n: - return 0 - if k > n - k: - k = n - k # Take advantage of symmetry - c = 1 - for i in range(k): - c = c * (n - i) // (i + 1) - return c - - -@njit(cache=True, fastmath=True) -def _undifference(diff, initial_values): - """ - Reconstruct original time series from an n-th order differenced series. - - Parameters - ---------- - diff : array-like - n-th order differenced series of length N - n - initial_values : array-like - The first n values of the original series before differencing (length n) - - Returns - ------- - original : np.ndarray - Reconstructed original series of length N - """ - n = len(initial_values) - kernel = np.array( - [(-1) ** (k + 1) * _comb(n, k) for k in range(1, n + 1)], - dtype=initial_values.dtype, - ) - original = np.empty((n + len(diff)), dtype=initial_values.dtype) - original[:n] = initial_values - - for i, d in enumerate(diff): - original[n + i] = np.dot(kernel, original[i : n + i][::-1]) + d - - return original From e7dbfce5968829ad373e389a92ba8d7af261f72e Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Mon, 4 Aug 2025 19:13:12 +0100 Subject: [PATCH 73/76] Comment out inverse_transform tests --- .../transformations/series/tests/test_diff.py | 30 +++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/aeon/transformations/series/tests/test_diff.py b/aeon/transformations/series/tests/test_diff.py index 5ac4b39be9..3d53871eb5 100644 --- a/aeon/transformations/series/tests/test_diff.py +++ b/aeon/transformations/series/tests/test_diff.py @@ -12,41 +12,41 @@ def test_diff(): dt1 = DifferenceTransformer(order=1) Xt1 = dt1.fit_transform(X) expected1 = np.array([[3.0, 5.0, 7.0, 9.0, 11.0]]) - X_hat1 = dt1.inverse_transform(Xt1, X) + # X_hat1 = dt1.inverse_transform(Xt1, X) np.testing.assert_allclose( Xt1, expected1, equal_nan=True, err_msg="Value mismatch for order 1" ) - np.testing.assert_allclose( - X_hat1, X, equal_nan=True, err_msg="Inverse transform failed for order 1" - ) + # np.testing.assert_allclose( + # X_hat1, X, equal_nan=True, err_msg="Inverse transform failed for order 1" + # ) dt2 = DifferenceTransformer(order=2) Xt2 = dt2.fit_transform(X) expected2 = np.array([[2.0, 2.0, 2.0, 2.0]]) - X_hat2 = dt2.inverse_transform(Xt2, X) + # X_hat2 = dt2.inverse_transform(Xt2, X) np.testing.assert_allclose( Xt2, expected2, equal_nan=True, err_msg="Value mismatch for order 2" ) - np.testing.assert_allclose( - X_hat2, X, equal_nan=True, err_msg="Inverse transform failed for order 2" - ) + # np.testing.assert_allclose( + # X_hat2, X, equal_nan=True, err_msg="Inverse transform failed for order 2" + # ) Y = np.array([[1, 2, 3, 4], [5, 3, 1, 8]]) Yt1 = dt1.fit_transform(Y) expected3 = np.array([[1, 1, 1], [-2, -2, 7]]) - Y_hat1 = dt1.inverse_transform(Yt1, Y) + # Y_hat1 = dt1.inverse_transform(Yt1, Y) np.testing.assert_allclose( Yt1, expected3, equal_nan=True, err_msg="Value mismatch for order 1,multivariate", ) - np.testing.assert_allclose( - Y_hat1, - Y, - equal_nan=True, - err_msg="Inverse transform failed for order 1,multivariate", - ) + # np.testing.assert_allclose( + # Y_hat1, + # Y, + # equal_nan=True, + # err_msg="Inverse transform failed for order 1,multivariate", + # ) From 5dade4011916ad8675ea2660a1d30161d6e9cd9d Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Mon, 4 Aug 2025 19:14:28 +0100 Subject: [PATCH 74/76] Add back in inverse_transform_tests --- .../transformations/series/tests/test_diff.py | 30 +++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/aeon/transformations/series/tests/test_diff.py b/aeon/transformations/series/tests/test_diff.py index 3d53871eb5..5ac4b39be9 100644 --- a/aeon/transformations/series/tests/test_diff.py +++ b/aeon/transformations/series/tests/test_diff.py @@ -12,41 +12,41 @@ def test_diff(): dt1 = DifferenceTransformer(order=1) Xt1 = dt1.fit_transform(X) expected1 = np.array([[3.0, 5.0, 7.0, 9.0, 11.0]]) - # X_hat1 = dt1.inverse_transform(Xt1, X) + X_hat1 = dt1.inverse_transform(Xt1, X) np.testing.assert_allclose( Xt1, expected1, equal_nan=True, err_msg="Value mismatch for order 1" ) - # np.testing.assert_allclose( - # X_hat1, X, equal_nan=True, err_msg="Inverse transform failed for order 1" - # ) + np.testing.assert_allclose( + X_hat1, X, equal_nan=True, err_msg="Inverse transform failed for order 1" + ) dt2 = DifferenceTransformer(order=2) Xt2 = dt2.fit_transform(X) expected2 = np.array([[2.0, 2.0, 2.0, 2.0]]) - # X_hat2 = dt2.inverse_transform(Xt2, X) + X_hat2 = dt2.inverse_transform(Xt2, X) np.testing.assert_allclose( Xt2, expected2, equal_nan=True, err_msg="Value mismatch for order 2" ) - # np.testing.assert_allclose( - # X_hat2, X, equal_nan=True, err_msg="Inverse transform failed for order 2" - # ) + np.testing.assert_allclose( + X_hat2, X, equal_nan=True, err_msg="Inverse transform failed for order 2" + ) Y = np.array([[1, 2, 3, 4], [5, 3, 1, 8]]) Yt1 = dt1.fit_transform(Y) expected3 = np.array([[1, 1, 1], [-2, -2, 7]]) - # Y_hat1 = dt1.inverse_transform(Yt1, Y) + Y_hat1 = dt1.inverse_transform(Yt1, Y) np.testing.assert_allclose( Yt1, expected3, equal_nan=True, err_msg="Value mismatch for order 1,multivariate", ) - # np.testing.assert_allclose( - # Y_hat1, - # Y, - # equal_nan=True, - # err_msg="Inverse transform failed for order 1,multivariate", - # ) + np.testing.assert_allclose( + Y_hat1, + Y, + equal_nan=True, + err_msg="Inverse transform failed for order 1,multivariate", + ) From cc302e1c18dfc84efbe0980d6ab99b546ccd3405 Mon Sep 17 00:00:00 2001 From: Alex Banwell Date: Mon, 4 Aug 2025 19:43:39 +0100 Subject: [PATCH 75/76] Remove DifferenceTransformer from the exclusion list --- aeon/testing/testing_config.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/aeon/testing/testing_config.py b/aeon/testing/testing_config.py index 047491e7c6..d199fbf59b 100644 --- a/aeon/testing/testing_config.py +++ b/aeon/testing/testing_config.py @@ -62,9 +62,6 @@ # Unknown issue not producing the same results "RDSTRegressor": ["check_regressor_against_expected_results"], "RISTRegressor": ["check_regressor_against_expected_results"], - # Requires y to be passed in invers_transform, - # but this is not currently enabled/supported - "DifferenceTransformer": ["check_transform_inverse_transform_equivalent"], } # Exclude specific tests for estimators here only when numba is disabled From ffee4c4978512ed31c3ca2966c275d5323aa9aa4 Mon Sep 17 00:00:00 2001 From: alexbanwell1 <31886108+alexbanwell1@users.noreply.github.com> Date: Mon, 4 Aug 2025 19:55:46 +0100 Subject: [PATCH 76/76] Remove Commented out tests --- aeon/transformations/series/tests/test_diff.py | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/aeon/transformations/series/tests/test_diff.py b/aeon/transformations/series/tests/test_diff.py index 3d53871eb5..9f54fccf7d 100644 --- a/aeon/transformations/series/tests/test_diff.py +++ b/aeon/transformations/series/tests/test_diff.py @@ -12,41 +12,26 @@ def test_diff(): dt1 = DifferenceTransformer(order=1) Xt1 = dt1.fit_transform(X) expected1 = np.array([[3.0, 5.0, 7.0, 9.0, 11.0]]) - # X_hat1 = dt1.inverse_transform(Xt1, X) np.testing.assert_allclose( Xt1, expected1, equal_nan=True, err_msg="Value mismatch for order 1" ) - # np.testing.assert_allclose( - # X_hat1, X, equal_nan=True, err_msg="Inverse transform failed for order 1" - # ) dt2 = DifferenceTransformer(order=2) Xt2 = dt2.fit_transform(X) expected2 = np.array([[2.0, 2.0, 2.0, 2.0]]) - # X_hat2 = dt2.inverse_transform(Xt2, X) np.testing.assert_allclose( Xt2, expected2, equal_nan=True, err_msg="Value mismatch for order 2" ) - # np.testing.assert_allclose( - # X_hat2, X, equal_nan=True, err_msg="Inverse transform failed for order 2" - # ) Y = np.array([[1, 2, 3, 4], [5, 3, 1, 8]]) Yt1 = dt1.fit_transform(Y) expected3 = np.array([[1, 1, 1], [-2, -2, 7]]) - # Y_hat1 = dt1.inverse_transform(Yt1, Y) np.testing.assert_allclose( Yt1, expected3, equal_nan=True, err_msg="Value mismatch for order 1,multivariate", ) - # np.testing.assert_allclose( - # Y_hat1, - # Y, - # equal_nan=True, - # err_msg="Inverse transform failed for order 1,multivariate", - # )