Update app.py

app.py

@@ -15,655 +15,96 @@ st.set_page_config(layout='wide')
     
 @st.cache_resource
 def load_model(path, freq):
-    nf = NeuralForecast.load(path=path)
-    return nf
+    return NeuralForecast.load(path=path)
 
 @st.cache_resource
 def load_all_models():
-    nhits_paths = {
-        'D': './M4/NHITS/daily',
-        'M': './M4/NHITS/monthly',
-        'H': './M4/NHITS/hourly',
-        'W': './M4/NHITS/weekly',
-        'Y': './M4/NHITS/yearly'
-    }
-    
-    timesnet_paths = {
-        'D': './M4/TimesNet/daily',
-        'M': './M4/TimesNet/monthly',
-        'H': './M4/TimesNet/hourly',
-        'W': './M4/TimesNet/weekly',
-        'Y': './M4/TimesNet/yearly'
+    model_paths = {
+        'D': './M4/{model}/daily',
+        'M': './M4/{model}/monthly',
+        'H': './M4/{model}/hourly',
+        'W': './M4/{model}/weekly',
+        'Y': './M4/{model}/yearly'
     }
     
-    lstm_paths = {
-        'D': './M4/LSTM/daily',
-        'M': './M4/LSTM/monthly',
-        'H': './M4/LSTM/hourly',
-        'W': './M4/LSTM/weekly',
-        'Y': './M4/LSTM/yearly'
-    }
-    
-    tft_paths = {
-        'D': './M4/TFT/daily',
-        'M': './M4/TFT/monthly',
-        'H': './M4/TFT/hourly',
-        'W': './M4/TFT/weekly',
-        'Y': './M4/TFT/yearly'
-    }
-    nhits_models = {freq: load_model(path, freq) for freq, path in nhits_paths.items()}
-    timesnet_models = {freq: load_model(path, freq) for freq, path in timesnet_paths.items()}
-    lstm_models = {freq: load_model(path, freq) for freq, path in lstm_paths.items()}
-    tft_models = {freq: load_model(path, freq) for freq, path in tft_paths.items()}
+    models = ['NHITS', 'TimesNet', 'LSTM', 'TFT']
+    all_models = {model: {freq: load_model(model_paths[freq].format(model=model), freq) for freq in model_paths} for model in models}
+    return all_models
 
-    return nhits_models, timesnet_models, lstm_models, tft_models
-
-def generate_forecast(model, df,tag=False):
-    if tag == 'retrain':
-        forecast_df = model.predict()
-    else:
-        forecast_df = model.predict(df=df)
-    return forecast_df
+def generate_forecast(model, df, tag=False):
+    return model.predict() if tag == 'retrain' else model.predict(df=df)
 
 def determine_frequency(df):
-    df['ds'] = pd.to_datetime(df['ds'])
-    df = df.drop_duplicates(subset='ds')
-    df = df.set_index('ds')
-    
-    # # Create a complete date range
-    # full_range = pd.date_range(start=df.index.min(), end=df.index.max(),freq=freq)
-    
-    # # Reindex the DataFrame to this full date range
-    # df_full = df.reindex(full_range)
-    
-    # Infer the frequency
-    # freq = pd.infer_freq(df_full.index)
-
-    freq = pd.infer_freq(df.index)
+    df['ds'] = pd.to_datetime(df['ds']).drop_duplicates().set_index('ds')
+    freq = pd.infer_freq(df.index) or 'D'
     if not freq:
-        st.warning('The forecast will use default Daily forecast due to date inconsistency. Please check your data.',icon="⚠️")
-        freq = 'D'
-        
+        st.warning('Default Daily forecast due to date inconsistency.')
     return freq
 
-def plot_forecasts_matplotlib(forecast_df, train_df, title):
-    fig, ax = plt.subplots(1, 1, figsize=(20, 7))
-    plot_df = pd.concat([train_df, forecast_df]).set_index('ds')
-    historical_col = 'y'
-    forecast_col = next((col for col in plot_df.columns if 'median' in col), None)
-    lo_col = next((col for col in plot_df.columns if 'lo-90' in col), None)
-    hi_col = next((col for col in plot_df.columns if 'hi-90' in col), None)
-    if forecast_col is None:
-        raise KeyError("No forecast column found in the data.")
-    plot_df[[historical_col, forecast_col]].plot(ax=ax, linewidth=2, label=['Historical', 'Forecast'])
-    if lo_col and hi_col:
-        ax.fill_between(
-            plot_df.index,
-            plot_df[lo_col],
-            plot_df[hi_col],
-            color='blue',
-            alpha=0.3,
-            label='90% Confidence Interval'
-        )
-    ax.set_title(title, fontsize=22)
-    ax.set_ylabel('Value', fontsize=20)
-    ax.set_xlabel('Timestamp [t]', fontsize=20)
-    ax.legend(prop={'size': 15})
-    ax.grid()
-    st.pyplot(fig)
-
-import plotly.graph_objects as go
-
 def plot_forecasts(forecast_df, train_df, title):
-    # Combine historical and forecast data
     plot_df = pd.concat([train_df, forecast_df]).set_index('ds')
-    
-    # Find relevant columns
     historical_col = 'y'
     forecast_col = next((col for col in plot_df.columns if 'median' in col), None)
     lo_col = next((col for col in plot_df.columns if 'lo-90' in col), None)
     hi_col = next((col for col in plot_df.columns if 'hi-90' in col), None)
     
-    if forecast_col is None:
-        raise KeyError("No forecast column found in the data.")
-    
-    # Create Plotly figure
-    fig = go.Figure()
-    
-    # Add historical data
-    fig.add_trace(go.Scatter(x=plot_df.index, y=plot_df[historical_col], mode='lines', name='Historical'))
-    
-    # Add forecast data
-    fig.add_trace(go.Scatter(x=plot_df.index, y=plot_df[forecast_col], mode='lines', name='Forecast'))
-    
-    # Add confidence interval if available
-    if lo_col and hi_col:
-        fig.add_trace(go.Scatter(
-            x=plot_df.index,
-            y=plot_df[hi_col],
-            mode='lines',
-            line=dict(color='rgba(0,100,80,0.2)'),
-            showlegend=False
-        ))
-        fig.add_trace(go.Scatter(
-            x=plot_df.index,
-            y=plot_df[lo_col],
-            mode='lines',
-            line=dict(color='rgba(0,100,80,0.2)'),
-            fill='tonexty',
-            fillcolor='rgba(0,100,80,0.2)',
-            name='90% Confidence Interval'
-        ))
-    
-    # Update layout
-    fig.update_layout(
-        title=title,
-        xaxis_title='Timestamp [t]',
-        yaxis_title='Value',
-        template='plotly_white'
-    )
-    
-    # Display the plot
-    st.plotly_chart(fig)
+    if forecast_col:
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(x=plot_df.index, y=plot_df[historical_col], mode='lines', name='Historical'))
+        fig.add_trace(go.Scatter(x=plot_df.index, y=plot_df[forecast_col], mode='lines', name='Forecast'))
+        if lo_col and hi_col:
+            fig.add_trace(go.Scatter(x=plot_df.index, y=plot_df[hi_col], mode='lines', line=dict(color='rgba(0,100,80,0.2)'), showlegend=False))
+            fig.add_trace(go.Scatter(x=plot_df.index, y=plot_df[lo_col], mode='lines', fill='tonexty', fillcolor='rgba(0,100,80,0.2)', name='90% Confidence Interval'))
+        fig.update_layout(title=title, xaxis_title='Timestamp', yaxis_title='Value', template='plotly_white')
+        st.plotly_chart(fig)
 
