{
"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": 45,
"metadata": {
"scrolled": false
},
"outputs": [],
"source": [
"import os,sys\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": 46,
"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": 47,
"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": 48,
"metadata": {},
"outputs": [],
"source": [
"investment_start = \"2016-03-18\"\n",
"investment_end = \"2021-03-18\""
]
},
{
"cell_type": "code",
"execution_count": 49,
"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": [
"We will solve a fund of funds problem. Suppose there are fund managers optimizing their funds wrt. specific benchmarks, and there is an overall benchmark, against which all funds are optimized together. This can be modeled as the following optimization problem: \n",
"\n",
"$$\n",
" \\begin{array}{lrcl}\n",
" \\mbox{minimize} & (\\mathbf{x}_\\mathrm{o}-\\mathbf{x}_{\\mathrm{bm},\\mathrm{o}})^\\mathsf{T}\\ECov(\\mathbf{x}_{\\mathrm{o}}-\\mathbf{x}_{\\mathrm{bm},\\mathrm{o}}) & &\\\\\n",
" \\mbox{subject to} & \\mathbf{x}_\\mathrm{o} & = & \\sum_i f_i \\mathbf{x}_i\\\\\n",
" & (\\mathbf{x}_i-\\mathbf{x}_{\\mathrm{bm},i})^\\mathsf{T}\\ECov(\\mathbf{x}_{i}-\\mathbf{x}_{\\mathrm{bm},i}) & \\leq &\\sigma_{\\mathrm{max},i}^2\\quad i=1,\\dots,K\\\\\n",
" & \\alpha_i^\\mathsf{T}\\mathbf{x}_i & \\geq & \\alpha_{\\mathrm{min},i}\\quad i=1,\\dots,K\\\\ \n",
" & \\mathbf{1}^\\mathsf{T}\\mathbf{x}_i & = & 1,\\quad i=1,\\dots,K\\\\\n",
" & \\mathbf{x}_i & \\geq & 0,\\quad i=1,\\dots,K\\\\\n",
" \\end{array}\n",
"$$\n",
"\n",
"The objective is the squared tracking error of the overall fund. $\\mathbf{x}_\\mathrm{o}$ is the overall fund portfolio, and $\\mathrm{x}_i$ is the portfolio of fund $i$. Likewise, $\\mathbf{x}_{\\mathrm{bm},\\mathrm{o}}$ is the the overall benchmark, and $\\mathbf{x}_{\\mathrm{bm},i}$ is the benchmark of fund $i$. $f_i$ is the weight of fund $i$, and has to satisfy $f_i\\geq 0$, $\\sum_if_i=1$. $\\sigma_{\\mathrm{max},i}^2$ is the squared tracking error upper bound for fund $i$, and $\\alpha_{\\mathrm{min},i}$ is the portfolio alpha lower bound for fund $i$.\n",
"\n",
"Then we rewrite the above problem into conic form, and implement it in Fusion API:\n",
"\n",
"$$\n",
" \\begin{array}{lrcl}\n",
" \\mbox{minimize} & t_\\mathrm{o} & &\\\\\n",
" \\mbox{subject to} & (t_\\mathrm{o}, 0.5, \\mathbf{G}^\\mathrm{T}(\\mathbf{x}_{\\mathrm{o}}-\\mathbf{x}_{\\mathrm{bm},\\mathrm{o}})) & \\in &\\Q_\\mathrm{r}^{N+2}\\\\\n",
" & \\mathbf{x}_\\mathrm{o} & = & \\sum_i f_i \\mathbf{x}_i\\\\\n",
" & (\\sigma_{\\mathrm{max},i}^2, 0.5, \\mathbf{G}^\\mathrm{T}(\\mathbf{x}_i-\\mathbf{x}_{\\mathrm{bm},i})) & \\in &\\Q_\\mathrm{r}^{N+2},\\quad i=1,\\dots,K\\\\\n",
" & \\alpha_i^\\mathsf{T}\\mathbf{x}_i & \\geq & \\alpha_{\\mathrm{min},i}\\quad i=1,\\dots,K\\\\ \n",
" & \\mathbf{1}^\\mathsf{T}\\mathbf{x}_i & = & 1,\\quad i=1,\\dots,K\\\\\n",
" & \\mathbf{x}_i & \\geq & 0,\\quad i=1,\\dots,K\\\\\n",
" \\end{array}\n",
"$$\n",
"\n",
"We create it inside a function so we can call it later.\n",
"\n",
"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",
"- `a`: The vectors of alphas for each fund.\n",
"- `ao`: The vector of alphas for the overall fund.\n",
"- `a_min`: The minimum required portfolio alpha for each fund.\n",
"- `s2_max`: The maximum tracking error for each fund.\n",
"- `f`: The weigth of each fund portfolio in the overall portfolio.\n",
"- `xobm`: The overall benchmark portfolio.\n",
"- `XFbm`: The benchmark portfolio for each fund."
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {},
"outputs": [],
"source": [
"def EfficientFrontier(N, K, a, ao, a_min, s2_max, G, f, xobm, Xfbm):\n",
"\n",
" with Model(\"Case study\") as M:\n",
" # Settings\n",
" #M.setLogHandler(sys.stdout)\n",
" \n",
" # Variables \n",
" # The variable x is the fraction of holdings in each security. \n",
" # It is restricted to be positive, which imposes the constraint of no short-selling. \n",
" xo = M.variable(\"xo\", N, Domain.greaterThan(0.0))\n",
" Xf = M.variable(\"Xf\", [N, K], Domain.greaterThan(0.0))\n",
" \n",
" # Active holdings\n",
" xoa = Expr.sub(xo, xobm)\n",
" Xfa = Expr.sub(Xf, Xfbm) \n",
" \n",
" # The variable teo models the overall tracking error in the objective.\n",
" te2o = M.variable(\"teo\", 1, Domain.unbounded())\n",
" \n",
" # Relate overall portfolio to fund portfolios\n",
" M.constraint(\"combine\", Expr.sub(xo, Expr.mul(Xf, f)), Domain.equalsTo(0.0))\n",
" \n",
" # Budget constraint for each fund\n",
" M.constraint('budget_f', Expr.sum(Xf, 0), Domain.equalsTo(np.ones(K)))\n",
" \n",
" # Conic constraint for the fund sq. tracking errors\n",
" sigma2 = M.parameter()\n",
" for i in range(K):\n",
" idx = [[j, i] for j in range(N)]\n",
" M.constraint(f'fund_te2_{i}', Expr.vstack(sigma2, 0.5, Expr.mul(G.T, Xfa.pick(idx))), Domain.inRotatedQCone())\n",
" \n",
" # Conic constraint for the overall sq. tracking error\n",
" M.constraint('overall_te2', Expr.vstack(te2o, 0.5, Expr.mul(G.T, xoa)), Domain.inRotatedQCone())\n",
" \n",
" # Alpha constraint for each fund.\n",
" for i in range(K):\n",
" idx = [[j, i] for j in range(N)]\n",
" M.constraint(f'fund_alpha_{i}', Expr.dot(a[:, i], Xf.pick(idx)), Domain.greaterThan(a_min[i]))\n",
" \n",
" # Objective\n",
" M.objective('obj', ObjectiveSense.Minimize, te2o)\n",
" \n",
" # Create DataFrame to store the results. Last security name (the SPY ETF) is removed.\n",
" columns = [\"s2\", \"obj\", \"return\", \"te_o\", \"te_1\", \"te_2\"] + df_prices.columns[:-1].tolist()\n",
" df_result = pd.DataFrame(columns=columns)\n",
" for s2 in s2_max:\n",
" # Update parameter\n",
" sigma2.setValue(s2) \n",
" \n",
" # Solve optimization\n",
" M.solve()\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 = ao @ xo.level()\n",
" overall_te2 = te2o.level()[0]\n",
" r1 = G.T @ (Xf.level().reshape(N, K)[:, 0] - Xfbm[:, 0])\n",
" fund_te2_1 = np.dot(r1, r1)\n",
" r2 = G.T @ (Xf.level().reshape(N, K)[:, 1] - Xfbm[:, 1])\n",
" fund_te2_2 = np.dot(r2, r2)\n",
" row = pd.Series([s2, M.primalObjValue(), portfolio_return, overall_te2, fund_te2_1, fund_te2_2] + list(xo.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": [
"## Define the factor model"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here we define a function that computes the factor model\n",
"$$\n",
"R_t = \\alpha + \\beta R_{F,t} + \\varepsilon_t.\n",
"$$\n",
"It can handle any number of factors, and returns estimates $\\EBeta$, $\\ECov_F$, and $\\ECov_\\theta$. The factors are assumed to be at the last coordinates of the data. \n",
"\n",
"The input of the function is the expected return and covariance of yearly logarithmic returns. The reason is that it is easier to generate logarithmic return scenarios from normal distribution instead of generating linear return scenarios from lognormal distribution. "
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {},
"outputs": [],
"source": [
"def factor_model(m_log, S_log, factor_num):\n",
" \"\"\"\n",
" It is assumed that the last factor_num coordinates correspond to the factors.\n",
" \"\"\"\n",
" if factor_num < 1: \n",
" raise Exception(\"Does not make sense to compute a factor model without factors!\")\n",
" \n",
" # Generate logarithmic return scenarios\n",
" scenarios_log = np.random.default_rng().multivariate_normal(m_log, S_log, 100000)\n",
" \n",
" # Convert logarithmic return scenarios to linear return scenarios \n",
" scenarios_lin = np.exp(scenarios_log) - 1\n",
" \n",
" # Do linear regression \n",
" params = []\n",
" resid = []\n",
" X = scenarios_lin[:, -factor_num:]\n",
" X = sm.add_constant(X, prepend=False)\n",
" \n",
" for k in range(N):\n",
" y = scenarios_lin[:, k]\n",
" model = sm.OLS(y, X, hasconst=True).fit()\n",
" resid.append(model.resid)\n",
" params.append(model.params)\n",
" resid = np.array(resid)\n",
" params = np.array(params)\n",
" \n",
" # Get parameter estimates\n",
" a = params[:, 1]\n",
" B = params[:, 0:factor_num]\n",
" S_F = np.atleast_2d(np.cov(X[:, 0:factor_num].T))\n",
" S_theta = np.cov(resid)\n",
" S_theta = np.diag(np.diag(S_theta))\n",
" \n",
" return a, B, S_F, S_theta "
]
},
{
"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": 52,
"metadata": {},
"outputs": [],
"source": [
"# Number of securities (We subtract fnum to account for factors at the end of the price data)\n",
"N = 8\n",
"K = 2\n",
"\n",
"# Get optimization parameters\n",
"m, S = compute_inputs(df_prices, security_num=N)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We also create three benchmarks, one for each fund, and an overall benchmark."
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {},
"outputs": [],
"source": [
"# Create benchmarks\n",
"# - Benchmark for fund 1 \n",
"w1 = np.diag(S)\n",
"w1 = w1 / sum(w1)\n",
"bm_1 = df_prices.iloc[:-2, 0:8].dot(w1)\n",
"\n",
"# - Benchmark for fund 2\n",
"w2 = np.diag(S)**2\n",
"w2 = w2 / sum(w2)\n",
"bm_2 = df_prices.iloc[:-2, 0:8].dot(w2)\n",
"\n",
"# - Overall benchmark\n",
"wo = (1.0 / np.diag(S))\n",
"wo = wo / sum(wo)\n",
"bm_o = df_prices.iloc[:-2, 0:8].dot(wo)"
]
},
{
"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": 54,
"metadata": {},
"outputs": [],
"source": [
"G = np.linalg.cholesky(S) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we compute the estimates $\\EAlpha$ and $\\EBeta$ using the factor model, for each benchmark. First we compute logarithmic return statistics and use them to compute the factor exposures and covariances. "
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {},
"outputs": [],
"source": [
"df_prices['bm'] = bm_1\n",
"m_log, S_log = compute_inputs(df_prices, return_log=True)\n",
"a_1, _, _, _ = factor_model(m_log, S_log, 1)\n",
"\n",
"df_prices['bm'] = bm_2\n",
"m_log, S_log = compute_inputs(df_prices, return_log=True)\n",
"a_2, _, _, _ = factor_model(m_log, S_log, 1)\n",
"\n",
"df_prices['bm'] = bm_o\n",
"m_log, S_log = compute_inputs(df_prices, return_log=True)\n",
"a_3, _, _, _ = factor_model(m_log, S_log, 1)\n",
"\n",
"a = np.vstack([a_1, a_2]).T\n",
"ao = a_3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Also define the benchmark weights for the funds, and the overall benchmark."
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {},
"outputs": [],
"source": [
"Xfbm = np.vstack([w1, w2]).T\n",
"xobm = wo\n",
"\n",
"# Fund weights\n",
"f = [0.5, 0.5]\n",
"\n",
"# Alpha lower bounds\n",
"a_min = [0.05, 0.05]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Call the optimizer function"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We run the optimization for a range of tracking error limits."
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {
"scrolled": false
},
"outputs": [],
"source": [
"# Tracking error upper bounds (in percent)\n",
"s2_max = np.linspace(start=1, stop=0.1, num=10) / 100\n",
"\n",
"df_result = EfficientFrontier(N, K, a, ao, a_min, s2_max, G, f, xobm, Xfbm)\n",
"mask = df_result < 0\n",
"mask.iloc[:, :2] = False\n",
"df_result[mask] = 0"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Visualize the results"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Plot the squared tracking errors of the funds in function of the tracking error limit. "
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" s2 \n",
" obj \n",
" return \n",
" te_o \n",
" te_1 \n",
" te_2 \n",
" PM \n",
" LMT \n",
" MCD \n",
" MMM \n",
" AAPL \n",
" MSFT \n",
" TXN \n",
" CSCO \n",
" \n",
" \n",
" \n",
" \n",
" 0 \n",
" 0.010 \n",
" 0.001884 \n",
" 0.093003 \n",
" 0.001884 \n",
" 0.003703 \n",
" 0.010 \n",
" 0.044036 \n",
" 0.102734 \n",
" 0.192379 \n",
" 0.062397 \n",
" 0.078985 \n",
" 0.228180 \n",
" 0.165808 \n",
" 0.125481 \n",
" \n",
" \n",
" 1 \n",
" 0.009 \n",
" 0.001916 \n",
" 0.093437 \n",
" 0.001916 \n",
" 0.004370 \n",
" 0.009 \n",
" 0.043458 \n",
" 0.102432 \n",
" 0.192544 \n",
" 0.061605 \n",
" 0.079146 \n",
" 0.229107 \n",
" 0.166272 \n",
" 0.125436 \n",
" \n",
" \n",
" 2 \n",
" 0.008 \n",
" 0.001951 \n",
" 0.093898 \n",
" 0.001951 \n",
" 0.005142 \n",
" 0.008 \n",
" 0.042831 \n",
" 0.102125 \n",
" 0.192737 \n",
" 0.060755 \n",
" 0.079310 \n",
" 0.230093 \n",
" 0.166765 \n",
" 0.125385 \n",
" \n",
" \n",
" 3 \n",
" 0.007 \n",
" 0.001988 \n",
" 0.094410 \n",
" 0.001988 \n",
" 0.005931 \n",
" 0.007 \n",
" 0.042075 \n",
" 0.101833 \n",
" 0.192939 \n",
" 0.059923 \n",
" 0.080024 \n",
" 0.230799 \n",
" 0.167092 \n",
" 0.125316 \n",
" \n",
" \n",
" 4 \n",
" 0.006 \n",
" 0.002036 \n",
" 0.095282 \n",
" 0.002036 \n",
" 0.006000 \n",
" 0.006 \n",
" 0.043524 \n",
" 0.101328 \n",
" 0.189254 \n",
" 0.059700 \n",
" 0.087500 \n",
" 0.228238 \n",
" 0.166165 \n",
" 0.124293 \n",
" \n",
" \n",
" 5 \n",
" 0.005 \n",
" 0.002160 \n",
" 0.096745 \n",
" 0.002160 \n",
" 0.005000 \n",
" 0.005 \n",
" 0.049023 \n",
" 0.100206 \n",
" 0.179244 \n",
" 0.060148 \n",
" 0.106671 \n",
" 0.219698 \n",
" 0.163110 \n",
" 0.121901 \n",
" \n",
" \n",
" 6 \n",
" 0.004 \n",
" 0.002404 \n",
" 0.098373 \n",
" 0.002404 \n",
" 0.004000 \n",
" 0.004 \n",
" 0.055574 \n",
" 0.098766 \n",
" 0.167765 \n",
" 0.060563 \n",
" 0.128138 \n",
" 0.210113 \n",
" 0.159798 \n",
" 0.119282 \n",
" \n",
" \n",
" 7 \n",
" 0.003 \n",
" 0.002817 \n",
" 0.100223 \n",
" 0.002817 \n",
" 0.003000 \n",
" 0.003 \n",
" 0.063121 \n",
" 0.097105 \n",
" 0.154651 \n",
" 0.061002 \n",
" 0.152573 \n",
" 0.199199 \n",
" 0.156054 \n",
" 0.116295 \n",
" \n",
" \n",
" 8 \n",
" 0.002 \n",
" 0.003497 \n",
" 0.102425 \n",
" 0.003497 \n",
" 0.002000 \n",
" 0.002 \n",
" 0.072137 \n",
" 0.095111 \n",
" 0.139027 \n",
" 0.061510 \n",
" 0.181652 \n",
" 0.186214 \n",
" 0.151607 \n",
" 0.112742 \n",
" \n",
" \n",
" 9 \n",
" 0.001 \n",
" 0.004704 \n",
" 0.105326 \n",
" 0.004704 \n",
" 0.001000 \n",
" 0.001 \n",
" 0.083985 \n",
" 0.092474 \n",
" 0.118496 \n",
" 0.062154 \n",
" 0.219865 \n",
" 0.169160 \n",
" 0.145778 \n",
" 0.108087 \n",
" \n",
" \n",
"
\n",
"
"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"# Efficient frontier\n",
"ax = df_result.plot(x=\"s2\", y=\"te_o\", style=\"-o\", xlabel=\"risk limit\", ylabel=\"portfolio tracking error\", grid=True)\n",
"df_result.plot(ax=ax, x=\"s2\", y=\"te_1\", style=\"-o\", xlabel=\"risk limit\", ylabel=\"portfolio tracking error\", grid=True) \n",
"df_result.plot(ax=ax, x=\"s2\", y=\"te_2\", style=\"-o\", xlabel=\"risk limit\", ylabel=\"portfolio tracking error\", grid=True)\n",
"ax.legend([\"overall portfolio\", \"fund 1\", \"fund_2\"]);"
]
}
],
"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
}