PaddleTS packages deep time series models from NBEATS to PatchTST behind one API

A model zoo with a shared pipeline interface

PaddleTS is described as an easy to use deep time series modeling library based on the PaddlePaddle deep learning framework, focused on industry leading deep models, aimed at domain experts and industry users who want extensible time series modeling capability with a convenient user experience. The design commitment that makes it more than a list of model implementations is described in the README as encapsulation of base model functionality, covering data loading, callback configuration, loss functions and training process control, so that developers working on a new model can focus on the network structure itself. That is the difference between a library and a collection of scripts. The module list in the README makes the same point from the other direction, with paddlets.datasets holding a unified time series data structure and predefined data processing methods, paddlets.transform for preprocessing and feature engineering, paddlets.pipeline as the modelling task flow that supports feature engineering, model training and model evaluation, paddlets.metrics for multi dimensional evaluation, paddlets.analysis for time series specific data analysis, paddlets.ensemble for model ensembling, paddlets.xai for model interpretability, and paddlets.utils for utilities such as backtesting. The licence is Apache-2.0, the default branch is release_v1.1, and the last push to the repository was on 2026-04-17.

The three model families and what they cover

The built-in models are grouped by task, and the README lists them explicitly. For forecasting there are NBEATS, NHiTS, LSTNet, TCN, Transformer, DeepAR and Informer. For representation learning there are TS2Vec and CoST. For anomaly detection there are Autoencoder, VAE and AnomalyTransformer. More recent additions named in the README are USAD for unsupervised anomaly detection and MTAD_GAT for multivariate anomaly detection through graph attention, CNN and Inception Time for time series classification, and SCINet and the Temporal Fusion Transformer for forecasting. A separate update line adds seven more forecasting algorithms, DLinear, NLinear, RLinear, Nonstationary, PatchTST, TiDE and TimesNet, five more anomaly detection algorithms including AutoEncoder_ad, DLinear_ad, Nonstationary_ad, PatchTST_ad and TimesNet_ad, and TimesNet_cls for classification. The topic tags on the repository mirror this inventory, naming deepar, informer, n-beats, n-hits and ts2vec among others, which is a useful sanity check on whether the model you want is actually in the tree.

Data, transforms and the analysis operators

The data layer is where most time series projects lose their week, and PaddleTS treats it as a first class concern. The README describes a unified data structure that expresses diverse time series data, supporting single target and multi target variables and multiple types of covariates. Built-in data transform operators cover missing value filling, outlier handling, normalisation and time related covariate extraction, and the classic data analysis operators give statistics and summaries for exploration before any model runs. The requirement list in requirements.txt shows how heavy that stack is, and it is worth reading because it defines your real dependency footprint.

numpy>=1.17.0, <=1.26.4
pandas>=1.4
scikit-learn>=0.24.1
chinese-calendar==1.8.0
python-docx
matplotlib>=3.1.2
PyWavelets>=1.1.0
statsmodels>=0.10.2
scipy>=1.5.0
tqdm
pyod>=1.0.5
seaborn>=0.11.2
shap>=0.40.0
einops
jinja2
IPython
more-itertools
ruamel.yaml
packaging

The pinned upper bound on numpy, the exact pin on chinese-calendar and the presence of ruamel.yaml for configuration and jinja2 for templating all point to a library that assumes a fairly specific environment. The README also states that third party machine learning models and data transformation modules are integrated automatically, including sklearn and pyod, so a sklearn based baseline can be compared inside the same framework.

AutoTS and the hyperparameter search backends

AutoTS is the automatic model tuning module, and the README says it supports multiple types of hyperparameter optimization algorithms and shows significant tuning results across several models and datasets. The requirements file shows what that means in practice, because the autots section pulls in four separate search backends.

ray[tune]>=1.13.0
optuna>=2.10.1
FLAML>=0.10.0
hpbandster>=0.7.4
ConfigSpace>=0.5.0
protobuf==3.20.2; platform_system=='Windows'

Ray Tune, Optuna, FLAML and HpBandSterp are all installed as part of the default requirements, and HpBandSterp brings ConfigSpace with it. The last line is a small but telling detail: protobuf is pinned to exactly 3.20.2 and only on Windows, which is the kind of platform specific pin that comes from resolving a dependency conflict on one operating system. Expect the install to be heavier than the module list suggests.

Installing paddlets and running the first task

