# AutoTS runs a genetic search over models, and the interrupt key has a 1.5 second window

> A forecasting AutoML package with dozens of models and thirty-odd transformers behind a scikit-learn shaped API. The performance advice is unusually concrete, and the repository ships LaTeX build intermediates next to the package source.

**winedarksea/AutoTS** — Automated Time Series Forecasting

- Repository: https://github.com/winedarksea/AutoTS
- Stars: 1,429 · Forks: 124
- Language: Python
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/winedarksea-autots

## The search is genetic, and the ensemble assigns a model per series

The AutoML layer does not pick one model. It runs a genetic algorithm over three things at once: which models, which preprocessing, and how they are ensembled. What comes out the other end is not a single fitted forecaster but an assignment.

The two flagship ensemble types are horizontal and mosaic. Horizontal means each series gets the models that scored best for that series, so two unrelated series can end up on different model families. That is the point of the design, and it is also why it costs what it costs: to predict, every model in the ensemble runs.

```python
model = AutoTS(
    forecast_length=21,
    frequency="infer",
    prediction_interval=0.9,
    ensemble=None,
    model_list="superfast",  # "fast", "default", "fast_parallel"
    transformer_list="fast",  # "superfast",
    drop_most_recent=1,
    max_generations=4,
    num_validations=2,
    validation_method="backwards"
)
```

Six of those arguments are search controls, not forecasting controls. `max_generations=4` and `num_validations=2` are both low, which makes this a quick first run rather than a serious one. `drop_most_recent=1` holds back the final point of each series from training, which is a validation choice wearing a different name.

## Five model lists, and the one you want depends on which limit you are hitting

Rather than making you name models, the package ships predefined lists, and the choice is really a choice about which resource is scarce.

`superfast` is described as simple naive models. `fast` is more complex but still optimized for many series. `fast_parallel` combines `fast` with parallel execution and is for when you have many CPU cores, where `n_jobs='auto'` gets close but wants tuning for the environment. And `scalable` is the one named for avoiding a crash when many series are present, with a matching `transformer_list='scalable'`.

There is also `no_shared_fast`, which appears later as a pairing for `horizontal-max` rather than as a speed tier.

The dictionary behind these is inspectable:

```python
from autots.models.model_list import model_lists
```

with a parenthetical note that some entries in it are for internal use, so treat the public names as the stable surface.

Separately, `subset` is the parameter for many similar series: `subset=100` generalizes well for tens of thousands of similar ones, and passing `weights` biases subset selection toward higher-priority series. That combination is the documented answer to a large homogeneous panel, and it is a different answer from sharding.

## Interrupt is two-stage, and the window is configurable

A genetic search over dozens of models on tens of thousands of series is a long-running thing to want to stop, so the interrupt behavior is unusually well specified.

Setting `model_interrupt=True` means one press of Ctrl+C skips only the current model and the search continues. A second press within 1.5 seconds ends the entire run. The window is a parameter, and the documented form is a dict:

```python
model_interrupt={"mode": "skip", "double_press_window": 1.2}
```

so you can tighten or loosen it. Two presses inside the window abort, one press outside it just skips. This is a small design decision that most long-running search tools get wrong, because they offer a single interrupt that means one thing and no way to recover from a mispress.

Progress is separately durable. The `result_file` method of `.fit()` writes after each generation, and `import_results` recovers from it. That matters for the same reason: a search that takes hours should not lose hours to a closed terminal.

One caveat worth knowing: reducing `num_validations` and `models_to_validate` will cut runtime and may make the model selection worse. Those two are the trade you make when you are short on time.

## Long format takes three column names, wide format takes nothing

Input arrives in one of two shapes, and the difference is whether you pass column names.

Wide is a `pandas.DataFrame` with a `pandas.DatetimeIndex` where each column is a distinct series. Long is three columns: date, series ID, and value. The three names are passed to `.fit()` as `date_col`, `id_col` and `value_col`, and nothing is passed for wide.

```python
from autots import AutoTS, load_daily

long = False
df = load_daily(long=long)
```

The same sample datasets load in either shape, which is the convenient way to check that your pipeline handles both.

Two constraints on that. For a single series, `series_id` can be `None`. And the lower-level functions are designed for wide data only, so if you are reaching past the AutoML wrapper into individual functions, you are in wide format whether you like it or not.

Everything works directly on DataFrames with no conversion to a proprietary object type, which is the decision that keeps this package composable with the rest of a pandas pipeline.

## Transformers are a separate layer you can use without the search

There are over thirty time-series-specific transformers, carrying the same scikit-learn shape as the models: `.fit()`, `.transform()`, `.inverse_transform()`. They can be used independently of the AutoML framework, and that is the documented reason the lower-level API is mentioned separately at all.

The pipeline accepts a list of them the same way it accepts models, and the search chooses among them alongside the models rather than after them.

```python
model_list="superfast",  # "fast", "default", "fast_parallel"
transformer_list="fast",  # "superfast",
```

