tradin_pal.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1b6b5377",
   "metadata": {},
   "source": [
    "# Advanced Forex Trading System\n",
    "\n",
    "## Features\n",
    "- Multi-timeframe (H1, H4, D)\n",
    "- Hyperparameter optimization\n",
    "- Cross-validation\n",
    "- Multiple currency pairs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffa3e588",
   "metadata": {},
   "source": [
    "## Install Dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88c79afc",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install oandapyV20 pandas numpy scikit-learn ta joblib optuna"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce8d7f7d",
   "metadata": {},
   "source": [
    "## Import Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e17dbe53",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from oandapyV20 import API\n",
    "import oandapyV20.endpoints.instruments as instruments\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import TimeSeriesSplit\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n",
    "import optuna\n",
    "from ta.trend import EMAIndicator, MACD\n",
    "from ta.volatility import BollingerBands\n",
    "from ta.momentum import RSIIndicator\n",
    "import datetime\n",
    "import joblib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e50cfbe",
   "metadata": {},
   "source": [
    "## Model Class Definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34534d00",
   "metadata": {},
   "outputs": [],
   "source": [
    "class AdvancedForexModel:\n",
    "    def __init__(self, api_key):\n",
    "        self.pairs = ['EUR_USD', 'GBP_USD', 'AUD_USD', 'USD_JPY']\n",
    "        self.timeframes = ['H1', 'H4', 'D']\n",
    "        self.api = API(access_token=api_key)\n",
    "        self.models = {}\n",
    "        self.best_params = {}\n",
    "        self.performance_metrics = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95348293",
   "metadata": {},
   "source": [
    "## Data Collection Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bfeb4783",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fetch_multi_timeframe_data(self, pair):\n",
    "    data = {}\n",
    "    for tf in self.timeframes:\n",
    "        params = {\"count\": 5000, \"granularity\": tf}\n",
    "        r = instruments.InstrumentsCandles(instrument=pair, params=params)\n",
    "        self.api.request(r)\n",
    "        \n",
    "        df = pd.DataFrame([\n",
    "            {\n",
    "                'time': candle['time'],\n",
    "                'open': float(candle['mid']['o']),\n",
    "                'high': float(candle['mid']['h']),\n",
    "                'low': float(candle['mid']['l']),\n",
    "                'close': float(candle['mid']['c']),\n",
    "                'volume': float(candle['volume'])\n",
    "            } for candle in r.response['candles']\n",
    "        ])\n",
    "        data[tf] = df\n",
    "    return data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "718f9098",
   "metadata": {},
   "source": [
    "## Technical Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "269881e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_technical_indicators(self, df):\n",
    "    # Trend indicators\n",
    "    df['ema_20'] = EMAIndicator(close=df['close'], window=20).ema_indicator()\n",
    "    df['ema_50'] = EMAIndicator(close=df['close'], window=50).ema_indicator()\n",
    "    macd = MACD(close=df['close'])\n",
    "    df['macd'] = macd.macd()\n",
    "    df['macd_signal'] = macd.macd_signal()\n",
    "    \n",
    "    # Volatility\n",
    "    bb = BollingerBands(close=df['close'])\n",
    "    df['bb_upper'] = bb.bollinger_hband()\n",
    "    df['bb_lower'] = bb.bollinger_lband()\n",
    "    \n",
    "    # Momentum\n",
    "    df['rsi'] = RSIIndicator(close=df['close']).rsi()\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3446fd2f",
   "metadata": {},
   "source": [
    "## Model Optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93c8754b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimize_hyperparameters(self, X, y):\n",
    "    def objective(trial):\n",
    "        params = {\n",
    "            'n_estimators': trial.suggest_int('n_estimators', 100, 1000),\n",
    "            'max_depth': trial.suggest_int('max_depth', 10, 100),\n",
    "            'min_samples_split': trial.suggest_int('min_samples_split', 2, 20),\n",
    "            'min_samples_leaf': trial.suggest_int('min_samples_leaf', 1, 10)\n",
    "        }\n",
    "        \n",
    "        tscv = TimeSeriesSplit(n_splits=5)\n",
    "        scores = []\n",
    "        \n",
    "        for train_idx, val_idx in tscv.split(X):\n",
    "            X_train, X_val = X.iloc[train_idx], X.iloc[val_idx]\n",
    "            y_train, y_val = y.iloc[train_idx], y.iloc[val_idx]\n",
    "            \n",
    "            model = RandomForestClassifier(**params, random_state=42)\n",
    "            model.fit(X_train, y_train)\n",
    "            score = model.score(X_val, y_val)\n",
    "            scores.append(score)\n",
    "            \n",
    "        return np.mean(scores)\n",
    "    \n",
    "    study = optuna.create_study(direction='maximize')\n",
    "    study.optimize(objective, n_trials=50)\n",
    "    return study.best_params"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f160362e",
   "metadata": {},
   "source": [
    "## Training Pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f287791",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_models(self):\n",
    "    for pair in self.pairs:\n",
    "        print(f\"Training models for {pair}\")\n",
    "        data = self.fetch_multi_timeframe_data(pair)\n",
    "        \n",
    "        for timeframe in self.timeframes:\n",
    "            df = self.add_technical_indicators(data[timeframe])\n",
    "            X, y = self.prepare_training_data(df)\n",
    "            \n",
    "            X = X.dropna()\n",
    "            y = y[X.index]\n",
    "            \n",
    "            best_params = self.optimize_hyperparameters(X, y)\n",
    "            self.best_params[f\"{pair}_{timeframe}\"] = best_params\n",
    "            \n",
    "            model = RandomForestClassifier(**best_params, random_state=42)\n",
    "            model.fit(X, y)\n",
    "            \n",
    "            self.models[f\"{pair}_{timeframe}\"] = model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f29ce766",
   "metadata": {},
   "source": [
    "## Signal Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "759ce4db",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_signals(self):\n",
    "    signals = []\n",
    "    for pair in self.pairs:\n",
    "        data = self.fetch_multi_timeframe_data(pair)\n",
    "        pair_signals = {}\n",
    "        \n",
    "        for timeframe in self.timeframes:\n",
    "            df = self.add_technical_indicators(data[timeframe])\n",
    "            X = df[self.feature_columns].iloc[-1:]\n",
    "            \n",
    "            model = self.models[f\"{pair}_{timeframe}\"]\n",
    "            prediction = model.predict(X)\n",
    "            probability = model.predict_proba(X)\n",
    "            \n",
    "            pair_signals[timeframe] = {\n",
    "                'prediction': prediction[0],\n",
    "                'confidence': np.max(probability[0])\n",
    "            }\n",
    "        \n",
    "        consensus = self.calculate_consensus(pair_signals)\n",
    "        if consensus['signal'] != 0:\n",
    "            signals.append(self.format_signal(pair, consensus, data))\n",
    "    \n",
    "    return signals"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0477e7d",
   "metadata": {},
   "source": [
    "## Model Usage Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dba16c8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize and train\n",
    "api_key = 'YOUR_OANDA_API_KEY'\n",
    "trader = AdvancedForexModel(api_key)\n",
    "trader.train_models()\n",
    "\n",
    "# Generate signals\n",
    "signals = trader.generate_signals()\n",
    "print(\"Trading Signals:\")\n",
    "for signal in signals:\n",
    "    print(f\"\\n{signal}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}