the great simplification part 1

app.py

@@ -119,34 +119,6 @@ with st.form("choose_model"):
 
             with st.spinner("Getting new prediction..."):
 
-                model_cols = [
-                    'BigNewsDay',
-                    'Quarter',
-                    'Perf5Day',
-                    'Perf5Day_n1',
-                    'DaysGreen',
-                    'DaysRed',
-                    'CurrentGap',
-                    'RangePct',
-                    'RangePct_n1',
-                    'RangePct_n2',
-                    'OHLC4_VIX',
-                    'OHLC4_VIX_n1',
-                    'OHLC4_VIX_n2',
-                    'OpenL1',
-                    'OpenL2',
-                    'OpenH1',
-                    'OpenH2',
-                    'L1TouchPct',
-                    'L2TouchPct',
-                    'H1TouchPct',
-                    'H2TouchPct',
-                    'L1BreakPct',
-                    'L2BreakPct',
-                    'H1BreakPct',
-                    'H2BreakPct'
-                ]
-
                 # Get last row
                 new_pred = data.loc[final_row, model_cols]
 
@@ -187,12 +159,12 @@ with st.form("choose_model"):
         elif option == '07:00':
         # run30 = st.button('🏃🏽‍♂️ Run')
         # if run30:
-            from model_30m import *
+            from model_intra import *
 
             fname='performance_for_30m_model.csv'
 
             with st.spinner('Loading data...'):
-                data, df_final, final_row = get_data()
+                data, df_final, final_row = get_data(1)
             # st.success("✅ Historical data")
 
             with st.spinner("Training models..."):
@@ -204,40 +176,6 @@ with st.form("choose_model"):
 
             with st.spinner("Getting new prediction..."):
 
-                model_cols = [
-                    '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',
-                    'OpenL1',
-                    'OpenL2',
-                    'OpenH1',
-                    'OpenH2',
-                    'L1TouchPct',
-                    'L2TouchPct',
-                    'H1TouchPct',
-                    'H2TouchPct',
-                    'L1BreakPct',
-                    'L2BreakPct',
-                    'H1BreakPct',
-                    'H2BreakPct',
-                    'GreenProbas'
-                ]
-
                 # Get last row
                 new_pred = data.loc[final_row, model_cols]
 
@@ -284,12 +222,12 @@ with st.form("choose_model"):
         elif option == '07:30':
         # run60 = st.button('🏃🏽‍♂️ Run')
         # if run60:
-            from model_1h import *
+            from model_intra import *
             
             fname='performance_for_1h_model.csv'
 
             with st.spinner('Loading data...'):
-                data, df_final, final_row = get_data()
+                data, df_final, final_row = get_data(2)
             # st.success("✅ Historical data")
 
             with st.spinner("Training models..."):
@@ -301,40 +239,6 @@ with st.form("choose_model"):
 
             with st.spinner("Getting new prediction..."):
 
-                model_cols = [
-                    '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',
-                    'OpenL1',
-                    'OpenL2',
-                    'OpenH1',
-                    'OpenH2',
-                    'L1TouchPct',
-                    'L2TouchPct',
-                    'H1TouchPct',
-                    'H2TouchPct',
-                    'L1BreakPct',
-                    'L2BreakPct',
-                    'H1BreakPct',
-                    'H2BreakPct',
-                    'GreenProbas'
-                ]
-
                 # Get last row
                 new_pred = data.loc[final_row, model_cols]
 
@@ -381,12 +285,12 @@ with st.form("choose_model"):
         elif option == '08:00':
         # run60 = st.button('🏃🏽‍♂️ Run')
         # if run60:
-            from model_90m import *
+            from model_intra import *
 
             fname='performance_for_90m_model.csv'
 
             with st.spinner('Loading data...'):
-                data, df_final, final_row = get_data()
+                data, df_final, final_row = get_data(3)
             # st.success("✅ Historical data")
 
             with st.spinner("Training models..."):
@@ -398,40 +302,6 @@ with st.form("choose_model"):
 
             with st.spinner("Getting new prediction..."):
 
-                model_cols = [
-                    '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',
-                    'OpenL1',
-                    'OpenL2',
-                    'OpenH1',
-                    'OpenH2',
-                    'L1TouchPct',
-                    'L2TouchPct',
-                    'H1TouchPct',
-                    'H2TouchPct',
-                    'L1BreakPct',
-                    'L2BreakPct',
-                    'H1BreakPct',
-                    'H2BreakPct',
-                    'GreenProbas'
-                ]
-
                 # Get last row
                 new_pred = data.loc[final_row, model_cols]
 
@@ -477,9 +347,26 @@ with st.form("choose_model"):
 
         st.info(f'as of {option} on {curr_date} 👇🏽', icon="🔮")
 
+        # st.subheader('New Prediction')
+
+        # int_labels = ['(0, .20]', '(.20, .40]', '(.40, .60]', '(.60, .80]', '(.80, .1]']
+        # df_probas = res1.groupby(pd.qcut(res1['Predicted'],5)).agg({'True':[np.mean,len,np.sum]})
+        _q = 7
+        lo_thres = 0.4 # res1.loc[middle_quantiles, 'Predicted'].min()
+        hi_thres = 0.6 # res1.loc[middle_quantiles, 'Predicted'].max()
+
+        data['ClosePct'] = (data['Close'] / data['PrevClose']) - 1
+        data['ClosePct'] = data['ClosePct'].shift(-1)
+        res1 = res1.merge(data['ClosePct'], left_index=True,right_index=True)
+        # 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],'ClosePct':[np.mean]})
+        df_probas = res1.groupby(pd.cut(res1['Predicted'], _q)).agg({'True':[np.mean,len,np.sum],'ClosePct':[np.mean]})
+        
+        df_probas.columns = ['PctGreen','NumObs','NumGreen','AvgPerf']
+        df_probas['AvgPerf'] = df_probas['AvgPerf'].apply(lambda x: f'{x:.2%}')
+
         green_proba = seq_proba[0]
         red_proba = 1 - green_proba
