Update app.py

app.py

@@ -1,374 +1,372 @@
-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()
+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 Forecasting",
+        page_icon="🔮",
+        layout="wide",
+        initial_sidebar_state="expanded",
+    )
+
+    st.title(
+        "Transfer Learning: Revolutionizing Time Series"
+    )
+    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 = st.tabs(
+        [
+            "📈 Forecast",
+            "🔎 Cross Validation",
+            "📚 Documentation",
+        ]
+    )
+
+    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 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_dummy:
+    #     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()