the_information_nexus/projects/forex_algo_trading.md

Mean Reversion Trading Strategy for EUR/USD with Machine Learning

Overview

This guide is dedicated to developing a mean reversion trading strategy for the EUR/USD currency pair. It harnesses the power of machine learning (ML) via scikit-learn for strategy development, Backtrader for backtesting, and ultimately, deploying the optimized strategy for live trading on Oanda.

Step 1: Data Preparation

Fetch Historical EUR/USD Data

• Objective: Use oandapyV20 to download 5 years of EUR/USD daily data from Oanda.
• Rationale: A 5-year period provides a balanced dataset to capture various market phases, essential for training robust mean reversion models.

Clean and Preprocess Data

• Tasks: Eliminate duplicates and handle missing data. Standardize prices to ensure consistency across the dataset.
• Normalization: Apply Min-Max scaling to align features on a similar scale, enhancing model training efficiency.

Step 2: Exploratory Data Analysis (EDA) and Feature Engineering

Perform EDA

• Visualization: Plot price movements with matplotlib to identify mean reversion patterns. Analyze price volatility and its correlation with mean reversion points.

Develop Technical Indicators

• Indicators for Mean Reversion: Calculate Bollinger Bands and RSI. These indicators help identify overbought or oversold conditions signaling potential mean reversions.

Feature Engineering

• Feature Creation: Derive features like the distance from moving averages, Bollinger Band width, and RSI levels to capture market states indicative of mean reversion.

Step 3: Machine Learning Model Development with Scikit-learn

Choose an ML Model

• Model Selection: Start with Logistic Regression to classify potential mean reversion opportunities. Consider Random Forest for a more nuanced understanding of feature relationships.

Train and Validate the Model

• Cross-Validation: Implement cross-validation to assess model performance, minimizing the risk of overfitting.
• Metrics: Evaluate models based on accuracy, precision, recall, and the F1 score to ensure a balanced assessment of the model's predictive capabilities.

Step 4: Backtesting Strategy with Backtrader

Integrate ML Model into Backtrader Strategy

• Strategy Implementation: Embed your scikit-learn model within a custom Backtrader strategy. Use model predictions to drive trade entries and exits based on identified mean reversion signals.

Execute Backtesting

• Configuration: Set up Backtrader with historical EUR/USD data, including transaction costs and initial capital.
• Analysis: Utilize Backtrader's analyzers to evaluate the strategy's performance, focusing on net profit, drawdown, and Sharpe ratio.

Step 5: Live Trading Preparation

Paper Trading with Oanda Demo

• Objective: Validate the strategy under current market conditions using Oanda's demo account.
• Adjustments: Fine-tune strategy parameters and risk management settings based on paper trading outcomes.

Transition to Live Trading

• Live Account Switch: Transition the strategy to a live Oanda account for real trading.
• Capital Management: Start with conservative capital allocation, gradually scaling based on live performance and risk appetite.

Continuous Monitoring and Optimization

• Live Performance Tracking: Closely monitor trading activity and performance metrics.
• Strategy Iteration: Regularly review and adjust the trading model and strategy parameters in response to evolving market conditions and performance insights.

Conclusion

This guide provides a concise roadmap for creating a mean reversion trading strategy for the EUR/USD pair, leveraging machine learning for signal generation, Backtrader for rigorous backtesting, and Oanda for deployment. It emphasizes a systematic approach from data analysis to live trading, ensuring a well-founded strategy backed by empirical evidence and optimized through practical experience.

---

Swing Trading Project with EUR/USD Using Oanda and scikit-learn

Step 1: Environment Setup

Install Python

Ensure Python 3.8+ is installed.

Create a Virtual Environment

Navigate to your project directory and run:

python -m venv venv
source venv/bin/activate  # Unix/macOS
venv\Scripts\activate     # Windows
deactivate

Install Essential Libraries

Create requirements.txt with the following content:

pandas
numpy
matplotlib
seaborn
scikit-learn
jupyterlab
oandapyV20
requests

Install with pip install -r requirements.txt.

Step 2: Project Structure

Organize your directory as follows:

swing_trading_project/
├── data/
├── notebooks/
├── src/
│   ├── __init__.py
│   ├── data_fetcher.py
│   ├── feature_engineering.py
│   ├── model.py
│   └── backtester.py
├── tests/
├── requirements.txt
└── README.md

Step 3: Fetch Historical Data

• Sign up for an Oanda practice account and get an API key.
• Use oandapyV20 in data_fetcher.py to request historical EUR/USD data. Consider H4 or D granularity.
• Save the data to data/ as CSV.

import os
import pandas as pd
from oandapyV20 import API  # Import the Oanda API client
import oandapyV20.endpoints.instruments as instruments