-        do_not_play = (seq_proba[0] > 0.4) and (seq_proba[0] <= 0.6) 
+        do_not_play = (seq_proba[0] > lo_thres) and (seq_proba[0] <= hi_thres) 
         stdev = 0.01
         score = None
         num_obs = None
@@ -487,14 +374,23 @@ with st.form("choose_model"):
         historical_proba = None
         text_cond = None
         operator = None
+        intv = None
+        for q in df_probas.index:
+            if q.left <= green_proba <= q.right:
+                historical_proba = df_probas.loc[q, 'PctGreen']
+                num_obs = df_probas.loc[q, 'NumObs']
+                intv = f'({q.left:.03f}, {q.right:.03f}])'
+
+        qs = [f'({q.left:.2f}, {q.right:.2f}]' for q in df_probas.index]
+        df_probas.index = qs
 
         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()
+            cond = (res1['Predicted'] > lo_thres) & (res1['Predicted'] <= hi_thres)
+            # num_obs = len(res1.loc[cond])
+            # historical_proba = res1.loc[cond, 'True'].mean()
 
             
         elif green_proba > red_proba:
@@ -504,9 +400,9 @@ with st.form("choose_model"):
             score = green_proba
             # How many with this score?
             cond = (res1['Predicted'] >= green_proba)
-            num_obs = len(res1.loc[cond])
+            # num_obs = len(res1.loc[cond])
             # How often green?
-            historical_proba = res1.loc[cond, 'True'].mean()
+            # historical_proba = res1.loc[cond, 'True'].mean()
             # print(cond)
 
         elif green_proba <= red_proba:
@@ -516,9 +412,9 @@ with st.form("choose_model"):
             score = red_proba
             # How many with this score?
             cond = (res1['Predicted'] <= seq_proba[0])
-            num_obs = len(res1.loc[cond])
+            # num_obs = len(res1.loc[cond])
             # How often green?
-            historical_proba = 1 - res1.loc[cond, 'True'].mean()
+            # historical_proba = 1 - res1.loc[cond, 'True'].mean()
             # print(cond)
 
         score_fmt = f'{score:.1%}'
@@ -536,8 +432,8 @@ with st.form("choose_model"):
             index=['Results'], 
             data = {
                 'Confidence':[f'{text_cond} {score:.1%}'],
-                'Success':[f'{historical_proba:.1%}'],
-                f'N{operator}{score:.1%}':[f'{num_obs} / {len(data)}'],
+                'Calib. Proba':[f'{historical_proba:.1%}'],
+                f'{intv}':[f'{num_obs}'],
                 'Prev / Curr':[f'{prev_close:.2f} / {curr_close:.2f}']
             })
 
@@ -551,26 +447,16 @@ with st.form("choose_model"):
 
         prices.columns = ['']
 
-        # st.subheader('New Prediction')
-
-        int_labels = ['(0, .20]', '(.20, .40]', '(.40, .60]', '(.60, .80]', '(.80, .1]']
-        # df_probas = res1.groupby(pd.qcut(res1['Predicted'],5)).agg({'True':[np.mean,len,np.sum]})
-
-        data['ClosePct'] = (data['Close'] / data['PrevClose']) - 1
-        data['ClosePct'] = data['ClosePct'].shift(-1)
-        res1 = res1.merge(data['ClosePct'], left_index=True,right_index=True)
-        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],'ClosePct':[np.mean]})
-        df_probas.columns = ['PctGreen','NumObs','NumGreen','AvgPerf']
-        df_probas['AvgPerf'] = df_probas['AvgPerf'].apply(lambda x: f'{x:.2%}')
-
         roc_auc_score_all = roc_auc_score(res1['True'].astype(int), res1['Predicted'].values)
+        roc_auc_score_calib = roc_auc_score(res1.dropna(subset='CalibGreenProba')['True'].astype(int), res1.dropna(subset='CalibGreenProba')['CalibGreenProba'].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)]
+        res2_filtered = res1.loc[(res1['Predicted'] > hi_thres) | (res1['Predicted'] <= lo_thres)]
 
         roc_auc_score_hi = roc_auc_score(res2_filtered['True'].astype(int), res2_filtered['Predicted'].values)
+        roc_auc_score_hi_calib = roc_auc_score(res2_filtered.dropna(subset='CalibGreenProba')['True'].astype(int), res2_filtered.dropna(subset='CalibGreenProba')['CalibGreenProba'].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)
@@ -579,6 +465,7 @@ with st.form("choose_model"):
             index=[
                 'N',
                 'ROC AUC',
+                'Calib. AUC',
                 'Precision',
                 'Recall'
             ],
