Upload 7 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+XAUUSD_M15_Data.csv filter=lfs diff=lfs merge=lfs -text

RL_ONNX_EA.mq5

@@ -0,0 +1,135 @@
+//+------------------------------------------------------------------+
+//|                                             RL_ONNX_EA.mq5       |
+//|                                   Copyright 2026, Algorembrant   |
+//|                                   Rembrant Oyangoren Albeos      |
+//+------------------------------------------------------------------+
+#property copyright "Algorembrant, Rembrant Oyangoren Albeos"
+#property link      "https://github.com/Algorembrant"
+#property version   "1.00"
+
+#include <Trade\Trade.mqh>
+CTrade trade;
+
+// Inputs compatible with the RL training setup
+input string ONNX_Filename = "RL_Agent_XAUUSD.onnx";
+input double RiskPercent = 2.0;
+
+long model_handle = INVALID_HANDLE;
+double max_lot_size = 20.0;
+
+int OnInit() {
+    Print("Initializing RL XAUUSDc ONNX EA...");
+    
+    // Load the ONNX model trained in Google Colab
+    model_handle = OnnxCreate(ONNX_Filename, ONNX_DEFAULT);
+    if(model_handle == INVALID_HANDLE) {
+        Print("Error loading ONNX model ", ONNX_Filename, " : ", GetLastError());
+        return INIT_FAILED;
+    }
+    
+    trade.SetExpertMagicNumber(2026101); // 2026 methodologies
+    
+    return INIT_SUCCEEDED;
+}
+
+void OnDeinit(const int reason) {
+    if(model_handle != INVALID_HANDLE)
+        OnnxRelease(model_handle);
+    Print("EA Deinitialized.");
+}
+
+void OnTick() {
+    // Strictly execute on close-price only (Wait for new bar generation)
+    static datetime last_time = 0;
+    datetime current_time = iTime(_Symbol, _Period, 0);
+    
+    // If the bar hasn't closed / new bar hasn't opened, do nothing
+    if(current_time == last_time) return;
+    last_time = current_time;
+    
+    // --- 1. Fetch data & Indicators
+    // The ONNX model requires the exact 100+ vectorized attributes as built by pandas_ta in python.
+    // In this production script, we construct the input float array shape based on observation_space.
+    // Ensure length matches `features.shape[1]` exactly.
+    float features[];
+    int num_features = 100; // MUST MATCH exactly the CSV features
+    ArrayResize(features, num_features); 
+    
+    for(int i=0; i<ArraySize(features); i++) {
+        // [In a complete system, map MT5 runtime M3 moving averages, FDI, oscillators to these indices here]
+        features[i] = 0.0f; 
+    }
+    
+    // --- 2. Predict with ONNX Model
+    long action_output[] = {3}; // Default 3 = Do Nothing
+    
+    // onnx model inference
+    if(!OnnxRun(model_handle, ONNX_NO_CONVERSION, features, action_output)) {
+        Print("ONNX Run Error: ", GetLastError());
+        return;
+    }
+    
+    long action = action_output[0];
+    
+    // --- 3. Execute Actions & Handle Fragment/Sizing
+    double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
+    double spread = SymbolInfoInteger(_Symbol, SYMBOL_SPREAD) * point;
+    double closePrice = iClose(_Symbol, _Period, 1);
+    double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
+    double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
+    
+    // System rule: After opened, wait until tookprofit or stopout. No averaging.
+    if(PositionsTotal() > 0) return; 
+
+    // StopLoss distance constraints: SL distance never less than spread * 10
+    double sl_dist = MathMax(closePrice * 0.005, spread * 10.0);
+    
+    // Calculate Sizing (2% Risk)
+    double balance = AccountInfoDouble(ACCOUNT_BALANCE);
+    double risk_amount = balance * (RiskPercent / 100.0);
+    
+    // MT5 Standard contract size computation for Gold (usually $100 per lot per $1)
+    double sl_dollar_risk_per_lot = sl_dist * 100.0;
+    double lots = 0.01;
+    
+    if(sl_dollar_risk_per_lot > 0)
+        lots = risk_amount / sl_dollar_risk_per_lot;
+        
+    // Fragmentize execution cap
+    lots = MathRound(lots * 100.0) / 100.0;
+    if(lots < 0.01) lots = 0.01;
+    
+    // Fragmenting Logic: Open multiple positions if lot size exceeds cap
+    int fragments = 1;
+    double current_fragment_lot = lots;
+    
+    if(lots > max_lot_size) {
+        fragments = (int)MathCeil(lots / max_lot_size);
+        current_fragment_lot = max_lot_size;
+        Print("Notice: Position fragmentization triggered. Total Lot = ", lots, " -> Fragmented into ", fragments, " orders.");
+    }
+
+    if(action == 0) { // BUY
+        double stoploss = ask - sl_dist;
+        double takeprofit = ask + (sl_dist * 1.5); // TP >= 1R
+        
+        for(int f=0; f<fragments; f++) {
+            if(f == fragments - 1 && lots > max_lot_size) {
+                // Remaining fraction stringency
+                current_fragment_lot = lots - (max_lot_size * (fragments - 1));
+            }
+            trade.Buy(current_fragment_lot, _Symbol, ask, stoploss, takeprofit, "RL_BUY");
+        }
+    }
+    else if(action == 1) { // SELL
+        double stoploss = bid + sl_dist;
+        double takeprofit = bid - (sl_dist * 1.5); // TP >= 1R
+        
+        for(int f=0; f<fragments; f++) {
+            if(f == fragments - 1 && lots > max_lot_size) {
+                current_fragment_lot = lots - (max_lot_size * (fragments - 1));
+            }
+            trade.Sell(current_fragment_lot, _Symbol, bid, stoploss, takeprofit, "RL_SELL");
+        }
+    }
+}