+def select_model_based_on_frequency(freq, models):
+    return {model: models[model][freq] for model in models}
 
-def select_model_based_on_frequency(freq, nhits_models, timesnet_models, lstm_models, tft_models):
-    if freq == 'D':
-        return nhits_models['D'], timesnet_models['D'], lstm_models['D'], tft_models['D']
-    elif freq == 'ME':
-        return nhits_models['M'], timesnet_models['M'], lstm_models['M'], tft_models['M']
-    elif freq == 'H':
-        return nhits_models['H'], timesnet_models['H'], lstm_models['H'], tft_models['H']
-    elif freq in ['W', 'W-SUN']:
-        return nhits_models['W'], timesnet_models['W'], lstm_models['W'], tft_models['W']
-    elif freq in ['Y', 'Y-DEC']:
-        return nhits_models['Y'], timesnet_models['Y'], lstm_models['Y'], tft_models['Y']
-    else:
-        raise ValueError(f"Unsupported frequency: {freq}")
-
-def select_model(horizon, model_type, max_steps=50):
-    if model_type == 'NHITS':
-        return NHITS(input_size=5 * horizon,
-                     h=horizon,
-                     max_steps=max_steps,
-                     stack_types=3*['identity'],
-                     n_blocks=3*[1],
-                     mlp_units=[[256, 256] for _ in range(3)],
-                     n_pool_kernel_size=3*[1],
-                     batch_size=32,
-                     scaler_type='standard',
-                     n_freq_downsample=[12, 4, 1],
-                     loss=HuberMQLoss(level=[90]))
-    elif model_type == 'TimesNet':
-        return TimesNet(h=horizon,
-                        input_size=horizon * 5,
-                        hidden_size=32,
-                        conv_hidden_size=64,
-                        loss=HuberMQLoss(level=[90]),
-                        scaler_type='standard',
-                        learning_rate=1e-3,
-                        max_steps=max_steps,
-                        val_check_steps=200,
-                        valid_batch_size=64,
-                        windows_batch_size=128,
-                        inference_windows_batch_size=512)
-    elif model_type == 'LSTM':
-        return LSTM(h=horizon,
-                    input_size=horizon * 5,
-                    loss=HuberMQLoss(level=[90]),
-                    scaler_type='standard',
-                    encoder_n_layers=3,
-                    encoder_hidden_size=256,
-                    context_size=10,
-                    decoder_hidden_size=256,
-                    decoder_layers=3,
-                    max_steps=max_steps)
-    elif model_type == 'TFT':
-        return TFT(h=horizon,
-                   input_size=horizon*5,
-                   hidden_size=96,
-                   loss=HuberMQLoss(level=[90]),
-                   learning_rate=0.005,
-                   scaler_type='standard',
-                   windows_batch_size=128,
-                   max_steps=max_steps,
-                   val_check_steps=200,
-                   valid_batch_size=64,
-                   enable_progress_bar=True)
-    else:
-        raise ValueError(f"Unsupported model type: {model_type}")
-
-def model_train(df,model, freq):
+def model_train(df, model, freq):
     nf = NeuralForecast(models=[model], freq=freq)
     df['ds'] = pd.to_datetime(df['ds'])
     nf.fit(df)
     return nf
 