@@ -589,31 +476,44 @@ with st.form("choose_model"):
             data = [
                 [len_all, len_hi],
                 [roc_auc_score_all, roc_auc_score_hi],
+                [roc_auc_score_calib, roc_auc_score_hi_calib],
                 [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:
+            if t == False and p <= lo_thres:
+                return '✅' # &#9989;</p>
+            elif t == True and p > hi_thres:
+                return '✅' # 
+            elif t == False and p > hi_thres:
+                return '❌' # &#10060;</p>
+            elif t == True and p <= lo_thres:
                 return '❌'
             else:
-                return '🟨'
+                return '🟨' # &#11036;</p>
             
+        def get_acc_html(t, p):
+            if t == False and p <= lo_thres:
+                return '&#9989;'
+            elif t == True and p > hi_thres:
+                return '&#9989;'
+            elif t == False and p > hi_thres:
+                return '&#10060;'
+            elif t == True and p <= lo_thres:
+                return '&#10060;'
+            else:
+                return '&#11036;'
+
         def get_acc_text(t, p):
-            if t == False and p <= 0.4:
+            if t == False and p <= lo_thres:
                 return 'Correct'
-            elif t == True and p > 0.6:
+            elif t == True and p > hi_thres:
                 return 'Correct'
-            elif t == False and p > 0.6:
+            elif t == False and p > hi_thres:
                 return 'Incorrect'
-            elif t == True and p <= 0.4:
+            elif t == True and p <= lo_thres:
                 return 'Incorrect'
             else:
                 return 'No Action'

model_1h.py

@@ -80,7 +80,9 @@ model_cols = [
     'L2BreakPct',
     'H1BreakPct',
     'H2BreakPct',
-    'GreenProbas'
+    'GreenProbas',
+    # 'GapFillGreenProba'
+
 ]
 
 def walk_forward_validation_seq(df, target_column_clf, target_column_regr, num_training_rows, num_periods):
@@ -334,6 +336,7 @@ def get_data():
     data['OHLC4_VIX_n1'] = data['OHLC4_VIX'].shift(1)
     data['OHLC4_VIX_n2'] = data['OHLC4_VIX'].shift(2)
     data['CurrentGap'] = (data['Open'] - data['PrevClose']) / data['PrevClose']
+    data['CurrentGapHist'] = data['CurrentGap'].copy()
     data['CurrentGap'] = data['CurrentGap'].shift(-1)
     data['DayOfWeek'] = pd.to_datetime(data.index)
     data['DayOfWeek'] = data['DayOfWeek'].dt.day
@@ -388,6 +391,7 @@ def get_data():
     data['CurrentHigh30'] = data['High30'].shift(-1)
     data['CurrentLow30'] = data['Low30'].shift(-1)
     data['CurrentClose30'] = data['Close30'].shift(-1)
+    data['HistClose30toPrevClose'] = (data['Close30'] / data['PrevClose']) - 1
 
     # Open to High
     data['CurrentHigh30toClose'] = (data['CurrentHigh30'] / data['Close']) - 1
@@ -408,13 +412,13 @@ def get_data():
     data['Quarter'] = data['DayOfWeek'].dt.quarter
     data['DayOfWeek'] = data['DayOfWeek'].dt.weekday
 
-    def get_quintiles(df):
-        return df.groupby(pd.qcut(df['CurrentClose30toClose'], 5))['GreenDay'].mean()
+    def get_quintiles(df, col_name, q):
+        return df.groupby(pd.qcut(df[col_name], q))['GreenDay'].mean()
 
     probas = []
     for i, pct in enumerate(data['CurrentClose30toClose']):
         try:
-            df_q = get_quintiles(data.iloc[:i])
+            df_q = get_quintiles(data.iloc[:i], 'HistClose30toPrevClose', 5)
             for q in df_q.index:
                 if q.left <= pct <= q.right:
                     p = df_q[q]
@@ -423,7 +427,20 @@ def get_data():
 
         probas.append(p)
 
+    # gapfills = []
+    # for i, pct in enumerate(data['CurrentGap']):
+    #     try:
+    #         df_q = get_quintiles(data.iloc[:i], 'CurrentGapHist', 5)
+    #         for q in df_q.index:
+    #             if q.left <= pct <= q.right:
+    #                 p = df_q[q]
+    #     except:
+    #         p = None
+
+    #     gapfills.append(p)
+
     data['GreenProbas'] = probas
+    # data['GapFillGreenProba'] = gapfills
 
     for rid in tqdm(release_ids, desc='Merging econ data'):
         # Get the name of the release
@@ -459,41 +476,6 @@ def get_data():
 
     exp_row = data.index[-1]
 
-    df_final = 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',
-        'OpenL1',
-        'OpenL2',
-        'OpenH1',
-        'OpenH2',
-        'L1TouchPct',
-        'L2TouchPct',
-        'H1TouchPct',
-        'H2TouchPct',
-        'L1BreakPct',
-        'L2BreakPct',
-        'H1BreakPct',
-        'H2BreakPct',
-        'GreenProbas',
-        'Target',
-        'Target_clf'
-        ]]
+    df_final = data.loc[:final_row, model_cols + ['Target','Target_clf']]
     df_final = df_final.dropna(subset=['Target','Target_clf','Perf5Day_n1'])
     return data, df_final, final_row

model_30m.py

@@ -81,7 +81,8 @@ model_cols = [
     'L2BreakPct',
     'H1BreakPct',
     'H2BreakPct',
-    'GreenProbas'
+    'GreenProbas',
+    # 'GapFillGreenProba'
 ]
 
 def walk_forward_validation_seq(df, target_column_clf, target_column_regr, num_training_rows, num_periods):
