qol changes:

app.py

@@ -42,11 +42,9 @@ def convert_to_datetime(time_str, pst_now):
     return datetime.combine(pst_now.date(), time_obj.time())
 
 # Function to determine the emoji for each time
-@st.cache_data
-def get_time_emojis(_times, _pst_now):
+def get_time(_times, _pst_now):
     pst_now_time = pst_now.time()
     us_holidays = get_us_holidays()
-    emojis = []
     idxs = []
     
     for t in _times:
@@ -55,24 +53,19 @@ def get_time_emojis(_times, _pst_now):
         # Check if the time is less than or equal to the current time in PST
         if time_obj.time() <= pst_now_time:
             idxs.append(True)
-            emoji = "✅"
 
         else:
             # Check if it's a business day or a holiday
             if is_business_day(time_obj) or time_obj.date() in us_holidays:
                 idxs.append(False)
-                emoji = "⛔"
             else:
                 idxs.append(True)
-                emoji = "✅"
-        
-        emojis.append(emoji)
-    
-    return emojis, idxs
+            
+    return idxs
 
 # Example usage:
 times_list = ['06:30', '07:00', '07:30', '08:00', '08:30', '09:00', '09:30', '10:00', '10:30', '11:00', '11:30', '12:00', '12:30']
-emojis_list, idxs = get_time_emojis(times_list, pst_now)
+idxs = get_time(times_list, pst_now)
 
 def get_last_idx(arr):
     try:
@@ -87,23 +80,22 @@ st.markdown('**PLEASE NOTE:** Model should be run at or after market open. Docum
 
 if "mode" not in st.session_state:
     st.session_state.mode = "Auto"
+    st.session_state.option = times_list[idx_use]
 
 with st.form("choose_model"):
     t1, t2 = st.columns(2)
     with t1:
-        mode = st.radio('Choose mode', options=['Auto','Manual'], horizontal=True)
+        mode = st.radio('Choose mode', options=['Auto','Manual'], horizontal=True, label_visibility='collapsed')
+        change_mode = st.form_submit_button('👊🏽 Confirm Mode',use_container_width=True)
     with t2:
         submitted = st.form_submit_button('🏃🏽‍♂️ Run',use_container_width=True)
-        sub1, sub2 = st.columns(2)
-        with sub1:
-            change_mode = st.form_submit_button('👊🏽 Change Mode',use_container_width=True)
-        with sub2:
-            cleared = st.form_submit_button('🧹 Clear',use_container_width=True)
+        cleared = st.form_submit_button('🧹 Clear',use_container_width=True)
+
 
     option = st.select_slider(
         f"""Change mode to Manual, and select time 👉🏽 Run.""",
         times_list,
-        format_func=lambda x: f"{emojis_list[times_list.index(x)]} {x}",
+        # format_func=lambda x: f"{emojis_list[times_list.index(x)]} {x}",
         disabled = mode == 'Auto'
     )
 
@@ -113,36 +105,38 @@ with st.form("choose_model"):
         option = option
 
     if change_mode:
-        st.write(f"Changed to {mode}.{' Model will run for {}.'.format(option) if mode == 'Auto' else ''}")        
+        st.info(f"Changed to {mode}.{' Model will run for {}.'.format(option) if mode == 'Auto' else ''}")        
 
     if cleared:
         st.cache_data.clear()
 
     if option == '':
-        st.write('No model selected.')
+        st.info('No model selected.')
 
     if submitted:
         
         fname=f'performance_for_{option}_model.csv'
+        
+        with st.status(f"Running model for {option}..."):
 
-        if option == '06:30':
+            if option == '06:30':
 
-            from model_day import *
+                from model_day import *
 
-            fname='performance_for_open_model.csv'
+                fname='performance_for_open_model.csv'
 
-            with st.spinner('Loading data...'):
+                st.write('Loading data...')
                 data, df_final, final_row = get_data()
-            # st.success("✅ Historical data")
+                # st.success("✅ Historical data")
 
-            with st.spinner("Training models..."):
+                st.write("Training models...")
                 def train_models():
                     res1, xgbr, seq2 = walk_forward_validation_seq(df_final.dropna(), 'Target_clf', 'Target', 200, 1)
                     return res1, xgbr, seq2
                 res1, xgbr, seq2 = train_models()
-            # st.success("✅ Models trained")
+                # st.success("✅ Models trained")
 
-            with st.spinner("Getting new prediction..."):
+                st.write("Getting new prediction...")
 
                 # Get last row
                 new_pred = data.loc[final_row, model_cols]
@@ -166,6 +160,8 @@ with st.form("choose_model"):
                 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)