-def forecast_time_series(df, model_type, horizon, max_steps,y_col):
-    start_time = time.time()  # Start timing
+def forecast_time_series(df, model_type, horizon, max_steps, y_col):
     freq = determine_frequency(df)
     st.sidebar.write(f"Data frequency: {freq}")
     
     selected_model = select_model(horizon, model_type, max_steps)
-    st.spinner(f"Training {model_type} model...")
-    model = model_train(df, selected_model,freq)
+    model = model_train(df, selected_model, freq)
     
-    forecast_results = {}
-    forecast_results[model_type] = generate_forecast(model, df, tag='retrain')
-
+    forecast_results = generate_forecast(model, df, tag='retrain')
     st.session_state.forecast_results = forecast_results
     
-    for model_name, forecast_df in forecast_results.items():
-        plot_forecasts(forecast_df, df, f'{model_name} Forecast for {y_col}')
-        
-    end_time = time.time()  # End timing
-    time_taken = end_time - start_time
-    st.success(f"Time taken for {model_type} forecast: {time_taken:.2f} seconds")
-    if 'forecast_results' in st.session_state:
-        forecast_results = st.session_state.forecast_results
-
-        st.markdown('You can download Input and Forecast Data below')
-        tab_insample, tab_forecast  = st.tabs(
-                        ["Input data", "Forecast"]
-                    )
-            
-        with tab_insample:
-            df_grid = df.drop(columns="unique_id")
-            st.write(df_grid)
-            # grid_table = AgGrid(
-            #                 df_grid,
-            #                 theme="alpine",
-            #             )
-    
-        with tab_forecast:
-            if model_type in forecast_results:
-                df_grid = forecast_results[model_type]
-                st.write(df_grid)
-                # grid_table = AgGrid(
-                #                 df_grid,
-                #                 theme="alpine",
-                #             )
+    plot_forecasts(forecast_results.iloc[:horizon,:], df, f'{model_type} Forecast for {y_col}')
 
 @st.cache_data
 def load_default():
