Optimal Order Execution.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e064d1ef-d43a-4b07-9168-7bacc85b4bdf",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import yfinance as yf\n",
    "import matplotlib.pyplot as plt\n",
    "import datetime\n",
    "import time\n",
    "import requests\n",
    "import warnings\n",
    "\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "66561b86-9bcb-4753-9674-80a122d29835",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MarketData:\n",
    "    def __init__(self, ticker, start_date, end_date=None):\n",
    "        self.ticker = ticker\n",
    "        self.start_date = start_date\n",
    "        self.end_date = end_date if end_date else datetime.datetime.today().strftime('%Y-%m-%d')\n",
    "        self.data = None\n",
    "        self.log_returns = None\n",
    "        self.daily_volatility = None\n",
    "        self.adv = None  # Average Daily Volume\n",
    "\n",
    "    def fetch_data(self):\n",
    "        # Fetch historical data\n",
    "        self.data = yf.download(self.ticker, start=self.start_date, end=self.end_date)\n",
    "        if self.data.empty:\n",
    "            raise ValueError(f\"No data fetched for ticker {self.ticker}.\")\n",
    "        print(f\"Data fetched for {self.ticker} from {self.start_date} to {self.end_date}.\")\n",
    "\n",
    "    def fetch_intraday_data(self, interval='1m'):\n",
    "        # Fetch intraday data using yfinance\n",
    "        intraday_data = yf.download(tickers=self.ticker, period='5d', interval=interval)\n",
    "        if intraday_data.empty:\n",
    "            raise ValueError(f\"No intraday data fetched for ticker {self.ticker}.\")\n",
    "        self.intraday_data = intraday_data\n",
    "        print(f\"Intraday data fetched for {self.ticker}.\")\n",
    "\n",
    "    def calculate_intraday_volume_profile(self):\n",
    "        # Calculate average volume per time interval\n",
    "        self.intraday_data['Time'] = self.intraday_data.index.time\n",
    "        volume_profile = self.intraday_data.groupby('Time')['Volume'].mean()\n",
    "        self.volume_profile = volume_profile / volume_profile.sum()  # Normalize\n",
    "        print(\"Intraday volume profile calculated.\")\n",
    "\n",
    "    def calculate_log_returns(self):\n",
    "        # Calculate daily logarithmic returns\n",
    "        self.data['Log_Returns'] = np.log(self.data['Adj Close'] / self.data['Adj Close'].shift(1))\n",
    "        self.data.dropna(inplace=True)\n",
    "        self.log_returns = self.data['Log_Returns']\n",
    "\n",
    "    def estimate_volatility(self):\n",
    "        # Calculate daily volatility\n",
    "        self.daily_volatility = self.log_returns.std()\n",
    "        print(f\"Estimated daily volatility (sigma) for {self.ticker}: {self.daily_volatility:.6f}\")\n",
    "\n",
    "    def calculate_adv(self):\n",
    "        # Calculate Average Daily Volume over the past month\n",
    "        self.adv = self.data['Volume'][-21:].mean()\n",
    "        print(f\"Estimated Average Daily Volume (ADV) for {self.ticker}: {self.adv:,.0f}\")\n",
    "\n",
    "    def prepare_data(self):\n",
    "        self.fetch_data()\n",
    "        self.calculate_log_returns()\n",
    "        self.estimate_volatility()\n",
    "        self.calculate_adv()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "108eb981-3e34-4b83-b560-365d867b86d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ParameterEstimator:\n",
    "    def __init__(self, market_data):\n",
    "        self.market_data = market_data\n",
    "        self.sigma = None\n",
    "        self.S0 = None\n",
    "        self.X0 = None  # Total shares to trade\n",
    "        self.T = None   # Trading horizon\n",
    "        self.N = None   # Number of time steps\n",
    "        self.dt = None  # Time step size\n",
    "        self.phi = None\n",
    "        self.eta = None\n",
    "        self.epsilon = None\n",
    "\n",
    "    def estimate_parameters(self, X0, T, N, phi, eta=None, epsilon=0.0):\n",
    "        self.sigma = self.market_data.daily_volatility\n",
    "        self.S0 = self.market_data.data['Adj Close'][-1]\n",
    "        self.X0 = X0\n",
    "        self.T = T\n",
    "        self.N = N\n",
    "        self.dt = T / N\n",
    "        self.phi = phi\n",
    "        self.epsilon = epsilon\n",
    "\n",
    "        # Estimate eta if not provided\n",
    "        if eta is None:\n",
    "            # Simple estimation of eta using empirical formula\n",
    "            self.eta = self.S0 / (self.market_data.adv * np.sqrt(self.N))\n",
    "            print(f\"Estimated temporary impact coefficient (eta): {self.eta:.6e}\")\n",
    "        else:\n",
    "            self.eta = eta\n",
    "\n",
    "        print(f\"Parameters estimated for {self.market_data.ticker}:\")\n",
    "        print(f\"  Sigma (volatility): {self.sigma:.6f}\")\n",
    "        print(f\"  Initial price (S0): ${self.S0:.2f}\")\n",
    "        print(f\"  Total shares to trade (X0): {self.X0}\")\n",
    "        print(f\"  Trading horizon (T): {self.T} days\")\n",
    "        print(f\"  Time steps (N): {self.N}\")\n",
    "        print(f\"  Time step size (dt): {self.dt:.6f}\")\n",
    "        print(f\"  Risk aversion (phi): {self.phi}\")\n",
    "        print(f\"  Temporary impact coefficient (eta): {self.eta:.6e}\")\n",
    "        print(f\"  Permanent impact coefficient (epsilon): {self.epsilon}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "30fac199-09d9-47e3-9a3f-22c94c825dda",
   "metadata": {},
   "outputs": [],
   "source": [
    "class OptimalExecutionModel:\n",
    "    def __init__(self, params):\n",
    "        self.params = params\n",
    "        self.kappa = None\n",
    "        self.x_t = None\n",
    "        self.u_t = None\n",
    "        self.t_grid = None\n",
    "\n",
    "    def calculate_kappa(self):\n",
    "        self.kappa = np.sqrt(self.params.phi * self.params.sigma**2 / self.params.eta)\n",
    "        print(f\"Calculated kappa: {self.kappa:.6e}\")\n",
    "\n",
    "    def calculate_optimal_trajectory(self):\n",
    "        self.t_grid = np.linspace(0, self.params.T, self.params.N + 1)\n",
    "        sinh_kappa_T = np.sinh(self.kappa * self.params.T)\n",
    "        self.x_t = self.params.X0 * (np.sinh(self.kappa * (self.params.T - self.t_grid)) / sinh_kappa_T)\n",
    "        self.u_t = -np.diff(self.x_t) / self.params.dt  # Trading rate\n",
    "        print(\"Optimal execution trajectory calculated.\")\n",
    "\n",
    "    def adjust_for_volume_profile(self, volume_profile):\n",
    "        volume_profile_array = volume_profile.values\n",
    "    \n",
    "        # Resample volume_profile_array to match the length of self.u_t\n",
    "        from scipy.interpolate import interp1d\n",
    "    \n",
    "        original_length = len(volume_profile_array)\n",
    "        target_length = len(self.u_t)\n",
    "    \n",
    "        # Create interpolation function\n",
    "        interpolation_function = interp1d(\n",
    "            np.linspace(0, 1, original_length),\n",
    "            volume_profile_array,\n",
    "            kind='linear',\n",
    "            fill_value='extrapolate'\n",
    "        )\n",
    "    \n",
    "        # Generate new volume profile array with the target length\n",
    "        volume_profile_array_resampled = interpolation_function(np.linspace(0, 1, target_length))\n",
    "    \n",
    "        # Normalize the resampled volume profile\n",
    "        volume_profile_array_resampled /= np.mean(volume_profile_array_resampled)\n",
    "    \n",
    "        print(f\"Length of resampled volume_profile_array: {len(volume_profile_array_resampled)}\")\n",
    "        print(f\"Length of self.u_t: {len(self.u_t)}\")\n",
    "    \n",
    "        # Adjust self.u_t\n",
    "        self.u_t = self.u_t * volume_profile_array_resampled\n",
    "        self.x_t = np.concatenate(([self.params.X0], self.params.X0 - np.cumsum(self.u_t * self.params.dt)))\n",
    "        print(\"Trading trajectory adjusted for intraday volume profile.\")\n",
    "\n",
    "    def run_model(self):\n",
    "        self.calculate_kappa()\n",
    "        self.calculate_optimal_trajectory()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6112b850-ea76-45c5-986b-26c5bb6f2e0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimulationEngine:\n",
    "    def __init__(self, market_data, model):\n",
    "        self.market_data = market_data\n",
    "        self.model = model\n",
    "\n",
    "    def simulate_price_paths(self, num_paths=1):\n",
    "        dt = self.model.params.dt\n",
    "        N = self.model.params.N\n",
    "        S0 = self.model.params.S0\n",
    "        sigma = self.model.params.sigma\n",
    "\n",
    "        dW = np.random.randn(num_paths, N) * np.sqrt(dt)\n",
    "        price_paths = np.zeros((num_paths, N + 1))\n",
    "        price_paths[:, 0] = S0\n",
    "        for i in range(N):\n",
    "            price_paths[:, i + 1] = price_paths[:, i] * np.exp(-0.5 * sigma**2 * dt + sigma * dW[:, i])\n",
    "        return price_paths\n",
    "\n",
    "    def calculate_execution_cost(self, price_paths, gamma=1.0):\n",
    "        num_paths = price_paths.shape[0]\n",
    "        N = self.model.params.N\n",
    "        dt = self.model.params.dt\n",
    "        u_t = self.model.u_t\n",
    "        x_t = self.model.x_t\n",
    "        eta = self.model.params.eta\n",
    "        epsilon = self.model.params.epsilon\n",
    "\n",
    "        execution_costs = np.zeros(num_paths)\n",
    "\n",
    "        for j in range(num_paths):\n",
    "            execution_cost = 0.0\n",
    "            for i in range(N):\n",
    "                # Nonlinear market impact\n",
    "                temp_impact = eta * (abs(u_t[i]) / self.market_data.adv) ** gamma\n",
    "                S_exec = price_paths[j, i] + temp_impact * np.sign(u_t[i]) + epsilon * x_t[i]\n",
    "                execution_cost += u_t[i] * S_exec * dt\n",
    "            execution_costs[j] = execution_cost\n",
    "\n",
    "        return execution_costs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b7f80bf4-ca48-4fcb-b16b-80c259207cc6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    # User inputs\n",
    "    ticker_symbol = input(\"Enter the ticker symbol (e.g., AAPL): \").upper()\n",
    "    start_date = input(\"Enter the start date for historical data (YYYY-MM-DD): \")\n",
    "    end_date = input(\"Enter the end date for historical data (YYYY-MM-DD) or press Enter for today: \") or None\n",
    "\n",
    "    # Initialize MarketData\n",
    "    market_data = MarketData(ticker_symbol, start_date, end_date)\n",
    "    market_data.prepare_data()\n",
    "\n",
    "    # Initialize ParameterEstimator\n",
    "    estimator = ParameterEstimator(market_data)\n",
    "\n",
    "    # User inputs for parameters\n",
    "    X0 = int(input(\"Enter the total shares to trade (e.g., 1000000): \"))\n",
    "    T = float(input(\"Enter the trading horizon in days (e.g., 1.0): \"))\n",
    "    N = int(input(\"Enter the number of time steps (e.g., 390 for intraday): \"))\n",
    "    phi = float(input(\"Enter the risk aversion parameter (e.g., 1e-6): \"))\n",
    "    gamma_input = input(\"Enter the market impact exponent gamma (e.g., 0.5 for nonlinear impact) or press Enter for linear impact: \")\n",
    "    gamma = float(gamma_input) if gamma_input else 1.0\n",
    "    eta_input = input(\"Enter the temporary impact coefficient eta or press Enter to estimate: \")\n",
    "    eta = float(eta_input) if eta_input else None\n",
    "\n",
    "    # Estimate parameters\n",
    "    estimator.estimate_parameters(X0=X0, T=T, N=N, phi=phi, eta=eta)\n",
    "\n",
    "    # Initialize OptimalExecutionModel\n",
    "    model = OptimalExecutionModel(estimator)\n",
    "    model.run_model()\n",
    "\n",
    "    if N > 390:\n",
    "        market_data.fetch_intraday_data(interval='1m')\n",
    "        market_data.calculate_intraday_volume_profile()\n",
    "        model.adjust_for_volume_profile(market_data.volume_profile)\n",
    "\n",
    "    # Initialize SimulationEngine\n",
    "    simulator = SimulationEngine(market_data, model)\n",
    "\n",
    "    # Simulate price paths\n",
    "    num_paths = int(input(\"Enter the number of simulation paths (e.g., 1000): \"))\n",
    "    price_paths = simulator.simulate_price_paths(num_paths=num_paths)\n",
    "\n",
    "    # Calculate execution costs\n",
    "    execution_costs = simulator.calculate_execution_cost(price_paths)\n",
    "\n",
    "    # Analyze and display results\n",
    "    mean_cost = np.mean(execution_costs)\n",
    "    std_cost = np.std(execution_costs)\n",
    "\n",
    "    print(f\"\\nAverage Execution Cost over {num_paths} simulations: ${mean_cost:,.2f}\")\n",
    "    print(f\"Standard Deviation of Execution Cost: ${std_cost:,.2f}\")\n",
    "\n",
    "    # Plot distribution of execution costs\n",
    "    plt.figure(figsize=(12, 6))\n",
    "    plt.hist(execution_costs, bins=50, alpha=0.7)\n",
    "    plt.xlabel('Execution Cost')\n",
    "    plt.ylabel('Frequency')\n",
    "    plt.title('Distribution of Execution Costs')\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "    # Plot optimal trading trajectory\n",
    "    plt.figure(figsize=(12, 6))\n",
    "    plt.plot(model.t_grid[:-1], model.x_t[:-1], label='Remaining Inventory')\n",
    "    plt.xlabel('Time (days)')\n",
    "    plt.ylabel('Shares')\n",
    "    plt.title('Optimal Trading Trajectory')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "1df21c62-177d-4687-ac65-4d8d3f721ce1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the ticker symbol (e.g., AAPL):  AAPL\n",
      "Enter the start date for historical data (YYYY-MM-DD):  2012-01-01\n",
      "Enter the end date for historical data (YYYY-MM-DD) or press Enter for today:  \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[*********************100%***********************]  1 of 1 completed\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data fetched for AAPL from 2012-01-01 to 2024-10-10.\n",
      "Estimated daily volatility (sigma) for AAPL: 0.017800\n",
      "Estimated Average Daily Volume (ADV) for AAPL: 57,391,642\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the total shares to trade (e.g., 1000000):  10000000\n",
      "Enter the trading horizon in days (e.g., 1.0):  4\n",
      "Enter the number of time steps (e.g., 390 for intraday):  391\n",
      "Enter the risk aversion parameter (e.g., 1e-6):  1e-4\n",
      "Enter the market impact exponent gamma (e.g., 0.5 for nonlinear impact) or press Enter for linear impact:  0.3\n",
      "Enter the temporary impact coefficient eta or press Enter to estimate:  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated temporary impact coefficient (eta): 2.022653e-07\n",
      "Parameters estimated for AAPL:\n",
      "  Sigma (volatility): 0.017800\n",
      "  Initial price (S0): $229.54\n",
      "  Total shares to trade (X0): 10000000\n",
      "  Trading horizon (T): 4.0 days\n",
      "  Time steps (N): 391\n",
      "  Time step size (dt): 0.010230\n",
      "  Risk aversion (phi): 0.0001\n",
      "  Temporary impact coefficient (eta): 2.022653e-07\n",
      "  Permanent impact coefficient (epsilon): 0.0\n",
      "Calculated kappa: 3.957958e-01\n",
      "Optimal execution trajectory calculated.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[*********************100%***********************]  1 of 1 completed\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intraday data fetched for AAPL.\n",
      "Intraday volume profile calculated.\n",
      "Length of resampled volume_profile_array: 391\n",
      "Length of self.u_t: 391\n",
      "Trading trajectory adjusted for intraday volume profile.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the number of simulation paths (e.g., 1000):  10000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Average Execution Cost over 10000 simulations: $2,502,791,118.76\n",
      "Standard Deviation of Execution Cost: $35,856,813.05\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    main()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}