@@ -127,6 +128,30 @@ def walk_forward_validation_seq(df, target_column_clf, target_column_regr, num_t
         overall_results.append(result_df)
 
     df_results = pd.concat(overall_results)
+
+    # Calibrate Probabilities
+    def get_quantiles(df, col_name, q):
+        return df.groupby(pd.qcut(df[col_name], q))['True'].mean()
+
+    greenprobas = []
+    meanprobas = []
+    for i, pct in enumerate(df_results['Predicted']):
+        try:
+            df_q = get_quantiles(df_results.iloc[:i], 'Predicted', 7)
+            for q in df_q.index:
+                if q.left <= pct <= q.right:
+                    p = df_q[q]
+                    c = (q.left + q.right) / 2
+        except:
+            p = None
+            c = None
+
+        greenprobas.append(p)
+        meanprobas.append(c)
+
+    df_results['CalibPredicted'] = meanprobas
+    df_results['CalibGreenProba'] = greenprobas
+
     return df_results, model1, model2
 
 
@@ -320,6 +345,7 @@ def get_data():
     data['OHLC4_VIX_n1'] = data['OHLC4_VIX'].shift(1)
     data['OHLC4_VIX_n2'] = data['OHLC4_VIX'].shift(2)
     data['CurrentGap'] = (data['Open'] - data['PrevClose']) / data['PrevClose']
+    data['CurrentGapHist'] = data['CurrentGap'].copy()
     data['CurrentGap'] = data['CurrentGap'].shift(-1)
     data['DayOfWeek'] = pd.to_datetime(data.index)
     data['DayOfWeek'] = data['DayOfWeek'].dt.day
@@ -329,6 +355,7 @@ def get_data():
     data['CurrentHigh30'] = data['High30'].shift(-1)
     data['CurrentLow30'] = data['Low30'].shift(-1)
     data['CurrentClose30'] = data['Close30'].shift(-1)
+    data['HistClose30toPrevClose'] = (data['Close30'] / data['PrevClose']) - 1
 
 
     # Open to High
@@ -410,13 +437,13 @@ def get_data():
         data[col+'Pct'] = data[col+'Pct'].shift(-1)
 
 
-    def get_quintiles(df):
-        return df.groupby(pd.qcut(df['CurrentClose30toClose'], 5))['GreenDay'].mean()
+    def get_quintiles(df, col_name, q):
+        return df.groupby(pd.qcut(df[col_name], q))['GreenDay'].mean()
 
     probas = []
     for i, pct in enumerate(data['CurrentClose30toClose']):
         try:
-            df_q = get_quintiles(data.iloc[:i])
+            df_q = get_quintiles(data.iloc[:i], 'HistClose30toPrevClose', 10)
             for q in df_q.index:
                 if q.left <= pct <= q.right:
                     p = df_q[q]
@@ -425,7 +452,20 @@ def get_data():
 
         probas.append(p)
 
+    # gapfills = []
+    # for i, pct in enumerate(data['CurrentGap']):
+    #     try:
+    #         df_q = get_quintiles(data.iloc[:i], 'CurrentGapHist', 5)
+    #         for q in df_q.index:
+    #             if q.left <= pct <= q.right:
+    #                 p = df_q[q]
+    #     except:
+    #         p = None
+
+    #     gapfills.append(p)
+
     data['GreenProbas'] = probas
+    # data['GapFillGreenProba'] = gapfills
 
     for rid in tqdm(release_ids, desc='Merging econ data'):
         # Get the name of the release
@@ -461,41 +501,6 @@ def get_data():
 
     exp_row = data.index[-1]
 
-    df_final = 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',
-        'OpenL1',
-        'OpenL2',
-        'OpenH1',
-        'OpenH2',
-        'L1TouchPct',
-        'L2TouchPct',
-        'H1TouchPct',
-        'H2TouchPct',
-        'L1BreakPct',
-        'L2BreakPct',
-        'H1BreakPct',
-        'H2BreakPct',
-        'GreenProbas',
-        'Target',
-        'Target_clf'
-        ]]
+    df_final = data.loc[:final_row, model_cols + ['Target', 'Target_clf']]
     df_final = df_final.dropna(subset=['Target','Target_clf','Perf5Day_n1'])
     return data, df_final, final_row

model_90m.py

@@ -80,7 +80,8 @@ model_cols = [
     'L2BreakPct',
     'H1BreakPct',
     'H2BreakPct',
-    'GreenProbas'
+    'GreenProbas',
+    # 'GapFillGreenProba'
 ]
 
 def walk_forward_validation_seq(df, target_column_clf, target_column_regr, num_training_rows, num_periods):
@@ -334,6 +335,7 @@ def get_data():
     data['OHLC4_VIX_n1'] = data['OHLC4_VIX'].shift(1)
     data['OHLC4_VIX_n2'] = data['OHLC4_VIX'].shift(2)
     data['CurrentGap'] = (data['Open'] - data['PrevClose']) / data['PrevClose']
+    data['CurrentGapHist'] = data['CurrentGap'].copy()
     data['CurrentGap'] = data['CurrentGap'].shift(-1)
     data['DayOfWeek'] = pd.to_datetime(data.index)
     data['DayOfWeek'] = data['DayOfWeek'].dt.day
@@ -342,6 +344,8 @@ def get_data():
     data['CurrentHigh30'] = data['High30'].shift(-1)
     data['CurrentLow30'] = data['Low30'].shift(-1)
     data['CurrentClose30'] = data['Close30'].shift(-1)
+    data['HistClose30toPrevClose'] = (data['Close30'] / data['PrevClose']) - 1
+
 
     # Open to High
     data['CurrentHigh30toClose'] = (data['CurrentHigh30'] / data['Close']) - 1
@@ -408,13 +412,13 @@ def get_data():
         data[col+'Pct'] = data[col].rolling(100).mean()
         data[col+'Pct'] = data[col+'Pct'].shift(-1)
 
-    def get_quintiles(df):
-        return df.groupby(pd.qcut(df['CurrentClose30toClose'], 5))['GreenDay'].mean()
+    def get_quintiles(df, col_name, q):
+        return df.groupby(pd.qcut(df[col_name], q))['GreenDay'].mean()
 
     probas = []
     for i, pct in enumerate(data['CurrentClose30toClose']):
         try:
-            df_q = get_quintiles(data.iloc[:i])
+            df_q = get_quintiles(data.iloc[:i], 'HistClose30toPrevClose', 5)
             for q in df_q.index:
                 if q.left <= pct <= q.right:
                     p = df_q[q]
@@ -423,7 +427,20 @@ def get_data():
 
         probas.append(p)
 
+    # gapfills = []
+    # for i, pct in enumerate(data['CurrentGap']):
+    #     try:
+    #         df_q = get_quintiles(data.iloc[:i], 'CurrentGapHist', 5)
+    #         for q in df_q.index:
+    #             if q.left <= pct <= q.right:
+    #                 p = df_q[q]
+    #     except:
+    #         p = None
+
+    #     gapfills.append(p)
+
     data['GreenProbas'] = probas
+    # data['GapFillGreenProba'] = gapfills
 
     for rid in tqdm(release_ids, desc='Merging econ data'):
         # Get the name of the release
@@ -459,41 +476,6 @@ def get_data():
 
     exp_row = data.index[-1]
 
