ipynb/spencer_lyon-python.ipynb

{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {
                "outputExpanded": false
            },
            "source": [
                "# Solving a New Keynesian model with Python\n",
                "\n",
                "This file is part of a computational appendix that accompanies the paper.\n",
                "\n",
                "> MATLAB, Python, Julia: What to Choose in Economics?\n",
                ">\n",
                "> Coleman, Lyon, Maliar, and Maliar (2017)\n",
                "\n",
                "In order to run the codes in this file you will need to install and\n",
                "configure a few Python packages. We recommend following the instructions\n",
                "on\n",
                "[quantecon.org](https://lectures.quantecon.org/jl/getting_started.html)\n",
                "for getting a base python installation set up. Then to acquire\n",
                "additional packages used in this file, uncomment the lines in the\n",
                "cell below (delete the `#` and space at the beginning of the line) and\n",
                "then run the cell:\n",
                "\n",
                "For some details regarding the model solved in this file, please see\n",
                "the [companion notebook that describes the model](http://bookshelf.quant\n",
                "econ.org/submission/59fa1b45145fc3772b0cef82)."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {
                "outputExpanded": false
            },
            "outputs": [],
            "source": [
                "# !pip install git+https://github.com/EconForge/interpolation.py.git\n",
                "# !pip install git+https://github.com/naught101/sobol_seq.git\n",
                "# !pip install requests"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "outputExpanded": false
            },
            "source": [
                "## Python Code\n",
                "\n",
                "The Python version of our algorithm is implemented as a few methods defined on\n",
                "a core class named `Model`. This class is itself composed of instances of three\n",
                "different classes that hold the model parameters, steady state, and grids\n",
                "needed to describe the numerical model. Before we get to the classes, we need\n",
                "to bring in some dependencies:"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "metadata": {
                "outputExpanded": false
            },
            "outputs": [],
            "source": [
                "import os\n",
                "import sys\n",
                "import math\n",
                "from math import sqrt\n",
                "import time as time\n",
                "from collections import namedtuple\n",
                "import requests\n",
                "\n",
                "if \"table\" not in sys.argv:\n",
                "    import matplotlib.pyplot as plt\n",
                "    # turn on interactive mode so plots display automatically\n",
                "    plt.ion()\n",
                "\n",
                "import numpy as np\n",
                "from numpy import exp\n",
                "from scipy.io import loadmat\n",
                "from interpolation.complete_poly import (_complete_poly_impl_vec,\n",
                "                                         _complete_poly_impl,\n",
                "                                         complete_polynomial)\n",
                "import sobol_seq\n",
                "\n",
                "# get path to this folder\n",
                "DIR = os.path.abspath(\"\")\n",
                "\n",
                "# set seed on random number generator to make results reproducible\n",
                "np.random.seed(42)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "outputExpanded": false
            },
            "source": [
                "We will also need the following two functions, which use monomial rules to\n",
                "compute quadrature nodes and weights:"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "metadata": {
                "outputExpanded": false
            },
            "outputs": [],
            "source": [
                "def qnwmonomial1(vcv):\n",
                "    n = vcv.shape[0]\n",
                "    n_nodes = 2*n\n",
                "\n",
                "    z1 = np.zeros((n_nodes, n))\n",
                "\n",
                "    # In each node, random variable i takes value either 1 or -1, and\n",
                "    # all other variables take value 0. For example, for N = 2,\n",
                "    # z1 = [1 0; -1 0; 0 1; 0 -1]\n",
                "    for i in range(n):\n",
                "        z1[2*i:2*(i+1), i] = [1, -1]\n",
                "\n",
                "    sqrt_vcv = np.linalg.cholesky(vcv)\n",
                "    R = np.sqrt(n)*sqrt_vcv\n",
                "    ϵj = z1 @ R\n",
                "    ωj = np.ones(n_nodes) / n_nodes\n",
                "\n",
                "    return ϵj, ωj\n",
                "\n",
                "\n",
                "def qnwmonomial2(vcv):\n",
                "    n = vcv.shape[0]\n",
                "    assert n == vcv.shape[1], \"Variance covariance matrix must be square\"\n",
                "    z0 = np.zeros((1, n))\n",
                "\n",
                "    z1 = np.zeros((2*n, n))\n",
                "    # In each node, random variable i takes value either 1 or -1, and\n",
                "    # all other variables take value 0. For example, for N = 2,\n",
                "    # z1 = [1 0; -1 0; 0 1; 0 -1]\n",
                "    for i in range(n):\n",
                "        z1[2*i:2*(i+1), i] = [1, -1]\n",
                "\n",
                "    z2 = np.zeros((2*n*(n-1), n))\n",
                "    i = 0\n",
                "\n",
                "    # In each node, a pair of random variables (p,q) takes either values\n",
                "    # (1,1) or (1,-1) or (-1,1) or (-1,-1), and all other variables take\n",
                "    # value 0. For example, for N = 2, `z2 = [1 1; 1 -1; -1 1; -1 1]`\n",
                "    for p in range(n-1):\n",
                "        for q in range(p+1, n):\n",
                "            z2[4*i:4*(i+1), p] = [1, -1, 1, -1]\n",
                "            z2[4*i:4*(i+1), q] = [1, 1, -1, -1]\n",
                "            i += 1\n",
                "\n",
                "    sqrt_vcv = np.linalg.cholesky(vcv)\n",
                "    R = np.sqrt(n+2)*sqrt_vcv\n",
                "    S = np.sqrt((n+2)/2)*sqrt_vcv\n",
                "    ϵj = np.row_stack([z0, z1 @ R, z2 @ S])\n",
                "\n",
                "    ωj = np.concatenate([2/(n+2) * np.ones(z0.shape[0]),\n",
                "                         (4-n)/(2*(n+2)**2) * np.ones(z1.shape[0]),\n",
                "                         1/(n+2)**2 * np.ones(z2.shape[0])])\n",
                "    return ϵj, ωj"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "outputExpanded": false
            },
            "source": [
                "## Classes\n",
                "\n",
                "First we have the `Params` class, which holds all the model parameters as well\n",
                "as the paramters that drive the algorithm."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "metadata": {
                "outputExpanded": false
            },
            "outputs": [],
            "source": [
                "SteadyState = namedtuple(\"SteadyState\",\n",
                "                         [\"Yn\", \"Y\", \"π\", \"δ\", \"L\", \"C\", \"F\", \"S\", \"R\", \"w\"])\n",
                "\n",
                "\n",
                "class Params(object):\n",
                "    def __init__(self, zlb=True, γ=1, β=0.99, ϑ=2.09, ϵ=4.45, ϕ_y=0.07,\n",
                "                 ϕ_π=2.21, μ=0.82, Θ=0.83, πstar=1, gbar=0.23,\n",
                "                 ρηR=0.0, ρηa=0.95, ρηL=0.25, ρηu=0.92, ρηB=0.0, ρηG=0.95,\n",
                "                 σηR=0.0028, σηa=0.0045, σηL=0.0500, σηu=0.0054, σηB=0.0010,\n",
                "                 σηG=0.0038, degree=2):\n",
                "\n",
                "        self.zlb = zlb      # whether or not the zlb should be imposed\n",
                "        self.γ = γ          # Utility-function parameter\n",
                "        self.β = β          # Discount factor\n",
                "        self.ϑ = ϑ          # Utility-function parameter\n",
                "        self.ϵ = ϵ          # Parameter in the Dixit-Stiglitz aggregator\n",
                "        self.ϕ_y = ϕ_y      # Parameter of the Taylor rule\n",
                "        self.ϕ_π = ϕ_π      # Parameter of the Taylor rule\n",
                "        self.μ = μ          # Parameter of the Taylor rule\n",
                "        self.Θ = Θ          # Share of non-reoptimizing firms (Calvo's pricing)\n",
                "        self.πstar = πstar  # Target (gross) inflation rate\n",
                "        self.gbar = gbar    # Steady-state share of gov. spending in output\n",
                "\n",
                "        # autocorrelation coefficients\n",
                "        self.ρηR = ρηR  # See process (28) in MM (2015)\n",
                "        self.ρηa = ρηa  # See process (22) in MM (2015)\n",
                "        self.ρηL = ρηL  # See process (16) in MM (2015)\n",
                "        self.ρηu = ρηu  # See process (15) in MM (2015)\n",
                "        self.ρηB = ρηB  # See process (17) in MM (2015)\n",
                "        self.ρηG = ρηG  # See process (26) in MM (2015)\n",
                "\n",
                "        # standard deviations\n",
                "        self.σηR = σηR  # See process (28) in MM (2015)\n",
                "        self.σηa = σηa  # See process (22) in MM (2015)\n",
                "        self.σηL = σηL  # See process (16) in MM (2015)\n",
                "        self.σηu = σηu  # See process (15) in MM (2015)\n",
                "        self.σηB = σηB  # See process (17) in MM (2015)\n",
                "        self.σηG = σηG  # See process (26) in MM (2015)\n",
                "\n",
                "        self.degree = degree\n",
                "\n",
                "    @property\n",
                "    def vcov(self):\n",
                "        return np.diag([self.σηR**2, self.σηa**2, self.σηL**2,\n",
                "                        self.σηu**2, self.σηB**2, self.σηG**2])\n",
                "\n",
                "    @property\n",
                "    def steady_state(self):\n",
                "        Yn_ss = exp(self.gbar)**(self.γ/(self.ϑ+self.γ))\n",
                "        Y_ss = Yn_ss\n",
                "        π_ss = 1.0\n",
                "        δ_ss = 1.0\n",
                "        L_ss = Y_ss/δ_ss\n",
                "        C_ss = (1-self.gbar)*Y_ss\n",
                "        F_ss = C_ss**(-self.γ)*Y_ss/(1-self.β*self.Θ*π_ss**(self.ϵ-1))\n",
                "        S_ss = L_ss**self.ϑ*Y_ss/(1-self.β*self.Θ*π_ss**self.ϵ)\n",
                "        R_ss = π_ss/self.β\n",
                "        w_ss = (L_ss**self.ϑ)*(C_ss**self.γ)\n",
                "\n",
                "        return SteadyState(\n",
                "            Yn_ss, Y_ss, π_ss, δ_ss, L_ss, C_ss, F_ss, S_ss, R_ss, w_ss\n",
                "        )\n",
                "\n",
                "    @property\n",
                "    def grid_size(self):\n",
                "        \"Grid size pinned down by degree of polynomials\"\n",
                "        return {1: 20, 2: 100, 3: 300, 4: 1000, 5: 2000}[self.degree]"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "outputExpanded": false
            },
            "source": [
                "Notice that we have a namedtuple to hold the steady state of the model. Using\n",
                "the namedtuple infrastructure allows us to have convenient \"dot-style\" access\n",
                "to the steady state, without defining a full class.\n",
                "\n",
                "Given an instance of `Params` class, we can construct the grid on which we will\n",
                "solve the model.\n",
                "\n",
                "The `Grids` class holds this grid as well as matrices used to compute\n",
                "expectations.\n",
                "\n",
                "To match the Julia and Matlab versions of the code, the `__init__` method for\n",
                "`Grids` below loads pre-generated grids from a `.mat` file for both Sobol and\n",
                "random grids. This ensures that the exact same code is run in each language. If\n",
                "you would like to generate the grids in pure Python, you can set the\n",
                "`grid_source` keyword argument to `\"python\"`"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 5,
            "metadata": {
                "outputExpanded": false
            },
            "outputs": [],
            "source": [
                "class Grids(object):\n",
                "\n",
                "    def __init__(self, p, kind=\"random\", grid_source=\"mat\"):\n",
                "        m = p.grid_size\n",
                "        σ = np.array([p.σηR, p.σηa, p.σηL, p.σηu, p.σηB, p.σηG])\n",
                "        ρ = np.array([p.ρηR, p.ρηa, p.ρηL, p.ρηu, p.ρηB, p.ρηG])\n",
                "\n",
                "        if kind == \"sobol\":\n",
                "            if grid_source == \"mat\":\n",
                "                _path = os.path.join(DIR, \"Sobol_grids.mat\")\n",
                "                s = loadmat(_path)[\"Sobol_grids\"][:m, :]\n",
                "            else:\n",
                "                s = sobol_seq.i4_sobol_generate(8, m)\n",
                "            sη = s[:, :6]\n",
                "            η = (-2*σ + 4*(sη.max(0)-sη) / (sη.max(0)-sη.min(0))*σ)/np.sqrt(1-ρ**2)\n",
                "            R = 1+0.05*(np.max(s[:, 6])-s[:, 6])/(np.max(s[:, 6])-np.min(s[:, 6]))\n",
                "            δ = 0.95+0.05*(np.max(s[:, 7])-s[:, 7])/(np.max(s[:, 7])-np.min(s[:, 7]))\n",
                "        else:\n",
                "            # Values of exogenous state variables are distributed uniformly\n",
                "            # in the interval +/- std/sqrt(1-rho_nu**2)\n",
                "            if grid_source == \"mat\":\n",
                "                _path = os.path.join(DIR, \"random_grids.mat\")\n",
                "                s = loadmat(_path)[\"random_grids\"][:m, :]\n",
                "            else:\n",
                "                s = np.random.rand(m, 8)\n",
                "            sη = s[:, :6]\n",
                "            η = (-2*σ + 4*σ*sη) / np.sqrt(1-ρ**2)\n",
                "\n",
                "            # Values of endogenous state variables are distributed uniformly\n",
                "            # in the intervals [1 1.05] and [0.95 1], respectively\n",
                "            R = 1 + 0.05 * s[:, 6]\n",
                "            δ = 0.95 + 0.05 * s[:, 7]\n",
                "\n",
                "        ηR = η[:, 0]\n",
                "        ηa = η[:, 1]\n",
                "        ηL = η[:, 2]\n",
                "        ηu = η[:, 3]\n",
                "        ηB = η[:, 4]\n",
                "        ηG = η[:, 5]\n",
                "\n",
                "        self.ηR = ηR\n",
                "        self.ηa = ηa\n",
                "        self.ηL = ηL\n",
                "        self.ηu = ηu\n",
                "        self.ηB = ηB\n",
                "        self.ηG = ηG\n",
                "        self.R = R\n",
                "        self.δ = δ\n",
                "\n",
                "        # shape (8, m)\n",
                "        self.X = np.vstack([np.log(R), np.log(δ), η.T])\n",
                "\n",
                "        # shape (n_complete(8, p.Degree), m)\n",
                "        self.X0_G = {\n",
                "            1: complete_polynomial(self.X, 1),\n",
                "            p.degree: complete_polynomial(self.X, p.degree)\n",
                "        }\n",
                "\n",
                "        # shape (2*n=12, n=6)\n",
                "        self.ϵ_nodes, self.ω_nodes = qnwmonomial1(p.vcov)\n",
                "\n",
                "        # all shape (len(ϵ_nodes), m)\n",
                "        self.ηR1 = p.ρηR * ηR[None, :] + self.ϵ_nodes[:, None, 0]\n",
                "        self.ηa1 = p.ρηa * ηa[None, :] + self.ϵ_nodes[:, None, 1]\n",
                "        self.ηL1 = p.ρηL * ηL[None, :] + self.ϵ_nodes[:, None, 2]\n",
                "        self.ηu1 = p.ρηu * ηu[None, :] + self.ϵ_nodes[:, None, 3]\n",
                "        self.ηB1 = p.ρηB * ηB[None, :] + self.ϵ_nodes[:, None, 4]\n",
                "        self.ηG1 = p.ρηG * ηG[None, :] + self.ϵ_nodes[:, None, 5]"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "outputExpanded": false
            },
            "source": [
                "Finally, we construct the Model class, which has an instance of Params,\n",
                "SteadyState and Grids as its three attributes.\n",
                "\n",
                "This block of code will be longer than the others because we also include\n",
                "routines to solve and simulate the model as methods on the Model class. These\n",
                "methods will be clearly marked and commented."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 6,
            "metadata": {
                "outputExpanded": false
            },
            "outputs": [],
            "source": [
                "class Model(object):\n",
                "    def __init__(self, p=Params(), g=None):\n",
                "        if g is None:\n",
                "            g = Grids(p)\n",
                "\n",
                "        self.p = p\n",
                "        self.g = g\n",
                "        self.s = self.p.steady_state\n",
                "\n",
                "    def init_coefs(self, degree):\n",
                "        \"Iniital guess for coefs. We evaluate interpoland as coefs @ basis_mat\"\n",
                "        npol = self.g.X0_G[degree].shape[0]\n",
                "        coefs = np.full((3, npol), 1e-5)\n",
                "        coefs[:, 0] = [self.s.S, self.s.F, self.s.C**(-self.p.γ)]\n",
                "        return coefs\n",
                "\n",
                "    def step(self, S, F, C, δ0, R0, ηG, ηa, ηL, ηR):\n",
                "        # simplify notation\n",
                "        Θ, ϵ, gbar, ϑ, γ = self.p.Θ, self.p.ϵ, self.p.gbar, self.p.ϑ, self.p.γ\n",
                "        β, μ, ϕ_π, ϕ_y = self.p.β, self.p.μ, self.p.ϕ_π, self.p.ϕ_y\n",
                "        πstar = self.p.πstar\n",
                "\n",
                "        # Compute pie(t) from condition (35) in MM (2015)\n",
                "        π0 = ((1-(1-Θ)*(S/F)**(1-ϵ))/Θ)**(1/(ϵ-1))\n",
                "\n",
                "        # Compute delta(t) from condition (36) in MM (2015)\n",
                "        δ1 = ((1-Θ)*((1-Θ*π0**(ϵ-1))/(1-Θ))**(ϵ/(ϵ-1))+Θ*π0**ϵ/δ0)**(-1)\n",
                "\n",
                "        # Compute Y(t) from condition (38) in MM (2015)\n",
                "        Y0 = C/(1-gbar/exp(ηG))\n",
                "\n",
                "        # Compute L(t) from condition (37) in MM (2015)\n",
                "        L0 = Y0/exp(ηa)/δ1\n",
                "\n",
                "        #  Compute Yn(t) from condition (31) in MM (2015)\n",
                "        Yn0 = (exp(ηa)**(1+ϑ)*(1-gbar/exp(ηG))**(-γ)/exp(ηL))**(1/(ϑ+γ))\n",
                "\n",
                "        # Compute R(t) from conditions (27), (39) in MM (2015) -- Taylor rule\n",
                "        R1 = πstar/β*(R0*β/πstar)**μ*((π0/πstar)**ϕ_π * (Y0/Yn0)**ϕ_y)**(1-μ)*exp(ηR)\n",
                "\n",
                "        return π0, δ1, Y0, L0, Yn0, R1\n",
                "\n",
                "    def solve(self, damp=0.1, tol=1e-7, verbose=False):\n",
                "        # rename self to m to make code below readable\n",
                "        m = self\n",
                "\n",
                "        n = len(m.g.ηR)\n",
                "        n_nodes = len(m.g.ω_nodes)\n",
                "\n",
                "        ## allocate memory\n",
                "        # euler equations\n",
                "        e = np.zeros((3, n))\n",
                "\n",
                "        # previous iteration S, F, C\n",
                "        S0_old_G = np.ones(n)\n",
                "        F0_old_G = np.ones(n)\n",
                "        C0_old_G = np.ones(n)\n",
                "\n",
                "        # current iteration S, F, C\n",
                "        S0_new_G = np.ones(n)\n",
                "        F0_new_G = np.ones(n)\n",
                "        C0_new_G = np.ones(n)\n",
                "\n",
                "        # future S, F, C\n",
                "        S1 = np.zeros((n_nodes, n))\n",
                "        F1 = np.zeros((n_nodes, n))\n",
                "        C1 = np.zeros((n_nodes, n))\n",
                "\n",
                "        degs = [self.p.degree] if self.p.degree == 1 else [1, self.p.degree]\n",
                "\n",
                "        for deg in degs:\n",
                "            # housekeeping\n",
                "            err = 1.0\n",
                "            it = 0\n",
                "            X0_G = m.g.X0_G[deg]\n",
                "\n",
                "            start_time = time.time()\n",
                "\n",
                "            if deg <= 2:\n",
                "                coefs = self.init_coefs(deg)\n",
                "            else:\n",
                "                coefs = np.linalg.lstsq(X0_G.T, e.T)[0].T\n",
                "                # old_coefs = coefs.copy()\n",
                "                # coefs = self.init_coefs(deg)\n",
                "                # coefs[:, :old_coefs.shape[1]] = old_coefs\n",
                "\n",
                "            while err > tol:\n",
                "                it += 1\n",
                "                # Current choices (at t)\n",
                "                # ------------------------------\n",
                "                SFC0 = coefs @ X0_G\n",
                "                S0 = SFC0[0, :]                # Compute S(t) using coefs\n",
                "                F0 = SFC0[1, :]                # Compute F(t) using coefs\n",
                "                C0 = (SFC0[2, :])**(-1/m.p.γ)  # Compute C(t) using coefs\n",
                "                π0, δ1, Y0, L0, Yn0, R1 = self.step(\n",
                "                    S0, F0, C0, m.g.δ, m.g.R, m.g.ηG, m.g.ηa, m.g.ηL, m.g.ηR\n",
                "                )\n",
                "\n",
                "                if self.p.zlb:\n",
                "                    R1 = np.maximum(R1, 1.0)\n",
                "\n",
                "                for u in range(n_nodes):\n",
                "                    # Form complete polynomial of degree \"Degree\" (at t+1 states)\n",
                "                    grid1 = [np.log(R1), np.log(δ1), m.g.ηR1[u, :], m.g.ηa1[u, :],\n",
                "                             m.g.ηL1[u, :], m.g.ηu1[u, :], m.g.ηB1[u, :], m.g.ηG1[u, :]]\n",
                "\n",
                "                    X1 = complete_polynomial(grid1, deg)\n",
                "\n",
                "                    S1[u, :] = coefs[0, :] @ X1                # Compute S(t+1)\n",
                "                    F1[u, :] = coefs[1, :] @ X1                # Compute F(t+1)\n",
                "                    C1[u, :] = (coefs[2, :] @ X1)**(-1/m.p.γ)  # Compute C(t+1)\n",
                "\n",
                "                # Compute next-period π using condition\n",
                "                # (35) in MM (2015)\n",
                "                π1 = ((1-(1-m.p.Θ)*(S1/F1)**(1-m.p.ϵ))/m.p.Θ)**(1/(m.p.ϵ-1))\n",
                "\n",
                "                # Evaluate conditional expectations in the Euler equations\n",
                "                #---------------------------------------------------------\n",
                "                e[0, :] = exp(m.g.ηu)*exp(m.g.ηL)*L0**m.p.ϑ*Y0/exp(m.g.ηa) + m.g.ω_nodes @ (m.p.β*m.p.Θ*π1**m.p.ϵ*S1)\n",
                "                e[1, :] = exp(m.g.ηu)*C0**(-m.p.γ)*Y0 + m.g.ω_nodes @ (m.p.β*m.p.Θ*π1**(m.p.ϵ-1)*F1)\n",
                "                e[2, :] = m.p.β*exp(m.g.ηB)/exp(m.g.ηu)*R1 * (m.g.ω_nodes @ ((exp(m.g.ηu1)*C1**(-m.p.γ)/π1)))\n",
                "\n",
                "                # Variables of the current iteration\n",
                "                #-----------------------------------\n",
                "                np.copyto(S0_new_G, S0)\n",
                "                np.copyto(F0_new_G, F0)\n",
                "                np.copyto(C0_new_G, C0)\n",
                "\n",
                "                # Compute and update the coefficients of the decision functions\n",
                "                # -------------------------------------------------------------\n",
                "                coefs_hat = np.linalg.lstsq(X0_G.T, e.T)[0].T\n",
                "\n",
                "                # Update the coefficients using damping\n",
                "                coefs = damp*coefs_hat + (1-damp)*coefs\n",
                "\n",
                "                # Evaluate the percentage (unit-free) difference between the values\n",
                "                # on the grid from the previous and current iterations\n",
                "                # -----------------------------------------------------------------\n",
                "                # The convergence criterion is adjusted to the damping parameters\n",
                "                err = (np.mean(np.abs(1-S0_new_G/S0_old_G)) +\n",
                "                       np.mean(np.abs(1-F0_new_G/F0_old_G)) +\n",
                "                       np.mean(np.abs(1-C0_new_G/C0_old_G)))\n",
                "\n",
                "                # Store the obtained values for S(t), F(t), C(t) on the grid to\n",
                "                # be used on the subsequent iteration in Section 10.2.6\n",
                "                #-----------------------------------------------------------------------\n",
                "                np.copyto(S0_old_G, S0_new_G)\n",
                "                np.copyto(F0_old_G, F0_new_G)\n",
                "                np.copyto(C0_old_G, C0_new_G)\n",
                "\n",
                "                if it % 20 == 0 and verbose:\n",
                "                    print(\"On iteration {:d} err is {:6.7e}\".format(it, err))\n",
                "\n",
                "        elapsed = time.time() - start_time\n",
                "\n",
                "        return coefs, elapsed\n",
                "\n",
                "    def simulate(self, coefs=None, capT=10201):\n",
                "        if coefs is None:\n",
                "            coefs, elapsed = self.solve()\n",
                "\n",
                "        # rename self to m to make code below readable\n",
                "        m = self\n",
                "\n",
                "        # create namedtuple to hold simulation results in an organized container\n",
                "        Simulation = namedtuple(\n",
                "            \"Simulation\",\n",
                "            [\"nuR\", \"nua\", \"nuL\", \"nuu\", \"nuB\", \"nuG\",\n",
                "             \"δ\", \"R\", \"S\", \"F\", \"C\", \"π\", \"Y\", \"L\", \"Yn\", \"w\"]\n",
                "        )\n",
                "\n",
                "        # 11. Simualating a time-series solution\n",
                "        #---------------------------------------\n",
                "\n",
                "        # Initialize the values of 6 exogenous shocks and draw innovations\n",
                "        #-----------------------------------------------------------------\n",
                "        nuR = np.zeros(capT)\n",
                "        nua = np.zeros(capT)\n",
                "        nuL = np.zeros(capT)\n",
                "        nuu = np.zeros(capT)\n",
                "        nuB = np.zeros(capT)\n",
                "        nuG = np.zeros(capT)\n",
                "\n",
                "        # Generate the series for shocks\n",
                "        #-------------------------------\n",
                "        _path = os.path.join(DIR, \"epsi_test_NK.mat\")\n",
                "        rands = (loadmat(_path)[\"epsi_test_NK\"])\n",
                "        capT = rands.shape[0]\n",
                "        # rands = np.random.randn(capT-1, 6)\n",
                "\n",
                "        for t in range(capT-1):\n",
                "            nuR[t+1] = self.p.ρηR*nuR[t] + self.p.σηR*rands[t, 0]\n",
                "            nua[t+1] = self.p.ρηa*nua[t] + self.p.σηa*rands[t, 1]\n",
                "            nuL[t+1] = self.p.ρηL*nuL[t] + self.p.σηL*rands[t, 2]\n",
                "            nuu[t+1] = self.p.ρηu*nuu[t] + self.p.σηu*rands[t, 3]\n",
                "            nuB[t+1] = self.p.ρηB*nuB[t] + self.p.σηB*rands[t, 4]\n",
                "            nuG[t+1] = self.p.ρηG*nuG[t] + self.p.σηG*rands[t, 5]\n",
                "\n",
                "        # Allocate memory for time series of ...\n",
                "        δ = np.ones(capT+1)  # ... delta(t)\n",
                "        R = np.ones(capT+1)  # ... R(t)\n",
                "        S = np.ones(capT)    # ... S(t)\n",
                "        F = np.ones(capT)    # ... F(t)\n",
                "        C = np.ones(capT)    # ... C(t)\n",
                "        π = np.ones(capT)    # ... π(t)\n",
                "        Y = np.ones(capT)    # ... Y(t)\n",
                "        L = np.ones(capT)    # ... L(t)\n",
                "        Yn = np.ones(capT)   # ... Yn(t)\n",
                "        w = np.ones(capT)    # ... w(t)\n",
                "\n",
                "        pol_bases = np.empty(coefs.shape[1])\n",
                "        states = np.empty(8)\n",
                "\n",
                "        for t in range(capT):\n",
                "            states[0] = math.log(R[t])\n",
                "            states[1] = math.log(δ[t])\n",
                "            states[2] = nuR[t]\n",
                "            states[3] = nua[t]\n",
                "            states[4] = nuL[t]\n",
                "            states[5] = nuu[t]\n",
                "            states[6] = nuB[t]\n",
                "            states[7] = nuG[t]\n",
                "\n",
                "            _complete_poly_impl_vec(states, self.p.degree, pol_bases)\n",
                "\n",
                "            vals = coefs @ pol_bases\n",
                "            S[t] = vals[0]\n",
                "            F[t] = vals[1]\n",
                "            C[t] = (vals[2])**(-1/m.p.γ)\n",
                "\n",
                "            π[t], δ[t+1], Y[t], L[t], Yn[t], R[t+1] = self.step(\n",
                "                S[t], F[t], C[t], δ[t], R[t], nuG[t], nua[t], nuL[t], nuR[t]\n",
                "            )\n",
                "\n",
                "            # Compute real wage\n",
                "            w[t] = exp(nuL[t])*(L[t]**m.p.ϑ)*(C[t]**m.p.γ)\n",
                "\n",
                "            # If ZLB is imposed, set R(t)=1 if ZLB binds\n",
                "            if self.p.zlb:\n",
                "                R[t+1] = max(R[t+1], 1.0)\n",
                "\n",
                "        return Simulation(nuR, nua, nuL, nuu, nuB, nuG, δ, R, S, F, C, π, Y, L, Yn, w)\n",
                "\n",
                "    def residuals(self, coefs, sim, burn=200):\n",
                "        m = self  # rename self to m so the rest of this code is more readable\n",
                "        capT = len(sim.w)\n",
                "        resids = np.zeros((capT, 9))\n",
                "\n",
                "        # Integration method for evaluating accuracy\n",
                "        # ------------------------------------------\n",
                "        # Monomial integration rule with 2N**2+1 nodes\n",
                "        ϵ_nodes, ω_nodes = qnwmonomial2(m.p.vcov)\n",
                "        n_nodes = len(ω_nodes)\n",
                "\n",
                "        # Allocate for arrays needed in the loop\n",
                "        basis_mat = np.empty((8, n_nodes))\n",
                "        X1 = np.empty((coefs.shape[1], n_nodes))\n",
                "\n",
                "        nuR1 = np.empty(n_nodes)\n",
                "        nua1 = np.empty(n_nodes)\n",
                "        nuL1 = np.empty(n_nodes)\n",
                "        nuu1 = np.empty(n_nodes)\n",
                "        nuB1 = np.empty(n_nodes)\n",
                "        nuG1 = np.empty(n_nodes)\n",
                "\n",
                "        for t in range(capT):                 # For each given point,\n",
                "            # Take the corresponding value for shocks at t\n",
                "            #---------------------------------------------\n",
                "            nuR0 = sim.nuR[t]  # nuR(t)\n",
                "            nua0 = sim.nua[t]  # nua(t)\n",
                "            nuL0 = sim.nuL[t]  # nuL(t)\n",
                "            nuu0 = sim.nuu[t]  # nuu(t)\n",
                "            nuB0 = sim.nuB[t]  # nuB(t)\n",
                "            nuG0 = sim.nuG[t]  # nuG(t)\n",
                "\n",
                "            # Exctract time t values for all other variables (and t+1 for R, δ)\n",
                "            #------------------------------------------------------------------\n",
                "            R0 = sim.R[t]    # R(t-1)\n",
                "            δ0 = sim.δ[t]    # δ(t-1)\n",
                "            R1 = sim.R[t+1]  # R(t)\n",
                "            δ1 = sim.δ[t+1]  # δ(t)\n",
                "\n",
                "            L0 = sim.L[t]    # L(t)\n",
                "            Y0 = sim.Y[t]    # Y(t)\n",
                "            Yn0 = sim.Yn[t]  # Yn(t)\n",
                "            π0 = sim.π[t]    # π(t)\n",
                "            S0 = sim.S[t]    # S(t)\n",
                "            F0 = sim.F[t]    # F(t)\n",
                "            C0 = sim.C[t]    # C(t)\n",
                "\n",
                "            # Fill basis matrix with R1, δ1 and shocks\n",
                "            #-----------------------------------------\n",
                "            # Note that we do not premultiply by standard deviations as ϵ_nodes\n",
                "            # already include them. All these variables are vectors of length n_nodes\n",
                "            nuR1[:] = nuR0*m.p.ρηR + ϵ_nodes[:, 0]\n",
                "            nua1[:] = nua0*m.p.ρηa + ϵ_nodes[:, 1]\n",
                "            nuL1[:] = nuL0*m.p.ρηL + ϵ_nodes[:, 2]\n",
                "            nuu1[:] = nuu0*m.p.ρηu + ϵ_nodes[:, 3]\n",
                "            nuB1[:] = nuB0*m.p.ρηB + ϵ_nodes[:, 4]\n",
                "            nuG1[:] = nuG0*m.p.ρηG + ϵ_nodes[:, 5]\n",
                "\n",
                "            basis_mat[0, :] = np.log(R1)\n",
                "            basis_mat[1, :] = np.log(δ1)\n",
                "            basis_mat[2, :] = nuR1\n",
                "            basis_mat[3, :] = nua1\n",
                "            basis_mat[4, :] = nuL1\n",
                "            basis_mat[5, :] = nuu1\n",
                "            basis_mat[6, :] = nuB1\n",
                "            basis_mat[7, :] = nuG1\n",
                "\n",
                "            # Future choices at t+1\n",
                "            #----------------------\n",
                "            # Form a complete polynomial of degree \"Degree\" (at t+1) on future state\n",
                "            # variables; n_nodes-by-npol\n",
                "            _complete_poly_impl(basis_mat, self.p.degree, X1)\n",
                "\n",
                "            # Compute S(t+1), F(t+1) and C(t+1) in all nodes using coefs\n",
                "            S1 = coefs[0, :] @ X1\n",
                "            F1 = coefs[1, :] @ X1\n",
                "            C1 = (coefs[2, :] @ X1)**(-1/m.p.γ)\n",
                "\n",
                "            # Compute π(t+1) using condition (35) in MM (2015)\n",
                "            π1 = ((1-(1-m.p.Θ)*(S1/F1)**(1-m.p.ϵ))/m.p.Θ)**(1/(m.p.ϵ-1))\n",
                "\n",
                "            # Compute residuals for each of the 9 equilibrium conditions\n",
                "            #-----------------------------------------------------------\n",
                "            resids[t, 0] = 1 - (ω_nodes @\n",
                "                (exp(nuu0)*exp(nuL0)*L0**m.p.ϑ*Y0/exp(nua0) +\n",
                "                 m.p.β*m.p.Θ*π1**m.p.ϵ*S1)/S0\n",
                "            )\n",
                "            resids[t, 1] = 1 - (ω_nodes @\n",
                "                (exp(nuu0)*C0**(-m.p.γ)*Y0 + m.p.β*m.p.Θ*π1**(m.p.ϵ-1)*F1)/F0\n",
                "            )\n",
                "            resids[t, 2] = 1 - (ω_nodes @\n",
                "                (m.p.β*exp(nuB0)/exp(nuu0)*R1*exp(nuu1)*C1**(-m.p.γ)/π1)/C0**(-m.p.γ)\n",
                "            )\n",
                "\n",
                "            resids[t, 3] = 1 - ((1-m.p.Θ*π0**(m.p.ϵ-1))/(1-m.p.Θ))**(1/(1-m.p.ϵ))*F0/S0\n",
                "            resids[t, 4] = 1 - ((1-m.p.Θ)*((1-m.p.Θ*π0**(m.p.ϵ-1))/(1-m.p.Θ))**(m.p.ϵ/(m.p.ϵ-1)) + m.p.Θ*π0**m.p.ϵ/δ0)**(-1)/δ1\n",
                "            resids[t, 5] = 1 - exp(nua0)*L0*δ1/Y0\n",
                "            resids[t, 6] = 1 - (1-m.p.gbar/exp(nuG0))*Y0/C0\n",
                "            resids[t, 7] = 1 - (exp(nua0)**(1+m.p.ϑ)*(1-m.p.gbar/exp(nuG0))**(-m.p.γ)/exp(nuL0))**(1/(m.p.ϑ+m.p.γ))/Yn0\n",
                "            resids[t, 8] = 1 - m.s.π/m.p.β*(R0*m.p.β/m.s.π)**m.p.μ*((π0/m.s.π)**m.p.ϕ_π * (Y0/Yn0)**m.p.ϕ_y)**(1-m.p.μ)*exp(nuR0)/R1   # Taylor rule\n",
                "\n",
                "            # If the ZLB is imposed and R>1, the residuals in the Taylor rule (the\n",
                "            # 9th equation) are zero\n",
                "            if m.p.zlb and R1 <= 1:\n",
                "                resids[t, 8] = 0.0\n",
                "\n",
                "        return resids[burn:, :]"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "outputExpanded": false
            },
            "source": [
                "## Running the code\n",
                "\n",
                "Now that we've done all the hard work to define the model, its solution and\n",
                "simulation, and accuracy checks, let's put things together and run the code!"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 7,
            "metadata": {
                "outputExpanded": false
            },
            "outputs": [],
            "source": [
                "def ensurefile(url, localpath):\n",
                "    if not os.path.isfile(localpath):\n",
                "        print(\"Downloading {} to {}\".format(url, localpath))\n",
                "        with open(localpath, \"wb\") as f:\n",
                "            res = requests.get(url)\n",
                "            f.write(res.content)\n",
                "\n",
                "\n",
                "def main(m=None, file=None, plot=True, verbose=False):\n",
                "    ensurefile(\"https://github.com/sglyon/CLMMJuliaPythonMatlab/raw/master/NewKeynesian/Sobol_grids.mat\", \"Sobol_grids.mat\")\n",
                "    ensurefile(\"https://github.com/sglyon/CLMMJuliaPythonMatlab/raw/master/NewKeynesian/epsi_test_NK.mat\", \"epsi_test_NK.mat\")\n",
                "    ensurefile(\"https://github.com/sglyon/CLMMJuliaPythonMatlab/raw/master/NewKeynesian/random_grids.mat\", \"random_grids.mat\")\n",
                "\n",
                "    if m is None:\n",
                "        m = Model()\n",
                "\n",
                "    if file is None:\n",
                "        mprint = print\n",
                "    else:\n",
                "        def mprint(*x):\n",
                "            print(*x, file=file)\n",
                "\n",
                "    # solve the model\n",
                "    coefs, solve_time = m.solve(verbose=verbose)\n",
                "\n",
                "    # simulate the model\n",
                "    t1 = time.time()\n",
                "    sim = m.simulate(coefs)\n",
                "    sim_time = time.time() - t1\n",
                "\n",
                "    # check accuracy\n",
                "    t1 = time.time()\n",
                "    resids = m.residuals(coefs, sim)\n",
                "    resids_time = time.time() - t1\n",
                "\n",
                "    tot_time = solve_time + sim_time + resids_time\n",
                "    max_err = np.log10(np.abs(resids).max() + 1e-16)\n",
                "    max_err_eqn = np.log10(np.abs(resids).max(0) + 1e-16)\n",
                "    l1 = np.log10(np.abs(resids).mean() + 1e-16)\n",
                "\n",
                "    mprint(\"Solver time (in seconds): \", solve_time)\n",
                "    mprint(\"Simulation time (in seconds): \", sim_time)\n",
                "    mprint(\"Residuals time (in seconds): \", resids_time)\n",
                "    mprint(\"Total time (in seconds): \", tot_time)\n",
                "    mprint(\"\\nAPPROXIMATION ERRORS (log10):\")\n",
                "    mprint(\"\\ta) mean error in the model equations: {:0.3f}\".format(l1))\n",
                "    mprint(\"\\tb) max error in the model equations: {:0.3f}\".format(max_err))\n",
                "    mprint(\"\\tc) max error by equation: \", max_err_eqn)\n",
                "    mprint(\"tex row: {:.2f} & {:.2f} & {:.2f}\".format(l1, max_err, solve_time))\n",
                "\n",
                "    # plot simulated path of variables\n",
                "    if plot:\n",
                "        fig, ax = plt.subplots(2, 2, figsize=(10, 8))\n",
                "        t = np.arange(1, 101)\n",
                "        ax[0, 0].plot(t, sim.S[t], label=\"S\")\n",
                "        ax[0, 0].plot(t, sim.F[t], label=\"F\")\n",
                "        ax[0, 0].set_title(\"Figure 1a. S and F\")\n",
                "        ax[0, 0].legend()\n",
                "\n",
                "        ax[0, 1].plot(t, sim.Y[t], label=\"Y\")\n",
                "        ax[0, 1].plot(t, sim.Yn[t], label=\"Yn\")\n",
                "        ax[0, 1].set_title(\"Figure 1b. Output and natural output\")\n",
                "        ax[0, 1].legend()\n",
                "\n",
                "        ax[1, 0].plot(t, sim.C[t], label=\"C\")\n",
                "        ax[1, 0].plot(t, sim.L[t], label=\"L\")\n",
                "        ax[1, 0].set_title(\"Figure 1c. Consumption and labor\")\n",
                "        ax[1, 0].legend()\n",
                "\n",
                "        ax[1, 1].plot(t, sim.δ[t], label=\"δ\")\n",
                "        ax[1, 1].plot(t, sim.R[t], label=\"R\")\n",
                "        ax[1, 1].plot(t, sim.π[t], label=\"π\")\n",
                "        ax[1, 1].set_title(\"Figure 1d. Distortion, interest rate and inflation\")\n",
                "        ax[1, 1].legend()\n",
                "\n",
                "        return fig, solve_time, sim_time, resids_time, coefs, sim, resids, l1, max_err\n",
                "    else:\n",
                "        return None, solve_time, sim_time, resids_time, coefs, sim, resids, l1, max_err"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 8,
            "metadata": {
                "outputExpanded": false
            },
            "outputs": [],
            "source": [
                "def build_paper_table():\n",
                "    msg = \"starting πstar={πstar} and degree={degree} zlb={zlb}\"\n",
                "\n",
                "    with open(os.path.join(DIR, \"output.csv\"), \"w\") as f_csv:\n",
                "        f_csv.write(\"pi_star,zlb,degree,solve_time,l_1,l_inf\\n\")\n",
                "        with open(os.path.join(DIR, \"output.log\"), \"w\") as f:\n",
                "            for params in (dict(πstar=1.0, zlb=False),\n",
                "                           dict(πstar=1, zlb=True),\n",
                "                           dict(πstar=1 + 0.0598/4, zlb=False),):\n",
                "                for degree in range(1, 6):\n",
                "                    print(msg.format(degree=degree, **params))\n",
                "                    p = Params(degree=degree, **params)\n",
                "                    g = Grids(p, kind=\"sobol\")\n",
                "\n",
                "                    m = Model(p, g)\n",
                "\n",
                "                    print(msg.format(degree=degree, **params), file=f)\n",
                "                    outputs = main(m, f, plot=False)\n",
                "\n",
                "                    _stuff = [params[\"πstar\"], params[\"zlb\"]*1, degree,\n",
                "                              outputs[1], outputs[7], outputs[8]]\n",
                "                    f_csv.write(\",\".join(map(str, _stuff)) + \"\\n\")\n",
                "                    print(\"\\n\"*5, file=f)\n",
                "\n",
                "                    # flush io streams so we can see output in real time\n",
                "                    f_csv.flush()\n",
                "                    f.flush()"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 9,
            "metadata": {
                "outputExpanded": false
            },
            "outputs": [
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "/Users/sglyon/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:131: FutureWarning: `rcond` parameter will change to the default of machine precision times ``max(M, N)`` where M and N are the input matrix dimensions.\n",
                        "To use the future default and silence this warning we advise to pass `rcond=None`, to keep using the old, explicitly pass `rcond=-1`.\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Solver time (in seconds):  0.8275482654571533\n",
                        "Simulation time (in seconds):  0.6516990661621094\n",
                        "Residuals time (in seconds):  0.8314309120178223\n",
                        "Total time (in seconds):  2.310678243637085\n",
                        "\n",
                        "APPROXIMATION ERRORS (log10):\n",
                        "\ta) mean error in the model equations: -4.426\n",
                        "\tb) max error in the model equations: -2.199\n",
                        "\tc) max error by equation:  [ -2.19932463  -2.45903291  -2.36390504 -14.95892299 -16.\n",
                        " -15.49208397 -15.49208397 -16.         -16.        ]\n",
                        "tex row: -4.43 & -2.20 & 0.83\n"
                    ]
                },
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 720x576 with 4 Axes>"
                        ]
                    },
                    "metadata": {
                        "needs_background": "light"
                    },
                    "output_type": "display_data"
                }
            ],
            "source": [
                "if \"table\" in sys.argv:\n",
                "    build_paper_table()\n",
                "else:\n",
                "    results = main()"
            ]
        }
    ],
    "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.6.8"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 2
}