{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<a id='egm-policy-iter'></a>\n",
    "<div id=\"qe-notebook-header\" style=\"text-align:right;\">\n",
    "        <a href=\"https://quantecon.org/\" title=\"quantecon.org\">\n",
    "                <img style=\"width:250px;display:inline;\" src=\"https://assets.quantecon.org/img/qe-menubar-logo.svg\" alt=\"QuantEcon\">\n",
    "        </a>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimal Growth III: The Endogenous Grid Method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contents\n",
    "\n",
    "- [Optimal Growth III: The Endogenous Grid Method](#Optimal-Growth-III:-The-Endogenous-Grid-Method)  \n",
    "  - [Overview](#Overview)  \n",
    "  - [Key Idea](#Key-Idea)  \n",
    "  - [Implementation](#Implementation)  \n",
    "  - [Speed](#Speed)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview\n",
    "\n",
    "We solved the stochastic optimal growth model using\n",
    "\n",
    "1. [value function iteration](optgrowth.html)  \n",
    "1. [Euler equation based time iteration](coleman_policy_iter.html)  \n",
    "\n",
    "\n",
    "We found time iteration to be significantly more accurate at each step.\n",
    "\n",
    "In this lecture we’ll look at an ingenious twist on the time iteration technique called the **endogenous grid method** (EGM).\n",
    "\n",
    "EGM is a numerical method for implementing policy iteration invented by [Chris Carroll](http://www.econ2.jhu.edu/people/ccarroll/).\n",
    "\n",
    "It is a good example of how a clever algorithm can save a massive amount of computer time.\n",
    "\n",
    "(Massive when we multiply saved CPU cycles on each implementation times the number of implementations worldwide)\n",
    "\n",
    "The original reference is [[Car06]](../zreferences.html#carroll2006)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Key Idea\n",
    "\n",
    "Let’s start by reminding ourselves of the theory and then see how the numerics fit in."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Theory\n",
    "\n",
    "Take the model set out in [the time iteration lecture](coleman_policy_iter.html), following the same terminology and notation.\n",
    "\n",
    "The Euler equation is\n",
    "\n",
    "\n",
    "<a id='equation-egm-euler'></a>\n",
    "$$\n",
    "(u'\\circ c^*)(y)\n",
    "= \\beta \\int (u'\\circ c^*)(f(y - c^*(y)) z) f'(y - c^*(y)) z \\phi(dz) \\tag{1}\n",
    "$$\n",
    "\n",
    "As we saw, the Coleman operator is a nonlinear operator $ K $ engineered so that $ c^* $ is a fixed point of $ K $.\n",
    "\n",
    "It takes as its argument a continuous strictly increasing consumption policy $ g \\in \\Sigma $.\n",
    "\n",
    "It returns a new function $ Kg $,  where $ (Kg)(y) $ is the $ c \\in (0, \\infty) $ that solves\n",
    "\n",
    "\n",
    "<a id='equation-egm-coledef'></a>\n",
    "$$\n",
    "u'(c)\n",
    "= \\beta \\int (u' \\circ g) (f(y - c) z ) f'(y - c) z \\phi(dz) \\tag{2}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exogenous Grid\n",
    "\n",
    "As discussed in [the lecture on time iteration](coleman_policy_iter.html), to implement the method on a computer we need numerical approximation.\n",
    "\n",
    "In particular, we represent a policy function by a set of values on a finite grid.\n",
    "\n",
    "The function itself is reconstructed from this representation when necessary, using interpolation or some other method.\n",
    "\n",
    "[Previously](coleman_policy_iter.html), to obtain a finite representation of an updated consumption policy we\n",
    "\n",
    "- fixed a grid of income points $ \\{y_i\\} $  \n",
    "- calculated the consumption value $ c_i $ corresponding to each\n",
    "  $ y_i $ using [(2)](#equation-egm-coledef) and a root finding routine  \n",
    "\n",
    "\n",
    "Each $ c_i $ is then interpreted as the value of the function $ K g $ at $ y_i $.\n",
    "\n",
    "Thus, with the points $ \\{y_i, c_i\\} $ in hand, we can reconstruct $ Kg $ via approximation.\n",
    "\n",
    "Iteration then continues…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Endogenous Grid\n",
    "\n",
    "The method discussed above requires a root finding routine to find the\n",
    "$ c_i $ corresponding to a given income value $ y_i $.\n",
    "\n",
    "Root finding is costly because it typically involves a significant number of\n",
    "function evaluations.\n",
    "\n",
    "As pointed out by Carroll [[Car06]](../zreferences.html#carroll2006), we can avoid this if\n",
    "$ y_i $ is chosen endogenously.\n",
    "\n",
    "The only assumption required is that $ u' $ is invertible on $ (0, \\infty) $.\n",
    "\n",
    "The idea is this:\n",
    "\n",
    "First we fix an *exogenous* grid $ \\{k_i\\} $ for capital ($ k = y - c $).\n",
    "\n",
    "Then we obtain  $ c_i $ via\n",
    "\n",
    "\n",
    "<a id='equation-egm-getc'></a>\n",
    "$$\n",
    "c_i =\n",
    "(u')^{-1}\n",
    "\\left\\{\n",
    "    \\beta \\int (u' \\circ g) (f(k_i) z ) \\, f'(k_i) \\, z \\, \\phi(dz)\n",
    "\\right\\} \\tag{3}\n",
    "$$\n",
    "\n",
    "where $ (u')^{-1} $ is the inverse function of $ u' $.\n",
    "\n",
    "Finally, for each $ c_i $ we set $ y_i = c_i + k_i $.\n",
    "\n",
    "It is clear that each $ (y_i, c_i) $ pair constructed in this manner satisfies [(2)](#equation-egm-coledef).\n",
    "\n",
    "With the points $ \\{y_i, c_i\\} $ in hand, we can reconstruct $ Kg $ via approximation as before.\n",
    "\n",
    "The name EGM comes from the fact that the grid $ \\{y_i\\} $ is  determined **endogenously**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implementation\n",
    "\n",
    "Let’s implement this version of the Coleman operator and see how it performs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Operator\n",
    "\n",
    "Here’s an implementation of $ K $ using EGM as described above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "hide-output": true
   },
   "outputs": [],
   "source": [
    "using InstantiateFromURL\n",
    "# optionally add arguments to force installation: instantiate = true, precompile = true\n",
    "github_project(\"QuantEcon/quantecon-notebooks-julia\", version = \"0.8.0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "using LinearAlgebra, Statistics\n",
    "using BenchmarkTools, Interpolations, Parameters, Plots, QuantEcon, Random, Roots\n",
    "gr(fmt = :png);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "coleman_egm (generic function with 1 method)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function coleman_egm(g, k_grid, β, u′, u′_inv, f, f′, shocks)\n",
    "\n",
    "    # Allocate memory for value of consumption on endogenous grid points\n",
    "    c = similar(k_grid)\n",
    "\n",
    "    # Solve for updated consumption value\n",
    "    for (i, k) in enumerate(k_grid)\n",
    "        vals = u′.(g.(f(k) * shocks)) .* f′(k) .* shocks\n",
    "        c[i] = u′_inv(β * mean(vals))\n",
    "    end\n",
    "\n",
    "    # Determine endogenous grid\n",
    "    y = k_grid + c  # y_i = k_i + c_i\n",
    "\n",
    "    # Update policy function and return\n",
    "    Kg = LinearInterpolation(y,c, extrapolation_bc=Line())\n",
    "    Kg_f(x) = Kg(x)\n",
    "    return Kg_f\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the lack of any root finding algorithm.\n",
    "\n",
    "We’ll also run our original implementation, which uses an exogenous grid and requires root finding, so we can perform some comparisons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "K (generic function with 1 method)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function K!(Kg, g, grid, β, u′, f, f′, shocks)\n",
    "\n",
    "    # This function requires the container of the output value as argument Kg\n",
    "\n",
    "    # Construct linear interpolation object #\n",
    "    g_func = LinearInterpolation(grid, g, extrapolation_bc = Line())\n",
    "\n",
    "    # solve for updated consumption value #\n",
    "    for (i, y) in enumerate(grid)\n",
    "        function h(c)\n",
    "            vals = u′.(g_func.(f(y - c) * shocks)) .* f′(y - c) .* shocks\n",
    "            return u′(c) - β * mean(vals)\n",
    "        end\n",
    "        Kg[i] = find_zero(h, (1e-10, y - 1e-10))\n",
    "    end\n",
    "    return Kg\n",
    "end\n",
    "\n",
    "# The following function does NOT require the container of the output value as argument\n",
    "K(g, grid, β, u′, f, f′, shocks) =\n",
    "    K!(similar(g), g, grid, β, u′, f, f′, shocks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s test out the code above on some example parameterizations, after the following imports."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing on the Log / Cobb–Douglas case\n",
    "\n",
    "As we [did for value function iteration](optgrowth.html) and [time iteration](coleman_policy_iter.html), let’s start by testing our method with the log-linear benchmark.\n",
    "\n",
    "The first step is to bring in the model that we used in the [Coleman policy function iteration](coleman_policy_iter.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "##NamedTuple_kw#253 (generic function with 2 methods)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# model\n",
    "\n",
    "Model = @with_kw (α = 0.65, # productivity parameter\n",
    "                  β = 0.95, # discount factor\n",
    "                  γ = 1.0,  # risk aversion\n",
    "                  μ = 0.0,  # lognorm(μ, σ)\n",
    "                  s = 0.1,  # lognorm(μ, σ)\n",
    "                  grid_min = 1e-6, # smallest grid point\n",
    "                  grid_max = 4.0,  # largest grid point\n",
    "                  grid_size = 200, # grid size\n",
    "                  u = γ == 1 ? log : c->(c^(1-γ)-1)/(1-γ), # utility function\n",
    "                  u′ = c-> c^(-γ), # u'\n",
    "                  f = k-> k^α, # production function\n",
    "                  f′ = k -> α*k^(α-1), # f'\n",
    "                  grid = range(grid_min, grid_max, length = grid_size)) # grid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we generate an instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "mlog = Model(); # Log Linear model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also need some shock draws for Monte Carlo integration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "Random.seed!(42); # For reproducible behavior.\n",
    "\n",
    "shock_size = 250     # Number of shock draws in Monte Carlo integral\n",
    "shocks = exp.(mlog.μ .+ mlog.s * randn(shock_size));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a preliminary test, let’s see if $ K c^* = c^* $, as implied by the theory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "v_star (generic function with 1 method)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_star(y) = (1 - mlog.α * mlog.β) * y\n",
    "\n",
    "# some useful constants\n",
    "ab = mlog.α * mlog.β\n",
    "c1 = log(1 - ab) / (1 - mlog.β)\n",
    "c2 = (mlog.μ + mlog.α * log(ab)) / (1 - mlog.α)\n",
    "c3 = 1 / (1 - mlog.β)\n",
    "c4 = 1 / (1 - ab)\n",
    "\n",
    "v_star(y) = c1 + c2 * (c3 - c4) + c4 * log(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "verify_true_policy (generic function with 1 method)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function verify_true_policy(m, shocks, c_star)\n",
    "    k_grid = m.grid\n",
    "    c_star_new = coleman_egm(c_star, k_grid, m.β, m.u′, m.u′, m.f, m.f′, shocks)\n",
    "\n",
    "    plt = plot()\n",
    "    plot!(plt, k_grid, c_star.(k_grid), lw = 2, label = \"optimal policy c*\")\n",
    "    plot!(plt, k_grid, c_star_new.(k_grid), lw = 2, label = \"Kc*\")\n",
    "    plot!(plt, legend = :topleft)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "verify_true_policy(mlog, shocks, c_star)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we’re passing u′ to coleman_egm twice.\n",
    "\n",
    "The reason is that, in the case of log utility, $ u'(c) = (u')^{-1}(c) = 1/c $.\n",
    "\n",
    "Hence u′ and u′_inv are the same.\n",
    "\n",
    "We can’t really distinguish the two plots.\n",
    "\n",
    "In fact it’s easy to see that the difference is essentially zero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.3322676295501878e-15"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_star_new = coleman_egm(c_star, mlog.grid, mlog.β, mlog.u′,\n",
    "                         mlog.u′, mlog.f, mlog.f′, shocks)\n",
    "maximum(abs(c_star_new(g) - c_star(g)) for g in mlog.grid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next let’s try iterating from an arbitrary initial condition and see if we\n",
    "converge towards $ c^* $.\n",
    "\n",
    "Let’s start from the consumption policy that eats the whole pie: $ c(y) = y $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "check_convergence (generic function with 1 method)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 15\n",
    "function check_convergence(m, shocks, c_star, g_init, n_iter)\n",
    "    k_grid = m.grid\n",
    "    g = g_init\n",
    "    plt = plot()\n",
    "    plot!(plt, m.grid, g.(m.grid),\n",
    "          color = RGBA(0,0,0,1), lw = 2, alpha = 0.6, label = \"initial condition c(y) = y\")\n",
    "    for i in 1:n_iter\n",
    "        new_g = coleman_egm(g, k_grid, m.β, m.u′, m.u′, m.f, m.f′, shocks)\n",
    "        g = new_g\n",
    "        plot!(plt, k_grid, new_g.(k_grid), alpha = 0.6, color = RGBA(0,0,(i / n_iter), 1),\n",
    "              lw = 2, label = \"\")\n",
    "    end\n",
    "\n",
    "    plot!(plt, k_grid, c_star.(k_grid),\n",
    "          color = :black, lw = 2, alpha = 0.8, label = \"true policy function c*\")\n",
    "    plot!(plt, legend = :topleft)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_convergence(mlog, shocks, c_star, identity, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the policy has converged nicely, in only a few steps."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Speed\n",
    "\n",
    "Now let’s compare the clock times per iteration for the standard Coleman\n",
    "operator (with exogenous grid) and the EGM version.\n",
    "\n",
    "We’ll do so using the CRRA model adopted in the exercises of the [Euler equation time iteration lecture](coleman_policy_iter.html).\n",
    "\n",
    "Here’s the model and some convenient functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "u′_inv (generic function with 1 method)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mcrra = Model(α = 0.65, β = 0.95, γ = 1.5)\n",
    "u′_inv(c) = c^(-1 / mcrra.γ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here’s the result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "egm (generic function with 3 methods)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "crra_coleman(g, m, shocks) = K(g, m.grid, m.β, m.u′, m.f, m.f′, shocks)\n",
    "crra_coleman_egm(g, m, shocks) = coleman_egm(g, m.grid, m.β, m.u′,\n",
    "                                             u′_inv, m.f, m.f′, shocks)\n",
    "function coleman(m = m, shocks = shocks; sim_length = 20)\n",
    "    g = m.grid\n",
    "    for i in 1:sim_length\n",
    "        g = crra_coleman(g, m, shocks)\n",
    "    end\n",
    "    return g\n",
    "end\n",
    "function egm(m, g = identity, shocks = shocks; sim_length = 20)\n",
    "    for i in 1:sim_length\n",
    "        g = crra_coleman_egm(g, m, shocks)\n",
    "    end\n",
    "    return g.(m.grid)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  1.03 GiB\n",
       "  allocs estimate:  615012\n",
       "  --------------\n",
       "  minimum time:     7.132 s (1.56% GC)\n",
       "  median time:      7.132 s (1.56% GC)\n",
       "  mean time:        7.132 s (1.56% GC)\n",
       "  maximum time:     7.132 s (1.56% GC)\n",
       "  --------------\n",
       "  samples:          1\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark coleman($mcrra)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  18.50 MiB\n",
       "  allocs estimate:  76226\n",
       "  --------------\n",
       "  minimum time:     152.147 ms (0.00% GC)\n",
       "  median time:      157.500 ms (0.00% GC)\n",
       "  mean time:        158.227 ms (1.34% GC)\n",
       "  maximum time:     167.435 ms (3.40% GC)\n",
       "  --------------\n",
       "  samples:          32\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark egm($mcrra)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the EGM version is about 30 times faster.\n",
    "\n",
    "At the same time, the absence of numerical root finding means that it is\n",
    "typically more accurate at each step as well."
   ]
  }
 ],
 "metadata": {
  "date": 1591310614.9106944,
  "download_nb": 1,
  "download_nb_path": "https://julia.quantecon.org/",
  "filename": "egm_policy_iter.rst",
  "filename_with_path": "dynamic_programming/egm_policy_iter",
  "kernelspec": {
   "display_name": "Julia 1.4.2",
   "language": "julia",
   "name": "julia-1.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.4.2"
  },
  "title": "Optimal Growth III: The Endogenous Grid Method"
 },
 "nbformat": 4,
 "nbformat_minor": 2
}