0.1.0 (#5)

* steamy Rotorua

Expanding capabilities of Sklearn Rolling model

* pestilence

* stumped on tsfresh and wading through statsmodels

* regressor bugs squished, for now

* GLM, sorta maybe

* GLM touchup

* Abel Tasman

* Sklearn expanded

and parameters to VARMAX

* 0.1.0 on stormy seas

Author: winedarksea

README.md

@@ -1,7 +1,7 @@
 # AutoTS
 
-### Project CATS (Catlin Automated Time Series)
-(or maybe eventually: Clustered Automated Time Series)
+### Project CATS
+
 #### Model Selection for Multiple Time Series
 
 Simple package for comparing and predicting with open-source time series implementations.
@@ -26,7 +26,7 @@ from autots.datasets import load_toy_monthly # also: _daily _yearly or _hourly
 df_long = load_toy_monthly()
 
 from autots import AutoTS
-model = AutoTS(forecast_length = 14, frequency = 'infer',
+model = AutoTS(forecast_length = 3, frequency = 'infer',
                prediction_interval = 0.9, ensemble = True, weighted = False,
                max_generations = 5, num_validations = 2, validation_method = 'even')
 model = model.fit(df_long, date_col = 'datetime', value_col = 'value', id_col = 'series_id')
@@ -68,6 +68,7 @@ AutoTS works in the following way at present:
 #### Requirements
 	fbprophet
 	fredapi (example datasets)
+	tsfresh
 
 Check out `functional_environments.md` for specific versions tested to work.
 

TODO.md

@@ -1,18 +1,21 @@
 # To-Do
+Single time series
+Better point to probabilistic (uncertainty of naive last-value forecast) - linear reg of abs error of samples
+Better X_maker for Rolling Sklearn
+Sklearn Holiday not working
+Possible error where first template model is invalid, 'smape_weighted' doesn't exist error
 * Recombine best two of each model parameters, if two or more present
 * Inf appearing in MAE and RMSE (possibly all NaN in test)
 * Na Tolerance for test in simple_train_test_split
 * min_allowed_train_percent into higher-level API
-* annual data with different dates of the record 6/30, 1/1, 12/30
 * Relative/Absolute Imports and reduce package reloading
-* User regressor to sklearn model regression_type
+* User regressor to sklearn model regression_type (added, needs testing)
 * Weekly sample data
 * Format of Regressor - allow multiple input to at least sklearn models
 * 'Age' regressor as an option in addition to User/Holiday
-* Handle categorical forecasts where forecast leaves range of known values
-* Detrend transformer doesn't work on some indexes
+* Handle categorical forecasts where forecast leaves range of known values, then add to upper/lower forecasts
 * Speed improvements, Profiling, Parallelization, and Distributed options for general greater speed
-* Generate list of functional frequences, and improve usability on rarer frequenices
+* Improve usability on rarer frequenices
 * Warning/handling if lots of NaN in most recent (test) part of data
 * Figures: Add option to output figures of train/test + forecast, other performance figures
 * Pre-clustering on many time series
@@ -21,6 +24,7 @@
 * Hierachial correction (bottom-up to start with)
 * Improved verbosity controls and options. Replace most 'print' with logging.
 * Export as simpler code (as TPOT)
+* set up the lower-level API to be usable as pipelines
 * AIC metric, other accuracy metrics
 * Analyze and return inaccuracy patterns (most inaccurate periods out, days of week, most inaccurate series)
 * Used saved results to resume a search partway through
@@ -31,6 +35,12 @@
 * More thorough use of setting random seed
 * For monthly data account for number of days in month
 * Option to run generations until generations no longer see improvement of at least X % over n generations
+* add constant to GLM
+
+### Faster Convergence
+* Only search useful parameters, highest probability for most likely effective parameters
+* 'Expert' starting template to try most likley combinations first
+* Recombination of parameters (both transformation and model)
 
 #### New Ensembles:
 	best 3 (unique algorithms not just variations)
@@ -42,13 +52,14 @@
 	Last Value + Drift Naive
 	Simple Decomposition forecasting
 	GluonTS Models
+	Tensorflow Probability Structural Time Series
+	Pytorch Simple LSTM/GRU
 	Simulations
 	XGBoost (doesn't support multioutput directly)
 	Sklearn + TSFresh
-	Sklearn + polynomial features
 	Sktime
 	Ta-lib
 	tslearn
-	pydlm
+	pydlm - baysesian dynamic linear
 	Isotonic regression
 	TPOT if it adds multioutput functionality

autots/__init__.py

@@ -10,7 +10,7 @@
 
 from autots.evaluator.auto_ts import AutoTS
 
-__version__ = '0.0.4'
+__version__ = '0.1.0'
 
 
 __all__ = ['load_toy_daily','load_toy_monthly', 'load_toy_yearly', 'load_toy_hourly',

autots/evaluator/auto_model.py

@@ -163,9 +163,10 @@ def ModelPrediction(df_train, forecast_length: int, transformation_dict: dict,
 
     return df_forecast
 
-ModelNames = ['ZeroesNaive', 'LastValueNaive', 'MedValueNaive',
-              'GLM', 'ETS', 'ARIMA', 'FBProphet', 'RandomForestRolling']
-
+ModelNames = ['ZeroesNaive', 'LastValueNaive', 'MedValueNaive', 'GLS',
+              'GLM', 'ETS', 'ARIMA', 'FBProphet', 'RollingRegression',
+              'UnobservedComponents', 'VARMAX', 'VECM', 'DynamicFactor']
+# ModelNames = ['RollingRegression']
 def ModelMonster(model: str, parameters: dict = {}, frequency: str = 'infer', 
                  prediction_interval: float = 0.9, holiday_country: str = 'US', 
                  startTimeStamps = None,
@@ -188,9 +189,17 @@ def ModelMonster(model: str, parameters: dict = {}, frequency: str = 'infer',
         from autots.models.basics import MedValueNaive
         return MedValueNaive(frequency = frequency, prediction_interval = prediction_interval)
 
+    if model == 'GLS':
+        from autots.models.statsmodels import GLS
+        return GLS(frequency = frequency, prediction_interval = prediction_interval)
+    
     if model == 'GLM':
         from autots.models.statsmodels import GLM
-        return GLM(frequency = frequency, prediction_interval = prediction_interval)
+        if parameters == {}:
+            model = GLM(frequency = frequency, prediction_interval = prediction_interval, holiday_country = holiday_country, random_seed = random_seed, verbose = verbose)
+        else:
+            model = GLM(frequency = frequency, prediction_interval = prediction_interval, holiday_country = holiday_country, random_seed = random_seed, verbose = verbose, family = parameters['family'])
+        return model
 
     if model == 'ETS':
         from autots.models.statsmodels import ETS
@@ -216,15 +225,56 @@ def ModelMonster(model: str, parameters: dict = {}, frequency: str = 'infer',
             model = FBProphet(frequency = frequency, prediction_interval = prediction_interval, holiday_country = holiday_country, holiday =parameters['holiday'], regression_type=parameters['regression_type'], random_seed = random_seed, verbose = verbose)
         return model
 
-    if model == 'RandomForestRolling':
-        from autots.models.sklearn import RandomForestRolling
+    if model == 'RollingRegression':
+        from autots.models.sklearn import RollingRegression
+        if parameters == {}:
+            model = RollingRegression(frequency = frequency, prediction_interval = prediction_interval, holiday_country = holiday_country, random_seed = random_seed, verbose = verbose)
+        else:
+            model = RollingRegression(frequency = frequency, prediction_interval = prediction_interval, holiday_country = holiday_country, holiday =parameters['holiday'], regression_type=parameters['regression_type'], random_seed = random_seed, verbose = verbose,
+                 regression_model = parameters['regression_model'], mean_rolling_periods =parameters['mean_rolling_periods'], std_rolling_periods =parameters['std_rolling_periods'])
+        return model
+    
+    if model == 'UnobservedComponents':
+        from autots.models.statsmodels import UnobservedComponents
+        if parameters == {}:
+            model = UnobservedComponents(frequency = frequency, prediction_interval = prediction_interval, holiday_country = holiday_country, random_seed = random_seed, verbose = verbose)
+        else:
+            model = UnobservedComponents(frequency = frequency, prediction_interval = prediction_interval, holiday_country = holiday_country,
+                                         regression_type=parameters['regression_type'], random_seed = random_seed, verbose = verbose,
+                                         level = parameters['level'], trend=parameters['trend'], cycle = parameters['cycle'],
+                                         damped_cycle = parameters['damped_cycle'], irregular = parameters['irregular'],
+                                         stochastic_trend=parameters['stochastic_trend'], stochastic_level=parameters['stochastic_level'],
+                                         stochastic_cycle=parameters['stochastic_cycle'])
+        return model
+    
+    if model == 'DynamicFactor':
+        from autots.models.statsmodels import DynamicFactor
+        if parameters == {}:
+            model = DynamicFactor(frequency = frequency, prediction_interval = prediction_interval, holiday_country = holiday_country, random_seed = random_seed, verbose = verbose)
+        else:
+            model = DynamicFactor(frequency = frequency, prediction_interval = prediction_interval, holiday_country = holiday_country,
+                                         regression_type=parameters['regression_type'], random_seed = random_seed, verbose = verbose,
+                                         k_factors = parameters['k_factors'], factor_order = parameters['factor_order'])
+        return model
+    
+    if model == 'VECM':
+        from autots.models.statsmodels import VECM
         if parameters == {}:
-            model = RandomForestRolling(frequency = frequency, prediction_interval = prediction_interval, holiday_country = holiday_country, random_seed = random_seed, verbose = verbose)
+            model = VECM(frequency = frequency, prediction_interval = prediction_interval, holiday_country = holiday_country, random_seed = random_seed, verbose = verbose)
         else:
-            model = RandomForestRolling(frequency = frequency, prediction_interval = prediction_interval, holiday_country = holiday_country, holiday =parameters['holiday'], regression_type=parameters['regression_type'], random_seed = random_seed, verbose = verbose,
-                 n_estimators =parameters['n_estimators'], min_samples_split =parameters['min_samples_split'], max_depth =parameters['max_depth'], mean_rolling_periods =parameters['mean_rolling_periods'], std_rolling_periods =parameters['std_rolling_periods'])
+            model = VECM(frequency = frequency, prediction_interval = prediction_interval, holiday_country = holiday_country,
+                                         regression_type=parameters['regression_type'], random_seed = random_seed, verbose = verbose,
+                                         deterministic = parameters['deterministic'], k_ar_diff = parameters['k_ar_diff'])
         return model
 
+    if model == 'VARMAX':
+        from autots.models.statsmodels import VARMAX
+        if parameters == {}:
+            model = VARMAX(frequency = frequency, prediction_interval = prediction_interval, holiday_country = holiday_country, random_seed = random_seed, verbose = verbose)
+        else:
+            model = VARMAX(frequency = frequency, prediction_interval = prediction_interval, holiday_country = holiday_country, random_seed = random_seed, verbose = verbose, 
+                           order = parameters['order'], trend = parameters['trend'])
+        return model
 
     else:
         raise AttributeError("Model String not found in ModelMonster")

autots/models/ensemble.py

@@ -3,7 +3,7 @@
 import pandas as pd
 import json
 from autots.evaluator.auto_model import PredictionObject
-from autots.evaluator.auto_model import create_model_id    
+from autots.evaluator.auto_model import create_model_id
 
 
 def Best3Ensemble(ensemble_params, forecasts_list, forecasts, lower_forecasts, upper_forecasts, forecasts_runtime, prediction_interval):
@@ -123,7 +123,7 @@ def EnsembleEvaluate(ensemble_forecasts_list: list, df_test, weights, model_coun
                     'Runs': 1
                     }, index = [0])
             a = pd.DataFrame(model_error.avg_metrics_weighted.rename(lambda x: x + '_weighted')).transpose()
-            result = pd.concat([result, pd.DataFrame(model_error.avg_metrics).transpose(), a], axis = 1)
+            result = pd.concat([result, pd.DataFrame(model_error.avg_metrics).transpose(), a], axis = 1, sort = False)
 
             ens_eval.model_results = pd.concat([ens_eval.model_results, result], axis = 0, ignore_index = True, sort = False).reset_index(drop = True)
             temp = pd.DataFrame(model_error.per_timestamp_metrics.loc['smape']).transpose()