# Import necessary modules from separate folders
from config.settings import Settings
from config.api_keys import APIKeys
from data_collection.market_data.historical_data_fetcher import fetch_historical_data
from data_preprocessing.feature_engineering.custom_indicators import calculate_rsi,
calculate_macd
from strategy_engine.traditional_strategies.supply_demand_trader import
detect_supply_demand_zones
from strategy_engine.machine_learning.deep_reinforcement_learning_trader import
train_drl_trader
from risk_management.position_sizing.dynamic_position_sizing import calculate_position_size
from trade_execution.order_handling.order_execution import execute_order
from backtesting.performance_analysis.backtest_final_report_generator import
generate_final_backtest_report
from dashboard.backend_logic.live_event_tracker_dashboard import display_live_events
from learning_and_adaptation.adaptive_learning.online_learning_engine import update_model
# Initialize settings and API keys
settings = Settings()
api_keys = APIKeys()
# Main function
def main():
print("Starting AI-Based Trading System...")
# Step 1: Initialize databases
initialize_databases()
# Step 2: Fetch historical market data
symbol = 'EUR/USD'
timeframe = '1m'
historical_data = fetch_historical_data(symbol, timeframe)
# Step 3: Preprocess data
preprocessed_data = preprocess_data(historical_data)
# Step 4: Detect supply/demand zones using ICT concepts
zones = detect_supply_demand_zones(preprocessed_data)
print(f"Supply/Demand Zones Detected: {zones}")
# Step 5: Train machine learning models
ml_model = train_ml_model(preprocessed_data)
# Step 6: Train reinforcement learning agents
rl_model = train_rl_agent(preprocessed_data)
# Step 7: Execute trading loop
run_trading_loop(preprocessed_data, ml_model, rl_model, zones)
# Step 8: Generate backtest report
backtest_report = generate_final_backtest_report(get_backtested_trades())
print(f"Backtest Report: {backtest_report}")
# Step 9: Start dashboard and live event tracking
start_dashboard()
print("Trading System Initialized Successfully.")
# Helper Functions
def initialize_databases():
"""Initialize all required databases."""
from databases.create_influxdb import create_market_data_db
from databases.create_postgresql_db import create_trade_history_db
create_market_data_db()
create_trade_history_db()
print("Databases Initialized.")
def preprocess_data(raw_data):
"""Preprocess raw market data."""
from data_preprocessing.cleaning_and_normalization.data_cleaning import clean_data
from data_preprocessing.feature_engineering.custom_indicators import calculate_rsi,
calculate_macd
cleaned_data = clean_data(raw_data)
cleaned_data = calculate_rsi(cleaned_data)
cleaned_data = calculate_macd(cleaned_data)
return cleaned_data
def train_ml_model(data):
"""Train a machine learning model."""
from strategy_engine.machine_learning.neural_networks_forecasting import
create_forecasting_model
X = data[['rsi', 'macd']]
y = data['target'] # Example target column
model = create_forecasting_model(input_shape=(X.shape[1],))
model.fit(X, y, epochs=10, batch_size=32, verbose=0)
print("Machine Learning Model Trained.")
return model
def train_rl_agent(data):
"""Train a reinforcement learning agent."""
from learning_and_adaptation.reinforcement_learning.reinforcement_learning_env import
TradingEnv
from stable_baselines3 import PPO
env = TradingEnv(data)
model = PPO('MlpPolicy', env, verbose=1)
model.learn(total_timesteps=10000)
print("Reinforcement Learning Agent Trained.")
return model
def run_trading_loop(data, ml_model, rl_model, zones):
"""Run the main trading loop."""
from risk_management.position_sizing.dynamic_position_sizing import
calculate_position_size
from trade_execution.order_handling.order_execution import execute_order
account_balance = 10000
risk_percentage = settings.risk_percentage
max_drawdown = settings.max_drawdown
while True:
# Get latest price data
current_price = get_current_price(symbol='EUR/USD')
# Predict using ML and RL models
ml_signal = ml_model.predict(data[['rsi', 'macd']])[-1]
rl_signal = rl_model.predict(data[['close', 'volume']])[-1]
# Combine signals with ICT rules
if current_price > zones['supply'] and ml_signal == 1 and rl_signal == 1:
action = 'buy'
elif current_price < zones['demand'] and ml_signal == 0 and rl_signal == 0:
action = 'sell'
else:
action = 'hold'
# Calculate position size
stop_loss = calculate_stop_loss(data)
position_size = calculate_position_size(account_balance, risk_percentage, stop_loss)
# Execute trade
if action != 'hold':
order = {'symbol': 'EUR/USD', 'side': action, 'quantity': position_size, 'price':
current_price}
execute_order(order)
print(f"Trade Executed: {order}")
# Check drawdown and pause if necessary
if not check_max_drawdown(account_balance, max_drawdown):
print("Max Drawdown Exceeded. Pausing Trading.")
break
# Update models with new data
update_model(ml_model, get_new_data())
def calculate_stop_loss(data):
"""Calculate stop-loss level."""
from risk_management.stop_loss.volatility_based_stop_ict import calculate_ict_stop_loss
return calculate_ict_stop_loss(data)
def check_max_drawdown(account_balance, max_drawdown):
"""Check if max drawdown has been exceeded."""
from risk_management.position_sizing.max_drawdown_monitor import
monitor_max_drawdown
current_balance = get_current_account_balance()
return monitor_max_drawdown(account_balance, current_balance, max_drawdown)
def get_current_price(symbol):
"""Fetch current price for a given symbol."""
from data_collection.market_data.real_time_data_fetcher import stream_real_time_data
return stream_real_time_data(symbol=symbol)[-1]['close']
def get_new_data():
"""Fetch new data for online learning."""
from data_collection.market_data.high_frequency_data_enrichment import
enrich_high_frequency_data
ticks = fetch_tick_data(symbol='EUR/USD')
order_book = fetch_order_book(symbol='EUR/USD')
return enrich_high_frequency_data(ticks, order_book)
def get_current_account_balance():
"""Fetch current account balance."""
from trade_execution.order_handling.order_routing import get_account_balance
return get_account_balance(api_keys.get_binance_client())
def get_backtested_trades():
"""Fetch backtested trades for reporting."""
from backtesting.strategy_testing.strategy_tester import backtest_strategy
strategy = load_strategy()
data = load_backtest_data()
return backtest_strategy(strategy, data)
def load_strategy():
"""Load a predefined strategy for backtesting."""
from strategy_engine.traditional_strategies.trend_following import trend_following_strategy
return trend_following_strategy
def load_backtest_data():
"""Load historical data for backtesting."""
from data_collection.market_data.historical_data_fetcher import fetch_historical_data
return fetch_historical_data(symbol='EUR/USD', timeframe='1h', limit=1000)
def start_dashboard():
"""Start the dashboard server."""
from dashboard.backend_logic.ui_backend import app
import threading
def run_dashboard():
app.run(debug=True)
dashboard_thread = threading.Thread(target=run_dashboard)
dashboard_thread.start()
print("Dashboard Started.")
if __name__ == '__main__':
main()
