Update app.py

app.py

@@ -6,207 +6,443 @@ import aiohttp
 import pandas as pd
 import numpy as np
 from aiohttp import web
-from sklearn.ensemble import RandomForestRegressor
+from sklearn.ensemble import GradientBoostingRegressor
+from sklearn.preprocessing import RobustScaler
+import warnings
+warnings.filterwarnings('ignore')
 
 # --- CONFIGURATION ---
 SYMBOL_KRAKEN = "BTC/USD"
 PORT = 7860
 BROADCAST_RATE = 1.0
-PREDICTION_HORIZON = 100  # Predict next 100 candles
-MAX_HISTORY = 5000        # Store up to 5000 candles for training
-TRAIN_INTERVAL = 300      # Retrain model every 5 minutes
+PREDICTION_HORIZON = 100
+MAX_HISTORY = 5000
+TRAIN_INTERVAL = 300
+MIN_TRAINING_SAMPLES = 300
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')
 
+# Feature columns for ML model
+FEATURE_COLS = [
+    'rsi_norm', 'rsi_slope',
+    'macd_hist_norm', 'macd_slope',
+    'atr_pct',
+    'dist_ema20', 'dist_ema50', 'ema_cross',
+    'bb_width', 'bb_pos',
+    'vol_zscore',
+    'ret_1', 'ret_5', 'ret_10', 'ret_20',
+    'volatility_ratio',
+    'candle_body', 'upper_wick', 'lower_wick',
+    'trend_strength'
+]
+
+# Key horizons to predict (reduces noise vs predicting all 100)
+KEY_HORIZONS = [1, 3, 5, 10, 20, 35, 50, 75, 100]
+
 market_state = {
     "ohlc_history": [],
     "ready": False,
-    "model": None,
+    "models": {},           # Dictionary of models for each horizon
+    "scaler": None,
     "last_training_time": 0,
     "last_price": 0,
-    "price_change": 0
+    "price_change": 0,
+    "training_metrics": {}
 }
 
 connected_clients = set()
 
+
+def safe_divide(a, b, default=0.0):
+    """Safe division that handles zeros and NaN"""
+    with np.errstate(divide='ignore', invalid='ignore'):
+        result = np.where(b != 0, a / b, default)
+        result = np.where(np.isfinite(result), result, default)
+    return result
+
+
 def calculate_indicators(candles):
-    if len(candles) < 50:
+    """Calculate technical indicators with robust normalization"""
+    if len(candles) < 60:
         return None
     
-    df = pd.DataFrame(candles)
+    df = pd.DataFrame(candles).copy()
     cols = ['open', 'high', 'low', 'close', 'volume']
     for c in cols:
-        df[c] = df[c].astype(float)
+        df[c] = pd.to_numeric(df[c], errors='coerce')
+    
+    df = df.dropna(subset=['open', 'high', 'low', 'close'])
+    if len(df) < 60:
+        return None
 
-    # --- Standard Indicators ---
-    df['ema20'] = df['close'].ewm(span=20, adjust=False).mean()
-    df['ema50'] = df['close'].ewm(span=50, adjust=False).mean()
+    close = df['close']
+    high = df['high']
+    low = df['low']
+    volume = df['volume'].fillna(0)
+    
+    # --- EXPONENTIAL MOVING AVERAGES ---
+    df['ema20'] = close.ewm(span=20, adjust=False).mean()
+    df['ema50'] = close.ewm(span=50, adjust=False).mean()
     
-    # Bollinger Bands
-    df['std'] = df['close'].rolling(window=20).std()
-    df['bb_upper'] = df['ema20'] + (df['std'] * 2)
-    df['bb_lower'] = df['ema20'] - (df['std'] * 2)
+    # --- BOLLINGER BANDS ---
+    df['sma20'] = close.rolling(window=20).mean()
+    df['std20'] = close.rolling(window=20).std()
+    df['bb_upper'] = df['sma20'] + (df['std20'] * 2)
+    df['bb_lower'] = df['sma20'] - (df['std20'] * 2)
 
-    # RSI
-    delta = df['close'].diff()
-    gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
+    # --- RSI ---
+    delta = close.diff()
+    gain = delta.where(delta > 0, 0).rolling(window=14).mean()
     loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
