config.py
- Bryan Downing
- May 24
- 8 min read
Updated: Jun 2
TRADING_CONFIG = {
'initial_capital': 100000.0, # Starting capital for the trading strategy
'bid_ask_threshold': 0.02, # Minimum spread percentage to consider a trade
'volatility_threshold': 0.15, # Volatility level that might trigger certain actions
'max_position_size': 0.1, # Maximum proportion of capital for a single position
'stop_loss': -0.05, # Percentage loss at which to exit a position
'take_profit': 0.03, # Percentage profit at which to exit a position
'trading_frequency': 0.01 # Seconds between trading algorithm iterations (10ms)
}
Risk management settings
RISK_LIMITS = {
'max_daily_loss': -0.10, # Maximum allowable percentage loss for a single day (10%)
'max_concentration': 0.20, # Maximum percentage of capital allocated to a single instrument (20%)
'var_limit': 0.05 # Value at Risk limit, e.g., 5% VaR
}
Logging configuration
LOGGING_CONFIG = {
'level': 'INFO', # Logging level (e.g., DEBUG, INFO, WARNING, ERROR)
'file': 'hft_trading.log', # Name of the log file
'format': '%(asctime)s - %(levelname)s - %(message)s' # Log message format
}
```
Explanation of Configuration Parameters:
TRADING_CONFIG:
- `initial_capital`: Starting sum of money allocated to the trading strategy (e.g., $100,000).
- `bid_ask_threshold`: Defines the minimum percentage difference between bid and ask prices that the strategy considers an opportunity.
- `volatility_threshold`: A parameter indicating the level of market volatility that might influence trading decisions.
- `max_position_size`: Restricts the fraction of total capital that can be allocated to a trade.
- `stop_loss`: Automated exit rule that closes a position if it incurs a specified percentage loss.
- `take_profit`: Automated exit rule that closes a position when it achieves a predefined gain.
- `trading_frequency`: Time interval in seconds between consecutive runs of the trading algorithm's main loop, with a value of 0.01 corresponding to 10 milliseconds.
RISK_LIMITS:
- `max_daily_loss`: A hard limit on the loss a portfolio can sustain in a day.
- `max_concentration`: Ensures diversification by preventing over-allocation to any single financial instrument.
- `var_limit`: A measure of potential loss in value of the portfolio.
LOGGING_CONFIG:
- `level`: Determines the severity of messages logged.
- `file`: Specifies the filename for log messages.
- `format`: Defines the structure of each log entry.
Requirements File (requirements.txt)
To ensure reproducibility and ease of setup in different environments, a requirements.txt file lists all dependencies with their recommended versions:
```plaintext
numpy>=1.21.0
pandas>=1.3.0
scipy>=1.7.0
matplotlib>=3.4.0
seaborn>=0.11.0
websockets>=10.0
aiohttp>=3.8.0
asyncio-mqtt>=0.11.0 # Suggests potential MQTT integration
```
Deployment Options
Multiple methods exist for deploying the HFT strategy:
Option 1: Local Development
This is the simplest method for testing and development on a local machine.
```bash
Run the strategy
python hft_options_futures_strategy.py
```
Option 2: Production Server (Linux with systemd)
For a more robust deployment on a Linux server, using `systemd` as a service manager is recommended.
Create a systemd Service File:
Define how `systemd` should manage the trading strategy process.
```bash
sudo nano /etc/systemd/system/hft-trading.service
```
The content of this file should be:
```ini
[Unit]
Description=HFT Trading Strategy
After=network.target
[Service]
Type=simple
User=trader # Replace with actual user running the script
WorkingDirectory=/opt/hft_trading # Path to the project directory
ExecStart=/opt/hft_trading/hft_trading_env/bin/python hft_options_futures_strategy.py # Full path to python and script
Restart=always
RestartSec=10
[Install]
WantedBy=multi-user.target
```
Enable and Start the Service:
Utilize `systemctl` commands to manage the service:
```bash
sudo systemctl enable hft-trading.service # Enable the service to start on boot
sudo systemctl start hft-trading.service # Start the service immediately
```
Option 3: Docker Deployment
Containerization with Docker offers a portable, isolated environment for the trading strategy.
Create a Dockerfile:
The Dockerfile contains instructions to build a Docker image.
```dockerfile
Dockerfile
FROM python:3.9-slim
WORKDIR /app
requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
. .
CMD ["python", "hft_options_futures_strategy.py"]
```
Key Features Implemented in the Initial Version
The initial version of the HFT strategy features several sophisticated components:
Optimal Portfolio Weighting: Utilizes mean-variance optimization to allocate capital effectively.
Bid-Ask Opportunity Detection: Actively scans for and identifies arbitrage possibilities.
Real-time P&L Tracking: Continual monitoring of the portfolio's financial performance.
Risk Management: Implements crucial risk controls, including stop-loss orders.
Greeks-based Trading: Leverages option Greeks to inform trading decisions.
High-Frequency Execution: Operates on rapid 10-millisecond iteration cycles.
Comprehensive Reporting: Potential for generating detailed performance analytics and visualizations.
Enhancing the HFT Strategy: Live Simulation and Real-Time Charts
This section discusses the evolution of the HFT strategy, aiming to enhance it with live simulated trading capabilities and sophisticated real-time chart updates. This enhanced version seeks to provide a more dynamic and visually informative trading environment.
Enhanced Build Instructions
Setting up the enhanced HFT trading system involves a new project structure and additional dependencies for visualization.
Create Project Directory and Virtual Environment:
A new directory is recommended for the enhanced version.
```bash
mkdir enhanced_hft_trading
cd enhanced_hft_trading
python -m venv venv
source venv/bin/activate # Windows: venv\Scripts\activate
```
Install Enhanced Requirements:
This version requires libraries for advanced plotting and web-based dashboards.
```bash
pip install numpy pandas scipy matplotlib seaborn asyncio-mqtt websockets aiohttp
pip install plotly dash bokeh # Optional: for web-based dashboards
```
Save the Enhanced Script:
The main script for this version is referred to as `enhanced_hft_live_trading.py`.
Enhanced Requirements File (requirements_enhanced.txt)
A dedicated requirements file, `requirements_enhanced.txt`, lists all necessary packages, including those for visualization:
```plaintext
numpy>=1.21.0
pandas>=1.3.0
scipy>=1.7.0
matplotlib>=3.4.0
seaborn>=0.11.0
websockets>=10.0
aiohttp>=3.8.0
asyncio-mqtt>=0.11.0
plotly>=5.0.0
dash>=2.0.0
bokeh>=2.4.0
```
Enhanced Configuration File (config_enhanced.py)
This new configuration file includes more granular settings:
```python
config_enhanced.py
ENHANCED_CONFIG = {
'trading': {
'initial_capital': 100000.0,
'simulation_speed': 1.0, # 1x = real-time
'max_trades_per_minute': 20, # Limits trade execution
'min_trade_interval': 0.1, # Minimum time between trades
'market_making_enabled': True # Enable market making
},
'risk_management': {
'stop_loss': -0.05,
'take_profit': 0.04,
'max_position_size': 0.08,
'max_concentration': 0.25,
'daily_trade_limit': 1000 # Maximum trades per day
},
'visualization': {
'update_interval': 100, # Chart update interval
'chart_history': 500, # Data points in charts
'real_time_enabled': True # Enable real-time updates
},
'market_simulation': {
'volatility_multiplier': 1.0, # Adjust simulated volatility
'spread_realism': True, # Enable realistic spread simulation
'slippage_modeling': True # Enable slippage simulation
}
}
```
Enhanced Deployment Options
The deployment options for the enhanced strategy accommodate its GUI and monitoring features.
Option A: Local Development with GUI
For running locally with the graphical user interface and visualizations:
```bash
Run with full GUI
python enhanced_hft_live_trading.py
Run with specific configuration
python enhanced_hft_live_trading.py --config config_enhanced.py
```
Option B: Production Server with Monitoring (systemd)
Deployment on a production server using systemd is similar to the initial strategy but may require environment variables for GUI components.
Create systemd Service File:
```bash
sudo nano /etc/systemd/system/enhanced-hft.service
```
Service configuration:
```ini
[Unit]
Description=Enhanced HFT Live Trading
After=network.target
[Service]
Type=simple
User=trader
WorkingDirectory=/opt/enhanced_hft # Path to enhanced project
ExecStart=/opt/enhanced_hft/venv/bin/python enhanced_hft_live_trading.py
Restart=always
RestartSec=10
[Install]
WantedBy=multi-user.target
```
Option C: Docker with VNC for Charts
To deploy with visualizations in a Docker container, a Dockerfile involving a VNC server is proposed. This allows users to view charts remotely.
Create Dockerfile.enhanced:
```dockerfile
Dockerfile.enhanced
FROM python:3.9-slim
Install GUI dependencies
RUN apt-get update && apt-get install -y \
python3-tk \
xvfb \
x11vnc \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /app
requirements_enhanced.txt .
RUN pip install --no-cache-dir -r requirements_enhanced.txt
. .
Start VNC server and trading strategy
CMD ["bash", "-c", "Xvfb :1 -screen 0 1024x768x16 & x11vnc -display :1 -nopw -listen localhost -xkb & DISPLAY=:1 python enhanced_hft_live_trading.py"]
```
Key Features Added in the Enhanced Version
The enhanced HFT strategy introduces numerous new features, focusing on live simulation and advanced visualization.
Live Real-time Charts:
6 Simultaneous Chart Windows: Multiple updating charts for a comprehensive overview.
P&L Tracking: Color-coded displays for quick assessments.
Live Price Feeds: Real-time (simulated) price movements.
Trading Activity Monitor: Metrics like trades per minute.
Volatility Heatmap: Visual representation of market conditions.
Position Distribution Pie Chart: Illustrates capital allocation.
Top Performers Ranking: Leaderboard of profitable instruments.
Greeks Exposure Dashboard: Visualizes portfolio exposure.
Enhanced Trading Logic:
Market Making Capabilities: Logic to act as a market maker.
Greeks-based Position Sizing: Use of Greeks for determining position sizes.
Realistic Slippage Modeling: Provides more accurate representation of execution costs.
Advanced Risk Management: Refined risk controls.
Rate Limiting and Position Concentration Controls: More granular control.
Live Simulation Features:
Realistic Market Data Generation: Improved algorithms for synthetic data.
Time-based Volatility Patterns: Simulation of volatility changes.
Correlated Price Movements: Modeling correlations between instruments.
Volume and Open Interest Simulation: Enhancements for realism.
Performance Monitoring:
Real-time P&L Updates: Continuous feedback on profitability.
Sharpe Ratio Calculation: On-the-fly assessments of risk-adjusted returns.
Maximum Drawdown Tracking: Monitoring significant declines.
Win Rate Statistics: Tracking profitable trades.
Volatility Measurements: Real-time calculations displayed.
Running the Enhanced System
Executing the enhanced system is straightforward:
```bash
Simple execution
python enhanced_hft_live_trading.py
```
The expected console output indicates its initialization and operational mode:
🚀 Initializing Enhanced HFT Options & Futures Strategy...
📊 Starting Live Trading Simulation with Real-time Charts...
- Charts will update every 100ms
- Trading occurs every 50ms (Note: the config specifies a min trade interval of 0.1s)
- Press Ctrl+C to stop trading
Addressing Technical Challenges: Fixing Exceptions in the Enhanced Script
The development of the enhanced script with visualizations faced technical challenges. The document provides a section detailing the fixes for these issues, especially with Matplotlib's rendering.
Key Changes Made to Fix Exceptions
The fixes focused on ensuring smooth rendering of charts and robust error handling:
Fixed LaTeX/MathText Issues in Matplotlib:
A common source of errors was the interpretation of text. The script was modified to disable LaTeX interpretation:
```python
import matplotlib.pyplot as plt
plt.rcParams['text.usetex'] = False
plt.rcParams['mathtext.default'] = 'regular'
```
Safe Formatting Functions:
Custom functions were created for formatting values to avoid problematic characters in titles and labels.
Enhanced Error Handling:
Improved error handling with try-catch blocks around chart updates to manage unexpected errors.
Updated Chart Title Generation: Divided logic for creating chart titles to prevent misinterpretation of text.
Improved Chart Labels: Clarity and stability were enhanced by adjusting currency symbols and validating data.
Installation Instructions (for the Fixed Script)
After applying these fixes, the installation instructions for running the stable `enhanced_hft_live_trading_fixed.py` script are given as:
```bash
Install required packages
pip install numpy pandas scipy matplotlib seaborn asyncio
Run the fixed script
python enhanced_hft_live_trading_fixed.py
```
This shorter package list specifically pertains to core functionality. For full features, the requirements from `requirements_enhanced.txt` still apply.
Outcome of the Fixed
With these changes, the `enhanced_hft_live_trading_fixed.py` script runs without LaTeX parsing exceptions. Crucially, it retains live trading visualization capabilities, including:
Real-time P&L tracking.
Live price feeds for instruments.
Volatility heatmaps.
Position distribution charts.
Greeks exposure.
All charts update every 100ms, providing a dynamic trading dashboard.
Key Distinctions and Evolution: Initial vs. Enhanced Strategy
The journey from initial HFT strategy to enhanced, visualized, and fixed versions showcases significant functional and experiential evolution.
Core Logic vs. Interactive Simulation: Initial strategy focused on core trading logic, while the enhanced version offers a rich simulation environment.
Configuration Granularity: Enhanced configuration introduces more parameters for simulation aspects.
Dependencies: The enhanced version introduces new dependencies for advanced visualizations.
Deployment Complexity: The enhanced Docker deployment is notably complex due to the need for GUI elements.
Feature Set: The enhanced version boasts extensive features including live charts and sophisticated trading logic.
Development Path: The document realistically outlines the debugging and refinement processes.
This evolution reflects a desire for a functional trading algorithm that serves as a tool for analysis and refinement through detailed simulation.
Limitations and Considerations for Real-World HFT
The HFT strategy detailed in "readme.txt" provides a sophisticated simulation of high-frequency trading concepts. However, it is crucial to contextualize these concepts against the realities of live, production HFT.
Key Limitations of Simulated HFT Environments:
Infrastructure and Latency: Real HFT operates on microsecond scales, requiring specialized hardware and low-latency code often implemented in languages like C++.
Market Data Access: The system relies on synthetic or less efficient data feeds compared to direct market access.
Execution Speed and Slippage: Python's execution speed for low-latency order placement is generally insufficient.
Simplified Models: The pricing and market dynamics in simulations are inherently simplified.
Regulatory Compliance: Real-world HFT operations are subject to compliance burdens not covered in technical simulations.
As a simulation tool, the system allows exploration of HFT concepts and risk management techniques. Transitioning such a system to competitive high-frequency markets demands a fundamental shift in technology stack and data sourcing.
Conclusion
The document provides a detailed blueprint for a progressively sophisticated High-Frequency Trading strategy for options and futures. Starting with core features like portfolio optimization and risk management, it evolves into an enhanced version featuring live simulations and advanced visualizations.
While the enhanced strategy offers rich insights into HFT dynamics and performance monitoring, it is critical to remember the significant gap between a Python-based system and the infrastructure required for competitive real-world trading. Nevertheless, the HFT strategy serves as an invaluable educational resource and a testament to the intricate design involved in developing automated trading systems. It encapsulates many core principles of HFT, from execution logic to performance analytics, within a well-documented framework.
Comments