-    df = AirPassengersDF.copy()
-    return df
+    return AirPassengersDF.copy()
 
 def transfer_learning_forecasting():
     st.title("Zero-shot Forecasting")
-    st.markdown("""
-    Instant time series forecasting and visualization by using various pre-trained deep neural network-based model trained on M4 data.
-    """)
-
-    nhits_models, timesnet_models, lstm_models, tft_models = load_all_models()
-    
-    with st.sidebar.expander("Upload and Configure Dataset", expanded=True):
-        if 'uploaded_file' not in st.session_state:
-            uploaded_file = st.file_uploader("Upload your time series data (CSV)", type=["csv"])
-            if uploaded_file:
-                df = pd.read_csv(uploaded_file)
-                st.session_state.df = df
-                st.session_state.uploaded_file = uploaded_file
-            else:
-                df = load_default()
-                st.session_state.df = df
-        else:
-            if st.checkbox("Upload a new file (CSV)"):
-                uploaded_file = st.file_uploader("Upload your time series data (CSV)", type=["csv"])
-                if uploaded_file:
-                    df = pd.read_csv(uploaded_file)
-                    st.session_state.df = df
-                    st.session_state.uploaded_file = uploaded_file
-                else:
-                    df = st.session_state.df
-            else:
-                df = st.session_state.df
-
-        columns = df.columns.tolist()
-        ds_col = st.selectbox("Select Date/Time column", options=columns, index=columns.index('ds') if 'ds' in columns else 0)
-        target_columns = [col for col in columns if (col != ds_col) and (col != 'unique_id')]
-        y_col = st.selectbox("Select Target column", options=target_columns, index=0)
-
-        st.session_state.ds_col = ds_col
-        st.session_state.y_col = y_col
-
-    # Model selection and forecasting
-    st.sidebar.subheader("Model Selection and Forecasting")
-    model_choice = st.sidebar.selectbox("Select model", ["NHITS", "TimesNet", "LSTM", "TFT"])
-    horizon = st.sidebar.number_input("Forecast horizon", value=12)
-
-    df = df.rename(columns={ds_col: 'ds', y_col: 'y'})
-    df['unique_id']=1
-    df = df[['unique_id','ds','y']]
-
-    # Determine frequency of data
-    frequency = determine_frequency(df)
-    st.sidebar.write(f"Detected frequency: {frequency}")
-
-
-    nhits_model, timesnet_model, lstm_model, tft_model = select_model_based_on_frequency(frequency, nhits_models, timesnet_models, lstm_models, tft_models)
-    forecast_results = {}
-
-    
-
-    if st.sidebar.button("Submit"):
-        start_time = time.time()  # Start timing
-        if model_choice == "NHITS":
-            forecast_results['NHITS'] = generate_forecast(nhits_model, df)
-        elif model_choice == "TimesNet":
-            forecast_results['TimesNet'] = generate_forecast(timesnet_model, df)
-        elif model_choice == "LSTM":
-            forecast_results['LSTM'] = generate_forecast(lstm_model, df)
-        elif model_choice == "TFT":
-            forecast_results['TFT'] = generate_forecast(tft_model, df)
-
-        st.session_state.forecast_results = forecast_results
-        for model_name, forecast_df in forecast_results.items():
-            plot_forecasts(forecast_df.iloc[:horizon,:], df, f'{model_name} Forecast for {y_col}')
-
-        end_time = time.time()  # End timing
-        time_taken = end_time - start_time
-        st.success(f"Time taken for {model_choice} forecast: {time_taken:.2f} seconds")
-
-        if 'forecast_results' in st.session_state:
-            forecast_results = st.session_state.forecast_results
-    
-            st.markdown('You can download Input and Forecast Data below')
-            tab_insample, tab_forecast  = st.tabs(
-                            ["Input data", "Forecast"]
-                        )
-                
-            with tab_insample:
-                df_grid = df.drop(columns="unique_id")
-                st.write(df_grid)
-                # grid_table = AgGrid(
-                #                 df_grid,
-                #                 theme="alpine",
-                #             )
-        
-            with tab_forecast:
-                if model_choice in forecast_results:
-                    df_grid = forecast_results[model_choice]
-                    st.write(df_grid)
-                    # grid_table = AgGrid(
-                    #                 df_grid,
-                    #                 theme="alpine",
-                    #             )
-
-
-def dynamic_forecasting():
-    st.title("Personalized Neural Forecasting")
-    st.markdown("""
-    Train time series forecasting model from scratch and provide forecasts/visualization by using various deep neural network-based model trained on user data.
-    
-    Forecasting speed depends on CPU/GPU availabilty.
-    """)
-    
-    with st.sidebar.expander("Upload and Configure Dataset", expanded=True):
-        if 'uploaded_file' not in st.session_state:
-            uploaded_file = st.file_uploader("Upload your time series data (CSV)", type=["csv"])
-            if uploaded_file:
-                df = pd.read_csv(uploaded_file)
-                st.session_state.df = df
-                st.session_state.uploaded_file = uploaded_file
-            else:
-                df = load_default()
-                st.session_state.df = df
-        else:
-            if st.checkbox("Upload a new file (CSV)"):
-                uploaded_file = st.file_uploader("Upload your time series data (CSV)", type=["csv"])
-                if uploaded_file:
-                    df = pd.read_csv(uploaded_file)
-                    st.session_state.df = df
-                    st.session_state.uploaded_file = uploaded_file
-                else:
-                    df = st.session_state.df
-            else:
-                df = st.session_state.df
-
-        columns = df.columns.tolist()
-        ds_col = st.selectbox("Select Date/Time column", options=columns, index=columns.index('ds') if 'ds' in columns else 0)
-        target_columns = [col for col in columns if (col != ds_col) and (col != 'unique_id')]
-        y_col = st.selectbox("Select Target column", options=target_columns, index=0)
-
-        st.session_state.ds_col = ds_col
-        st.session_state.y_col = y_col
-
-    df = df.rename(columns={ds_col: 'ds', y_col: 'y'})
-    
-    df['unique_id']=1
-    df = df[['unique_id','ds','y']]
-    
-
-    # Dynamic forecasting
-    st.sidebar.subheader("Dynamic Model Selection and Forecasting")
-    dynamic_model_choice = st.sidebar.selectbox("Select model for dynamic forecasting", ["NHITS", "TimesNet", "LSTM", "TFT"], key="dynamic_model_choice")
-    dynamic_horizon = st.sidebar.number_input("Forecast horizon", value=12)
-    dynamic_max_steps = st.sidebar.number_input('Max steps', value=20)
-
-    if st.sidebar.button("Submit"):
-        with st.spinner('Training model. This may take few minutes...'):
-            forecast_time_series(df, dynamic_model_choice, dynamic_horizon, dynamic_max_steps,y_col)
-
-def timegpt_fcst():
-    nixtla_token = os.environ.get("NIXTLA_API_KEY")
-    nixtla_client = NixtlaClient(
-    api_key = nixtla_token
-    )
-
-    
-    st.title("TimeGPT Forecasting")
-    st.markdown("""
-    Instant time series forecasting and visualization by using the TimeGPT API provided by Nixtla.
-    """)
-    with st.sidebar.expander("Upload and Configure Dataset", expanded=True):
-        if 'uploaded_file' not in st.session_state:
-            uploaded_file = st.file_uploader("Upload your time series data (CSV)", type=["csv"])
-            if uploaded_file:
-                df = pd.read_csv(uploaded_file)
-                st.session_state.df = df
-                st.session_state.uploaded_file = uploaded_file
-            else:
-                df = load_default()
-                st.session_state.df = df
-        else:
-            if st.checkbox("Upload a new file (CSV)"):
-                uploaded_file = st.file_uploader("Upload your time series data (CSV)", type=["csv"])
-                if uploaded_file:
-                    df = pd.read_csv(uploaded_file)
-                    st.session_state.df = df
-                    st.session_state.uploaded_file = uploaded_file
-                else:
-                    df = st.session_state.df
-            else:
-                df = st.session_state.df
-
-        columns = df.columns.tolist()
-        ds_col = st.selectbox("Select Date/Time column", options=columns, index=columns.index('ds') if 'ds' in columns else 0)
-        target_columns = [col for col in columns if (col != ds_col) and (col != 'unique_id')]
-        y_col = st.selectbox("Select Target column", options=target_columns, index=0)
-        h = st.number_input("Forecast horizon", value=14)
-
-        df = df.rename(columns={ds_col: 'ds', y_col: 'y'})
-
-        
-        id_col = 'ts_test'
-        df['unique_id']=id_col
-        df = df[['unique_id','ds','y']]
-        
-
-    freq = determine_frequency(df)
-
-    df = df.drop_duplicates(subset=['ds']).reset_index(drop=True)
+    all_models = load_all_models()
     
