Update app.py

app.py

@@ -8,115 +8,105 @@ from sklearn.ensemble import RandomForestClassifier
 from sklearn.preprocessing import MinMaxScaler
 import joblib
 import os
-from pydantic import BaseModel
+import warnings
+warnings.filterwarnings('ignore')
 
 app = FastAPI(title="Crypto ML Strategy (Paper 2105.06827v3)")
 
-# 🔧 Konfigurasi
 SYMBOL = "ETH/USDT"
 TIMEFRAME = "4h"
-FEE = 0.0015        # 0.15% sesuai paper
-WINDOW = 60         # 60 candle * 4h = 240h lookback
+FEE = 0.0015
+WINDOW = 60
 MODEL_PATH = "rf_model.pkl"
 SCALER_PATH = "scaler.pkl"
 
-# 📥 1. Ambil Data Historis
 def fetch_data(symbol: str, timeframe: str, limit: int = 2000) -> pd.DataFrame:
-    exchange = ccxt.binance()
+    exchange = ccxt.binance({"enableRateLimit": True})
     ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
     df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
     df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
     return df
 
-# 🧮 2. Tambah Indikator & Siapkan Fitur/Label
 def prepare_dataset(df: pd.DataFrame):
     df = df.copy()
-    # Indikator teknikal (sesuai Appendix A paper)
     df.ta.rsi(append=True)
     df.ta.macd(append=True)
     df.ta.bbands(append=True)
     df.ta.cci(append=True)
     df.dropna(inplace=True)
-
-    # Label: 1 jika pergerakan 4h ke depan > fee (0.15%), else 0
     df["next_close"] = df["close"].shift(-1)
     df["label"] = (df["next_close"] > df["close"] * (1 + FEE)).astype(int)
     df.dropna(inplace=True)
-
-    # Buat sliding window (60 candle per sampel)
+    
     X_list, y_list, idx_list = [], [], []
     for i in range(WINDOW, len(df)):
         window = df.iloc[i-WINDOW:i].drop(columns=["timestamp", "next_close", "label"])
         X_list.append(window.values.flatten())
         y_list.append(df.iloc[i]["label"])
         idx_list.append(i)
-
+        
     X = np.array(X_list)
     y = np.array(y_list)
     scaler = MinMaxScaler()
     X_scaled = scaler.fit_transform(X)
     return X_scaled, y, idx_list, df, scaler
 
-# 📊 3. FastAPI Endpoints
-@app.get("/train")
+@app.get("/api/train")
 def train_and_backtest():