The package is built with setuptools, and setup.py names it paddlets at version 1.1.0, with python_requires of 3.7 or newer, and the classifiers cover Python 3.7, 3.8 and 3.9 and the Apache Software License.

    name='paddlets',
    version='1.1.0',
    maintainer='paddlets Team',
    maintainer_email='[email protected]',
    packages=find_packages(include=['paddlets', 'paddlets.*']) +
    find_namespace_packages(include=['paddlets', 'paddlets.*']),
    url='https://github.com/PaddlePaddle/PaddleTS',
    license='LICENSE',
    description='PaddleTS (Paddle Time Series Tool), \
           PaddlePaddle-based Time Series Modeling in Python',

The install requirements are read straight from requirements.txt by the setup script, so the dependency list you saw above is exactly what pip installs. The README badges state Python 3.7 or newer and PaddlePaddle 2.3.0 or newer, so PaddlePaddle itself has to be present in the environment before paddlets is useful. The examples/ directory at the top of the repository is the fastest way to see the intended workflow, with notebooks for getting started, data analysis, anomaly detection, AutoTS, ensemble forecasting, representation learning, third party models and explainability. The train.py script at the root and the configs/ directory suggest a config driven training path as well.

PaddleX as the low code route

A significant part of the README is now about PaddleX, the low code development tool built on PaddleTS, and it changes how you might actually use this library. The README says PaddleX provides low code end to end development for the time series domain, consolidating the models involved in time series forecasting, anomaly detection and time series classification into 13 models organised as three model production lines, callable through a very simple Python API, with the same API also covering image classification, image segmentation, object detection, text image analysis and general OCR for a total of more than 200 models across more than 20 single function modules so developers can combine models. It also offers a unified command line and a graphical interface, with high performance deployment, service deployment and on device deployment, and it names NVIDIA GPU, Kunlunxin, Ascend, Cambricon and Hygon hardware among the platforms where you can switch models. If your use case fits one of those production lines, going through PaddleX is likely less work than driving paddlets directly, and the README links both the quick start and the overview pages for it.

Where PaddleTS is the wrong choice

Four limits deserve a clear statement. The first is the runtime. Everything here runs on PaddlePaddle, and the topics list names paddlepaddle prominently, so a team whose trained models must run on TensorFlow or PyTorch infrastructure cannot use the models as they are, and deploying a PaddlePaddle model adds an inference stack of its own. The second is the release cadence. The tagged releases are 1.1.0 from 2022-12-30, 1.0.2 from 2022-11-14 and 1.0.1 from 2022-11-04, and the default branch is release_v1.1, so the versioned library line has not been cut since December 2022 even though the repository was pushed to on 2026-04-17, which means recent work is landing on a branch rather than in a release, and the current direction of the project is arguably in PaddleX rather than in paddlets. The third is the Python version range. The classifiers stop at Python 3.9 and the badge says 3.7 or newer, so on a modern Python 3.12 environment you are outside the tested range, and the numpy upper bound of 1.26.4 constrains the rest of your scientific stack. The fourth is that the model zoo is not the differentiator it once was. The forecasting models listed here are available in other frameworks too, and what PaddleTS actually gives you is the surrounding plumbing, so if you already have a working forecasting stack the case for migrating is weak. The honest alternative to compare against is a general purpose forecasting framework that runs on the deep learning framework you already deploy, where you trade the ready made pipeline and the built in AutoTS backends for keeping one runtime and writing the data handling yourself.

Editorial conclusion

Adopt PaddleTS if your team already builds on PaddlePaddle and you want forecasting, anomaly detection and representation learning behind one pipeline API instead of assembling each model's data handling yourself, because the library wraps data loading, callbacks, loss functions and training control so a new model only has to define its network. Do not adopt it if your team is on TensorFlow or PyTorch and has no plan to add PaddlePaddle, since the runtime dependency is the decision, not the model list. Verify two things before you commit: that the PaddlePaddle version you run satisfies the 2.3.0 or newer floor the README badge states, and that the models you need are present in the module you expect, since forecasting, representation, anomaly and classification models live in separate paddlets.models subpackages. The practical first step is to install paddlets with its requirements, load one of the example notebooks such as get_start.ipynb, and run the forecasting task end to end before you swap in your own data.

Frequently asked questions

Official sources

1. Issues
2. License: Apache-2.0
3. PaddlePaddle/PaddleTS on GitHub
4. README
5. Releases