-    plot_type = st.sidebar.selectbox("Select Visualization", ["Matplotlib", "Plotly"])
-    if st.sidebar.button("Submit"):
-        start_time = time.time()
-        forecast_df = nixtla_client.forecast(
-            df=df,
-            h=h,
-            freq=freq,
-            level=[90]
-        )
-        st.session_state.forecast_df = forecast_df
-
-
-        if 'forecast_df' in st.session_state:
-            forecast_df = st.session_state.forecast_df
-            
-            if plot_type == "Matplotlib":
-                # Convert the Plotly figure to a Matplotlib figure if needed
-                # Note: You may need to handle this conversion depending on your specific use case
-                # For now, this example assumes that you are using a Matplotlib figure
-                fig = nixtla_client.plot(df, forecast_df, level=[90], engine='matplotlib')
-                st.pyplot(fig)
-            elif plot_type == "Plotly":
-                # Plotly figure directly
-                fig = nixtla_client.plot(df, forecast_df, level=[90], engine='plotly')
-                st.plotly_chart(fig)
+    df = st.session_state.get('df', load_default())
+    ds_col, y_col = st.sidebar.selectbox("Date/Time column", df.columns), st.sidebar.selectbox("Target column", df.columns)
     
-            end_time = time.time()  # End timing
-            time_taken = end_time - start_time
-            st.success(f"Time taken for TimeGPT forecast: {time_taken:.2f} seconds")
-
-            if 'forecast_df' in st.session_state:
-                forecast_df = st.session_state.forecast_df
-        
-                st.markdown('You can download Input and Forecast Data below')
-                tab_insample, tab_forecast  = st.tabs(
-                                ["Input data", "Forecast"]
-                            )
-                    
-                with tab_insample:
-                    df_grid = df.drop(columns="unique_id")
-                    st.write(df_grid)
-                    # grid_table = AgGrid(
-                    #                 df_grid,
-                    #                 theme="alpine",
-                    #             )
-            
-                with tab_forecast:
-                    df_grid = forecast_df
-                    st.write(df_grid)
-                    # grid_table = AgGrid(
-                    #                 df_grid,
-                    #                 theme="alpine",
-                    #             )
-
-
-
-def timegpt_anom():
-    nixtla_token = os.environ.get("NIXTLA_API_KEY")
-    nixtla_client = NixtlaClient(
-    api_key = nixtla_token
-    )
-
+    df = df.rename(columns={ds_col: 'ds', y_col: 'y'}).assign(unique_id=1)[['unique_id', 'ds', 'y']]
     