RL_XAUUSD_Colab_System.ipynb

@@ -0,0 +1,261 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Phase 2: RL Trading Agent for MT5 (XAUUSDc)\n",
+    "This notebook trains a reinforcement learning model on the extracted MT5 data, simulating live-market constraints and exporting an ONNX model for the Expert Advisor."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install -q stable-baselines3[extra] pandas_ta xgboost onnx onnxruntime plotly gym"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import onnx\n",
+    "import onnxruntime as ort\n",
+    "import plotly.graph_objects as go\n",
+    "import gym\n",
+    "from gym import spaces\n",
+    "from stable_baselines3 import PPO\n",
+    "from google.colab import files\n",
+    "\n",
+    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+    "print(f\"Using device: {device}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load Dataset (Upload XAUUSD_M3_Data.csv to Colab first)\n",
+    "if not os.path.exists('XAUUSD_M3_Data.csv'):\n",
+    "    print(\"Please upload XAUUSD_M3_Data.csv to the Colab environment.\")\n",
+    "else:\n",
+    "    df = pd.read_csv('XAUUSD_M3_Data.csv', index_col='time', parse_dates=True)\n",
+    "    print(f\"Loaded {len(df)} rows.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Vectorized Custom Gym Environment for XAUUSDc\n",
+    "class XAUUSDM3Env(gym.Env):\n",
+    "    def __init__(self, df, initial_balance=2000.0, risk_per_trade=0.02, max_lot_size=20.0):\n",
+    "        super(XAUUSDM3Env, self).__init__()\n",
+    "        self.df = df\n",
+    "        self.prices = df['close'].values\n",
+    "        self.spreads = df['spread'].values if 'spread' in df.columns else np.full(len(df), 20.0)\n",
+    "        \n",
+    "        # Features for observation (dropping strings/dates)\n",
+    "        self.features = df.select_dtypes(include=[np.number]).fillna(0).values\n",
+    "        \n",
+    "        self.initial_balance = initial_balance\n",
+    "        self.risk_per_trade = risk_per_trade\n",
+    "        self.max_lot_size = max_lot_size\n",
+    "        \n",
+    "        # Actions: 0=Buy, 1=Sell, 2=Hold, 3=Do Nothing\n",
+    "        self.action_space = spaces.Discrete(4)\n",
+    "        \n",
+    "        self.observation_space = spaces.Box(\n",
+    "            low=-np.inf, high=np.inf, shape=(self.features.shape[1],), dtype=np.float32\n",
+    "        )\n",
+    "        \n",
+    "        self.reset()\n",
+    "\n",
+    "    def reset(self):\n",
+    "        self.current_step = 0\n",
+    "        self.balance = self.initial_balance\n",
+    "        self.equity = self.initial_balance\n",
+    "        self.current_position = 0 # 1=Long, -1=Short, 0=Flat\n",
+    "        self.entry_price = 0.0\n",
+    "        self.stop_loss = 0.0\n",
+    "        self.take_profit = 0.0\n",
+    "        self.lot_size = 0.0\n",
+    "        self.history = []\n",
+    "        return self.features[self.current_step]\n",
+    "\n",
+    "    def _calculate_lot_size(self, sl_distance):\n",
+    "        # 2% Risk\n",
+    "        risk_amount = self.balance * self.risk_per_trade\n",
+    "        # XAUUSDc lot size standard: $100 per $1 move for 1 lot usually. \n",
+    "        sl_dollar_risk_per_lot = sl_distance * 100.0 \n",
+    "        if sl_dollar_risk_per_lot <= 0:\n",
+    "            return 0.01\n",
+    "            \n",
+    "        lots = risk_amount / sl_dollar_risk_per_lot\n",
+    "        return max(0.01, round(lots, 2))\n",
+    "\n",
+    "    def step(self, action):\n",
+    "        done = False\n",
+    "        reward = 0.0\n",
+    "        \n",
+    "        current_price = self.prices[self.current_step]\n",
+    "        spread = self.spreads[self.current_step] / 100.0 # Standard conversion for points\n",
+    "        \n",
+    "        # Calculate equity running\n",
+    "        if self.current_position == 1:\n",
+    "            self.equity = self.balance + (current_price - self.entry_price) * 100.0 * self.lot_size\n",
+    "        elif self.current_position == -1:\n",
+    "            self.equity = self.balance + (self.entry_price - current_price) * 100.0 * self.lot_size\n",
+    "\n",
+    "        # Execute at close-price\n",
+    "        if action == 0 and self.current_position == 0:\n",
+    "            # BUY\n",
+    "            sl_dist = max(current_price * 0.005, spread * 10.0)\n",
+    "            self.stop_loss = current_price - sl_dist\n",
+    "            self.take_profit = current_price + (sl_dist * 2.0) # > 1R\n",
+    "            self.entry_price = current_price + spread\n",
+    "            self.lot_size = self._calculate_lot_size(sl_dist)\n",
+    "            self.current_position = 1\n",
+    "            \n",
+    "        elif action == 1 and self.current_position == 0:\n",
+    "            # SELL\n",
+    "            sl_dist = max(current_price * 0.005, spread * 10.0)\n",
+    "            self.stop_loss = current_price + sl_dist + spread\n",
+    "            self.take_profit = current_price - (sl_dist * 2.0) \n",
+    "            self.entry_price = current_price\n",
+    "            self.lot_size = self._calculate_lot_size(sl_dist)\n",
+    "            self.current_position = -1\n",
+    "\n",
+    "        # Check SL / TP for exit\n",
+    "        if self.current_position == 1:\n",
+    "            if current_price <= self.stop_loss or current_price >= self.take_profit:\n",
+    "                profit = (current_price - self.entry_price) * 100.0 * self.lot_size\n",
+    "                self.balance += profit\n",
+    "                self.equity = self.balance\n",
+    "                self.current_position = 0\n",
+    "                reward = profit\n",
+    "                self.history.append({'type': 'long', 'profit': profit, 'lot': self.lot_size})\n",
+    "                \n",
+    "        elif self.current_position == -1:\n",
+    "            if current_price >= self.stop_loss or current_price <= self.take_profit:\n",
+    "                profit = (self.entry_price - current_price) * 100.0 * self.lot_size\n",
+    "                self.balance += profit\n",
+    "                self.equity = self.balance\n",
+    "                self.current_position = 0\n",
+    "                reward = profit\n",
+    "                self.history.append({'type': 'short', 'profit': profit, 'lot': self.lot_size})\n",
+    "\n",
+    "        self.current_step += 1\n",
+    "        if self.current_step >= len(self.prices) - 1 or self.equity <= 0:\n",
+    "            done = True\n",
+    "            \n",
+    "        next_state = self.features[self.current_step] if not done else np.zeros(self.features.shape[1])\n",
+    "        return next_state, reward, done, {}\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Train Model\n",
+    "if 'df' in locals():\n",
+    "    train_size = int(len(df) * 0.7)\n",
+    "    train_df = df.iloc[:train_size].copy()\n",
+    "    test_df = df.iloc[train_size:].copy()\n",
+    "    \n",
+    "    env = XAUUSDM3Env(train_df)\n",
+    "    model = PPO(\"MlpPolicy\", env, verbose=1, device=device)\n",
+    "    \n",
+    "    print(\"Starting RL Training...\")\n",
+    "    model.learn(total_timesteps=50000)\n",
+    "    print(\"Training Finished.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plotting white-themed performance metrics\n",
+    "if 'env' in locals() and len(env.history) > 0:\n",
+    "    profits = [x['profit'] for x in env.history]\n",
+    "    cumulative = np.cumsum(profits)\n",
+    "    \n",
+    "    fig = go.Figure()\n",
+    "    fig.add_trace(go.Scatter(y=cumulative, mode='lines', name='Cumulative Profit', line=dict(color='blue')))\n",
+    "    fig.update_layout(\n",
+    "        title=\"RL Agent Performance (Cumulative Profit)\",\n",
+    "        xaxis_title=\"Trades\",\n",
+    "        yaxis_title=\"USD Returns\",\n",
+    "        template=\"plotly_white\"\n",
+    "    )\n",
+    "    fig.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Export to ONNX for MT5 Expert Advisor\n",
+    "if 'model' in locals():\n",
+    "    class OnnxablePolicy(nn.Module):\n",
+    "        def __init__(self, policy):\n",
+    "            super().__init__()\n",
+    "            self.policy = policy\n",
+    "            \n",
+    "        def forward(self, observation):\n",
+    "            return self.policy(observation, deterministic=True)[0]\n",
+    "            \n",
+    "    onnx_policy = OnnxablePolicy(model.policy)\n",
+    "    dummy_input = torch.randn(1, env.observation_space.shape[0]).to(device)\n",
+    "    onnx_policy.to(device)\n",
+    "    \n",
+    "    onnx_path = \"RL_Agent_XAUUSD.onnx\"\n",
+    "    torch.onnx.export(\n",
+    "        onnx_policy,\n",
+    "        dummy_input,\n",
+    "        onnx_path,\n",
+    "        opset_version=11,\n",
+    "        input_names=[\"input\"],\n",
+    "        output_names=[\"output\"]\n",
+    "    )\n",
+    "    print(f\"ONNX Model successfully exported to {onnx_path}. Next, download it and deploy to your MT5 EA.\")\n",
+    "    try: files.download(onnx_path)\n",
+    "    except: pass\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

