README.md

---
title: Cross-Asset Arbitrage Engine With Transformer Models
colorFrom: gray
colorTo: gray
sdk: gradio
sdk_version: 5.41.1
app_file: app.py
pinned: false
license: mit
short_description: Arbitrage engine with transformer forecasts & latency model
---

# Cross-Asset Arbitrage Engine with Transformer Models

This project presents a sophisticated, high-fidelity simulation of a cross-asset arbitrage trading engine. It is designed to demonstrate advanced concepts in quantitative development, from predictive modeling with transformer architectures to complex risk management and execution logic. The entire system is accessible through an interactive dashboard built with Gradio.

This is a **simulation environment** created for demonstration and educational purposes. It does not connect to live markets or execute real trades.

## Core Features

This engine simulates a complete end-to-end arbitrage workflow with the following key components:

* **Transformer-Based Price Forecasting**: A custom `NumericalTransformer` model, built with PyTorch, is trained on-the-fly to generate multi-horizon forecasts for price, volatility, and volume across different asset classes.
* **Multi-Asset and Multi-Venue Simulation**: The engine simulates arbitrage opportunities across a diverse range of configurable asset classes, including:
    * Cryptocurrency (Spot and Perpetual Futures)
    * Foreign Exchange (FX) Pairs
    * Equity ETFs
* **Realistic Market Microstructure**: The simulation models order books for both centralized (CEX) and decentralized (DEX) exchanges, incorporating realistic bid-ask spreads, liquidity depth, and slippage.
* **Latency-Aware Execution Engine**: A `LatencyAwareExecutionEngine` simulates the entire trade lifecycle, modeling network latency between different exchange types (CEX-CEX, CEX-DEX, DEX-DEX), price drift during execution delays, and transaction costs, including gas fees for DEX trades.
* **Dynamic Strategy Optimization**: The system includes a `LLMStrategyOptimizer` module that uses a neural network to dynamically adjust key strategy parameters (e.g., profit thresholds, position sizing, risk limits) based on recent trade performance and simulated market conditions.
* **Comprehensive Risk Analytics**: A `RiskAnalytics` module calculates and monitors portfolio risk in real-time, computing critical metrics such as Value at Risk (VaR), Conditional Value at Risk (cVaR), Sharpe Ratio, Sortino Ratio, and maximum drawdown.
* **Interactive Dashboard**: The entire simulation is controlled and visualized through a Gradio interface, featuring performance charts, execution analysis, risk metric dashboards, and a network graph of arbitrage opportunities.

## How It Works

The engine is built on a modular architecture where specialized Python classes manage distinct parts of the arbitrage process:

1.  **Market Data Generation**: The `CrossAssetArbitrageEngine` class first generates a realistic, correlated historical price series for all configured assets.
2.  **Price Forecasting**: For each asset, the `PriceForecastingEngine` prepares features from the market data and uses its `NumericalTransformer` model to predict future price movements and volatility.
3.  **Opportunity Discovery**: The `ArbitrageDetector` consumes simulated order book data from multiple exchanges. It identifies potential arbitrage opportunities where the best bid price on one exchange is higher than the best ask price on another, factoring in transaction costs.
4.  **Risk Assessment & Optimization**:
    * The `LLMStrategyOptimizer` analyzes recent execution results and market volatility to suggest optimal parameters for the current trading cycle.
    * Identified opportunities are filtered based on these dynamic parameters (e.g., `min_profit_threshold`).
    * The `RiskAnalytics` module checks if a potential trade violates predefined risk limits, such as maximum position size or concurrent trade limits.
5.  **Execution Simulation**: The `LatencyAwareExecutionEngine` takes valid opportunities and simulates the execution process. It models slippage based on trade size, market volatility, and order book depth, and calculates the final realized profit after accounting for all costs and latency-related price changes.
6.  **Performance Tracking & Visualization**: Results from each cycle are stored, and the Gradio interface uses Plotly and NetworkX to generate interactive visualizations of portfolio performance, execution statistics, and opportunity networks.

## Technical Stack

* **Machine Learning**: PyTorch, scikit-learn
* **Data Manipulation**: NumPy, Pandas
* **Mathematical & Statistical Analysis**: SciPy, StatsModels
* **Web Interface & Dashboard**: Gradio
* **Visualization**: Plotly, NetworkX
* **Core Language**: Python

## How to Use the Demo

1.  Navigate to the **Arbitrage Simulation** tab.
2.  Adjust the simulation parameters on the left-hand side:
    * **Number of Trading Cycles**: The number of discrete time steps the simulation will run.
    * **Initial Capital**: The starting portfolio value.
    * **Minimum Profit Threshold**: The initial minimum expected profit required to consider a trade.
3.  Click the **Run Simulation** button.
4.  Analyze the results in the generated plots and summary tables, which display the portfolio's performance, risk metrics, and individual trade outcomes.
5.  Navigate to the **Strategy Analysis** tab to view how the `LLMStrategyOptimizer` adjusted its parameters over the course of the simulation.

## Disclaimer

This project is a **simulation only** and is intended to showcase software architecture and quantitative modeling skills. It does not represent a live trading system and is not a source of financial advice. All data is synthetically generated, and the models and logic are for demonstration purposes. Trading in financial markets involves significant risk.