+                # new_pred['OHLC4_Current_Trend'] = new_pred['OHLC4_Current_Trend'].astype(bool)
+                # new_pred['OHLC4_Trend'] = new_pred['OHLC4_Trend'].astype(bool)
                 new_pred['OpenL1'] = new_pred['OpenL1'].astype(float)
                 new_pred['OpenL2'] = new_pred['OpenL2'].astype(float)
                 new_pred['OpenH1'] = new_pred['OpenH1'].astype(float)
@@ -184,24 +180,24 @@ with st.form("choose_model"):
                 new_pred['L2BreakTouchPct'] = new_pred['L2BreakTouchPct'].astype(float)
 
                 seq_proba = seq_predict_proba(new_pred, xgbr, seq2)
-        
-        else:
+            
+            else:
 
-            from model_intra import *
-            idx = times_list.index(option)
+                from model_intra import *
+                idx = times_list.index(option)
 
-            with st.spinner('Loading data...'):
+                st.write('Loading data...')
                 data, df_final, final_row = get_data(idx)
-            # st.success("✅ Historical data")
+                # st.success("✅ Historical data")
 
-            with st.spinner("Training models..."):
+                st.write("Training models...")
                 def train_models():
-                    res1, xgbr = walk_forward_validation(df_final.dropna(), 'Target_clf', 100, 1)
+                    res1, xgbr = walk_forward_validation(df_final.dropna(), 'Target_clf', 120, 1)
                     return res1, xgbr
                 res1, xgbr = train_models()
-            # st.success("✅ Models trained")
+                # st.success("✅ Models trained")
 
-            with st.spinner("Getting new prediction..."):
+                st.write("Getting new prediction...")
 
                 # Get last row
                 new_pred = data.loc[final_row, model_cols]
@@ -230,10 +226,10 @@ with st.form("choose_model"):
                 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)
-                new_pred['OpenL1'] = new_pred['OpenL1'].astype(float)
-                new_pred['OpenL2'] = new_pred['OpenL2'].astype(float)
-                new_pred['OpenH1'] = new_pred['OpenH1'].astype(float)
-                new_pred['OpenH2'] = new_pred['OpenH2'].astype(float)
+                # new_pred['OpenL1'] = new_pred['OpenL1'].astype(float)
+                # new_pred['OpenL2'] = new_pred['OpenL2'].astype(float)
+                # new_pred['OpenH1'] = new_pred['OpenH1'].astype(float)
+                # new_pred['OpenH2'] = new_pred['OpenH2'].astype(float)
                 new_pred['L1TouchPct'] = new_pred['L1TouchPct'].astype(float)
                 new_pred['L2TouchPct'] = new_pred['L2TouchPct'].astype(float)
                 new_pred['H1TouchPct'] = new_pred['H1TouchPct'].astype(float)
@@ -246,7 +242,13 @@ with st.form("choose_model"):
                 new_pred['H2BreakTouchPct'] = new_pred['H2BreakTouchPct'].astype(float)
                 new_pred['L1BreakTouchPct'] = new_pred['L1BreakTouchPct'].astype(float)
                 new_pred['L2BreakTouchPct'] = new_pred['L2BreakTouchPct'].astype(float)
+                new_pred['H1BreakH2TouchPct'] = new_pred['H1BreakH2TouchPct'].astype(float)
+                new_pred['L1BreakL2TouchPct'] = new_pred['L1BreakL2TouchPct'].astype(float)   
                 new_pred['GreenProbas'] = new_pred['GreenProbas'].astype(float)