-    rs = gain / loss
+    rs = safe_divide(gain.values, loss.values, 1.0)
     df['rsi'] = 100 - (100 / (1 + rs))
+    df['rsi'] = df['rsi'].fillna(50).clip(0, 100)
+    
+    # Normalized RSI (centered at 0, range -1 to 1)
+    df['rsi_norm'] = (df['rsi'] - 50) / 50
+    df['rsi_slope'] = df['rsi'].diff(5).fillna(0) / 50  # 5-period RSI change
 
-    # MACD
-    k = df['close'].ewm(span=12, adjust=False).mean()
-    d = df['close'].ewm(span=26, adjust=False).mean()
-    df['macd'] = k - d
+    # --- MACD ---
+    ema12 = close.ewm(span=12, adjust=False).mean()
+    ema26 = close.ewm(span=26, adjust=False).mean()
+    df['macd'] = ema12 - ema26
     df['macd_signal'] = df['macd'].ewm(span=9, adjust=False).mean()
     df['macd_hist'] = df['macd'] - df['macd_signal']
+    
+    # Normalize MACD by ATR to make it price-independent
+    atr_for_norm = close.rolling(20).std().replace(0, 1)
+    df['macd_hist_norm'] = df['macd_hist'] / atr_for_norm
+    df['macd_hist_norm'] = df['macd_hist_norm'].clip(-5, 5)
+    df['macd_slope'] = df['macd_hist_norm'].diff(3).fillna(0)
 
-    # ATR
-    df['tr0'] = abs(df['high'] - df['low'])
-    df['tr1'] = abs(df['high'] - df['close'].shift())
-    df['tr2'] = abs(df['low'] - df['close'].shift())
-    df['tr'] = df[['tr0', 'tr1', 'tr2']].max(axis=1)
+    # --- ATR (Average True Range) ---
+    tr1 = abs(high - low)
+    tr2 = abs(high - close.shift())
+    tr3 = abs(low - close.shift())
+    df['tr'] = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
     df['atr'] = df['tr'].rolling(window=14).mean()
+    
+    # ATR as percentage of price (volatility measure)
+    df['atr_pct'] = safe_divide(df['atr'].values, close.values) * 100
 
-    # --- FEATURE ENGINEERING (Normalization) ---
-    # We create features that represent % differences rather than raw prices
-    # This helps the model learn patterns regardless of whether BTC is $20k or $100k
+    # --- NORMALIZED PRICE FEATURES ---
+    
+    # Distance from EMAs (percentage)
+    df['dist_ema20'] = safe_divide((close - df['ema20']).values, df['ema20'].values) * 100
+    df['dist_ema50'] = safe_divide((close - df['ema50']).values, df['ema50'].values) * 100
     
-    # Distance from EMAs (Percentage)
-    df['dist_ema20'] = (df['close'] - df['ema20']) / df['ema20']
-    df['dist_ema50'] = (df['close'] - df['ema50']) / df['ema50']
+    # EMA cross strength
+    df['ema_cross'] = safe_divide((df['ema20'] - df['ema50']).values, df['ema50'].values) * 100
     
-    # Bollinger Band Width & Position
-    df['bb_width'] = (df['bb_upper'] - df['bb_lower']) / df['ema20']
-    df['bb_pos'] = (df['close'] - df['bb_lower']) / (df['bb_upper'] - df['bb_lower'])
+    # --- BOLLINGER BAND FEATURES ---
+    bb_range = df['bb_upper'] - df['bb_lower']
+    bb_range_safe = bb_range.replace(0, np.nan).fillna(close * 0.01)  # Fallback to 1% of price
+    
+    df['bb_width'] = safe_divide(bb_range.values, df['sma20'].values) * 100
+    df['bb_pos'] = safe_divide((close - df['bb_lower']).values, bb_range_safe.values)
+    df['bb_pos'] = df['bb_pos'].clip(-0.5, 1.5).fillna(0.5)  # Allow some overflow
+
+    # --- VOLUME FEATURES ---
+    vol_mean = volume.rolling(window=20).mean().replace(0, 1)
+    vol_std = volume.rolling(window=20).std().replace(0, 1)
+    df['vol_zscore'] = safe_divide((volume - vol_mean).values, vol_std.values)
+    df['vol_zscore'] = df['vol_zscore'].clip(-3, 3).fillna(0)
+
+    # --- RETURN FEATURES (momentum) ---
+    df['ret_1'] = close.pct_change(1).fillna(0) * 100
+    df['ret_5'] = close.pct_change(5).fillna(0) * 100
+    df['ret_10'] = close.pct_change(10).fillna(0) * 100
+    df['ret_20'] = close.pct_change(20).fillna(0) * 100
     