Performance guidance separates the two layers. Transformations are described as pretty fast on their own, so lowering `transformer_max_depth` to something like 2 increases speed, and `transformer_list` set to `fast` or `superfast` narrows the candidates.

This split is the most reusable thing in the package. If the ensemble search is not what you want, you can keep the transforms and drop the search, or invert that and keep a single model with the transform stack around it.

## The distribution answer for a RAM limit is several processes and one template

Most models are described as scaling to tens and even hundreds of thousands of input series, but memory is the limit that gets addressed explicitly.

The documented approach for a RAM-constrained machine is to run multiple AutoTS instances over different batches of the data, after first importing a template that has been pretrained as a starting point for all of them. The template is the point: without it each instance rediscovers the search from scratch, and with it you are doing the expensive part once.

That also connects to the horizontal-ensemble scaling note, which pairs `ensemble='horizontal-max'` with `model_list='no_shared_fast'` as the combination that scales on many cores, because each model runs only on the series that needs it.

Prediction cost is where ensembles get expensive, and the numbers given are relative: distance-based models are about 2x slower, and simple models 3x to 5x slower, because an ensemble runs many models.

Upsampling is the other lever, suggested for datasets with many records where a coarser forecast target is acceptable, for example going from daily to monthly frequency.

## A LaTeX build directory sits in the repository root

The repository root holds the package, the tests, the docs and an extended tutorial, plus a few entries that do not belong to a Python distribution.

There are three LaTeX intermediates checked in at the top level: `main.aux`, `main.fdb_latexmk` and `main.fls`. The last of those is a recorder file, so it contains absolute paths from whatever machine last compiled the document.

```
main.aux
main.fdb_latexmk
main.fls
```

There is also `feature_detector_notes.rtf`, an RTF file rather than Markdown, sitting beside `TODO.md` and `AGENTS.md`. The presence of `AGENTS.md` and `server.json` at the root points to the package being published through an agent-friendly registry as well as PyPI, and `MANIFEST.in` sits alongside both `setup.py` and `pyproject.toml`, so packaging is configured twice.

None of this affects the installed package, since `pip install autots` resolves from the index rather than the repository. It matters if you are reading the tree to judge how the project is maintained, which is exactly what that root listing makes harder.

## Conclusion

AutoTS suits a team that has many series and no idea which family of forecaster fits them, because the genetic search is what turns that ignorance into a per-series model assignment rather than one global choice. Three things to settle first. Pick a predefined model list before you start, because the default is not a safe starting point on large data and `scalable` exists specifically to avoid crashing when many series are present. Decide up front how you will shard, because the documented path for a RAM limit is several instances over batches of data sharing one pretrained template, and that has to be planned before the first run. And if the run is long enough that you will want to stop it, learn the interrupt first: one press skips a model, two within a second and a half ends the run. The transformers are usable on their own if you outgrow the AutoML layer, since they carry the same fit, transform and inverse_transform shape as the models. What you give up by starting here is control over which model runs on which series, since horizontal ensembles assign that per series for you.

## FAQ

### What is AutoTS used for?

Automated time series forecasting in Python. It searches over models, transformers and ensembling with a genetic algorithm and returns forecasts, optionally multivariate and with prediction intervals.

### Does AutoTS need extra packages installed?

Yes for some models and methods. `pip install autots` pulls the dependencies for the basic models only, and additional packages are required beyond that, documented in the extended tutorial.

### How do I control AutoTS runtime?

Start from a predefined model list: `superfast` for naive models, `fast` for more complex ones tuned for many series, `fast_parallel` when you have cores to spare, and `scalable` to avoid crashing on large series counts. The full dictionary is importable from `autots.models.model_list`.

### Can AutoTS be stopped partway through a long run?

Yes. With `model_interrupt=True`, one press of Ctrl+C skips the current model, and a second press within 1.5 seconds ends the run. The window is adjustable through the `double_press_window` key, and `result_file` plus `import_results` let you resume from the last saved generation.

### Does AutoTS accept Pandas DataFrames directly?

Yes, in either a wide shape where each column is a series, or a long shape with date, series ID and value columns whose names you pass as `date_col`, `id_col` and `value_col`. No conversion to a proprietary object type is required.

### What do the AutoML search options control?

How much searching happens rather than how the forecast looks. `max_generations` bounds the genetic loop, `num_validations` bounds the cross-validation, `drop_most_recent` holds back the final point of each series, and `validation_method` selects the strategy. The example configuration runs 4 generations and 2 validations.

## Sources

- [Issues](https://github.com/winedarksea/AutoTS/issues)
- [License: MIT](https://github.com/winedarksea/AutoTS/blob/master/LICENSE)
- [README](https://github.com/winedarksea/AutoTS/blob/master/README.md)
- [Releases](https://github.com/winedarksea/AutoTS/releases)
- [winedarksea/AutoTS on GitHub](https://github.com/winedarksea/AutoTS)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/winedarksea-autots