From 641e0bce7b8e6256d979efc350426525256db0c4 Mon Sep 17 00:00:00 2001 From: AMonninger Date: Tue, 28 May 2024 10:16:24 -0400 Subject: [PATCH 1/2] Integration Example v1 --- ...nsumerType_IntegrationMethod_Example.ipynb | 629 ++++++++++++++++++ 1 file changed, 629 insertions(+) create mode 100644 examples/ConsIndShockModel/IndShockConsumerType_IntegrationMethod_Example.ipynb diff --git a/examples/ConsIndShockModel/IndShockConsumerType_IntegrationMethod_Example.ipynb b/examples/ConsIndShockModel/IndShockConsumerType_IntegrationMethod_Example.ipynb new file mode 100644 index 000000000..6134e6162 --- /dev/null +++ b/examples/ConsIndShockModel/IndShockConsumerType_IntegrationMethod_Example.ipynb @@ -0,0 +1,629 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cfe8f06b", + "metadata": {}, + "source": [ + "# Integration Method by Matt (Example using `IndShockConsumer`)\n", + "\n", + "Constructing End of Period (Marginal) Value Function using Transitionmatrices instead of Expectations.\n", + "This notebook shows the necessary steps to construct the function. For simplicity, we will only focus on transitory shock without unemployment probability nor permanent shocks.\n", + "\n", + "Idea by Matt White\n", + "Code by Adrian Monninger" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "915c0bb6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adria\\anaconda3\\envs\\Durable\\lib\\site-packages\\numba\\core\\decorators.py:262: NumbaDeprecationWarning: \u001b[1mnumba.generated_jit is deprecated. Please see the documentation at: https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-generated-jit for more information and advice on a suitable replacement.\u001b[0m\n", + " warnings.warn(msg, NumbaDeprecationWarning)\n" + ] + } + ], + "source": [ + "from HARK.econforgeinterp import LinearFast\n", + "from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n", + "import numpy as np\n", + "\n", + "from HARK.distribution import (\n", + " expected,\n", + ")\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from HARK.utilities import make_grid_exp_mult\n", + "import scipy as sp" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7c3cc5e1", + "metadata": {}, + "outputs": [], + "source": [ + "T_cycles = 5\n", + "PermShk = 0.00\n", + "TranShk = 0.2\n", + "ShockCount = 21\n", + "UnempPrb = 0.0\n", + "CRRA = 2\n", + "Rfree = 1.04**.25\n", + "DiscFac = 0.975\n", + "PermGroFac = 1.0\n", + "LivPrb = 0.99375\n", + "DiscFacEff = DiscFac * LivPrb\n", + "\n", + "Dict={\n", + " \"CRRA\": CRRA,\n", + " \"Rfree\": [Rfree] * T_cycles, # Interest factor on assets\n", + " \"DiscFac\": DiscFac, # Intertemporal discount factor\n", + " \"LivPrb\" : [LivPrb] * T_cycles, #[0.999], #[.99375], # Survival probability\n", + " \"PermGroFac\" : [PermGroFac] * T_cycles, # Permanent income growth factor\n", + "\n", + " # Parameters that specify the income distribution over the lifecycle\n", + " \"PermShkStd\" : [PermShk] * T_cycles, #[.06], # Standard deviation of log permanent shocks to income\n", + " \"PermShkCount\" : ShockCount, # Number of points in discrete approximation to permanent income shocks\n", + " \"TranShkStd\" : [TranShk] * T_cycles, #[.2], # Standard deviation of log transitory shocks to income\n", + " \"TranShkCount\" : ShockCount, # Number of points in discrete approximation to transitory income shocks\n", + " \"UnempPrb\" : [UnempPrb] * T_cycles, # Probability of unemployment while working\n", + " \"IncUnemp\" : [0.0] * T_cycles, # Unemployment benefits replacement rate\n", + " \"UnempPrbRet\" : [0.0] * T_cycles, # Probability of \"unemployment\" while retired\n", + " \"IncUnempRet\" : [0.0] * T_cycles, # \"Unemployment\" benefits when retired\n", + " \"T_cycle\" : T_cycles, # Number of periods in the cycle for this agent type\n", + "\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3e7b6ec8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "new period solve(self)\n", + "new period solve(self)\n", + "new period solve(self)\n", + "new period solve(self)\n", + "new period solve(self)\n" + ] + } + ], + "source": [ + "IndShock = IndShockConsumerType(**Dict)\n", + "IndShock.update()\n", + "IndShock.solve()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d4e55f42", + "metadata": {}, + "outputs": [], + "source": [ + "t = 0\n", + "tNext = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8b893f23", + "metadata": {}, + "outputs": [], + "source": [ + "### Get Last Period Marginal Value Function and grids\n", + "# cFuncNext = IndShock.solution[1].cFunc\n", + "# vPfuncNext = MargValueFuncCRRA(cFuncNext, CRRA)\n", + "vPfuncNext = IndShock.solution[tNext].vPfunc\n", + "aXtraGrid = IndShock.aXtraGrid\n", + "\n", + "### Shocks\n", + "IncShkDstn = IndShock.IncShkDstn[t]\n", + "ShkPrbsNext = IncShkDstn.pmv\n", + "PermShkValsNext = IncShkDstn.atoms[0]\n", + "TranShkValsNext = IncShkDstn.atoms[1]\n", + "PermShkMinNext = np.min(PermShkValsNext)\n", + "TranShkMinNext = np.min(TranShkValsNext)\n", + "\n", + "# Borrowing Constraint\n", + "BoroCnstNat = (\n", + " (IndShock.solution[tNext].mNrmMin - TranShkMinNext)\n", + " * (IndShock.PermGroFac[t] * PermShkMinNext)\n", + " / IndShock.Rfree[t] )\n", + "\n", + "aNrmNow = np.asarray(aXtraGrid) + BoroCnstNat" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "09419231", + "metadata": {}, + "outputs": [], + "source": [ + "def m_nrm_next(PermGroFac, shocks, a_nrm, Rfree):\n", + " \"\"\"\n", + " Computes normalized market resources of the next period\n", + " from income shocks and current normalized market resources.\n", + "\n", + " Parameters\n", + " ----------\n", + " shocks: [float]\n", + " Permanent and transitory income shock levels.\n", + " a_nrm: float\n", + " Normalized market assets this period\n", + "\n", + " Returns\n", + " -------\n", + " float\n", + " normalized market resources in the next period\n", + " \"\"\"\n", + " return Rfree / (PermGroFac * shocks[\"PermShk\"]) * a_nrm + shocks[\"TranShk\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "47da57d1", + "metadata": {}, + "outputs": [], + "source": [ + "### End-of-period Marginal Value Function (Traditional Way)\n", + "\n", + "def vp_next(shocks, a_nrm, Rfree):\n", + " return shocks[\"PermShk\"] ** (-CRRA) * vPfuncNext(\n", + " m_nrm_next(PermGroFac, shocks, a_nrm, Rfree)\n", + " )\n", + "\n", + "EndOfPrdvP = (\n", + " DiscFacEff\n", + " * Rfree\n", + " * PermGroFac ** (-CRRA)\n", + " * expected(vp_next, IncShkDstn, args=(aNrmNow, Rfree))\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a92737a4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 2.0)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(aNrmNow, EndOfPrdvP)\n", + "plt.title('End Of Period Marginal Value Function')\n", + "plt.ylim([0.0, 2.0])" + ] + }, + { + "cell_type": "markdown", + "id": "c7c25550", + "metadata": {}, + "source": [ + "### Alternative Start" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "36bdd9ec", + "metadata": {}, + "outputs": [], + "source": [ + "### Step 1: In a pre-solution step, specify fairly dense grids of m and b, denser than the grid of a.\n", + "mGrid = make_grid_exp_mult(0.0, 50, 300)\n", + "bGrid = make_grid_exp_mult(0.0, 50, 300)\n", + "\n", + "### Let ist start from minimum of aNrm\n", + "mGrid = mGrid - aNrmNow[0]\n", + "bGrid = bGrid - aNrmNow[0]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "475cc722", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 2.0)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(mGrid, vPfuncNext(mGrid))\n", + "plt.ylim([0.0, 2.0])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "282a0419", + "metadata": {}, + "outputs": [], + "source": [ + "### Step 2: In that pre-solution step, for each $F_{\\theta, t}$ (i.e. just once if this is an ifinite horizon problem), \n", + "### calculate $f_{\\theta, t}(m - b) on the cross product of the b-grid and m-grid. \n", + "### Put them in a matrix that has b values by row and m values by column.\n", + "### Still in the pre-solution step, for each b-row in the matrix, take the row-wise sum and\n", + "### divide the row by it. This represents a Markov transition matrix from the exogenous\n", + "### b-grid to the exogenous m-grid.\n", + "\n", + "def updateBM_TranMatrix(TranShkStd, bGrid, mGrid):\n", + " \"\"\"\n", + " Calculates the Probabillity of a transioty shock for the b times m matrix\n", + " \"\"\"\n", + " # probGrid = np.zeros((len(self.bNrmGrid_income), len(self.mNrmGrid_income))) # b x m\n", + " # ### getting the probability for each transitory shock with the size b - m (remember m = b * transitory shock)\n", + "\n", + " ### Integration 1: No unemployment probability\n", + " s = TranShkStd\n", + " mu = -0.5 * s**2\n", + " lognorm_dist = sp.stats.lognorm(s, scale=np.exp(mu))\n", + "\n", + " ### Create matrix\n", + " # Construct meshgrid of bNrmGrid_income and mNrmGrid_income\n", + " b, m = np.meshgrid(bGrid, mGrid, indexing='ij')\n", + "\n", + " # Calculate differences between corresponding elements\n", + " probGrid = lognorm_dist.pdf(m - b)\n", + "\n", + " for i_b in range(len(bGrid)):\n", + " probGrid[i_b] = probGrid[i_b]/(np.max([np.sum(probGrid[i_b]), 0.000001]))\n", + "\n", + " return probGrid\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "93f258bd", + "metadata": {}, + "outputs": [], + "source": [ + "probGrid = updateBM_TranMatrix(TranShk, bGrid, mGrid)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "3b1497d5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.00000000e+000, 0.00000000e+000, 4.13785401e-280, ...,\n", + " 1.68203581e-064, 6.84678105e-075, 1.54372978e-087],\n", + " [0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n", + " 1.68501768e-064, 6.85758429e-075, 1.54588270e-087],\n", + " [0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n", + " 1.68802626e-064, 6.86848198e-075, 1.54805399e-087],\n", + " ...,\n", + " [0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n", + " 0.00000000e+000, 2.22410422e-021, 3.84397937e-048],\n", + " [0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n", + " 0.00000000e+000, 0.00000000e+000, 3.98381835e-032],\n", + " [0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n", + " 0.00000000e+000, 0.00000000e+000, 0.00000000e+000]])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "probGrid" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "11eb5103", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0000000000000002" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sum(probGrid[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "f53a5d71", + "metadata": {}, + "outputs": [], + "source": [ + "### Step 3: To compute expectations during backwards solution, evaluate vt(mt) on the dense m-grid. Put\n", + "### these (marginal) values into a matrix that has one column.\n", + "\n", + "EndOfPrdvP_Interm_array = vPfuncNext(mGrid)\n", + "large_number = 1e12\n", + "EndOfPrdvP_Interm_array = np.where(EndOfPrdvP_Interm_array == np.inf, large_number, EndOfPrdvP_Interm_array)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "9642f501", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 2.0)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(mGrid, EndOfPrdvP_Interm_array)\n", + "plt.title('End Of Period Marginal Value Function')\n", + "plt.xlabel('m Next grid')\n", + "plt.ylim([0.0, 2.0])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "69bb8a13", + "metadata": {}, + "outputs": [], + "source": [ + "### Step 4: Pre-multiply the Markov matrix by the matrix you just constructed. The resulting\n", + "### matrix of intermediate expected values will have b row-wise.\n", + "\n", + "EndOfPrdvP_Interm_array = np.reshape(EndOfPrdvP_Interm_array, (1 ,len(EndOfPrdvP_Interm_array)))\n", + "EndOfPrdvP_Interm_array = EndOfPrdvP_Interm_array @ probGrid\n", + "EndOfPrdvP_Interm = LinearFast(EndOfPrdvP_Interm_array[0], [bGrid])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "913ba280", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 2.0)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(bGrid, EndOfPrdvP_Interm_array[0])\n", + "plt.title('Interim End Of Period Marginal Value Function')\n", + "plt.xlabel('b Next Grid')\n", + "plt.ylim([0.0, 2.0])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "56c88261", + "metadata": {}, + "outputs": [], + "source": [ + "### Step 5: Using the pre-specified exogenous grid of a, compute expected end-of-period\n", + "### (marginal) value using the typical discretized approximation to the permanent shock\n", + "### distribution. For any (a) end-of-period state, there is a finite set of future (b)\n", + "### points that can be reached under the discretization." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "5b7a487c", + "metadata": {}, + "outputs": [], + "source": [ + "def b_nrm_next(PermGroFac, shocks, a_nrm, Rfree):\n", + " \"\"\"\n", + " Computes normalized bank balances of the next period\n", + " from income shocks and current normalized market resources.\n", + "\n", + " Parameters\n", + " ----------\n", + " shocks: [float]\n", + " Permanent and transitory income shock levels.\n", + " a_nrm: float\n", + " Normalized market assets this period\n", + "\n", + " Returns\n", + " -------\n", + " float\n", + " normalized market resources in the next period\n", + " \"\"\"\n", + " return Rfree / (PermGroFac * shocks[\"PermShk\"]) * a_nrm" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "651ab6ae", + "metadata": {}, + "outputs": [], + "source": [ + "def vp_next_Integration(shocks, a_nrm, Rfree):\n", + " return shocks[\"PermShk\"] ** (-CRRA) * EndOfPrdvP_Interm(\n", + " b_nrm_next(PermGroFac, shocks, a_nrm, Rfree)\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "036c3a61", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adria\\anaconda3\\envs\\Durable\\lib\\site-packages\\interpolation\\splines\\eval_splines.py:232: NumbaPendingDeprecationWarning: \u001b[1m\u001b[1m\u001b[1m\u001b[1mCode using Numba extension API maybe depending on 'old_style' error-capturing, which is deprecated and will be replaced by 'new_style' in a future release. See details at https://numba.readthedocs.io/en/latest/reference/deprecation.html#deprecation-of-old-style-numba-captured-errors\n", + "Exception origin:\n", + " File \"c:\\Users\\adria\\anaconda3\\envs\\Durable\\lib\\site-packages\\interpolation\\splines\\eval_splines.py\", line 116, in __eval_spline\n", + " kk = (order).literal_value\n", + "\u001b[0m\u001b[0m\u001b[0m\u001b[0m\n", + " return _eval_linear(*args)\n" + ] + } + ], + "source": [ + "EndOfPrdvP_Integration = (\n", + " DiscFacEff\n", + " * Rfree\n", + " * PermGroFac ** (-CRRA)\n", + " * expected(vp_next_Integration, IncShkDstn, args=(aNrmNow, Rfree))\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "325313b3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 2.0)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(aNrmNow, EndOfPrdvP)\n", + "plt.plot(aNrmNow, EndOfPrdvP_Integration, '--')\n", + "plt.title('End Of Period Marginal Value Function')\n", + "plt.xlabel('a Grid')\n", + "plt.ylim([0.0, 2.0])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Durable", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 0994ac69939c303187828bdb23e3d8c2e0ef8081 Mon Sep 17 00:00:00 2001 From: "Matthew N. White" Date: Tue, 28 May 2024 17:12:58 -0400 Subject: [PATCH 2/2] Revise integration method notebook Made various changes to Adrian's notebook to make the method work as intended. Most of it had to do with selecting the grids properly, with some work on function representation. Should run without issue now. --- ...nsumerType_IntegrationMethod_Example.ipynb | 442 +++++++----------- 1 file changed, 167 insertions(+), 275 deletions(-) diff --git a/examples/ConsIndShockModel/IndShockConsumerType_IntegrationMethod_Example.ipynb b/examples/ConsIndShockModel/IndShockConsumerType_IntegrationMethod_Example.ipynb index 6134e6162..7dff7f367 100644 --- a/examples/ConsIndShockModel/IndShockConsumerType_IntegrationMethod_Example.ipynb +++ b/examples/ConsIndShockModel/IndShockConsumerType_IntegrationMethod_Example.ipynb @@ -16,21 +16,12 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "915c0bb6", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\Users\\adria\\anaconda3\\envs\\Durable\\lib\\site-packages\\numba\\core\\decorators.py:262: NumbaDeprecationWarning: \u001b[1mnumba.generated_jit is deprecated. Please see the documentation at: https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-generated-jit for more information and advice on a suitable replacement.\u001b[0m\n", - " warnings.warn(msg, NumbaDeprecationWarning)\n" - ] - } - ], + "outputs": [], "source": [ - "from HARK.econforgeinterp import LinearFast\n", + "from HARK.interpolation import LinearInterp, MargValueFuncCRRA\n", "from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n", "import numpy as np\n", "\n", @@ -46,62 +37,51 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "7c3cc5e1", "metadata": {}, "outputs": [], "source": [ - "T_cycles = 5\n", - "PermShk = 0.00\n", + "T_cycle = 5\n", + "PermShk = 0.0\n", "TranShk = 0.2\n", "ShockCount = 21\n", - "UnempPrb = 0.0\n", + "UnempPrb = 1e-10\n", "CRRA = 2\n", - "Rfree = 1.04**.25\n", + "Rfree = 1.04**0.25\n", "DiscFac = 0.975\n", "PermGroFac = 1.0\n", "LivPrb = 0.99375\n", "DiscFacEff = DiscFac * LivPrb\n", "\n", - "Dict={\n", + "Dict = {\n", " \"CRRA\": CRRA,\n", - " \"Rfree\": [Rfree] * T_cycles, # Interest factor on assets\n", - " \"DiscFac\": DiscFac, # Intertemporal discount factor\n", - " \"LivPrb\" : [LivPrb] * T_cycles, #[0.999], #[.99375], # Survival probability\n", - " \"PermGroFac\" : [PermGroFac] * T_cycles, # Permanent income growth factor\n", - "\n", + " \"Rfree\": [Rfree] * T_cycle, # Interest factor on assets\n", + " \"DiscFac\": DiscFac, # Intertemporal discount factor\n", + " \"LivPrb\": [LivPrb]\n", + " * T_cycle, # [0.999], #[.99375], # Survival probability\n", + " \"PermGroFac\": [PermGroFac] * T_cycle, # Permanent income growth factor\n", " # Parameters that specify the income distribution over the lifecycle\n", - " \"PermShkStd\" : [PermShk] * T_cycles, #[.06], # Standard deviation of log permanent shocks to income\n", - " \"PermShkCount\" : ShockCount, # Number of points in discrete approximation to permanent income shocks\n", - " \"TranShkStd\" : [TranShk] * T_cycles, #[.2], # Standard deviation of log transitory shocks to income\n", - " \"TranShkCount\" : ShockCount, # Number of points in discrete approximation to transitory income shocks\n", - " \"UnempPrb\" : [UnempPrb] * T_cycles, # Probability of unemployment while working\n", - " \"IncUnemp\" : [0.0] * T_cycles, # Unemployment benefits replacement rate\n", - " \"UnempPrbRet\" : [0.0] * T_cycles, # Probability of \"unemployment\" while retired\n", - " \"IncUnempRet\" : [0.0] * T_cycles, # \"Unemployment\" benefits when retired\n", - " \"T_cycle\" : T_cycles, # Number of periods in the cycle for this agent type\n", - "\n", + " \"PermShkStd\": [PermShk]\n", + " * T_cycle, # [.06], # Standard deviation of log permanent shocks to income\n", + " \"PermShkCount\": ShockCount, # Number of points in discrete approximation to permanent income shocks\n", + " \"TranShkStd\": [TranShk]\n", + " * T_cycle, # [.2], # Standard deviation of log transitory shocks to income\n", + " \"TranShkCount\": ShockCount, # Number of points in discrete approximation to transitory income shocks\n", + " \"UnempPrb\": [UnempPrb] * T_cycle, # Probability of unemployment while working\n", + " \"IncUnemp\": [0.0] * T_cycle, # Unemployment benefits replacement rate\n", + " \"UnempPrbRet\": [0.0] * T_cycle, # Probability of \"unemployment\" while retired\n", + " \"IncUnempRet\": [0.0] * T_cycle, # \"Unemployment\" benefits when retired\n", + " \"T_cycle\": T_cycle, # Number of periods in the cycle for this agent type\n", "}" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "3e7b6ec8", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "new period solve(self)\n", - "new period solve(self)\n", - "new period solve(self)\n", - "new period solve(self)\n", - "new period solve(self)\n" - ] - } - ], + "outputs": [], "source": [ "IndShock = IndShockConsumerType(**Dict)\n", "IndShock.update()\n", @@ -110,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "d4e55f42", "metadata": {}, "outputs": [], @@ -121,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "8b893f23", "metadata": {}, "outputs": [], @@ -131,6 +111,7 @@ "# vPfuncNext = MargValueFuncCRRA(cFuncNext, CRRA)\n", "vPfuncNext = IndShock.solution[tNext].vPfunc\n", "aXtraGrid = IndShock.aXtraGrid\n", + "mNrmMinNext = IndShock.solution[tNext].mNrmMin\n", "\n", "### Shocks\n", "IncShkDstn = IndShock.IncShkDstn[t]\n", @@ -144,14 +125,15 @@ "BoroCnstNat = (\n", " (IndShock.solution[tNext].mNrmMin - TranShkMinNext)\n", " * (IndShock.PermGroFac[t] * PermShkMinNext)\n", - " / IndShock.Rfree[t] )\n", + " / IndShock.Rfree[t]\n", + ")\n", "\n", "aNrmNow = np.asarray(aXtraGrid) + BoroCnstNat" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "09419231", "metadata": {}, "outputs": [], @@ -178,57 +160,39 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "47da57d1", "metadata": {}, "outputs": [], "source": [ "### End-of-period Marginal Value Function (Traditional Way)\n", "\n", + "\n", "def vp_next(shocks, a_nrm, Rfree):\n", " return shocks[\"PermShk\"] ** (-CRRA) * vPfuncNext(\n", " m_nrm_next(PermGroFac, shocks, a_nrm, Rfree)\n", " )\n", "\n", + "\n", "EndOfPrdvP = (\n", " DiscFacEff\n", " * Rfree\n", " * PermGroFac ** (-CRRA)\n", " * expected(vp_next, IncShkDstn, args=(aNrmNow, Rfree))\n", - " )" + ")" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "a92737a4", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.0, 2.0)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.plot(aNrmNow, EndOfPrdvP)\n", - "plt.title('End Of Period Marginal Value Function')\n", - "plt.ylim([0.0, 2.0])" + "plt.title(\"End Of Period Marginal Value Function\")\n", + "plt.ylim([0.0, 2.0])\n", + "plt.show()" ] }, { @@ -241,66 +205,49 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "36bdd9ec", "metadata": {}, "outputs": [], "source": [ "### Step 1: In a pre-solution step, specify fairly dense grids of m and b, denser than the grid of a.\n", - "mGrid = make_grid_exp_mult(0.0, 50, 300)\n", - "bGrid = make_grid_exp_mult(0.0, 50, 300)\n", + "mGrid = make_grid_exp_mult(0.0001, 52, 310, timestonest=1)\n", + "bGrid = make_grid_exp_mult(0.0, 48, 300, timestonest=1)\n", "\n", "### Let ist start from minimum of aNrm\n", - "mGrid = mGrid - aNrmNow[0]\n", - "bGrid = bGrid - aNrmNow[0]\n" + "# NO, WRONG MINIMUM!\n", + "mGrid = mGrid + mNrmMinNext\n", + "bGrid = bGrid + aNrmNow[0]" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "475cc722", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.0, 2.0)" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.plot(mGrid, vPfuncNext(mGrid))\n", - "plt.ylim([0.0, 2.0])" + "plt.ylim([0.0, 2.0])\n", + "plt.title(\"Next period marginal value function\")\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "282a0419", "metadata": {}, "outputs": [], "source": [ - "### Step 2: In that pre-solution step, for each $F_{\\theta, t}$ (i.e. just once if this is an ifinite horizon problem), \n", - "### calculate $f_{\\theta, t}(m - b) on the cross product of the b-grid and m-grid. \n", + "### Step 2: In that pre-solution step, for each $F_{\\theta, t}$ (i.e. just once if this is an ifinite horizon problem),\n", + "### calculate $f_{\\theta, t}(m - b) on the cross product of the b-grid and m-grid.\n", "### Put them in a matrix that has b values by row and m values by column.\n", "### Still in the pre-solution step, for each b-row in the matrix, take the row-wise sum and\n", "### divide the row by it. This represents a Markov transition matrix from the exogenous\n", "### b-grid to the exogenous m-grid.\n", "\n", + "\n", "def updateBM_TranMatrix(TranShkStd, bGrid, mGrid):\n", " \"\"\"\n", " Calculates the Probabillity of a transioty shock for the b times m matrix\n", @@ -311,24 +258,24 @@ " ### Integration 1: No unemployment probability\n", " s = TranShkStd\n", " mu = -0.5 * s**2\n", - " lognorm_dist = sp.stats.lognorm(s, scale=np.exp(mu))\n", + " lognorm_dist = sp.stats.lognorm(s, scale=np.exp(mu))\n", "\n", " ### Create matrix\n", " # Construct meshgrid of bNrmGrid_income and mNrmGrid_income\n", - " b, m = np.meshgrid(bGrid, mGrid, indexing='ij')\n", + " b, m = np.meshgrid(bGrid, mGrid, indexing=\"ij\")\n", "\n", " # Calculate differences between corresponding elements\n", " probGrid = lognorm_dist.pdf(m - b)\n", "\n", " for i_b in range(len(bGrid)):\n", - " probGrid[i_b] = probGrid[i_b]/(np.max([np.sum(probGrid[i_b]), 0.000001]))\n", + " probGrid[i_b] = probGrid[i_b] / (np.max([np.sum(probGrid[i_b]), 0.000001]))\n", "\n", - " return probGrid\n" + " return probGrid" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "93f258bd", "metadata": {}, "outputs": [], @@ -338,110 +285,43 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "3b1497d5", + "execution_count": null, + "id": "7aa79e03-4449-43f1-bfc0-7216143b0d37", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.00000000e+000, 0.00000000e+000, 4.13785401e-280, ...,\n", - " 1.68203581e-064, 6.84678105e-075, 1.54372978e-087],\n", - " [0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n", - " 1.68501768e-064, 6.85758429e-075, 1.54588270e-087],\n", - " [0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n", - " 1.68802626e-064, 6.86848198e-075, 1.54805399e-087],\n", - " ...,\n", - " [0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n", - " 0.00000000e+000, 2.22410422e-021, 3.84397937e-048],\n", - " [0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n", - " 0.00000000e+000, 0.00000000e+000, 3.98381835e-032],\n", - " [0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n", - " 0.00000000e+000, 0.00000000e+000, 0.00000000e+000]])" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "probGrid" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "11eb5103", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1.0000000000000002" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "np.sum(probGrid[0])" + "probGrid.shape" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "f53a5d71", "metadata": {}, "outputs": [], "source": [ "### Step 3: To compute expectations during backwards solution, evaluate vt(mt) on the dense m-grid. Put\n", "### these (marginal) values into a matrix that has one column.\n", - "\n", - "EndOfPrdvP_Interm_array = vPfuncNext(mGrid)\n", - "large_number = 1e12\n", - "EndOfPrdvP_Interm_array = np.where(EndOfPrdvP_Interm_array == np.inf, large_number, EndOfPrdvP_Interm_array)" + "vPnext_array = vPfuncNext(mGrid)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "9642f501", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.0, 2.0)" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "plt.plot(mGrid, EndOfPrdvP_Interm_array)\n", - "plt.title('End Of Period Marginal Value Function')\n", - "plt.xlabel('m Next grid')\n", - "plt.ylim([0.0, 2.0])" + "plt.plot(mGrid, vPnext_array)\n", + "plt.title(\"Next period marginal value function\")\n", + "plt.xlabel(\"m Next grid\")\n", + "plt.ylim([0.0, 2.0])\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "69bb8a13", "metadata": {}, "outputs": [], @@ -449,48 +329,32 @@ "### Step 4: Pre-multiply the Markov matrix by the matrix you just constructed. The resulting\n", "### matrix of intermediate expected values will have b row-wise.\n", "\n", - "EndOfPrdvP_Interm_array = np.reshape(EndOfPrdvP_Interm_array, (1 ,len(EndOfPrdvP_Interm_array)))\n", - "EndOfPrdvP_Interm_array = EndOfPrdvP_Interm_array @ probGrid\n", - "EndOfPrdvP_Interm = LinearFast(EndOfPrdvP_Interm_array[0], [bGrid])" + "vPnext_array_reshaped = np.reshape(vPnext_array, (vPnext_array.size, 1))\n", + "Interm_vP = np.dot(probGrid, vPnext_array_reshaped)\n", + "Interm_vPnvrs = Interm_vP.flatten() ** (-1 / CRRA)\n", + "Interm_vPnvrsFunc = LinearInterp(\n", + " np.insert(bGrid, 0, 0.0), np.insert(Interm_vPnvrs, 0, 0.0)\n", + ") # IMPORTANT: GENERALIZE THIS ZERO\n", + "Interm_vPfunc = MargValueFuncCRRA(Interm_vPnvrsFunc, CRRA)" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "913ba280", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.0, 2.0)" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "plt.plot(bGrid, EndOfPrdvP_Interm_array[0])\n", - "plt.title('Interim End Of Period Marginal Value Function')\n", - "plt.xlabel('b Next Grid')\n", - "plt.ylim([0.0, 2.0])" + "plt.plot(bGrid, Interm_vPfunc(bGrid))\n", + "plt.title(\"Intermediate Marginal Value Function\")\n", + "plt.xlabel(\"b Next Grid\")\n", + "plt.ylim([0.0, 2.0])\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "56c88261", "metadata": {}, "outputs": [], @@ -503,7 +367,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "5b7a487c", "metadata": {}, "outputs": [], @@ -530,84 +394,112 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "id": "651ab6ae", "metadata": {}, "outputs": [], "source": [ "def vp_next_Integration(shocks, a_nrm, Rfree):\n", - " return shocks[\"PermShk\"] ** (-CRRA) * EndOfPrdvP_Interm(\n", + " return shocks[\"PermShk\"] ** (-CRRA) * Interm_vPfunc(\n", " b_nrm_next(PermGroFac, shocks, a_nrm, Rfree)\n", " )" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "id": "036c3a61", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\Users\\adria\\anaconda3\\envs\\Durable\\lib\\site-packages\\interpolation\\splines\\eval_splines.py:232: NumbaPendingDeprecationWarning: \u001b[1m\u001b[1m\u001b[1m\u001b[1mCode using Numba extension API maybe depending on 'old_style' error-capturing, which is deprecated and will be replaced by 'new_style' in a future release. See details at https://numba.readthedocs.io/en/latest/reference/deprecation.html#deprecation-of-old-style-numba-captured-errors\n", - "Exception origin:\n", - " File \"c:\\Users\\adria\\anaconda3\\envs\\Durable\\lib\\site-packages\\interpolation\\splines\\eval_splines.py\", line 116, in __eval_spline\n", - " kk = (order).literal_value\n", - "\u001b[0m\u001b[0m\u001b[0m\u001b[0m\n", - " return _eval_linear(*args)\n" - ] - } - ], + "outputs": [], "source": [ "EndOfPrdvP_Integration = (\n", " DiscFacEff\n", " * Rfree\n", " * PermGroFac ** (-CRRA)\n", " * expected(vp_next_Integration, IncShkDstn, args=(aNrmNow, Rfree))\n", - " )" + ")" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "id": "325313b3", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.0, 2.0)" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.plot(aNrmNow, EndOfPrdvP)\n", - "plt.plot(aNrmNow, EndOfPrdvP_Integration, '--')\n", - "plt.title('End Of Period Marginal Value Function')\n", - "plt.xlabel('a Grid')\n", - "plt.ylim([0.0, 2.0])" + "plt.plot(aNrmNow, EndOfPrdvP_Integration, \"--\")\n", + "plt.title(\"End Of Period Marginal Value Functions: Comparison\")\n", + "plt.xlabel(\"a Grid\")\n", + "plt.ylim([0.0, 2.0])\n", + "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a70cd24a-6184-4a29-8040-93132a43892c", + "metadata": {}, + "outputs": [], + "source": [ + "# Construct the consumption function in two ways: standard approach and new approach\n", + "cNrm_old = EndOfPrdvP ** (-1 / CRRA)\n", + "mNrm_old = aNrmNow + cNrm_old\n", + "cFunc_old = LinearInterp(np.insert(mNrm_old, 0, 0.0), np.insert(cNrm_old, 0, 0.0))\n", + "\n", + "cNrm_new = EndOfPrdvP_Integration ** (-1 / CRRA)\n", + "mNrm_new = aNrmNow + cNrm_new\n", + "cFunc_new = LinearInterp(np.insert(mNrm_new, 0, 0.0), np.insert(cNrm_new, 0, 0.0))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e67ea4ac-1fff-4edb-af84-36bf50eb7e9e", + "metadata": {}, + "outputs": [], + "source": [ + "# Plot a comparison of the two consumption functions using different integration methods\n", + "M = np.linspace(0.0, 10.0, 201)\n", + "C0 = cFunc_old(M)\n", + "C1 = cFunc_new(M)\n", + "plt.plot(M, C0)\n", + "plt.plot(M, C1)\n", + "plt.xlabel(r\"Market resources $m_t$\")\n", + "plt.ylabel(r\"Consumption $c_t$\")\n", + "plt.xlim(0.0, 10.0)\n", + "plt.ylim(0.0, None)\n", + "plt.title(\"Consumption function comparison\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "05ad7a58-0edf-4d04-837d-c27953508e58", + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(M, C1 - C0)\n", + "plt.xlabel(r\"Market resources $m_t$\")\n", + "plt.ylabel(r\"Difference between methods\")\n", + "plt.title(\"Consumption function comparison\")\n", + "plt.xlim(0.0, 10.0)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1fc316d2-5b6b-43c4-ad53-3dfd47c92ba1", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Durable", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -621,7 +513,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.0" + "version": "3.10.14" } }, "nbformat": 4,