Markowitz__vs_BL.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Markowitz _vs_BL",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "<img src=\"https://www.bpmfinancial.com/images/bpm/slide_01-man.jpg\" width=\"550px\" align=\"right\">"
      ],
      "metadata": {
        "id": "fQP9AnC021FB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "\n",
        "# Markowitz vs. Black-Litterman Model: 2-Asset Allocation\n",
        "\n",
        "\n",
        "Luc C. Smith\n",
        "\n",
        "---\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "cEhM1bXY21qB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Summary & Methods:\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "Markowitz's Modern Portfolio Theory became one of the great foundations of portfolio optimization and asset allocation. After it, extensions came along to enhance its ideas and cover some of the issues, giving way to such as the Black-Litterman model. These two are still consistently used throughout the financial sector for asset allocation, so a simple example is to be done comparing them with two assets only. The two assets will be Tesla and Coca-Cola's stocks, for one is extremely volatile with high returns while the other isn't so much, which will exemplify the models well. A simple minimum volatility optimization is to be done to exemplify Markowitz's Modern Portfolio Theory in contrast with Meucci's implementation of the Black-Litterman model with Idzorek's weight formula. The minimum volatility optimizer and the Black-Litterman model are done from scratch. \n",
        "\n"
      ],
      "metadata": {
        "id": "D6Vl7RJx5X9w"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Markowitz's Modern Portfolio Theory:\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "American economist Harry Markowitz came up with the Modern Portfolio Theory in 1952, for which he was awarded a Nobel Prize. His theory emphasizes diversification and aims to find an optimized allocation of capital between assets. With this, this method constructs portfolios diversifying the allocation to maximize returns for certain levels of risk, creating an efficient frontier of portfolios with optimal weights for specific levels of risk and return. Risk is measured as volatility here, which is the standard deviation stemed from the variance of the returns of the portfolio's assets and the covariance between them. These ideas bring the key component of Markowitz's theory of diversification, for they aim to highlight how an asset shouldn't only be viewed individually but in how they affect the overall portfolio instead. When assets have inverse relationships in their price movements, the more they are able to diversify the portfolio since one isn't dependent on the other. Ultimatelly, Modern Portfolio Theory allows investors to construct more efficient portfolios. Even though there are a few variations of it, the simplest form is implemented here to minimize volatility only.\n",
        "- **Minimize(volatility)** \n",
        "- **Volatility = square_root((w.T)(Cov)(w))**\n",
        "  - *w.T: transpose of weights of assets.*\n",
        "  - *Cov: covariance matrix showing correlation/relationship between assets.*\n",
        "  - *w: weights of assets.*   "
      ],
      "metadata": {
        "id": "tveSV21d5YVF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## The Black-Litterman Model:\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "7Q4h0uk-5YXh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Even though Markowitz's Modern Portfolio Theory became so prominent, it still has its issues. A few of them is that it can generate highly concentrated portfolios as some assets may have much bigger returns and volatility as well. With this, small changes in the returns measure also poses great sensitivity to the allocation, so huge weights can be attained towards one or two assets, which defeats the idea of diversification since the capital is not being spread out more. Furthermore, only returns and volatility are taken into consideration from a historical approach, and many investors may have their own opinions and ideas about assets and their future performances. As a result of these issues, extensions have been made to the method. Fischer Black and Robert Litterman created the Black-Litterman model at Goldman Sachs in 1990 to respond to these issues and give the ability for investors to use their views in the asset allocation method. This model begins with the market capitalization weights of assets as the portfolio and uses investor views on how they will perform in the future to optimize the return and risk metrics, producing new returns and a new covariance matrix to be used in the optimization part through the mean-variance objective function (Markowitz). Essentially, Black-Litterman adds the investor views to the Markowitz optimization function. Here, Meucci's implementation is to be used as he found more stable equations that are mathematically equal to the original ones. Here are the steps and equations for each part:\n",
        "- **Step 1**: Market Cap. Weights: just retrieve market capitalization of assets and divide each by the total.\n",
        "- **Step 2**: Estimate the initial covariance matrix (S) from the returns.\n",
        " - Here, simple Python \"cov()\" method is used.\n",
        "- **Step 3**: Calculate the implied equilibrium excess returns (pi) to attain the market returns of the assets:\n",
        "  - *pi = 2(A)(S)(market cap weights)*\n",
        "  - *A: risk-aversion*\n",
        "- **Step 4**: set the views vector (Q) for each investor view.\n",
        "- **Step 5**: set the link matrix (P) to align the views to the specific assets.\n",
        "  - This matrix has the number of views as the number of rows and columns being equal to the number of assets.\n",
        "- **Step 6**: scalar tau, standardizer c, and the uncertainty of views matrix (omega):\n",
        "  - *tau = 1 / length of time series*\n",
        "  - *c = 1 as default* \n",
        "  - *omega = [ (P)(S)(P.T) ] / c*\n",
        "- **Step 7**: Calculate the posterior/Black-Litterman returns (optimized returns):\n",
        "  -  *post_returns = pi + (tau)(S)(P^T) x (tau)(P)(S)(P^T) + omega)^-1 x (Q - (P)(pi))*\n",
        "- **Step 8**: Calculate the posterior/Black-Litterman covariance matrix (optimized matrix):\n",
        "  -  *post_S = (1+tau)(S) - (tau^2)(S)(P.T) x ((tau)(P)(S)(P.T) + omega)^-1 x (P)(S)*\n",
        "- **Step 9**: Make sure the posterior covariance is symmetric by summing it with its transpose and dividing by 2 and than making sure it is strictly positive semi-definite, which is needed for the optimization to work.\n",
        "  - Here, a package is used to do this.\n",
        "- **Step 10**: calculate the posterior weights:\n",
        "  - *posterior_w = post_returns(A)(post_S)^-1*\n"
      ],
      "metadata": {
        "id": "YkpOYE8_FRWx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Tools of Implementation: Python\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "A prominent idea being tied to asset allocation is automation, so Python is a great tool for this being one of the most popular analytics and finance related programming languages. It contains many useful packages for these types of uses while also being free. Here, an algorithm is built to implement the two models described above with the following Python packages:\n",
        "- **NumPy**: mathematical and vectorized tools (vector/matrix calculations).\n",
        "- **Pandas**: data manipulation and tabular analytics.\n",
        "- **Matplotlib**: visualization tools.\n",
        "- **Pandas-datareader**: data gathering of stock prices.\n",
        "- **cov_nearest**: statistical modelling tool to make sure posterior covariance is strictly positive semi-definite for optimization."
      ],
      "metadata": {
        "id": "9ckT20vcgxAy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Implementation:\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "ka4CAEJFiAH4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- Before coding the implementation, the necessary packages named previously need to be imported:"
      ],
      "metadata": {
        "id": "kYjVqZ9CjHYb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Necessary Packages:\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas_datareader.data as web\n",
        "from statsmodels.stats.correlation_tools import cov_nearest"
      ],
      "metadata": {
        "id": "rc8EM9DajHtj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "07842ebe-d5d8-473e-b101-dabe0861be56"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
            "  import pandas.util.testing as tm\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "- Now, the data can be gathered using pandas-datareader for more than 3 years. Only the closing prices are needed:"
      ],
      "metadata": {
        "id": "D_DHbP6rjH4-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Gather closing prices for TSLA and KO stocks:\n",
        "stocks = ['TSLA', 'KO']\n",
        "data = web.DataReader(stocks, start='2018-01-01', end='2021-10-27', data_source='stooq').Close\n",
        "data.head()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 237
        },
        "id": "pYJZSXE9jIFr",
        "outputId": "677e6c56-dea5-461d-a218-44a2f8fb8a15"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "\n",
              "  <div id=\"df-889ae7a9-f1d2-41ba-aa50-563d26a09602\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th>Symbols</th>\n",
              "      <th>TSLA</th>\n",
              "      <th>KO</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Date</th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>2021-10-27</th>\n",
              "      <td>1037.86</td>\n",
              "      <td>55.52</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2021-10-26</th>\n",
              "      <td>1018.43</td>\n",
              "      <td>54.47</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2021-10-25</th>\n",
              "      <td>1024.86</td>\n",
              "      <td>54.23</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2021-10-22</th>\n",
              "      <td>909.68</td>\n",
              "      <td>54.45</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2021-10-21</th>\n",
              "      <td>894.00</td>\n",
              "      <td>54.35</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-889ae7a9-f1d2-41ba-aa50-563d26a09602')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-889ae7a9-f1d2-41ba-aa50-563d26a09602 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-889ae7a9-f1d2-41ba-aa50-563d26a09602');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ],
            "text/plain": [
              "Symbols        TSLA     KO\n",
              "Date                      \n",
              "2021-10-27  1037.86  55.52\n",
              "2021-10-26  1018.43  54.47\n",
              "2021-10-25  1024.86  54.23\n",
              "2021-10-22   909.68  54.45\n",
              "2021-10-21   894.00  54.35"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "- With this, the yearly return and the covariance matrix can now be calculated with simple Pandas functions:"
      ],
      "metadata": {
        "id": "UjtwETBRjIRC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Calculate yearly returns and covariance matrix:\n",
        "yearly_ret = data.resample('Y').last().pct_change().mean()  #Average yearly returns\n",
        "cov = data.pct_change().cov()\n",
        "print('Yearly Returns: \\n' + str(yearly_ret))\n",
        "print('\\nCovariance Matrix:\\n' + str(cov))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9GqglQtDjIbc",
        "outputId": "0353e776-35eb-4b1c-9f6d-69e1b91e71eb"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Yearly Returns: \n",
            "Symbols\n",
            "TSLA    2.720705\n",
            "KO      0.088992\n",
            "dtype: float64\n",
            "\n",
            "Covariance Matrix:\n",
            "Symbols      TSLA        KO\n",
            "Symbols                    \n",
            "TSLA     0.001682  0.000128\n",
            "KO       0.000128  0.000201\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "- Now, the minimum volatility portfolio can be found by simply looping through all possible weights between the two, which will be 100 different ones as the weights will start at 0 and end at 1. Here, a loop is done for this making Tesla's weight go from 0 to 1 by 0.01 increments and adding the weights, returns, and volatilities to empty lists, which then later get placed into a dictionary to be placed directly into a Pandas dataframe. Pandas dataframes have methods to easily find a specific row by a criterion, which here will be the minimum volatility. Matrices and vectors can easily be multiplied by NumPy's vectorized operations such as np.dot, so the variance can easily be calculated as such. "
      ],
      "metadata": {
        "id": "CviUc5sEjIlj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Empty lists to store weights, returns, and volatilities of portfolios made:\n",
        "weights = []\n",
        "returns = []\n",
        "vols = []\n",
        "\n",
        "tesla_w = 0   #TSLA initial weight\n",
        "\n",
        "#Loop to calculate each portfolio with 100 different weights for TSLA:\n",
        "for i in range(101):\n",
        "  #Weights calculation:\n",
        "  coke_w = 1 - tesla_w              #Find coke's weight given TSLA's\n",
        "  w = np.array([tesla_w, coke_w])   #groups the two weights as one \n",
        "  weights.append(w)                 #Adds the two into list\n",
        "  tesla_w += 0.01                   #Increase tesla weight each iteration by 0.01\n",
        "\n",
        "  #Returns:\n",
        "  ret = np.dot(w, yearly_ret)       #Weighted sum between returns and weights\n",
        "  returns.append(ret)               #Add it to the list\n",
        "\n",
        "  #Volatility:\n",
        "  var = np.dot(w.T, np.dot(cov, w))        #w.T*Cov*w as shown previously\n",
        "  yearly_vol = np.sqrt(var)*np.sqrt(252)   #Standard deviation is volatility\n",
        "  vols.append(yearly_vol)\n",
        "\n",
        "#Putting made lists into a dictionary:\n",
        "port = {'Returns': returns, 'Volatility':vols}\n",
        "\n",
        "#Placing weights into dictionary made with a list comprehension:\n",
        "for counter, symbol in enumerate(data.columns.tolist()):\n",
        "  port[symbol + '_Weight'] = [weight[counter] for weight in weights]\n",
        "\n",
        "#Make a dataframe from the dictionary buil:\n",
        "port_df = pd.DataFrame(port)\n",
        "port_df.head()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "0DRDe3JwjIwm",
        "outputId": "e86f8c1f-3bcf-484b-de67-cd08f3667d3b"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "\n",
              "  <div id=\"df-33fba4b9-9bbe-4bef-9d1f-3df526f6a82e\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Returns</th>\n",
              "      <th>Volatility</th>\n",
              "      <th>TSLA_Weight</th>\n",
              "      <th>KO_Weight</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0.088992</td>\n",
              "      <td>0.225079</td>\n",
              "      <td>0.00</td>\n",
              "      <td>1.00</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>0.115309</td>\n",
              "      <td>0.224347</td>\n",
              "      <td>0.01</td>\n",
              "      <td>0.99</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>0.141626</td>\n",
              "      <td>0.223796</td>\n",
              "      <td>0.02</td>\n",
              "      <td>0.98</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>0.167943</td>\n",
              "      <td>0.223427</td>\n",
              "      <td>0.03</td>\n",
              "      <td>0.97</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>0.194260</td>\n",
              "      <td>0.223241</td>\n",
              "      <td>0.04</td>\n",
              "      <td>0.96</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-33fba4b9-9bbe-4bef-9d1f-3df526f6a82e')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-33fba4b9-9bbe-4bef-9d1f-3df526f6a82e button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-33fba4b9-9bbe-4bef-9d1f-3df526f6a82e');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ],
            "text/plain": [
              "    Returns  Volatility  TSLA_Weight  KO_Weight\n",
              "0  0.088992    0.225079         0.00       1.00\n",
              "1  0.115309    0.224347         0.01       0.99\n",
              "2  0.141626    0.223796         0.02       0.98\n",
              "3  0.167943    0.223427         0.03       0.97\n",
              "4  0.194260    0.223241         0.04       0.96"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "- As it can be seen, as Tesla's weight increases, so does the returns. More interestingly, the volatility actually decreases first even though Tesla is much more volatile. This highlights Markowitz's Modern Portfolio Theory as it shows how placing all of the allocation into the least risky asset is actually not the least risky allocation, for diversification can actually reduce risk even more due to correlation differences among assets. Now, the minimum volatility portfolio can be found with Pandas and plotted against all of the other 99 portfolios made to see a visual representation:\n"
      ],
      "metadata": {
        "id": "eCzES-9GrIQM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Minimum Volatility Portfolio:\n",
        "min_vol = port_df.iloc[port_df.Volatility.idxmin()]\n",
        "print('Min. Vol. Portfolio:\\n' + str(min_vol))"
      ],
      "metadata": {
        "id": "IpnQtZWKt56E",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "210ee39a-9d73-43ad-b709-c8ce4728ccc9"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Min. Vol. Portfolio:\n",
            "Returns        0.220577\n",
            "Volatility     0.223240\n",
            "TSLA_Weight    0.050000\n",
            "KO_Weight      0.950000\n",
            "Name: 5, dtype: float64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "- As seen, and as expected, the minimum volatility portfolio allocates the vast majority towards Coca-Cola's stock as it is less risky. Here is a visual representation using Matplotlib, where the minimum volatility portfolio is the yellow star:\n",
        "\n"
      ],
      "metadata": {
        "id": "CIzGeccNuzhQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Plot Tesla Weight vs. Volatility\n",
        "plt.subplots(figsize=(10,8))\n",
        "plt.title('Tesla Weight vs Port. Volatility', fontsize=20)\n",
        "plt.xlabel('Tesla Weight', fontsize=15)\n",
        "plt.ylabel('Volatility', fontsize=15)\n",
        "plt.scatter(port_df.TSLA_Weight, port_df.Volatility, s=5)\n",
        "plt.scatter(min_vol[2], min_vol[1], s=350, color = 'y', marker = '*')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 522
        },
        "id": "mhhxMNJpvHd5",
        "outputId": "2504f188-f195-48c4-ee0a-bfd35c08ad49"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "- With the first method done, the Black-Litterman model can now be constructed and implemented. As stated, the market capitalization weights first need to be calculated. Pandas-datareader once again help in the data gathering:"
      ],
      "metadata": {
        "id": "LzPZAtfXvoQP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Market Cap. Weights:\n",
        "mcs = web.get_quote_yahoo(stocks)['marketCap'].values    #Geta market caps of each as np array\n",
        "mcs_w = mcs / mcs.sum()    #NumPy lets us do vectorized operation\n",
        "mcs_w"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "580qxmQsv9lD",
        "outputId": "bfca0200-88b8-4e45-bb84-9f5867e59a0e"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.77908741, 0.22091259])"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "- Now, the risk-aversion (A) parameter can be set (Meucci uses 1.2 as default) and the S can be set to equal the covariance matrix previously calculated:"
      ],
      "metadata": {
        "id": "8ry_cVo5N839"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Risk-Aversion and Covariance Matrix (S):\n",
        "A = 1.2\n",
        "S = cov"
      ],
      "metadata": {
        "id": "2QNGpxBdOa_2"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- The next step is to calculate the implied equilibrium excess returns with the covariance, risk-aversion, and market cap. weights. Np.dot lets us do a dot product between vectors and matrices:\n"
      ],
      "metadata": {
        "id": "tH8FmpvLOgpl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Implied Equilibrium Excess Returns (pi):\n",
        "    #pi = 2A*S*w\n",
        "pi = 2.0*A*np.dot(S, mcs_w)   \n",
        "pi"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s6byZSHtWHVJ",
        "outputId": "5b914445-2f4f-497d-a406-51bc5c86e1b0"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.00321326, 0.00034518])"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "- There are only a few more needed variables for the model. Without an investor's views, this would just be the market portfolio as calculated with the market cap. weights, so a sample investor view is needed. Views can be either absolute such as \"Tesla will go up by 10%\" or relative such as \"Tesla will outperform Coca-Cola by 10%.\" Relative views are more prominent among the industry, so this will be used here as the second example just named. The link matrix follows, with 1 as the asset with the positive view, Tesla, and -1 as the asset with the negative view, Coca-Cola. c, tau, and omega will also be done in the next cell with the respective Meucci formulas:"
      ],
      "metadata": {
        "id": "ZymyRVxWWiYc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Views (Q): Tesla will outperform coca cola by 10% \n",
        "Q = np.array([0.5])\n",
        "\n",
        "#Link Matrix (P): 1 for positive viewed asset and -1 for negatively viewed asset\n",
        "P = np.array([1, -1])\n",
        "\n",
        "#Scalar (tau), c, and Uncertainty of views matrix (omega):\n",
        "    #tau = 1 / length of time series \n",
        "    #c = 1 as default\n",
        "    #omega = 1/c*P*S*P^T \n",
        "c = 1  \n",
        "tau = 1/float(len(data))\n",
        "omega = (1/c) * np.dot(np.dot(P, S), P.T) \n",
        "omega"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4_enK9r8X9oQ",
        "outputId": "ca0b6cc6-0179-4431-dc91-70926a08f787"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.0016281440954906779"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "- The Black-Litterman main formulas enhanced by Meucci can now be used to calculate the posterior returns and covariance matrix needed to be used in the formula for the weights' generation. The covariance matris can then be sumed with its transpose and divided by 2 to ensure it is symmetric to then use the statistical model cov_nearest to ensure it is strictly positive semi-definite, which is needed for some optimization tools to not receive errors:"
      ],
      "metadata": {
        "id": "SyHM4kttYuMD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#BL Excess Return:\n",
        "    # = pi + tau*S*P^T * (tau*P*S*P^T + omega)^-1 * (Q - P*pi)\n",
        "bl_returns = pi + (np.dot(tau*np.dot(S, P.T), \n",
        "             (tau*np.dot(np.dot(P, S), P.T) + omega)**-1) * (Q - np.dot(P, pi)))\n",
        "\n",
        "#BL Covariance Matrix:\n",
        "    # = (1+tau)*S - tau^2*S*P.T * (tau*P*S*P.T + omega)^-1 * P*S\n",
        "bl_S = (1+tau)*S - np.dot(np.dot(tau**2*np.dot(S, P.T), \n",
        "        (np.dot(tau*np.dot(P, S), P.T) + omega)**-1), np.dot(P, S))\n",
        "\n",
        "sym_S = (bl_S + bl_S.T) / 2      #Make it symmetric\n",
        "semidef_S = cov_nearest(sym_S)   #Make it strict positive semi-definite\n",
        "\n",
        "bl_returns, semidef_S"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "whsolvNfZFBY",
        "outputId": "a0c2f8da-03aa-48c1-944d-14fd2cbbb011"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([0.0037057 , 0.00032192]), array([[0.00168406, 0.00012773],\n",
              "        [0.00012773, 0.00020124]]))"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "- With all the components prepared, the weights can be generated with the formula named in Idzorek's paper, using the new returns and new covariance matrix:"
      ],
      "metadata": {
        "id": "CCW3JQQFaBy9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#BL Posterior Weights:\n",
        "    # w' = postRet * (A*postS)^-1\n",
        "post_W = np.dot(bl_returns, np.linalg.inv(A*semidef_S))     \n",
        "post_W = post_W / post_W.sum()   \n",
        "\n",
        "#Printing BL Weights:\n",
        "print('\\nB-L Adjusted Portfolio Weights:')\n",
        "print('Tesla: ' + str(round(post_W[0], 2)))\n",
        "print('Coca-Cola: ' + str(round(post_W[1],2)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XCfqLQsDcxDo",
        "outputId": "f901ced3-af4d-4e7b-90d1-2985c5909310"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "B-L Adjusted Portfolio Weights:\n",
            "Tesla: 0.91\n",
            "Coca-Cola: 0.09\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "- Finally, a bar graph can be made to compare the two methods implemented here for a visual perspective. This can simply be done by placing both set of weights into a Pandas dataframe with the columns as the stock names and the index as the method used. Pandas dataframes have a plotting method connected to matplotlib:"
      ],
      "metadata": {
        "id": "FWJcldTWdCv5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Setting weights to respective lists:\n",
        "mark_ws = [min_vol[2], min_vol[3]]\n",
        "bl_ws = post_W\n",
        "\n",
        "#Placing weights into dataframe:\n",
        "frame = pd.DataFrame([mark_ws, bl_ws],\n",
        "                     columns = stocks,\n",
        "                     index = ['Min. Vol. Weights', 'B-L Weights'])\n",
        "\n",
        "frame.T.plot(kind='bar', figsize=(12,8))  #Plotting the dataframe as a bar chart\n",
        "plt.legend(fontsize=15)                   #Increasing legend fontsize"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 516
        },
        "id": "XYNli2B_d_zo",
        "outputId": "c8ac33c3-acfc-4d9f-bdef-59cda3b913b0"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7fd50fdc7210>"
            ]
          },
          "metadata": {},
          "execution_count": 20
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "- With the above results, it can easily be seen how the weights changed with each method. It makes sense as well, for the first method aimed for the portfolio with the least amount of risk. Tesla is obviously the riskiest asset here out of the two by far, for it contains great amounts of volatility due to high price movements. However, in the Black-Litterman method, the investor's views are included. The views used favored Tesla's stock over Coca-cola's, meaning the investor saw higher potential for Tesla's stock over Coca-cola's. As seen, the Black-Litterman method resulted in Tesla having a much higher weight, being the opposite of the first method and making sense with the given information."
      ],
      "metadata": {
        "id": "v2FBKg1te41o"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Conclusion:\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "It is clear that the use of technological tools such as Python can be extremely helpful in implementing useful methods of asset allocation. These popular methods also prove to make sense towards their desired goals, for the weights generated followed the logic behind the information given. With this, it can easily be seen through this simple 2-asset example on how each one works and differs from the other. The Black-Litterman model surely provides greater flexibility and ability to include forward-looking returns according to an investor's opinion and even forecasting technique, which may prove to be of better use as returns don't necessarily follow historical data only."
      ],
      "metadata": {
        "id": "O-8u6BKBf9fe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# References:\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "- A STEP-BY-STEP GUIDE TO THE BLACK-LITTERMAN MODEL: Incorporating user-specified confidence levels (Thomas M. Idzorek - 2004)\n",
        "\n",
        "- An Introduction to Modern Portfolio Theory: Markowitz, CAP-M, APT and Black-Litterman (Dr. Graeme West - 2004)\n",
        "\n",
        "- The Black-Litterman Approach: Original Model and Extensions (Attilio Meucci - 2010)\n",
        "\n"
      ],
      "metadata": {
        "id": "GjY3VdS65YZ9"
      }
    }
  ]
}