-    # Volume Change
-    df['vol_change'] = df['volume'].pct_change()
+    # Clip extreme returns
+    for col in ['ret_1', 'ret_5', 'ret_10', 'ret_20']:
+        df[col] = df[col].clip(-10, 10)
 
-    # Log Returns (Momentum)
-    df['log_ret'] = np.log(df['close'] / df['close'].shift(1))
+    # --- VOLATILITY FEATURES ---
+    vol_short = df['ret_1'].rolling(5).std().fillna(0)
+    vol_long = df['ret_1'].rolling(20).std().replace(0, 1)
+    df['volatility_ratio'] = safe_divide(vol_short.values, vol_long.values).clip(0, 3)
 
+    # --- CANDLESTICK FEATURES ---
+    candle_range = (high - low).replace(0, 0.01)
+    df['candle_body'] = safe_divide((close - df['open']).values, candle_range.values)
+    df['upper_wick'] = safe_divide((high - pd.concat([close, df['open']], axis=1).max(axis=1)).values, candle_range.values)
+    df['lower_wick'] = safe_divide((pd.concat([close, df['open']], axis=1).min(axis=1) - low).values, candle_range.values)
+
+    # --- TREND STRENGTH ---
+    # Compare current price to 20-period high/low range
+    rolling_high = high.rolling(20).max()
+    rolling_low = low.rolling(20).min()
+    rolling_range = (rolling_high - rolling_low).replace(0, 1)
+    df['trend_strength'] = safe_divide((close - rolling_low).values, rolling_range.values) * 2 - 1  # -1 to 1
+
+    # Replace any remaining infinities or NaN
+    df = df.replace([np.inf, -np.inf], np.nan)
+    
     return df
 
+
+def prepare_training_data(df):
+    """Prepare features and multi-horizon targets for training"""
+    data = df.copy()
+    
+    # Create target: future return at each key horizon
+    target_cols = []
+    for h in KEY_HORIZONS:
+        col_name = f'target_{h}'
+        future_price = data['close'].shift(-h)
+        current_price = data['close']
+        # Target is percentage return
+        data[col_name] = safe_divide((future_price - current_price).values, current_price.values) * 100
+        target_cols.append(col_name)
+    
+    # Drop rows with NaN in features or targets
+    required_cols = FEATURE_COLS + target_cols
+    data = data.dropna(subset=required_cols)
+    
+    if len(data) < MIN_TRAINING_SAMPLES:
+        return None, None
+    
+    X = data[FEATURE_COLS].values
+    y_dict = {h: data[f'target_{h}'].values for h in KEY_HORIZONS}
+    
+    return X, y_dict
+
+
 def train_model(df):
-    logging.info(f"Training ML Model on {len(df)} candles...")
+    """Train separate models for each prediction horizon"""
+    logging.info(f"Training ML Models on {len(df)} candles...")
+    
+    X, y_dict = prepare_training_data(df)
     
-    # Use normalized features for input
-    feature_cols = [
-        'rsi', 'macd_hist', 'atr', 
-        'dist_ema20', 'dist_ema50', 
-        'bb_width', 'bb_pos', 
-        'vol_change', 'log_ret'
-    ]
+    if X is None:
+        logging.warning("Not enough training data")
+        return None, None
     
-    data = df.dropna().copy()
+    logging.info(f"Training data: {len(X)} samples, {len(FEATURE_COLS)} features")
     
-    # --- CREATE TARGETS (Percentage Change) ---
-    targets = []
+    # Robust scaling handles outliers better than StandardScaler
+    scaler = RobustScaler()
+    X_scaled = scaler.fit_transform(X)
     
