Update MLCryptoForecasterAllAssetsTPSL.py

MLCryptoForecasterAllAssetsTPSL.py

@@ -8,117 +8,122 @@ from sklearn.ensemble import RandomForestClassifier
 from sklearn.metrics import classification_report
 import ta
 
-# Initialize Binance client (insert API keys if needed)
+# Function to log results to both console and file
+def log_results(message, filename="predictions_results.txt"):
+    print(message)
+    with open(filename, "a") as f:
+        f.write(message + "\n")
+
+# Initialize Binance client
 client = Client()
 
 # Settings
 interval = Client.KLINE_INTERVAL_4HOUR
+result_file = "predictions_results.txt"
+# Initialize result file
+if not os.path.exists(result_file):
+    with open(result_file, "w") as f:
+        f.write("Asset,Accuracy,Optimal_UP_TP,Optimal_UP_SL,Optimal_DN_TP,Optimal_DN_SL\n")
+
 symbols = [s['symbol'] for s in client.get_exchange_info()['symbols']
            if s['status']=='TRADING' and s['quoteAsset']=='USDT']
 
-def process_symbol(symbol):
-    data_file = f"{symbol}_data_4h_full.csv"
+def optimize_tp_sl(df, signals, side, pgrid, lgrid):
+    best = (0, 0, -np.inf)
+    prices = df['close'].values
+    idxs = np.where(signals == side)[0]
+    for tp in pgrid:
+        for sl in lgrid:
+            rets = []
+            for i in idxs:
+                entry = prices[i]
+                for j in range(i+1, min(i+11, len(prices))):
+                    if side == 1:
+                        ret = (prices[j] - entry) / entry
+                    else:
+                        ret = (entry - prices[j]) / entry
+                    if ret >= tp or ret <= -sl:
+                        rets.append(np.sign(ret) * min(abs(ret), max(tp, sl)))
+                        break
+            if rets:
+                avg_ret = np.mean(rets)
+                if avg_ret > best[2]:
+                    best = (tp, sl, avg_ret)
+    return best
+
+for symbol in symbols:
+    log_results(f"=== {symbol} ===", result_file)
     # Load or download data
+    data_file = f"{symbol}_data_4h_full.csv"
     if os.path.exists(data_file):
         df = pd.read_csv(data_file, index_col=0, parse_dates=True)
-        # Normalize volume column name
-        if 'volume' in df.columns:
-            df.rename(columns={'volume':'vol'}, inplace=True)
         last_ts = df.index[-1]
         start = (last_ts + timedelta(hours=4)).strftime("%d %B %Y %H:%M:%S")
         new = client.get_historical_klines(symbol, interval, start)
         if new:
-            new_df = pd.DataFrame(new, columns=['ts','open','high','low','close','vol',
-                                                 'close_time','quote_av','trades','tb_base_av','tb_quote_av','ignore'])
-            new_df = new_df[['ts','open','high','low','close','vol']].astype({k:float for k in ['open','high','low','close','vol']})
-            new_df['ts'] = pd.to_datetime(new_df['ts'], unit='ms')
-            new_df.set_index('ts', inplace=True)
+            new_df = pd.DataFrame(new, columns=['timestamp','open','high','low','close','volume',
+                                                'close_time','quote_av','trades','tb_base_av','tb_quote_av','ignore'])
+            new_df = new_df[['timestamp','open','high','low','close','volume']].astype(float)
+            new_df['timestamp'] = pd.to_datetime(new_df['timestamp'], unit='ms')
+            new_df.set_index('timestamp', inplace=True)
             df = pd.concat([df, new_df]).drop_duplicates()
             df.to_csv(data_file)
     else:
-        klines = client.get_historical_klines(symbol, interval, "01 Dec 2021")
-        df = pd.DataFrame(klines, columns=['ts','open','high','low','close','vol',
+        klines = client.get_historical_klines(symbol, interval, "01 December 2021")
+        df = pd.DataFrame(klines, columns=['timestamp','open','high','low','close','volume',
                                            'close_time','quote_av','trades','tb_base_av','tb_quote_av','ignore'])
-        df = df[['ts','open','high','low','close','vol']].astype({k:float for k in ['open','high','low','close','vol']})
-        df['ts'] = pd.to_datetime(df['ts'], unit='ms')
-        df.set_index('ts', inplace=True)
+        df = df[['timestamp','open','high','low','close','volume']].astype(float)
+        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
+        df.set_index('timestamp', inplace=True)
         df.to_csv(data_file)
 
-    # Standardize volume if still present as 'volume'
-    if 'volume' in df.columns:
-        df.rename(columns={'volume':'vol'}, inplace=True)
-
-    # Feature Engineering
+    # Indicators
     df['rsi'] = ta.momentum.RSIIndicator(df['close'], window=14).rsi()
     df['macd'] = ta.trend.MACD(df['close']).macd()
-    for s in [10, 20, 50, 100]:
-        df[f'ema_{s}'] = df['close'].ewm(span=s).mean()
-    for w in [10, 20, 50, 100]:
-        df[f'sma_{w}'] = df['close'].rolling(window=w).mean()
+    for s in [10,20,50,100]: df[f'ema_{s}'] = df['close'].ewm(span=s).mean()
+    for w in [10,20,50,100]: df[f'sma_{w}'] = df['close'].rolling(window=w).mean()
     bb = ta.volatility.BollingerBands(df['close'], window=20, window_dev=2)
     df['bbw'] = (bb.bollinger_hband() - bb.bollinger_lband()) / bb.bollinger_mavg()
     df['atr'] = ta.volatility.AverageTrueRange(df['high'], df['low'], df['close'], window=14).average_true_range()
     df['adx'] = ta.trend.ADXIndicator(df['high'], df['low'], df['close'], window=14).adx()
     st = ta.momentum.StochasticOscillator(df['high'], df['low'], df['close'], window=14)
-    df['st_k'] = st.stoch()
-    df['st_d'] = st.stoch_signal()
+    df['st_k'] = st.stoch(); df['st_d'] = st.stoch_signal()
     df['wr'] = ta.momentum.WilliamsRIndicator(df['high'], df['low'], df['close'], lbp=14).williams_r()
     df['cci'] = ta.trend.CCIIndicator(df['high'], df['low'], df['close'], window=20).cci()
     df['mom'] = df['close'] - df['close'].shift(10)
     ichi = ta.trend.IchimokuIndicator(df['high'], df['low'], window1=9, window2=26, window3=52)
-    df['span_a'] = ichi.ichimoku_a()
-    df['span_b'] = ichi.ichimoku_b()
+    df['span_a'] = ichi.ichimoku_a(); df['span_b'] = ichi.ichimoku_b()
     df.dropna(inplace=True)
 
-    # Trend labels
-    df['signal'] = np.select(
-        [(df['close'] > df['span_a']) & (df['close'] > df['span_b']),
-         (df['close'] < df['span_a']) & (df['close'] < df['span_b'])],
-        [1, 0],
-        default=-1
-    )
+    # Signal labeling
+    df['signal'] = np.select([
+        (df['close']>df['span_a'])&(df['close']>df['span_b']),
+        (df['close']<df['span_a'])&(df['close']<df['span_b'])], [1,0], default=-1)
 
-    # Train/Test
-    features = df.drop(columns=['open', 'high', 'low', 'close', 'vol', 'signal']).columns
+    # Train/test
+    features = [c for c in df.columns if c not in ['open','high','low','close','volume','signal']]
     X, y = df[features], df['signal']
     Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2, shuffle=False)
-    mdl = RandomForestClassifier(n_estimators=200, class_weight='balanced', random_state=42)
-    mdl.fit(Xtr, ytr)
-    yp = mdl.predict(Xte)
-    print(f"=== {symbol} ===")
-    print(classification_report(yte, yp, zero_division=0))
+    model = RandomForestClassifier(n_estimators=200, class_weight='balanced', random_state=42)
+    model.fit(Xtr, ytr)
+    ypr = model.predict(Xte)
+    report = classification_report(yte, ypr, zero_division=0)
+    log_results(f"Classification report for {symbol}:\n{report}", result_file)
 
-    # Backtest for optimal TP/SL
-    def optimize_tp_sl(df, signals, side, pgrid, lgrid):
-        best = (0, 0, -np.inf)
-        prices = df['close'].values
-        idxs = np.where(signals == side)[0]
-        for tp in pgrid:
-            for sl in lgrid:
-                rets = []
-                for i in idxs:
-                    entry = prices[i]
-                    for j in range(i+1, min(i+11, len(prices))):
-                        ret = ((prices[j] - entry) / entry) if side == 1 else ((entry - prices[j]) / entry)
-                        if ret >= tp or ret <= -sl:
-                            rets.append(np.sign(ret) * min(abs(ret), max(tp, sl)))
-                            break
-                if rets:
-                    avg_ret = np.mean(rets)
-                    if avg_ret > best[2]:
-                        best = (tp, sl, avg_ret)
-        return best
+    # Predict latest trend
+    latest = model.predict(X.iloc[-1:].values)[0]
+    trend_map = {1:'Uptrend',0:'Downtrend',-1:'Neutral'}
+    log_results(f"Predicted next trend for {symbol}: {trend_map[latest]}", result_file)
 
-    hist_signals = pd.Series(mdl.predict(X), index=X.index)
-    pgrid = np.arange(0.01, 0.1, 0.01)
-    lgrid = np.arange(0.01, 0.1, 0.01)
-    up_tp, up_sl, _ = optimize_tp_sl(df, hist_signals.values, 1, pgrid, lgrid)
-    dn_tp, dn_sl, _ = optimize_tp_sl(df, hist_signals.values, 0, pgrid, lgrid)
-    print(f"Optimal UP TP/SL: +{up_tp*100:.1f}% / -{up_sl*100:.1f}%")
-    print(f"Optimal DN TP/SL: +{dn_tp*100:.1f}% / -{dn_sl*100:.1f}%")
+    # Optimize TP/SL
+    hist_sign = model.predict(X.values)
+    pgrid = np.arange(0.01,0.1,0.01); lgrid = np.arange(0.01,0.1,0.01)
+    up_tp, up_sl, _ = optimize_tp_sl(df, hist_sign, 1, pgrid, lgrid)
+    dn_tp, dn_sl, _ = optimize_tp_sl(df, hist_sign, 0, pgrid, lgrid)
+    log_results(f"Optimal UP TP/SL: +{up_tp*100:.1f}% / -{up_sl*100:.1f}%", result_file)
+    log_results(f"Optimal DN TP/SL: +{dn_tp*100:.1f}% / -{dn_sl*100:.1f}%", result_file)
 
 for sym in symbols:
-    try:
-        process_symbol(sym)
+    try: process_symbol(sym)
     except Exception as e:
-        print(f"Error {sym}: {e}")
+        log_results(f"Error processing {sym}: {e}", result_file)