+                new_pred['OHLC4_Current_Trend'] = new_pred['OHLC4_Current_Trend'].astype(bool)
+                new_pred['OHLC4_Trend'] = new_pred['OHLC4_Trend'].astype(bool)
+                new_pred['H1TouchGreenPct'] = new_pred['H1TouchGreenPct'].astype(float)
+                new_pred['L1TouchRedPct'] = new_pred['L1TouchRedPct'].astype(float)
                 
                 seq_proba = seq_predict_proba(new_pred, xgbr)
 
@@ -264,12 +266,16 @@ with st.form("choose_model"):
         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.median, lambda x: np.quantile(x, 0.25), lambda x: np.quantile(x, 0.75)]})
+        df_probas = res1.groupby(pd.cut(res1['Predicted'], _q)).agg({
+            'True':[np.mean,len,np.sum],
+            'ClosePct':[np.mean, 
+                        lambda x: np.mean([r for r in x if r < 0]), 
+                        lambda x: np.mean([r for r in x if r > 0])]})
         
-        df_probas.columns = ['PctGreen','NumObs','NumGreen','AvgPerf','25P','75P']
+        df_probas.columns = ['PctGreen','NumObs','NumGreen','AvgPerf','AvgDown','AvgUp']
         df_probas['AvgPerf'] = df_probas['AvgPerf'].apply(lambda x: f'{x:.2%}')
-        df_probas['25P'] = df_probas['25P'].apply(lambda x: f'{x:.2%}')
-        df_probas['75P'] = df_probas['75P'].apply(lambda x: f'{x:.2%}')
+        df_probas['AvgDown'] = df_probas['AvgDown'].apply(lambda x: f'{x:.2%}')
+        df_probas['AvgUp'] = df_probas['AvgUp'].apply(lambda x: f'{x:.2%}')
 
         green_proba = seq_proba[0]
         red_proba = 1 - green_proba
@@ -293,8 +299,8 @@ with st.form("choose_model"):
                 red_hist_proba = 1 - historical_proba
                 num_obs = df_probas.loc[q, 'NumObs']
                 mid = df_probas.loc[q, 'AvgPerf']
-                lo = df_probas.loc[q, '25P']
-                hi = df_probas.loc[q, '75P']
+                lo = df_probas.loc[q, 'AvgDown']
+                hi = df_probas.loc[q, 'AvgUp']
                 intv = f'({q.left:.03f}, {q.right:.03f}])'
 
         qs = [f'({q.left:.2f}, {q.right:.2f}]' for q in df_probas.index]
@@ -381,7 +387,7 @@ with st.form("choose_model"):
                 [f"{curr_close30:.0f}"],
                 [f"{(1+float(lo.strip('%'))/100) * prev_close:.0f}"], 
                 [f"{(1+float(mid.strip('%'))/100) * prev_close:.0f}"], 
-                [f"{(1+float(hi.strip('%'))/100) * prev_close   :.0f}"]
+                [f"{(1+float(hi.strip('%'))/100) * prev_close:.0f}"]
                 ], 
             columns=['Targets'])
 

model_intra.py

@@ -12,6 +12,9 @@ import datetime
 from pandas.tseries.offsets import BDay
 from datasets import load_dataset
 import lightgbm as lgb