-    st.title("TimeGPT Anomaly Detection")
-    st.markdown("""
-    Instant time series anomaly detection and visualization by using the TimeGPT API provided by Nixtla.
-    """)
-    with st.sidebar.expander("Upload and Configure Dataset", expanded=True):
-        if 'uploaded_file' not in st.session_state:
-            uploaded_file = st.file_uploader("Upload your time series data (CSV)", type=["csv"])
-            if uploaded_file:
-                df = pd.read_csv(uploaded_file)
-                st.session_state.df = df
-                st.session_state.uploaded_file = uploaded_file
-            else:
-                df = load_default()
-                st.session_state.df = df
-        else:
-            if st.checkbox("Upload a new file (CSV)"):
-                uploaded_file = st.file_uploader("Upload your time series data (CSV)", type=["csv"])
-                if uploaded_file:
-                    df = pd.read_csv(uploaded_file)
-                    st.session_state.df = df
-                    st.session_state.uploaded_file = uploaded_file
-                else:
-                    df = st.session_state.df
-            else:
-                df = st.session_state.df
-
-        columns = df.columns.tolist()
-        ds_col = st.selectbox("Select Date/Time column", options=columns, index=columns.index('ds') if 'ds' in columns else 0)
-        target_columns = [col for col in columns if (col != ds_col) and (col != 'unique_id')]
-        y_col = st.selectbox("Select Target column", options=target_columns, index=0)
-
-        df = df.rename(columns={ds_col: 'ds', y_col: 'y'})
-
-        id_col = 'ts_test'
-        df['unique_id']=id_col
-        df = df[['unique_id','ds','y']]
-
-    freq = determine_frequency(df)
-
-    df = df.drop_duplicates(subset=['ds']).reset_index(drop=True)
+    frequency = determine_frequency(df)
+    models = select_model_based_on_frequency(frequency, all_models)
     
