big change to form and QOL

app.py

@@ -10,669 +10,686 @@ st.set_page_config(
 )
 
 st.title('🎮 Gameday Model for $SPX')
-col1, col2 = st.columns(2)
-with col1:
-    st.markdown('**PLEASE NOTE:** Model should be run at or after market open. Documentation on the model and its features [can be found here.](https://huggingface.co/spaces/boomsss/gamedayspx/blob/main/README.md)')
-with col2:
-    st.caption('Clear before next run.')
-    if st.button("🧹 Clear All"):
+st.markdown('**PLEASE NOTE:** Model should be run at or after market open. Documentation on the model and its features [can be found here.](https://huggingface.co/spaces/boomsss/gamedayspx/blob/main/README.md)')
+with st.form("choose_model"):
+
+    option = st.selectbox(
+        'Select a model, then run.',
+        ('', '🌞 At Open', '⌚ 30 Mins', '⏳ 60 Mins'))
+    col1, col2 = st.columns(2)
+    with col1:
+        submitted = st.form_submit_button('🏃🏽‍♂️ Run',use_container_width=True)
+        
+    with col2:
+        cleared = st.form_submit_button('🧹 Clear All',use_container_width=True)
+
+    if cleared:
         st.cache_data.clear()
 
-option = st.selectbox(
-    'Select a model, then run.',
-    ('', '🌞 At Open', '⌚ 30 Mins', '⏳ 60 Mins'))
-    
-if option == '':
-    st.write('Gotta pick one.')
-
-elif option == '🌞 At Open':
-    if st.button('🏃🏽‍♂️ Run'):
-        from model_day import *
-        with st.spinner('Loading data...'):
-            data, df_final, final_row = get_data()
-        # st.success("✅ Historical data")
-
-        with st.spinner("Training models..."):
-            def train_models():
-                res1, xgbr, seq2 = walk_forward_validation_seq(df_final.dropna(), 'Target_clf', 'Target', 100, 1)
-                return res1, xgbr, seq2
-            res1, xgbr, seq2 = train_models()
-        # st.success("✅ Models trained")
-
-        with st.spinner("Getting new prediction..."):
-
-            # Get last row
-            new_pred = data.loc[final_row, ['BigNewsDay',
-                'Quarter',
-                'Perf5Day',
-                'Perf5Day_n1',    
-                'DaysGreen',    
-                'DaysRed',    
-                'CurrentGap',
-                'RangePct',
-                'RangePct_n1',
-                'RangePct_n2',
-                'OHLC4_VIX',
-                'OHLC4_VIX_n1',
-                'OHLC4_VIX_n2']]
-
-            new_pred = pd.DataFrame(new_pred).T
-            # new_pred_show = pd.DataFrame(index=[new_pred.columns], columns=[new_pred.index], data=[[v] for v in new_pred.values])
-            # last_date = datetime.datetime.strptime(data.loc[final_row], '%Y-%m-%d')
-            curr_date = final_row + BDay(1)
-            curr_date = curr_date.strftime('%Y-%m-%d')
-
-            new_pred['BigNewsDay'] = new_pred['BigNewsDay'].astype(float)
-            new_pred['Quarter'] = new_pred['Quarter'].astype(int)
-            new_pred['Perf5Day'] = new_pred['Perf5Day'].astype(bool)
-            new_pred['Perf5Day_n1'] = new_pred['Perf5Day_n1'].astype(bool)
-            new_pred['DaysGreen'] = new_pred['DaysGreen'].astype(float)
-            new_pred['DaysRed'] = new_pred['DaysRed'].astype(float)
-            new_pred['CurrentGap'] = new_pred['CurrentGap'].astype(float)
-            new_pred['RangePct'] = new_pred['RangePct'].astype(float)
-            new_pred['RangePct_n1'] = new_pred['RangePct_n1'].astype(float)
-            new_pred['RangePct_n2'] = new_pred['RangePct_n2'].astype(float)
-            new_pred['OHLC4_VIX'] = new_pred['OHLC4_VIX'].astype(float)
-            new_pred['OHLC4_VIX_n1'] = new_pred['OHLC4_VIX_n1'].astype(float)
-            new_pred['OHLC4_VIX_n2'] = new_pred['OHLC4_VIX_n2'].astype(float)
-
-        st.success("✅ All done!")
-        tab1, tab2, tab3, tab4 = st.tabs(["🔮 Prediction", "✨ New Data", "🗄 Historical", "📊 Performance"])
-
-        seq_proba = seq_predict_proba(new_pred, xgbr, seq2)
-
-        green_proba = seq_proba[0]
-        red_proba = 1 - green_proba
-        do_not_play = (seq_proba[0] > 0.4) and (seq_proba[0] <= 0.6) 
-        stdev = 0.01
-        score = None
-        num_obs = None
-        cond = None
-        historical_proba = None
-        text_cond = None
-        operator = None
-
-        if do_not_play:
-            text_cond = '🟨'
-            operator = ''
-            score = seq_proba[0]
-            cond = (res1['Predicted'] > 0.4) & (res1['Predicted'] <= 0.6)
-            num_obs = len(res1.loc[cond])
-            historical_proba = res1.loc[cond, 'True'].mean()
-
-            
-        elif green_proba > red_proba:
-            # If the day is predicted to be green, say so
-            text_cond = '🟩'
-            operator = '>='
-            score = green_proba
-            # How many with this score?
-            cond = (res1['Predicted'] >= green_proba)
-            num_obs = len(res1.loc[cond])
-            # How often green?
-            historical_proba = res1.loc[cond, 'True'].mean()
-            # print(cond)
-
-        elif green_proba <= red_proba:
-            # If the day is predicted to be green, say so
-            text_cond = '🟥'
-            operator = '<='
-            score = red_proba
-            # How many with this score?
-            cond = (res1['Predicted'] <= red_proba)
-            num_obs = len(res1.loc[cond])
-            # How often green?
-            historical_proba = 1 - res1.loc[cond, 'True'].mean()
-            # print(cond)
-
-        score_fmt = f'{score:.1%}'
-
-        results = pd.DataFrame(index=[
-            'PrevClose',
-            'Confidence Score',
-            'Success Rate',
-            f'NumObs {operator} {"" if do_not_play else score_fmt}',
-        ], data = [
-            f"{data.loc[final_row,'Close']:.2f}",
-            f'{text_cond} {score:.1%}',
-            f'{historical_proba:.1%}', 
-            num_obs,
-            ])
-
-        results.columns = ['Outputs']
-
-        # st.subheader('New Prediction')
-
-        int_labels = ['(-∞, .20]', '(.20, .40]', '(.40, .60]', '(.60, .80]', '(.80, ∞]']
-        # df_probas = res1.groupby(pd.qcut(res1['Predicted'],5)).agg({'True':[np.mean,len,np.sum]})
-        df_probas = res1.groupby(pd.cut(res1['Predicted'], bins = [-np.inf, 0.2, 0.4, 0.6, 0.8, np.inf], labels = int_labels)).agg({'True':[np.mean,len,np.sum]})
-        df_probas.columns = ['PctGreen','NumObs','NumGreen']
-
-        roc_auc_score_all = roc_auc_score(res1['True'].astype(int), res1['Predicted'].values)
-        precision_score_all = precision_score(res1['True'].astype(int), res1['Predicted'] > 0.5)
-        recall_score_all = recall_score(res1['True'].astype(int), res1['Predicted'] > 0.5)
-        len_all = len(res1)
-
-        res2_filtered = res1.loc[(res1['Predicted'] > 0.6) | (res1['Predicted'] <= 0.4)]
-
-        roc_auc_score_hi = roc_auc_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'].values)
-        precision_score_hi = precision_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'] > 0.5)
-        recall_score_hi = recall_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'] > 0.5)
-        len_hi = len(res2_filtered)
-
-        df_performance = pd.DataFrame(
-            index=[
-                'N',
-                'ROC AUC',
-                'Precision',
-                'Recall'
-            ],
-            columns = [
-                'All',
-                'High Confidence'
-            ],
-            data = [
-                [len_all, len_hi],
-                [roc_auc_score_all, roc_auc_score_hi],
-                [precision_score_all, precision_score_hi],
-                [recall_score_all, recall_score_hi]
-            ]
-        ).round(2)
-
-        def get_acc(t, p):
-            if t == False and p <= 0.4:
-                return '✅'
-            elif t == True and p > 0.6:
-                return '✅'
-            elif t == False and p > 0.6:
-                return '❌'
-            elif t == True and p <= 0.4:
-                return '❌'
-            else:
-                return '🟨'
-            
-        def get_acc_text(t, p):
-            if t == False and p <= 0.4:
-                return 'Correct'
-            elif t == True and p > 0.6:
-                return 'Correct'
-            elif t == False and p > 0.6:
-                return 'Incorrect'
-            elif t == True and p <= 0.4:
-                return 'Incorrect'
-            else:
-                return 'No Action'
-
-        perf_daily = res1.copy()
-        perf_daily['TargetDate'] = perf_daily.index + BDay(1)
-        perf_daily['Accuracy'] = [get_acc(t, p) for t, p in zip(perf_daily['True'], perf_daily['Predicted'])]
-        perf_daily['AccuracyText'] = [get_acc_text(t, p) for t, p in zip(perf_daily['True'], perf_daily['Predicted'])]
-        perf_daily['ConfidenceScore'] = [x if x > 0.6 else 1-x if x <= 0.4 else x for x in perf_daily['Predicted']]
-        perf_daily = perf_daily[['TargetDate','Predicted','True','Accuracy','AccuracyText','ConfidenceScore']]
-
-        def convert_df(df):
-            # IMPORTANT: Cache the conversion to prevent computation on every rerun
-            return df.to_csv()
-
-        csv = convert_df(perf_daily)
-
-        with tab1:
-            st.subheader(f'Pred for {curr_date} as of 6:30AM PST')
-            st.write(results)
-            st.write(df_probas)
-        with tab2:
-            st.subheader('Latest Data for Pred')
-            st.write(new_pred)
-        with tab3:
-            st.subheader('Historical Data')
-            st.write(df_final)
-        with tab4:
-            st.subheader('Performance')
-            st.write(df_performance)
-            st.write(perf_daily[['TargetDate','Predicted','True','Accuracy']])
-            st.download_button(
-                label="Download Historical Performance",
-                data=csv,
-                file_name='performance_for_at_open_model.csv',
-            )
-
-elif option == '⌚ 30 Mins':
-    if st.button('🏃🏽‍♂️ Run'):
-        from model_30m import *
-        with st.spinner('Loading data...'):
-            data, df_final, final_row = get_data()
-        # st.success("✅ Historical data")
-
-        with st.spinner("Training models..."):
-            def train_models():
-                res1, xgbr, seq2 = walk_forward_validation_seq(df_final.dropna(), 'Target_clf', 'Target', 100, 1)
-                return res1, xgbr, seq2
-            res1, xgbr, seq2 = train_models()
-        # st.success("✅ Models trained")
-
-        with st.spinner("Getting new prediction..."):
-
-            # Get last row
-            new_pred = data.loc[final_row, ['BigNewsDay',
-                'Quarter',
-                'Perf5Day',
-                'Perf5Day_n1',    
-                'DaysGreen',    
-                'DaysRed',
-                'CurrentHigh30toClose',
-                'CurrentLow30toClose',
-                'CurrentClose30toClose',
-                'CurrentRange30',
-                'GapFill30',    
-                'CurrentGap',
-                'RangePct',
-                'RangePct_n1',
-                'RangePct_n2',
-                'OHLC4_VIX',
-                'OHLC4_VIX_n1',
-                'OHLC4_VIX_n2']]
-
-            new_pred = pd.DataFrame(new_pred).T
-            # new_pred_show = pd.DataFrame(index=[new_pred.columns], columns=[new_pred.index], data=[[v] for v in new_pred.values])
-            # last_date = datetime.datetime.strptime(data.loc[final_row], '%Y-%m-%d')
-            curr_date = final_row + BDay(1)
-            curr_date = curr_date.strftime('%Y-%m-%d')
-
-            new_pred['BigNewsDay'] = new_pred['BigNewsDay'].astype(float)
-            new_pred['Quarter'] = new_pred['Quarter'].astype(int)
-            new_pred['Perf5Day'] = new_pred['Perf5Day'].astype(bool)
-            new_pred['Perf5Day_n1'] = new_pred['Perf5Day_n1'].astype(bool)
-            new_pred['DaysGreen'] = new_pred['DaysGreen'].astype(float)
-            new_pred['DaysRed'] = new_pred['DaysRed'].astype(float)
-            new_pred['CurrentHigh30toClose'] = new_pred['CurrentHigh30toClose'].astype(float)
-            new_pred['CurrentLow30toClose'] = new_pred['CurrentLow30toClose'].astype(float)
-            new_pred['CurrentClose30toClose'] = new_pred['CurrentClose30toClose'].astype(float)
-            new_pred['CurrentRange30'] = new_pred['CurrentRange30'].astype(float)
-            new_pred['GapFill30'] = new_pred['GapFill30'].astype(float)  
-            new_pred['CurrentGap'] = new_pred['CurrentGap'].astype(float)
-            new_pred['RangePct'] = new_pred['RangePct'].astype(float)
-            new_pred['RangePct_n1'] = new_pred['RangePct_n1'].astype(float)
-            new_pred['RangePct_n2'] = new_pred['RangePct_n2'].astype(float)
-            new_pred['OHLC4_VIX'] = new_pred['OHLC4_VIX'].astype(float)
-            new_pred['OHLC4_VIX_n1'] = new_pred['OHLC4_VIX_n1'].astype(float)
-            new_pred['OHLC4_VIX_n2'] = new_pred['OHLC4_VIX_n2'].astype(float)
-
-        st.success("✅ All done!")
-        tab1, tab2, tab3, tab4 = st.tabs(["🔮 Prediction", "✨ New Data", "🗄 Historical", "📊 Performance"])
-
-        seq_proba = seq_predict_proba(new_pred, xgbr, seq2)
-
-        green_proba = seq_proba[0]
-        red_proba = 1 - green_proba
-        do_not_play = (seq_proba[0] > 0.4) and (seq_proba[0] <= 0.6) 
-        stdev = 0.01
-        score = None
-        num_obs = None
-        cond = None
-        historical_proba = None
-        text_cond = None
-        operator = None
-
-        if do_not_play:
-            text_cond = '🟨'
-            operator = ''
-            score = seq_proba[0]
-            cond = (res1['Predicted'] > 0.4) & (res1['Predicted'] <= 0.6)
-            num_obs = len(res1.loc[cond])
-            historical_proba = res1.loc[cond, 'True'].mean()
-
-            
-        elif green_proba > red_proba:
-            # If the day is predicted to be green, say so
-            text_cond = '🟩'
-            operator = '>='
-            score = green_proba
-            # How many with this score?
-            cond = (res1['Predicted'] >= green_proba)
-            num_obs = len(res1.loc[cond])
-            # How often green?
-            historical_proba = res1.loc[cond, 'True'].mean()
-            # print(cond)
-
-        elif green_proba <= red_proba:
-            # If the day is predicted to be green, say so
-            text_cond = '🟥'
-            operator = '<='
-            score = red_proba
-            # How many with this score?
-            cond = (res1['Predicted'] <= red_proba)
-            num_obs = len(res1.loc[cond])
-            # How often green?
-            historical_proba = 1 - res1.loc[cond, 'True'].mean()
-            # print(cond)
-
-        score_fmt = f'{score:.1%}'
-
-        results = pd.DataFrame(index=[
-            'PrevClose',
-            'Confidence Score',
-            'Success Rate',
-            f'NumObs {operator} {"" if do_not_play else score_fmt}',
-        ], data = [
-            f"{data.loc[final_row,'Close']:.2f}",
-            f'{text_cond} {score:.1%}',
-            f'{historical_proba:.1%}', 
-            num_obs,
-            ])
-
-        results.columns = ['Outputs']
-
-        # st.subheader('New Prediction')
-
-        int_labels = ['(-∞, .20]', '(.20, .40]', '(.40, .60]', '(.60, .80]', '(.80, ∞]']
-        # df_probas = res1.groupby(pd.qcut(res1['Predicted'],5)).agg({'True':[np.mean,len,np.sum]})
-        df_probas = res1.groupby(pd.cut(res1['Predicted'], bins = [-np.inf, 0.2, 0.4, 0.6, 0.8, np.inf], labels = int_labels)).agg({'True':[np.mean,len,np.sum]})
-        df_probas.columns = ['PctGreen','NumObs','NumGreen']
-
-        roc_auc_score_all = roc_auc_score(res1['True'].astype(int), res1['Predicted'].values)
-        precision_score_all = precision_score(res1['True'].astype(int), res1['Predicted'] > 0.5)
-        recall_score_all = recall_score(res1['True'].astype(int), res1['Predicted'] > 0.5)
-        len_all = len(res1)
-
-        res2_filtered = res1.loc[(res1['Predicted'] > 0.6) | (res1['Predicted'] <= 0.4)]
-
-        roc_auc_score_hi = roc_auc_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'].values)
-        precision_score_hi = precision_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'] > 0.5)
-        recall_score_hi = recall_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'] > 0.5)
-        len_hi = len(res2_filtered)
-
-        df_performance = pd.DataFrame(
-            index=[
-                'N',
-                'ROC AUC',
-                'Precision',
-                'Recall'
-            ],
-            columns = [
-                'All',
-                'High Confidence'
-            ],
-            data = [
-                [len_all, len_hi],
-                [roc_auc_score_all, roc_auc_score_hi],
-                [precision_score_all, precision_score_hi],
-                [recall_score_all, recall_score_hi]
-            ]
-        ).round(2)
-
-        def get_acc(t, p):
-            if t == False and p <= 0.4:
-                return '✅'
-            elif t == True and p > 0.6:
-                return '✅'
-            elif t == False and p > 0.6:
-                return '❌'
-            elif t == True and p <= 0.4:
-                return '❌'
-            else:
-                return '🟨'
-            
-        def get_acc_text(t, p):
-            if t == False and p <= 0.4:
-                return 'Correct'
-            elif t == True and p > 0.6:
-                return 'Correct'
-            elif t == False and p > 0.6:
-                return 'Incorrect'
-            elif t == True and p <= 0.4:
-                return 'Incorrect'
-            else:
-                return 'No Action'
-
-        perf_daily = res1.copy()
-        perf_daily['TargetDate'] = perf_daily.index + BDay(1)
-        perf_daily['Accuracy'] = [get_acc(t, p) for t, p in zip(perf_daily['True'], perf_daily['Predicted'])]
-        perf_daily['AccuracyText'] = [get_acc_text(t, p) for t, p in zip(perf_daily['True'], perf_daily['Predicted'])]
-        perf_daily['ConfidenceScore'] = [x if x > 0.6 else 1-x if x <= 0.4 else x for x in perf_daily['Predicted']]
-        perf_daily = perf_daily[['TargetDate','Predicted','True','Accuracy','AccuracyText','ConfidenceScore']]
-
-        def convert_df(df):
-            # IMPORTANT: Cache the conversion to prevent computation on every rerun
-            return df.to_csv()
-
-        csv = convert_df(perf_daily)
-
-        with tab1:
-            st.subheader(f'Pred for {curr_date} as of 7AM PST')
-            st.write(results)
-            st.write(df_probas)
-        with tab2:
-            st.subheader('Latest Data for Pred')
-            st.write(new_pred)
-        with tab3:
-            st.subheader('Historical Data')
-            st.write(df_final)
-        with tab4:
-            st.subheader('Performance')
-            st.write(df_performance)
-            st.write(perf_daily[['TargetDate','Predicted','True','Accuracy']])
-            st.download_button(
-                label="Download Historical Performance",
-                data=csv,
-                file_name='performance_for_30m_model.csv',
-            )
-
-elif option == '⏳ 60 Mins':
-    if st.button('🏃🏽‍♂️ Run'):
-        from model_1h import *
-        with st.spinner('Loading data...'):
-            data, df_final, final_row = get_data()
-        # st.success("✅ Historical data")
-
-        with st.spinner("Training models..."):
-            def train_models():
-                res1, xgbr, seq2 = walk_forward_validation_seq(df_final.dropna(), 'Target_clf', 'Target', 100, 1)
-                return res1, xgbr, seq2
-            res1, xgbr, seq2 = train_models()
-        # st.success("✅ Models trained")
-
-        with st.spinner("Getting new prediction..."):
-
-            # Get last row
-            new_pred = data.loc[final_row, ['BigNewsDay',
-                'Quarter',
-                'Perf5Day',
-                'Perf5Day_n1',    
-                'DaysGreen',    
-                'DaysRed',
-                'CurrentHigh30toClose',
-                'CurrentLow30toClose',
-                'CurrentClose30toClose',
-                'CurrentRange30',
-                'GapFill30',    
-                'CurrentGap',
-                'RangePct',
-                'RangePct_n1',
-                'RangePct_n2',
-                'OHLC4_VIX',
-                'OHLC4_VIX_n1',
-                'OHLC4_VIX_n2']]
-
-            new_pred = pd.DataFrame(new_pred).T
-            # new_pred_show = pd.DataFrame(index=[new_pred.columns], columns=[new_pred.index], data=[[v] for v in new_pred.values])
-            # last_date = datetime.datetime.strptime(data.loc[final_row], '%Y-%m-%d')
-            curr_date = final_row + BDay(1)
-            curr_date = curr_date.strftime('%Y-%m-%d')
-
-            new_pred['BigNewsDay'] = new_pred['BigNewsDay'].astype(float)
-            new_pred['Quarter'] = new_pred['Quarter'].astype(int)
-            new_pred['Perf5Day'] = new_pred['Perf5Day'].astype(bool)
-            new_pred['Perf5Day_n1'] = new_pred['Perf5Day_n1'].astype(bool)
-            new_pred['DaysGreen'] = new_pred['DaysGreen'].astype(float)
-            new_pred['DaysRed'] = new_pred['DaysRed'].astype(float)
-            new_pred['CurrentHigh30toClose'] = new_pred['CurrentHigh30toClose'].astype(float)
-            new_pred['CurrentLow30toClose'] = new_pred['CurrentLow30toClose'].astype(float)
-            new_pred['CurrentClose30toClose'] = new_pred['CurrentClose30toClose'].astype(float)
-            new_pred['CurrentRange30'] = new_pred['CurrentRange30'].astype(float)
-            new_pred['GapFill30'] = new_pred['GapFill30'].astype(float)  
-            new_pred['CurrentGap'] = new_pred['CurrentGap'].astype(float)
-            new_pred['RangePct'] = new_pred['RangePct'].astype(float)
-            new_pred['RangePct_n1'] = new_pred['RangePct_n1'].astype(float)
-            new_pred['RangePct_n2'] = new_pred['RangePct_n2'].astype(float)
-            new_pred['OHLC4_VIX'] = new_pred['OHLC4_VIX'].astype(float)
-            new_pred['OHLC4_VIX_n1'] = new_pred['OHLC4_VIX_n1'].astype(float)
-            new_pred['OHLC4_VIX_n2'] = new_pred['OHLC4_VIX_n2'].astype(float)
-
-        st.success("✅ All done!")
-        tab1, tab2, tab3, tab4 = st.tabs(["🔮 Prediction", "✨ New Data", "🗄 Historical", "📊 Performance"])
-
-        seq_proba = seq_predict_proba(new_pred, xgbr, seq2)
-
-        green_proba = seq_proba[0]
-        red_proba = 1 - green_proba
-        do_not_play = (seq_proba[0] > 0.4) and (seq_proba[0] <= 0.6) 
-        stdev = 0.01
-        score = None
-        num_obs = None
-        cond = None
-        historical_proba = None
-        text_cond = None
-        operator = None
-
-        if do_not_play:
-            text_cond = '🟨'
-            operator = ''
-            score = seq_proba[0]
-            cond = (res1['Predicted'] > 0.4) & (res1['Predicted'] <= 0.6)
-            num_obs = len(res1.loc[cond])
-            historical_proba = res1.loc[cond, 'True'].mean()
-
-            
-        elif green_proba > red_proba:
-            # If the day is predicted to be green, say so
-            text_cond = '🟩'
-            operator = '>='
-            score = green_proba
-            # How many with this score?
-            cond = (res1['Predicted'] >= green_proba)
-            num_obs = len(res1.loc[cond])
-            # How often green?
-            historical_proba = res1.loc[cond, 'True'].mean()
-            # print(cond)
-
-        elif green_proba <= red_proba:
-            # If the day is predicted to be green, say so
-            text_cond = '🟥'
-            operator = '<='
-            score = red_proba
-            # How many with this score?
-            cond = (res1['Predicted'] <= red_proba)
-            num_obs = len(res1.loc[cond])
-            # How often green?
-            historical_proba = 1 - res1.loc[cond, 'True'].mean()
-            # print(cond)
-
-        score_fmt = f'{score:.1%}'
-
-        results = pd.DataFrame(index=[
-            'PrevClose',
-            'Confidence Score',
-            'Success Rate',
-            f'NumObs {operator} {"" if do_not_play else score_fmt}',
-        ], data = [
-            f"{data.loc[final_row,'Close']:.2f}",
-            f'{text_cond} {score:.1%}',
-            f'{historical_proba:.1%}', 
-            num_obs,
-            ])
-
-        results.columns = ['Outputs']
-
-        # st.subheader('New Prediction')
-        int_labels = ['(-∞, .20]', '(.20, .40]', '(.40, .60]', '(.60, .80]', '(.80, ∞]']
-        # df_probas = res1.groupby(pd.qcut(res1['Predicted'],5)).agg({'True':[np.mean,len,np.sum]})
-        df_probas = res1.groupby(pd.cut(res1['Predicted'], bins = [-np.inf, 0.2, 0.4, 0.6, 0.8, np.inf], labels = int_labels)).agg({'True':[np.mean,len,np.sum]})
-        df_probas.columns = ['PctGreen','NumObs','NumGreen']
-
-        roc_auc_score_all = roc_auc_score(res1['True'].astype(int), res1['Predicted'].values)
-        precision_score_all = precision_score(res1['True'].astype(int), res1['Predicted'] > 0.5)
-        recall_score_all = recall_score(res1['True'].astype(int), res1['Predicted'] > 0.5)
-        len_all = len(res1)
-
-        res2_filtered = res1.loc[(res1['Predicted'] > 0.6) | (res1['Predicted'] <= 0.4)]
-
-        roc_auc_score_hi = roc_auc_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'].values)
-        precision_score_hi = precision_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'] > 0.5)
-        recall_score_hi = recall_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'] > 0.5)
-        len_hi = len(res2_filtered)
-
-        df_performance = pd.DataFrame(
-            index=[
-                'N',
-                'ROC AUC',
-                'Precision',
-                'Recall'
-            ],
-            columns = [
-                'All',
-                'High Confidence'
-            ],
-            data = [
-                [len_all, len_hi],
-                [roc_auc_score_all, roc_auc_score_hi],
-                [precision_score_all, precision_score_hi],
-                [recall_score_all, recall_score_hi]
-            ]
-        ).round(2)
-
-        def get_acc(t, p):
-            if t == False and p <= 0.4:
-                return '✅'
-            elif t == True and p > 0.6:
-                return '✅'
-            elif t == False and p > 0.6:
-                return '❌'
-            elif t == True and p <= 0.4:
-                return '❌'
-            else:
-                return '🟨'
-            
-        def get_acc_text(t, p):
-            if t == False and p <= 0.4:
-                return 'Correct'
-            elif t == True and p > 0.6:
-                return 'Correct'
-            elif t == False and p > 0.6:
-                return 'Incorrect'
-            elif t == True and p <= 0.4:
-                return 'Incorrect'
-            else:
-                return 'No Action'
-
-        perf_daily = res1.copy()
-        perf_daily['TargetDate'] = perf_daily.index + BDay(1)
-        perf_daily['Accuracy'] = [get_acc(t, p) for t, p in zip(perf_daily['True'], perf_daily['Predicted'])]
-        perf_daily['AccuracyText'] = [get_acc_text(t, p) for t, p in zip(perf_daily['True'], perf_daily['Predicted'])]
-        perf_daily['ConfidenceScore'] = [x if x > 0.6 else 1-x if x <= 0.4 else x for x in perf_daily['Predicted']]
-        perf_daily = perf_daily[['TargetDate','Predicted','True','Accuracy','AccuracyText','ConfidenceScore']]
-
-        def convert_df(df):
-            # IMPORTANT: Cache the conversion to prevent computation on every rerun
-            return df.to_csv()
-
-        csv = convert_df(perf_daily)
-
-        with tab1:
-            st.subheader(f'Pred for {curr_date} as of 7:30AM PST')
-            st.write(results)
-            st.write(df_probas)
-        with tab2:
-            st.subheader('Latest Data for Pred')
-            st.write(new_pred)
-        with tab3:
-            st.subheader('Historical Data')
-            st.write(df_final)
-        with tab4:
-            st.subheader('Performance')
-            st.write(df_performance)
-            st.write(perf_daily[['TargetDate','Predicted','True','Accuracy']])
-            st.download_button(
-                label="Download Historical Performance",
-                data=csv,
-                file_name='performance_for_60m_model.csv',
-            )
+    if option == '':
+        st.write('No model selected.')
+
+    if submitted:
+
+        if option == '🌞 At Open':
+        # runday = st.button('🏃🏽‍♂️ Run')
+        # if runday:
+            from model_day import *
+            with st.spinner('Loading data...'):
+                data, df_final, final_row = get_data()
+            # st.success("✅ Historical data")
+
+            with st.spinner("Training models..."):
+                def train_models():
+                    res1, xgbr, seq2 = walk_forward_validation_seq(df_final.dropna(), 'Target_clf', 'Target', 100, 1)
+                    return res1, xgbr, seq2
+                res1, xgbr, seq2 = train_models()
+            # st.success("✅ Models trained")
+
+            with st.spinner("Getting new prediction..."):
+
+                # Get last row
+                new_pred = data.loc[final_row, ['BigNewsDay',
+                    'Quarter',
+                    'Perf5Day',
+                    'Perf5Day_n1',    
+                    'DaysGreen',    
+                    'DaysRed',    
+                    'CurrentGap',
+                    'RangePct',
+                    'RangePct_n1',
+                    'RangePct_n2',
+                    'OHLC4_VIX',
+                    'OHLC4_VIX_n1',
+                    'OHLC4_VIX_n2']]
+
+                new_pred = pd.DataFrame(new_pred).T
+                # new_pred_show = pd.DataFrame(index=[new_pred.columns], columns=[new_pred.index], data=[[v] for v in new_pred.values])
+                # last_date = datetime.datetime.strptime(data.loc[final_row], '%Y-%m-%d')
+                curr_date = final_row + BDay(1)
+                curr_date = curr_date.strftime('%Y-%m-%d')
+
+                new_pred['BigNewsDay'] = new_pred['BigNewsDay'].astype(float)
+                new_pred['Quarter'] = new_pred['Quarter'].astype(int)
+                new_pred['Perf5Day'] = new_pred['Perf5Day'].astype(bool)
+                new_pred['Perf5Day_n1'] = new_pred['Perf5Day_n1'].astype(bool)
+                new_pred['DaysGreen'] = new_pred['DaysGreen'].astype(float)
+                new_pred['DaysRed'] = new_pred['DaysRed'].astype(float)
+                new_pred['CurrentGap'] = new_pred['CurrentGap'].astype(float)
+                new_pred['RangePct'] = new_pred['RangePct'].astype(float)
+                new_pred['RangePct_n1'] = new_pred['RangePct_n1'].astype(float)
+                new_pred['RangePct_n2'] = new_pred['RangePct_n2'].astype(float)
+                new_pred['OHLC4_VIX'] = new_pred['OHLC4_VIX'].astype(float)
+                new_pred['OHLC4_VIX_n1'] = new_pred['OHLC4_VIX_n1'].astype(float)
+                new_pred['OHLC4_VIX_n2'] = new_pred['OHLC4_VIX_n2'].astype(float)
+
+            st.success("✅ All done!")
+            tab1, tab2, tab3, tab4 = st.tabs(["🔮 Prediction", "✨ New Data", "🗄 Historical", "📊 Performance"])
+
+            seq_proba = seq_predict_proba(new_pred, xgbr, seq2)
+
+            green_proba = seq_proba[0]
+            red_proba = 1 - green_proba
+            do_not_play = (seq_proba[0] > 0.4) and (seq_proba[0] <= 0.6) 
+            stdev = 0.01
+            score = None
+            num_obs = None
+            cond = None
+            historical_proba = None
+            text_cond = None
+            operator = None
+
+            if do_not_play:
+                text_cond = '🟨'
+                operator = ''
+                score = seq_proba[0]
+                cond = (res1['Predicted'] > 0.4) & (res1['Predicted'] <= 0.6)
+                num_obs = len(res1.loc[cond])
+                historical_proba = res1.loc[cond, 'True'].mean()
+
+                
+            elif green_proba > red_proba:
+                # If the day is predicted to be green, say so
+                text_cond = '🟩'
+                operator = '>='
+                score = green_proba
+                # How many with this score?
+                cond = (res1['Predicted'] >= green_proba)
+                num_obs = len(res1.loc[cond])
+                # How often green?
+                historical_proba = res1.loc[cond, 'True'].mean()
+                # print(cond)
+
+            elif green_proba <= red_proba:
+                # If the day is predicted to be green, say so
+                text_cond = '🟥'
+                operator = '<='
+                score = red_proba
+                # How many with this score?
+                cond = (res1['Predicted'] <= red_proba)
+                num_obs = len(res1.loc[cond])
+                # How often green?
+                historical_proba = 1 - res1.loc[cond, 'True'].mean()
+                # print(cond)
+
+            score_fmt = f'{score:.1%}'
+
+            results = pd.DataFrame(index=[
+                'PrevClose',
+                'Confidence Score',
+                'Success Rate',
+                f'NumObs {operator} {"" if do_not_play else score_fmt}',
+            ], data = [
+                f"{data.loc[final_row,'Close']:.2f}",
+                f'{text_cond} {score:.1%}',
+                f'{historical_proba:.1%}', 
+                num_obs,
+                ])
+
+            results.columns = ['Outputs']
+
+            # st.subheader('New Prediction')
+
+            int_labels = ['(-∞, .20]', '(.20, .40]', '(.40, .60]', '(.60, .80]', '(.80, ∞]']
+            # df_probas = res1.groupby(pd.qcut(res1['Predicted'],5)).agg({'True':[np.mean,len,np.sum]})
+            df_probas = res1.groupby(pd.cut(res1['Predicted'], bins = [-np.inf, 0.2, 0.4, 0.6, 0.8, np.inf], labels = int_labels)).agg({'True':[np.mean,len,np.sum]})
+            df_probas.columns = ['PctGreen','NumObs','NumGreen']
+
+            roc_auc_score_all = roc_auc_score(res1['True'].astype(int), res1['Predicted'].values)
+            precision_score_all = precision_score(res1['True'].astype(int), res1['Predicted'] > 0.5)
+            recall_score_all = recall_score(res1['True'].astype(int), res1['Predicted'] > 0.5)
+            len_all = len(res1)
+
+            res2_filtered = res1.loc[(res1['Predicted'] > 0.6) | (res1['Predicted'] <= 0.4)]
+
+            roc_auc_score_hi = roc_auc_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'].values)
+            precision_score_hi = precision_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'] > 0.5)
+            recall_score_hi = recall_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'] > 0.5)
+            len_hi = len(res2_filtered)
+
+            df_performance = pd.DataFrame(
+                index=[
+                    'N',
+                    'ROC AUC',
+                    'Precision',
+                    'Recall'
+                ],
+                columns = [
+                    'All',
+                    'High Confidence'
+                ],
+                data = [
+                    [len_all, len_hi],
+                    [roc_auc_score_all, roc_auc_score_hi],
+                    [precision_score_all, precision_score_hi],
+                    [recall_score_all, recall_score_hi]
+                ]
+            ).round(2)
+
+            def get_acc(t, p):
+                if t == False and p <= 0.4:
+                    return '✅'
+                elif t == True and p > 0.6:
+                    return '✅'
+                elif t == False and p > 0.6:
+                    return '❌'
+                elif t == True and p <= 0.4:
+                    return '❌'
+                else:
+                    return '🟨'
+                
+            def get_acc_text(t, p):
+                if t == False and p <= 0.4:
+                    return 'Correct'
+                elif t == True and p > 0.6:
+                    return 'Correct'
+                elif t == False and p > 0.6:
+                    return 'Incorrect'
+                elif t == True and p <= 0.4:
+                    return 'Incorrect'
+                else:
+                    return 'No Action'
+
+            perf_daily = res1.copy()
+            perf_daily['TargetDate'] = perf_daily.index + BDay(1)
+            perf_daily['Accuracy'] = [get_acc(t, p) for t, p in zip(perf_daily['True'], perf_daily['Predicted'])]
+            perf_daily['AccuracyText'] = [get_acc_text(t, p) for t, p in zip(perf_daily['True'], perf_daily['Predicted'])]
+            perf_daily['ConfidenceScore'] = [x if x > 0.6 else 1-x if x <= 0.4 else x for x in perf_daily['Predicted']]
+            perf_daily = perf_daily[['TargetDate','Predicted','True','Accuracy','AccuracyText','ConfidenceScore']]
+
+            def convert_df(df):
+                # IMPORTANT: Cache the conversion to prevent computation on every rerun
+                return df.to_csv()
+
+            csv = convert_df(perf_daily)
+
+            with tab1:
+                st.subheader(f'Pred for {curr_date} as of 6:30AM PST')
+                st.write(results)
+                st.write(df_probas)
+            with tab2:
+                st.subheader('Latest Data for Pred')
+                st.write(new_pred)
+            with tab3:
+                st.subheader('Historical Data')
+                st.write(df_final)
+            with tab4:
+                st.subheader('Performance')
+                st.write(df_performance)
+                st.write(perf_daily[['TargetDate','Predicted','True','Accuracy']])
+                # st.download_button(
+                #     label="Download Historical Performance",
+                #     data=csv,
+                fname='performance_for_at_open_model.csv'
+                # )
+
+        elif option == '⌚ 30 Mins':
+        # run30 = st.button('🏃🏽‍♂️ Run')
+        # if run30:
+            from model_30m import *
+            with st.spinner('Loading data...'):
+                data, df_final, final_row = get_data()
+            # st.success("✅ Historical data")
+
+            with st.spinner("Training models..."):
+                def train_models():
+                    res1, xgbr, seq2 = walk_forward_validation_seq(df_final.dropna(), 'Target_clf', 'Target', 100, 1)
+                    return res1, xgbr, seq2
+                res1, xgbr, seq2 = train_models()
+            # st.success("✅ Models trained")
+
+            with st.spinner("Getting new prediction..."):
+
+                # Get last row
+                new_pred = data.loc[final_row, ['BigNewsDay',
+                    'Quarter',
+                    'Perf5Day',
+                    'Perf5Day_n1',    
+                    'DaysGreen',    
+                    'DaysRed',
+                    'CurrentHigh30toClose',
+                    'CurrentLow30toClose',
+                    'CurrentClose30toClose',
+                    'CurrentRange30',
+                    'GapFill30',    
+                    'CurrentGap',
+                    'RangePct',
+                    'RangePct_n1',
+                    'RangePct_n2',
+                    'OHLC4_VIX',
+                    'OHLC4_VIX_n1',
+                    'OHLC4_VIX_n2']]
+
+                new_pred = pd.DataFrame(new_pred).T
+                # new_pred_show = pd.DataFrame(index=[new_pred.columns], columns=[new_pred.index], data=[[v] for v in new_pred.values])
+                # last_date = datetime.datetime.strptime(data.loc[final_row], '%Y-%m-%d')
+                curr_date = final_row + BDay(1)
+                curr_date = curr_date.strftime('%Y-%m-%d')
+
+                new_pred['BigNewsDay'] = new_pred['BigNewsDay'].astype(float)
+                new_pred['Quarter'] = new_pred['Quarter'].astype(int)
+                new_pred['Perf5Day'] = new_pred['Perf5Day'].astype(bool)
+                new_pred['Perf5Day_n1'] = new_pred['Perf5Day_n1'].astype(bool)
+                new_pred['DaysGreen'] = new_pred['DaysGreen'].astype(float)
+                new_pred['DaysRed'] = new_pred['DaysRed'].astype(float)
+                new_pred['CurrentHigh30toClose'] = new_pred['CurrentHigh30toClose'].astype(float)
+                new_pred['CurrentLow30toClose'] = new_pred['CurrentLow30toClose'].astype(float)
+                new_pred['CurrentClose30toClose'] = new_pred['CurrentClose30toClose'].astype(float)
+                new_pred['CurrentRange30'] = new_pred['CurrentRange30'].astype(float)
+                new_pred['GapFill30'] = new_pred['GapFill30'].astype(float)  
+                new_pred['CurrentGap'] = new_pred['CurrentGap'].astype(float)
+                new_pred['RangePct'] = new_pred['RangePct'].astype(float)
+                new_pred['RangePct_n1'] = new_pred['RangePct_n1'].astype(float)
+                new_pred['RangePct_n2'] = new_pred['RangePct_n2'].astype(float)
+                new_pred['OHLC4_VIX'] = new_pred['OHLC4_VIX'].astype(float)
+                new_pred['OHLC4_VIX_n1'] = new_pred['OHLC4_VIX_n1'].astype(float)
+                new_pred['OHLC4_VIX_n2'] = new_pred['OHLC4_VIX_n2'].astype(float)
+
+            st.success("✅ All done!")
+            tab1, tab2, tab3, tab4 = st.tabs(["🔮 Prediction", "✨ New Data", "🗄 Historical", "📊 Performance"])
+
+            seq_proba = seq_predict_proba(new_pred, xgbr, seq2)
+
+            green_proba = seq_proba[0]
+            red_proba = 1 - green_proba
+            do_not_play = (seq_proba[0] > 0.4) and (seq_proba[0] <= 0.6) 
+            stdev = 0.01
+            score = None
+            num_obs = None
+            cond = None
+            historical_proba = None
+            text_cond = None
+            operator = None
+
+            if do_not_play:
+                text_cond = '🟨'
+                operator = ''
+                score = seq_proba[0]
+                cond = (res1['Predicted'] > 0.4) & (res1['Predicted'] <= 0.6)
+                num_obs = len(res1.loc[cond])
+                historical_proba = res1.loc[cond, 'True'].mean()
+
+                
+            elif green_proba > red_proba:
+                # If the day is predicted to be green, say so
+                text_cond = '🟩'
+                operator = '>='
+                score = green_proba
+                # How many with this score?
+                cond = (res1['Predicted'] >= green_proba)
+                num_obs = len(res1.loc[cond])
+                # How often green?
+                historical_proba = res1.loc[cond, 'True'].mean()
+                # print(cond)
+
+            elif green_proba <= red_proba:
+                # If the day is predicted to be green, say so
+                text_cond = '🟥'
+                operator = '<='
+                score = red_proba
+                # How many with this score?
+                cond = (res1['Predicted'] <= red_proba)
+                num_obs = len(res1.loc[cond])
+                # How often green?
+                historical_proba = 1 - res1.loc[cond, 'True'].mean()
+                # print(cond)
+
+            score_fmt = f'{score:.1%}'
+
+            results = pd.DataFrame(index=[
+                'PrevClose',
+                'Confidence Score',
+                'Success Rate',
+                f'NumObs {operator} {"" if do_not_play else score_fmt}',
+            ], data = [
+                f"{data.loc[final_row,'Close']:.2f}",
+                f'{text_cond} {score:.1%}',
+                f'{historical_proba:.1%}', 
+                num_obs,
+                ])
+
+            results.columns = ['Outputs']
+
+            # st.subheader('New Prediction')
+
+            int_labels = ['(-∞, .20]', '(.20, .40]', '(.40, .60]', '(.60, .80]', '(.80, ∞]']
+            # df_probas = res1.groupby(pd.qcut(res1['Predicted'],5)).agg({'True':[np.mean,len,np.sum]})
+            df_probas = res1.groupby(pd.cut(res1['Predicted'], bins = [-np.inf, 0.2, 0.4, 0.6, 0.8, np.inf], labels = int_labels)).agg({'True':[np.mean,len,np.sum]})
+            df_probas.columns = ['PctGreen','NumObs','NumGreen']
+
+            roc_auc_score_all = roc_auc_score(res1['True'].astype(int), res1['Predicted'].values)
+            precision_score_all = precision_score(res1['True'].astype(int), res1['Predicted'] > 0.5)
+            recall_score_all = recall_score(res1['True'].astype(int), res1['Predicted'] > 0.5)
+            len_all = len(res1)
+
+            res2_filtered = res1.loc[(res1['Predicted'] > 0.6) | (res1['Predicted'] <= 0.4)]
+
+            roc_auc_score_hi = roc_auc_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'].values)
+            precision_score_hi = precision_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'] > 0.5)
+            recall_score_hi = recall_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'] > 0.5)
+            len_hi = len(res2_filtered)
+
+            df_performance = pd.DataFrame(
+                index=[
+                    'N',
+                    'ROC AUC',
+                    'Precision',
+                    'Recall'
+                ],
+                columns = [
+                    'All',
+                    'High Confidence'
+                ],
+                data = [
+                    [len_all, len_hi],
+                    [roc_auc_score_all, roc_auc_score_hi],
+                    [precision_score_all, precision_score_hi],
+                    [recall_score_all, recall_score_hi]
+                ]
+            ).round(2)
+
+            def get_acc(t, p):
+                if t == False and p <= 0.4:
+                    return '✅'
+                elif t == True and p > 0.6:
+                    return '✅'
+                elif t == False and p > 0.6:
+                    return '❌'
+                elif t == True and p <= 0.4:
+                    return '❌'
+                else:
+                    return '🟨'
+                
+            def get_acc_text(t, p):
+                if t == False and p <= 0.4:
+                    return 'Correct'
+                elif t == True and p > 0.6:
+                    return 'Correct'
+                elif t == False and p > 0.6:
+                    return 'Incorrect'
+                elif t == True and p <= 0.4:
+                    return 'Incorrect'
+                else:
+                    return 'No Action'
+
+            perf_daily = res1.copy()
+            perf_daily['TargetDate'] = perf_daily.index + BDay(1)
+            perf_daily['Accuracy'] = [get_acc(t, p) for t, p in zip(perf_daily['True'], perf_daily['Predicted'])]
+            perf_daily['AccuracyText'] = [get_acc_text(t, p) for t, p in zip(perf_daily['True'], perf_daily['Predicted'])]
+            perf_daily['ConfidenceScore'] = [x if x > 0.6 else 1-x if x <= 0.4 else x for x in perf_daily['Predicted']]
+            perf_daily = perf_daily[['TargetDate','Predicted','True','Accuracy','AccuracyText','ConfidenceScore']]
+
+            def convert_df(df):
+                # IMPORTANT: Cache the conversion to prevent computation on every rerun
+                return df.to_csv()
+
+            csv = convert_df(perf_daily)
+
+            with tab1:
+                st.subheader(f'Pred for {curr_date} as of 7AM PST')
+                st.write(results)
+                st.write(df_probas)
+            with tab2:
+                st.subheader('Latest Data for Pred')
+                st.write(new_pred)
+            with tab3:
+                st.subheader('Historical Data')
+                st.write(df_final)
+            with tab4:
+                st.subheader('Performance')
+                st.write(df_performance)
+                st.write(perf_daily[['TargetDate','Predicted','True','Accuracy']])
+                # st.download_button(
+                #     label="Download Historical Performance",
+                #     data=csv,
+                fname='performance_for_30m_model.csv'
+                # )
+
+        elif option == '⏳ 60 Mins':
+        # run60 = st.button('🏃🏽‍♂️ Run')
+        # if run60:
+            from model_1h import *
+            with st.spinner('Loading data...'):
+                data, df_final, final_row = get_data()
+            # st.success("✅ Historical data")
+
+            with st.spinner("Training models..."):
+                def train_models():
+                    res1, xgbr, seq2 = walk_forward_validation_seq(df_final.dropna(), 'Target_clf', 'Target', 100, 1)
+                    return res1, xgbr, seq2
+                res1, xgbr, seq2 = train_models()
+            # st.success("✅ Models trained")
+
+            with st.spinner("Getting new prediction..."):
+
+                # Get last row
+                new_pred = data.loc[final_row, ['BigNewsDay',
+                    'Quarter',
+                    'Perf5Day',
+                    'Perf5Day_n1',    
+                    'DaysGreen',    
+                    'DaysRed',
+                    'CurrentHigh30toClose',
+                    'CurrentLow30toClose',
+                    'CurrentClose30toClose',
+                    'CurrentRange30',
+                    'GapFill30',    
+                    'CurrentGap',
+                    'RangePct',
+                    'RangePct_n1',
+                    'RangePct_n2',
+                    'OHLC4_VIX',
+                    'OHLC4_VIX_n1',
+                    'OHLC4_VIX_n2']]
+
+                new_pred = pd.DataFrame(new_pred).T
+                # new_pred_show = pd.DataFrame(index=[new_pred.columns], columns=[new_pred.index], data=[[v] for v in new_pred.values])
+                # last_date = datetime.datetime.strptime(data.loc[final_row], '%Y-%m-%d')
+                curr_date = final_row + BDay(1)
+                curr_date = curr_date.strftime('%Y-%m-%d')
+
+                new_pred['BigNewsDay'] = new_pred['BigNewsDay'].astype(float)
+                new_pred['Quarter'] = new_pred['Quarter'].astype(int)
+                new_pred['Perf5Day'] = new_pred['Perf5Day'].astype(bool)
+                new_pred['Perf5Day_n1'] = new_pred['Perf5Day_n1'].astype(bool)
+                new_pred['DaysGreen'] = new_pred['DaysGreen'].astype(float)
+                new_pred['DaysRed'] = new_pred['DaysRed'].astype(float)
+                new_pred['CurrentHigh30toClose'] = new_pred['CurrentHigh30toClose'].astype(float)
+                new_pred['CurrentLow30toClose'] = new_pred['CurrentLow30toClose'].astype(float)
+                new_pred['CurrentClose30toClose'] = new_pred['CurrentClose30toClose'].astype(float)
+                new_pred['CurrentRange30'] = new_pred['CurrentRange30'].astype(float)
+                new_pred['GapFill30'] = new_pred['GapFill30'].astype(float)  
+                new_pred['CurrentGap'] = new_pred['CurrentGap'].astype(float)
+                new_pred['RangePct'] = new_pred['RangePct'].astype(float)
+                new_pred['RangePct_n1'] = new_pred['RangePct_n1'].astype(float)
+                new_pred['RangePct_n2'] = new_pred['RangePct_n2'].astype(float)
+                new_pred['OHLC4_VIX'] = new_pred['OHLC4_VIX'].astype(float)
+                new_pred['OHLC4_VIX_n1'] = new_pred['OHLC4_VIX_n1'].astype(float)
+                new_pred['OHLC4_VIX_n2'] = new_pred['OHLC4_VIX_n2'].astype(float)
+
+            st.success("✅ All done!")
+            tab1, tab2, tab3, tab4 = st.tabs(["🔮 Prediction", "✨ New Data", "🗄 Historical", "📊 Performance"])
+
+            seq_proba = seq_predict_proba(new_pred, xgbr, seq2)
+
+            green_proba = seq_proba[0]
+            red_proba = 1 - green_proba
+            do_not_play = (seq_proba[0] > 0.4) and (seq_proba[0] <= 0.6) 
+            stdev = 0.01
+            score = None
+            num_obs = None
+            cond = None
+            historical_proba = None
+            text_cond = None
+            operator = None
+
+            if do_not_play:
+                text_cond = '🟨'
+                operator = ''
+                score = seq_proba[0]
+                cond = (res1['Predicted'] > 0.4) & (res1['Predicted'] <= 0.6)
+                num_obs = len(res1.loc[cond])
+                historical_proba = res1.loc[cond, 'True'].mean()
+
+                
+            elif green_proba > red_proba:
+                # If the day is predicted to be green, say so
+                text_cond = '🟩'
+                operator = '>='
+                score = green_proba
+                # How many with this score?
+                cond = (res1['Predicted'] >= green_proba)
+                num_obs = len(res1.loc[cond])
+                # How often green?
+                historical_proba = res1.loc[cond, 'True'].mean()
+                # print(cond)
+
+            elif green_proba <= red_proba:
+                # If the day is predicted to be green, say so
+                text_cond = '🟥'
+                operator = '<='
+                score = red_proba
+                # How many with this score?
+                cond = (res1['Predicted'] <= red_proba)
+                num_obs = len(res1.loc[cond])
+                # How often green?
+                historical_proba = 1 - res1.loc[cond, 'True'].mean()
+                # print(cond)
+
+            score_fmt = f'{score:.1%}'
+
+            results = pd.DataFrame(index=[
+                'PrevClose',
+                'Confidence Score',
+                'Success Rate',
+                f'NumObs {operator} {"" if do_not_play else score_fmt}',
+            ], data = [
+                f"{data.loc[final_row,'Close']:.2f}",
+                f'{text_cond} {score:.1%}',
+                f'{historical_proba:.1%}', 
+                num_obs,
+                ])
+
+            results.columns = ['Outputs']
+
+            # st.subheader('New Prediction')
+            int_labels = ['(-∞, .20]', '(.20, .40]', '(.40, .60]', '(.60, .80]', '(.80, ∞]']
+            # df_probas = res1.groupby(pd.qcut(res1['Predicted'],5)).agg({'True':[np.mean,len,np.sum]})
+            df_probas = res1.groupby(pd.cut(res1['Predicted'], bins = [-np.inf, 0.2, 0.4, 0.6, 0.8, np.inf], labels = int_labels)).agg({'True':[np.mean,len,np.sum]})
+            df_probas.columns = ['PctGreen','NumObs','NumGreen']
+
+            roc_auc_score_all = roc_auc_score(res1['True'].astype(int), res1['Predicted'].values)
+            precision_score_all = precision_score(res1['True'].astype(int), res1['Predicted'] > 0.5)
+            recall_score_all = recall_score(res1['True'].astype(int), res1['Predicted'] > 0.5)
+            len_all = len(res1)
+
+            res2_filtered = res1.loc[(res1['Predicted'] > 0.6) | (res1['Predicted'] <= 0.4)]
+
+            roc_auc_score_hi = roc_auc_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'].values)
+            precision_score_hi = precision_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'] > 0.5)
+            recall_score_hi = recall_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'] > 0.5)
+            len_hi = len(res2_filtered)
+
+            df_performance = pd.DataFrame(
+                index=[
+                    'N',
+                    'ROC AUC',
+                    'Precision',
+                    'Recall'
+                ],
+                columns = [
+                    'All',
+                    'High Confidence'
+                ],
+                data = [
+                    [len_all, len_hi],
+                    [roc_auc_score_all, roc_auc_score_hi],
+                    [precision_score_all, precision_score_hi],
+                    [recall_score_all, recall_score_hi]
+                ]
+            ).round(2)
+
+            def get_acc(t, p):
+                if t == False and p <= 0.4:
+                    return '✅'
+                elif t == True and p > 0.6:
+                    return '✅'
+                elif t == False and p > 0.6:
+                    return '❌'
+                elif t == True and p <= 0.4:
+                    return '❌'
+                else:
+                    return '🟨'
+                
+            def get_acc_text(t, p):
+                if t == False and p <= 0.4:
+                    return 'Correct'
+                elif t == True and p > 0.6:
+                    return 'Correct'
+                elif t == False and p > 0.6:
+                    return 'Incorrect'
+                elif t == True and p <= 0.4:
+                    return 'Incorrect'
+                else:
+                    return 'No Action'
+
+            perf_daily = res1.copy()
+            perf_daily['TargetDate'] = perf_daily.index + BDay(1)
+            perf_daily['Accuracy'] = [get_acc(t, p) for t, p in zip(perf_daily['True'], perf_daily['Predicted'])]
+            perf_daily['AccuracyText'] = [get_acc_text(t, p) for t, p in zip(perf_daily['True'], perf_daily['Predicted'])]
+            perf_daily['ConfidenceScore'] = [x if x > 0.6 else 1-x if x <= 0.4 else x for x in perf_daily['Predicted']]
+            perf_daily = perf_daily[['TargetDate','Predicted','True','Accuracy','AccuracyText','ConfidenceScore']]
+
+            def convert_df(df):
+                # IMPORTANT: Cache the conversion to prevent computation on every rerun
+                return df.to_csv()
+
+            csv = convert_df(perf_daily)
+
+            with tab1:
+                st.subheader(f'Pred for {curr_date} as of 7:30AM PST')
+                st.write(results)
+                st.write(df_probas)
+            with tab2:
+                st.subheader('Latest Data for Pred')
+                st.write(new_pred)
+            with tab3:
+                st.subheader('Historical Data')
+                st.write(df_final)
+            with tab4:
+                st.subheader('Performance')
+                st.write(df_performance)
+                st.write(perf_daily[['TargetDate','Predicted','True','Accuracy']])
+                # st.download_button(
+                #     label="Download Historical Performance",
+                #     data=csv,
+                fname='performance_for_60m_model.csv'
+                # )
+
+if submitted:
+    st.download_button(
+        label="Download Historical Performance",
+        data=csv,
+        file_name=fname,
+    )
+    st.caption('⚠️ Downloading the CSV will reload the page. ⚠️')