autots 0.5.5__tar.gz

autots-0.5.5/AutoTS.egg-info/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.1
+Name: autots
+Version: 0.5.5
+Summary: Automated Time Series Forecasting
+Home-page: https://github.com/winedarksea/AutoTS
+Author: Colin Catlin
+Author-email: Colin Catlin <colin.catlin@gmail.com>
+License: MIT License
+Project-URL: Homepage, https://github.com/winedarksea/AutoTS
+Project-URL: Bug Tracker, https://github.com/winedarksea/AutoTS/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Provides-Extra: additional
+License-File: LICENSE
+
+# AutoTS
+
+<img src="/img/autots_1280.png" width="400" height="184" title="AutoTS Logo">
+
+AutoTS is a time series package for Python designed for rapidly deploying high-accuracy forecasts at scale. 
+
+In 2023, AutoTS has won the M6 forecasting competition, delivering the highest performance investment decisions across 12 months of stock market forecasting.
+
+There are dozens of forecasting models usable in the `sklearn` style of `.fit()` and `.predict()`. 
+These includes naive, statistical, machine learning, and deep learning models. 
+Additionally, there are over 30 time series specific transforms usable in the `sklearn` style of `.fit()`, `.transform()` and `.inverse_transform()`. 
+All of these function directly on Pandas Dataframes, without the need for conversion to proprietary objects. 
+
+All models support forecasting multivariate (multiple time series) outputs and also support probabilistic (upper/lower bound) forecasts. 
+Most models can readily scale to tens and even hundreds of thousands of input series. 
+Many models also support passing in user-defined exogenous regressors. 
+
+These models are all designed for integration in an AutoML feature search which automatically finds the best models, preprocessing, and ensembling for a given dataset through genetic algorithms. 
+
+Horizontal and mosaic style ensembles are the flagship ensembling types, allowing each series to receive the most accurate possible models while still maintaining scalability.
+
+A combination of metrics and cross-validation options, the ability to apply subsets and weighting, regressor generation tools, simulation forecasting mode, event risk forecasting, live datasets, template import and export, plotting, and a collection of data shaping parameters round out the available feature set. 
+
+## Table of Contents
+* [Installation](https://github.com/winedarksea/AutoTS#installation)
+* [Basic Use](https://github.com/winedarksea/AutoTS#basic-use)
+* [Tips for Speed and Large Data](https://github.com/winedarksea/AutoTS#tips-for-speed-and-large-data)
+* Extended Tutorial [GitHub](https://github.com/winedarksea/AutoTS/blob/master/extended_tutorial.md) or [Docs](https://winedarksea.github.io/AutoTS/build/html/source/tutorial.html)
+* [Production Example](https://github.com/winedarksea/AutoTS/blob/master/production_example.py)
+
+## Installation
+```
+pip install autots
+```
+This includes dependencies for basic models, but [additonal packages](https://github.com/winedarksea/AutoTS/blob/master/extended_tutorial.md#installation-and-dependency-versioning) are required for some models and methods.
+
+## Basic Use
+
+Input data for AutoTS is expected to come in either a *long* or a *wide* format:
+
+- The *wide* format is a `pandas.DataFrame` with a `pandas.DatetimeIndex` and each column a distinct series. 
+- The *long* format has three columns: 
+  - Date (ideally already in pandas-recognized `datetime` format)
+  - Series ID. For a single time series, series_id can be `= None`.
+  - Value
+- For *long* data, the column name for each of these is passed to `.fit()` as `date_col`, `id_col`, and `value_col`. No parameters are needed for *wide* data.
+
+Lower-level functions are only designed for `wide` style data.
+
+```python
+# also load: _hourly, _monthly, _weekly, _yearly, or _live_daily
+from autots import AutoTS, load_daily
+
+# sample datasets can be used in either of the long or wide import shapes
+long = False
+df = load_daily(long=long)
+
+model = AutoTS(
+    forecast_length=21,
+    frequency='infer',
+    prediction_interval=0.9,
+    ensemble=None,
+    model_list="fast",  # "superfast", "default", "fast_parallel"
+    transformer_list="fast",  # "superfast",
+    drop_most_recent=1,
+    max_generations=4,
+    num_validations=2,
+    validation_method="backwards"
+)
+model = model.fit(
+    df,
+    date_col='datetime' if long else None,
+    value_col='value' if long else None,
+    id_col='series_id' if long else None,
+)
+
+prediction = model.predict()
+# plot a sample
+prediction.plot(model.df_wide_numeric,
+                series=model.df_wide_numeric.columns[0],
+                start_date="2019-01-01")
+# Print the details of the best model
+print(model)
+
+# point forecasts dataframe
+forecasts_df = prediction.forecast
+# upper and lower forecasts
+forecasts_up, forecasts_low = prediction.upper_forecast, prediction.lower_forecast
+
+# accuracy of all tried model results
+model_results = model.results()
+# and aggregated from cross validation
+validation_results = model.results("validation")
+```
+
+The lower-level API, in particular the large section of time series transformers in the scikit-learn style, can also be utilized independently from the AutoML framework.
+
+Check out [extended_tutorial.md](https://winedarksea.github.io/AutoTS/build/html/source/tutorial.html) for a more detailed guide to features.
+
+Also take a look at the [production_example.py](https://github.com/winedarksea/AutoTS/blob/master/production_example.py)
+
+## Tips for Speed and Large Data:
+* Use appropriate model lists, especially the predefined lists:
+	* `superfast` (simple naive models) and `fast` (more complex but still faster models, optimized for many series)
+	* `fast_parallel` (a combination of `fast` and `parallel`) or `parallel`, given many CPU cores are available
+		* `n_jobs` usually gets pretty close with `='auto'` but adjust as necessary for the environment
+	* see a dict of predefined lists (some defined for internal use) with `from autots.models.model_list import model_lists`
+* Use the `subset` parameter when there are many similar series, `subset=100` will often generalize well for tens of thousands of similar series.
+	* if using `subset`, passing `weights` for series will weight subset selection towards higher priority series.
+	* if limited by RAM, it can be distributed by running multiple instances of AutoTS on different batches of data, having first imported a template pretrained as a starting point for all.
+* Set `model_interrupt=True` which passes over the current model when a `KeyboardInterrupt` ie `crtl+c` is pressed (although if the interrupt falls between generations it will stop the entire training).
+* Use the `result_file` method of `.fit()` which will save progress after each generation - helpful to save progress if a long training is being done. Use `import_results` to recover.
+* While Transformations are pretty fast, setting `transformer_max_depth` to a lower number (say, 2) will increase speed. Also utilize `transformer_list` == 'fast' or 'superfast'.
+* Check out [this example](https://github.com/winedarksea/AutoTS/discussions/76) of using AutoTS with pandas UDF.
+* Ensembles are obviously slower to predict because they run many models, 'distance' models 2x slower, and 'simple' models 3x-5x slower.
+	* `ensemble='horizontal-max'` with `model_list='no_shared_fast'` can scale relatively well given many cpu cores because each model is only run on the series it is needed for.
+* Reducing `num_validations` and `models_to_validate` will decrease runtime but may lead to poorer model selections.
+* For datasets with many records, upsampling (for example, from daily to monthly frequency forecasts) can reduce training time if appropriate.
+	* this can be done by adjusting `frequency` and `aggfunc` but is probably best done before passing data into AutoTS.
+* It will be faster if NaN's are already filled. If a search for optimal NaN fill method is not required, then fill any NaN with a satisfactory method before passing to class.
+* Set `runtime_weighting` in `metric_weighting` to a higher value. This will guide the search towards faster models, although it may come at the expense of accuracy. 
+
+## How to Contribute:
+* Give feedback on where you find the documentation confusing
+* Use AutoTS and...
+	* Report errors and request features by adding Issues on GitHub
+	* Posting the top model templates for your data (to help improve the starting templates)
+	* Feel free to recommend different search grid parameters for your favorite models
+* And, of course, contributing to the codebase directly on GitHub.
+
+
+*Also known as Project CATS (Catlin's Automated Time Series) hence the logo.*

autots-0.5.5/AutoTS.egg-info/SOURCES.txt

@@ -0,0 +1,81 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+AutoTS.egg-info/PKG-INFO
+AutoTS.egg-info/SOURCES.txt
+AutoTS.egg-info/dependency_links.txt
+AutoTS.egg-info/requires.txt
+AutoTS.egg-info/top_level.txt
+autots/__init__.py
+autots.egg-info/PKG-INFO
+autots.egg-info/SOURCES.txt
+autots.egg-info/dependency_links.txt
+autots.egg-info/requires.txt
+autots.egg-info/top_level.txt
+autots/datasets/__init__.py
+autots/datasets/_base.py
+autots/datasets/fred.py
+autots/datasets/data/covid_daily.zip
+autots/datasets/data/eia_weekly.zip
+autots/datasets/data/fred_monthly.zip
+autots/datasets/data/fred_yearly.zip
+autots/datasets/data/holidays.zip
+autots/datasets/data/traffic_hourly.zip
+autots/evaluator/__init__.py
+autots/evaluator/anomaly_detector.py
+autots/evaluator/auto_model.py
+autots/evaluator/auto_ts.py
+autots/evaluator/benchmark.py
+autots/evaluator/event_forecasting.py
+autots/evaluator/metrics.py
+autots/evaluator/validation.py
+autots/models/__init__.py
+autots/models/arch.py
+autots/models/base.py
+autots/models/basics.py
+autots/models/cassandra.py
+autots/models/dnn.py
+autots/models/ensemble.py
+autots/models/gluonts.py
+autots/models/greykite.py
+autots/models/matrix_var.py
+autots/models/mlensemble.py
+autots/models/model_list.py
+autots/models/prophet.py
+autots/models/pytorch.py
+autots/models/sklearn.py
+autots/models/statsmodels.py
+autots/models/tfp.py
+autots/templates/__init__.py
+autots/templates/general.py
+autots/tools/__init__.py
+autots/tools/anomaly_utils.py
+autots/tools/calendar.py
+autots/tools/cointegration.py
+autots/tools/cpu_count.py
+autots/tools/fast_kalman.py
+autots/tools/hierarchial.py
+autots/tools/holiday.py
+autots/tools/impute.py
+autots/tools/lunar.py
+autots/tools/percentile.py
+autots/tools/probabilistic.py
+autots/tools/profile.py
+autots/tools/regressor.py
+autots/tools/seasonal.py
+autots/tools/shaping.py
+autots/tools/thresholding.py
+autots/tools/transform.py
+autots/tools/window_functions.py
+docs/conf.py
+tests/test_anomalies.py
+tests/test_autots.py
+tests/test_calendar_holiday.py
+tests/test_cassandra.py
+tests/test_event_forecasting.py
+tests/test_impute.py
+tests/test_metrics.py
+tests/test_percentile.py
+tests/test_regressor.py

autots-0.5.5/AutoTS.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

autots-0.5.5/AutoTS.egg-info/requires.txt

@@ -0,0 +1,21 @@
+numpy>=1.14.6
+pandas>=0.25.0
+statsmodels>=0.10.0
+scikit-learn>=0.20.0
+
+[additional]
+holidays>=0.9
+prophet>=0.4.0
+fredapi
+tensorflow
+xgboost
+lightgbm
+joblib
+scipy
+arch
+numexpr
+bottleneck
+yfinance
+pytrends
+matplotlib
+requests

autots-0.5.5/AutoTS.egg-info/top_level.txt

@@ -0,0 +1,6 @@
+autots
+build
+dist
+docs
+img
+tests

autots-0.5.5/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Colin Catlin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

autots-0.5.5/MANIFEST.in

@@ -0,0 +1,3 @@
+include autots/datasets/data/*.csv
+include autots/datasets/data/*.zip
+include README.md LICENSE

autots-0.5.5/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.1
+Name: autots
+Version: 0.5.5
+Summary: Automated Time Series Forecasting
+Home-page: https://github.com/winedarksea/AutoTS
+Author: Colin Catlin
+Author-email: Colin Catlin <colin.catlin@gmail.com>
+License: MIT License
+Project-URL: Homepage, https://github.com/winedarksea/AutoTS
+Project-URL: Bug Tracker, https://github.com/winedarksea/AutoTS/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Provides-Extra: additional
+License-File: LICENSE
+
+# AutoTS
+
+<img src="/img/autots_1280.png" width="400" height="184" title="AutoTS Logo">
+
+AutoTS is a time series package for Python designed for rapidly deploying high-accuracy forecasts at scale. 
+
+In 2023, AutoTS has won the M6 forecasting competition, delivering the highest performance investment decisions across 12 months of stock market forecasting.
+
+There are dozens of forecasting models usable in the `sklearn` style of `.fit()` and `.predict()`. 
+These includes naive, statistical, machine learning, and deep learning models. 
+Additionally, there are over 30 time series specific transforms usable in the `sklearn` style of `.fit()`, `.transform()` and `.inverse_transform()`. 
+All of these function directly on Pandas Dataframes, without the need for conversion to proprietary objects. 
+
+All models support forecasting multivariate (multiple time series) outputs and also support probabilistic (upper/lower bound) forecasts. 
+Most models can readily scale to tens and even hundreds of thousands of input series. 
+Many models also support passing in user-defined exogenous regressors. 
+
+These models are all designed for integration in an AutoML feature search which automatically finds the best models, preprocessing, and ensembling for a given dataset through genetic algorithms. 
+
+Horizontal and mosaic style ensembles are the flagship ensembling types, allowing each series to receive the most accurate possible models while still maintaining scalability.
+
+A combination of metrics and cross-validation options, the ability to apply subsets and weighting, regressor generation tools, simulation forecasting mode, event risk forecasting, live datasets, template import and export, plotting, and a collection of data shaping parameters round out the available feature set. 
+
+## Table of Contents
+* [Installation](https://github.com/winedarksea/AutoTS#installation)
+* [Basic Use](https://github.com/winedarksea/AutoTS#basic-use)
+* [Tips for Speed and Large Data](https://github.com/winedarksea/AutoTS#tips-for-speed-and-large-data)
+* Extended Tutorial [GitHub](https://github.com/winedarksea/AutoTS/blob/master/extended_tutorial.md) or [Docs](https://winedarksea.github.io/AutoTS/build/html/source/tutorial.html)
+* [Production Example](https://github.com/winedarksea/AutoTS/blob/master/production_example.py)
+
+## Installation
+```
+pip install autots
+```
+This includes dependencies for basic models, but [additonal packages](https://github.com/winedarksea/AutoTS/blob/master/extended_tutorial.md#installation-and-dependency-versioning) are required for some models and methods.
+
+## Basic Use
+
+Input data for AutoTS is expected to come in either a *long* or a *wide* format:
+
+- The *wide* format is a `pandas.DataFrame` with a `pandas.DatetimeIndex` and each column a distinct series. 
+- The *long* format has three columns: 
+  - Date (ideally already in pandas-recognized `datetime` format)
+  - Series ID. For a single time series, series_id can be `= None`.
+  - Value
+- For *long* data, the column name for each of these is passed to `.fit()` as `date_col`, `id_col`, and `value_col`. No parameters are needed for *wide* data.
+
+Lower-level functions are only designed for `wide` style data.
+
+```python
+# also load: _hourly, _monthly, _weekly, _yearly, or _live_daily
+from autots import AutoTS, load_daily
+
+# sample datasets can be used in either of the long or wide import shapes
+long = False
+df = load_daily(long=long)
+
+model = AutoTS(
+    forecast_length=21,
+    frequency='infer',
+    prediction_interval=0.9,
+    ensemble=None,
+    model_list="fast",  # "superfast", "default", "fast_parallel"
+    transformer_list="fast",  # "superfast",
+    drop_most_recent=1,
+    max_generations=4,
+    num_validations=2,
+    validation_method="backwards"
+)
+model = model.fit(
+    df,
+    date_col='datetime' if long else None,
+    value_col='value' if long else None,
+    id_col='series_id' if long else None,
+)
+
+prediction = model.predict()
+# plot a sample
+prediction.plot(model.df_wide_numeric,
+                series=model.df_wide_numeric.columns[0],
+                start_date="2019-01-01")
+# Print the details of the best model
+print(model)
+
+# point forecasts dataframe
+forecasts_df = prediction.forecast
+# upper and lower forecasts
+forecasts_up, forecasts_low = prediction.upper_forecast, prediction.lower_forecast
+
+# accuracy of all tried model results
+model_results = model.results()
+# and aggregated from cross validation
+validation_results = model.results("validation")
+```
+
+The lower-level API, in particular the large section of time series transformers in the scikit-learn style, can also be utilized independently from the AutoML framework.
+
+Check out [extended_tutorial.md](https://winedarksea.github.io/AutoTS/build/html/source/tutorial.html) for a more detailed guide to features.
+
+Also take a look at the [production_example.py](https://github.com/winedarksea/AutoTS/blob/master/production_example.py)
+
+## Tips for Speed and Large Data:
+* Use appropriate model lists, especially the predefined lists:
+	* `superfast` (simple naive models) and `fast` (more complex but still faster models, optimized for many series)
+	* `fast_parallel` (a combination of `fast` and `parallel`) or `parallel`, given many CPU cores are available
+		* `n_jobs` usually gets pretty close with `='auto'` but adjust as necessary for the environment
+	* see a dict of predefined lists (some defined for internal use) with `from autots.models.model_list import model_lists`
+* Use the `subset` parameter when there are many similar series, `subset=100` will often generalize well for tens of thousands of similar series.
+	* if using `subset`, passing `weights` for series will weight subset selection towards higher priority series.
+	* if limited by RAM, it can be distributed by running multiple instances of AutoTS on different batches of data, having first imported a template pretrained as a starting point for all.
+* Set `model_interrupt=True` which passes over the current model when a `KeyboardInterrupt` ie `crtl+c` is pressed (although if the interrupt falls between generations it will stop the entire training).
+* Use the `result_file` method of `.fit()` which will save progress after each generation - helpful to save progress if a long training is being done. Use `import_results` to recover.
+* While Transformations are pretty fast, setting `transformer_max_depth` to a lower number (say, 2) will increase speed. Also utilize `transformer_list` == 'fast' or 'superfast'.
+* Check out [this example](https://github.com/winedarksea/AutoTS/discussions/76) of using AutoTS with pandas UDF.
+* Ensembles are obviously slower to predict because they run many models, 'distance' models 2x slower, and 'simple' models 3x-5x slower.
+	* `ensemble='horizontal-max'` with `model_list='no_shared_fast'` can scale relatively well given many cpu cores because each model is only run on the series it is needed for.
+* Reducing `num_validations` and `models_to_validate` will decrease runtime but may lead to poorer model selections.
+* For datasets with many records, upsampling (for example, from daily to monthly frequency forecasts) can reduce training time if appropriate.
+	* this can be done by adjusting `frequency` and `aggfunc` but is probably best done before passing data into AutoTS.
+* It will be faster if NaN's are already filled. If a search for optimal NaN fill method is not required, then fill any NaN with a satisfactory method before passing to class.
+* Set `runtime_weighting` in `metric_weighting` to a higher value. This will guide the search towards faster models, although it may come at the expense of accuracy. 
+
+## How to Contribute:
+* Give feedback on where you find the documentation confusing
+* Use AutoTS and...
+	* Report errors and request features by adding Issues on GitHub
+	* Posting the top model templates for your data (to help improve the starting templates)
+	* Feel free to recommend different search grid parameters for your favorite models
+* And, of course, contributing to the codebase directly on GitHub.
+
+
+*Also known as Project CATS (Catlin's Automated Time Series) hence the logo.*

autots-0.5.5/README.md

@@ -0,0 +1,132 @@
+# AutoTS
+
+<img src="/img/autots_1280.png" width="400" height="184" title="AutoTS Logo">
+
+AutoTS is a time series package for Python designed for rapidly deploying high-accuracy forecasts at scale. 
+
+In 2023, AutoTS has won the M6 forecasting competition, delivering the highest performance investment decisions across 12 months of stock market forecasting.
+
+There are dozens of forecasting models usable in the `sklearn` style of `.fit()` and `.predict()`. 
+These includes naive, statistical, machine learning, and deep learning models. 
+Additionally, there are over 30 time series specific transforms usable in the `sklearn` style of `.fit()`, `.transform()` and `.inverse_transform()`. 
+All of these function directly on Pandas Dataframes, without the need for conversion to proprietary objects. 
+
+All models support forecasting multivariate (multiple time series) outputs and also support probabilistic (upper/lower bound) forecasts. 
+Most models can readily scale to tens and even hundreds of thousands of input series. 
+Many models also support passing in user-defined exogenous regressors. 
+
+These models are all designed for integration in an AutoML feature search which automatically finds the best models, preprocessing, and ensembling for a given dataset through genetic algorithms. 
+
+Horizontal and mosaic style ensembles are the flagship ensembling types, allowing each series to receive the most accurate possible models while still maintaining scalability.
+
+A combination of metrics and cross-validation options, the ability to apply subsets and weighting, regressor generation tools, simulation forecasting mode, event risk forecasting, live datasets, template import and export, plotting, and a collection of data shaping parameters round out the available feature set. 
+
+## Table of Contents
+* [Installation](https://github.com/winedarksea/AutoTS#installation)
+* [Basic Use](https://github.com/winedarksea/AutoTS#basic-use)
+* [Tips for Speed and Large Data](https://github.com/winedarksea/AutoTS#tips-for-speed-and-large-data)
+* Extended Tutorial [GitHub](https://github.com/winedarksea/AutoTS/blob/master/extended_tutorial.md) or [Docs](https://winedarksea.github.io/AutoTS/build/html/source/tutorial.html)
+* [Production Example](https://github.com/winedarksea/AutoTS/blob/master/production_example.py)
+
+## Installation
+```
+pip install autots
+```
+This includes dependencies for basic models, but [additonal packages](https://github.com/winedarksea/AutoTS/blob/master/extended_tutorial.md#installation-and-dependency-versioning) are required for some models and methods.
+
+## Basic Use
+
+Input data for AutoTS is expected to come in either a *long* or a *wide* format:
+
+- The *wide* format is a `pandas.DataFrame` with a `pandas.DatetimeIndex` and each column a distinct series. 
+- The *long* format has three columns: 
+  - Date (ideally already in pandas-recognized `datetime` format)
+  - Series ID. For a single time series, series_id can be `= None`.
+  - Value
+- For *long* data, the column name for each of these is passed to `.fit()` as `date_col`, `id_col`, and `value_col`. No parameters are needed for *wide* data.
+
+Lower-level functions are only designed for `wide` style data.
+
+```python
+# also load: _hourly, _monthly, _weekly, _yearly, or _live_daily
+from autots import AutoTS, load_daily
+
+# sample datasets can be used in either of the long or wide import shapes
+long = False
+df = load_daily(long=long)
+
+model = AutoTS(
+    forecast_length=21,
+    frequency='infer',
+    prediction_interval=0.9,
+    ensemble=None,
+    model_list="fast",  # "superfast", "default", "fast_parallel"
+    transformer_list="fast",  # "superfast",
+    drop_most_recent=1,
+    max_generations=4,
+    num_validations=2,
+    validation_method="backwards"
+)
+model = model.fit(
+    df,
+    date_col='datetime' if long else None,
+    value_col='value' if long else None,
+    id_col='series_id' if long else None,
+)
+
+prediction = model.predict()
+# plot a sample
+prediction.plot(model.df_wide_numeric,
+                series=model.df_wide_numeric.columns[0],
+                start_date="2019-01-01")
+# Print the details of the best model
+print(model)
+
+# point forecasts dataframe
+forecasts_df = prediction.forecast
+# upper and lower forecasts
+forecasts_up, forecasts_low = prediction.upper_forecast, prediction.lower_forecast
+
+# accuracy of all tried model results
+model_results = model.results()
+# and aggregated from cross validation
+validation_results = model.results("validation")
+```
+
+The lower-level API, in particular the large section of time series transformers in the scikit-learn style, can also be utilized independently from the AutoML framework.
+
+Check out [extended_tutorial.md](https://winedarksea.github.io/AutoTS/build/html/source/tutorial.html) for a more detailed guide to features.
+
+Also take a look at the [production_example.py](https://github.com/winedarksea/AutoTS/blob/master/production_example.py)
+
+## Tips for Speed and Large Data:
+* Use appropriate model lists, especially the predefined lists:
+	* `superfast` (simple naive models) and `fast` (more complex but still faster models, optimized for many series)
+	* `fast_parallel` (a combination of `fast` and `parallel`) or `parallel`, given many CPU cores are available
+		* `n_jobs` usually gets pretty close with `='auto'` but adjust as necessary for the environment
+	* see a dict of predefined lists (some defined for internal use) with `from autots.models.model_list import model_lists`
+* Use the `subset` parameter when there are many similar series, `subset=100` will often generalize well for tens of thousands of similar series.
+	* if using `subset`, passing `weights` for series will weight subset selection towards higher priority series.
+	* if limited by RAM, it can be distributed by running multiple instances of AutoTS on different batches of data, having first imported a template pretrained as a starting point for all.
+* Set `model_interrupt=True` which passes over the current model when a `KeyboardInterrupt` ie `crtl+c` is pressed (although if the interrupt falls between generations it will stop the entire training).
+* Use the `result_file` method of `.fit()` which will save progress after each generation - helpful to save progress if a long training is being done. Use `import_results` to recover.
+* While Transformations are pretty fast, setting `transformer_max_depth` to a lower number (say, 2) will increase speed. Also utilize `transformer_list` == 'fast' or 'superfast'.
+* Check out [this example](https://github.com/winedarksea/AutoTS/discussions/76) of using AutoTS with pandas UDF.
+* Ensembles are obviously slower to predict because they run many models, 'distance' models 2x slower, and 'simple' models 3x-5x slower.
+	* `ensemble='horizontal-max'` with `model_list='no_shared_fast'` can scale relatively well given many cpu cores because each model is only run on the series it is needed for.
+* Reducing `num_validations` and `models_to_validate` will decrease runtime but may lead to poorer model selections.
+* For datasets with many records, upsampling (for example, from daily to monthly frequency forecasts) can reduce training time if appropriate.
+	* this can be done by adjusting `frequency` and `aggfunc` but is probably best done before passing data into AutoTS.
+* It will be faster if NaN's are already filled. If a search for optimal NaN fill method is not required, then fill any NaN with a satisfactory method before passing to class.
+* Set `runtime_weighting` in `metric_weighting` to a higher value. This will guide the search towards faster models, although it may come at the expense of accuracy. 
+
+## How to Contribute:
+* Give feedback on where you find the documentation confusing
+* Use AutoTS and...
+	* Report errors and request features by adding Issues on GitHub
+	* Posting the top model templates for your data (to help improve the starting templates)
+	* Feel free to recommend different search grid parameters for your favorite models
+* And, of course, contributing to the codebase directly on GitHub.
+
+
+*Also known as Project CATS (Catlin's Automated Time Series) hence the logo.*

autots-0.5.5/autots/__init__.py

@@ -0,0 +1,56 @@
+"""
+Automated Time Series Model Selection for Python
+
+https://github.com/winedarksea/AutoTS
+"""
+from autots.datasets import (
+    load_hourly,
+    load_daily,
+    load_monthly,
+    load_yearly,
+    load_weekly,
+    load_weekdays,
+    load_live_daily,
+    load_linear,
+    load_artificial,
+    load_sine,
+)
+
+from autots.evaluator.auto_ts import AutoTS
+from autots.evaluator.event_forecasting import EventRiskForecast
+from autots.tools.transform import GeneralTransformer, RandomTransform
+from autots.tools.shaping import long_to_wide
+from autots.tools.regressor import create_lagged_regressor, create_regressor
+from autots.evaluator.auto_model import model_forecast
+from autots.evaluator.anomaly_detector import AnomalyDetector, HolidayDetector
+from autots.models.cassandra import Cassandra
+
+
+__version__ = '0.5.5'
+
+TransformTS = GeneralTransformer
+
+__all__ = [
+    'load_daily',
+    'load_monthly',
+    'load_yearly',
+    'load_hourly',
+    'load_weekly',
+    'load_weekdays',
+    'load_live_daily',
+    'load_linear',
+    'load_artificial',
+    'load_sine',
+    'AutoTS',
+    'TransformTS',
+    'GeneralTransformer',
+    'RandomTransform',
+    'long_to_wide',
+    'model_forecast',
+    'create_lagged_regressor',
+    'create_regressor',
+    'EventRiskForecast',
+    'AnomalyDetector',
+    'HolidayDetector',
+    'Cassandra',
+]

autots-0.5.5/autots/datasets/__init__.py

@@ -0,0 +1,30 @@
+"""
+Tools for Importing Sample Data
+"""
+from autots.datasets._base import (
+    load_daily,
+    load_live_daily,
+    load_monthly,
+    load_yearly,
+    load_hourly,
+    load_weekly,
+    load_weekdays,
+    load_zeroes,
+    load_linear,
+    load_sine,
+    load_artificial,
+)
+
+__all__ = [
+    'load_daily',
+    'load_monthly',
+    'load_yearly',
+    'load_hourly',
+    'load_weekly',
+    'load_weekdays',
+    'load_live_daily',
+    'load_zeroes',
+    'load_linear',
+    'load_sine',
+    'load_artificial',
+]