-    # We want to predict the % return for the next 1 to N steps relative to CURRENT price
-    for i in range(1, PREDICTION_HORIZON + 1):
-        col_name = f'target_return_{i}'
-        # Formula: (Price_Future - Price_Current) / Price_Current
-        data[col_name] = (data['close'].shift(-i) - data['close']) / data['close']
-        targets.append(col_name)
+    models = {}
+    metrics = {}
+    
+    for h in KEY_HORIZONS:
+        y = y_dict[h]
+        
+        # Gradient Boosting with regularization to prevent overfitting
+        model = GradientBoostingRegressor(
+            n_estimators=150,
+            max_depth=4,
+            learning_rate=0.05,
+            min_samples_split=30,
+            min_samples_leaf=15,
+            subsample=0.8,
+            max_features='sqrt',
+            validation_fraction=0.15,
+            n_iter_no_change=10,
+            random_state=42,
+            verbose=0
+        )
+        
+        model.fit(X_scaled, y)
+        models[h] = model
         
-    data = data.dropna()
+        # Calculate training R² score
+        train_score = model.score(X_scaled, y)
+        metrics[h] = {'r2': round(train_score, 3)}
+        
+        logging.info(f"  Horizon {h:3d}: R² = {train_score:.3f}")
+    
+    # Log feature importance (from longest horizon model)
+    if 100 in models:
+        importance = dict(zip(FEATURE_COLS, models[100].feature_importances_))
+        top_5 = sorted(importance.items(), key=lambda x: x[1], reverse=True)[:5]
+        logging.info(f"Top features: {[f'{k}:{v:.3f}' for k,v in top_5]}")
+    
+    market_state['training_metrics'] = metrics
+    logging.info("Model training complete")
+    
+    return models, scaler
 
-    if len(data) < 200:
-        logging.warning("Not enough data to train model yet.")
-        return None
 
-    X = data[feature_cols].values
-    y = data[targets].values
+def interpolate_predictions(horizon_preds, target_horizon):
+    """Interpolate between key horizon predictions for smooth curve"""
+    horizons = sorted(horizon_preds.keys())
+    
+    if target_horizon <= horizons[0]:
+        return horizon_preds[horizons[0]]
+    if target_horizon >= horizons[-1]:
+        return horizon_preds[horizons[-1]]
+    
+    # Find surrounding horizons
+    lower_h = max([h for h in horizons if h <= target_horizon])
+    upper_h = min([h for h in horizons if h >= target_horizon])
+    
+    if lower_h == upper_h:
+        return horizon_preds[lower_h]
+    
+    # Cubic interpolation weight for smoother curves
+    t = (target_horizon - lower_h) / (upper_h - lower_h)
+    t_smooth = t * t * (3 - 2 * t)  # Smoothstep function
+    
+    return horizon_preds[lower_h] + (horizon_preds[upper_h] - horizon_preds[lower_h]) * t_smooth
 
-    # Increase estimators for better stability
-    model = RandomForestRegressor(
-        n_estimators=100, 
-        max_depth=15, 
-        min_samples_split=5,
-        n_jobs=-1, 
-        random_state=42
-    )
-    model.fit(X, y)
+
+def apply_trend_smoothing(predictions, window=5):
+    """Apply exponential moving average smoothing to predictions"""
+    if len(predictions) < window:
+        return predictions
+    
+    smoothed = []
+    alpha = 2 / (window + 1)
+    
+    # Initialize with first value
+    ema = predictions[0]
+    smoothed.append(ema)
+    
+    for i in range(1, len(predictions)):
+        ema = alpha * predictions[i] + (1 - alpha) * ema
+        smoothed.append(ema)
     
-    logging.info(f"Model Trained successfully.")
-    return model
+    return smoothed
 
-def get_prediction(df, model):
-    if model is None:
+
+def get_prediction(df, models, scaler):
+    """Generate price predictions for the next N candles"""
+    if not models or scaler is None:
         return []
     
-    feature_cols = [
-        'rsi', 'macd_hist', 'atr', 
-        'dist_ema20', 'dist_ema50', 
-        'bb_width', 'bb_pos', 
-        'vol_change', 'log_ret'
-    ]
-    
-    last_row = df.iloc[[-1]][feature_cols]
+    # Check if we have valid features
+    last_row = df.iloc[-1:].copy()
     
