{ "cells": [ { "cell_type": "markdown", "id": "f5e7b1d0", "metadata": { "id": "f5e7b1d0" }, "source": [ "\"Open" ] }, { "cell_type": "markdown", "id": "7735eea6", "metadata": {}, "source": [ "# Notebook: Expansion Suite" ] }, { "cell_type": "markdown", "id": "ef624dcb", "metadata": { "id": "ef624dcb" }, "source": [ "We previously covered the small-noise expansion method and the recursive utility framework. This section covers the usage of `Expansion Suite`, an open source Python toolbox which uses these methods to solve discrete nonlinear DSGE models.\n", "\n", "This notebook provides both written explanations and accompanying code. The simplest way to run the code is to open the Google Colab link at the top of this page. Otherwise, the reader can copy the code snippets onto their local machine.\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "6f590ad3-c8d4-4fba-93f4-bf14f4f3364b", "metadata": {}, "source": [ "\n", "\n", "\n", "```{contents}\n", ":depth: 1\n", "```" ] }, { "cell_type": "markdown", "id": "e247ca61", "metadata": {}, "source": [ "Consider the framework previously introduced:\n", "\n", "$$\n", "\\begin{align}\n", "\\mathbb{E}[{N_{t+1}^*Q_{t+1}^* \\psi_1(X_t, J_t, X_{t+1}, J_{t+1})}|{\\mathfrak{A}_t}] - \\psi_2(X_t, J_t) &= 0 \\tag{1}\\\\\n", " \\phi\\left(X_t, X_{t+1}, J_t, {\\sf q}W_{t+1}, {\\sf q} \\right) &= 0 \n", "\\tag{2} \\end{align}\n", "$$\n", "\n", "The `Expansion Suite` uses the function `uncertain_expansion` to approximate a solution to the above system locally. It takes the following inputs:\n", "\n", "```{list-table}\n", ":header-rows: 1\n", "\n", "* - Input\n", " - Type\n", " - Description\n", "* - `eq`\n", " - *callable*\n", " - Function which takes state and jump variables and outputs error of equilibrium conditions, i.e. RHS of equation (1)\n", "* - `ss`\n", " - *callable*\n", " - Function which takes model parameters and outputs steady-state values of state and jump variables\n", "* - `var_shape`\n", " - *tuple of int*\n", " - Triple of integers $(n_J,n_X,n_W)$ where $n_J$ is the number of jump variables, $n_X$ is the number of state variables, and $n_W$ is the number of shocks.\n", "* - `args`\n", " - *tuple of float or ndarray*\n", " - Array of preference and model parameters\n", "* - `gc`\n", " - *callable*\n", " - Function which takes in variables and outputs log-growth of consumption\n", "* - `args`\n", " - tuple of float/ndarray\n", " - Preference and model parameters\n", "* - `gc`\n", " - *callable*\n", " - Function which takes in variables and outputs log-growth of consumption\n", "* - `approach`\n", " - *string*\n", " - If equal to '1', then solve the model using approach 1 (default, see Appendix C); If equal to '2', then use approach 2 (see Appendix D). The function raises an exception if other values are provided\n", "* - `init_util`\n", " - *dict, or None*\n", " - Dictionary for initialization of the expansion coefficients $\\mu^0, \\Upsilon_0^2, \\Upsilon_1^2,$ and $\\Upsilon_2^2$. The keys are: `mu_0`, `Upsilon_0`, `Upsilon_1`, `Upsilon_2`. If *None*, zero matrices are used\n", "* - `iter_tol`\n", " - *float*\n", " - Iteration stops when the maximum absolute difference between the approximated variables in the current and previous iteration is below `iter_tol`\n", "* - `max_iter`\n", " - *int*\n", " - Maximum number of iterations\n", "```\n", "\n", "The output is of class `ModelSolution`, which stores the coefficients for the linear-quadratic approximation for the jump and state variables; continuation values; consumption growth; and log change of measure, as well as the steady-state values of each variables. \n", "\n", "We will now walk through the computation using a simple example.\n", "
\n", "
" ] }, { "cell_type": "markdown", "id": "6f6c2319", "metadata": {}, "source": [ "# 1 AK Model with Recursive Utility" ] }, { "cell_type": "markdown", "id": "1141ee3e", "metadata": {}, "source": [ "## 1.1 Model Setup \n", "\n", "Consider the following recursive utility maximization problem with AK technology:\n", "\n", "$$\n", "\\max_{C_t, I_t} V_t = \\left[ (1 - \\beta) \\left(C_t\\right)^{1-\\rho} + \\beta \\left( R_t \\right)^{1-\\rho} \\right]^{\\frac 1 {1-\\rho}}\\tag{3}\n", "$$\n", "such that\n", "\n", "$$\n", "C_t + I_t = \\alpha K_t\n", "$$ \n", "\n", "$$\n", "\\log K_{t+1} - \\log K_t = \\frac 1 \\psi \\log \\left[ 1 + \\psi \\frac {I_t}{K_t} \\right] + \\beta_k Z_t - \\eta_k + \\sigma_k W_{t+1} \n", "$$ \n", "\n", "$$\n", "Z_{t+1} = \\exp( - \\beta_z) Z_t + \\sigma_z W_{t+1} \n", "$$ \n", "\n", "where $\\psi$ is adjustment cost parameter which determines the efficiency of converting investment to capital, and $\\eta_k$ is depreciation.\n", "$Z_t$ governs the (scalar) conditional mean of (stochastic) technology growth while $\\sigma_k$ governs the stochastic volatility of technology growth. \n", "$W_{t+1}$ is a two-dimensional Wiener process which provides the exogenous shocks to this model.\n", "\n", "For the purposes of computation, we divide the first two equations by $K_t$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.2 First-Order Conditions \n", "\n", "Let ${\\widehat G}_t = {\\widehat K}_t,$ $X_t = Z_t,$ and $D_t = \\frac {I_t }{K_t}.$ We can rewrite the previous equations as: \n", "\n", "$$\n", "{\\widehat C}_t = \\log \\left( \\alpha - D_t \\right) + {\\widehat G}_t \n", "$$ \n", "\n", "$$\n", "{\\widehat G}_{t + 1} - {\\widehat G}_t = \\frac 1 \\psi \\log \\left[ 1 + \\psi D_t \\right] + \\beta_k X_t - \\eta_k + \\sigma_k W_{t+1}\n", "$$ \n", "\n", "Apply the general form of FOC and costate equations and notice in this special case $\\psi^x_d = 0$, we have \n", "\n", "The FOC is \n", "\n", "$$\n", " \\mathbb{E} \\left[N^*_{t + 1}Q^*_{t + 1} \\beta \\left(\\frac{C_{t + 1}}{G_{t + 1}}\\right)^{-\\rho} \\left(\\frac{G_{t + 1}}{G_{t}}\\right)^{1-\\rho} \\left(\\frac{C_{t}}{G_{t}}\\right)^{\\rho} \\frac{1}{1 + \\psi D_t} \\widetilde{MG}_{t+1} \\right] - 1 = 0\n", "$$ \n", "\n", "The law of motion of costate $\\widetilde{MG}$ is \n", "\n", "$$\n", " \\mathbb{E} \\left[N^*_{t + 1}Q^*_{t + 1} \\beta \\left(\\frac{C_{t + 1}}{G_{t + 1}}\\right)^{-\\rho} \\left(\\frac{G_{t + 1}}{G_{t}}\\right)^{1-\\rho} \\left(\\frac{C_{t}}{G_{t}}\\right)^{\\rho} \\widetilde{MG}_{t+1} \\right ] - \\widetilde{MG}_t + \\frac{C_t}{G_t} = 0\n", "$$\n", "\n", "Finally, we can express our system of equations as\n", "\n", "$$\n", "\\psi_1 = \n", "\\begin{bmatrix}\n", "0\\\\ \n", "\\beta \\left(\\frac{C_{t + 1}}{G_{t + 1}}\\right)^{-\\rho} \\left(\\frac{G_{t + 1}}{G_{t}}\\right)^{1-\\rho} \\left(\\frac{C_{t}}{G_{t}}\\right)^{\\rho} \\frac{1}{1 + \\psi D_t} \\widetilde{MG}_{t+1} \\\\\n", "\\beta \\left(\\frac{C_{t + 1}}{G_{t + 1}}\\right)^{-\\rho} \\left(\\frac{G_{t + 1}}{G_{t}}\\right)^{1-\\rho} \\left(\\frac{C_{t}}{G_{t}}\\right)^{\\rho} \\widetilde{MG}_{t+1}\n", "\\end{bmatrix}\n", "$$\n", "\n", "\n", "$$\n", "\\psi_2 = \n", "\\begin{bmatrix}\n", "\\frac{C_t}{G_t} + D_t - {\\mathbf a}\\\\\n", "1\\\\\n", "\\widetilde{MG}_t - \\frac{C_t}{G_t}\n", "\\end{bmatrix}\n", "$$\n", "\n", "\n", "$$\\phi=\\begin{bmatrix} \n", "&\\frac{G_{t+1}} {G_t} - \\left( 1 + \\psi D_t \\right)^{\\frac{1}{\\psi}} + exp( \\beta_k Z_t - \\eta_k + \\sigma_k W_{t+1} ) \\\\\n", "&Z_{t+1} - \\exp( - \\beta_z) Z_t - \\sigma_z W_{t+1} \n", "\\end{bmatrix}$$\n", "\n", "\n", "The model has thre\n", "e jump variables (In the expansion suite, $J_t$ is used to represent the array of jump variables):\n", "- $\\log C_t - \\log G_t$ : Log consumption over capital\n", "- $\\log D_t$ : Log investment over capital\n", "- $\\log MG_t$ : Log co-state variable\n", "\n", "and two state variables (In the expansion suite, $X_t$ is used to represent state variables):\n", "- $\\log G_{t} - \\log G_{t-1}$ : Log capital growth process\n", "- $Z_{t}$ : Exogenous technology" ] }, { "cell_type": "markdown", "id": "f5e59370", "metadata": {}, "source": [ "
\n", "
\n", "
\n", "\n", "# 2 Inputs \n", "\n", "## 2.1 Libraries \n", "\n", "Begin by installing the following libraries and downloading `RiskUncertaintyValue`, which contains the functions required to solve the model:" ] }, { "cell_type": "code", "execution_count": 2, "id": "f0d30383", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "fatal: destination path 'RiskUncertaintyValue' already exists and is not an empty directory.\n" ] }, { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import os\n", "import sys\n", "workdir = os.getcwd()\n", "!git clone https://github.com/lphansen/RiskUncertaintyValue \n", "workdir = os.getcwd() + '/RiskUncertaintyValue' \n", "sys.path.insert(0, workdir+'/src') \n", "import numpy as np\n", "import autograd.numpy as anp\n", "from scipy import optimize\n", "np.set_printoptions(suppress=True)\n", "np.set_printoptions(linewidth=200)\n", "from IPython.display import display, HTML\n", "from BY_example_sol import disp\n", "display(HTML(\"\"))\n", "import warnings\n", "warnings.filterwarnings(\"ignore\")\n", "\n", "from lin_quad import LinQuadVar\n", "from lin_quad_util import E, concat, next_period, cal_E_ww, lq_sum, N_tilde_measure, E_N_tp1\n", "from uncertain_expansion import uncertain_expansion\n", "np.set_printoptions(suppress=True)" ] }, { "cell_type": "markdown", "id": "06a5ca90-4eec-48d3-862a-4a00d766b58e", "metadata": {}, "source": [ "## 2.2 Equilibrium Condition Function \n", "\n", "The first input for `uncertain_expansion` requires us to define the equilibrium conditions for the model. Therefore we define a function `eq` which takes in a list of jump and state variables as inputs, and outputs the equilibrium equations in the form of equations 1 and 2. The inputs required:\n", "\n", "```{list-table}\n", ":header-rows: 1\n", "\n", "* - Variable\n", " - Type\n", " - Description\n", " - Corresponds to\n", "* - `Var_t`\n", " - array-like\n", " - Vector of jump and state variables in the current period\n", " - $(J_t, X_t)$\n", "* - `Var_tp1`\n", " - array-like\n", " - Vector of jump and state variables in the next period\n", " - $(J_{t+1}, X_{t+1})$\n", "* - `W_tp1`\n", " - array-like\n", " - Vector of shock variables in the next period\n", " - $(W_{t+1})$\n", "* - `q`\n", " - float\n", " - Perturbation parameter\n", " - $q$\n", "* - `mode`\n", " - string\n", " - By default, this function returns the LHS of equation (1) and (2). Set mode to 'psi1', 'psi2', or 'phi' to return the corresponding function in the equilibrium conditions\n", " - \n", "* - `args`\n", " - tuple of float/ndarray\n", " - Preference and model parameters\n", " - \n", "```\n" ] }, { "cell_type": "markdown", "id": "ba75562f", "metadata": { "id": "ba75562f" }, "source": [ "\n", "While writing out `eq`, ensure that: \n", "\n", "- The first components of `Var_t` and `Var_tp1` are fixed as `q_t` or `q_tp1`.\n", "- State variables follow jump variables.\n", "- The number of jump variables (except `q_t` and `q_tp1`) equals the number of forward-looking equilibrium conditions. \n", "- The number of state variables equals to the number of state evolution equations.\n", "- All values are expressed as type `float`. Otherwise, this may cause type errors.\n", "\n", "Note that the log change of measure is skipped in the specification of equilibrium conditions. \n", "\n", "Notice that the first 3 parameters and $q$ in variables should be defined and called in the given order. \n", "\n", "For the example model, we write:" ] }, { "cell_type": "code", "execution_count": 3, "id": "6ae5d2d3", "metadata": { "id": "6ae5d2d3", "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "def eq_onecap_2d(Var_t, Var_tp1, W_tp1, q, mode, *args):\n", " \n", " # Unpack model parameters\n", " γ, β, ρ, a, ϕ_1, ϕ_2, α_k, beta_k, beta_z, sigma_k, sigma_z1, sigma_z2 = args\n", " w1_tp1, w2_tp1 = W_tp1.ravel()\n", "\n", " # Unpack model variables\n", " q_t, cmk_t, imk_t, mk_t, Z_t, gk_t = Var_t.ravel()\n", " q_tp1, cmk_tp1, imk_tp1, mk_tp1, Z_tp1, gk_tp1 = Var_tp1.ravel()\n", "\n", " # Intermedite varibles that facilitates computation\n", " sdf_ex = anp.log(β) - ρ*(cmk_tp1+gk_tp1-cmk_t)\n", " g_dep = -α_k + beta_k*Z_t + sigma_k*w1_tp1 - 0.5 * (sigma_k**2)\n", "\n", " ## Forward-looking conditions\n", " psi1_1 = 0.\n", " psi1_2 = anp.exp(sdf_ex + gk_tp1) * 1/(1 + ϕ_2*anp.exp(imk_t)) * mk_tp1\n", " psi1_3 = anp.exp(sdf_ex + gk_tp1) * mk_tp1\n", "\n", " psi2_1 = -a + anp.exp(cmk_t) + anp.exp(imk_t)\n", " psi2_2 = 1.\n", " psi2_3 = mk_t - anp.exp(cmk_t)\n", "\n", " # State evoluion processes\n", " phi_1 = Z_tp1 - beta_z*Z_t - sigma_z1*w1_tp1 - sigma_z2*w2_tp1\n", " phi_2 = gk_tp1 - ϕ_1 * anp.log(1.+ϕ_2*anp.exp(imk_t)) - g_dep\n", " \n", " if mode == 'psi1':\n", " return np.array([psi1_1, psi1_2, psi1_3])\n", " \n", " return anp.array([\n", " psi1_1 * anp.exp(q_tp1) - psi2_1,\n", " psi1_2 * anp.exp(q_tp1) - psi2_2,\n", " psi1_3 * anp.exp(q_tp1) - psi2_3,\n", " phi_1, phi_2])" ] }, { "cell_type": "markdown", "id": "d554abc5", "metadata": { "id": "d554abc5" }, "source": [ "## 2.3 Steady State Function \n", "\n", "This function takes model parameters as input and outputs the steady states for each variable following the variable order specified in `Var_t` and `Var_tp1`. To find the steady state, we remove the time subscripts from each variable and solve the system of equations. \n", "\n", "Note that the first entry of the output array will always be 0, since the steady state of `q_t` is 0." ] }, { "cell_type": "code", "execution_count": 4, "id": "e0d871c4", "metadata": { "id": "e0d871c4", "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "def ss_onecap_2d(*args):\n", "\n", " γ, β, ρ, a, ϕ_1, ϕ_2, α_k, beta_k, beta_z, sigma_k, sigma_z1, sigma_z2 = args\n", "\n", " def f(imk):\n", " g_k = ϕ_1 * np.log(1.+ ϕ_2 * np.exp(imk)) - α_k - 0.5 * (sigma_k**2)\n", " sdf_ex = np.log(β) - ρ*g_k\n", " cmk = np.log(a - np.exp(imk))\n", " mk = 1./(anp.exp(sdf_ex + g_k)* 1/(1 + ϕ_2*anp.exp(imk)))\n", " return mk - anp.exp(cmk) - anp.exp(sdf_ex + g_k) * mk\n", "\n", " imk = optimize.bisect(f,-10,-2.5)\n", " cmk = np.log(a - np.exp(imk))\n", " g_k = ϕ_1 * np.log(1. + ϕ_2 * np.exp(imk)) - α_k - 0.5 * (sigma_k**2)\n", " sdf_ex = np.log(β) - ρ*g_k\n", " mk = 1./(anp.exp(sdf_ex + g_k)* 1/(1 + ϕ_2*anp.exp(imk)))\n", "\n", " return np.array([0., cmk, imk, mk, 0., g_k])" ] }, { "cell_type": "markdown", "id": "aadc21b2", "metadata": { "id": "aadc21b2" }, "source": [ "## 2.4 Specifying Number of Variables \n", "\n", "We need to specify the number of jump variables, state and shock variables as an array `(n_J, n_X, n_W)`." ] }, { "cell_type": "code", "execution_count": 5, "id": "6f4f50b9", "metadata": { "id": "6f4f50b9", "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "var_shape = (3, 2, 2)" ] }, { "cell_type": "markdown", "id": "715b17d5", "metadata": { "id": "715b17d5" }, "source": [ "## 2.5 Model Parameters \n", "\n", "Next, we need to specify all the model parameters using a Python tuple. \n", "\n", "- The first three parameters should be γ, β, ρ, respectively. The package is designed for recursive utlity.\n", "- Please use 1.00001 for γ and ρ as approximation for 1.0.\n", "- We suggest not using matrix when specifying the equilibrium conditions and parameters.\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 6, "id": "43a4ac46", "metadata": { "id": "43a4ac46", "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "σ_k = 0.477*2\n", "sigmaz1 = 0.011*2\n", "sigmaz2 = 0.025*2\n", "\n", "delta = 0.01\n", "alpha = 0.0922\n", "\n", "a = alpha\n", "ϕ_1 = 1/8\n", "ϕ_2 = 8\n", "beta_k = 0.01\n", "beta_z1 = np.exp(-0.056)\n", "beta_z2 = np.exp(-0.145)\n", "beta_z3 = np.exp(-0.1)\n", "\n", "sigma_k = σ_k*0.01\n", "sigma_z1 = sigmaz1\n", "sigma_z2 = sigmaz2\n", "\n", "α_k = 0.04\n", "β = np.exp(-delta)\n", "γ = 12.0\n", "ρ = 1.5 \n", "\n", "args = (γ, β, ρ, a, ϕ_1, ϕ_2, α_k, beta_k, beta_z1, sigma_k, sigma_z1, sigma_z2)" ] }, { "cell_type": "markdown", "id": "238e1c2a", "metadata": { "id": "238e1c2a" }, "source": [ "## 2.6 Log Consumption Growth \n", "\n", "Finally, we need to specify how to compute the log-growth of consumption $\\log{C_{t+1}/C_t}$ using the defined variables `Var_t` and `Var_tp1` in the equilibrium conditions. \n", "\n", "In this example, we simply use the decomposition:\n", "\n", "$$\n", "\\log{C_{t+1}/C_t} = \\log{C_{t+1}/K_{t+1}} + \\log{K_{t+1}/K_t} - \\log{C_t/K_t}\n", "$$\n", "\n", "- The reason to specify log consumtion growth is that we need to approximate recursive utility as described in the notes section 3.2.2 and section 3.2.3\n", "- In habit formation models, $C_t$ is replaced with $U_t$, in which case we would specify the log growth process for $U_t$ correspondingly.\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "2e1398d3", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "def gc_onecap_2d(Var_t, Var_tp1, W_tp1, q, *args):\n", " \n", " # Unpack model parameters\n", " γ, β, ρ, a, ϕ_1, ϕ_2, α_k, beta_k, beta_z, sigma_k, sigma_z1, sigma_z2 = args\n", "\n", " # Unpack model variables\n", " q_t, cmk_t, imk_t, mk_t, Z_t, gk_t = Var_t.ravel()\n", " q_tp1, cmk_tp1, imk_tp1, mk_tp1, Z_tp1, gk_tp1 = Var_tp1.ravel()\n", "\n", " # Compute log consumption growth\n", " gc_tp1 = cmk_tp1 + gk_tp1 - cmk_t\n", " \n", " return gc_tp1" ] }, { "cell_type": "markdown", "id": "020b982b", "metadata": { "id": "020b982b" }, "source": [ "## 2.7 Computing ModelSol \n", "\n", "Now we are able to use steps 2.1 to 2.5 as inputs to the `uncertain_expansion` function. The solution is stored in a class named `ModelSolution`(Please refer to uncertainexpansion.ipynb for details.) under the Linear Quadratic Framework. \n", "\n", "See [src/uncertain_expansion.py](https://github.com/lphansen/RiskUncertaintyValue/blob/main/src/uncertain_expansion.py) for the source code of the expansion suite.\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "217c9448", "metadata": { "id": "217c9448", "outputId": "aab57b59-6dce-4452-dfde-a6ee003cdbd7", "tags": [ "hide-cell" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Iteration 1: error = 0.0211794947\n", "Iteration 2: error = 2.77555756e-17\n" ] } ], "source": [ "# Solve the One-Capital Adjustment Model\n", "eq = eq_onecap_2d\n", "ss = ss_onecap_2d\n", "gc = gc_onecap_2d\n", "var_shape = (3, 2, 2)\n", "args = (γ, β, ρ, a, ϕ_1, ϕ_2, α_k, beta_k, beta_z1, sigma_k, sigma_z1, sigma_z2)\n", "approach = '1' # See Exploring Recursive Utility Appendix for difference about approach '1' and '2'\n", "ModelSol = uncertain_expansion(eq, ss, var_shape, args, gc, approach = '1')" ] }, { "cell_type": "markdown", "id": "961bdc55", "metadata": { "id": "961bdc55" }, "source": [ "
\n", "
\n", "
\n", "\n", "# 3 Outputs\n", "\n", "## 3.1 List of Outputs \n", "\n", "We now examine the contents of `ModelSol`, which contains the attributes listed below. Each approximation is stored in a class `LinQuadVar`, which contains the coefficients for $X_{1,t}, X_{2,t}, X_{1,t}'X_{1,t}, W_{t+1}, W_{t+1}'W_{t+1}, X_{1,t}'W_{t+1}$ and the constant.\n", "\n", "\n", "```{list-table}\n", ":header-rows: 1\n", "\n", "* - Input\n", " - Type\n", " - Description\n", "* - `JXn_t`\n", " - *LinQuadVar*\n", " - Approximation of jump and state variables at time $t$. Replace `n` with `0,1,2` to get the zeroth, first and second-order contribution. Omit `n` to get the full approximation. The variables are indexed in the order specified in Section 2. \n", "* - `Jn_t`\n", " - *LinQuadVar*\n", " - Same as `JXn_t` but limited to jump variables.\n", "* - `Xn_tp1`\n", " - *LinQuadVar*\n", " - Same as `JXn_t` but limited to state variables.\n", "* - `JXn_t_tilde`\n", " - *LinQuadVar*\n", " - Same as `JXn_t` but using distorted measure. This variation is also available for `Jn_t` and `Xn_tp1`.\n", "* - `util_sol`\n", " - *dict*\n", " - Dictionary containing solutions of the continuation values, including $\\mu^0, \\Upsilon_0^2, \\Upsilon_1^2,$ and $\\Upsilon_2^2$ etc.\n", "* - `vmrn_tp1`\n", " - *LinQuadVar*\n", " - Approximation of continuation values $\\widehat{V}^1_{t+1}-\\widehat{R}^1_t$ . Replace `n` with `0,1,2` to get the zeroth, first and second-order contribution. Omit `n` to get the full approximation. \n", "* - `gcn_tp1`\n", " - *LinQuadVar*\n", " - Approximation of consumption growth $\\widehat{C}_{t+1}-\\widehat{C}_t$ . Replace `n` with `0,1,2` to get the zeroth, first and second-order contribution. Omit `n` to get the full approximation. \n", "* - `ss`\n", " - *dict*\n", " - Steady states for state and jump variables\n", "* - `log_N_tilde`\n", " - *LinQuadVar*\n", " - Approximation for the log change of measure\n", "```\n", "\n", "For example, we can obtain the coefficients for the first-order contribution of $\\log{C_t/K_t}$ in the following way, noting that `cmk_t` was listed as the first jump variable when we specified the equilibrum conditions.\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "3fa57ffa", "metadata": { "id": "3fa57ffa", "outputId": "1cdb816b-4ed7-4c19-e009-60fdcf049004", "tags": [] }, "outputs": [ { "data": { "text/plain": [ "{'x': array([[ 0.04344641, -0. ]]), 'c': array([[-0.02117949]])}" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "## Log consumption over capital approximation results, shown in the LinQuadVar coefficients form\n", "ModelSol['JX1_t'][0].coeffs" ] }, { "cell_type": "markdown", "id": "6b4f132c", "metadata": {}, "source": [ "We can also display the full second-order approximation of $\\log{C_t/K_t}$ using the `disp` function, which renders a `LinQuadVar` object in LATEX form." ] }, { "cell_type": "code", "execution_count": 10, "id": "a21c4b7d", "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\log\\frac{C_t}{K_t}=-3.683+\\begin{bmatrix}0.04379&-1.477e-19\\end{bmatrix}X_t^1+\\begin{bmatrix}0.02172&-7.372e-20\\end{bmatrix}X_t^2+X^{1T}_{t}\\begin{bmatrix}-0.0002216&5.549e-21\\\\-4.919e-21&-1.892e-38\\end{bmatrix}X^1_{t}$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## Log consumption over capital approximation results, shown in the Latex analytical form\n", "disp(ModelSol['JX_t'][0],'\\\\log\\\\frac{C_t}{K_t}') " ] }, { "cell_type": "markdown", "id": "2c2d4266", "metadata": {}, "source": [ "Another example:" ] }, { "cell_type": "code", "execution_count": 11, "id": "d5b18ec2", "metadata": { "id": "d5b18ec2", "outputId": "1b2ebb60-d294-4281-e573-a76dcbc55b4d" }, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\log\\frac{K_{t+1}^2}{K_t^2}=\\begin{bmatrix}0.9455&-0\\end{bmatrix}X_t^2$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## Log capital growth process second order approximation results\n", "disp(ModelSol['X2_tp1'][0],'\\\\log\\\\frac{K_{t+1}^2}{K_t^2}') " ] }, { "cell_type": "markdown", "id": "0190ee8e", "metadata": { "id": "0190ee8e" }, "source": [ "\n", "## 3.2 Approximate Related Variables \n", "\n", "We can use the method `ModelSol.approximate` to approximate variables which can be expressed as functions of the state and jump variables. For example, suppose we want to approximate log investment growth $\\log{I_{t+1}/I_t}$. We can express this as:\n", "\n", "$$\n", "\\log{I_{t+1}/I_t} = \\log{I_{t+1}/K_{t+1}} + \\log{K_{t+1}/K_t} - \\log{I_t/K_t}\n", "$$\n", "\n", "We use this expression to write the function `gi_tp1_approx`, which is used as an input in `ModelSol.approximate` below." ] }, { "cell_type": "code", "execution_count": 12, "id": "145a47f6", "metadata": { "id": "145a47f6", "outputId": "ae3e6f0d-39c8-47a6-b2b3-934eaa6cffaa", "tags": [ "hide-cell" ] }, "outputs": [ { "data": { "text/plain": [ "{'x': array([[ 0.01018563, -0. ]]),\n", " 'c': array([[0.00035532]]),\n", " 'w': array([[ 0.00917057, -0.00083961]])}" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def gi_tp1_approx(Var_t, Var_tp1, W_tp1, q, *args):\n", "\n", " # Parameters for the model\n", " γ, β, ρ, a, ϕ_1, ϕ_2, α_k, beta_k, beta_z1, sigma_k, sigma_z1, sigma_z2 = args\n", "\n", " # Variables: (q_t, q_tp1 is excluded when using the method in `ModelSolution`)\n", " cmk_t, imk_t, mkmc_t, Z_t, gk_t = Var_t.ravel()\n", " cmk_tp1, imk_tp1, mkmc_tp1, Z_tp1, gk_tp1 = Var_tp1.ravel()\n", " \n", " gi_tp1 = imk_tp1 + gk_tp1 -imk_t\n", " \n", " return gi_tp1\n", "\n", "n_J, n_X, n_W = var_shape\n", "gi_tp1_list = ModelSol.approximate(gi_tp1_approx, args)\n", "gi_tp1 = {'gi_tp1':gi_tp1_list[0],\\\n", " 'gi0_tp1':gi_tp1_list[1],\\\n", " 'gi1_tp1':gi_tp1_list[2],\\\n", " 'gi2_tp1':gi_tp1_list[3]}\n", "gi_tp1['gi1_tp1'].coeffs" ] }, { "cell_type": "markdown", "id": "bbd28ede", "metadata": { "id": "bbd28ede" }, "source": [ "
\n", "\n", "## 3.3 Simulate Variables \n", "Given a series of shock processes, we can simulate the path of our state and jump variables using the `ModelSolution.simulate` method. Here, we simulate 400 periods of i.i.d standard multivariate normal shocks." ] }, { "cell_type": "code", "execution_count": 13, "id": "58417c59", "metadata": { "id": "58417c59" }, "outputs": [], "source": [ "Ws = np.random.multivariate_normal(np.zeros(n_W),np.eye(n_W),size = 400)\n", "JX_sim = ModelSol.simulate(Ws)" ] }, { "cell_type": "markdown", "id": "738d5ef7", "metadata": { "id": "738d5ef7" }, "source": [ "
\n", "\n", "## 3.4 Shock Elasticities and IRF \n", "\n", "`ModelSolution` contains a method `elasticities` used to compute the shock elasticities of jump and state variables. We do this by defining a `log_SDF_ex` function, which expresses the log stochastic discount factor exclusive of the change of measure ${N}^*_{t+1}$ and variable $Q_{t+1}^*$. Shock elasticities are great tools for nonlinear impulsive response analyses, and in linear models, the shock elasticities correspond to the traditional impulse response function (IRF). \n", "\n", "`ModelSolution` also has a method `IRF` to compute the traditional IRF of all jump and state variables. Below we calculate the IRF of all variables with respect to the first shock for 400 periods.\n", "\n", "The figure plots elasticities and IRF of investment rate with regard to shock 1. " ] }, { "cell_type": "code", "execution_count": 14, "id": "c2fb03dd", "metadata": { "id": "c2fb03dd", "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "def log_SDF_ex(Var_t, Var_tp1, W_tp1, q, *args):\n", "\n", " # Log stochastic discount factor exclusive of the change of measure N and Q.\n", "\n", " # Parameters for the model \n", " γ, β, ρ, a, ϕ_1, ϕ_2, α_k, beta_k, beta_z, sigma_k1, sigma_k2, sigma_z = args\n", "\n", " # Variables: (q_t, q_tp1 is excluded when using the method in `ModelSolution`) \n", " cmk_t, imk_t, mk_t, Z_t, gk_t = Var_t.ravel()\n", " cmk_tp1, imk_tp1, mk_tp1, Z_tp1, gk_tp1 = Var_tp1.ravel()\n", "\n", " sdf_ex = anp.log(β) - ρ*(cmk_tp1+gk_tp1-cmk_t)\n", " \n", " return sdf_ex\n", "\n", "expo_elas, price_elas = ModelSol.elasticities(log_SDF_ex, T=40, shock=0)\n", "states, controls = ModelSol.IRF(T = 40, shock = 0) " ] }, { "cell_type": "code", "execution_count": 15, "id": "a60531f0", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "time_periods = list(range(1, 41)) # 40 time periods starting from 1\n", "\n", "fig, axs = plt.subplots(1, 3, figsize=(15, 5)) # Adjust the figure size as needed\n", "\n", "# Plotting Exposure Elasticity in the first subfigure\n", "axs[0].plot(time_periods, expo_elas[:, 1], label='Exposure Elasticity', marker='o')\n", "axs[0].set_xlabel('Time Period')\n", "axs[0].set_ylabel('Exposure Elasticity')\n", "axs[0].set_title('Exposure Elasticity Over Time')\n", "axs[0].grid(True)\n", "\n", "# Plotting Price Elasticity in the second subfigure\n", "axs[1].plot(time_periods, price_elas[:, 1], label='Price Elasticity', marker='x')\n", "axs[1].set_xlabel('Time Period')\n", "axs[1].set_ylabel('Price Elasticity')\n", "axs[1].set_title('Price Elasticity Over Time')\n", "axs[1].grid(True)\n", "\n", "# Plotting IRF in the third subfigure\n", "axs[2].plot(time_periods, controls[:, 1], label='IRF', marker='^')\n", "axs[2].set_xlabel('Time Period')\n", "axs[2].set_ylabel('Impulse Response')\n", "axs[2].set_title('IRF Over Time')\n", "axs[2].grid(True)\n", "\n", "plt.tight_layout()\n", "plt.show()\n", "\n" ] }, { "cell_type": "markdown", "id": "eab36438", "metadata": { "id": "eab36438" }, "source": [ "
\n", "
\n", "\n", "# 4 Using `LinQuadVar` in Computation \n", "\n", "In the previous section, we saw how to use `uncertain_expansion` to approximate variables and store their coefficients as `LinQuadVar` objects. In this section, we explore how to manipulate `LinQuadVar` objects for different uses.\n", "\n", "To aid our examples, we first extract the steady states for the state evolution processes from the previous model solution:\n", "\n", "See [src/lin_quad.py](https://github.com/lphansen/RiskUncertaintyValue/blob/main/src/lin_quad.py) for source code of `LinQuadVar` definition." ] }, { "cell_type": "code", "execution_count": 43, "id": "b5d7ee6b", "metadata": { "id": "b5d7ee6b", "outputId": "882669aa-3be7-4c20-dd54-1273a7c1826d" }, "outputs": [ { "data": { "text/plain": [ "{'c': array([[-2.71057934],\n", " [ 1.5576879 ]])}" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n_J, n_X, n_W = ModelSol['var_shape']\n", "X0_tp1 = LinQuadVar({'c':np.array([[ModelSol['ss'][1]],[ModelSol['ss'][2]]])}, shape = (2, n_X, n_W))\n", "X0_tp1.coeffs" ] }, { "cell_type": "markdown", "id": "a5270666", "metadata": { "id": "a5270666" }, "source": [ "## 4.1 `LinQuadVar` Operations \n", "We can sum multiple LinQuads together in two different ways. Here we demonstrate this with an example by summing the zeroth, first and second order contributions of our approximation for capital growth. " ] }, { "cell_type": "code", "execution_count": 44, "id": "205dd148", "metadata": { "id": "205dd148", "outputId": "75bfa88f-3b99-4535-cf0d-121591eae233" }, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\log\\frac{K_{t+1}}{K_t}=-2.711+\\begin{bmatrix}0.9455&0\\end{bmatrix}X_t^1+\\begin{bmatrix}0.022&0.05\\end{bmatrix}W_{t+1}+\\begin{bmatrix}0.4728&0\\end{bmatrix}X_t^2$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "gk_tp1 = X0_tp1[0] + ModelSol['X1_tp1'][0] + 0.5 * ModelSol['X2_tp1'][0] \n", "disp(gk_tp1,'\\\\log\\\\frac{K_{t+1}}{K_t}') " ] }, { "cell_type": "markdown", "id": "f901b7a3", "metadata": {}, "source": [ "In the next example, we sum together the contributions for both capital growth and technology:" ] }, { "cell_type": "code", "execution_count": 45, "id": "b5747b24", "metadata": { "id": "b5747b24", "outputId": "b23404ea-0275-4a57-812e-a675e5f3d37d" }, "outputs": [ { "data": { "text/plain": [ "{'c': array([[-2.71057934],\n", " [ 1.55804585]]),\n", " 'w': array([[0.022 , 0.05 ],\n", " [0.00954, 0. ]]),\n", " 'x2': array([[0.47276957, 0. ],\n", " [0.00463556, 0. ]]),\n", " 'xx': array([[ 0. , 0. , 0. , 0. ],\n", " [-0.00001424, -0. , 0. , 0. ]]),\n", " 'x': array([[0.94553914, 0. ],\n", " [0.00928281, 0. ]])}" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "lq_sum([X0_tp1, ModelSol['X1_tp1'], 0.5 * ModelSol['X2_tp1']]).coeffs" ] }, { "cell_type": "markdown", "id": "5c1952e3", "metadata": { "id": "5c1952e3" }, "source": [ "## 4.2 `LinQuadVar` Split and Concat \n", "`split` breaks multiple dimensional LinQuad into one-dimensional LinQuads, while `concat` does the inverse." ] }, { "cell_type": "code", "execution_count": 46, "id": "d085149f", "metadata": { "id": "d085149f", "outputId": "a6bdf64b-17a6-48c5-b159-5715a34e0174" }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "gk_tp1, Z_tp1 = ModelSol['X1_tp1'].split()\n", "concat([gk_tp1, Z_tp1])" ] }, { "cell_type": "markdown", "id": "e67b04c1", "metadata": { "id": "e67b04c1" }, "source": [ "## 4.3 Evaluate a `LinQuadVar` \n", "We can evaluate a LinQuad at specific state $(X_{t},W_{t+1})$ in time. As an example, we evaluate all 5 variables under steady state with a multivariate random normal shock." ] }, { "cell_type": "code", "execution_count": 47, "id": "5782676a", "metadata": { "id": "5782676a", "outputId": "0e8e4471-839b-4679-c7a2-fd8d6a8e6879" }, "outputs": [ { "data": { "text/plain": [ "array([[-3.68228516],\n", " [-2.70254332],\n", " [ 1.56144343],\n", " [ 0.01147443],\n", " [ 0.02648373]])" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x1 = np.zeros([n_X ,1])\n", "x2 = np.zeros([n_X ,1])\n", "w = np.random.multivariate_normal(np.zeros(n_W),np.eye(n_W),size = 1).T\n", "ModelSol['JX_tp1'](*(x1,x2,w))" ] }, { "cell_type": "markdown", "id": "5051f96c", "metadata": { "id": "5051f96c" }, "source": [ "## 4.4 Next period expression for `LinQuadVar` \n", "`ModelSol` allows us to express a jump variable $J_t$ as a function of $t$ state and shock variables. Suppose we would like to compute its next period expression $J_{t+1}$ with shocks. The function `next_period` expresses $J_{t+1}$ in terms of $t$ state variables and $t+1$ shock variables. For example, we can express the $t+1$ expression for the first-order contribution to consumption over capital as:" ] }, { "cell_type": "code", "execution_count": 48, "id": "7e088a47", "metadata": { "id": "7e088a47", "outputId": "116af9b7-9791-4391-b7a4-8d9ee133baff" }, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\log\\frac{C_{t+1}^1}{K_{t+1}^1}=-0.02118+\\begin{bmatrix}0.04108&-3.647e-40\\end{bmatrix}X_t^1+\\begin{bmatrix}0.0009558&0.002172\\end{bmatrix}W_{t+1}$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "cmk1_tp1 = next_period(ModelSol['J1_t'][0], ModelSol['X1_tp1'])\n", "disp(cmk1_tp1, '\\\\log\\\\frac{C_{t+1}^1}{K_{t+1}^1}') " ] }, { "cell_type": "code", "execution_count": 49, "id": "fa8ab664", "metadata": { "id": "fa8ab664", "outputId": "f4244fa2-2a8a-4a42-8a33-2ab7407c7c8d" }, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\log\\frac{C_{t+1}^2}{K_{t+1}^2}=-0.0008222+\\begin{bmatrix}0.0006544&1.448e-41\\end{bmatrix}X_t^1+\\begin{bmatrix}1.523e-05&3.46e-05\\end{bmatrix}W_{t+1}+\\begin{bmatrix}0.04108&-3.647e-40\\end{bmatrix}X_t^2+X^{1T}_{t}\\begin{bmatrix}-0.0003962&3.544e-41\\\\-6.531e-41&-3.263e-59\\end{bmatrix}X^1_{t}+X^{1T}_{t}\\begin{bmatrix}-1.844e-05&-4.191e-05\\\\6.864e-44&1.56e-43\\end{bmatrix}W_{t+1}+W_{t+1}^{T}\\begin{bmatrix}-2.145e-07&-4.875e-07\\\\-4.875e-07&-1.108e-06\\end{bmatrix}W_{t+1}$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "cmk2_tp1 = next_period(ModelSol['J2_t'][0], ModelSol['X1_tp1'], ModelSol['X2_tp1'])\n", "disp(cmk2_tp1, '\\\\log\\\\frac{C_{t+1}^2}{K_{t+1}^2}') " ] }, { "cell_type": "markdown", "id": "daa0c4c1", "metadata": { "id": "daa0c4c1" }, "source": [ "## 4.6 Compute the Expectation of time $t+1$ `LinQuadVar` \n", "\n", "Suppose the distribution of shocks has a constant mean and variance (not state dependent). Then, we can use the `E` function to compute the expectation of a time $t+1$ `LinQuadVar` as follows:\n" ] }, { "cell_type": "code", "execution_count": 50, "id": "3140272c", "metadata": { "id": "3140272c", "outputId": "418a75e2-ff56-4bd7-8471-67634f26654c" }, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\mathbb{E}[\\log\\frac{C_{t+1}^2}{K_{t+1}^2}|\\mathfrak{F_t}]=-0.0008284+\\begin{bmatrix}0.0006602&1.446e-41\\end{bmatrix}X_t^1+\\begin{bmatrix}0.04108&-3.647e-40\\end{bmatrix}X_t^2+X^{1T}_{t}\\begin{bmatrix}-0.0003962&3.544e-41\\\\-6.531e-41&-3.263e-59\\end{bmatrix}X^1_{t}$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "E_w = ModelSol['util_sol']['μ_0']\n", "cov_w = np.eye(n_W)\n", "E_ww = cal_E_ww(E_w, cov_w)\n", "E_cmk2_tp1 = E(cmk2_tp1, E_w, E_ww)\n", "disp(E_cmk2_tp1, '\\mathbb{E}[\\\\log\\\\frac{C_{t+1}^2}{K_{t+1}^2}|\\mathfrak{F_t}]')" ] }, { "cell_type": "markdown", "id": "18a1686c", "metadata": { "id": "18a1686c" }, "source": [ "Suppose the distribution of shock has a state-dependent mean and variance (implied by $\\tilde{N}_{t+1}$ shown in the notes), we can use `E_N_tp1` and `N_tilde_measure` to compute the expectation of time $t+1$ `LinQuadVar`." ] }, { "cell_type": "code", "execution_count": 51, "id": "a58482f7", "metadata": { "id": "a58482f7", "outputId": "b8f2fc85-7c37-4d01-a5ed-c6b4d6d940a0" }, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\mathbb{\\tilde{E}}[\\log\\frac{C_{t+1}^2}{K_{t+1}^2}|\\mathfrak{F_t}]=-0.0008284+\\begin{bmatrix}0.0006602&1.446e-41\\end{bmatrix}X_t^1+\\begin{bmatrix}0.04108&-3.647e-40\\end{bmatrix}X_t^2+X^{1T}_{t}\\begin{bmatrix}-0.0003963&3.544e-41\\\\-6.531e-41&-3.263e-59\\end{bmatrix}X^1_{t}$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "N_cm = N_tilde_measure(ModelSol['util_sol']['log_N_tilde'],(1,n_X,n_W))\n", "E_cmk2_tp1_tilde = E_N_tp1(cmk2_tp1, N_cm)\n", "disp(E_cmk2_tp1_tilde, '\\mathbb{\\\\tilde{E}}[\\\\log\\\\frac{C_{t+1}^2}{K_{t+1}^2}|\\mathfrak{F_t}]')" ] } ], "metadata": { "colab": { "provenance": [] }, "interpreter": { "hash": "1c67a9c81f4b1f676ee52b818d3e176be5c9dd44f82a35d6054954eb94c37bc5" }, "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.8" } }, "nbformat": 4, "nbformat_minor": 5 }