nextrade-engine 0.6.0__tar.gz → 0.7.0__tar.gz

{nextrade_engine-0.6.0/nextrade/nextrade_engine.egg-info → nextrade_engine-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextrade-engine
-Version: 0.6.0
+Version: 0.7.0
 Summary: AI Trading Engine — Ringan, Multi-Market, Bisa di HP
 Author-email: NexTrade <wafiqrazy035@gmail.com>
 License-Expression: MIT
@@ -13,6 +13,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: yfinance
+Requires-Dist: scikit-learn
 Dynamic: license-file
 
 # NexTrade 🧠

nextrade_engine-0.7.0/nextrade/nextrade/__init__.py

@@ -0,0 +1,330 @@
+"""
+NexTrade — AI Trading Engine
+import nextrade  →  wizard muncul otomatis di terminal
+"""
+
+from nextrade.lang import set_language, list_languages, get, current as _lang
+from nextrade.utils.terminal_ui import (
+    print_welcome, print_signal, print_error,
+    print_loading, print_success, list_strategies, STRATEGIES
+)
+from nextrade.indicators.confluence import confluence_score
+from nextrade.core.regime import detect_regime
+from nextrade.core.brain import Brain
+from nextrade.data.fetcher import fetch, fetch_multi, list_markets
+import numpy as np
+
+__version__ = "0.7.0"
+__author__  = "NexTrade"
+
+# Tampilkan wizard saat pertama kali import
+print_welcome()
+
+# Global instances
+_brain    = Brain.__new__(Brain)
+_brain.state = None
+_ml_engine = None
+
+def _get_brain():
+    global _brain
+    if _brain.state is None:
+        _brain = Brain()
+    return _brain
+
+def _get_ml():
+    global _ml_engine
+    return _ml_engine
+
+# ─────────────────────────────────────────
+# PUBLIC API
+# ─────────────────────────────────────────
+
+def start(strategy: str   = "adaptive",
+          market: str     = "BTCUSD",
+          timeframe: str  = "H1",
+          data: dict      = None,
+          use_ml: bool    = False):
+    """
+    Jalankan NexTrade dengan strategi pilihan.
+
+    Contoh:
+        nextrade.start("momentum", market="BTCUSD")
+        nextrade.start("adaptive", market="EURUSD", use_ml=True)
+    """
+    strategy = strategy.lower().strip()
+    if strategy not in STRATEGIES:
+        print_error(f"{get('error_strategy')}: {', '.join(STRATEGIES)}")
+        list_strategies()
+        return
+
+    print_loading(f"{get('loading_strategy')} {strategy.upper()}...")
+
+    if data is None:
+        data = fetch(market, timeframe, bars=500)
+        if data is None:
+            print_error(get('error_data'))
+            return
+
+    print_loading(f"{get('loading_indicators')}...")
+
+    # ── Sinyal dari rule-based engine ─────────────────────
+    result     = confluence_score(
+        opens=data["open"], highs=data["high"],
+        lows=data["low"],   closes=data["close"],
+    )
+    brain      = _get_brain()
+    threshold  = brain.get_confidence_threshold()
+    confidence = result["confidence"]
+
+    if confidence >= threshold and result["details"]["pattern"]["direction"] != "bear":
+        signal_rb = "BUY"
+    elif confidence <= (100 - threshold) or result["details"]["pattern"]["direction"] == "bear":
+        signal_rb = "SELL"
+    else:
+        signal_rb = "HOLD"
+
+    # ── Sinyal dari ML engine (opsional) ──────────────────
+    ml_signal = None
+    ml_conf   = None
+    ml_proba  = None
+
+    if use_ml:
+        ml = _get_ml()
+        if ml is None or not ml.is_trained:
+            print(f"  \033[33m⚠\033[0m  ML belum ditraining. "
+                  f"Jalankan \033[1mnextrade.train_ml()\033[0m dulu.\n"
+                  f"  \033[2mMenggunakan rule-based engine sementara...\033[0m\n")
+        else:
+            print_loading("Menjalankan ML engine...")
+            ml_signal, ml_conf, ml_proba = ml.predict(
+                data["open"], data["high"],
+                data["low"],  data["close"],
+                data.get("volume"))
+
+    # ── Gabungkan sinyal (ML + Rule-based) ────────────────
+    if ml_signal and ml_conf:
+        # Voting: ML 60% + Rule-based 40%
+        signals_vote = {"BUY": 0.0, "SELL": 0.0, "HOLD": 0.0}
+        signals_vote[ml_signal]  += ml_conf   * 0.6
+        signals_vote[signal_rb]  += confidence * 0.4
+        signal     = max(signals_vote, key=signals_vote.get)
+        confidence = round(signals_vote[signal], 2)
+        source     = "ML + Rule-based"
+    else:
+        signal = signal_rb
+        source = "Rule-based"
+
+    print_signal(signal=signal, confidence=confidence,
+                 strategy=strategy, market=market)
+
+    regime = result["details"]["regime"]["regime"]
+    rsi    = result["details"]["rsi"]
+    price  = data["price_now"]
+
+    print(f"  \033[2m{get('detail_analysis')}:\033[0m")
+    print(f"  \033[36m{get('price_now'):<18}:\033[0m  {price:,.5f}")
+    print(f"  \033[36m{get('market_condition'):<18}:\033[0m  {get(regime)}")
+    print(f"  \033[36mRSI Adaptif       :\033[0m  {rsi:.1f}")
+    print(f"  \033[36m{get('iq_model'):<18}:\033[0m  {brain.state['iq']} / 100")
+    print(f"  \033[36mEngine            :\033[0m  {source}")
+
+    if ml_signal:
+        print(f"  \033[36mML Signal         :\033[0m  {ml_signal}  "
+              f"\033[2m({ml_conf:.1f}%)\033[0m")
+        print(f"  \033[36mML Probabilitas   :\033[0m  "
+              f"BUY={ml_proba.get('BUY',0):.2f}  "
+              f"SELL={ml_proba.get('SELL',0):.2f}  "
+              f"HOLD={ml_proba.get('HOLD',0):.2f}")
+    print()
+
+    return {**result, "signal": signal, "market": market,
+            "price": price, "strategy": strategy, "source": source}
+
+
+def train_ml(market: str    = "BTCUSD",
+             timeframe: str = "H1",
+             bars: int      = 1000,
+             forward: int   = 3,
+             threshold: float = 0.005):
+    """
+    Train ML engine NexTrade dengan data real market.
+
+    Contoh:
+        nextrade.train_ml("BTCUSD", "H1")
+        nextrade.train_ml("EURUSD", "H4", bars=2000)
+        nextrade.train_ml("AAPL",   "D1")
+    """
+    global _ml_engine
+    from nextrade.ml.model import NexTradeML
+
+    print(f"\n  \033[1m\033[37m NexTrade ML Training\033[0m")
+    print(f"  \033[36m{'─' * 44}\033[0m")
+
+    data = fetch(market, timeframe, bars=bars)
+    if data is None:
+        print_error(get('error_data'))
+        return None
+
+    _ml_engine = NexTradeML()
+
+    # Coba load model tersimpan dulu
+    if _ml_engine.load():
+        print(f"  \033[32m✓\033[0m  Model tersimpan ditemukan — "
+              f"winrate sebelumnya: {_ml_engine.winrate:.1f}%")
+        print(f"  \033[36m⠿\033[0m  Melatih ulang dengan data terbaru...\n")
+
+    result = _ml_engine.train(
+        opens=data["open"], highs=data["high"],
+        lows=data["low"],   closes=data["close"],
+        volume=data.get("volume"),
+        forward=forward, threshold=threshold,
+    )
+
+    # Update brain IQ berdasarkan winrate ML
+    brain = _get_brain()
+    brain.state["correct_predictions"] += int(
+        result["winrate"] / 100 * result["samples_train"])
+    brain.state["total_predictions"]   += result["samples_train"]
+    brain.state["iq"] = min(int(result["winrate"]), 100)
+
+    print(f"  \033[32m✓\033[0m  IQ Model diupdate ke: "
+          f"\033[1m\033[33m{brain.state['iq']}\033[0m\n")
+
+    return _ml_engine
+
+
+def ml_status():
+    """Tampilkan status ML engine."""
+    ml = _get_ml()
+    if ml is None or not ml.is_trained:
+        print(f"\n  \033[33m⚠\033[0m  ML belum ditraining. "
+              f"Jalankan \033[1mnextrade.train_ml()\033[0m dulu.\n")
+        return
+    print(f"\n  \033[1m\033[37m NexTrade ML Status\033[0m")
+    print(f"  \033[36m{'─' * 40}\033[0m")
+    if ml.train_history:
+        h = ml.train_history[-1]
+        print(f"  \033[1mWinrate        :\033[0m  \033[33m{h['winrate']:.1f}%\033[0m")
+        print(f"  \033[1mPrice Predictor:\033[0m  {h['acc_price']:.1f}%")
+        print(f"  \033[1mPattern Classif:\033[0m  {h['acc_pattern']:.1f}%")
+        print(f"  \033[1mSignal Filter  :\033[0m  {h['acc_filter']:.1f}%")
+        print(f"  \033[1mTotal Features :\033[0m  {h['features']}")
+        print(f"  \033[1mSamples Train  :\033[0m  {h['samples_train']:,}")
+    print(f"  \033[36m{'─' * 40}\033[0m\n")
+
+
+def train(mode: str = "hybrid", market: str = "BTCUSD",
+          timeframe: str = "D1", bars: int = 1000):
+    """Latih brain NexTrade dengan data real market."""
+    print(f"\n  \033[1m\033[37m Training NexTrade Brain\033[0m")
+    print(f"  \033[36m{'─' * 40}\033[0m")
+    data = fetch(market, timeframe, bars=bars)
+    if data is None:
+        print_error(get('error_data'))
+        return
+    _get_brain().train(mode=mode, data=data)
+
+
+def brain_status():
+    """Tampilkan status otak NexTrade."""
+    _get_brain().status()
+
+
+def set_agresivitas(pct: int):
+    """Set agresivitas sinyal (0-100)."""
+    _get_brain().set_agresivitas(pct)
+
+
+def scan(markets: list = None, timeframe: str = "H1",
+         use_ml: bool = False):
+    """Scan banyak market sekaligus."""
+    if markets is None:
+        markets = ["BTCUSD", "EURUSD", "XAUUSD", "AAPL", "TSLA"]
+
+    print(f"\n  \033[1m\033[37m NexTrade Market Scanner\033[0m")
+    print(f"  \033[36m{'─' * 58}\033[0m")
+    print(f"  \033[2m{'MARKET':<12} {'HARGA':>14} {get('signal'):>8} "
+          f"{'CONF':>8} {'ENGINE'}\033[0m")
+    print(f"  \033[36m{'─' * 58}\033[0m")
+
+    results = []
+    ml = _get_ml()
+
+    for market in markets:
+        data = fetch(market, timeframe, bars=300, silent=True)
+        if data is None: continue
+
+        result = confluence_score(
+            opens=data["open"], highs=data["high"],
+            lows=data["low"],   closes=data["close"],
+        )
+
+        signal     = result["signal"]
+        confidence = result["confidence"]
+        price      = data["price_now"]
+        engine_tag = "rule"
+
+        if use_ml and ml and ml.is_trained:
+            ms, mc, _ = ml.predict(
+                data["open"], data["high"],
+                data["low"],  data["close"],
+                data.get("volume"))
+            vote = {"BUY":0.0,"SELL":0.0,"HOLD":0.0}
+            vote[ms]     += mc * 0.6
+            vote[signal] += confidence * 0.4
+            signal     = max(vote, key=vote.get)
+            confidence = round(vote[signal], 2)
+            engine_tag = "ML+rule"
+
+        sc = "\033[32m" if signal=="BUY" else "\033[31m" if signal=="SELL" else "\033[33m"
+        print(f"  {market:<12} {price:>14,.5f} {sc}{signal:>8}\033[0m "
+              f"{confidence:>6.1f}%  \033[2m{engine_tag}\033[0m")
+        results.append({**result, "market": market,
+                        "price": price, "signal": signal})
+
+    print(f"  \033[36m{'─' * 58}\033[0m\n")
+    buys  = [r for r in results if r["signal"]=="BUY"]
+    sells = [r for r in results if r["signal"]=="SELL"]
+    if buys:
+        best = max(buys,  key=lambda x: x["confidence"])
+        print(f"  \033[32m★  BUY  : {best['market']} ({best['confidence']:.1f}%)\033[0m")
+    if sells:
+        best = max(sells, key=lambda x: x["confidence"])
+        print(f"  \033[31m★  SELL : {best['market']} ({best['confidence']:.1f}%)\033[0m")
+    print()
+    return results
+
+
+def backtest(strategy: str   = "adaptive",
+             market: str     = "BTCUSD",
+             timeframe: str  = "D1",
+             bars: int       = 500,
+             agresivitas: int = 30,
+             sl_pct: float   = 2.0,
+             tp_pct: float   = 4.0):
+    """Backtest strategi dengan data real historis."""
+    from nextrade.backtest.engine import run as _run
+    data = fetch(market, timeframe, bars=bars)
+    if data is None:
+        print_error(get('error_data'))
+        return
+    return _run(data=data, strategy=strategy, agresivitas=agresivitas,
+                sl_pct=sl_pct, tp_pct=tp_pct)
+
+
+def info():
+    """Tampilkan semua strategi dan market."""
+    list_strategies()
+    list_markets()
+
+
+def regime(market: str = "BTCUSD", timeframe: str = "H1") -> dict:
+    """Deteksi kondisi pasar saat ini."""
+    data = fetch(market, timeframe, bars=100, silent=True)
+    if data is None: return {}
+    return detect_regime(data["close"])
+
+
+def language():
+    """Tampilkan semua bahasa yang tersedia."""
+    list_languages()

nextrade_engine-0.7.0/nextrade/nextrade/ml/features.py

@@ -0,0 +1,185 @@
+"""
+NexTrade ML — Feature Engineering Layer
+30 fitur dari data OHLCV untuk model ML.
+"""
+import numpy as np
+
+def _safe_div(a, b, fill=0.0):
+    return np.where(np.abs(b) > 1e-9, a / b, fill)
+
+def _rolling(arr, n, func):
+    out = np.full(len(arr), np.nan)
+    for i in range(n-1, len(arr)):
+        out[i] = func(arr[i-n+1:i+1])
+    return out
+
+def _ema(arr, period):
+    k = 2 / (period + 1)
+    out = np.full(len(arr), np.nan)
+    out[period-1] = np.mean(arr[:period])
+    for i in range(period, len(arr)):
+        out[i] = arr[i] * k + out[i-1] * (1 - k)
+    return out
+
+def _rsi(close, period=14):
+    delta = np.diff(close, prepend=close[0])
+    gain  = np.where(delta > 0, delta, 0.0)
+    loss  = np.where(delta < 0, -delta, 0.0)
+    avg_g = _rolling(gain, period, np.mean)
+    avg_l = _rolling(loss, period, np.mean)
+    rs    = _safe_div(avg_g, avg_l + 1e-9)
+    return 100 - 100 / (1 + rs)
+
+def _atr(high, low, close, period=14):
+    tr = np.maximum(high - low,
+         np.maximum(np.abs(high - np.roll(close, 1)),
+                    np.abs(low  - np.roll(close, 1))))
+    return _rolling(tr, period, np.mean)
+
+def _bollinger(close, period=20):
+    ma  = _rolling(close, period, np.mean)
+    std = _rolling(close, period, np.std)
+    upper = ma + 2 * std
+    lower = ma - 2 * std
+    pct_b = _safe_div(close - lower, upper - lower + 1e-9)
+    width = _safe_div(upper - lower, ma + 1e-9)
+    return pct_b, width
+
+def _macd(close, fast=12, slow=26, signal=9):
+    ema_f = _ema(close, fast)
+    ema_s = _ema(close, slow)
+    macd  = ema_f - ema_s
+    sig   = _ema(np.nan_to_num(macd), signal)
+    return macd, sig, macd - sig
+
+def _stochastic(high, low, close, k=14, d=3):
+    lowest  = _rolling(low,  k, np.min)
+    highest = _rolling(high, k, np.max)
+    stoch_k = _safe_div(close - lowest, highest - lowest + 1e-9) * 100
+    stoch_d = _rolling(stoch_k, d, np.mean)
+    return stoch_k, stoch_d
+
+def _williams_r(high, low, close, period=14):
+    highest = _rolling(high, period, np.max)
+    lowest  = _rolling(low,  period, np.min)
+    return _safe_div(highest - close, highest - lowest + 1e-9) * -100
+
+def _cci(high, low, close, period=20):
+    tp  = (high + low + close) / 3
+    ma  = _rolling(tp, period, np.mean)
+    mad = _rolling(tp, period, lambda x: np.mean(np.abs(x - np.mean(x))))
+    return _safe_div(tp - ma, 0.015 * mad + 1e-9)
+
+def _obv(close, volume):
+    direction = np.sign(np.diff(close, prepend=close[0]))
+    return np.cumsum(direction * volume)
+
+def _vwap(high, low, close, volume):
+    tp   = (high + low + close) / 3
+    cvol = np.cumsum(volume)
+    ctpv = np.cumsum(tp * volume)
+    return _safe_div(ctpv, cvol + 1e-9)
+
+def build_features(opens: np.ndarray, highs: np.ndarray,
+                   lows: np.ndarray, closes: np.ndarray,
+                   volume: np.ndarray = None) -> np.ndarray:
+    """
+    Bangun 30 fitur ML dari data OHLCV.
+    Returns: np.ndarray shape (n, 30)
+    """
+    n = len(closes)
+    if volume is None:
+        volume = np.ones(n)
+
+    # Price returns
+    ret1  = _safe_div(np.diff(closes, prepend=closes[0]), closes)
+    ret5  = _safe_div(closes - np.roll(closes, 5),  closes)
+    ret10 = _safe_div(closes - np.roll(closes, 10), closes)
+    ret20 = _safe_div(closes - np.roll(closes, 20), closes)
+
+    # Trend
+    ema8   = _ema(closes, 8)
+    ema21  = _ema(closes, 21)
+    ema50  = _ema(closes, 50)
+    p_e8   = _safe_div(closes - ema8,  closes)
+    p_e21  = _safe_div(closes - ema21, closes)
+    p_e50  = _safe_div(closes - ema50, closes)
+    e8_e21 = _safe_div(ema8  - ema21,  closes)
+    e21_e50= _safe_div(ema21 - ema50,  closes)
+
+    # Momentum
+    rsi14 = _rsi(closes, 14)
+    rsi7  = _rsi(closes, 7)
+    rsi21 = _rsi(closes, 21)
+    _, _, macd_hist = _macd(closes)
+    macd_n = _safe_div(macd_hist, closes)
+    stoch_k, stoch_d = _stochastic(highs, lows, closes)
+    will_r = _williams_r(highs, lows, closes)
+    cci    = _cci(highs, lows, closes)
+
+    # Volatility
+    atr_n = _safe_div(_atr(highs, lows, closes, 14), closes)
+    bb_pct, bb_width = _bollinger(closes)
+    vs5  = _rolling(ret1, 5,  np.std)
+    vs20 = _rolling(ret1, 20, np.std)
+
+    # Volume
+    vol_ma = _rolling(volume, 20, np.mean)
+    vol_n  = _safe_div(volume, vol_ma + 1)
+    obv_v  = _obv(closes, volume)
+    obv_n  = _safe_div(obv_v, np.abs(obv_v).max() + 1e-9)
+    vwap_d = _safe_div(closes - _vwap(highs, lows, closes, volume), closes)
+
+    # Candle pattern
+    body   = np.abs(closes - opens)
+    rng    = highs - lows + 1e-9
+    body_p = _safe_div(body, rng)
+    upper  = highs - np.maximum(opens, closes)
+    lower  = np.minimum(opens, closes) - lows
+    up_p   = _safe_div(upper, rng)
+    lo_p   = _safe_div(lower, rng)
+    is_bull= (closes > opens).astype(float)
+
+    # Position in range
+    h20    = _rolling(highs, 20, np.max)
+    l20    = _rolling(lows,  20, np.min)
+    pos_r  = _safe_div(closes - l20, h20 - l20 + 1e-9)
+
+    features = np.column_stack([
+        ret1, ret5, ret10, ret20,
+        p_e8, p_e21, p_e50, e8_e21, e21_e50,
+        rsi14, rsi7, rsi21,
+        macd_n, stoch_k, stoch_d, will_r, cci,
+        atr_n, bb_pct, bb_width, vs5, vs20,
+        vol_n, obv_n, vwap_d,
+        body_p, up_p, lo_p, is_bull,
+        pos_r,
+    ])
+
+    return np.nan_to_num(features, nan=0.0, posinf=0.0, neginf=0.0)
+
+def build_labels(closes: np.ndarray,
+                 forward: int = 3,
+                 threshold: float = 0.005) -> np.ndarray:
+    """
+    Label: 1=BUY, -1=SELL, 0=HOLD
+    Berdasarkan pergerakan harga forward bar ke depan.
+    """
+    labels = np.zeros(len(closes), dtype=int)
+    for i in range(len(closes) - forward):
+        ret = (closes[i+forward] - closes[i]) / (closes[i] + 1e-9)
+        if ret > threshold:   labels[i] = 1
+        elif ret < -threshold: labels[i] = -1
+    return labels
+
+def feature_names() -> list:
+    return [
+        "ret1","ret5","ret10","ret20",
+        "p_ema8","p_ema21","p_ema50","ema8_21","ema21_50",
+        "rsi14","rsi7","rsi21",
+        "macd","stoch_k","stoch_d","williams_r","cci",
+        "atr","bb_pct","bb_width","vol_std5","vol_std20",
+        "vol_norm","obv_norm","vwap_dist",
+        "body_pct","upper_wick","lower_wick","is_bull",
+        "pos_range",
+    ]

nextrade_engine-0.7.0/nextrade/nextrade/ml/model.py

@@ -0,0 +1,250 @@
+"""
+NexTrade ML — 3 Model Spesialis + Ensemble
+Price Predictor + Pattern Classifier + Signal Filter
+"""
+import numpy as np
+import os
+import pickle
+from nextrade.ml.features import build_features, build_labels, feature_names
+
+try:
+    from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
+    from sklearn.linear_model import LogisticRegression
+    from sklearn.preprocessing import StandardScaler
+    from sklearn.calibration import CalibratedClassifierCV
+    SKLEARN_OK = True
+except ImportError:
+    SKLEARN_OK = False
+
+MODEL_PATH = os.path.join(os.path.dirname(__file__), "saved_model.pkl")
+
+class NexTradeML:
+    """
+    Engine ML NexTrade — 3 spesialis + ensemble.
+
+    Cara pakai:
+        ml = NexTradeML()
+        ml.train(opens, highs, lows, closes, volume)
+        signal, confidence, proba = ml.predict(opens, highs, lows, closes)
+    """
+
+    def __init__(self):
+        if not SKLEARN_OK:
+            raise ImportError("scikit-learn belum terinstall. "
+                              "Jalankan: pip install scikit-learn")
+        self.scaler     = StandardScaler()
+        self.is_trained = False
+        self.weights    = np.array([0.4, 0.35, 0.25])  # bobot awal
+        self.train_history = []
+        self._build_models()
+
+    def _build_models(self):
+        # Model 1: Price Predictor — Random Forest
+        self.price_model = RandomForestClassifier(
+            n_estimators   = 200,
+            max_depth       = 8,
+            min_samples_leaf= 5,
+            class_weight    = "balanced",
+            random_state    = 42,
+            n_jobs          = -1,
+        )
+        # Model 2: Pattern Classifier — Gradient Boosting
+        self.pattern_model = GradientBoostingClassifier(
+            n_estimators  = 150,
+            max_depth     = 5,
+            learning_rate = 0.05,
+            subsample     = 0.8,
+            random_state  = 42,
+        )
+        # Model 3: Signal Filter — Logistic Regression
+        self.filter_model = LogisticRegression(
+            C            = 1.0,
+            class_weight = "balanced",
+            max_iter     = 500,
+            random_state = 42,
+        )
+
+    def train(self, opens: np.ndarray, highs: np.ndarray,
+              lows: np.ndarray, closes: np.ndarray,
+              volume: np.ndarray = None,
+              forward: int = 3,
+              threshold: float = 0.005,
+              silent: bool = False) -> dict:
+        """
+        Latih semua model dengan data OHLCV.
+        Returns dict hasil training.
+        """
+        if not silent:
+            print(f"\n  \033[36m⠿\033[0m  Membangun {len(closes):,} fitur ML...")
+
+        X = build_features(opens, highs, lows, closes, volume)
+        y = build_labels(closes, forward=forward, threshold=threshold)
+
+        # Potong label terakhir yang tidak valid
+        valid = len(closes) - forward
+        X, y  = X[:valid], y[:valid]
+
+        # Split train/val
+        split = int(valid * 0.8)
+        X_tr, X_val = X[:split], X[split:]
+        y_tr, y_val = y[:split], y[split:]
+
+        # Scale
+        X_tr_s  = self.scaler.fit_transform(X_tr)
+        X_val_s = self.scaler.transform(X_val)
+
+        if not silent:
+            dist = {1: int((y_tr==1).sum()), -1: int((y_tr==-1).sum()),
+                    0: int((y_tr==0).sum())}
+            print(f"  \033[36m⠿\033[0m  Label: BUY={dist[1]} SELL={dist[-1]} HOLD={dist[0]}")
+            print(f"  \033[36m⠿\033[0m  Training 3 model spesialis...")
+
+        # Train semua model
+        self.price_model.fit(X_tr_s, y_tr)
+        if not silent: print(f"  \033[32m✓\033[0m  Price Predictor (RandomForest) selesai")
+
+        self.pattern_model.fit(X_tr_s, y_tr)
+        if not silent: print(f"  \033[32m✓\033[0m  Pattern Classifier (GradientBoosting) selesai")
+
+        self.filter_model.fit(X_tr_s, y_tr)
+        if not silent: print(f"  \033[32m✓\033[0m  Signal Filter (LogisticRegression) selesai")
+
+        # Evaluasi dan update bobot adaptif
+        acc1 = self.price_model.score(X_val_s, y_val)
+        acc2 = self.pattern_model.score(X_val_s, y_val)
+        acc3 = self.filter_model.score(X_val_s, y_val)
+
+        # Bobot proporsional ke akurasi
+        accs = np.array([acc1, acc2, acc3])
+        self.weights = accs / (accs.sum() + 1e-9)
+
+        # Hitung winrate keseluruhan
+        preds_val = self._ensemble_predict(X_val_s)
+        winrate = float(np.mean(preds_val == y_val) * 100)
+
+        result = {
+            "winrate"        : round(winrate, 2),
+            "acc_price"      : round(acc1 * 100, 2),
+            "acc_pattern"    : round(acc2 * 100, 2),
+            "acc_filter"     : round(acc3 * 100, 2),
+            "weights"        : self.weights.tolist(),
+            "samples_train"  : split,
+            "samples_val"    : valid - split,
+            "features"       : X.shape[1],
+        }
+
+        self.is_trained = True
+        self.train_history.append(result)
+        self._save()
+
+        if not silent:
+            print(f"\n  \033[1m\033[37m Hasil Training ML\033[0m")
+            print(f"  \033[36m{'─' * 44}\033[0m")
+            print(f"  \033[1mWinrate Overall  :\033[0m  \033[33m{winrate:.1f}%\033[0m")
+            print(f"  \033[1mPrice Predictor  :\033[0m  {acc1*100:.1f}%  "
+                  f"\033[2m(bobot {self.weights[0]:.2f})\033[0m")
+            print(f"  \033[1mPattern Classif. :\033[0m  {acc2*100:.1f}%  "
+                  f"\033[2m(bobot {self.weights[1]:.2f})\033[0m")
+            print(f"  \033[1mSignal Filter    :\033[0m  {acc3*100:.1f}%  "
+                  f"\033[2m(bobot {self.weights[2]:.2f})\033[0m")
+            print(f"  \033[36m{'─' * 44}\033[0m\n")
+
+        return result
+
+    def predict(self, opens: np.ndarray, highs: np.ndarray,
+                lows: np.ndarray, closes: np.ndarray,
+                volume: np.ndarray = None) -> tuple:
+        """
+        Prediksi sinyal untuk candle terbaru.
+        Returns: (signal, confidence, proba_dict)
+        signal: 'BUY' | 'SELL' | 'HOLD'
+        """
+        if not self.is_trained:
+            return "HOLD", 50.0, {"BUY": 0.33, "SELL": 0.33, "HOLD": 0.34}
+
+        X   = build_features(opens, highs, lows, closes, volume)
+        X_s = self.scaler.transform(X[-1:])
+
+        pred   = self._ensemble_predict(X_s)[0]
+        probas = self._ensemble_proba(X_s)[0]
+
+        # Map label ke signal
+        label_map = {1: "BUY", -1: "SELL", 0: "HOLD"}
+        signal    = label_map.get(pred, "HOLD")
+
+        # Confidence = probabilitas kelas yang dipilih * 100
+        classes   = list(self.price_model.classes_)
+        idx       = classes.index(pred) if pred in classes else 0
+        confidence = float(probas[idx] * 100)
+
+        proba_dict = {}
+        for i, cls in enumerate(classes):
+            key = label_map.get(cls, "HOLD")
+            proba_dict[key] = round(float(probas[i]), 4)
+
+        return signal, round(confidence, 2), proba_dict
+
+    def _ensemble_predict(self, X_s: np.ndarray) -> np.ndarray:
+        """Gabungkan prediksi 3 model dengan bobot adaptif."""
+        p1 = self._get_proba(self.price_model,   X_s)
+        p2 = self._get_proba(self.pattern_model, X_s)
+        p3 = self._get_proba(self.filter_model,  X_s)
+        combined = (p1 * self.weights[0] +
+                    p2 * self.weights[1] +
+                    p3 * self.weights[2])
+        classes = list(self.price_model.classes_)
+        return np.array([classes[i] for i in combined.argmax(axis=1)])
+
+    def _ensemble_proba(self, X_s: np.ndarray) -> np.ndarray:
+        p1 = self._get_proba(self.price_model,   X_s)
+        p2 = self._get_proba(self.pattern_model, X_s)
+        p3 = self._get_proba(self.filter_model,  X_s)
+        return (p1 * self.weights[0] +
+                p2 * self.weights[1] +
+                p3 * self.weights[2])
+
+    def _get_proba(self, model, X_s):
+        try:
+            return model.predict_proba(X_s)
+        except Exception:
+            preds = model.predict(X_s)
+            classes = list(model.classes_)
+            out = np.zeros((len(preds), len(classes)))
+            for i, p in enumerate(preds):
+                out[i, classes.index(p)] = 1.0
+            return out
+
+    def _save(self):
+        try:
+            with open(MODEL_PATH, "wb") as f:
+                pickle.dump({
+                    "price_model"  : self.price_model,
+                    "pattern_model": self.pattern_model,
+                    "filter_model" : self.filter_model,
+                    "scaler"       : self.scaler,
+                    "weights"      : self.weights,
+                    "history"      : self.train_history,
+                }, f)
+        except Exception:
+            pass
+
+    def load(self) -> bool:
+        try:
+            with open(MODEL_PATH, "rb") as f:
+                saved = pickle.load(f)
+            self.price_model   = saved["price_model"]
+            self.pattern_model = saved["pattern_model"]
+            self.filter_model  = saved["filter_model"]
+            self.scaler        = saved["scaler"]
+            self.weights       = saved["weights"]
+            self.train_history = saved.get("history", [])
+            self.is_trained    = True
+            return True
+        except Exception:
+            return False
+
+    @property
+    def winrate(self) -> float:
+        if self.train_history:
+            return self.train_history[-1]["winrate"]
+        return 0.0

{nextrade_engine-0.6.0 → nextrade_engine-0.7.0/nextrade/nextrade_engine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextrade-engine
-Version: 0.6.0
+Version: 0.7.0
 Summary: AI Trading Engine — Ringan, Multi-Market, Bisa di HP
 Author-email: NexTrade <wafiqrazy035@gmail.com>
 License-Expression: MIT
@@ -13,6 +13,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: yfinance
+Requires-Dist: scikit-learn
 Dynamic: license-file
 
 # NexTrade 🧠

{nextrade_engine-0.6.0 → nextrade_engine-0.7.0}/nextrade/nextrade_engine.egg-info/SOURCES.txt

@@ -14,6 +14,9 @@ nextrade/nextrade/indicators/__init__.py
 nextrade/nextrade/indicators/adaptive.py
 nextrade/nextrade/indicators/confluence.py
 nextrade/nextrade/indicators/pattern.py
+nextrade/nextrade/ml/__init__.py
+nextrade/nextrade/ml/features.py
+nextrade/nextrade/ml/model.py
 nextrade/nextrade/utils/__init__.py
 nextrade/nextrade/utils/terminal_ui.py
 nextrade/nextrade_engine.egg-info/PKG-INFO

{nextrade_engine-0.6.0 → nextrade_engine-0.7.0}/nextrade/nextrade_engine.egg-info/requires.txt

@@ -1,2 +1,3 @@
 numpy
 yfinance
+scikit-learn

{nextrade_engine-0.6.0 → nextrade_engine-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nextrade-engine"
-version = "0.6.0"
+version = "0.7.0"
 description = "AI Trading Engine — Ringan, Multi-Market, Bisa di HP"
 readme = "README.md"
 license = "MIT"
@@ -21,6 +21,7 @@ requires-python = ">=3.8"
 dependencies = [
     "numpy",
     "yfinance",
+    "scikit-learn",
 ]
 
 [tool.setuptools]

nextrade_engine-0.6.0/nextrade/nextrade/__init__.py

@@ -1,194 +0,0 @@
-"""
-NexTrade — AI Trading Engine
-import nextrade  →  wizard muncul otomatis di terminal
-"""
-
-from nextrade.lang import set_language, list_languages, get, current as _lang
-from nextrade.utils.terminal_ui import (
-    print_welcome, print_signal, print_error,
-    print_loading, print_success, list_strategies, STRATEGIES
-)
-from nextrade.indicators.confluence import confluence_score
-from nextrade.core.regime import detect_regime
-from nextrade.core.brain import Brain
-from nextrade.data.fetcher import fetch, fetch_multi, list_markets
-import numpy as np
-
-__version__ = "0.6.0"
-__author__  = "NexTrade"
-
-# Tampilkan wizard saat pertama kali import
-print_welcome()
-
-# Instance brain global
-_brain = Brain.__new__(Brain)
-_brain.state = None
-
-def _get_brain():
-    global _brain
-    if _brain.state is None:
-        _brain = Brain()
-    return _brain
-
-# ─────────────────────────────────────────
-# PUBLIC API
-# ─────────────────────────────────────────
-
-def start(strategy: str = "adaptive",
-          market: str = "BTCUSD",
-          timeframe: str = "H1",
-          data: dict = None):
-    """
-    Jalankan NexTrade dengan strategi pilihan.
-
-    Contoh:
-        nextrade.start("momentum", market="BTCUSD")
-        nextrade.start("reversal", market="EURUSD", timeframe="H4")
-    """
-    strategy = strategy.lower().strip()
-
-    if strategy not in STRATEGIES:
-        print_error(f"{get('error_strategy')}: {', '.join(STRATEGIES)}")
-        list_strategies()
-        return
-
-    print_loading(f"{get('loading_strategy')} {strategy.upper()}...")
-
-    if data is None:
-        data = fetch(market, timeframe, bars=500)
-        if data is None:
-            print_error(get('error_data'))
-            return
-
-    print_loading(f"{get('loading_indicators')}...")
-
-    result = confluence_score(
-        opens  = data["open"],
-        highs  = data["high"],
-        lows   = data["low"],
-        closes = data["close"],
-    )
-
-    brain      = _get_brain()
-    threshold  = brain.get_confidence_threshold()
-    confidence = result["confidence"]
-
-    if confidence >= threshold and result["details"]["pattern"]["direction"] != "bear":
-        signal = "BUY"
-    elif confidence <= (100 - threshold) or result["details"]["pattern"]["direction"] == "bear":
-        signal = "SELL"
-    else:
-        signal = "HOLD"
-
-    print_signal(signal=signal, confidence=confidence,
-                 strategy=strategy, market=market)
-
-    regime = result["details"]["regime"]["regime"]
-    rsi    = result["details"]["rsi"]
-    mom    = result["details"]["momentum"]
-    price  = data["price_now"]
-
-    print(f"  \033[2m{get('detail_analysis')}:\033[0m")
-    print(f"  \033[36m{get('price_now'):<18}:\033[0m  {price:,.5f}")
-    print(f"  \033[36m{get('market_condition'):<18}:\033[0m  {get(regime)}")
-    print(f"  \033[36mRSI Adaptif       :\033[0m  {rsi:.1f}")
-    print(f"  \033[36m{get('iq_model'):<18}:\033[0m  {brain.state['iq']} / 100")
-    print(f"  \033[36m{get('agresivitas'):<18}:\033[0m  {brain.state['agresivitas']}%")
-    print()
-
-    return {**result, "signal": signal, "market": market,
-            "price": price, "strategy": strategy}
-
-
-def train(mode: str = "hybrid", market: str = "BTCUSD",
-          timeframe: str = "D1", bars: int = 1000):
-    """Latih brain NexTrade dengan data real market."""
-    print(f"\n  \033[1m\033[37m Training NexTrade Brain\033[0m")
-    print(f"  \033[36m{'─' * 40}\033[0m")
-    data = fetch(market, timeframe, bars=bars)
-    if data is None:
-        print_error(get('error_data'))
-        return
-    _get_brain().train(mode=mode, data=data)
-
-
-def brain_status():
-    """Tampilkan status otak NexTrade."""
-    _get_brain().status()
-
-
-def set_agresivitas(pct: int):
-    """Set agresivitas sinyal (0-100)."""
-    _get_brain().set_agresivitas(pct)
-
-
-def scan(markets: list = None, timeframe: str = "H1"):
-    """Scan banyak market sekaligus."""
-    if markets is None:
-        markets = ["BTCUSD", "EURUSD", "XAUUSD", "AAPL", "TSLA"]
-
-    print(f"\n  \033[1m\033[37m NexTrade Market Scanner\033[0m")
-    print(f"  \033[36m{'─' * 55}\033[0m")
-    print(f"  \033[2m{'MARKET':<12} {'HARGA':>14} {get('signal'):>8} "
-          f"{'CONFIDENCE':>12} {get('market_condition')}\033[0m")
-    print(f"  \033[36m{'─' * 55}\033[0m")
-
-    results = []
-    for market in markets:
-        data = fetch(market, timeframe, bars=300, silent=True)
-        if data is None: continue
-        result = confluence_score(
-            opens=data["open"], highs=data["high"],
-            lows=data["low"],   closes=data["close"],
-        )
-        signal     = result["signal"]
-        confidence = result["confidence"]
-        regime     = result["details"]["regime"]["regime"]
-        price      = data["price_now"]
-        sc = "\033[32m" if signal=="BUY" else "\033[31m" if signal=="SELL" else "\033[33m"
-        print(f"  {market:<12} {price:>14,.5f} {sc}{signal:>8}\033[0m "
-              f"{confidence:>10.1f}%  \033[2m{regime}\033[0m")
-        results.append({**result, "market": market, "price": price})
-
-    print(f"  \033[36m{'─' * 55}\033[0m\n")
-    buys  = [r for r in results if r["signal"]=="BUY"]
-    sells = [r for r in results if r["signal"]=="SELL"]
-    if buys:
-        best = max(buys,  key=lambda x: x["confidence"])
-        print(f"  \033[32m★  BUY  : {best['market']} ({best['confidence']:.1f}%)\033[0m")
-    if sells:
-        best = max(sells, key=lambda x: x["confidence"])
-        print(f"  \033[31m★  SELL : {best['market']} ({best['confidence']:.1f}%)\033[0m")
-    print()
-    return results
-
-
-def backtest(strategy: str = "adaptive", market: str = "BTCUSD",
-             timeframe: str = "D1", bars: int = 500,
-             agresivitas: int = 30, sl_pct: float = 2.0, tp_pct: float = 4.0):
-    """Backtest strategi dengan data real historis."""
-    from nextrade.backtest.engine import run as _run
-    data = fetch(market, timeframe, bars=bars)
-    if data is None:
-        print_error(get('error_data'))
-        return
-    return _run(data=data, strategy=strategy, agresivitas=agresivitas,
-                sl_pct=sl_pct, tp_pct=tp_pct)
-
-
-def info():
-    """Tampilkan semua strategi dan market."""
-    list_strategies()
-    list_markets()
-
-
-def regime(market: str = "BTCUSD", timeframe: str = "H1") -> dict:
-    """Deteksi kondisi pasar saat ini."""
-    data = fetch(market, timeframe, bars=100, silent=True)
-    if data is None: return {}
-    return detect_regime(data["close"])
-
-
-def language():
-    """Tampilkan semua bahasa yang tersedia."""
-    list_languages()