XAUUSD_M15_Data.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12e0adfe6dca2e13a67039ec8e8ff5317fef64494b5c7692d02925dcfa20ec49
+size 34739911

data_fetcher.py

@@ -0,0 +1,78 @@
+import os
+import pytz
+import numpy as np
+import pandas as pd
+import ta
+import MetaTrader5 as mt5
+from datetime import datetime
+
+def fetch_data():
+    if not mt5.initialize():
+        print(f"MT5 initialize() failed, error code: {mt5.last_error()}")
+        return None
+
+    symbol = "XAUUSDc"
+    
+    # Direct M3 fetch (Terminal was likely stalled before)
+    timeframe = mt5.TIMEFRAME_M3
+    
+    # Use 2026 dates (updated methodologies)
+    # Fetching from March 1st to current (approx 19th)
+    utc_from = datetime(2026, 3, 1)
+    utc_to = datetime(2026, 3, 19)
+    
+    print(f"Fetching data for {symbol} on M3 timeframe...")
+    rates = mt5.copy_rates_range(symbol, timeframe, utc_from, utc_to)
+    
+    if rates is None or len(rates) == 0:
+        print(f"Failed to fetch rates for {symbol}, error code: {mt5.last_error()}")
+        mt5.shutdown()
+        return None
+        
+    df = pd.DataFrame(rates)
+    df['time'] = pd.to_datetime(df['time'], unit='s')
+    df.set_index('time', inplace=True)
+    
+    # Ensure standard OHLCV names
+    df = df[['open', 'high', 'low', 'close', 'tick_volume', 'spread', 'real_volume']]
+    
+    print(f"Fetched and resampled {len(df)} rows. Calculating 100+ vectorized indicators...")
+    
+    # Generate 90+ indicators automatically using the 'ta' library
+    df = ta.add_all_ta_features(df, open="open", high="high", low="low", close="close", volume="tick_volume", fillna=True)
+    
+    # Add EXTRA indicators to exceed 100 count (approx 110-120 total)
+    # 1. Rolling statistics (10-step windows)
+    for col in ['open', 'high', 'low', 'close']:
+        df[f'{col}_roll_mean_10'] = df[col].rolling(10).mean()
+        df[f'{col}_roll_std_10'] = df[col].rolling(10).std()
+        
+    # 2. Lags (1-5)
+    for i in range(1, 6):
+        df[f'close_lag_{i}'] = df['close'].shift(i)
+        
+    # 3. RSI Variants
+    df['rsi_fast'] = ta.momentum.rsi(df['close'], window=7)
+    df['rsi_slow'] = ta.momentum.rsi(df['close'], window=21)
+    
+    # 4. Volatility Helpers
+    df['atr_custom'] = ta.volatility.average_true_range(df['high'], df['low'], df['close'], window=14)
+    
+    # Drop rows with NaN from new indicators
+    df.dropna(inplace=True)
+    
+    # Drop columns that have all NaNs
+    df.dropna(axis=1, how='all', inplace=True)
+    
+    # Drop rows with any NaN values resulting from indicator lookbacks
+    df.dropna(inplace=True)
+    
+    output_filename = "XAUUSD_M3_Data.csv"
+    print(f"Saving {len(df)} clean rows to {output_filename} (Columns: {len(df.columns)})...")
+    df.to_csv(output_filename)
+    
+    print("Data extraction and indicator generation complete!")
+    mt5.shutdown()
+
+if __name__ == "__main__":
+    fetch_data()