-    if last_row.isnull().values.any():
+    # Validate features
+    missing_features = [col for col in FEATURE_COLS if col not in last_row.columns]
+    if missing_features:
+        logging.error(f"Missing features: {missing_features}")
         return []
-
-    # The model predicts Percentage Returns
-    predicted_returns = model.predict(last_row.values)[0]
     
-    # Convert Percentage Returns back to Absolute Prices
-    current_price = df.iloc[-1]['close']
-    current_time = int(df.iloc[-1]['time'])
+    feature_values = last_row[FEATURE_COLS]
+    if feature_values.isnull().values.any():
+        logging.warning("NaN in prediction features")
+        return []
     
-    pred_data = []
-    for i, pct_change in enumerate(predicted_returns):
-        # Reconstruct: Price = Current * (1 + Predicted_Return)
-        future_price = current_price * (1 + pct_change)
+    try:
+        X = feature_values.values
+        X_scaled = scaler.transform(X)
         
-        pred_data.append({
-            "time": current_time + ((i + 1) * 60), # Add 60s for each step
-            "value": float(future_price)
-        })
-    
-    return pred_data
+        current_price = float(df.iloc[-1]['close'])
+        current_time = int(df.iloc[-1]['time'])
+        
+        # Get predictions at key horizons
+        horizon_preds = {}
+        for h in KEY_HORIZONS:
+            if h in models:
+                pred_return = models[h].predict(X_scaled)[0]
+                # Clip extreme predictions
+                pred_return = np.clip(pred_return, -15, 15)  # Max ±15% move
+                horizon_preds[h] = pred_return
+        
+        if not horizon_preds:
+            return []
+        
+        # Interpolate for all time steps
+        raw_returns = []
+        for i in range(1, PREDICTION_HORIZON + 1):
+            pct_return = interpolate_predictions(horizon_preds, i)
+            raw_returns.append(pct_return)
+        
+        # Apply trend smoothing
+        smoothed_returns = apply_trend_smoothing(raw_returns, window=7)
+        
+        # Convert to prices with momentum continuation
+        predictions = []
+        prev_price = current_price
+        
+        for i, pct_return in enumerate(smoothed_returns):
+            # Price = current * (1 + cumulative_return%)
+            future_price = current_price * (1 + pct_return / 100)
+            
+            # Add slight momentum continuation (reduces jumps)
+            if i > 0:
+                momentum = (future_price - prev_price) * 0.1
+                future_price = future_price + momentum
+            
+            predictions.append({
+                "time": current_time + ((i + 1) * 60),
+                "value": round(float(future_price), 2)
+            })
+            prev_price = future_price
+        
+        return predictions
+        
+    except Exception as e:
+        logging.error(f"Prediction error: {e}")
+        return []
+
 
 def process_market_data():
+    """Process market data and generate predictions"""
     if not market_state['ready'] or not market_state['ohlc_history']:
         return {"error": "Initializing..."}
 
     # 1. Calculate Indicators
     df = calculate_indicators(market_state['ohlc_history'])
-    if df is None or len(df) < 50:
+    if df is None or len(df) < 60:
         return {"error": "Not enough data"}
 
-    # 2. Train Model (Periodically)
-    if market_state['model'] is None or (time.time() - market_state['last_training_time'] > TRAIN_INTERVAL):
+    # 2. Train Model Periodically
+    current_time = time.time()
+    should_train = (
+        market_state['models'] is None or 
+        len(market_state['models']) == 0 or
+        (current_time - market_state['last_training_time'] > TRAIN_INTERVAL)
+    )
+    
+    if should_train:
         try:
-            market_state['model'] = train_model(df)
-            market_state['last_training_time'] = time.time()
+            models, scaler = train_model(df)
+            if models:
+                market_state['models'] = models
+                market_state['scaler'] = scaler
+                market_state['last_training_time'] = current_time
         except Exception as e:
             logging.error(f"Training failed: {e}")
+            import traceback
+            traceback.print_exc()
 
-    # 3. Get Prediction
+    # 3. Generate Predictions
     predictions = []
     try:
-        predictions = get_prediction(df, market_state['model'])
+        predictions = get_prediction(df, market_state['models'], market_state['scaler'])
     except Exception as e:
         logging.error(f"Prediction failed: {e}")
 
-    # 4. Prepare Data for Broadcast
-    # Clean NaNs for JSON
+    # 4. Prepare Display Data
     df_clean = df.replace([np.inf, -np.inf], np.nan)
     df_clean = df_clean.astype(object).where(pd.notnull(df_clean), None)
     
+    # Calculate stats
     last_close = float(df['close'].iloc[-1]) if len(df) > 0 else 0
-    first_close = float(df['close'].iloc[0]) if len(df) > 0 else 0
+    first_close = float(df['close'].iloc[0]) if len(df) > 0 else last_close
     price_change = ((last_close - first_close) / first_close * 100) if first_close > 0 else 0
     
     market_state['last_price'] = last_close
     market_state['price_change'] = price_change
     
-    # Only send last 500 candles to client to save bandwidth, but keep full history in memory
+    # Only send last 500 candles to client
     display_data = df_clean.tail(500).to_dict('records')
-    last_row = df.iloc[-1] if len(df) > 0 else {}
+    
+    # Extract last row stats safely
+    last_row = df.iloc[-1]
+    
+    def safe_get(series, key, default=0):
+        try:
+            val = series[key] if key in series.index else default
+            return float(val) if pd.notna(val) and np.isfinite(val) else default
+        except:
+            return default
     
     return {
         "data": display_data,
@@ -214,14 +450,17 @@ def process_market_data():
         "stats": {
             "price": last_close,
             "change": round(price_change, 2),
-            "rsi": round(float(last_row.get('rsi', 0)), 1) if pd.notna(last_row.get('rsi')) else 0,
-            "macd": round(float(last_row.get('macd', 0)), 2) if pd.notna(last_row.get('macd')) else 0,
-            "atr": round(float(last_row.get('atr', 0)), 2) if pd.notna(last_row.get('atr')) else 0,
-            "volume": round(float(last_row.get('volume', 0)), 2) if pd.notna(last_row.get('volume')) else 0
+            "rsi": round(safe_get(last_row, 'rsi'), 1),
+            "macd": round(safe_get(last_row, 'macd'), 2),
+            "atr": round(safe_get(last_row, 'atr'), 2),
+            "volume": round(safe_get(last_row, 'volume'), 2),
+            "candles": len(market_state['ohlc_history']),
+            "model_ready": len(market_state.get('models', {})) > 0
         }
     }
 
-# --- FRONTEND HTML (No changes needed, handles price data perfectly) ---
+
+# --- FRONTEND HTML ---
 HTML_PAGE = """
 <!DOCTYPE html>
 <html lang="en">
@@ -280,6 +519,21 @@ HTML_PAGE = """
             color: #00ff88;
         }
         