-    df_final = 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',
-        'OpenL1',
-        'OpenL2',
-        'OpenH1',
-        'OpenH2',
-        'L1TouchPct',
-        'L2TouchPct',
-        'H1TouchPct',
-        'H2TouchPct',
-        'L1BreakPct',
-        'L2BreakPct',
-        'H1BreakPct',
-        'H2BreakPct',
-        'GreenProbas',
-        'Target',
-        'Target_clf'
-        ]]
+    df_final = data.loc[:final_row, model_cols + ['Target','Target_clf']]
     df_final = df_final.dropna(subset=['Target','Target_clf','Perf5Day_n1'])
     return data, df_final, final_row

model_intra.py

@@ -0,0 +1,518 @@
+import streamlit as st
+import pandas as pd
+import pandas_datareader as pdr
+import numpy as np
+import yfinance as yf
+import json
+import requests
+from bs4 import BeautifulSoup
+from typing import List
+import xgboost as xgb
+from tqdm import tqdm
+from sklearn import linear_model
+import joblib
+import os
+from sklearn.metrics import roc_auc_score, precision_score, recall_score
+import datetime
+from pandas.tseries.offsets import BDay
+from datasets import load_dataset
+import lightgbm as lgb
+
+# If the dataset is gated/private, make sure you have run huggingface-cli login
+def walk_forward_validation(df, target_column, num_training_rows, num_periods):
+    
+    # Create an XGBRegressor model
+    # model = xgb.XGBRegressor(n_estimators=100, objective='reg:squarederror', random_state = 42)
+    model = linear_model.LinearRegression()
+
+    overall_results = []
+    # Iterate over the rows in the DataFrame, one step at a time
+    for i in tqdm(range(num_training_rows, df.shape[0] - num_periods + 1),desc='LR Model'):
+        # Split the data into training and test sets
+        X_train = df.drop(target_column, axis=1).iloc[:i]
+        y_train = df[target_column].iloc[:i]
+        X_test = df.drop(target_column, axis=1).iloc[i:i+num_periods]
+        y_test = df[target_column].iloc[i:i+num_periods]
+        
+        # Fit the model to the training data
+        model.fit(X_train, y_train)
+        
+        # Make a prediction on the test data
+        predictions = model.predict(X_test)
+        
+        # Create a DataFrame to store the true and predicted values
+        result_df = pd.DataFrame({'True': y_test, 'Predicted': predictions}, index=y_test.index)
+        
+        overall_results.append(result_df)
+
+    df_results = pd.concat(overall_results)
+    # model.save_model('model_lr.bin')
+    # Return the true and predicted values, and fitted model
+    return df_results, model
+
+model_cols = [
+    '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',
+    'OpenL1',
+    'OpenL2',
+    'OpenH1',
+    'OpenH2',
+    'L1TouchPct',
+    'L2TouchPct',
+    'H1TouchPct',
+    'H2TouchPct',
+    'L1BreakPct',
+    'L2BreakPct',
+    'H1BreakPct',
+    'H2BreakPct',
+    'GreenProbas',
+    # 'GapFillGreenProba'
+]
+
+def walk_forward_validation_seq(df, target_column_clf, target_column_regr, num_training_rows, num_periods):
+
+    # Create run the regression model to get its target
+    res, model1 = walk_forward_validation(df.drop(columns=[target_column_clf]).dropna(), target_column_regr, num_training_rows, num_periods)
+    # joblib.dump(model1, 'model1.bin')
+
+    # Merge the result df back on the df for feeding into the classifier
+    for_merge = res[['Predicted']]
+    for_merge.columns = ['RegrModelOut']
+    for_merge['RegrModelOut'] = for_merge['RegrModelOut'] > 0
+    df = df.merge(for_merge, left_index=True, right_index=True)
+    df = df.drop(columns=[target_column_regr])
+    df = df[model_cols + ['RegrModelOut', target_column_clf]]
+    
+    df[target_column_clf] = df[target_column_clf].astype(bool)
+    df['RegrModelOut'] = df['RegrModelOut'].astype(bool)
+
+    # Create an XGBRegressor model
+    # model2 = xgb.XGBClassifier(n_estimators=10, random_state = 42)
+    model2 = lgb.LGBMClassifier(n_estimators=10, random_state=42, verbosity=-1)
+    # model = linear_model.LogisticRegression(max_iter=1500)
+    
+    overall_results = []
+    # Iterate over the rows in the DataFrame, one step at a time
+    for i in tqdm(range(num_training_rows, df.shape[0] - num_periods + 1),'CLF Model'):
+        # Split the data into training and test sets
+        X_train = df.drop(target_column_clf, axis=1).iloc[:i]
+        y_train = df[target_column_clf].iloc[:i]
+        X_test = df.drop(target_column_clf, axis=1).iloc[i:i+num_periods]
+        y_test = df[target_column_clf].iloc[i:i+num_periods]
+        
+        # Fit the model to the training data
+        model2.fit(X_train, y_train)
+        
+        # Make a prediction on the test data
+        predictions = model2.predict_proba(X_test)[:,-1]
+        
+        # Create a DataFrame to store the true and predicted values
+        result_df = pd.DataFrame({'True': y_test, 'Predicted': predictions}, index=y_test.index)
+        
+        overall_results.append(result_df)
+
+    df_results = pd.concat(overall_results)
+
+    # Calibrate Probabilities
+    def get_quantiles(df, col_name, q):
+        return df.groupby(pd.cut(df[col_name], q))['True'].mean()
+
+    greenprobas = []
+    meanprobas = []
+    for i, pct in enumerate(df_results['Predicted']):
+        try:
+            df_q = get_quantiles(df_results.iloc[:i], 'Predicted', 7)
+            for q in df_q.index:
+                if q.left <= pct <= q.right:
+                    p = df_q[q]
+                    c = (q.left + q.right) / 2
+        except:
+            p = None
+            c = None
+
+        greenprobas.append(p)
+        meanprobas.append(c)
+
+    df_results['CalibPredicted'] = meanprobas
+    df_results['CalibGreenProba'] = greenprobas
+
+    return df_results, model1, model2
+
+
+def seq_predict_proba(df, trained_reg_model, trained_clf_model):
+    regr_pred = trained_reg_model.predict(df)
+    regr_pred = regr_pred > 0
+    new_df = df.copy()
+    new_df['RegrModelOut'] = regr_pred
+    clf_pred_proba = trained_clf_model.predict_proba(new_df[model_cols + ['RegrModelOut']])[:,-1]
+    return clf_pred_proba
+
+def get_data(periods_30m = 1):
+    # f = open('settings.json')
+    # j = json.load(f)
+    # API_KEY_FRED = j["API_KEY_FRED"]
+
+    API_KEY_FRED = os.getenv('API_KEY_FRED')
+    
+    def parse_release_dates(release_id: str) -> List[str]:
+        release_dates_url = f'https://api.stlouisfed.org/fred/release/dates?release_id={release_id}&realtime_start=2015-01-01&include_release_dates_with_no_data=true&api_key={API_KEY_FRED}'
+        r = requests.get(release_dates_url)
+        text = r.text
+        soup = BeautifulSoup(text, 'xml')
+        dates = []
+        for release_date_tag in soup.find_all('release_date', {'release_id': release_id}):
+            dates.append(release_date_tag.text)
+        return dates
+
+    def parse_release_dates_obs(series_id: str) -> List[str]:
+        obs_url = f'https://api.stlouisfed.org/fred/series/observations?series_id={series_id}&realtime_start=2015-01-01&include_release_dates_with_no_data=true&api_key={API_KEY_FRED}'
+        r = requests.get(obs_url)
+        text = r.text
+        soup = BeautifulSoup(text, 'xml')
+        observations  = []
+        for observation_tag in soup.find_all('observation'):
+            date = observation_tag.get('date')
+            value = observation_tag.get('value')
+            observations.append((date, value))
+        return observations
+
+    econ_dfs = {}
+
+    econ_tickers = [
+        'WALCL',
+        'NFCI',
+        'WRESBAL'
+    ]
+
+    for et in tqdm(econ_tickers, desc='getting econ tickers'):
+        # p = parse_release_dates_obs(et)
+        # df = pd.DataFrame(columns = ['ds',et], data = p)
+        df = pdr.get_data_fred(et)
+        df.index = df.index.rename('ds')
+        # df.index = pd.to_datetime(df.index.rename('ds')).dt.tz_localize(None)
+        # df['ds'] = pd.to_datetime(df['ds']).dt.tz_localize(None)
+        econ_dfs[et] = df
+
+    # walcl = pd.DataFrame(columns = ['ds','WALCL'], data = p)
+    # walcl['ds'] = pd.to_datetime(walcl['ds']).dt.tz_localize(None)
+
+    # nfci = pd.DataFrame(columns = ['ds','NFCI'], data = p2)
+    # nfci['ds'] = pd.to_datetime(nfci['ds']).dt.tz_localize(None)
+
+    release_ids = [
+        "10", # "Consumer Price Index"
+        "46", # "Producer Price Index"
+        "50", # "Employment Situation"
+        "53", # "Gross Domestic Product"
+        "103", # "Discount Rate Meeting Minutes"
+        "180", # "Unemployment Insurance Weekly Claims Report"
+        "194", # "ADP National Employment Report"
+        "323" # "Trimmed Mean PCE Inflation Rate"
+    ]
+
+    release_names = [
+        "CPI",
+        "PPI",
+        "NFP",
+        "GDP",
+        "FOMC",
+        "UNEMP",
+        "ADP",
+        "PCE"
+    ]
+
+    releases = {}
+
+    for rid, n in tqdm(zip(release_ids, release_names), total = len(release_ids), desc='Getting release dates'):
+        releases[rid] = {}
+        releases[rid]['dates'] = parse_release_dates(rid)
+        releases[rid]['name'] = n 
+
+    # Create a DF that has all dates with the name of the col as 1
+    # Once merged on the main dataframe, days with econ events will be 1 or None. Fill NA with 0
+    # This column serves as the true/false indicator of whether there was economic data released that day.
+    for rid in tqdm(release_ids, desc='Making indicators'):
+        releases[rid]['df'] = pd.DataFrame(
+            index=releases[rid]['dates'],
+            data={
+            releases[rid]['name']: 1
+            })
+        releases[rid]['df'].index = pd.DatetimeIndex(releases[rid]['df'].index)
+        # releases[rid]['df']['ds'] = pd.to_datetime(releases[rid]['df']['ds']).dt.tz_localize(None)
+        # releases[rid]['df'] = releases[rid]['df'].set_index('ds')
+
+    vix = yf.Ticker('^VIX')
+    spx = yf.Ticker('^GSPC')
+
+    # Pull in data
+    data = load_dataset("boomsss/spx_intra", split='train')
+
+    rows = [d['text'] for d in data]
+    rows = [x.split(',') for x in rows]
+
+    fr = pd.DataFrame(columns=[
+        'Datetime','Open','High','Low','Close'
+    ], data = rows)
+
+    fr['Datetime'] = pd.to_datetime(fr['Datetime'])
+    fr['Datetime'] = fr['Datetime'].dt.tz_localize('America/New_York')
+    fr = fr.set_index('Datetime')
+    fr['Open'] = pd.to_numeric(fr['Open'])
+    fr['High'] = pd.to_numeric(fr['High'])
+    fr['Low'] = pd.to_numeric(fr['Low'])
+    fr['Close'] = pd.to_numeric(fr['Close'])
+    
+    # Get incremental date
+    last_date = fr.index.date[-1]
+    last_date = last_date + datetime.timedelta(days=1)
+    # Get incremental data
+    spx1 = yf.Ticker('^GSPC')
+    yfp = spx1.history(start=last_date, interval='30m')
+
+    if len(yfp) > 0:
+        # Concat current and incremental
+        df_30m = pd.concat([fr, yfp])
+    else:
+        df_30m = fr.copy()
+
+    # Get the first 30 minute bar
+    df_30m = df_30m.reset_index()
+    df_30m['Datetime'] = df_30m['Datetime'].dt.date
+    df_30m = df_30m.groupby('Datetime').head(periods_30m)
+    df_30m = df_30m.set_index('Datetime',drop=True)
+    # Rename the columns
+    df_30m = df_30m[['Open','High','Low','Close']]
+
+    opens_1h = df_30m.groupby('Datetime')['Open'].head(1)
+    highs_1h = df_30m.groupby('Datetime')['High'].max()
+    lows_1h = df_30m.groupby('Datetime')['Low'].min()
+    closes_1h = df_30m.groupby('Datetime')['Close'].tail(1)
+    
+    df_1h = pd.DataFrame(index=df_30m.index.unique())
+    df_1h['Open'] = opens_1h
+    df_1h['High'] = highs_1h
+    df_1h['Low'] = lows_1h
+    df_1h['Close'] = closes_1h
+
+    df_1h.columns = ['Open30','High30','Low30','Close30']
+
+    prices_vix = vix.history(start='2018-07-01', interval='1d')
+    prices_spx = spx.history(start='2018-07-01', interval='1d')
+    prices_spx['index'] = [str(x).split()[0] for x in prices_spx.index]
+    prices_spx['index'] = pd.to_datetime(prices_spx['index']).dt.date
+    prices_spx.index = prices_spx['index']
+    prices_spx = prices_spx.drop(columns='index')
+    prices_spx.index = pd.DatetimeIndex(prices_spx.index)
+
+
+    prices_vix['index'] = [str(x).split()[0] for x in prices_vix.index]
+    prices_vix['index'] = pd.to_datetime(prices_vix['index']).dt.date
+    prices_vix.index = prices_vix['index']
+    prices_vix = prices_vix.drop(columns='index')
+    prices_vix.index = pd.DatetimeIndex(prices_vix.index)
+
+
+    data = prices_spx.merge(df_1h, left_index=True, right_index=True)
+    data = data.merge(prices_vix[['Open','High','Low','Close']], left_index=True, right_index=True, suffixes=['','_VIX'])
+
+    # Features
+    data['PrevClose'] = data['Close'].shift(1)
+    data['Perf5Day'] = data['Close'] > data['Close'].shift(5)
+    data['Perf5Day_n1'] = data['Perf5Day'].shift(1)
+    data['Perf5Day_n1'] = data['Perf5Day_n1'].astype(bool)
+    data['GreenDay'] = (data['Close'] > data['PrevClose']) * 1
+    data['RedDay'] = (data['Close'] <= data['PrevClose']) * 1
+
+    data['VIX5Day'] = data['Close_VIX'] > data['Close_VIX'].shift(5)
+    data['VIX5Day_n1'] = data['VIX5Day'].astype(bool)
+
+    data['Range'] = data[['Open','High']].max(axis=1) - data[['Low','Open']].min(axis=1) # Current day range in points
+    data['RangePct'] = data['Range'] / data['Close']
+    data['VIXLevel'] = pd.qcut(data['Close_VIX'], 4)
+    data['OHLC4_VIX'] = data[['Open_VIX','High_VIX','Low_VIX','Close_VIX']].mean(axis=1)
+    data['OHLC4'] = data[['Open','High','Low','Close']].mean(axis=1)
+    data['OHLC4_Trend'] = data['OHLC4'] > data['OHLC4'].shift(1)
+    data['OHLC4_Trend_n1'] = data['OHLC4_Trend'].shift(1)
+    data['OHLC4_Trend_n1'] = data['OHLC4_Trend_n1'].astype(float)
+    data['OHLC4_Trend_n2'] = data['OHLC4_Trend'].shift(1)
+    data['OHLC4_Trend_n2'] = data['OHLC4_Trend_n2'].astype(float)
+    data['RangePct_n1'] = data['RangePct'].shift(1)
+    data['RangePct_n2'] = data['RangePct'].shift(2)
+    data['OHLC4_VIX_n1'] = data['OHLC4_VIX'].shift(1)
+    data['OHLC4_VIX_n2'] = data['OHLC4_VIX'].shift(2)
+    data['CurrentGap'] = (data['Open'] - data['PrevClose']) / data['PrevClose']
+    data['CurrentGapHist'] = data['CurrentGap'].copy()
+    data['CurrentGap'] = data['CurrentGap'].shift(-1)
+    data['DayOfWeek'] = pd.to_datetime(data.index)
+    data['DayOfWeek'] = data['DayOfWeek'].dt.day
+
+    # Intraday features
+    data['CurrentOpen30'] = data['Open30'].shift(-1)
+    data['CurrentHigh30'] = data['High30'].shift(-1)
+    data['CurrentLow30'] = data['Low30'].shift(-1)
+    data['CurrentClose30'] = data['Close30'].shift(-1)
+    data['HistClose30toPrevClose'] = (data['Close30'] / data['PrevClose']) - 1
+
+
+    # Open to High
+    data['CurrentHigh30toClose'] = (data['CurrentHigh30'] / data['Close']) - 1
+    data['CurrentLow30toClose'] = (data['CurrentLow30'] / data['Close']) - 1
+    data['CurrentClose30toClose'] = (data['CurrentClose30'] / data['Close']) - 1
+    data['CurrentRange30'] = (data['CurrentHigh30'] - data['CurrentLow30']) / data['Close']
+    data['GapFill30'] = [low <= prev_close if gap > 0 else high >= prev_close for high, low, prev_close, gap in zip(data['CurrentHigh30'], data['CurrentLow30'], data['Close'], data['CurrentGap'])]
+    
+    # Target -- the next day's low
+    data['Target'] = (data['OHLC4'] / data['PrevClose']) - 1
+    data['Target'] = data['Target'].shift(-1)
+    # data['Target'] = data['RangePct'].shift(-1)
+
+    # Target for clf -- whether tomorrow will close above or below today's close
+    data['Target_clf'] = data['Close'] > data['PrevClose']
+    data['Target_clf'] = data['Target_clf'].shift(-1)
+    data['DayOfWeek'] = pd.to_datetime(data.index)
+    data['Quarter'] = data['DayOfWeek'].dt.quarter
+    data['DayOfWeek'] = data['DayOfWeek'].dt.weekday
+
+    # Calculate up
+    data['up'] = 100 * (data['High'].shift(1) - data['Open'].shift(1)) / data['Close'].shift(1)
+
+    # Calculate upSD
+    data['upSD'] = data['up'].rolling(30).std(ddof=0)
+
+    # Calculate aveUp
+    data['aveUp'] = data['up'].rolling(30).mean()
+    data['H1'] = data['Open'] + (data['aveUp'] / 100) * data['Open']
+    data['H2'] = data['Open'] + ((data['aveUp'] + data['upSD']) / 100) * data['Open']
+    data['down'] = 100 * (data['Open'].shift(1) - data['Low'].shift(1)) / data['Close'].shift(1)
+    data['downSD'] = data['down'].rolling(30).std(ddof=0)
+    data['aveDown'] = data['down'].rolling(30).mean()
+    data['L1'] = data['Open'] - (data['aveDown'] / 100) * data['Open']
+    data['L2'] = data['Open'] - ((data['aveDown'] + data['upSD']) / 100) * data['Open']
+
+    data = data.assign(
+        L1Touch = lambda x: x['Low'] < x['L1'],
+        L2Touch = lambda x: x['Low'] < x['L2'],
+        H1Touch = lambda x: x['High'] > x['H1'],
+        H2Touch = lambda x: x['High'] > x['H2'],
+        L1Break = lambda x: x['Close'] < x['L1'],
+        L2Break = lambda x: x['Close'] < x['L2'],
+        H1Break = lambda x: x['Close'] > x['H1'],
+        H2Break = lambda x: x['Close'] > x['H2'],
+        OpenL1 = lambda x: np.where(x['Open'] < x['L1'], 1, 0),
+        OpenL2 = lambda x: np.where(x['Open'] < x['L2'], 1, 0),
+        OpenH1 = lambda x: np.where(x['Open'] > x['H1'], 1, 0),
+        OpenH2 = lambda x: np.where(x['Open'] > x['H2'], 1, 0),
+        CloseL1 = lambda x: np.where(x['Close'] < x['L1'], 1, 0),
+        CloseL2 = lambda x: np.where(x['Close'] < x['L2'], 1, 0),
+        CloseH1 = lambda x: np.where(x['Close'] > x['H1'], 1, 0),
+        CloseH2 = lambda x: np.where(x['Close'] > x['H2'], 1, 0)
+    )
+
+    data['OpenL1'] = data['OpenL1'].shift(-1)
+    data['OpenL2'] = data['OpenL2'].shift(-1)
+    data['OpenH1'] = data['OpenH1'].shift(-1)
+    data['OpenH2'] = data['OpenH2'].shift(-1)
+    data['CloseL1'] = data['CloseL1'].shift(-1)
+    data['CloseL2'] = data['CloseL2'].shift(-1)
+    data['CloseH1'] = data['CloseH1'].shift(-1)
+    data['CloseH2'] = data['CloseH2'].shift(-1)
+
+    level_cols = [
+        'L1Touch',
+        'L2Touch',
+        'H1Touch',
+        'H2Touch',
+        'L1Break',
+        'L2Break',
+        'H1Break',
+        'H2Break'
+    ]
+
+    for col in level_cols:
+        data[col+'Pct'] = data[col].rolling(100).mean()
+        data[col+'Pct'] = data[col+'Pct'].shift(-1)
+
+
+    def get_quintiles(df, col_name, q):
+        return df.groupby(pd.qcut(df[col_name], q))['GreenDay'].mean()
+
+    probas = []
+    for i, pct in enumerate(data['CurrentClose30toClose']):
+        try:
+            df_q = get_quintiles(data.iloc[:i], 'HistClose30toPrevClose', 10)
+            for q in df_q.index:
+                if q.left <= pct <= q.right:
+                    p = df_q[q]
+        except:
+            p = None
+
+        probas.append(p)
+
+    # gapfills = []
+    # for i, pct in enumerate(data['CurrentGap']):
+    #     try:
+    #         df_q = get_quintiles(data.iloc[:i], 'CurrentGapHist', 5)
+    #         for q in df_q.index:
+    #             if q.left <= pct <= q.right:
+    #                 p = df_q[q]
+    #     except:
+    #         p = None
+
+    #     gapfills.append(p)
+
+    data['GreenProbas'] = probas
+    # data['GapFillGreenProba'] = gapfills
+
+    for rid in tqdm(release_ids, desc='Merging econ data'):
+        # Get the name of the release
+        n = releases[rid]['name']
+        # Merge the corresponding DF of the release
+        data = data.merge(releases[rid]['df'], how = 'left', left_index=True, right_index=True)
+        # Create a column that shifts the value in the merged column up by 1
+        data[f'{n}_shift'] = data[n].shift(-1)
+        # Fill the rest with zeroes
+        data[n] = data[n].fillna(0)
+        data[f'{n}_shift'] = data[f'{n}_shift'].fillna(0)
+        
+    data['BigNewsDay'] = data[[x for x in data.columns if '_shift' in x]].max(axis=1)
+
+    def cumul_sum(col):
+        nums = []
+        s = 0
+        for x in col:
+            if x == 1:
+                s += 1
+            elif x == 0:
+                s = 0
+            nums.append(s)
+        return nums
+
+    consec_green = cumul_sum(data['GreenDay'].values)
+    consec_red = cumul_sum(data['RedDay'].values)
+
+    data['DaysGreen'] = consec_green
+    data['DaysRed'] = consec_red
+
+    final_row = data.index[-2]
+
+    exp_row = data.index[-1]
+
+    df_final = data.loc[:final_row, model_cols + ['Target', 'Target_clf']]
+    df_final = df_final.dropna(subset=['Target','Target_clf','Perf5Day_n1'])
+    return data, df_final, final_row