{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "LaTeX macros (hidden cell)\n", "$\n", "\\newcommand{\\Q}{\\mathcal{Q}}\n", "\\newcommand{\\ECov}{\\boldsymbol{\\Sigma}}\n", "\\newcommand{\\EMean}{\\boldsymbol{\\mu}}\n", "\\newcommand{\\EAlpha}{\\boldsymbol{\\alpha}}\n", "\\newcommand{\\EBeta}{\\boldsymbol{\\beta}}\n", "$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Imports and configuration" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "scrolled": false }, "outputs": [], "source": [ "import sys\n", "import os\n", "import re\n", "import datetime as dt\n", "\n", "import numpy as np\n", "import pandas as pd\n", "import statsmodels.api as sm\n", "%matplotlib inline\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "from matplotlib.colors import LinearSegmentedColormap\n", "\n", "from mosek.fusion import *\n", "\n", "from notebook.services.config import ConfigManager\n", "\n", "from portfolio_tools import data_download, DataReader, compute_inputs" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3.9.7 (default, Sep 16 2021, 13:09:58) \n", "[GCC 7.5.0]\n", "matplotlib: 3.7.2\n" ] } ], "source": [ "# Version checks\n", "print(sys.version)\n", "print('matplotlib: {}'.format(matplotlib.__version__))\n", "\n", "# Jupyter configuration\n", "c = ConfigManager()\n", "c.update('notebook', {\"CodeCell\": {\"cm_config\": {\"autoCloseBrackets\": False}}}) \n", "\n", "# Numpy options\n", "np.set_printoptions(precision=5, linewidth=120, suppress=True)\n", "\n", "# Pandas options\n", "pd.set_option('display.max_rows', None)\n", "\n", "# Matplotlib options\n", "plt.rcParams['figure.figsize'] = [12, 8]\n", "plt.rcParams['figure.dpi'] = 200" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Prepare input data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we load the raw data that will be used to compute the optimization input variables, the vector $\\EMean$ of expected returns and the covariance matrix $\\ECov$. The data consists of daily stock prices of $8$ stocks from the US market. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Download data" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# Data downloading:\n", "# If the user has an API key for alphavantage.co, then this code part will download the data. \n", "# The code can be modified to download from other sources. To be able to run the examples, \n", "# and reproduce results in the cookbook, the files have to have the following format and content:\n", "# - File name pattern: \"daily_adjusted_[TICKER].csv\", where TICKER is the symbol of a stock. \n", "# - The file contains at least columns \"timestamp\", \"adjusted_close\", and \"volume\".\n", "# - The data is daily price/volume, covering at least the period from 2016-03-18 until 2021-03-18, \n", "# - Files are for the stocks PM, LMT, MCD, MMM, AAPL, MSFT, TXN, CSCO.\n", "list_stocks = [\"PM\", \"LMT\", \"MCD\", \"MMM\", \"AAPL\", \"MSFT\", \"TXN\", \"CSCO\"]\n", "list_factors = []\n", "alphaToken = None\n", " \n", "list_tickers = list_stocks + list_factors\n", "if alphaToken is not None:\n", " data_download(list_tickers, alphaToken) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Read data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We load the daily stock price data from the downloaded CSV files. The data is adjusted for splits and dividends. Then a selected time period is taken from the data." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "investment_start = \"2016-03-18\"\n", "investment_end = \"2021-03-18\"" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Found data files: \n", "stock_data/daily_adjusted_AAPL.csv\n", "stock_data/daily_adjusted_PM.csv\n", "stock_data/daily_adjusted_CSCO.csv\n", "stock_data/daily_adjusted_TXN.csv\n", "stock_data/daily_adjusted_MMM.csv\n", "stock_data/daily_adjusted_IWM.csv\n", "stock_data/daily_adjusted_MCD.csv\n", "stock_data/daily_adjusted_SPY.csv\n", "stock_data/daily_adjusted_MSFT.csv\n", "stock_data/daily_adjusted_LMT.csv\n", "\n", "Using data files: \n", "stock_data/daily_adjusted_PM.csv\n", "stock_data/daily_adjusted_LMT.csv\n", "stock_data/daily_adjusted_MCD.csv\n", "stock_data/daily_adjusted_MMM.csv\n", "stock_data/daily_adjusted_AAPL.csv\n", "stock_data/daily_adjusted_MSFT.csv\n", "stock_data/daily_adjusted_TXN.csv\n", "stock_data/daily_adjusted_CSCO.csv\n", "\n" ] } ], "source": [ "# The files are in \"stock_data\" folder, named as \"daily_adjusted_[TICKER].csv\"\n", "dr = DataReader(folder_path=\"stock_data\", symbol_list=list_tickers)\n", "dr.read_data(read_volume=True)\n", "df_prices, df_volumes = dr.get_period(start_date=investment_start, end_date=investment_end)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Run the optimization" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define the optimization model" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Below we implement the optimization model in Fusion API. We create it inside a function so we can call it later.\n", "\n", "The parameters:\n", "- `vp`/`vm`: Variable cost coefficients,\n", "- `fp`/`fm`: Fixed cost coefficients,\n", "- `up`/`um`: Upper bound of long and short side of the portfolio,\n", "- `lp`/`lm`: Lower bound of long and short side of the portfolio,\n", "- `pcoef`: Penalty term coefficient. (We use a penalty term to force either `xp` or `xm` to zero.)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# x = xp - xm\n", "# NOTE: Uses integer variables!\n", "def posneg(M, x, bigm_p, bigm_m=None):\n", " bigm_m = bigm_p if bigm_m is None else bigm_m\n", " \n", " # Positive and negative part of x\n", " xp = M.variable(\"_xp\", N, Domain.greaterThan(0.0))\n", " xm = M.variable(\"_xm\", N, Domain.greaterThan(0.0))\n", " \n", " # Binary variables\n", " yp = M.variable(\"_yp\", N, Domain.binary())\n", " ym = M.variable(\"_ym\", N, Domain.binary())\n", " \n", " # Constraint assigning xp and xm to be the positive and negative part of x.\n", " M.constraint('_pos-neg-part', Expr.sub(x, Expr.sub(xp, xm)), Domain.equalsTo(0.0))\n", " \n", " # Constraints making sure xp and xm are never both positive.\n", " M.constraint('_ubound-p', Expr.sub(xp, Expr.mul(bigm_p, yp)), Domain.lessThan(0.0))\n", " M.constraint('_ubound-m', Expr.sub(xm, Expr.mul(bigm_m, ym)), Domain.lessThan(0.0))\n", " M.constraint('_exclusion', Expr.add(yp, ym), Domain.lessThan(1.0))\n", " \n", " return xp, xm, yp, ym\n", "\n", "\n", "def EfficientFrontier(N, m, G, deltas, vp, vm, fp, fm, up, um, lp, lm, pcoef):\n", "\n", " with Model(\"Case study\") as M:\n", " # Settings\n", " #M.setLogHandler(sys.stdout)\n", " \n", " # Real variables \n", " # The variable x is the fraction of holdings in each security. \n", " x = M.variable(\"x\", N, Domain.unbounded())\n", " \n", " # The variable s models the portfolio variance term in the objective.\n", " s = M.variable(\"s\", 1, Domain.unbounded())\n", " \n", " # Auxiliary variable for 130/30 leverage constraint \n", " z = M.variable(\"z\", N, Domain.unbounded())\n", " \n", " # Positive and negative part of x\n", " xp, xm, yp, ym = posneg(M, x, up, um)\n", " \n", " # Buy-in\n", " M.constraint('lbound-p', Expr.sub(xp, Expr.mul(lp, yp)), Domain.greaterThan(0.0))\n", " M.constraint('lbound-m', Expr.sub(xm, Expr.mul(lm, ym)), Domain.greaterThan(0.0))\n", " \n", " # Budget constraint with transaction cost terms\n", " fixcost_terms = Expr.add([Expr.dot(fp, yp), Expr.dot(fm, ym)])\n", " varcost_terms = Expr.add([Expr.dot(vp, xp), Expr.dot(vm, xm)])\n", " budget_terms = Expr.add([Expr.sum(x), varcost_terms, fixcost_terms])\n", " M.constraint('budget', budget_terms, Domain.equalsTo(1.0))\n", "\n", " # 130/30 leverage constraint\n", " M.constraint('leverage-gt', Expr.sub(z, x), Domain.greaterThan(0.0))\n", " M.constraint('leverage-ls', Expr.add(z, x), Domain.greaterThan(0.0))\n", " M.constraint('leverage-sum', Expr.add([Expr.sum(z), varcost_terms, fixcost_terms]), Domain.equalsTo(1.6))\n", " \n", " # Objective (quadratic utility version)\n", " delta = M.parameter()\n", " penalty = Expr.mul(pcoef, Expr.sum(Expr.add(xp, xm)))\n", " M.objective('obj', ObjectiveSense.Maximize, Expr.sub(Expr.sub(Expr.dot(m, x), penalty), Expr.mul(delta, s)))\n", " \n", " # Conic constraint for the portfolio variance\n", " M.constraint('risk', Expr.vstack(s, 1, Expr.mul(G.transpose(), x)), Domain.inRotatedQCone())\n", " \n", " columns = [\"delta\", \"obj\", \"return\", \"risk\", \"x_sum\", \"tcost\"] + df_prices.columns.tolist()\n", " df_result = pd.DataFrame(columns=columns)\n", " for idx, d in enumerate(deltas):\n", " # Update parameter\n", " delta.setValue(d);\n", " \n", " # Solve optimization\n", " M.solve()\n", " \n", " # Check if the solution is an optimal point\n", " solsta = M.getPrimalSolutionStatus()\n", " if (solsta != SolutionStatus.Optimal):\n", " # See https://docs.mosek.com/latest/pythonfusion/accessing-solution.html about handling solution statuses.\n", " raise Exception(\"Unexpected solution status!\") \n", " \n", " # Save results\n", " portfolio_return = m @ x.level()\n", " portfolio_risk = np.sqrt(2 * s.level()[0]) \n", " tcost = np.dot(vp, xp.level()) + np.dot(vm, xm.level()) + np.dot(fp, yp.level()) + np.dot(fm, ym.level())\n", " row = pd.Series([d, M.primalObjValue(), portfolio_return, portfolio_risk, \n", " sum(x.level()), tcost] + list(x.level()), index=columns)\n", " df_result = pd.concat([df_result, pd.DataFrame([row])], ignore_index=True)\n", "\n", " return df_result" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Compute optimization input variables" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we use the loaded daily price data to compute the corresponding yearly mean return and covariance matrix." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# Number of securities\n", "N = df_prices.shape[1] \n", "\n", "# Get optimization parameters\n", "m, S = compute_inputs(df_prices)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next we compute the matrix $G$ such that $\\ECov=GG^\\mathsf{T}$, this is the input of the conic form of the optimization problem. Here we use Cholesky factorization." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# Cholesky factor of S to use in conic risk constraint\n", "G = np.linalg.cholesky(S)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Call the optimizer function" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We run the optimization for a range of risk aversion parameter values: $\\delta = 10^{-0.5},\\dots,10^{2}$. We compute and plot the efficient frontier this way both with and without transaction cost. " ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "scrolled": false }, "outputs": [ { "ename": "NameError", "evalue": "name 'ub' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m/tmp/ipykernel_750993/1625948282.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0mlm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;36m0.05\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m \u001b[0mdf_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEfficientFrontier\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mN\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mG\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdeltas\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mup\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mum\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpcoef\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 15\u001b[0m df_result.plot(ax=ax, x=\"risk\", y=\"return\", style=\"-o\", \n\u001b[1;32m 16\u001b[0m xlabel=\"portfolio risk (std. dev.)\", ylabel=\"portfolio return\", grid=True)\n", "\u001b[0;32m/tmp/ipykernel_750993/576466742.py\u001b[0m in \u001b[0;36mEfficientFrontier\u001b[0;34m(N, m, G, deltas, vp, vm, fp, fm, up, um, lp, lm, pcoef)\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0;31m# Positive and negative part of x\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 40\u001b[0;31m \u001b[0mxp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mym\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mposneg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mM\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mub\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 41\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 42\u001b[0m \u001b[0;31m# Buy-in\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mNameError\u001b[0m: name 'ub' is not defined" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "deltas = np.logspace(start=-0.5, stop=2, num=20)[::-1]\n", "ax = plt.gca()\n", "for a in [0, 1]:\n", " pcoef = a * 0.03\n", " fp = a * 0.005 * np.ones(N) # Depends on portfolio value\n", " fm = a * 0.01 * np.ones(N) # Depends on portfolio value\n", " vp = a * 0.01 * np.ones(N)\n", " vm = a * 0.02 * np.ones(N)\n", " up = 2.0\n", " um = 2.0\n", " lp = a * 0.05\n", " lm = a * 0.05\n", "\n", " df_result = EfficientFrontier(N, m, G, deltas, vp, vm, fp, fm, up, um, lp, lm, pcoef)\n", " df_result.plot(ax=ax, x=\"risk\", y=\"return\", style=\"-o\", \n", " xlabel=\"portfolio risk (std. dev.)\", ylabel=\"portfolio return\", grid=True)\n", "ax.legend([\"return without transaction cost\", \"return with transaction cost\"]);" ] } ], "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.9.7" } }, "nbformat": 4, "nbformat_minor": 2 }