# Set your Oanda API credentials and configuration for data fetching
ACCOUNT_ID = 'your_account_id_here'
ACCESS_TOKEN = 'your_access_token_here'
# List of currency pairs to fetch. Add or remove pairs as needed.
CURRENCY_PAIRS = ['EUR_USD', 'USD_JPY', 'GBP_USD', 'AUD_USD', 'USD_CAD']
TIME_FRAME = 'H4'  # 4-hour candles, change as per your analysis needs
DATA_DIRECTORY = 'data'  # Directory where fetched data will be saved

# Ensure the data directory exists, create it if it doesn't
if not os.path.exists(DATA_DIRECTORY):
    os.makedirs(DATA_DIRECTORY)

def fetch_and_save_forex_data(account_id, access_token, currency_pairs, time_frame, data_dir):
    """Fetch historical forex data for specified currency pairs and save it to CSV files."""
    # Initialize the Oanda API client with your access token
    api_client = API(access_token=access_token)
    
    for pair in currency_pairs:
        # Define the parameters for the data request: time frame and number of data points
        request_params = {"granularity": time_frame, "count": 5000}
        
        # Prepare the data request for fetching candle data for the current currency pair
        data_request = instruments.InstrumentsCandles(instrument=pair, params=request_params)
        # Fetch the data
        response = api_client.request(data_request)
        # Extract the candle data from the response
        candle_data = response.get('candles', [])
        
        # If data was fetched, proceed to save it
        if candle_data:
            # Convert the candle data into a pandas DataFrame
            forex_data_df = pd.DataFrame([{
                'Time': candle['time'],
                'Open': float(candle['mid']['o']),
                'High': float(candle['mid']['h']),
                'Low': float(candle['mid']['l']),
                'Close': float(candle['mid']['c']),
                'Volume': candle['volume']
            } for candle in candle_data])
            
            # Construct the filename for the CSV file
            csv_filename = f"{pair.lower()}_data.csv"
            # Save the DataFrame to a CSV file in the specified data directory
            forex_data_df.to_csv(os.path.join(data_dir, csv_filename), index=False)
            print(f"Data for {pair} saved to {csv_filename}")

def main():
    """Orchestrates the data fetching and saving process."""
    print("Starting data fetching process...")
    # Call the function to fetch and save data for the configured currency pairs
    fetch_and_save_forex_data(ACCOUNT_ID, ACCESS_TOKEN, CURRENCY_PAIRS, TIME_FRAME, DATA_DIRECTORY)
    print("Data fetching process completed.")

if __name__ == '__main__':
    # Execute the script
    main()

Step 4: Exploratory Data Analysis

• Create a new Jupyter notebook in notebooks/.
• Load the CSV with pandas and perform initial exploration. Plot closing prices and moving averages.

Step 5: Basic Feature Engineering

• In the notebook, add technical indicators as features (e.g., SMA 50, SMA 200, RSI) using pandas.
• Investigate the relationship between these features and price movements.

Step 6: Initial Model Training

• In model.py, fit a simple scikit-learn model (e.g., LinearRegression, LogisticRegression) to predict price movements.
• Split data into training and testing sets to evaluate the model's performance.

Step 7: Documentation

• Document your project's setup, objectives, and findings in README.md.

Next Steps

• Refine features, try different models, and develop a backtesting framework as you progress.

---

From Backtesting to Live Trading with Backtrader and Oanda

Setup and Installation

• Install Required Packages

  pip install backtrader oandapyV20
  

• Oanda API Credentials

  • Obtain API credentials from your Oanda demo account.

Backtesting

1. Data Preparation

• Fetch historical data using Oanda's API for your target currency pairs.

2. Strategy Development

• Code your trading strategy within a subclass of bt.Strategy.
• Define indicators, entry and exit logic.

3. Backtesting Execution

• Initialize a bt.Cerebro() engine, adding your strategy and data.
• Set initial capital and other parameters.
• Run backtest and analyze results using Backtrader's built-in analyzers.

Transition to Paper Trading

1. Configure Live Data Feed

• Setup a live data feed from Oanda using the oandapyV20 package.

2. Integrate Oanda Demo as Broker

• Configure Backtrader to use Oanda as the broker with your demo account credentials.
• This simulates order execution in the demo environment.

3. Run Paper Trading

• Execute your strategy with Backtrader against the live data feed in simulation mode.
• Monitor performance and make adjustments as necessary.

Going Live

1. Strategy Review and Adjustment

• Fine-tune your strategy based on insights gained from paper trading.

2. Switch to Live Account

• Change the API credentials in your script to those of your live Oanda account.

3. Start Live Trading

• Begin with the smallest lot sizes.
• Closely monitor the strategy's live trading performance.

Key Considerations

• Monitoring: Keep a close watch on your system's operation during live trading.
• Incremental Deployment: Gradually increase your trading size based on the strategy's live performance.
• Continuous Improvement: Regularly update your strategy based on live trading data and market conditions.

This markdown guide outlines a focused and actionable path from developing and backtesting trading strategies with Backtrader and Oanda, to paper trading and eventually live trading.