Blog

Optimal Execution with Almgren-Chriss Model Basics 2024

PerfectQuant

— 2 min read

One of the fascinating topics gaining traction in Quantitative Finance is Optimal Execution with Almgren-Chriss Model. This model helps large institutional traders minimize the trading cost associated with executing large orders by balancing market impact and price uncertainty.

Here's an overview, the mathematical formulation, and a Python code example for implementing this model.

1. The Almgren-Chriss Model: Mathematical Overview

The Almgren-Chriss model balances the trade-off between two main components:

  • Temporary Impact: The immediate cost of trading large volumes, which pushes the price of the asset.
  • Permanent Impact: The lasting price effect of a trade.
  • Variance: The price uncertainty, as larger trades can increase the volatility of the asset's price.

Mathematical Formula

The objective of the Almgren-Chriss model is to minimize the following function:

\[
\min_{{x(t)}} \mathbb{E}\left[ C(x) \right] + \lambda \text{Var}(C(x))
\]

Where:

  • \( x(t) \) is the volume executed at time \( t \),
  • \( \mathbb{E}[C(x)] \) is the expected cost of execution, and
  • \( \text{Var}(C(x)) \) is the variance of the execution cost,
  • \( \lambda \) is a risk-aversion parameter (higher \( \lambda \) corresponds to greater concern for variance).

The cost of execution \( C(x) \) can be expressed as:

\[
C(x) = \frac{\eta}{2} \sum_{i=1}^{n} \frac{x_i^2}{Q_i} + \gamma \sum_{i=1}^{n} x_i S_i + \sigma^2 \sum_{i=1}^{n} Q_i
\]

Where:

  • \( \eta \) is the temporary price impact constant,
  • \( \gamma \) is the permanent price impact constant,
  • \( S_i \) is the asset price at step \( i \),
  • \( Q_i \) is the remaining inventory at step \( i \),
  • \( \sigma \) is the volatility of the asset.

2. Python Code Example

The following code implements a simple Almgren-Chriss model in Python using numerical optimization to minimize execution cost.

import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import minimize

# Parameters
T = 1.0  # Time horizon
n = 10  # Number of trading periods
Q0 = 100000  # Initial order size (shares)
sigma = 0.2  # Volatility of the asset
gamma = 0.0001  # Permanent price impact
eta = 0.01  # Temporary price impact
lambda_risk = 0.5  # Risk aversion parameter

# Time grid
dt = T / n
t = np.linspace(0, T, n)

# Initial price
S0 = 50.0

# Objective function to minimize: Expected cost + Lambda * Variance
def cost(x):
    Q = Q0 - np.cumsum(x)  # Remaining shares
    temp_impact_cost = 0.5 * eta * np.sum((x ** 2) / Q)  # Temporary impact
    perm_impact_cost = gamma * np.sum(x * S0)  # Permanent impact
    variance_cost = lambda_risk * np.sum((sigma ** 2) * Q ** 2 * dt)  # Variance
    return temp_impact_cost + perm_impact_cost + variance_cost

# Constraints: Sell all shares by end
constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - Q0})

# Initial guess for trades
x0 = np.ones(n) * (Q0 / n)

# Bounds for trades (must sell positive number of shares each time)
bounds = [(0, Q0 / n)] * n

# Optimize
result = minimize(cost, x0, bounds=bounds, constraints=constraints, method='SLSQP')

# Extract optimal trading trajectory
optimal_trades = result.x
remaining_inventory = Q0 - np.cumsum(optimal_trades)

# Plotting the optimal trading schedule
plt.figure(figsize=(10, 6))
plt.plot(t, remaining_inventory, label='Remaining Inventory')
plt.plot(t, optimal_trades, label='Trades at each step')
plt.xlabel('Time')
plt.ylabel('Shares')
plt.legend()
plt.title('Optimal Execution Strategy - Almgren-Chriss Model')
plt.grid(True)
plt.show()

print("Optimal Trades at each time step:", optimal_trades)

Explanation of the Code:

  • The cost function encapsulates the expected cost of execution, combining the temporary price impact, permanent price impact, and variance of the remaining inventory.
  • We then use the minimize function from the scipy.optimize library to optimize the trading trajectory \( x(t) \) to minimize the execution cost.
  • The constraints ensure that all shares are sold by the end of the time horizon.

3. Key Takeaways:

  • The Almgren-Chriss model provides a framework for optimal execution of large trades by balancing price impact and price uncertainty.
  • The Python code implements this model using numerical optimization to find the trading trajectory that minimizes the execution cost.

This is a simplified version, but you can expand it with more complex risk metrics and market conditions, such as stochastic volatility or real-time price adjustments.

Read more