+        .model-badge {
+            background: rgba(191, 90, 242, 0.1);
+            border: 1px solid rgba(191, 90, 242, 0.3);
+            padding: 4px 10px;
+            border-radius: 12px;
+            font-size: 11px;
+            color: #bf5af2;
+        }
+        
+        .model-badge.ready {
+            background: rgba(0, 255, 136, 0.1);
+            border-color: rgba(0, 255, 136, 0.3);
+            color: #00ff88;
+        }
+        
         .stats-row {
             display: flex;
             gap: 24px;
@@ -452,6 +706,15 @@ HTML_PAGE = """
             color: #bf5af2;
             z-index: 10;
         }
+        
+        .candle-count {
+            position: absolute;
+            bottom: 12px;
+            right: 16px;
+            font-size: 10px;
+            color: #444;
+            z-index: 10;
+        }
     </style>
 </head>
 <body>
@@ -459,6 +722,7 @@ HTML_PAGE = """
         <div class="logo-section">
             <div class="logo">QuantAI</div>
             <div class="symbol-badge">BTC/USD</div>
+            <div id="model-status" class="model-badge">Model: Training...</div>
         </div>
         
         <div class="stats-row">
@@ -522,6 +786,7 @@ HTML_PAGE = """
                 <span><div class="dot" style="background: #26a69a; opacity: 0.5"></div>Bollinger</span>
             </div>
             <div class="prediction-badge">AI Forecast: 100 candles</div>
+            <div id="candle-count" class="candle-count">Candles: --</div>
         </div>
         
         <div id="volume-chart" class="chart-wrapper">
@@ -613,6 +878,21 @@ document.addEventListener('DOMContentLoaded', () => {
         crosshairMarkerVisible: false,
         title: 'Forecast'
     });
+    
+    // Prediction confidence band (optional visual)
+    const predUpper = mainChart.addLineSeries({
+        color: 'rgba(191, 90, 242, 0.15)',
+        lineWidth: 1,
+        lineStyle: LightweightCharts.LineStyle.Dotted,
+        crosshairMarkerVisible: false
+    });
+    
+    const predLower = mainChart.addLineSeries({
+        color: 'rgba(191, 90, 242, 0.15)',
+        lineWidth: 1,
+        lineStyle: LightweightCharts.LineStyle.Dotted,
+        crosshairMarkerVisible: false
+    });
 
     const volumeSeries = volChart.addHistogramSeries({
         priceFormat: { type: 'volume' },
@@ -627,6 +907,22 @@ document.addEventListener('DOMContentLoaded', () => {
         lineWidth: 2,
         priceScaleId: 'rsi'
     });
+    
+    // RSI overbought/oversold lines
+    const rsiUpper = oscChart.addLineSeries({
+        color: 'rgba(239, 83, 80, 0.3)',
+        lineWidth: 1,
+        lineStyle: LightweightCharts.LineStyle.Dashed,
+        priceScaleId: 'rsi'
+    });
+    
+    const rsiLower = oscChart.addLineSeries({
+        color: 'rgba(38, 166, 154, 0.3)',
+        lineWidth: 1,
+        lineStyle: LightweightCharts.LineStyle.Dashed,
+        priceScaleId: 'rsi'
+    });
+    
     oscChart.priceScale('rsi').applyOptions({
         scaleMargins: { top: 0.1, bottom: 0.1 }
     });
@@ -679,6 +975,19 @@ document.addEventListener('DOMContentLoaded', () => {
             rsiEl.className = 'stat-value ' + (rsiVal > 70 ? 'negative' : rsiVal < 30 ? 'positive' : 'neutral');
             
             document.getElementById('atr').textContent = stats.atr;
+            
+            // Update model status
+            const modelBadge = document.getElementById('model-status');
+            if (stats.model_ready) {
+                modelBadge.textContent = 'Model: Active';
+                modelBadge.className = 'model-badge ready';
+            } else {
+                modelBadge.textContent = 'Model: Training...';
+                modelBadge.className = 'model-badge';
+            }
+            
+            // Update candle count
+            document.getElementById('candle-count').textContent = 'Candles: ' + (stats.candles || '--');
         }
         
         if (lastData) {
@@ -760,7 +1069,13 @@ document.addEventListener('DOMContentLoaded', () => {
                     if (volData.length > 0) volumeSeries.setData(volData);
                     
                     const rsiData = safeMap(d, 'rsi');
-                    if (rsiData.length > 0) rsi.setData(rsiData);
+                    if (rsiData.length > 0) {
+                        rsi.setData(rsiData);
+                        // Set RSI reference lines
+                        const times = rsiData.map(x => x.time);
+                        rsiUpper.setData(times.map(t => ({time: t, value: 70})));
+                        rsiLower.setData(times.map(t => ({time: t, value: 30})));
+                    }
                     
                     const macdData = d
                         .filter(x => x && x.time && x.macd_hist !== null && x.macd_hist !== undefined && !isNaN(x.macd_hist))
@@ -771,6 +1086,7 @@ document.addEventListener('DOMContentLoaded', () => {
                         }));
                     if (macdData.length > 0) macdHist.setData(macdData);
                     
+                    // Handle predictions with confidence bands
                     if (payload.prediction && payload.prediction.length > 0) {
                         const lastCandle = candleData[candleData.length - 1];
                         const predData = [
@@ -778,6 +1094,18 @@ document.addEventListener('DOMContentLoaded', () => {
                             ...payload.prediction.filter(p => p && p.time && p.value !== null && !isNaN(p.value))
                         ];
                         predLine.setData(predData);
+                        
+                        // Add confidence bands (±1% expanding over time)
+                        const upperBand = predData.map((p, i) => ({
+                            time: p.time,
+                            value: p.value * (1 + 0.002 * Math.sqrt(i))
+                        }));
+                        const lowerBand = predData.map((p, i) => ({
+                            time: p.time,
+                            value: p.value * (1 - 0.002 * Math.sqrt(i))
+                        }));
+                        predUpper.setData(upperBand);
+                        predLower.setData(lowerBand);
                     }
                     
                     updateStats(payload.stats, d[d.length - 1]);
@@ -808,10 +1136,11 @@ document.addEventListener('DOMContentLoaded', () => {
 </html>
 """
 
+
 async def fetch_initial_data():
+    """Fetch initial OHLC data from Kraken"""
     try:
         async with aiohttp.ClientSession() as session:
-            # Although Kraken returns limited data, we set logic to accumulate it over time.
             url = "https://api.kraken.com/0/public/OHLC?pair=XBTUSD&interval=1"
             async with session.get(url, timeout=aiohttp.ClientTimeout(total=30)) as response:
                 if response.status == 200:
@@ -838,7 +1167,9 @@ async def fetch_initial_data():
         logging.error(f"Initial data fetch error: {e}")
     return False
 
+
 async def kraken_rest_worker():
+    """Background worker to fetch and update OHLC data"""
     await fetch_initial_data()
     
     while True:
@@ -861,26 +1192,22 @@ async def kraken_rest_worker():
                                             'close': float(c[4]),
                                             'volume': float(c[6])
                                         }