-    if os.path.exists(MODEL_PATH):
-        return {"message": "Model sudah ada. Hapus model.pkl & scaler.pkl untuk retrain."}
-
-    df = fetch_data(SYMBOL, TIMEFRAME)
-    X, y, idx, df_full, scaler = prepare_dataset(df)
-
-    # Split 95% train / 5% test (sesuai paper)
-    split = int(len(X) * 0.95)
-    X_train, X_test = X[:split], X[split:]
-    y_train, y_test = y[:split], y[split:]
-
-    # Training
-    model = RandomForestClassifier(n_estimators=500, max_depth=None, random_state=42)
-    model.fit(X_train, y_train)
-    acc = float(model.score(X_test, y_test))
-
-    joblib.dump(model, MODEL_PATH)
-    joblib.dump(scaler, SCALER_PATH)
-
-    # 🧪 Backtest pada data unseen (5% terakhir)
-    test_indices = idx[split:]
-    df_test = df_full.loc[test_indices].copy()
-    df_test["pred"] = model.predict(X_test)
-
-    pnl_list = []
-    for i in range(len(df_test) - 1):
-        if df_test.iloc[i]["pred"] == 1:
-            entry = df_test.iloc[i]["close"]
-            exit_ = df_test.iloc[i + 1]["close"]
-            ret = (exit_ - entry) / entry
-            pnl = ret - FEE  # Kurangi fee exchange
-            pnl_list.append(pnl)
-
-    wins = sum(1 for p in pnl_list if p > 0)
-    losses = len(pnl_list) - wins
-    gross_profit = sum(p for p in pnl_list if p > 0)
-    gross_loss = sum(abs(p) for p in pnl_list if p <= 0)
-    profit_factor = gross_profit / gross_loss if gross_loss > 0 else float("inf")
-
-    return {
-        "accuracy_test": round(acc, 4),
-        "profit_factor": round(profit_factor, 3),
-        "net_profit_pct": round(sum(pnl_list) * 100, 3),
-        "wins": wins,
-        "losses": losses,
-        "win_rate_pct": round(wins / len(pnl_list) * 100, 2) if pnl_list else 0,
-        "message": "Model trained & backtested on unseen data"
-    }
-
-@app.get("/predict")
+    try:
+        if os.path.exists(MODEL_PATH):
+            return {"message": "Model sudah ada. Hapus rf_model.pkl & scaler.pkl untuk retrain."}
+            
+        df = fetch_data(SYMBOL, TIMEFRAME)
+        X, y, idx, df_full, scaler = prepare_dataset(df)
+        
+        split = int(len(X) * 0.95)
+        X_train, X_test = X[:split], X[split:]
+        y_train, y_test = y[:split], y[split:]
+        
+        model = RandomForestClassifier(n_estimators=500, max_depth=None, random_state=42)
+        model.fit(X_train, y_train)
+        acc = float(model.score(X_test, y_test))
+        
+        joblib.dump(model, MODEL_PATH)
+        joblib.dump(scaler, SCALER_PATH)
+        
+        test_indices = idx[split:]
+        df_test = df_full.loc[test_indices].copy()
+        df_test["pred"] = model.predict(X_test)
+        
+        pnl_list = []
+        for i in range(len(df_test) - 1):
+            if df_test.iloc[i]["pred"] == 1:
+                entry = df_test.iloc[i]["close"]
+                exit_ = df_test.iloc[i + 1]["close"]
+                pnl = (exit_ - entry) / entry - FEE
+                pnl_list.append(pnl)
+                
+        wins = sum(1 for p in pnl_list if p > 0)
+        losses = len(pnl_list) - wins
+        gross_profit = sum(p for p in pnl_list if p > 0)
+        gross_loss = sum(abs(p) for p in pnl_list if p <= 0)
+        profit_factor = gross_profit / gross_loss if gross_loss > 0 else float("inf")
+        
+        return {
+            "accuracy_test": round(acc, 4),
+            "profit_factor": round(profit_factor, 3),
+            "net_profit_pct": round(sum(pnl_list) * 100, 3),
+            "wins": wins, "losses": losses,
+            "win_rate_pct": round(wins / len(pnl_list) * 100, 2) if pnl_list else 0,
+            "message": "Model trained & backtested successfully"
+        }
+    except Exception as e:
+        raise HTTPException(500, f"Training failed: {str(e)}")
+
+@app.get("/api/predict")
 def predict_next_move():
     if not os.path.exists(MODEL_PATH):
-        raise HTTPException(400, "Model belum dilatih. Panggil /train terlebih dahulu.")
-    
+        raise HTTPException(400, "Model belum dilatih. Panggil /api/train terlebih dahulu.")
+        
     df = fetch_data(SYMBOL, TIMEFRAME, limit=WINDOW + 10)
     _, _, _, df_full, scaler = prepare_dataset(df)
-    
     latest_window = df_full.iloc[-WINDOW:].drop(columns=["timestamp", "next_close", "label"]).values.flatten().reshape(1, -1)
     latest_scaled = scaler.transform(latest_window)
     
@@ -124,8 +114,30 @@ def predict_next_move():
     pred = int(model.predict(latest_scaled)[0])
     
     return {
-        "symbol": SYMBOL,
-        "timeframe": TIMEFRAME,
+        "symbol": SYMBOL, "timeframe": TIMEFRAME,
         "prediction": "BUY (Hold 4h)" if pred == 1 else "HOLD/SELL",
         "logic": "Prediksi >0.15% movement dalam 4 jam ke depan"
-    }
+    }
+
+# 🎨 Gradio UI
+def run_train():
+    return train_and_backtest()
+
+def run_predict():
+    return predict_next_move()
+
+with gr.Blocks(title="Crypto ML Predictor") as demo:
+    gr.Markdown("## 📈 Crypto ML Strategy (ETH/USDT 4h)")
+    gr.Markdown("Berdasarkan paper 2105.06827v3. Membutuhkan koneksi internet untuk fetch data Binance.")
+    with gr.Row():
+        train_btn = gr.Button("🔄 Train Model & Backtest")
+        train_out = gr.JSON(label="Hasil Training & Backtest")
+    with gr.Row():
+        pred_btn = gr.Button("🔮 Prediksi Pergerakan Berikutnya")
+        pred_out = gr.JSON(label="Sinyal Prediksi")
+    train_btn.click(run_train, outputs=train_out)
+    pred_btn.click(run_predict, outputs=pred_out)
+    gr.Markdown("⚠️ *File model bersifat temporary. Retrain otomatis jika Space restart.*")
+
+# ⚙️ Mount Gradio ke FastAPI
+app = gr.mount_gradio_app(app, demo, path="/")