feat: add nixtla pp

.gitignore

@@ -0,0 +1,131 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+models/

app.py

@@ -0,0 +1,374 @@
+from time import time
+
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import streamlit as st
+from datasetsforecast.losses import rmse, mae, smape, mse, mape
+from st_aggrid import AgGrid
+
+from src.nf import MODELS, forecast_pretrained_model
+from src.model_descriptions import model_cards
+
+DATASETS = {
+    "Electricity (Ercot COAST)": "https://raw.githubusercontent.com/Nixtla/transfer-learning-time-series/main/datasets/ercot_COAST.csv",
+    #"Electriciy (ERCOT, multiple markets)": "https://raw.githubusercontent.com/Nixtla/transfer-learning-time-series/main/datasets/ercot_multiple_ts.csv",
+    "Web Traffic (Peyton Manning)": "https://raw.githubusercontent.com/Nixtla/transfer-learning-time-series/main/datasets/peyton_manning.csv",
+    "Demand (AirPassengers)": "https://raw.githubusercontent.com/Nixtla/transfer-learning-time-series/main/datasets/air_passengers.csv",
+    "Finance (Exchange USD-EUR)": "https://raw.githubusercontent.com/Nixtla/transfer-learning-time-series/main/datasets/usdeur.csv",
+}
+
+
+@st.cache_data
+def convert_df(df):
+    # IMPORTANT: Cache the conversion to prevent computation on every rerun
+    return df.to_csv(index=False).encode("utf-8")
+
+
+def plot(df, uid, df_forecast, model):
+    figs = []
+    figs += [
+        go.Scatter(
+            x=df["ds"],
+            y=df["y"],
+            mode="lines",
+            marker=dict(color="#236796"),
+            legendrank=1,
+            name=uid,
+        ),
+    ]
+    if df_forecast is not None:
+        ds_f = df_forecast["ds"].to_list()
+        lo = df_forecast["forecast_lo_90"].to_list()
+        hi = df_forecast["forecast_hi_90"].to_list()
+        figs += [
+            go.Scatter(
+                x=ds_f + ds_f[::-1],
+                y=hi + lo[::-1],
+                fill="toself",
+                fillcolor="#E7C4C0",
+                mode="lines",
+                line=dict(color="#E7C4C0"),
+                name="Prediction Intervals (90%)",
+                legendrank=5,
+                opacity=0.5,
+                hoverinfo="skip",
+            ),
+            go.Scatter(
+                x=ds_f,
+                y=df_forecast["forecast"],
+                mode="lines",
+                legendrank=4,
+                marker=dict(color="#E7C4C0"),
+                name=f"Forecast {uid}",
+            ),
+        ]
+    fig = go.Figure(figs)
+    fig.update_layout(
+        {"plot_bgcolor": "rgba(0, 0, 0, 0)", "paper_bgcolor": "rgba(0, 0, 0, 0)"}
+    )
+    fig.update_layout(
+        title=f"Forecasts for {uid} using Transfer Learning (from {model})",
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+        margin=dict(l=20, b=20),
+        xaxis=dict(rangeslider=dict(visible=True)),
+    )
+    initial_range = [df.tail(200)["ds"].iloc[0], ds_f[-1]]
+    fig["layout"]["xaxis"].update(range=initial_range)
+    return fig
+
+
+def st_transfer_learning():
+    st.set_page_config(
+        page_title="Time Series Visualization",
+        page_icon="🔮",
+        layout="wide",
+        initial_sidebar_state="expanded",
+    )
+
+    st.title(
+        "Transfer Learning: Revolutionizing Time Series by Nixtla"
+    )
+    st.write(
+        "<style>div.block-container{padding-top:2rem;}</style>", unsafe_allow_html=True
+    )
+
+    intro = """
+        The success of startups like Open AI and Stability highlights the potential for transfer learning (TL) techniques to have a similar impact on the field of time series forecasting.
+
+        TL can achieve lightning-fast predictions with a fraction of the computational cost by pre-training a flexible model on a large dataset and then using it on another dataset with little to no additional training.
+
+        In this live demo, you can use pre-trained models by Nixtla (trained on the M4 dataset) to predict your own datasets. You can also see how the models perform on unseen example datasets.
+	"""
+    st.write(intro)
+
+    required_cols = ["ds", "y"]
+
+    with st.sidebar.expander("Dataset", expanded=False):
+        data_selection = st.selectbox("Select example dataset", DATASETS.keys())
+        data_url = DATASETS[data_selection]
+        url_json = st.text_input("Data (you can pass your own url here)", data_url)
+        st.write(
+            "You can also upload a CSV file like [this one](https://github.com/Nixtla/transfer-learning-time-series/blob/main/datasets/air_passengers.csv)."
+        )
+
+        uploaded_file = st.file_uploader("Upload CSV")
+        with st.form("Data"):
+
+            if uploaded_file is not None:
+                df = pd.read_csv(uploaded_file)
+                cols = df.columns
+                timestamp_col = st.selectbox("Timestamp column", options=cols)
+                value_col = st.selectbox("Value column", options=cols)
+            else:
+                timestamp_col = st.text_input("Timestamp column", value="timestamp")
+                value_col = st.text_input("Value column", value="value")
+            st.write("You must press Submit each time you want to forecast.")
+            submitted = st.form_submit_button("Submit")
+            if submitted:
+                if uploaded_file is None:
+                    st.write("Please provide a dataframe.")
+                    if url_json.endswith("json"):
+                        df = pd.read_json(url_json)
+                    else:
+                        df = pd.read_csv(url_json)
+                    df = df.rename(
+                        columns=dict(zip([timestamp_col, value_col], required_cols))
+                    )
+                else:
+                    # df = pd.read_csv(uploaded_file)
+                    df = df.rename(
+                        columns=dict(zip([timestamp_col, value_col], required_cols))
+                    )
+            else:
+                if url_json.endswith("json"):
+                    df = pd.read_json(url_json)
+                else:
+                    df = pd.read_csv(url_json)
+                cols = df.columns
+                if "unique_id" in cols:
+                    cols = cols[-2:]
+                df = df.rename(columns=dict(zip(cols, required_cols)))
+
+            if "unique_id" not in df:
+                df.insert(0, "unique_id", "ts_0")
+
+            df["ds"] = pd.to_datetime(df["ds"])
+            df = df.sort_values(["unique_id", "ds"])
+
+    with st.sidebar:
+        st.write("Define the pretrained model you want to use to forecast your data")
+        model_name = st.selectbox("Select your model", tuple(MODELS.keys()))
+        model_file = MODELS[model_name]["model"]
+        st.write("Choose how many steps you want to forecast")
+        fh = st.number_input("Forecast horizon", value=18)
+        st.write(
+            "Choose for how many steps the pretrained model will be updated using your data (use 0 for fast computation)"
+        )
+        max_steps = st.number_input("N-shot inference", value=0)
+
+    # tabs
+    tab_fcst, tab_cv, tab_docs, tab_nixtla = st.tabs(
+        [
+            "📈 Forecast",
+            "🔎 Cross Validation",
+            "📚 Documentation",
+            "🔮 Nixtlaverse",
+        ]
+    )
+
+    uids = df["unique_id"].unique()
+    fcst_cols = ["forecast_lo_90", "forecast", "forecast_hi_90"]
+
+    with tab_fcst:
+        uid = uids[0]#st.selectbox("Dataset", options=uids)
+        col1, col2 = st.columns([2, 4])
+        with col1:
+            tab_insample, tab_forecast = st.tabs(
+                ["Modify input data", "Modify forecasts"]
+            )
+            with tab_insample:
+                df_grid = df.query("unique_id == @uid").drop(columns="unique_id")
+                grid_table = AgGrid(
+                    df_grid,
+                    editable=True,
+                    theme="streamlit",
+                    fit_columns_on_grid_load=True,
+                    height=360,
+                )
+                df.loc[df["unique_id"] == uid, "y"] = (
+                    grid_table["data"].sort_values("ds")["y"].values
+                )
+                # forecast code
+                init = time()
+                df_forecast = forecast_pretrained_model(df, model_file, fh, max_steps)
+                end = time()
+                df_forecast = df_forecast.rename(
+                    columns=dict(zip(["y_5", "y_50", "y_95"], fcst_cols))
+                )
+            with tab_forecast:
+                df_fcst_grid = df_forecast.query("unique_id == @uid").filter(
+                    ["ds", "forecast"]
+                )
+                grid_fcst_table = AgGrid(
+                    df_fcst_grid,
+                    editable=True,
+                    theme="streamlit",
+                    fit_columns_on_grid_load=True,
+                    height=360,
+                )
+                changes = (
+                    df_forecast.query("unique_id == @uid")["forecast"].values
+                    - grid_fcst_table["data"].sort_values("ds")["forecast"].values
+                )
+                for col in fcst_cols:
+                    df_forecast.loc[df_forecast["unique_id"] == uid, col] = (
+                        df_forecast.loc[df_forecast["unique_id"] == uid, col] - changes
+                    )
+        with col2:
+            st.plotly_chart(
+                plot(
+                    df.query("unique_id == @uid"),
+                    uid,
+                    df_forecast.query("unique_id == @uid"),
+                    model_name,
+                ),
+                use_container_width=True,
+            )
+            st.success(f'Done! Approximate inference time CPU: {0.7*(end-init):.2f} seconds.')
+
+    with tab_cv:
+        col_uid, col_n_windows = st.columns(2)
+        uid = uids[0]
+        #with col_uid:
+        #    uid = st.selectbox("Time series to analyse", options=uids, key="uid_cv")
+        with col_n_windows:
+            n_windows = st.number_input("Cross validation windows", value=1)
+        df_forecast = []
+        for i_window in range(n_windows, 0, -1):
+            test = df.groupby("unique_id").tail(i_window * fh)
+            df_forecast_w = forecast_pretrained_model(
+                df.drop(test.index), model_file, fh, max_steps
+            )
+            df_forecast_w = df_forecast_w.rename(
+                columns=dict(zip(["y_5", "y_50", "y_95"], fcst_cols))
+            )
+            df_forecast_w.insert(2, "window", i_window)
+            df_forecast.append(df_forecast_w)
+        df_forecast = pd.concat(df_forecast)
+        df_forecast["ds"] = pd.to_datetime(df_forecast["ds"])
+        df_forecast = df_forecast.merge(df, how="left", on=["unique_id", "ds"])
+        metrics = [mae, mape, rmse, smape]
+        evaluation = df_forecast.groupby(["unique_id", "window"]).apply(
+            lambda df: [f'{fn(df["y"].values, df["forecast"]):.2f}' for fn in metrics]
+        )
+        evaluation = evaluation.rename("eval").reset_index()
+        evaluation["eval"] = evaluation["eval"].str.join(",")
+        evaluation[["MAE", "MAPE", "RMSE", "sMAPE"]] = evaluation["eval"].str.split(
+            ",", expand=True
+        )
+        col_eval, col_plot = st.columns([2, 4])
+        with col_eval:
+            st.write("Evaluation metrics for each cross validation window")
+            st.dataframe(
+                evaluation.query("unique_id == @uid")
+                .drop(columns=["unique_id", "eval"])
+                .set_index("window")
+            )
+        with col_plot:
+            st.plotly_chart(
+                plot(
+                    df.query("unique_id == @uid"),
+                    uid,
+                    df_forecast.query("unique_id == @uid").drop(columns="y"),
+                    model_name,
+                ),
+                use_container_width=True,
+            )
+    with tab_docs:
+        tab_transfer, tab_desc, tab_ref = st.tabs(
+            [
+                "🚀 Transfer Learning",
+                "🔎 Description of the model",
+                "📚 References",
+            ]
+        )
+
+        with tab_desc:
+            model_card_name = MODELS[model_name]["card"]
+            st.subheader("Abstract")
+            st.write(f"""{model_cards[model_card_name]['Abstract']}""")
+            st.subheader("Intended use")
+            st.write(f"""{model_cards[model_card_name]['Intended use']}""")
+            st.subheader("Secondary use")
+            st.write(f"""{model_cards[model_card_name]['Secondary use']}""")
+            st.subheader("Limitations")
+            st.write(f"""{model_cards[model_card_name]['Limitations']}""")
+            st.subheader("Training data")
+            st.write(f"""{model_cards[model_card_name]['Training data']}""")
+            st.subheader("BibTex/Citation Info")
+            st.code(f"""{model_cards[model_card_name]['Citation Info']}""")
+
+        with tab_transfer:
+            transfer_text = """
+                Transfer learning refers to the process of pre-training a flexible model on a large dataset and using it later on other data with little to no training. It is one of the most outstanding 🚀 achievements in Machine Learning 🧠 and has many practical applications.
+
+                For time series forecasting, the technique allows you to get lightning-fast predictions ⚡ bypassing the tradeoff between accuracy and speed.
+
+                [This notebook](https://colab.research.google.com/drive/1uFCO2UBpH-5l2fk3KmxfU0oupsOC6v2n?authuser=0&pli=1#cell-5=) shows how to generate a pre-trained model and store it in a checkpoint to make it available for public use to forecast new time series never seen by the model. 
+                **You can contribute with your pre-trained models by following [this Notebook](https://github.com/Nixtla/transfer-learning-time-series/blob/main/nbs/Transfer_Learning.ipynb) and sending us an email at federico[at]nixtla.io**
+
+                You can also take a look at list of pretrained models here.  Currently we have this ones avaiable in our [API](https://docs.nixtla.io/reference/neural_transfer_neural_transfer_post) or [Demo](http://nixtla.io/transfer-learning/). You can also download the `.ckpt`:
+                - [Pretrained N-HiTS M4 Hourly](https://nixtla-public.s3.amazonaws.com/transfer/pretrained_models/nhits_m4_hourly.ckpt)
+                - [Pretrained N-HiTS M4 Hourly (Tiny)](https://nixtla-public.s3.amazonaws.com/transfer/pretrained_models/nhits_m4_hourly_tiny.ckpt)
+                - [Pretrained N-HiTS M4 Daily](https://nixtla-public.s3.amazonaws.com/transfer/pretrained_models/nhits_m4_daily.ckpt)
+                - [Pretrained N-HiTS M4 Monthly](https://nixtla-public.s3.amazonaws.com/transfer/pretrained_models/nhits_m4_monthly.ckpt)
+                - [Pretrained N-HiTS M4 Yearly](https://nixtla-public.s3.amazonaws.com/transfer/pretrained_models/nhits_m4_yearly.ckpt)
+                - [Pretrained N-BEATS M4 Hourly](https://nixtla-public.s3.amazonaws.com/transfer/pretrained_models/nbeats_m4_hourly.ckpt)
+                - [Pretrained N-BEATS M4 Daily](https://nixtla-public.s3.amazonaws.com/transfer/pretrained_models/nbeats_m4_daily.ckpt)
+                - [Pretrained N-BEATS M4 Weekly](https://nixtla-public.s3.amazonaws.com/transfer/pretrained_models/nbeats_m4_weekly.ckpt)
+                - [Pretrained N-BEATS M4 Monthly](https://nixtla-public.s3.amazonaws.com/transfer/pretrained_models/nbeats_m4_monthly.ckpt)
+                - [Pretrained N-BEATS M4 Yearly](https://nixtla-public.s3.amazonaws.com/transfer/pretrained_models/nbeats_m4_yearly.ckpt)
+                """
+            st.write(transfer_text)
+
+        with tab_ref:
+            ref_text = """
+                If you are interested in the transfer learning literature applied to time series forecasting, take a look at these papers:
+                - [Meta-learning framework with applications to zero-shot time-series forecasting](https://arxiv.org/abs/2002.02887)
+                - [N-HiTS: Neural Hierarchical Interpolation for Time Series Forecasting](https://arxiv.org/abs/2201.12886)
+            """
+            st.write(ref_text)
+
+    with tab_nixtla:
+        nixtla_text = """
+            Nixtla is a startup that is building forecasting software for Data Scientists and Devs.
+
+            We have been developing different open source libraries for machine learning, statistical and deep learning forecasting.
+
+            In our [GitHub repo](https://github.com/Nixtla), you can find the projects that support this APP.
+        """
+        st.write(nixtla_text)
+        st.image(
+            "https://files.readme.io/168cdb2-Screen_Shot_2022-09-30_at_10.40.09.png",
+            width=800,
+        )
+
+    with st.sidebar:
+        st.download_button(
+            label="Download historical data as CSV",
+            data=convert_df(df),
+            file_name="history.csv",
+            mime="text/csv",
+        )
+        st.download_button(
+            label="Download forecasts as CSV",
+            data=convert_df(df_forecast),
+            file_name="forecasts.csv",
+            mime="text/csv",
+        )
+
+
+if __name__ == "__main__":
+    st_transfer_learning()

