app.py

import os

import numpy as np
import pandas as pd
import pinecone
import streamlit as st

from src.utils import (
    tsfeatures_vector, get_closest_ids, 
    plot_best_models_count, plot_closest_series,
    get_catalogue
)

CATALOGUE = get_catalogue()
pinecone.init(
    api_key=os.environ['API_KEY'],
    environment=os.environ['ENVIRONMENT'],
)
INDEX = pinecone.Index(os.environ['INDEX_NAME'])
DATASETS = {
    "Demand (AirPassengers)": "https://raw.githubusercontent.com/Nixtla/transfer-learning-time-series/main/datasets/air_passengers.csv",
    "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",
    "Finance (Exchange USD-EUR)": "https://raw.githubusercontent.com/Nixtla/transfer-learning-time-series/main/datasets/usdeur.csv",
}



def st_timenet_features():
    st.set_page_config(
        page_title="TimeNet Insights",
        page_icon="🔮",
        layout="wide",
        initial_sidebar_state="expanded",
    )

    st.title(
        "TimeNet Insights: Revolutionizing Time Series by Nixtla"
    )
    st.write(
        "<style>div.block-container{padding-top:2rem;}</style>", unsafe_allow_html=True
    )

    intro = """
    This tool is designed to perform time series analysis through comparative studies with the TimeNet dataset, curated by Nixtla.

    Beyond simply identifying the most similar series within our dataset to your uploaded data, this application provides insights into your time series, especially in terms of forecasting model performance.

    This app allows you to determine which predictive models might perform optimally for your particular data. The comparison between your series and similar ones within the TimeNet dataset can enhance your understanding of the context of your time series and facilitate better-informed forecasting decisions.
	"""
    st.write(intro)

    required_cols = ["ds", "y"]

    with st.sidebar.expander("Dataset", expanded=True):
        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:
        seasonality = st.number_input("Seasonality of your data:", value=1)
        top_k = st.number_input('Number of closest series:', value=12)
    
    y_vector_feats = tsfeatures_vector(df.tail(100), seasonality)
    closest_ids = get_closest_ids(y_vector_feats, top_k, INDEX)
    st.header('Closest match from TimeNet')
    st.write(
        """
        This side-by-side plot visualizes your uploaded time series (left) and its closest match from the TimeNet dataset (right). 

        By comparing these two plots, you can see how your data's behavior aligns with the most similar series in the TimeNet dataset. Similarities in trends, cycles, or patterns can indicate shared underlying structures or influences between your series and the TimeNet series.
        """

    )
    st.pyplot(
        plot_closest_series(df, closest_ids[0]['id'], CATALOGUE)
    )
    st.header('Potential winner models')
    st.write(
        """
        This plot showcases the "win rate" of various predictive models. 
        Each model's win rate is based on how frequently it outperforms others when used to forecast the closest series to your own data.

        This visualization allows you to compare the effectiveness of different models and identify which ones are more likely to provide accurate forecasts for your data.
        """
    )
    st.pyplot(
        plot_best_models_count(closest_ids, CATALOGUE)
    )

if __name__ == "__main__":
    st_timenet_features()