-                                        for c in raw[-10:]
+                                        for c in raw[-20:]  # Get last 20 candles for merging
                                     ]
                                     
-                                    # Intelligent Merge to keep history
                                     if market_state['ohlc_history']:
                                         existing_times = {c['time'] for c in market_state['ohlc_history']}
                                         for nc in new_candles:
                                             if nc['time'] in existing_times:
-                                                # Update existing (in case close price changed)
                                                 for i, ec in enumerate(market_state['ohlc_history']):
                                                     if ec['time'] == nc['time']:
                                                         market_state['ohlc_history'][i] = nc
                                                         break
                                             else:
-                                                # Append new
                                                 market_state['ohlc_history'].append(nc)
                                         
                                         market_state['ohlc_history'].sort(key=lambda x: x['time'])
                                         
-                                        # Keep MAX_HISTORY (5000)
                                         if len(market_state['ohlc_history']) > MAX_HISTORY:
                                             market_state['ohlc_history'] = market_state['ohlc_history'][-MAX_HISTORY:]
                                     
@@ -891,7 +1218,9 @@ async def kraken_rest_worker():
         
         await asyncio.sleep(5)
 
+
 async def broadcast_worker():
+    """Broadcast market data to connected clients"""
     while True:
         if connected_clients and market_state['ready']:
             payload = process_market_data()
@@ -906,7 +1235,9 @@ async def broadcast_worker():
                 connected_clients.difference_update(disconnected)
         await asyncio.sleep(BROADCAST_RATE)
 
+
 async def websocket_handler(request):
+    """Handle WebSocket connections"""
     ws = web.WebSocketResponse()
     await ws.prepare(request)
     connected_clients.add(ws)
@@ -919,17 +1250,22 @@ async def websocket_handler(request):
         logging.info(f"Client disconnected. Total: {len(connected_clients)}")
     return ws
 
+
 async def handle_index(request):
     return web.Response(text=HTML_PAGE, content_type='text/html')
 
+
 async def handle_health(request):
     return web.json_response({
         "status": "ok",
         "ready": market_state['ready'],
         "candles": len(market_state['ohlc_history']),
-        "clients": len(connected_clients)
+        "clients": len(connected_clients),
+        "model_ready": len(market_state.get('models', {})) > 0,
+        "training_metrics": market_state.get('training_metrics', {})
     })
 
+
 async def main():
     app = web.Application()
     app.router.add_get('/', handle_index)
@@ -948,6 +1284,7 @@ async def main():
     
     await asyncio.Event().wait()
 
+
 if __name__ == "__main__":
     try:
         asyncio.run(main())