+from sklearn.model_selection import TimeSeriesSplit
+
+data_start_date = '2018-07-01'
 
 model_cols = [
     'BigNewsDay',
@@ -32,10 +35,12 @@ model_cols = [
     'OHLC4_VIX',
     'OHLC4_VIX_n1',
     'OHLC4_VIX_n2',
-    'OpenL1',
-    'OpenL2',
-    'OpenH1',
-    'OpenH2',
+    'OHLC4_Current_Trend',
+    'OHLC4_Trend',
+    # 'OpenL1',
+    # 'OpenL2',
+    # 'OpenH1',
+    # 'OpenH2',
     'L1TouchPct',
     'L2TouchPct',
     'H1TouchPct',
@@ -48,7 +53,11 @@ model_cols = [
     'H1BreakTouchPct',
     'H2BreakTouchPct',
     'L1BreakTouchPct',
-    'L2BreakTouchPct'
+    'L2BreakTouchPct',
+    'H1BreakH2TouchPct',
+    'L1BreakL2TouchPct',
+    'H1TouchGreenPct',    
+    'L1TouchRedPct'    
     # 'GapFillGreenProba'
 ]
 
@@ -59,20 +68,23 @@ def walk_forward_validation(df, target_column, num_training_rows, num_periods):
     df[target_column] = df[target_column].astype(bool)
 
     # Model
-    model = lgb.LGBMClassifier(n_estimators=10, random_state=42, verbosity=-1)
+    # model = lgb.LGBMClassifier(n_estimators=10, random_state=42, verbosity=-1)
+
+    tscv = TimeSeriesSplit(n_splits=len(df)-1, max_train_size=None, test_size=num_periods)  # num_splits is the number of splits you want
 
     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='LGB 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]
-        
+    # Split the time series data using TimeSeriesSplit
+    for train_index, test_index in tqdm(tscv.split(df), total=tscv.n_splits):
+        # Extract the training and testing data for the current split
+        X_train = df.drop(target_column, axis=1).iloc[train_index]
+        y_train = df[target_column].iloc[train_index]
+        X_test = df.drop(target_column, axis=1).iloc[test_index]
+        y_test = df[target_column].iloc[test_index]
+
         # Fit the model to the training data
+        model = lgb.LGBMClassifier(n_estimators=10, random_state=42, verbosity=-1)
         model.fit(X_train, y_train)
-        
         # Make a prediction on the test data
         predictions = model.predict_proba(X_test)[:,-1]
         
@@ -87,7 +99,7 @@ def walk_forward_validation(df, target_column, num_training_rows, num_periods):
         return df.groupby(pd.cut(df[col_name], q))['True'].mean()
 
     greenprobas = []
-    for i, pct in tqdm(enumerate(df_results['Predicted']), desc='Calibrating Probas'):
+    for i, pct in tqdm(enumerate(df_results['Predicted']), desc='Calibrating Probas',total=len(df_results)):
         try:
             df_q = get_quantiles(df_results.iloc[:i], 'Predicted', 7)
             for q in df_q.index:
@@ -123,18 +135,6 @@ def get_data(periods_30m = 1):
             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 = [
@@ -144,20 +144,10 @@ def get_data(periods_30m = 1):
     ]
 
     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"
@@ -197,8 +187,6 @@ def get_data(periods_30m = 1):
             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')
@@ -255,22 +243,20 @@ def get_data(periods_30m = 1):
 
     df_intra.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_vix = vix.history(start=data_start_date, interval='1d')
+    prices_spx = spx.history(start=data_start_date, 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_intra, left_index=True, right_index=True)
     data = data.merge(prices_vix[['Open','High','Low','Close']], left_index=True, right_index=True, suffixes=['','_VIX'])
 
@@ -291,6 +277,7 @@ def get_data(periods_30m = 1):
     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'] = data['OHLC4_Trend'].astype(bool)
     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)
@@ -310,6 +297,9 @@ def get_data(periods_30m = 1):
     data['CurrentHigh30'] = data['High30'].shift(-1)
     data['CurrentLow30'] = data['Low30'].shift(-1)
     data['CurrentClose30'] = data['Close30'].shift(-1)
+    data['CurrentOHLC430'] = data[['CurrentOpen30','CurrentHigh30','CurrentLow30','CurrentClose30']].max(axis=1)
+    data['OHLC4_Current_Trend'] = data['CurrentOHLC430'] > data['OHLC4']
+    data['OHLC4_Current_Trend'] = data['OHLC4_Current_Trend'].astype(bool)
     data['HistClose30toPrevClose'] = (data['Close30'] / data['PrevClose']) - 1
 
 
@@ -354,8 +344,12 @@ def get_data(periods_30m = 1):
         H1Touch = lambda x: x['High'] > x['H1'],
         H2Touch = lambda x: x['High'] > x['H2'],
         L1Break = lambda x: x['Close'] < x['L1'],
+        L1TouchRed = lambda x: (x['Low'] < x['L2']) & (x['Close'] < x['PrevClose']),
+        L2TouchL1Break = lambda x: (x['Low'] < x['L2']) & (x['Close'] < x['L1']),
         L2Break = lambda x: x['Close'] < x['L2'],
         H1Break = lambda x: x['Close'] > x['H1'],
+        H1TouchGreen = lambda x: (x['High'] > x['H1']) & (x['Close'] > x['PrevClose']),
+        H2TouchH1Break = lambda x: (x['High'] > x['H2']) & (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),
@@ -395,6 +389,11 @@ def get_data(periods_30m = 1):
     data['H2BreakTouchPct'] = data['H2Break'].rolling(100).sum() / data['H2Touch'].rolling(100).sum()
     data['L1BreakTouchPct'] = data['L1Break'].rolling(100).sum() / data['L1Touch'].rolling(100).sum()
     data['L2BreakTouchPct'] = data['L2Break'].rolling(100).sum() / data['L2Touch'].rolling(100).sum()
+    data['L1TouchRedPct'] = data['L1TouchRed'].rolling(100).sum() / data['L1Touch'].rolling(100).sum()
+    data['H1TouchGreenPct'] = data['H1TouchGreen'].rolling(100).sum() / data['H1Touch'].rolling(100).sum()
+
+    data['H1BreakH2TouchPct'] = data['H2TouchH1Break'].rolling(100).sum() / data['H2Touch'].rolling(100).sum()
+    data['L1BreakL2TouchPct'] = data['L2TouchL1Break'].rolling(100).sum() / data['L2Touch'].rolling(100).sum()
 
     def get_quintiles(df, col_name, q):
         return df.groupby(pd.qcut(df[col_name], q))['GreenDay'].mean()
@@ -461,5 +460,6 @@ def get_data(periods_30m = 1):
     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'])
+    df_final = df_final.dropna(subset=['Target','Target_clf'])
+    # df_final = df_final.dropna(subset=['Target','Target_clf','Perf5Day_n1'])
     return data, df_final, final_row

troubleshoot_day_model.ipynb

@@ -2,78 +2,92 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
     "import pandas as pd\n",
     "import numpy as np\n",
     "from model_intra import get_data, walk_forward_validation\n",
-    "import lightgbm as lgb"
+    "import lightgbm as lgb\n",
+    "from sklearn.linear_model import LogisticRegression"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "getting econ tickers: 100%|██████████| 3/3 [00:00<00:00,  3.10it/s]\n",
-      "Getting release dates: 100%|██████████| 8/8 [00:01<00:00,  4.87it/s]\n",
-      "Making indicators: 100%|██████████| 8/8 [00:00<00:00, 3997.91it/s]\n",
-      "Found cached dataset text (C:/Users/WINSTON-ITX/.cache/huggingface/datasets/boomsss___text/boomsss--spx_intra-e0e5e7af8fd43022/0.0.0/cb1e9bd71a82ad27976be3b12b407850fe2837d80c22c5e03a28949843a8ace2)\n",
-      "Merging econ data: 100%|██████████| 8/8 [00:00<00:00, 799.22it/s]\n"
+      "getting econ tickers: 100%|██████████| 3/3 [00:00<00:00,  6.05it/s]\n",
+      "Getting release dates: 100%|██████████| 8/8 [00:01<00:00,  5.73it/s]\n",
+      "Making indicators: 100%|██████████| 8/8 [00:00<00:00, 3997.43it/s]\n",
+      "Found cached dataset text (C:/Users/WINSTON-ITX/.cache/huggingface/datasets/boomsss___text/boomsss--spx_intra-b08c599e86f95628/0.0.0/cb1e9bd71a82ad27976be3b12b407850fe2837d80c22c5e03a28949843a8ace2)\n",
+      "Merging econ data: 100%|██████████| 8/8 [00:00<00:00, 865.85it/s]\n"
      ]
     }
    ],
    "source": [
-    "data, df_final, final_row = get_data(5)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data['ClosePct'] = (data['Close'] / data['PrevClose']) - 1\n",
-    "data['HighPct'] = (data['High'] / data['PrevClose']) - 1\n",
-    "data['LowPct'] = (data['Low'] / data['PrevClose']) - 1\n",
-    "data['ClosePct'] = data['ClosePct'].shift(-1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Calculate the rolling likelihood\n",
-    "rolling_likelihood = (data['H1Break'] & data['H1Touch']==True).rolling(window=100).mean()"
+    "data, df_final, final_row = get_data(2)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "L1BreakL2TouchPct       0.875\n",
+       "H1TouchGreenPct      0.785714\n",
+       "L1TouchRedPct           0.575\n",
+       "Target              -0.009281\n",
+       "Target_clf              False\n",
+       "Name: 2023-10-24 00:00:00, dtype: object"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "data['H1BreakTouchPct'] = data['H1Break'].expanding().sum() / data['H1Touch'].expanding().sum()\n",
-    "data['H2BreakTouchPct'] = data['H2Break'].expanding().sum() / data['H2Touch'].expanding().sum()\n",
-    "data['H1BreakTouchPct'] = data['L1Break'].expanding().sum() / data['L1Touch'].expanding().sum()\n",
-    "data['H2BreakTouchPct'] = data['L2Break'].expanding().sum() / data['L2Touch'].expanding().sum()"
+    "data.loc[final_row, df_final.columns[-5:]]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 13,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "d:\\Projects\\gamedayspx\\model_intra.py:68: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  df[target_column] = df[target_column].astype(bool)\n",
+      "  0%|          | 0/1238 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 1238/1238 [00:10<00:00, 116.79it/s]\n",
+      "Calibrating Probas: 100%|██████████| 1238/1238 [00:02<00:00, 418.46it/s]\n"
+     ]
+    }
+   ],
    "source": [
-    "l = [False, False, False, False, False,False,False,False]"
+    "res1, model1 = walk_forward_validation(df_final.dropna(axis=0), 'Target_clf', 250, 1)"
    ]
   },
   {
@@ -82,197 +96,80 @@
    "metadata": {},
    "outputs": [
     {
-     "ename": "ValueError",
-     "evalue": "True is not in list",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
-      "\u001b[1;32md:\\Projects\\gamedayspx\\troubleshoot_day_model.ipynb Cell 7\u001b[0m line \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/d%3A/Projects/gamedayspx/troubleshoot_day_model.ipynb#X60sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m place \u001b[39m=\u001b[39m \u001b[39m0\u001b[39m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m l[::\u001b[39m-\u001b[39;49m\u001b[39m1\u001b[39;49m]\u001b[39m.\u001b[39;49mindex(\u001b[39mTrue\u001b[39;49;00m) \u001b[39melse\u001b[39;00m \u001b[39mlen\u001b[39m(l) \u001b[39m-\u001b[39m \u001b[39m1\u001b[39m \u001b[39m-\u001b[39m l[::\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m]\u001b[39m.\u001b[39mindex(\u001b[39mTrue\u001b[39;00m)\n",
-      "\u001b[1;31mValueError\u001b[0m: True is not in list"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.7675170574106744\n",
+      "0.6997319034852547\n",
+      "0.7933130699088146\n",
+      "0.8022859842930231\n",
+      "0.7675276752767528\n",
+      "0.8721174004192872\n"
      ]
     }
    ],
    "source": [
-    "place = 0 if not l[::-1].index(True) else len(l) - 1 - l[::-1].index(True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "z = ['a','b','c','d','e']"
+    "from sklearn.metrics import roc_auc_score, precision_score, recall_score\n",
+    "\n",
+    "cal = res1.dropna()\n",
+    "\n",
+    "print(roc_auc_score(cal['True'], cal['CalibPredicted']))\n",
+    "print(precision_score(cal['True'], cal['CalibPredicted'] > .5))\n",
+    "print(recall_score(cal['True'], cal['CalibPredicted'] > .5))\n",
+    "\n",
+    "res1_hi_confidence = cal.query('(CalibPredicted >= .6) | (CalibPredicted < 0.4)')\n",
+    "\n",
+    "print(roc_auc_score(res1_hi_confidence['True'], res1_hi_confidence['CalibPredicted']))\n",
+    "print(precision_score(res1_hi_confidence['True'], res1_hi_confidence['CalibPredicted'] > .5))\n",
+    "print(recall_score(res1_hi_confidence['True'], res1_hi_confidence['CalibPredicted'] > .5))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>H2Touch</th>\n",
-       "      <th>H2Break</th>\n",
-       "      <th>H2BreakTouch</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>2018-07-02</th>\n",
-       "      <td>False</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2018-07-03</th>\n",
-       "      <td>False</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2018-07-05</th>\n",
-       "      <td>False</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2018-07-06</th>\n",
-       "      <td>False</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2018-07-09</th>\n",
-       "      <td>False</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>...</th>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2023-10-10</th>\n",
-       "      <td>True</td>\n",
-       "      <td>False</td>\n",
-       "      <td>0.588235</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2023-10-11</th>\n",
-       "      <td>False</td>\n",
-       "      <td>False</td>\n",
-       "      <td>0.588235</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2023-10-12</th>\n",
-       "      <td>False</td>\n",
-       "      <td>False</td>\n",
-       "      <td>0.588235</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2023-10-13</th>\n",
-       "      <td>False</td>\n",
-       "      <td>False</td>\n",
-       "      <td>0.588235</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2023-10-16</th>\n",
-       "      <td>True</td>\n",
-       "      <td>False</td>\n",
-       "      <td>0.571429</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "<p>1332 rows × 3 columns</p>\n",
-       "</div>"
-      ],
       "text/plain": [
-       "            H2Touch  H2Break  H2BreakTouch\n",
-       "2018-07-02    False    False           NaN\n",
-       "2018-07-03    False    False           NaN\n",
-       "2018-07-05    False    False           NaN\n",
-       "2018-07-06    False    False           NaN\n",
-       "2018-07-09    False    False           NaN\n",
-       "...             ...      ...           ...\n",
-       "2023-10-10     True    False      0.588235\n",
-       "2023-10-11    False    False      0.588235\n",
-       "2023-10-12    False    False      0.588235\n",
-       "2023-10-13    False    False      0.588235\n",
-       "2023-10-16     True    False      0.571429\n",
-       "\n",
-       "[1332 rows x 3 columns]"
+       "0.7691056910569106"
       ]
      },
