demo_notebooks/asset_pricing_sequential_demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8274b7cf",
   "metadata": {},
   "source": [
    "**Note**: This notebook should take around **a minute** to run.\n",
    "\n",
    "For a more comprehensive and detailed treatment of this problem, please refer to the [GitHub repository](https://github.com/HighDimensionalEconLab/transversality)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6b8a8ef",
   "metadata": {},
   "source": [
    "## The Economic Problem\n",
    "\n",
    "Consider an asset that pays dividends $\\{y_t\\}_{t=0}^\\infty$, and the sequence of dividends follows a law of motion described as:\n",
    "\n",
    "$\\begin{align}\n",
    "y(t+1) = c + (1+g) y(t)\n",
    "\\end{align}$\n",
    "\n",
    "This system can be written in a linear space setup as follows:\n",
    "\n",
    "$\\begin{align}\n",
    "x(t+1) = Ax(t)\\\\\n",
    "y(t) = Gx(t),\n",
    "\\end{align}$\n",
    "\n",
    "where \n",
    "\n",
    "$x(t) \\equiv \\begin{bmatrix}\n",
    "1\\\\\n",
    "y(t)\n",
    "\\end{bmatrix}$\n",
    "\n",
    "$\n",
    "A \\equiv \\begin{bmatrix}\n",
    "1 & 0\\\\\n",
    "c & 1+g\n",
    "\\end{bmatrix}\n",
    "$\n",
    "\n",
    "$G = \\begin{bmatrix}\n",
    "1 & 0\n",
    "\\end{bmatrix}$\n",
    "\n",
    "The price based on the fundamentals can be written as:\n",
    "\n",
    "$\n",
    "\\begin{align}\n",
    "p_f(t) = \\sum_{j=0}^\\infty \\beta^j y(t+j) = G (\\mathbf{I}-\\beta A)^{-1} x(t)\n",
    "\\end{align}\n",
    "$\n",
    "\n",
    "The equation for the price can be written in a recursive way:\n",
    "\n",
    "$\\begin{align}\n",
    "&p(t) = Gx(t) + \\beta p(t+1)\\\\\n",
    "&x(t+1) = A x(t)\n",
    "\\end{align}$\n",
    "\n",
    "This system described above has infinitely many solutions; therefore, we need a condition (i.e., no-bubble condition) to rule out the solutions with bubbles:\n",
    "\n",
    "$\\begin{align}\n",
    "\\lim_{T\\rightarrow \\infty } \\beta^T p(T) = 0\n",
    "\\end{align}$\n",
    "\n",
    "#### Note on the No-Bubble Condition:\n",
    "\n",
    "One of the main contributions of this paper is that one can ignore the no-bubble condition and completely rely on the implicit bias in deep learning to obtain the solution that is based on the fundamentals.\n",
    "\n",
    "In this example, we focus on the case of:\n",
    "\n",
    "1. $c = 0.01$, $g = -0.1$, $\\beta = 0.9$, and $y_0 = 0.08$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "301308ac",
   "metadata": {},
   "source": [
    "#### Importing Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "188e301e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import DataLoader,TensorDataset\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "60987f8b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x28d4e10c0b0>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.manual_seed(123) # fixing the seed"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8a8f29a",
   "metadata": {},
   "source": [
    "#### Setting Up the Economic Parameters \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7a6ebb2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = 0.01\n",
    "g = -0.1\n",
    "beta = 0.9\n",
    "y_0 = 0.08"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdd50bb4",
   "metadata": {},
   "source": [
    "### Setting Up the Grid ($\\mathcal{X}_{\\text{train}}$) and the DataLoader\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d84785ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_t_max = 29\n",
    "time_grid = torch.arange(0.0, train_t_max , 1.0)\n",
    "time_grid = time_grid.unsqueeze(dim =1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23707376",
   "metadata": {},
   "source": [
    "#### Creating the Dividends Stream in the State-Space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2f9482c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "A = torch.tensor([[1, 0], [c, 1 + g]]) \n",
    "G = torch.tensor([0.0, 1.0])  #\n",
    "x_0 = torch.tensor([1.0, y_0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "92823ed7",
   "metadata": {},
   "outputs": [],
   "source": [
    "y = []\n",
    "x = []\n",
    "x_t = x_0\n",
    "for _ in range(train_t_max):\n",
    "    x.append(x_t)\n",
    "    y.append(G @ x_t)\n",
    "    x_t = A @ x_t\n",
    "    \n",
    "y = torch.tensor(y).view(-1,1)#turning a list into a tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ba2cc259",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = TensorDataset(time_grid,y)\n",
    "data_loader = DataLoader(train_data, batch_size=len(time_grid), shuffle= False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcaa59ee",
   "metadata": {},
   "source": [
    "#### Setting up the Neural Network\n",
    "This is an approximation for price $\\hat{p}: \\mathbb{R}_+ \\rightarrow \\mathbb{R}_+$.\n",
    "\n",
    "$\\hat{p}(\\cdot)$ takes time as an input. The positivity of prices is going to be implemented by using a `Softplus` output layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c64dd755",
   "metadata": {},
   "outputs": [],
   "source": [
    "class P_hat_NN(nn.Module):\n",
    "    def __init__(self,\n",
    "                 dim_hidden = 128,):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.dim_hidden= dim_hidden\n",
    "        \n",
    "        self.p_hat = nn.Sequential(\n",
    "            nn.Linear(1, dim_hidden, bias=True),\n",
    "            nn.Tanh(),\n",
    "            nn.Linear(dim_hidden, dim_hidden, bias=True),\n",
    "            nn.Tanh(),\n",
    "            nn.Linear(dim_hidden, dim_hidden, bias=True),\n",
    "            nn.Tanh(),\n",
    "            nn.Linear(dim_hidden, dim_hidden, bias=True),\n",
    "            nn.Tanh(),\n",
    "            nn.Linear(dim_hidden, 1),\n",
    "            nn.Softplus(beta=1.0) #To make sure the price stays positive\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.p_hat(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b575f54",
   "metadata": {},
   "source": [
    "#### Initializing the Neural Network and Defining the Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c0496ae3",
   "metadata": {},
   "outputs": [],
   "source": [
    "p_hat= P_hat_NN()\n",
    "learning_rate = 1e-3\n",
    "optimizer = torch.optim.Adam(p_hat.parameters(), lr=learning_rate) #Adam Optimizer \n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=200, gamma=0.9) #dampening the learning rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1e78eafa",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_epochs = 2001 # step of optimization\n",
    "print_epoch_frequency = 200 # how often printing the results"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79c154f3",
   "metadata": {},
   "source": [
    "### Implementing the Economics\n",
    "Here, we implement the economic conditions in the form of residuals to be minimized, specifically:\n",
    "\n",
    "The price residuals: the difference between the left-hand and right-hand sides of the recursive equation for price (i.e., eq. 5).\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee4e3d60",
   "metadata": {},
   "source": [
    "#### Defining the Residuals Function to be Used in the Optimization\n",
    "This funtion defines the residuals for the recursive formulation of prices "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8bcbdbf2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def residuals(batch):\n",
    "    time, y_t = batch\n",
    "    t_p1 = time+1 # t+1\n",
    "    p_t = p_hat(time) # p(t), p_hat is the neural network\n",
    "    p_tp1 = p_hat(t_p1) # p(t+1), p_hat is the neural network\n",
    "    price_residulas =  y_t + beta * p_tp1 - p_t  # Gx(t)+ beta p(t+1) - p(t) = y(t)+ beta p(t+1) - p(t) \n",
    "    return price_residulas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49e4923f",
   "metadata": {},
   "source": [
    "### Training Loop (Optimization Process)\n",
    "Here, we minimize the mean squared of price residuals over the grid points:\n",
    "\n",
    "$\\min_{\\theta} \\frac{1}{|\\mathcal{X}_{\\text{train}}|} \\sum_{t\\in \\mathcal{X}_{\\text{train}}} [y(t)+\\beta \\hat{p}(t+1;\\theta)-\\hat{p}(t;\\theta)]^2$\n",
    "\n",
    "where $\\theta$ represents the coefficients of the neural network, and the optimization is done with gradient-based optimizers such as `Gradient Descent (GD)` and `Adam`.  \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "09a63b40",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch = 0, loss = 4.28e-04\n",
      "epoch = 200, loss = 1.33e-08\n",
      "epoch = 400, loss = 1.22e-09\n",
      "epoch = 600, loss = 6.82e-10\n",
      "epoch = 800, loss = 5.86e-10\n",
      "epoch = 1000, loss = 5.04e-10\n",
      "epoch = 1200, loss = 4.33e-10\n",
      "epoch = 1400, loss = 3.72e-10\n",
      "epoch = 1600, loss = 3.21e-10\n",
      "epoch = 1800, loss = 2.76e-10\n",
      "epoch = 2000, loss = 2.39e-10\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(num_epochs):\n",
    "    for batch in data_loader:\n",
    "        \n",
    "        optimizer.zero_grad() # Resetting the gradients (with respect to NN coefficients)\n",
    "        \n",
    "        price_res = residuals(batch) # Constructing the price residuals\n",
    "        \n",
    "        loss = price_res.pow(2).mean() # Calculating the mean squared (over the grid points) of the price residulas residuals\n",
    "        \n",
    "        loss.backward() # Calculating the gradients (with respect to NN coefficients)\n",
    "        optimizer.step() # Using the gradients to minimize the loss function\n",
    "        \n",
    "    scheduler.step() # Dampening the learning rate\n",
    "    \n",
    "    if epoch % print_epoch_frequency == 0:\n",
    "        print(f\"epoch = {epoch}, loss = {loss.detach().numpy():.2e}\")\n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "728d4bac",
   "metadata": {},
   "source": [
    "### Plotting the Results"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c69ce6f",
   "metadata": {},
   "source": [
    "#### Calculating the Approximate Capital and Consumption Path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "fe1dae92",
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating the test data\n",
    "test_T = 50\n",
    "time_grid_test = torch.arange(0.0, test_T , 1.0)\n",
    "time_grid_test = time_grid_test.unsqueeze(dim =1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c76ba42d",
   "metadata": {},
   "outputs": [],
   "source": [
    "p_hat_path = p_hat(time_grid_test).detach() # \\hat{p}(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b69663be",
   "metadata": {},
   "source": [
    "#### Closed Form Solution : Calculating the Price Path Based on the Fundamentals, $p_f(t)$\n",
    "$p_f(t)$ is the price based on the fundamentalson the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "93d7416f",
   "metadata": {},
   "outputs": [],
   "source": [
    "H = G @ torch.inverse(torch.eye(2)- beta * A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f4865495",
   "metadata": {},
   "outputs": [],
   "source": [
    "x_test = []\n",
    "x_t_test = x_0\n",
    "for _ in range(test_T):\n",
    "    x_test.append(x_t_test)\n",
    "    x_t_test = A @ x_t_test\n",
    "\n",
    "\n",
    "x_test_path = torch.stack(x_test).t()\n",
    "p_f_path = (H @ x_test_path).view(-1,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60deeaf9",
   "metadata": {},
   "source": [
    "#### Calculating relative errors\n",
    "Defined as \n",
    "\n",
    "$\\begin{align}\n",
    "\\varepsilon_p(t) = \\frac{\\hat{p}(t)-p_f(t)}{p_f(t)}\n",
    "\\end{align}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "a3f18e8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "rel_error_path = (p_hat_path-p_f_path)/p_f_path"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cc7e600",
   "metadata": {},
   "source": [
    "#### Plot Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "7c524a9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "fontsize= 14\n",
    "ticksize = 14\n",
    "figsize = (14, 4.5)\n",
    "params = {'font.family':'serif',\n",
    "    \"figure.figsize\":figsize,\n",
    "    'figure.dpi': 80,\n",
    "    'figure.edgecolor': 'k',\n",
    "    'font.size': fontsize,\n",
    "    'axes.labelsize': fontsize,\n",
    "    'axes.titlesize': fontsize,\n",
    "    'xtick.labelsize': ticksize,\n",
    "    'ytick.labelsize': ticksize\n",
    "}\n",
    "plt.rcParams.update(params)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccb4e459",
   "metadata": {},
   "source": [
    "#### Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "edd97a4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x28d5bf9ee50>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1120x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(1, 2 , 1)\n",
    "\n",
    "plt.plot(time_grid_test,p_hat_path, color='k',  label = r\"$\\hat{p}(t)$\")\n",
    "plt.plot(time_grid_test,p_f_path, color='k', linestyle = \"--\" ,label = r\"$p(t)$\")\n",
    "plt.xlabel(r\"Time(t)\")\n",
    "plt.axvline(x= train_t_max , color='k', linestyle=':', label = \"Interpolation vs Extrapolation\")\n",
    "plt.title(r\"Approximate Price Path\")\n",
    "plt.ylim([p_hat_path[0]-0.05,p_hat_path[-1]*(1+0.05) ])\n",
    "plt.legend(loc='lower right')\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "\n",
    "plt.plot(time_grid_test,rel_error_path, color='k',  label = r\"$\\varepsilon_p(t)$\")\n",
    "plt.xlabel(r\"Time(t)\")\n",
    "plt.axvline(x= train_t_max , color='k', linestyle=':', label = \"Interpolation vs Extrapolation\")\n",
    "plt.title(r\"Relative Errors\")\n",
    "plt.legend(loc='best')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9872d1fc",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}