session-three/session-three-project-questions-econ-and-finance.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python for Data Science Project Session 3: Economics and Finance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modern Portfolio Theory (MPT)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the first part of the notebook we will optimise a portfolio consisting of two assets: Amazon (AMZN) and Alibaba (BABA) stock. We will implement the ideas of the Modern Portfolio Theory. Although to complete this notebook you don't need any knowledge about finance, if you want to learn more about MPT, you can do it [here](https://corporatefinanceinstitute.com/resources/knowledge/trading-investing/modern-portfolio-theory-mpt/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start by importing packages required that we going to use in this notebook: numpy, pandas, pandas_datareader and matplotlib."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we start working on data, first we must get them. In the first section of the notebook, we will be working on the daily prices of the Amazon and Alibaba stocks. First, we need to create dataframe `stock` and then using [DataReader](https://pandas-datareader.readthedocs.io/en/latest/remote_data.html#remote-data-yahoo) we can get the data from Yahoo Finance. The starting date of our data doesn't matter, but for sake of simplicity, let's start from 1st January 2016."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#stock=..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#stock['AMZN']=..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#stock['BABA']=..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's display our data to see if we correctly downloaded the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we get our data, we can create a table with daily logarithmic returns. To do this, we can use [`.log()`](https://numpy.org/doc/stable/reference/generated/numpy.log.html) and [`.shift()`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.shift.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#log_returns=..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's display our returns!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, our values are really small. It shouldn't concern us, since the returns are daily. What should concern us is the first row. Since there are no values before it, we have got NaN. To prevent any errors in the future, we can delete those values using [`.dropna()`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.dropna.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Efficient Frontier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now it's time to explain the basic assumptions of the Markowitz model. As we already know, we have two stocks with different returns. If our portfolio would consist only of the Amazon stock, our returns will be equal to Amazon stock returns, and the portfolio's variance would be equal to the Amazon stock variance. On the other hand, if our portfolio would consist only of Alibaba stock, our returns will be equal to Alibaba stock returns, and the portfolio's variance would be equal to the amazon stock variance. However, if our portfolio consist of mix of those two stocks, our returns and variability would be:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ returns = w_1 r_1+w_2 r_2\\\\ variance=w_1^2 v_1+w_2^2 v_2+2 w_1 w_2 cov() $$\n",
    "$ w_1 - weight\\,of\\,1st\\,stock\\\\ $ \n",
    "$ w_2 - weight\\,of\\,2nd\\,stock\\\\ $ \n",
    "$ r_1 - returns\\,of\\,1st\\,stock\\\\ $ \n",
    "$ r_2 - returns\\,of\\,2nd\\,stock\\\\ $ \n",
    "$ v_1 - variance\\,of\\,1st\\,stock\\\\ $ \n",
    "$ v_2 - variance\\,of\\,2nd\\,stock\\\\ $ \n",
    "$ cov() - covariance\\,of\\,two\\,stocks\\\\ $ \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, what we can observe is that while mixing the weights of two stocks, we can achieve two different combinations of stock 1 and stock 2 with the same variance, but with different returns. This could be nicely represented on a graph."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To create a curve that will represent all the possible combinations of two stocks, we will use random numbers. The idea is as follows. Once we create a sufficiently large number of random portfolios consisting of two stocks, it would create a sufficiently good representation of all possible combinations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we need to create two empty arrays called returns and volatilities which we will expand by our randomly generated portfolios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, we need to create a loop that will execute a sufficiently large number of times (100 is enough). Within this loop, we need to generate one random number `ran` in range (0,1) which would be the weight of the first stock (you can use [`random.random()`](https://docs.python.org/3/library/random.html)). We don't need to generate the weight of the second stock, since it is just 1 - `ran` (because those two weights need to sum up to 1). Then we can append the arrays that we created before with the returns and volatility given randomly generated weight. The returns of the stocks we can get by taking the mean of the logarithmic returns calculated before (we need to multiply the mean daily returns by 250 to achieve annual returns because there are about 250 trading days in a year). We can get variances and covariance by using the [`.cov()`](https://numpy.org/doc/stable/reference/generated/numpy.cov.html) (note that this command returns covariance matrix, you need to use `.iloc[]` to get the values that you want, and you also need to multiply them by 250)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's display the values that we have calculated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can plot our results. Create a scatter plot with volatility on the x-axis and returns on the y-axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, our axes are not starting at 0. We can fix that by using [`.gca()`](https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.gca.html), [`set_xlim()`](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.xlim.html) and [`set_ylim()`](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.ylim.html) ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The upper part of this curve is called \"Efficient Frontier\". It represents all the combinations of two assets that maximise the returns on the given level of risk (volatility). This notebook won't cover all the details about the Markowitz portfolio model, so if you want to learn more details about this model you can easily find them just by googling."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Capital Allocation Line (CAL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this part of the notebook, we will calculate the Capital Allocation Line. That's the line that runs from the risk-free rate (the point where the returns are equal to the risk-free rate, and the volatility (risk) is equal to 0) and is tangent to our Efficient Frontier. This line shows all of the possible efficient allocations of the risk-free and risky assets. Once again, we won't go into details of the meaning of this line, we will just focus on computing it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's begin by setting our risk-free rate, which would be stored in a variable called `interest_rate` (let's say that it is 0.1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#interest_rate = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since in our example the Efficient Frontier is not a function but a set of points, to calculate the tangent line we will use a simple trick. To begin, let's calculate the equation of the line that goes through risk-free rate point and point (`volatilities[0]`, `returns[0]`). We can do it by creating linespace `x` and then calculating `y` by the following formula:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ y = risk\\,free\\,rate\\,+\\frac{return_0-risk\\,free\\,rate\\,}{volatility_0}*x $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#x = np.linspace(0, 0.2)\n",
    "#y = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can our line on top of the previous graph to see if it actually goes through our chosen points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we know how to compute the line that goes through chosen point, we can calculate the tangent line. To do this, we will use the property of the tangent line. In our case, the tangent line goes through one of the points on the line and lies above all the other points on our curve. What we need to do is find such a point, that the line that goes through it is above every other line. Let's create a matrix called `point` that would store the coordinates of our candidates for such point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#point = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, what we need to do is to check if there is any other point that lies above it. If it does, it would become our new candidate for point of tangency. Once we try it for all points on our curve, our candidate will be our final point of tangency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's change the `y` that it represents the line that goes through risk-free rate and `point`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#y = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can plot everything together and confirm that the line that we have computed actually is tangent to our curve."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3x3 Nash equilibria"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At the end of this notebook, we create a framework for finding nash equilibria in the 3x3 games."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say that we have two firms. They are setting their level of cost spend on marketing. They could either spend 2, 3 or 4. If they spend the same amount, they both sell 4, so their profit is 4 minus marketing costs. If one of the firms spend more, it attracts a majority of clients and sells 7, and the other firm sells 1. The game could be represented by the following payoff matrix:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table>\n",
    "    <tr>\n",
    "        <td></td><td></td><td>Firm 2</td><td></td><td></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td></td><td></td><td>Low</td><td>Medium</td><td>High</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td></td><td>Low</td><td>2;2</td><td>-1;4</td><td>-1;3</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>Firm 1</td><td>Medium</td><td>4;-1</td><td>1;1</td><td>-2;3</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td></td><td>High</td><td>3;-1</td><td>3;-2</td><td>0;0</td>\n",
    "    </tr>\n",
    "    \n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To find the Nash Equilibria, we need to first create the matrix and fill it with payoffs. To create 2x3x3 matrix we can use [`.zeros()`](https://numpy.org/doc/stable/reference/generated/numpy.zeros.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#payoff_matrix = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's display our payoff matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For such a simple 3x3 game, we can easily enter the values manually, but to practise for other more complicated cases, we will create a function that returns one player given marketing expenditures. The function should be as follows:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - if the players spend the same amount on marketing, return 4 - player's spending\n",
    " - if the player spends more than the opponent, return 7-player's spending \n",
    " - if the player spends less than the opponent, return 1-player's spending"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (<ipython-input-11-7a8fce239782>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-11-7a8fce239782>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    ...\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "#def payoff(player,opponent):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you created the function you can fill the payoffs matrix with values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now check if you have correctly filled the matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now given the payoff matrix we can compute Best Responses. Best Response for some choice of your opponent is the choice that gives no less than any other choice e.g. choosing medium is the best response of player 1 to player 2 choosing low. Let's use `.zeros()` and create the matrix of the same size as the payoff matrix filled with zeros. If the strategy is the best response, we will change the value to 1 (so for example, for player 1 playing low with response to low is not the best response, since playing medium gives higher payoff, but if player 1 plays medium with response to low, he doesn't have any other response that gives qual or higher payoff, so for player 1 paying medium is the best response to low). Let's create a loop that goes through every value in the best response matrix and checks whether it is the best response."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#best_response = ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the strategy is the best response for both player 1 and player 2, no one has any incentives to change their choice and we are in the Nash Equilibrium. We can create an empty array called `nash_equilibria` and run a loop that checks if the given strategy is the best response for both players 1 and 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can display our Nash Equilibria."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}