-     "execution_count": 37,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "data[['H2Touch','H2Break','H2BreakTouch']]"
+    "len(res1_hi_confidence) / len(cal)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "data": {
+      "image/png": "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",
       "text/plain": [
-       "2018-07-02     NaN\n",
-       "2018-07-03     NaN\n",
-       "2018-07-05     NaN\n",
-       "2018-07-06     NaN\n",
-       "2018-07-09     NaN\n",
-       "              ... \n",
-       "2023-10-10    0.22\n",
-       "2023-10-11    0.21\n",
-       "2023-10-12    0.21\n",
-       "2023-10-13    0.21\n",
-       "2023-10-16    0.22\n",
-       "Name: H1BreakPct, Length: 1332, dtype: float64"
+       "<Figure size 1152x864 with 1 Axes>"
       ]
      },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
     }
    ],
    "source": [
-    "data['H1BreakPct']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "res1, model1 = walk_forward_validation(df_final.dropna(axis=0), 'Target_clf', 100, 1)"
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Plot feature importances\n",
+    "# plt.figure(figsize=(16, 12))\n",
+    "lgb.plot_importance(model1, figsize=(16, 12))  # Adjust max_num_features as needed\n",
+    "plt.title(\"Feature Importances\")\n",
+    "plt.show()"
    ]
   },
   {
@@ -281,13 +178,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "# Plot feature importances\n",
-    "plt.figure(figsize=(10, 12))\n",
-    "lgb.plot_importance(model1)  # Adjust max_num_features as needed\n",
-    "plt.title(\"Feature Importances\")\n",
-    "plt.show()"
+    "XXX"
    ]
   },
   {