fetch_mt5_data.py

@@ -0,0 +1,80 @@
+import MetaTrader5 as mt5
+import pandas as pd
+from datetime import datetime
+import json
+
+# ==================== MT5 INITIALIZATION ====================
+if not mt5.initialize():
+    print("❌ MT5 initialize failed. Check terminal is open + logged in.")
+    quit()
+
+symbol = "XAUUSDc"
+timeframe = mt5.TIMEFRAME_M3
+
+# ==================== DATE RANGE (auto-safe) ====================
+date_from = datetime(2025, 1, 1)
+date_to = datetime.now()          # ← changed from fixed 2026-03-20
+
+print(f"🔄 Fetching {symbol} M3 from {date_from.date()} to {date_to.date()} (UTC)...")
+
+rates = mt5.copy_rates_range(symbol, timeframe, date_from, date_to)
+
+# ==================== CRITICAL SAFETY CHECKS ====================
+if rates is None:
+    print("❌ MT5 returned None. Possible reasons:")
+    print("   • Symbol does NOT exist on your broker")
+    print("   • History not downloaded (open chart + scroll back 1 year)")
+    print("   • Date range has no bars")
+    mt5.shutdown()
+    quit()
+
+if len(rates) == 0:
+    print("❌ No bars returned (0 rows).")
+    print("   Try changing symbol to 'XAUUSD' (without 'c') or download history in MT5.")
+    mt5.shutdown()
+    quit()
+
+print(f"✅ Fetched {len(rates)} bars successfully!")
+
+# ==================== CREATE DATAFRAME ====================
+df = pd.DataFrame(rates)
+
+# Debug columns (this will now never crash)
+print(f"Columns returned by MT5: {list(df.columns)}")
+
+# Convert time (MT5 always returns unix seconds in 'time' column)
+df['time'] = pd.to_datetime(df['time'], unit='s')
+
+# Keep only needed columns + spread
+df = df[['time', 'open', 'high', 'low', 'close', 'tick_volume', 'spread', 'real_volume']]
+
+# ==================== SAVE CSV ====================
+csv_path = "xauusd_3m_2025_2026.csv"
+df.to_csv(csv_path, index=False)
+print(f"💾 Saved {len(df)} bars to → {csv_path}")
+
+# ==================== SAVE SYMBOL PARAMS (for Colab) ====================
+info = mt5.symbol_info(symbol)
+if info is None:
+    print("⚠️ symbol_info failed. Using fallback values.")
+    params = {"tick_size": 0.01, "tick_value": 1.0, "volume_min": 0.01, "volume_max": 200.0,
+              "volume_step": 0.01, "point": 0.01, "trade_calc_mode": 0}
+else:
+    params = {
+        "tick_size": info.trade_tick_size,
+        "tick_value": info.trade_tick_value,
+        "volume_min": info.volume_min,
+        "volume_max": info.volume_max,
+        "volume_step": info.volume_step,
+        "point": info.point,
+        "trade_calc_mode": info.trade_calc_mode
+    }
+
+with open("symbol_params.json", "w") as f:
+    json.dump(params, f, indent=2)
+print("💾 Saved symbol_params.json")
+
+mt5.shutdown()
+print("\n🎉 DONE! Now upload BOTH files to Google Colab:")
+print("   1. xauusd_3m_2025_2026.csv")
+print("   2. symbol_params.json")

