Spaces:
Sleeping
Sleeping
| import threading | |
| import numpy as np | |
| import pandas as pd | |
| from models.base_model import BaseForecastModel, causal_exogenous, validate_history_and_horizon | |
| from models.dependencies import fit_arima, import_arima, quiet_fit | |
| from features.feature_pipeline import validate_features | |
| class ArimaModel(BaseForecastModel): | |
| name = 'ARIMA' | |
| def __init__(self, max_p=3, max_d=2, max_q=3, order=None, refit_order_every=None): | |
| self.max_p = max_p | |
| self.max_d = max_d | |
| self.max_q = max_q | |
| self._cached_order = order | |
| self.refit_order_every = refit_order_every | |
| self._calls_since_search = 0 | |
| self._lock = threading.Lock() | |
| self.last_diagnostics = {} | |
| def _best_order(self, series: pd.Series, exog: pd.DataFrame=None): | |
| arima = import_arima(self.name) | |
| best_aic = np.inf | |
| best_order = None | |
| failures = [] | |
| # AIC values from different integration orders have different likelihood | |
| # bases. Select d on the training sample, then compare only p/q at that d. | |
| from models.auto_arima_model import AutoArimaModel | |
| selected_d = AutoArimaModel(max_d=self.max_d)._find_d(series) | |
| with quiet_fit(): | |
| candidates = [(p, d, q) | |
| for d in [selected_d] | |
| for p in range(self.max_p + 1) | |
| for q in range(self.max_q + 1) | |
| if p + q <= 2] | |
| for order in candidates: | |
| try: | |
| fit = fit_arima(arima(series, exog=exog, order=order)) | |
| except Exception as error: | |
| failures.append({'order': order, 'error': f'{type(error).__name__}: {error}'}) | |
| continue | |
| if fit.aic < best_aic: | |
| best_aic = fit.aic | |
| best_order = order | |
| if best_order is None: | |
| self.last_diagnostics = {'converged': False, 'candidate_errors': failures} | |
| raise ValueError(f'No ARIMA candidate converged on this training window: {failures}') | |
| return best_order | |
| def _fit_forecast(self, arima, series, order, horizon, exog, future_exog): | |
| """Execute the selected ARIMA order; a failed fit is a failed evaluation.""" | |
| with quiet_fit(): | |
| fit = fit_arima(arima(series, exog=exog, order=order)) | |
| forecast = fit.forecast(steps=horizon, exog=future_exog) if exog is not None else fit.forecast(steps=horizon) | |
| values = np.exp(np.asarray(forecast, dtype=float)) | |
| if values.shape != (horizon,) or not np.isfinite(values).all() or (values <= 0).any(): | |
| raise ValueError(f'{self.name} returned an invalid forecast for selected order {order}.') | |
| self.last_diagnostics = {'converged': True, 'selected_order': order, 'executed_order': order, | |
| 'order_fallback': False, 'feature_policy': 'lagged one candle; unknown future covariates persist'} | |
| return values | |
| def predict(self, history: pd.Series, horizon: int=1, features: pd.DataFrame=None) -> list: | |
| with self._lock: | |
| self.last_diagnostics = {} | |
| validate_history_and_horizon(history, horizon, self.name) | |
| series = pd.Series(history).astype(float).reset_index(drop=True) | |
| validate_history_and_horizon(series, horizon, self.name) | |
| if len(series) < 20: | |
| raise ValueError('ARIMA needs at least 20 candles of history.') | |
| arima = import_arima(self.name) | |
| exog = future_exog = None | |
| if features is not None: | |
| validate_features(features, expected_len=len(series), model_name='ARIMA') | |
| exog, future_exog = causal_exogenous(features, horizon, self.name) | |
| if exog is not None: | |
| series = series.iloc[1:].reset_index(drop=True) | |
| if (series <= 0).any(): | |
| raise ValueError('ARIMA needs strictly positive prices for its log-price model.') | |
| log_series = np.log(series) | |
| need_search = self._cached_order is None | |
| if self.refit_order_every and self._calls_since_search >= self.refit_order_every: | |
| need_search = True | |
| if need_search: | |
| self._cached_order = self._best_order(log_series, exog=exog) | |
| self._calls_since_search = 0 | |
| self._calls_since_search += 1 | |
| forecast = self._fit_forecast(arima, log_series, self._cached_order, horizon, exog, future_exog) | |
| return [float(x) for x in forecast] | |