requirements.txt

@@ -0,0 +1,11 @@
+datasetsforecast
+fire
+neuralforecast<1.0.0
+pandas
+plotly
+python-dotenv
+pytorch-lightning==1.6.3
+statsforecast
+streamlit
+streamlit-aggrid
+torch==1.11.0

src/model_descriptions.py

@@ -0,0 +1,522 @@
+model_cards = dict(
+    nhitsm={
+        "Abstract": (
+            "The N-HiTS_M incorporates hierarchical interpolation and multi-rate data sampling "
+            "techniques. It assembles its predictions sequentially, selectively emphasizing "
+            "components with different frequencies and scales, while decomposing the input signal "
+            " and synthesizing the forecast [Cristian Challu, Kin G. Olivares, Boris N. Oreshkin, "
+            "Federico Garza, Max Mergenthaler-Canseco, Artur Dubrawski. N-HiTS: Neural "
+            "Hierarchical Interpolation for Time Series Forecasting, Submitted working paper.]"
+            "(https://arxiv.org/abs/2201.12886)"
+        ),
+        "Intended use": (
+            "The N-HiTS_M model specializes in monthly long-horizon forecasting by improving "
+            "accuracy and reducing the training time and memory requirements of the model."
+        ),
+        "Secondary use": (
+            "The interpretable predictions of the model produce a natural frequency time "
+            "series signal decomposition."
+        ),
+        "Limitations": (
+            "The transferability across different frequencies has not yet been tested, it is "
+            "advisable to restrict the use of N-HiTS_{M} to monthly data were it was pre-trained. "
+            "This model purely autorregresive, transferability of models with exogenous variables "
+            "is yet to be done."
+        ),
+        "Training data": (
+            "N-HiTS_M was trained on 48,000 monthly series from the M4 competition "
+            "[Spyros  Makridakis,  Evangelos  Spiliotis, and  Vassilios Assimakopoulos. The "
+            " M4  competition: 100,000  time  series and 61 forecasting methods. International "
+            "Journal of Forecasting, 36(1):54–74, 2020. ISSN  0169-2070.]"
+            "(https://www.sciencedirect.com/science/article/pii/S0169207019301128)"
+        ),
+        "Citation Info": (
+            "@article{challu2022nhits,\n "
+            "author    = {Cristian Challu and \n"
+            "              Kin G. Olivares and \n"
+            "              Boris N. Oreshkin and \n"
+            "              Federico Garza and \n"
+            "              Max Mergenthaler and \n"
+            "              Artur Dubrawski}, \n "
+            "title     = {N-HiTS: Neural Hierarchical Interpolation for Time Series Forecasting},\n "
+            "journal   = {Computing Research Repository},\n "
+            "volume    = {abs/2201.12886},\n "
+            "year      = {2022},\n "
+            "url       = {https://arxiv.org/abs/2201.12886},\n "
+            "eprinttype = {arXiv},\n "
+            "eprint    = {2201.12886},\n "
+            "biburl    = {https://dblp.org/rec/journals/corr/abs-2201-12886.bib}\n}"
+        ),
+    },
+    nhitsh={
+        "Abstract": (
+            "The N-HiTS_{H} incorporates hierarchical interpolation and multi-rate data sampling "
+            "techniques. It assembles its predictions sequentially, selectively emphasizing "
+            "components with different frequencies and scales, while decomposing the input signal "
+            " and synthesizing the forecast [Cristian Challu, Kin G. Olivares, Boris N. Oreshkin, "
+            "Federico Garza, Max Mergenthaler-Canseco, Artur Dubrawski. N-HiTS: Neural "
+            "Hierarchical Interpolation for Time Series Forecasting, Submitted working paper.]"
+            "(https://arxiv.org/abs/2201.12886)"
+        ),
+        "Intended use": (
+            "The N-HiTS_{H} model specializes in hourly long-horizon forecasting by improving "
+            "accuracy and reducing the training time and memory requirements of the model."
+        ),
+        "Secondary use": (
+            "The interpretable predictions of the model produce a natural frequency time "
+            "series signal decomposition."
+        ),
+        "Limitations": (
+            "The transferability across different frequencies has not yet been tested, it is "
+            "advisable to restrict the use of N-HiTS_{H} to hourly data were it was pre-trained. "
+            "This model purely autorregresive, transferability of models with exogenous variables "
+            "is yet to be done."
+        ),
+        "Training data": (
+            "N-HiTS_{H} was trained on 414 hourly series from the M4 competition "
+            "[Spyros  Makridakis,  Evangelos  Spiliotis, and  Vassilios Assimakopoulos. The "
+            " M4  competition: 100,000  time  series and 61 forecasting methods. International "
+            "Journal of Forecasting, 36(1):54–74, 2020. ISSN  0169-2070.]"
+            "(https://www.sciencedirect.com/science/article/pii/S0169207019301128)"
+        ),
+        "Citation Info": (
+            "@article{challu2022nhits,\n "
+            "author    = {Cristian Challu and \n"
+            "              Kin G. Olivares and \n"
+            "              Boris N. Oreshkin and \n"
+            "              Federico Garza and \n"
+            "              Max Mergenthaler and \n"
+            "              Artur Dubrawski}, \n "
+            "title     = {N-HiTS: Neural Hierarchical Interpolation for Time Series Forecasting},\n "
+            "journal   = {Computing Research Repository},\n "
+            "volume    = {abs/2201.12886},\n "
+            "year      = {2022},\n "
+            "url       = {https://arxiv.org/abs/2201.12886},\n "
+            "eprinttype = {arXiv},\n "
+            "eprint    = {2201.12886},\n "
+            "biburl    = {https://dblp.org/rec/journals/corr/abs-2201-12886.bib}\n}"
+        ),
+    },
+    nhitsd={
+        "Abstract": (
+            "The N-HiTS_D incorporates hierarchical interpolation and multi-rate data sampling "
+            "techniques. It assembles its predictions sequentially, selectively emphasizing "
+            "components with different frequencies and scales, while decomposing the input signal "
+            " and synthesizing the forecast [Cristian Challu, Kin G. Olivares, Boris N. Oreshkin, "
+            "Federico Garza, Max Mergenthaler-Canseco, Artur Dubrawski. N-HiTS: Neural "
+            "Hierarchical Interpolation for Time Series Forecasting, Submitted working paper.]"
+            "(https://arxiv.org/abs/2201.12886)"
+        ),
+        "Intended use": (
+            "The N-HiTS_D model specializes in daily long-horizon forecasting by improving "
+            "accuracy and reducing the training time and memory requirements of the model."
+        ),
+        "Secondary use": (
+            "The interpretable predictions of the model produce a natural frequency time "
+            "series signal decomposition."
+        ),
+        "Limitations": (
+            "The transferability across different frequencies has not yet been tested, it is "
+            "advisable to restrict the use of N-HiTS_D to daily data were it was pre-trained. "
+            "This model purely autorregresive, transferability of models with exogenous variables "
+            "is yet to be done."
+        ),
+        "Training data": (
+            "N-HiTS_D was trained on 4,227 daily series from the M4 competition "
+            "[Spyros  Makridakis,  Evangelos  Spiliotis, and  Vassilios Assimakopoulos. The "
+            " M4  competition: 100,000  time  series and 61 forecasting methods. International "
+            "Journal of Forecasting, 36(1):54–74, 2020. ISSN  0169-2070.]"
+            "(https://www.sciencedirect.com/science/article/pii/S0169207019301128)"
+        ),
+        "Citation Info": (
+            "@article{challu2022nhits,\n "
+            "author    = {Cristian Challu and \n"
+            "              Kin G. Olivares and \n"
+            "              Boris N. Oreshkin and \n"
+            "              Federico Garza and \n"
+            "              Max Mergenthaler and \n"
+            "              Artur Dubrawski}, \n "
+            "title     = {N-HiTS: Neural Hierarchical Interpolation for Time Series Forecasting},\n "
+            "journal   = {Computing Research Repository},\n "
+            "volume    = {abs/2201.12886},\n "
+            "year      = {2022},\n "
+            "url       = {https://arxiv.org/abs/2201.12886},\n "
+            "eprinttype = {arXiv},\n "
+            "eprint    = {2201.12886},\n "
+            "biburl    = {https://dblp.org/rec/journals/corr/abs-2201-12886.bib}\n}"
+        ),
+    },
+    nhitsy={
+        "Abstract": (
+            "The N-HiTS_Y incorporates hierarchical interpolation and multi-rate data sampling "
+            "techniques. It assembles its predictions sequentially, selectively emphasizing "
+            "components with different frequencies and scales, while decomposing the input signal "
+            " and synthesizing the forecast [Cristian Challu, Kin G. Olivares, Boris N. Oreshkin, "
+            "Federico Garza, Max Mergenthaler-Canseco, Artur Dubrawski. N-HiTS: Neural "
+            "Hierarchical Interpolation for Time Series Forecasting, Submitted working paper.]"
+            "(https://arxiv.org/abs/2201.12886)"
+        ),
+        "Intended use": (
+            "The N-HiTS_Y model specializes in yearly long-horizon forecasting by improving "
+            "accuracy and reducing the training time and memory requirements of the model."
+        ),
+        "Secondary use": (
+            "The interpretable predictions of the model produce a natural frequency time "
+            "series signal decomposition."
+        ),
+        "Limitations": (
+            "The transferability across different frequencies has not yet been tested, it is "
+            "advisable to restrict the use of N-HiTS_Y to yearly data were it was pre-trained. "
+            "This model purely autorregresive, transferability of models with exogenous variables "
+            "is yet to be done."
+        ),
+        "Training data": (
+            "N-HiTS_{H} was trained on 23,000 yearly series from the M4 competition "
+            "[Spyros  Makridakis,  Evangelos  Spiliotis, and  Vassilios Assimakopoulos. The "
+            " M4  competition: 100,000  time  series and 61 forecasting methods. International "
+            "Journal of Forecasting, 36(1):54–74, 2020. ISSN  0169-2070.]"
+            "(https://www.sciencedirect.com/science/article/pii/S0169207019301128)"
+        ),
+        "Citation Info": (
+            "@article{challu2022nhits,\n "
+            "author    = {Cristian Challu and \n"
+            "              Kin G. Olivares and \n"
+            "              Boris N. Oreshkin and \n"
+            "              Federico Garza and \n"
+            "              Max Mergenthaler and \n"
+            "              Artur Dubrawski}, \n "
+            "title     = {N-HiTS: Neural Hierarchical Interpolation for Time Series Forecasting},\n "
+            "journal   = {Computing Research Repository},\n "
+            "volume    = {abs/2201.12886},\n "
+            "year      = {2022},\n "
+            "url       = {https://arxiv.org/abs/2201.12886},\n "
+            "eprinttype = {arXiv},\n "
+            "eprint    = {2201.12886},\n "
+            "biburl    = {https://dblp.org/rec/journals/corr/abs-2201-12886.bib}\n}"
+        ),
+    },
+    nbeatsm={
+        "Abstract": (
+            "The N-BEATS_M models is a model based on a deep stack multi-layer percentrons connected"
+            "with doubly residual connections. The model combines a multi-step forecasting strategy "
+            "with projections unto piecewise functions for its generic version or polynomials and "
+            "harmonics for its interpretable version. [Boris N. Oreshkin, Dmitri Carpov, Nicolas "
+            "Chapados, Yoshua Bengio. N-BEATS: Neural basis expansion analysis for interpretable "
+            "time series forecasting. 8th International Conference on Learning Representations, "
+            "ICLR 2020.](https://arxiv.org/abs/1905.10437)"
+        ),
+        "Intended use": (
+            "The N-BEATS_M is an efficient univariate forecasting model specialized in monthly "
+            "data, that uses the multi-step forecasting strategy."
+        ),
+        "Secondary use": (
+            "The interpretable variant of N-BEATSi_M produces a trend and seasonality "
+            "decomposition."
+        ),
+        "Limitations": (
+            "The transferability across different frequencies has not yet been tested, it is "
+            "advisable to restrict the use of N-BEATS_M to monthly data were it was pre-trained."
+            "This model purely autorregresive, transferability of models with exogenous variables "
+            "is yet to be done."
+        ),
+        "Training data": (
+            "N-BEATS_M was trained on 48,000 monthly series from the M4 competition "
+            "[Spyros  Makridakis,  Evangelos  Spiliotis, and  Vassilios Assimakopoulos. The "
+            " M4  competition: 100,000  time  series and 61 forecasting methods. International "
+            "Journal of Forecasting, 36(1):54–74, 2020. ISSN  0169-2070.]"
+            "(https://www.sciencedirect.com/science/article/pii/S0169207019301128)"
+        ),
+        "Citation Info": (
+            "@inproceedings{oreshkin2020nbeats,\n "
+            "author    = {Boris N. Oreshkin and \n"
+            "              Dmitri Carpov and \n"
+            "              Nicolas Chapados and\n"
+            "              Yoshua Bengio},\n "
+            "title     = {{N-BEATS:} Neural basis expansion analysis for interpretable time series forecasting},\n "
+            "booktitle = {8th International Conference on Learning Representations, {ICLR} 2020},\n "
+            "year      = {2020},\n "
+            "url       = {https://openreview.net/forum?id=r1ecqn4YwB}\n }"
+        ),
+    },
+    nbeatsh={
+        "Abstract": (
+            "The N-BEATS_H models is a model based on a deep stack multi-layer percentrons connected"
+            "with doubly residual connections. The model combines a multi-step forecasting strategy "
+            "with projections unto piecewise functions for its generic version or polynomials and "
+            "harmonics for its interpretable version. [Boris N. Oreshkin, Dmitri Carpov, Nicolas "
+            "Chapados, Yoshua Bengio. N-BEATS: Neural basis expansion analysis for interpretable "
+            "time series forecasting. 8th International Conference on Learning Representations, "
+            "ICLR 2020.](https://arxiv.org/abs/1905.10437)"
+        ),
+        "Intended use": (
+            "The N-BEATS_H is an efficient univariate forecasting model specialized in hourly "
+            "data, that uses the multi-step forecasting strategy."
+        ),
+        "Secondary use": (
+            "The interpretable variant of N-BEATSi_H produces a trend and seasonality "
+            "decomposition."
+        ),
+        "Limitations": (
+            "The transferability across different frequencies has not yet been tested, it is "
+            "advisable to restrict the use of N-BEATS_H to hourly data were it was pre-trained."
+            "This model purely autorregresive, transferability of models with exogenous variables "
+            "is yet to be done."
+        ),
+        "Training data": (
+            "N-BEATS_H was trained on 414 hourly series from the M4 competition "
+            "[Spyros  Makridakis,  Evangelos  Spiliotis, and  Vassilios Assimakopoulos. The "
+            " M4  competition: 100,000  time  series and 61 forecasting methods. International "
+            "Journal of Forecasting, 36(1):54–74, 2020. ISSN  0169-2070.]"
+            "(https://www.sciencedirect.com/science/article/pii/S0169207019301128)"
+        ),
+        "Citation Info": (
+            "@inproceedings{oreshkin2020nbeats,\n "
+            "author    = {Boris N. Oreshkin and \n"
+            "              Dmitri Carpov and \n"
+            "              Nicolas Chapados and\n"
+            "              Yoshua Bengio},\n "
+            "title     = {{N-BEATS:} Neural basis expansion analysis for interpretable time series forecasting},\n "
+            "booktitle = {8th International Conference on Learning Representations, {ICLR} 2020},\n "
+            "year      = {2020},\n "
+            "url       = {https://openreview.net/forum?id=r1ecqn4YwB}\n }"
+        ),
+    },
+    nbeatsd={
+        "Abstract": (
+            "The N-BEATS_D models is a model based on a deep stack multi-layer percentrons connected"
+            "with doubly residual connections. The model combines a multi-step forecasting strategy "
+            "with projections unto piecewise functions for its generic version or polynomials and "
+            "harmonics for its interpretable version. [Boris N. Oreshkin, Dmitri Carpov, Nicolas "
+            "Chapados, Yoshua Bengio. N-BEATS: Neural basis expansion analysis for interpretable "
+            "time series forecasting. 8th International Conference on Learning Representations, "
+            "ICLR 2020.](https://arxiv.org/abs/1905.10437)"
+        ),
+        "Intended use": (
+            "The N-BEATS_D is an efficient univariate forecasting model specialized in hourly "
+            "data, that uses the multi-step forecasting strategy."
+        ),
+        "Secondary use": (
+            "The interpretable variant of N-BEATSi_D produces a trend and seasonality "
+            "decomposition."
+        ),
+        "Limitations": (
+            "The transferability across different frequencies has not yet been tested, it is "
+            "advisable to restrict the use of N-BEATS_D to daily data were it was pre-trained."
+            "This model purely autorregresive, transferability of models with exogenous variables "
+            "is yet to be done."
+        ),
+        "Training data": (
+            "N-BEATS_D was trained on 4,227 daily series from the M4 competition "
+            "[Spyros  Makridakis,  Evangelos  Spiliotis, and  Vassilios Assimakopoulos. The "
+            " M4  competition: 100,000  time  series and 61 forecasting methods. International "
+            "Journal of Forecasting, 36(1):54–74, 2020. ISSN  0169-2070.]"
+            "(https://www.sciencedirect.com/science/article/pii/S0169207019301128)"
+        ),
+        "Citation Info": (
+            "@inproceedings{oreshkin2020nbeats,\n "
+            "author    = {Boris N. Oreshkin and \n"
+            "              Dmitri Carpov and \n"
+            "              Nicolas Chapados and\n"
+            "              Yoshua Bengio},\n "
+            "title     = {{N-BEATS:} Neural basis expansion analysis for interpretable time series forecasting},\n "
+            "booktitle = {8th International Conference on Learning Representations, {ICLR} 2020},\n "
+            "year      = {2020},\n "
+            "url       = {https://openreview.net/forum?id=r1ecqn4YwB}\n }"
+        ),
+    },
+    nbeatsw={
+        "Abstract": (
+            "The N-BEATS_W models is a model based on a deep stack multi-layer percentrons connected"
+            "with doubly residual connections. The model combines a multi-step forecasting strategy "
+            "with projections unto piecewise functions for its generic version or polynomials and "
+            "harmonics for its interpretable version. [Boris N. Oreshkin, Dmitri Carpov, Nicolas "
+            "Chapados, Yoshua Bengio. N-BEATS: Neural basis expansion analysis for interpretable "
+            "time series forecasting. 8th International Conference on Learning Representations, "
+            "ICLR 2020.](https://arxiv.org/abs/1905.10437)"
+        ),
+        "Intended use": (
+            "The N-BEATS_W is an efficient univariate forecasting model specialized in weekly "
+            "data, that uses the multi-step forecasting strategy."
+        ),
+        "Secondary use": (
+            "The interpretable variant of N-BEATSi_W produces a trend and seasonality "
+            "decomposition."
+        ),
+        "Limitations": (
+            "The transferability across different frequencies has not yet been tested, it is "
+            "advisable to restrict the use of N-BEATS_W to weekly data were it was pre-trained."
+            "This model purely autorregresive, transferability of models with exogenous variables "
+            "is yet to be done."
+        ),
+        "Training data": (
+            "N-BEATS_W was trained on 359 weekly series from the M4 competition "
+            "[Spyros  Makridakis,  Evangelos  Spiliotis, and  Vassilios Assimakopoulos. The "
+            " M4  competition: 100,000  time  series and 61 forecasting methods. International "
+            "Journal of Forecasting, 36(1):54–74, 2020. ISSN  0169-2070.]"
+            "(https://www.sciencedirect.com/science/article/pii/S0169207019301128)"
+        ),
+        "Citation Info": (
+            "@inproceedings{oreshkin2020nbeats,\n "
+            "author    = {Boris N. Oreshkin and \n"
+            "              Dmitri Carpov and \n"
+            "              Nicolas Chapados and\n"
+            "              Yoshua Bengio},\n "
+            "title     = {{N-BEATS:} Neural basis expansion analysis for interpretable time series forecasting},\n "
+            "booktitle = {8th International Conference on Learning Representations, {ICLR} 2020},\n "
+            "year      = {2020},\n "
+            "url       = {https://openreview.net/forum?id=r1ecqn4YwB}\n }"
+        ),
+    },
+    nbeatsy={
+        "Abstract": (
+            "The N-BEATS_Y models is a model based on a deep stack multi-layer percentrons connected"
+            "with doubly residual connections. The model combines a multi-step forecasting strategy "
+            "with projections unto piecewise functions for its generic version or polynomials and "
+            "harmonics for its interpretable version. [Boris N. Oreshkin, Dmitri Carpov, Nicolas "
+            "Chapados, Yoshua Bengio. N-BEATS: Neural basis expansion analysis for interpretable "
+            "time series forecasting. 8th International Conference on Learning Representations, "
+            "ICLR 2020.](https://arxiv.org/abs/1905.10437)"
+        ),
+        "Intended use": (
+            "The N-BEATS_Y is an efficient univariate forecasting model specialized in hourly "
+            "data, that uses the multi-step forecasting strategy."
+        ),
+        "Secondary use": (
+            "The interpretable variant of N-BEATSi_Y produces a trend and seasonality "
+            "decomposition."
+        ),
+        "Limitations": (
+            "The transferability across different frequencies has not yet been tested, it is "
+            "advisable to restrict the use of N-BEATS_Y to yearly data were it was pre-trained."
+            "This model purely autorregresive, transferability of models with exogenous variables "
+            "is yet to be done."
+        ),
+        "Training data": (
+            "N-BEATS_Y was trained on 23,000 yearly series from the M4 competition "
+            "[Spyros  Makridakis,  Evangelos  Spiliotis, and  Vassilios Assimakopoulos. The "
+            " M4  competition: 100,000  time  series and 61 forecasting methods. International "
+            "Journal of Forecasting, 36(1):54–74, 2020. ISSN  0169-2070.]"
+            "(https://www.sciencedirect.com/science/article/pii/S0169207019301128)"
+        ),
+        "Citation Info": (
+            "@inproceedings{oreshkin2020nbeats,\n "
+            "author    = {Boris N. Oreshkin and \n"
+            "              Dmitri Carpov and \n"
+            "              Nicolas Chapados and\n"
+            "              Yoshua Bengio},\n "
+            "title     = {{N-BEATS:} Neural basis expansion analysis for interpretable time series forecasting},\n "
+            "booktitle = {8th International Conference on Learning Representations, {ICLR} 2020},\n "
+            "year      = {2020},\n "
+            "url       = {https://openreview.net/forum?id=r1ecqn4YwB}\n }"
+        ),
+    },
+    arima={
+        "Abstract": (
+            "The AutoARIMA model is a classic autoregressive model that automatically explores ARIMA"
+            "models with a step-wise algorithm using Akaike Information Criterion. It applies to "
+            "seasonal and non-seasonal data and has a proven record in the M3 forecasting competition. "
+            "An efficient open-source version of the model was only available in R but is now also "
+            "available in Python. [StatsForecast: Lightning fast forecasting with statistical and "
+            "econometric models](https://github.com/Nixtla/statsforecast)."
+        ),
+        "Intended use": (
+            "The AutoARIMA is an univariate forecasting model, intended to produce automatic "
+            "predictions for large numbers of time series."
+        ),
+        "Secondary use": (
+            "It is a classical model and is an almost obligated forecasting baseline."
+        ),
+        "Limitations": (
+            "ARIMA model uses a recurrent prediction strategy. It concatenates errors on long "
+            "horizon forecasting settings. It is a fairly simple model that does not model "
+            "non-linear relationships."
+        ),
+        "Training data": (
+            "The AutoARIMA is a univariate model that uses only autorregresive data from "
+            "the target variable."
+        ),
+        "Citation Info": (
+            "@article{hyndman2008auto_arima,"
+            "title={Automatic Time Series Forecasting: The forecast Package for R},\n"
+            "author={Hyndman, Rob J. and Khandakar, Yeasmin},\n"
+            "volume={27},\n"
+            "url={https://www.jstatsoft.org/index.php/jss/article/view/v027i03},\n"
+            "doi={10.18637/jss.v027.i03},\n"
+            "number={3},\n"
+            "journal={Journal of Statistical Software},\n"
+            "year={2008},\n"
+            "pages={1–22}\n"
+            "}"
+        ),
+    },
+    exp_smoothing={
+        "Abstract": (
+            "Exponential smoothing is a classic technique using exponential window functions, "
+            "and one of the most successful forecasting methods. It has a long history, the "
+            "name was coined by Charles C. Holt. [Holt, Charles C. (1957). Forecasting Trends "
+            'and Seasonal by Exponentially Weighted Averages". Office of Naval Research '
+            "Memorandum.](https://www.sciencedirect.com/science/article/abs/pii/S0169207003001134)."
+        ),
+        "Intended use": (
+            "Simple variants of exponential smoothing can serve as an efficient baseline method."
+        ),
+        "Secondary use": (
+            "The exponential smoothing method can also act as a low-pass filter removing "
+            "high-frequency noise. "
+        ),
+        "Limitations": (
+            "The method can face limitations if the series show strong discontinuities, or if "
+            "the high-frequency components are an important part of the predicted signal."
+        ),
+        "Training data": (
+            "Just like the ARIMA method, exponential smoothing uses only autorregresive data "
+            " from the target variable."
+        ),
+        "Citation Info": (
+            "@article{holt1957exponential_smoothing, \n"
+            "title = {Forecasting seasonals and trends by exponentially weighted moving averages},\n"
+            "author = {Charles C. Holt},\n"
+            "journal = {International Journal of Forecasting},\n"
+            "volume = {20},\n"
+            "number = {1},\n"
+            "pages = {5-10}\n,"
+            "year = {2004(1957)},\n"
+            "issn = {0169-2070},\n"
+            "doi = {https://doi.org/10.1016/j.ijforecast.2003.09.015},\n"
+            "url = {https://www.sciencedirect.com/science/article/pii/S0169207003001134},\n"
+            "}"
+        ),
+    },
+    prophet={
+        "Abstract": (
+            "Prophet is a widely used forecasting method. Prophet is a nonlinear regression model."
+        ),
+        "Intended use": ("Prophet can serve as a baseline method."),
+        "Secondary use": (
+            "The Prophet model is also useful for time series decomposition."
+        ),
+        "Limitations": (
+            "The method can face limitations if the series show strong discontinuities, or if "
+            "the high-frequency components are an important part of the predicted signal."
+        ),
+        "Training data": (
+            "Just like the ARIMA method and exponential smoothing, Prophet uses only autorregresive data "
+            " from the target variable."
+        ),
+        "Citation Info": (
+            "@article{doi:10.1080/00031305.2017.1380080,\n"
+            "author = {Sean J. Taylor and Benjamin Letham},\n"
+            "title = {Forecasting at Scale},\n"
+            "journal = {The American Statistician},\n"
+            "volume = {72},\n"
+            "number = {1},\n"
+            "pages = {37-45},\n"
+            "year  = {2018},\n"
+            "publisher = {Taylor & Francis},\n"
+            "doi = {10.1080/00031305.2017.1380080},\n"
+            "URL = {https://doi.org/10.1080/00031305.2017.1380080},\n"
+            "eprint = {https://doi.org/10.1080/00031305.2017.1380080},\n"
+            "}"
+        ),
+    },
+)