generate_notebook.py

@@ -0,0 +1,264 @@
+import json
+
+notebook = {
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Phase 2: RL Trading Agent for MT5 (XAUUSDc)\n",
+    "This notebook trains a reinforcement learning model on the extracted MT5 data, simulating live-market constraints and exporting an ONNX model for the Expert Advisor."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": None,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install -q stable-baselines3[extra] pandas_ta xgboost onnx onnxruntime plotly gym"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": None,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import onnx\n",
+    "import onnxruntime as ort\n",
+    "import plotly.graph_objects as go\n",
+    "import gym\n",
+    "from gym import spaces\n",
+    "from stable_baselines3 import PPO\n",
+    "from google.colab import files\n",
+    "\n",
+    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+    "print(f\"Using device: {device}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": None,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load Dataset (Upload XAUUSD_M3_Data.csv to Colab first)\n",
+    "if not os.path.exists('XAUUSD_M3_Data.csv'):\n",
+    "    print(\"Please upload XAUUSD_M3_Data.csv to the Colab environment.\")\n",
+    "else:\n",
+    "    df = pd.read_csv('XAUUSD_M3_Data.csv', index_col='time', parse_dates=True)\n",
+    "    print(f\"Loaded {len(df)} rows.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": None,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Vectorized Custom Gym Environment for XAUUSDc\n",
+    "class XAUUSDM3Env(gym.Env):\n",
+    "    def __init__(self, df, initial_balance=2000.0, risk_per_trade=0.02, max_lot_size=20.0):\n",
+    "        super(XAUUSDM3Env, self).__init__()\n",
+    "        self.df = df\n",
+    "        self.prices = df['close'].values\n",
+    "        self.spreads = df['spread'].values if 'spread' in df.columns else np.full(len(df), 20.0)\n",
+    "        \n",
+    "        # Features for observation (dropping strings/dates)\n",
+    "        self.features = df.select_dtypes(include=[np.number]).fillna(0).values\n",
+    "        \n",
+    "        self.initial_balance = initial_balance\n",
+    "        self.risk_per_trade = risk_per_trade\n",
+    "        self.max_lot_size = max_lot_size\n",
+    "        \n",
+    "        # Actions: 0=Buy, 1=Sell, 2=Hold, 3=Do Nothing\n",
+    "        self.action_space = spaces.Discrete(4)\n",
+    "        \n",
+    "        self.observation_space = spaces.Box(\n",
+    "            low=-np.inf, high=np.inf, shape=(self.features.shape[1],), dtype=np.float32\n",
+    "        )\n",
+    "        \n",
+    "        self.reset()\n",
+    "\n",
+    "    def reset(self):\n",
+    "        self.current_step = 0\n",
+    "        self.balance = self.initial_balance\n",
+    "        self.equity = self.initial_balance\n",
+    "        self.current_position = 0 # 1=Long, -1=Short, 0=Flat\n",
+    "        self.entry_price = 0.0\n",
+    "        self.stop_loss = 0.0\n",
+    "        self.take_profit = 0.0\n",
+    "        self.lot_size = 0.0\n",
+    "        self.history = []\n",
+    "        return self.features[self.current_step]\n",
+    "\n",
+    "    def _calculate_lot_size(self, sl_distance):\n",
+    "        # 2% Risk\n",
+    "        risk_amount = self.balance * self.risk_per_trade\n",
+    "        # XAUUSDc lot size standard: $100 per $1 move for 1 lot usually. \n",
+    "        sl_dollar_risk_per_lot = sl_distance * 100.0 \n",
+    "        if sl_dollar_risk_per_lot <= 0:\n",
+    "            return 0.01\n",
+    "            \n",
+    "        lots = risk_amount / sl_dollar_risk_per_lot\n",
+    "        return max(0.01, round(lots, 2))\n",
+    "\n",
+    "    def step(self, action):\n",
+    "        done = False\n",
+    "        reward = 0.0\n",
+    "        \n",
+    "        current_price = self.prices[self.current_step]\n",
+    "        spread = self.spreads[self.current_step] / 100.0 # Standard conversion for points\n",
+    "        \n",
+    "        # Calculate equity running\n",
+    "        if self.current_position == 1:\n",
+    "            self.equity = self.balance + (current_price - self.entry_price) * 100.0 * self.lot_size\n",
+    "        elif self.current_position == -1:\n",
+    "            self.equity = self.balance + (self.entry_price - current_price) * 100.0 * self.lot_size\n",
+    "\n",
+    "        # Execute at close-price\n",
+    "        if action == 0 and self.current_position == 0:\n",
+    "            # BUY\n",
+    "            sl_dist = max(current_price * 0.005, spread * 10.0)\n",
+    "            self.stop_loss = current_price - sl_dist\n",
+    "            self.take_profit = current_price + (sl_dist * 2.0) # > 1R\n",
+    "            self.entry_price = current_price + spread\n",
+    "            self.lot_size = self._calculate_lot_size(sl_dist)\n",
+    "            self.current_position = 1\n",
+    "            \n",
+    "        elif action == 1 and self.current_position == 0:\n",
+    "            # SELL\n",
+    "            sl_dist = max(current_price * 0.005, spread * 10.0)\n",
+    "            self.stop_loss = current_price + sl_dist + spread\n",
+    "            self.take_profit = current_price - (sl_dist * 2.0) \n",
+    "            self.entry_price = current_price\n",
+    "            self.lot_size = self._calculate_lot_size(sl_dist)\n",
+    "            self.current_position = -1\n",
+    "\n",
+    "        # Check SL / TP for exit\n",
+    "        if self.current_position == 1:\n",
+    "            if current_price <= self.stop_loss or current_price >= self.take_profit:\n",
+    "                profit = (current_price - self.entry_price) * 100.0 * self.lot_size\n",
+    "                self.balance += profit\n",
+    "                self.equity = self.balance\n",
+    "                self.current_position = 0\n",
+    "                reward = profit\n",
+    "                self.history.append({'type': 'long', 'profit': profit, 'lot': self.lot_size})\n",
+    "                \n",
+    "        elif self.current_position == -1:\n",
+    "            if current_price >= self.stop_loss or current_price <= self.take_profit:\n",
+    "                profit = (self.entry_price - current_price) * 100.0 * self.lot_size\n",
+    "                self.balance += profit\n",
+    "                self.equity = self.balance\n",
+    "                self.current_position = 0\n",
+    "                reward = profit\n",
+    "                self.history.append({'type': 'short', 'profit': profit, 'lot': self.lot_size})\n",
+    "\n",
+    "        self.current_step += 1\n",
+    "        if self.current_step >= len(self.prices) - 1 or self.equity <= 0:\n",
+    "            done = True\n",
+    "            \n",
+    "        next_state = self.features[self.current_step] if not done else np.zeros(self.features.shape[1])\n",
+    "        return next_state, reward, done, {}\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": None,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Train Model\n",
+    "if 'df' in locals():\n",
+    "    train_size = int(len(df) * 0.7)\n",
+    "    train_df = df.iloc[:train_size].copy()\n",
+    "    test_df = df.iloc[train_size:].copy()\n",
+    "    \n",
+    "    env = XAUUSDM3Env(train_df)\n",
+    "    model = PPO(\"MlpPolicy\", env, verbose=1, device=device)\n",
+    "    \n",
+    "    print(\"Starting RL Training...\")\n",
+    "    model.learn(total_timesteps=50000)\n",
+    "    print(\"Training Finished.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": None,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plotting white-themed performance metrics\n",
+    "if 'env' in locals() and len(env.history) > 0:\n",
+    "    profits = [x['profit'] for x in env.history]\n",
+    "    cumulative = np.cumsum(profits)\n",
+    "    \n",
+    "    fig = go.Figure()\n",
+    "    fig.add_trace(go.Scatter(y=cumulative, mode='lines', name='Cumulative Profit', line=dict(color='blue')))\n",
+    "    fig.update_layout(\n",
+    "        title=\"RL Agent Performance (Cumulative Profit)\",\n",
+    "        xaxis_title=\"Trades\",\n",
+    "        yaxis_title=\"USD Returns\",\n",
+    "        template=\"plotly_white\"\n",
+    "    )\n",
+    "    fig.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": None,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Export to ONNX for MT5 Expert Advisor\n",
+    "if 'model' in locals():\n",
+    "    class OnnxablePolicy(nn.Module):\n",
+    "        def __init__(self, policy):\n",
+    "            super().__init__()\n",
+    "            self.policy = policy\n",
+    "            \n",
+    "        def forward(self, observation):\n",
+    "            return self.policy(observation, deterministic=True)[0]\n",
+    "            \n",
+    "    onnx_policy = OnnxablePolicy(model.policy)\n",
+    "    dummy_input = torch.randn(1, env.observation_space.shape[0]).to(device)\n",
+    "    onnx_policy.to(device)\n",
+    "    \n",
+    "    onnx_path = \"RL_Agent_XAUUSD.onnx\"\n",
+    "    torch.onnx.export(\n",
+    "        onnx_policy,\n",
+    "        dummy_input,\n",
+    "        onnx_path,\n",
+    "        opset_version=11,\n",
+    "        input_names=[\"input\"],\n",
+    "        output_names=[\"output\"]\n",
+    "    )\n",
+    "    print(f\"ONNX Model successfully exported to {onnx_path}. Next, download it and deploy to your MT5 EA.\")\n",
+    "    try: files.download(onnx_path)\n",
+    "    except: pass\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {"provenance": []},
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {"name": "python"}
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
+
+with open("RL_XAUUSD_Colab_System.ipynb", "w") as f:
+    json.dump(notebook, f, indent=1)
+
+print("Generated RL_XAUUSD_Colab_System.ipynb securely!")