-    plot_type = st.sidebar.selectbox("Select Visualization", ["Matplotlib", "Plotly"])
     if st.sidebar.button("Submit"):
-        start_time=time.time()
-        anom_df = nixtla_client.detect_anomalies(
-            df=df,
-            freq=freq,
-            level=90
-        )
-        st.session_state.anom_df = anom_df
+        model_choice = st.sidebar.selectbox("Select model", models.keys())
+        forecast_time_series(df, model_choice, st.sidebar.number_input("Horizon", value=12), 50, y_col)
 
-        if 'anom_df' in st.session_state:
-            anom_df = st.session_state.anom_df
-            
-            if plot_type == "Matplotlib":
-                # Convert the Plotly figure to a Matplotlib figure if needed
-                # Note: You may need to handle this conversion depending on your specific use case
-                # For now, this example assumes that you are using a Matplotlib figure
-                fig = nixtla_client.plot(df, anom_df, level=[90], engine='matplotlib')
-                st.pyplot(fig)
-            elif plot_type == "Plotly":
-                # Plotly figure directly
-                fig = nixtla_client.plot(df, anom_df, level=[90], engine='plotly')
-                st.plotly_chart(fig)
-    
-            end_time = time.time()  # End timing
-            time_taken = end_time - start_time
-            st.success(f"Time taken for TimeGPT forecast: {time_taken:.2f} seconds")
-
-    
-            st.markdown('You can download Input and Forecast Data below')
-            tab_insample, tab_forecast  = st.tabs(
-                            ["Input data", "Forecast"]
-                        )
-                
-            with tab_insample:
-                df_grid = df.drop(columns="unique_id")
-                st.write(df_grid)
-                # grid_table = AgGrid(
-                #                 df_grid,
-                #                 theme="alpine",
-                #             )
-        
-            with tab_forecast:
-                df_grid = anom_df
-                st.write(df_grid)
-                # grid_table = AgGrid(
-                #                 df_grid,
-                #                 theme="alpine",
-                #             )
-    
-    
-    
 
 pg = st.navigation({
     "Neuralforecast": [
         # Load pages from functions
         st.Page(transfer_learning_forecasting, title="Zero-shot Forecasting", default=True, icon=":material/query_stats:"),
-        st.Page(dynamic_forecasting, title="Personalized Neural Forecasting", icon=":material/monitoring:"),
     ],
-        "TimeGPT": [
-        # Load pages from functions
-        st.Page(timegpt_fcst, title="TimeGPT Forecast", icon=":material/smart_toy:"),
-        st.Page(timegpt_anom, title="TimeGPT Anomalies Detection", icon=":material/detector_offline:")
-        ]
 })
 
 pg.run()