src/nf.py

@@ -0,0 +1,211 @@
+from itertools import chain
+from pathlib import Path
+from typing import List, Optional
+
+import neuralforecast as nf
+import numpy as np
+import pandas as pd
+import pytorch_lightning as pl
+from datasetsforecast.utils import download_file
+from hyperopt import hp
+from neuralforecast.auto import NHITS as autoNHITS
+from neuralforecast.data.tsdataset import WindowsDataset
+from neuralforecast.data.tsloader import TimeSeriesLoader
+from neuralforecast.models.mqnhits.mqnhits import MQNHITS
+from neuralforecast.models.nhits.nhits import NHITS
+
+# GLOBAL PARAMETERS
+DEFAULT_HORIZON = 30
+HYPEROPT_STEPS = 10
+MAX_STEPS = 1000
+N_TS_VAL = 2 * 30
+
+MODELS = {
+    "Pretrained N-HiTS M4 Hourly": {
+        "card": "nhitsh",
+        "max_steps": 0,
+        "model": "nhits_m4_hourly",
+    },
+    "Pretrained N-HiTS M4 Hourly (Tiny)": {
+        "card": "nhitsh",
+        "max_steps": 0,
+        "model": "nhits_m4_hourly_tiny",
+    },
+    "Pretrained N-HiTS M4 Daily": {
+        "card": "nhitsd",
+        "max_steps": 0,
+        "model": "nhits_m4_daily",
+    },
+    "Pretrained N-HiTS M4 Monthly": {
+        "card": "nhitsm",
+        "max_steps": 0,
+        "model": "nhits_m4_monthly",
+    },
+    "Pretrained N-HiTS M4 Yearly": {
+        "card": "nhitsy",
+        "max_steps": 0,
+        "model": "nhits_m4_yearly",
+    },
+    "Pretrained N-BEATS M4 Hourly": {
+        "card": "nbeatsh",
+        "max_steps": 0,
+        "model": "nbeats_m4_hourly",
+    },
+    "Pretrained N-BEATS M4 Daily": {
+        "card": "nbeatsd",
+        "max_steps": 0,
+        "model": "nbeats_m4_daily",
+    },
+    "Pretrained N-BEATS M4 Weekly": {
+        "card": "nbeatsw",
+        "max_steps": 0,
+        "model": "nbeats_m4_weekly",
+    },
+    "Pretrained N-BEATS M4 Monthly": {
+        "card": "nbeatsm",
+        "max_steps": 0,
+        "model": "nbeats_m4_monthly",
+    },
+    "Pretrained N-BEATS M4 Yearly": {
+        "card": "nbeatsy",
+        "max_steps": 0,
+        "model": "nbeats_m4_yearly",
+    },
+}
+
+
+def download_models():
+    for _, meta in MODELS.items():
+        if not Path(f'./models/{meta["model"]}.ckpt').is_file():
+            download_file(
+                "./models/",
+                f'https://nixtla-public.s3.amazonaws.com/transfer/pretrained_models/{meta["model"]}.ckpt',
+            )
+
+
+download_models()
+
+
+class StandardScaler:
+    """This class helps to standardize a dataframe with multiple time series."""
+
+    def __init__(self):
+        self.norm: pd.DataFrame
+
+    def fit(self, X: pd.DataFrame) -> "StandardScaler":
+        self.norm = X.groupby("unique_id").agg({"y": [np.mean, np.std]})
+        self.norm = self.norm.droplevel(0, 1).reset_index()
+
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        transformed = X.merge(self.norm, how="left", on=["unique_id"])
+        transformed["y"] = (transformed["y"] - transformed["mean"]) / transformed["std"]
+        return transformed[["unique_id", "ds", "y"]]
+
+    def inverse_transform(self, X: pd.DataFrame, cols: List[str]) -> pd.DataFrame:
+        transformed = X.merge(self.norm, how="left", on=["unique_id"])
+        for col in cols:
+            transformed[col] = (
+                transformed[col] * transformed["std"] + transformed["mean"]
+            )
+        return transformed[["unique_id", "ds"] + cols]
+
+
+def compute_ds_future(Y_df, fh):
+    if Y_df["unique_id"].nunique() == 1:
+        ds_ = pd.to_datetime(Y_df["ds"].values)
+        try:
+            freq = pd.infer_freq(ds_)
+        except:
+            freq = None
+        if freq is not None:
+            ds_future = pd.date_range(ds_[-1], periods=fh + 1, freq=freq)[1:]
+        else:
+            freq = ds_[-1] - ds_[-2]
+            ds_future = [ds_[-1] + (i + 1) * freq for i in range(fh)]
+        ds_future = list(map(str, ds_future))
+        return ds_future
+    else:
+        ds_future = chain(
+            *[compute_ds_future(df, fh) for _, df in Y_df.groupby("unique_id")]
+        )
+        return list(ds_future)
+
+
+def forecast_pretrained_model(
+    Y_df: pd.DataFrame, model: str, fh: int, max_steps: int = 0
+):
+    if "unique_id" not in Y_df:
+        Y_df.insert(0, "unique_id", "ts_1")
+
+    scaler = StandardScaler()
+    scaler.fit(Y_df)
+    Y_df = scaler.transform(Y_df)
+
+    # Model
+    file_ = f"./models/{model}.ckpt"
+    mqnhits = MQNHITS.load_from_checkpoint(file_)
+
+    # Fit
+    if max_steps > 0:
+        train_dataset = WindowsDataset(
+            Y_df=Y_df,
+            X_df=None,
+            S_df=None,
+            mask_df=None,
+            f_cols=[],
+            input_size=mqnhits.n_time_in,
+            output_size=mqnhits.n_time_out,
+            sample_freq=1,
+            complete_windows=True,
+            verbose=False,
+        )
+
+        train_loader = TimeSeriesLoader(
+            dataset=train_dataset, batch_size=1, n_windows=32, shuffle=True
+        )
+
+        trainer = pl.Trainer(
+            max_epochs=None,
+            checkpoint_callback=False,
+            logger=False,
+            max_steps=max_steps,
+            gradient_clip_val=1.0,
+            progress_bar_refresh_rate=1,
+            log_every_n_steps=1,
+        )
+
+        trainer.fit(mqnhits, train_loader)
+
+    # Forecast
+    forecast_df = mqnhits.forecast(Y_df=Y_df)
+    forecast_df = scaler.inverse_transform(forecast_df, cols=["y_5", "y_50", "y_95"])
+
+    # Foreoast
+    n_ts = forecast_df["unique_id"].nunique()
+    if fh * n_ts > len(forecast_df):
+        forecast_df = (
+            forecast_df.groupby("unique_id")
+            .apply(lambda df: pd.concat([df] * fh).head(fh))
+            .reset_index(drop=True)
+        )
+    else:
+        forecast_df = forecast_df.groupby("unique_id").head(fh)
+    forecast_df["ds"] = compute_ds_future(Y_df, fh)
+
+    return forecast_df
+
+
+if __name__ == "__main__":
+    df = pd.read_csv(
+        "https://raw.githubusercontent.com/Nixtla/transfer-learning-time-series/main/datasets/ercot_COAST.csv"
+    )
+    df.columns = ["ds", "y"]
+    multi_df = pd.concat([df.assign(unique_id=f"ts{i}") for i in range(2)])
+    assert len(compute_ds_future(multi_df, 80)) == 2 * 80
+    for _, meta in MODELS.items():
+        # test just a time series (without unique_id)
+        forecast = forecast_pretrained_model(df, model=meta["model"], fh=80)
+        assert forecast.shape == (80, 5)
+        # test multiple time series
+        multi_forecast = forecast_pretrained_model(multi_df, model=meta["model"], fh=80)
+        assert multi_forecast.shape == (80 * 2, 5)

src/st_deploy.py

@@ -0,0 +1,16 @@
+import os
+import sys
+
+from streamlit.web import cli
+
+if __name__ == "__main__":
+    sys.argv = [
+        "streamlit",
+        "run",
+        f"{os.path.dirname(os.path.realpath(__file__))}/st_app.py",
+        "--server.port=8501",
+        "--server.address=0.0.0.0",
+        "--server.baseUrlPath=transfer-learning",
+        "--logger.level=debug",
+    ]
+    sys.exit(cli.main())