{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# A Gentle Introduction to HARK: Buffer Stock Saving \n", "\n", "[![badge](https://img.shields.io/badge/Launch%20using%20-Econ--ARK-blue)](https://econ-ark.org/materials/gentle-intro-to-hark-buffer-stock-model#launch)\n", "\n", "This notebook explores the behavior of a consumer identical to the perfect foresight consumer described in [Gentle-Intro-To-HARK-PerfForesightCRRA](https://econ-ark.org/materials/Gentle-Intro-To-HARK-PerfForesightCRRA) except that now the model incorporates income uncertainty." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "# This cell has a bit of initial setup.\n", "# Click the \"Run\" button immediately above the notebook in order to execute the contents of any cell\n", "# WARNING: Each cell in the notebook relies upon results generated by previous cells\n", "# The most common problem beginners have is to execute a cell before all its predecessors\n", "# If you do this, you can restart the kernel (see the \"Kernel\" menu above) and start over\n", "import matplotlib.pyplot as plt\n", "\n", "import numpy as np\n", "import HARK \n", "from copy import deepcopy\n", "mystr = lambda number : \"{:.4f}\".format(number)\n", "from HARK.utilities import plot_funcs" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The Consumer's Problem with Transitory and Permanent Shocks\n", "### Mathematical Description\n", "\n", "Our new type of consumer receives two income shocks at the beginning of each period. Permanent income would grow by a factor $\\Gamma$ in the absence of any shock , but its growth is modified by a shock, $\\psi_{t+1}$:\n", "\\begin{align}\n", " P_{t+1} & = \\Gamma P_{t}\\psi_{t+1}\n", "\\end{align}\n", "whose expected (mean) value is $\\mathbb{E}_{t}[\\psi_{t+1}]=1$. Actual income received $Y$ is equal to permanent income $P$ multiplied by a transitory shock $\\theta$:\n", "\\begin{align}\n", " Y_{t+1} & = \\Gamma P_{t+1}\\theta_{t+1}\n", "\\end{align}\n", "where again $\\mathbb{E}_{t}[\\theta_{t+1}] = 1$.\n", "\n", "As with the perfect foresight problem, this model can be rewritten in terms of _normalized_ variables, e.g. the ratio of 'market resources' $M_{t}$ (wealth plus current income) to permanent income is $m_t \\equiv M_t/P_t$. (See [here](http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/) for the theory). In addition, lenders may set a limit on borrowing: The ratio $a_{t}$ of end-of-period assets to permanent income $A_t/P_t$ must be greater than $\\underline{a} \\leq 0$. (So, if $\\underline{a}=-0.3$, the consumer cannot borrow more than 30 percent of their permanent income). \n", "\n", "The consumer's (normalized) problem turns out to be:\n", "\\begin{eqnarray*}\n", "v_t(m_t) &=& \\max_{c_t} ~~u(c_t) + \\beta \\mathbb{E} [(\\Gamma_{t+1}\\psi_{t+1})^{1-\\rho} v_{t+1}(m_{t+1}) ], \\\\\n", " & \\text{s.t.} & \\\\\n", "a_t &=& m_t - c_t, \\\\\n", "a_t &\\geq& \\underline{a}, \\\\\n", "m_{t+1} &=& a_t R/(\\Gamma_{t+1} \\psi_{t+1}) + \\theta_{t+1}.\n", "\\end{eqnarray*}\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For present purposes, we assume that the transitory and permanent shocks are independent. The permanent shock is assumed to be (approximately) lognormal, while the transitory shock has two components: A probability $\\wp$ that the consumer is unemployed, in which case $\\theta^{u}=\\underline{\\theta}$, and a probability $(1-\\wp)$ of a shock that is a lognormal with a mean chosen so that $\\mathbb{E}_{t}[\\theta_{t+n}]=1$.\n", "\n", "\n", "### Representing the Income Shocks\n", "\n", "Computers are discrete devices; even if somehow we knew with certainty that the transitory and permanent shocks were, say, continuously lognormally distributed, in order to be represented on a computer those distributions would need to be approximated by a finite set of points. A large literature in numerical computation explores ways to construct such approximations; probably the easiest discretization to understand is the equiprobable approximation, in which the continuous distribution is represented by a set of $N$ outcomes that are equally likely to occur. \n", "\n", "In the case of a single variable (say, the permanent shock $\\psi$), and when the number of equiprobable points is, say, 5, the procedure is to construct a list: $\\psi^{0}$ is the mean value of the continuous $\\psi$ given that the draw of $\\psi$ is in the bottom 20 percent of the distribution of the continuous $\\psi$. $\\psi^{1}$ is the mean value of $\\psi$ given that the draw is between the 20th and 40th percentiles, and so on. Having constructed these, the approximation to the expectation of some expression $g(\\psi)$ can be very quickly calculated by:\n", "\n", "$$ \n", "\\mathbb{E}_{t}[g(\\psi)] \\equiv \\int_{0}^{\\infty} g(\\psi) dF_{\\psi} \\approx (1/N) \\sum_{i=0}^{N-1} g(\\psi^{i}).\n", "$$\n", "\n", "(For a graphical depiction of a particular instance of this, see [SolvingMicroDSOPs/#discreteApprox](http://www.econ2.jhu.edu/people/ccarroll/SolvingMicroDSOPs/#discreteApprox).)\n", "\n", "## The New Parameters\n", "\n", "In addition to the parameters required for the perfect foresight model (like the time preference factor $\\beta$), under the assumptions above, we need to choose values for the following extra parameters that describe the income shock distribution and the artificial borrowing constraint.\n", "\n", "| Param | Description | Code | Value |\n", "| :---: | --- | --- | :---: |\n", "| $\\underline{a}$ | Artificial borrowing constraint | $\\texttt{BoroCnstArt}$ | 0.0 |\n", "| $\\sigma_\\psi$ | Underlying stdev of permanent income shocks | $\\texttt{PermShkStd}$ | 0.1 |\n", "| $\\sigma_\\theta^{e}$ | Underlying stdev of transitory income shocks | $\\texttt{TranShkStd}$ | 0.1 |\n", "| $N_\\psi$ | Number of discrete permanent income shocks | $\\texttt{PermShkCount}$ | 7 |\n", "| $N_\\theta$ | Number of discrete transitory income shocks | $\\texttt{TranShkCount}$ | 7 |\n", "| $\\wp$ | Unemployment probability | $\\texttt{UnempPrb}$ | 0.05 |\n", "| $\\underline{\\theta}$ | Transitory shock when unemployed | $\\texttt{IncUnemp}$ | 0.3 |" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Representation in HARK\n", "\n", "HARK agents with this kind of problem are instances of the class $\\texttt{IndShockConsumerType}$, which is constructed by \"inheriting\" the properties of the $\\texttt{PerfForesightConsumerType}$ and then adding only the _new_ information required:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "code_folding": [ 0, 2 ] }, "outputs": [], "source": [ "# This cell defines a parameter dictionary for making an instance of IndShockConsumerType.\n", "\n", "IndShockDictionary = {\n", " 'PermShkStd': [0.1], # ... by specifying the new parameters for constructing the income process. \n", " 'PermShkCount': 7,\n", " 'TranShkStd': [0.1],\n", " 'TranShkCount': 7,\n", " 'UnempPrb': 0.05,\n", " 'IncUnemp': 0.3, # ... and income for unemployed people (30 percent of \"permanent\" income)\n", " 'BoroCnstArt': 0.0, # ... and specifying the location of the borrowing constraint (0 means no borrowing is allowed)\n", " 'cycles': 0 # signifies an infinite horizon solution (see below)\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Other Attributes are Inherited from PerfForesightConsumerType\n", "\n", "You can see all the **attributes** of an object in Python by using the `dir()` command. From the output of that command below, you can see that many of the model variables are now attributes of this object, along with many other attributes that are outside the scope of this tutorial." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['AgentCount',\n", " 'BoroCnstArt',\n", " 'CRRA',\n", " 'DiscFac',\n", " 'LivPrb',\n", " 'MaxKinks',\n", " 'PermGroFac',\n", " 'PermGroFacAgg',\n", " 'RNG',\n", " 'Rfree',\n", " 'T_age',\n", " 'T_cycle',\n", " '__call__',\n", " '__class__',\n", " '__delattr__',\n", " '__dict__',\n", " '__dir__',\n", " '__doc__',\n", " '__eq__',\n", " '__format__',\n", " '__ge__',\n", " '__getattribute__',\n", " '__gt__',\n", " '__hash__',\n", " '__init__',\n", " '__init_subclass__',\n", " '__le__',\n", " '__lt__',\n", " '__module__',\n", " '__ne__',\n", " '__new__',\n", " '__reduce__',\n", " '__reduce_ex__',\n", " '__repr__',\n", " '__setattr__',\n", " '__sizeof__',\n", " '__str__',\n", " '__subclasshook__',\n", " '__weakref__',\n", " 'aNrmInitMean',\n", " 'aNrmInitStd',\n", " 'addToTimeInv',\n", " 'addToTimeVary',\n", " 'assignParameters',\n", " 'cFunc_terminal_',\n", " 'check_AIC',\n", " 'check_condition',\n", " 'check_conditions',\n", " 'checkElementsOfTimeVaryAreLists',\n", " 'check_FHWC',\n", " 'check_GIC',\n", " 'check_RIC',\n", " 'checkRestrictions',\n", " 'clearHistory',\n", " 'cycles',\n", " 'delFromTimeInv',\n", " 'delFromTimeVary',\n", " 'distance',\n", " 'distance_criteria',\n", " 'getAvg',\n", " 'getControls',\n", " 'getMortality',\n", " 'getPostStates',\n", " 'getRfree',\n", " 'getShocks',\n", " 'getStates',\n", " 'history',\n", " 'initializeSim',\n", " 'makeShockHistory',\n", " 'pLvlInitMean',\n", " 'pLvlInitStd',\n", " 'postSolve',\n", " 'poststate_vars',\n", " 'poststate_vars_',\n", " 'preSolve',\n", " 'pseudo_terminal',\n", " 'quiet',\n", " 'readShocks',\n", " 'read_shocks',\n", " 'resetRNG',\n", " 'seed',\n", " 'shock_vars',\n", " 'shock_vars_',\n", " 'simBirth',\n", " 'simDeath',\n", " 'simOnePeriod',\n", " 'simulate',\n", " 'solution_terminal',\n", " 'solution_terminal_',\n", " 'solve',\n", " 'solveOnePeriod',\n", " 'time_inv',\n", " 'time_inv_',\n", " 'time_vary',\n", " 'time_vary_',\n", " 'tolerance',\n", " 'track_vars',\n", " 'unpack',\n", " 'unpackcFunc',\n", " 'updateSolutionTerminal',\n", " 'vFunc_terminal_',\n", " 'verbose']" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType\n", "\n", "pfc = PerfForesightConsumerType()\n", "dir(pfc)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In python terminology, `IndShockConsumerType` is a **superclass** of `PerfForesightConsumerType`. This means that it builds on the functionality of its parent type (including, for example, the definition of the utility function). You can find the superclasses of a type in Python using the `__bases__` attribute:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(HARK.ConsumptionSaving.ConsIndShockModel.PerfForesightConsumerType,)" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n", "\n", "IndShockConsumerType.__bases__" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# So, let's create an instance of the IndShockConsumerType\n", "IndShockExample = IndShockConsumerType(**IndShockDictionary)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As before, we need to import the relevant subclass of $\\texttt{AgentType}$ into our workspace, then create an instance by passing the dictionary to the class as if the class were a function." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The Discretized Probability Distribution\n", "\n", "The scatterplot below shows how the discretized probability distribution is represented in HARK: The lognormal distribution is represented by a set of equiprobable point masses." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEGCAYAAABy53LJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAbYklEQVR4nO3df5QdZZ3n8fcnCQFGiASSYSEJJGgQenb5EW6yMEgUXCTMjIliGBPAIcpMDkZGZzSu4TA7K4HZGVdYByTjkCMuOrsQgwPKKBo8w689ippOgIQGok02kE6Ypf0BiCBJ4Lt/1NN4c7l9uyrp6q6b/rzOuaernqp6+nOLhi/16ylFBGZmZnmNGu4AZmbWXlw4zMysEBcOMzMrxIXDzMwKceEwM7NCxgx3gKEwYcKEmDp16nDHMDNrK+vWrftZRExsbB8RhWPq1Kl0dnYOdwwzs7Yi6alm7T5VZWZmhbhwmJlZIS4cZmZWiAuHmZkV4sJhZmaFlFo4JM2RtElSt6RlTZbPlrRe0i5J8xuWvSrp4fS5s659mqQfpT6/Jmlsmd/BzMx2V1rhkDQaWAGcC3QACyV1NKz2NLAIuKVJFy9HxEnpM7eu/bPA5yPircAvgUsGPbyZmfWrzCOOWUB3RGyOiB3AKmBe/QoRsSUiNgCv5elQkoCzgK+npq8A7x28yGZmNpAyC8ckYGvdfE9qy+sASZ2SfiiprzgcBjwXEbsG6lPS4rR9Z29vb9HsZmbWjyo/OX50RGyTdAxwj6SNwPN5N46IlcBKgFqt5rdVmZkNkjKPOLYBU+rmJ6e2XCJiW/q5GbgPOBn4OXCIpL6CV6hPMzPbe2UWjrXA9HQX1FhgAXDnANsAIGm8pP3T9ATgdOCxyN5zey/QdwfWxcA3Bz25mZn1q7TCka5DXAasAR4HVkdEl6TlkuYCSJopqQc4H7hRUlfa/HigU9IjZIXi7yLisbTs08AnJHWTXfO4qazvYGZmb6Tsf+L3bbVaLTw6rplZMZLWRUStsd1PjpuZWSEuHGZmVogLh5mZFeLCYWZmhbhwmJlZIS4cZmZWiAuHmZkV4sJhZmaFuHCYmVkhLhxmZlaIC4eZmRXiwmFmZoW4cJiZWSEuHGZmVogLh5mZFeLCYWZmhbhwmJlZIS4cZmZWiAuHmZkVUmrhkDRH0iZJ3ZKWNVk+W9J6SbskzW+yfJykHkk31LUtlLRR0gZJ35U0oczvYGZmuyutcEgaDawAzgU6gIWSOhpWexpYBNzSTzdXAQ/U9TkGuA44MyJOADYAlw1ucjMza6XMI45ZQHdEbI6IHcAqYF79ChGxJSI2AK81bizpFOBw4O765vR5kyQB44DtJeU3M7Mmyiwck4CtdfM9qW1AkkYB1wJL69sjYifwEWAjWcHoAG7qp4/Fkjoldfb29hZPb2ZmTVX14vgS4K6I6KlvlLQfWeE4GTiS7FTV5c06iIiVEVGLiNrEiRPLzmtmNmKMKbHvbcCUuvnJqS2P04AzJC0BDgLGSnoR+GeAiHgSQNJq4A0X3c3MrDxlFo61wHRJ08gKxgLggjwbRsSFfdOSFgG1iFgm6UigQ9LEiOgFzgYeH/TkZmbWr9JOVUXELrI7ntaQ/cd9dUR0SVouaS6ApJmSeoDzgRsldQ3Q53bgSuABSRuAk4D/VtZ3MDOzN1JEDHeG0tVqtejs7BzuGGZmbUXSuoioNbZX9eK4mZlVlAuHmZkV4sJhZmaFuHCYmVkhLhxmZlaIC4eZmRXiwmFmZoW4cJiZWSEuHGZmVogLh5mZFeLCYWZmhbhwmJlZIS4cZmZWiAuHmZkV4sJhZmaFuHCYmVkhLhxmZlaIC4eZmRVSauGQNEfSJkndkpY1WT5b0npJuyTNb7J8nKQeSTfUtY2VtFLSTyQ9Ien9ZX4HMzPb3ZiyOpY0GlgBnA30AGsl3RkRj9Wt9jSwCFjaTzdXAQ80tF0BPBsRx0oaBRw6qMHNzKyl0goHMAvojojNAJJWAfOA1wtHRGxJy15r3FjSKcDhwHeB+pelfxg4Lm3/GvCzcuKbmVkzZZ6qmgRsrZvvSW0DSkcS19JwJCLpkDR5VTrFdZukwwcjrJmZ5VPVi+NLgLsioqehfQwwGfhBRMwAHgSuadaBpMWSOiV19vb2lpvWzGwEKfNU1TZgSt385NSWx2nAGZKWAAcBYyW9CFwOvATcnta7DbikWQcRsRJYCVCr1aJwejMza6rMwrEWmC5pGlnBWABckGfDiLiwb1rSIqAWEcvS/L8A7wTuAd5F3TUTMzMrX2mnqiJiF3AZsAZ4HFgdEV2SlkuaCyBppqQe4HzgRkldObr+NPAZSRuADwKfLOcbmJlZM4pofRZH0unAwxHxa0kXATOA6yLiqaEIOBhqtVp0dnYOdwwzs7YiaV1E1Brb8xxxfBF4SdKJZP93/yTw1UHOZ2ZmbSJP4dgV2WHJPOCGiFgBHFxuLDMzq6o8F8d/Jely4CJgdnrGYr9yY5mZWVXlOeL4APAKcElE/BvZbbWfKzWVmZlVVq4jDrKL4a9KOpZsuI9by41lZmZVleeI4wFgf0mTgLvJboG9ucxQZmZWXXkKhyLiJeA84B8i4nzg35cby8zMqipX4ZB0GnAh8O0C25mZ2T4oTwH4ONkYUXekJ7+PAe4tN5aZmVXVgBfHI+IB6l6mlN6v8bEyQ5mZWXUNWDgkTQT+M/B7wAF97RFxVom5zMysovKcqvrfwBPANOBKYAvZyLdmZjYC5Skch0XETcDOiLg/Ij4M+GjDzGyEyvMA4M708xlJfwhsBw4tL5KZmVVZnsJxtaQ3k42M+wVgHPCXpaYyM7PKynNX1bfS5PPAmeXGMTOzquu3cEi6vtWGEeFbcs3MRqBWRxyXAo8Cq8mua2hIEpmZWaW1KhxHkL0L/APALuBrwNcj4rmhCGZmZtXU7+24EfHziPjHiDgT+BBwCPCYpA/m7VzSHEmbJHVLWtZk+WxJ6yXtkjS/yfJxknok3dBk2Z2SHs2bxczMBseAz3FImkE2XtVFwHeAdXk6ljQaWAGcC3QACyV1NKz2NLAIuKWfbq6ibriTur7PA17Mk8PMzAZXv4VD0nJJ64BPAPcDtYi4JCIey9n3LKA7IjZHxA5gFdl7y18XEVsiYgPwWpPffwpwONk7QOrbD0qZrs6Zw8zMBlGrI46/Ijs9dSLwt8B6SRskbZS0IUffk4CtdfM9qW1A6b3m1wJLmyy+Ki17aYA+FkvqlNTZ29ub59eamVkOrS6OTxuyFG+0BLgrInqk397MJekk4C0R8ZeSprbqICJWAisBarValBfVzGxk6bdwRMRTe9n3NmBK3fzk1JbHacAZkpYABwFjJb0IPAXUJG0hy/67ku6LiHfuZVYzM8spz5Aje2otMF3SNLKCsQC4IM+GEXFh37SkRWTXV/ruyvpiap8KfMtFw8xsaJX2CtiI2AVcBqwBHgdWpzcILpc0F0DSTEk9ZM+L3Cipq6w8ZmY2OBTR+vS/pPcA346IN9z51C5qtVp0dnYOdwwzs7YiaV1E1Brb8xxxfAD4qaT/Lum4wY9mZmbtZMDCEREXAScDTwI3S3ow3ep6cOnpzMyscnJd44iIF4Cvkz3EdwTwPrLnOv68xGxmZlZBeYYcmSfpDuA+YD9gVkScS/Zg4CfLjWdmZlWT53bc84DPR8RuY0ZFxEuSLiknlpmZVVWeU1X/1lg0JH0WICL+tZRUZmZWWXkKx9lN2s4d7CBmZtYeWr069iNkY0a9pWFQw4OB75cdbLh946FtfG7NJrY/9zJHHnIgnzrnbbz35FxjNO5TqrwfqpKtKjmqmmcg7Za3HZS9T1td47iF7P0bfwvUv4TpVxHxi0FLUEHfeGgbl9++kZd3vgrAtude5vLbNwKMqD/oKu+HqmSrSo6q5hlIu+VtB0OxT1udqoqI2AJ8FPhV3QdJhw7Kb6+oz63Z9PpO7/Pyzlf53JpNw5RoeFR5P1QlW1VyVDXPQNotbzsYin060BHHH5G98S8A1S0L4JhBS1Ex2597uVD7vqrK+6Eq2aqSY6DfW4V/Zs20W952MBT7tNU7x/8o/ZwWEcekn32ffbZoABx5yIGF2vdVVd4PVclWlRwD/d4q/DNrpt3ytoOh2KetXh07o9Vn0BJU0KfOeRsH7jd6t7YD9xvNp8552zAlGh5V3g9VyVaVHFXNM5B2y9sOhmKftjpVdW2LZQGcNWgpKqbvAtJIv9OjyvuhKtmqkqOqeQbSbnnbwVDs0wGHVd8XeFh1M7Pi+htWvdVzHGdFxD2Szmu2PCJuH8yAZmbWHlqdqnoHcA/wnibLAnDhMDMbgfotHBHxX9PPDw1dHDMzq7o8w6ofJul6SeslrZN0naTDhiKcmZlVT55BDlcBvcD7gflp+mt5Opc0R9ImSd2SljVZPjsVpF2S5jdZPk5Sj6Qb0vzvSPq2pCckdUn6uzw5zMxs8OQpHEdExFUR8X/T52rg8IE2kjQaWEE2km4HsFBSR8NqTwOLyJ5Sb+Yq4IGGtmsi4jiy19meLskj9ZqZDaE8heNuSQskjUqfPwbW5NhuFtAdEZsjYgfZkcu8+hUiYktEbABea9xY0ilkBeruuvVfioh70/QOYD0wOUcWMzMbJK2eHP+VpBeAPyM7ItiRPquAxTn6ngRsrZvvSW0DkjSK7AHEpS3WOYTsjq+mL5OStFhSp6TO3t7ePL/WzMxyaDVW1cERMS79HBURY9JnVESMKznXEuCuiOhptlDSGOBW4PqI2NxsnYhYGRG1iKhNnDixxKhmZiNLnneOI2k8MB04oK+t8XWyTWwDptTNT05teZwGnCFpCXAQMFbSixHRd4F9JfDTiPj7nP2ZmdkgGbBwSPpT4ONk/+F/GDgVeJCBx6paC0yXNI2sYCwALsgTKiIurPv9i4BaX9GQdDXwZuBP8/RlZmaDK8/F8Y8DM4GnIuJMsruZnhtoo4jYBVxGdiH9cWB1RHRJWi5pLoCkmZJ6gPOBGyV1tepT0mTgCrK7tNZLejgVNjMzGyJ5TlX9JiJ+IwlJ+0fEE5Jyjc8bEXcBdzW0/XXd9FoGuCsqIm4Gbk7TPez+QikzMxtieQpHT7qD6RvA9yT9Eniq3FhmZlZVAxaOiHhfmvyMpHvJri98t9RUZmZWWXnvqpoBvJ1sVNzvp4fvzMxsBMozyOFfA18BDgMmAP9T0l+VHczMzKopzxHHhcCJEfEbgDSw4MPA1WUGMzOzaspzO+526h78A/Yn/4N8Zma2j2n16tgvkF3TeB7okvS9NH828OOhiWdmZlXT6lRVZ/q5Drijrv2+0tKYmVnltXp17Ff6piWNBY5Ns5siYmfZwczMrJryjFX1TrK7qraQPbU9RdLFOQY5NDOzfVCeu6quBd4dEZsAJB1LNqT5KWUGMzOzaspzV9V+fUUDICJ+AuxXXiQzM6uyPEcc6yR9Cfhfaf5Cfnvh3MzMRpg8heNS4KPAx9L8/wH+obREZmZWaS0Lh6TRwCMRcRzwP4YmkpmZVVnLaxwR8SqwSdJRQ5THzMwqLs+pqvFkT47/GPh1X2NEzC0tlZmZVVaewvFfSk9hZmZto99TVZIOkPQXZO8DP47sPRz3933ydC5pjqRNkrolLWuyfLak9ZJ2SZrfZPk4ST2SbqhrO0XSxtTn9ZL8KlkzsyHU6hrHV4AasBE4l+xBwNzShfUVadsOYKGkjobVngYWAbf0081VQOMT6l8E/gyYnj5ziuQyM7O90+pUVUdE/AcASTdRfETcWUB3RGxOfawC5gGP9a0QEVvSstcaN5Z0CnA42Wtqa6ntCGBcRPwwzX8VeC/wnYLZzMxsD7U64nh9IMOI2LUHfU8CttbN96S2AUkaRXaEs7RJnz170qeZmQ2OVkccJ0p6IU0LODDNC4iIGFdiriXAXRHRs6eXMCQtBhYDHHWU7yY2MxssrYZVH72XfW8DptTNTyb/mwNPA86QtAQ4CBgr6UXgutTPgH1GxEpgJUCtVoti0c3MrD95bsfdU2uB6ZKmkf3HfQFwQZ4NI+LCvmlJi4BaRCxL8y9IOhX4EfAnwBcGObeZmbWQZ3TcPZKui1wGrAEeB1ZHRJek5ZLmAkiaKamH7JbfGyV15eh6CfAloBt4El8YNzMbUorY98/i1Gq16Oz0gL5mZkVIWhcRtcb20o44zMxs3+TCYWZmhbhwmJlZIS4cZmZWiAuHmZkV4sJhZmaFuHCYmVkhLhxmZlaIC4eZmRXiwmFmZoW4cJiZWSEuHGZmVogLh5mZFeLCYWZmhbhwmJlZIS4cZmZWiAuHmZkV4sJhZmaFuHCYmVkhpRYOSXMkbZLULWlZk+WzJa2XtEvS/Lr2o1P7w5K6JF1at2yhpI2SNkj6rqQJZX4HMzPbXWmFQ9JoYAVwLtABLJTU0bDa08Ai4JaG9meA0yLiJOA/AsskHSlpDHAdcGZEnABsAC4r6zuYmdkblXnEMQvojojNEbEDWAXMq18hIrZExAbgtYb2HRHxSprdvy6n0udNkgSMA7aX+B3MzKxBmYVjErC1br4nteUiaYqkDamPz0bE9ojYCXwE2EhWMDqAm/rZfrGkTkmdvb29e/odzMysQWUvjkfE1nQ66q3AxZIOl7QfWeE4GTiS7FTV5f1svzIiahFRmzhx4pDlNjPb15VZOLYBU+rmJ6e2QiJiO/AocAZwUmp7MiICWA38/t5HNTOzvMosHGuB6ZKmSRoLLADuzLOhpMmSDkzT44G3A5vICk+HpL5DiLOBxwc9uZmZ9WtMWR1HxC5JlwFrgNHAlyOiS9JyoDMi7pQ0E7gDGA+8R9KVEfF7wPHAtZKC7GL4NRGxEUDSlcADknYCT5HdlWVmZkNE2RmffVutVovOzs7hjmFm1lYkrYuIWmN7ZS+Om5lZNblwmJlZIS4cZmZWiAuHmZkV4sJhZmaFuHCYmVkhLhxmZlaIC4eZmRXiwmFmZoW4cJiZWSEuHGZmVogLh5mZFeLCYWZmhbhwmJlZIS4cZmZWiAuHmZkV4sJhZmaFuHCYmVkhLhxmZlZIqYVD0hxJmyR1S1rWZPlsSesl7ZI0v6796NT+sKQuSZfWLRsraaWkn0h6QtL7y/wOZma2uzFldSxpNLACOBvoAdZKujMiHqtb7WlgEbC0YfNngNMi4hVJBwGPpm23A1cAz0bEsZJGAYeW9R3MzOyNSiscwCygOyI2A0haBcwDXi8cEbElLXutfsOI2FE3uz+7Hxl9GDgurfca8LMSspuZWT/KPFU1CdhaN9+T2nKRNEXShtTHZyNiu6RD0uKr0qms2yQd3s/2iyV1Surs7e3d0+9gZmYNKntxPCK2RsQJwFuBi1OBGANMBn4QETOAB4Fr+tl+ZUTUIqI2ceLEIcttZravK7NwbAOm1M1PTm2FpOsajwJnAD8HXgJuT4tvA2bsXUwzMyuizMKxFpguaZqkscAC4M48G0qaLOnAND0eeDuwKSIC+BfgnWnVd1F3zcTMzMpXWuGIiF3AZcAa4HFgdUR0SVouaS6ApJmSeoDzgRsldaXNjwd+JOkR4H7gmojYmJZ9GvhMuv7xQeCTZX0HMzN7I2X/E79vq9Vq0dnZOdwxzMzaiqR1EVFrbK/sxXEzM6smFw4zMyvEhcPMzApx4TAzs0JcOMzMrBAXDjMzK8SFw8zMCnHhMDOzQkbEA4CSeoGn9nDzCbT30O3OP7ycf3g5/945OiLeMErsiCgce0NSZ7MnJ9uF8w8v5x9ezl8On6oyM7NCXDjMzKwQF46BrRzuAHvJ+YeX8w8v5y+Br3GYmVkhPuIwM7NCXDjMzKyQEVs4JM2RtElSt6RlTZYfJeleSQ9J2iDpD1L7VEkvS3o4ff5x6NPnyn+0pH9N2e+TNLlu2cWSfpo+Fw9t8tcz7E3+V+v2f67XEQ82SV+W9KykR/tZLknXp++3QdKMumVV2P97k78d9v9xkh6U9IqkpQ3LWv7tDYW9zL9F0sa0/4fnDXURMeI+wGjgSeAYYCzwCNDRsM5K4CNpugPYkqanAo+2Qf7bgIvT9FnAP6XpQ4HN6ef4ND2+XfKn+Rcr8Dc0G5jR398C8AfAdwABpwI/qsr+35v8bbT/fxeYCfwNsLTI316V86dlW4AJw7n/R+oRxyygOyI2R8QOYBUwr2GdAMal6TcD24cw30Dy5O8A7knT99YtPwf4XkT8IiJ+CXwPmDMEmevtTf5KiIgHgF+0WGUe8NXI/BA4RNIRVGP/703+Shgof0Q8GxFrgZ0Ni/L87ZVuL/JXwkgtHJOArXXzPamt3meAiyT1AHcBf163bFo6hXW/pDNKTdpcnvyPAOel6fcBB0s6LOe2Zdub/AAHSOqU9ENJ7y036h7r7ztWYf/n0SpnO+z//rTL/m8lgLslrZO0eDgCjNTCkcdC4OaImEx22P5PkkYBzwBHRcTJwCeAWySNa9HPcFkKvEPSQ8A7gG3Aq8MbqZBW+Y+ObBiGC4C/l/SWYco4Unn/D6+3R8QM4Fzgo5JmD3WAkVo4tgFT6uYnp7Z6lwCrASLiQeAAsvOKr0TEz1P7OrLzpceWnnh3A+aPiO0RcV4qcFektufybDsE9iY/EbEt/dwM3AecPASZi+rvO1Zh/+fRb8422f/9aZf936+6/f8scAfZ6bchNVILx1pguqRpksYCC4DGu0OeBt4FIOl4ssLRK2mipNGp/RhgOtkFzqE0YH5JE9IREsDlwJfT9Brg3ZLGSxoPvDu1DaU9zp9y79+3DnA68NiQJc/vTuBP0t1JpwLPR8QzVGP/59E0fxvt//7k+Xe/siS9SdLBfdNkfz9N78wq1XBemR/OD9npp5+QHTFckdqWA3PTdAfwfbJz7Q8D707t7we6Utt64D0VzT8f+Gla50vA/nXbfhjoTp8PtVN+4PeBjemfy0bgkmHKfyvZacudZOfJLwEuBS5NywWsSN9vI1Cr2P7fo/xttP//XWp/AXguTY/r72+vXfKT3Q32SPp0DVd+DzliZmaFjNRTVWZmtodcOMzMrBAXDjMzK8SFw8zMCnHhMDOzQlw4zAaBspGUz2lo+wtJX+xn/fsk1YYmndngcuEwGxy3kj1MVm9Bajfbp7hwmA2OrwN/mJ5GRtJU4EhgYRoQsEvSlc02lPRi3fR8STen6YmS/lnS2vQ5vewvYZaHC4fZIIiIXwA/Jht4DrKjjdVkT/bWgBPIBm08oUC31wGfj4iZZCMWfGkQI5vtsTHDHcBsH9J3uuqb6eclwB+noa/HAEeQDWWzIWd//wnokNQ3P07SQRHxYottzErnwmE2eL4JfD69ZvV3yF7UsxSYGRG/TKegDmiyXf24P/XLRwGnRsRvSsprtkd8qspskKQjgXvJRvK9lWxQul8Dz0s6nN+exmr0/yQdn0YDfl9d+93UvUBM0kmlBDcryIXDbHDdCpwI3BoRjwAPAU8At5CNttzMMuBbwA/IRkzt8zGgJmmDpMfIRk81G3YeHdfMzArxEYeZmRXiwmFmZoW4cJiZWSEuHGZmVogLh5mZFeLCYWZmhbhwmJlZIf8fA0J30JECM6kAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Plot values for equiprobable distribution of permanent shocks\n", "\n", "plt.scatter(IndShockExample.PermShkDstn[0].X,\n", " IndShockExample.PermShkDstn[0].pmf)\n", "plt.xlabel(\"Value\")\n", "plt.ylabel(\"Probability Mass\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This distribution was created, using the parameters in the dictionary above, when the `IndShockConsumerType` object was initialized." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Solution by Backwards Induction\n", "\n", "HARK solves this problem using _backwards induction_: It will derive a solution for each period ($t$) by finding a mapping between specific values of market resources $\\{m[0],m[1],...\\}$ and the corresponding optimal consumption $\\{c[0],c[1],...\\}$. The function that \"connects the dots\" will be stored in a variable named `cFunc`.\n", "\n", "Backwards induction requires a \"terminal\" (last; final) period to work backwards from. `IndShockExample` constructed above did not specify a terminal consumption function, and consequently it uses the default terminal function in which all resources are consumed: $c_{T} = m_{t}$. " ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "IndShockExample.solution_terminal" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The consumption function `cFunc` is defined by _piecewise linear interpolation_.\n", "\n", "It is defined by a series of $(m,c)$ points on a grid; the value of the function for any $m$ is the $c$ determined by the line connecting the nearest defined gridpoints.\n", "\n", "You can see below that in the terminal period, $c = m$; the agent consumes all available resources." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Plot terminal consumption function\n", "plt.plot(IndShockExample.solution_terminal.cFunc.x_list,\n", " IndShockExample.solution_terminal.cFunc.y_list,\n", " color='k')\n", "plt.scatter(IndShockExample.solution_terminal.cFunc.x_list,\n", " IndShockExample.solution_terminal.cFunc.y_list)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The solution also has a representation of a `value function`, the value `v(m)` as a function of available market resources. Because the agent consumes all their resources in the last period, the value function for the terminal solution looks just like the CRRA utility function: $v_{T}(m) = u(m)$." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Final consumption function c=m\n", "m = np.linspace(0.1,1,100)\n", "plt.plot(m,IndShockExample.solution_terminal.vFunc(m))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Solving the problem" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This solution is generated by invoking `solve()` which is a **method** that is an **attribute** of the `IndShockExample` object. **Methods** in Python are supposed to have **documentation** that tell you what they do. You can read the documentation for methods and other attributes in HARK with the built-in Python `help()` function:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on method solve in module HARK.core:\n", "\n", "solve(verbose=False) method of HARK.ConsumptionSaving.ConsIndShockModel.IndShockConsumerType instance\n", " Solve the model for this instance of an agent type by backward induction.\n", " Loops through the sequence of one period problems, passing the solution\n", " from period t+1 to the problem for period t.\n", " \n", " Parameters\n", " ----------\n", " verbose : boolean\n", " If True, solution progress is printed to screen.\n", " \n", " Returns\n", " -------\n", " none\n", "\n" ] } ], "source": [ "help(IndShockExample.solve)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Finite or Infinite Horizon?\n", "\n", "$\\texttt{ConsIndShockType}$ can solve either finite-horizon (e.g., life-cycle) problems, or infinite-horizon problems (where the problem is the same in every period). Elsewhere you can find documentation about the finite horizon solution; here we are interested in the infinite-horizon solution which is obtained (by definition) when iterating one more period yields a solution that is essentially the same. In the dictionary above we signaled to HARK that we want the infinite horizon solution by setting the \"cycles\" paramter to zero:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "IndShockExample.cycles # Infinite horizon solution is computed when cycles = 0" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPFRaw = 0.984539 \n", "GPFNrm = 0.993777 \n", "GPFAggLivPrb = 0.964848 \n", "Thorn = APF = 0.994384 \n", "PermGroFacAdj = 1.000611 \n", "uInvEpShkuInv = 0.990704 \n", "VAF = 0.932054 \n", "WRPF = 0.213705 \n", "DiscFacGPFNrmMax = 0.972061 \n", "DiscFacGPFAggLivPrbMax = 1.010600 \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Finished cycle #1 in 0.0016739368438720703 seconds, solution distance = 100.0\n", "Finished cycle #2 in 0.0020780563354492188 seconds, solution distance = 10.088015890333441\n", "Finished cycle #3 in 0.0017011165618896484 seconds, solution distance = 3.3534114736589693\n", "Finished cycle #4 in 0.001529693603515625 seconds, solution distance = 1.669952961389428\n", "Finished cycle #5 in 0.0019981861114501953 seconds, solution distance = 0.9967360674688486\n", "Finished cycle #6 in 0.0018858909606933594 seconds, solution distance = 0.6602619046109517\n", "Finished cycle #7 in 0.007195234298706055 seconds, solution distance = 0.46809484231437537\n", "Finished cycle #8 in 0.002302885055541992 seconds, solution distance = 0.34807706501006663\n", "Finished cycle #9 in 0.0022499561309814453 seconds, solution distance = 0.2681341538834978\n", "Finished cycle #10 in 0.0018150806427001953 seconds, solution distance = 0.2122324816862755\n", "Finished cycle #11 in 0.0015168190002441406 seconds, solution distance = 0.17162798586899441\n", "Finished cycle #12 in 0.0026161670684814453 seconds, solution distance = 0.14121714401876417\n", "Finished cycle #13 in 0.004358053207397461 seconds, solution distance = 0.11786112023934692\n", "Finished cycle #14 in 0.0019199848175048828 seconds, solution distance = 0.09954374358267426\n", "Finished cycle #15 in 0.002624034881591797 seconds, solution distance = 0.08492077965589928\n", "Finished cycle #16 in 0.0026040077209472656 seconds, solution distance = 0.07306820983636797\n", "Finished cycle #17 in 0.0028498172760009766 seconds, solution distance = 0.06333371450893699\n", "Finished cycle #18 in 0.0033011436462402344 seconds, solution distance = 0.055246317280595036\n", "Finished cycle #19 in 0.00168609619140625 seconds, solution distance = 0.04845886926538867\n", "Finished cycle #20 in 0.0015017986297607422 seconds, solution distance = 0.042711109600137576\n", "Finished cycle #21 in 0.0015749931335449219 seconds, solution distance = 0.037804865822300915\n", "Finished cycle #22 in 0.0015451908111572266 seconds, solution distance = 0.03358704056809714\n", "Finished cycle #23 in 0.0015947818756103516 seconds, solution distance = 0.029937835775703636\n", "Finished cycle #24 in 0.0015821456909179688 seconds, solution distance = 0.02676242583398336\n", "Finished cycle #25 in 0.0017249584197998047 seconds, solution distance = 0.02398495974448922\n", "Finished cycle #26 in 0.0013790130615234375 seconds, solution distance = 0.021544181039296006\n", "Finished cycle #27 in 0.0014410018920898438 seconds, solution distance = 0.019390181762535263\n", "Finished cycle #28 in 0.0017719268798828125 seconds, solution distance = 0.01748196739049135\n", "Finished cycle #29 in 0.0017309188842773438 seconds, solution distance = 0.015785611379662168\n", "Finished cycle #30 in 0.0017249584197998047 seconds, solution distance = 0.014272839895088651\n", "Finished cycle #31 in 0.0014142990112304688 seconds, solution distance = 0.012919936192925086\n", "Finished cycle #32 in 0.001615762710571289 seconds, solution distance = 0.011706884785620986\n", "Finished cycle #33 in 0.0022771358489990234 seconds, solution distance = 0.010616703056517629\n", "Finished cycle #34 in 0.001847982406616211 seconds, solution distance = 0.009634898474986997\n", "Finished cycle #35 in 0.0017590522766113281 seconds, solution distance = 0.00874904442068214\n", "Finished cycle #36 in 0.0013680458068847656 seconds, solution distance = 0.007948413988061898\n", "Finished cycle #37 in 0.0012519359588623047 seconds, solution distance = 0.00722372447082309\n", "Finished cycle #38 in 0.0012059211730957031 seconds, solution distance = 0.006566906564932307\n", "Finished cycle #39 in 0.0013859272003173828 seconds, solution distance = 0.005970916077075117\n", "Finished cycle #40 in 0.0011909008026123047 seconds, solution distance = 0.005429579002497409\n", "Finished cycle #41 in 0.00110626220703125 seconds, solution distance = 0.004937463273915643\n", "Finished cycle #42 in 0.0010828971862792969 seconds, solution distance = 0.004489772052598262\n", "Finished cycle #43 in 0.001149892807006836 seconds, solution distance = 0.004082254546442954\n", "Finished cycle #44 in 0.0011780261993408203 seconds, solution distance = 0.003711131170160087\n", "Finished cycle #45 in 0.0012040138244628906 seconds, solution distance = 0.003373030500466001\n", "Finished cycle #46 in 0.001112222671508789 seconds, solution distance = 0.0030649359736791837\n", "Finished cycle #47 in 0.0012929439544677734 seconds, solution distance = 0.0027841406665807256\n", "Finished cycle #48 in 0.0010399818420410156 seconds, solution distance = 0.0025282088157077\n", "Finished cycle #49 in 0.0010499954223632812 seconds, solution distance = 0.0022949429754119954\n", "Finished cycle #50 in 0.0010769367218017578 seconds, solution distance = 0.0020823559119378388\n", "Finished cycle #51 in 0.0010399818420410156 seconds, solution distance = 0.0018886464739757969\n", "Finished cycle #52 in 0.0017330646514892578 seconds, solution distance = 0.0017121788176539532\n", "Finished cycle #53 in 0.0021021366119384766 seconds, solution distance = 0.0015514644867238303\n", "Finished cycle #54 in 0.0017199516296386719 seconds, solution distance = 0.0014051468883913287\n", "Finished cycle #55 in 0.0011959075927734375 seconds, solution distance = 0.0012719878080478253\n", "Finished cycle #56 in 0.001257181167602539 seconds, solution distance = 0.0011508556554602478\n", "Finished cycle #57 in 0.0015118122100830078 seconds, solution distance = 0.001040715183035168\n", "Finished cycle #58 in 0.0014200210571289062 seconds, solution distance = 0.0009406184572178233\n", "Finished cycle #59 in 0.0014238357543945312 seconds, solution distance = 0.0008496968979514463\n", "Finished cycle #60 in 0.002164125442504883 seconds, solution distance = 0.0007671542298588463\n", "Finished cycle #61 in 0.0020990371704101562 seconds, solution distance = 0.0006922602130656763\n", "Finished cycle #62 in 0.001447916030883789 seconds, solution distance = 0.00062434504219544\n", "Finished cycle #63 in 0.001293182373046875 seconds, solution distance = 0.0005627943195669616\n", "Finished cycle #64 in 0.0014579296112060547 seconds, solution distance = 0.0005070445234869325\n", "Finished cycle #65 in 0.0012559890747070312 seconds, solution distance = 0.00045657890516936916\n", "Finished cycle #66 in 0.0012729167938232422 seconds, solution distance = 0.0004109237583840297\n", "Finished cycle #67 in 0.0014119148254394531 seconds, solution distance = 0.0003696450150627584\n", "Finished cycle #68 in 0.00180816650390625 seconds, solution distance = 0.0003323451276209255\n", "Finished cycle #69 in 0.002145051956176758 seconds, solution distance = 0.0002986602050065734\n", "Finished cycle #70 in 0.0018019676208496094 seconds, solution distance = 0.0002682573749837047\n", "Finished cycle #71 in 0.0016438961029052734 seconds, solution distance = 0.00024083234929284103\n", "Finished cycle #72 in 0.00138092041015625 seconds, solution distance = 0.00021610717220754694\n", "Finished cycle #73 in 0.0019290447235107422 seconds, solution distance = 0.00019382813573720625\n", "Finished cycle #74 in 0.001438140869140625 seconds, solution distance = 0.0001737638473713332\n", "Finished cycle #75 in 0.0015208721160888672 seconds, solution distance = 0.0001557034380539335\n", "Finished cycle #76 in 0.0011610984802246094 seconds, solution distance = 0.00013945489982480908\n", "Finished cycle #77 in 0.0014510154724121094 seconds, solution distance = 0.00012484354371977702\n", "Finished cycle #78 in 0.0015549659729003906 seconds, solution distance = 0.00011171056964087711\n", "Finished cycle #79 in 0.0016109943389892578 seconds, solution distance = 9.991174074253095e-05\n", "Finished cycle #80 in 0.0013659000396728516 seconds, solution distance = 8.931615549911953e-05\n", "Finished cycle #81 in 0.0011630058288574219 seconds, solution distance = 7.98051111954301e-05\n", "Finished cycle #82 in 0.0012030601501464844 seconds, solution distance = 7.127105311699466e-05\n", "Finished cycle #83 in 0.0011370182037353516 seconds, solution distance = 6.361660386744461e-05\n", "Finished cycle #84 in 0.0010991096496582031 seconds, solution distance = 5.675366786039859e-05\n", "Finished cycle #85 in 0.0011119842529296875 seconds, solution distance = 5.060260605649347e-05\n", "Finished cycle #86 in 0.001277923583984375 seconds, solution distance = 4.5091476412739695e-05\n", "Finished cycle #87 in 0.0012450218200683594 seconds, solution distance = 4.0155335675251536e-05\n", "Finished cycle #88 in 0.0011320114135742188 seconds, solution distance = 3.573559836667073e-05\n", "Finished cycle #89 in 0.0011420249938964844 seconds, solution distance = 3.1779449082502964e-05\n", "Finished cycle #90 in 0.001935720443725586 seconds, solution distance = 2.8239304256771902e-05\n", "Finished cycle #91 in 0.0014662742614746094 seconds, solution distance = 2.507231993220671e-05\n", "Finished cycle #92 in 0.0020759105682373047 seconds, solution distance = 2.2239942116808464e-05\n", "Finished cycle #93 in 0.0031790733337402344 seconds, solution distance = 1.970749654489623e-05\n", "Finished cycle #94 in 0.0017740726470947266 seconds, solution distance = 1.7443814824158466e-05\n", "Finished cycle #95 in 0.0015819072723388672 seconds, solution distance = 1.5420894161621845e-05\n", "Finished cycle #96 in 0.0024521350860595703 seconds, solution distance = 1.361358793783296e-05\n", "Finished cycle #97 in 0.002887725830078125 seconds, solution distance = 1.1999324726730265e-05\n", "Finished cycle #98 in 0.0015711784362792969 seconds, solution distance = 1.0557853297399333e-05\n", "Finished cycle #99 in 0.0014679431915283203 seconds, solution distance = 9.271011537581586e-06\n", "Finished cycle #100 in 0.0019409656524658203 seconds, solution distance = 8.122517190400913e-06\n", "Finished cycle #101 in 0.0013899803161621094 seconds, solution distance = 7.097778525810838e-06\n", "Finished cycle #102 in 0.001196146011352539 seconds, solution distance = 6.183723240127392e-06\n", "Finished cycle #103 in 0.0012407302856445312 seconds, solution distance = 5.368643900993675e-06\n", "Finished cycle #104 in 0.0011181831359863281 seconds, solution distance = 4.6420585193551744e-06\n", "Finished cycle #105 in 0.0012371540069580078 seconds, solution distance = 3.994584801603196e-06\n", "Finished cycle #106 in 0.001432657241821289 seconds, solution distance = 3.4178268535356437e-06\n", "Finished cycle #107 in 0.0011641979217529297 seconds, solution distance = 2.9042732037076746e-06\n", "Finished cycle #108 in 0.0011570453643798828 seconds, solution distance = 2.4472050093038433e-06\n", "Finished cycle #109 in 0.0012590885162353516 seconds, solution distance = 2.0406135354811283e-06\n", "Finished cycle #110 in 0.0011327266693115234 seconds, solution distance = 1.6791260115667228e-06\n", "Finished cycle #111 in 0.0011620521545410156 seconds, solution distance = 1.3579390065743269e-06\n", "Finished cycle #112 in 0.001386880874633789 seconds, solution distance = 1.0727586690073565e-06\n", "Finished cycle #113 in 0.0012333393096923828 seconds, solution distance = 8.197470720006095e-07\n" ] } ], "source": [ "# Solve It\n", "IndShockExample.solve(verbose=True) # Verbose prints progress as solution proceeds" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# plot_funcs([list],min,max) takes a [list] of functions and plots their values over a range from min to max\n", "plot_funcs([IndShockExample.solution[0].cFunc,IndShockExample.solution_terminal.cFunc],0.,10.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Changing Constructed Attributes\n", "\n", "In the parameter dictionary above, we chose values for HARK to use when constructing its numerical representation of $F_t$, the joint distribution of permanent and transitory income shocks. When $\\texttt{IndShockExample}$ was created, those parameters ($\\texttt{TranShkStd}$, etc) were used by the **constructor** or **initialization** method of $\\texttt{IndShockConsumerType}$ to construct an attribute called $\\texttt{IncomeDstn}$.\n", "\n", "Suppose you were interested in changing (say) the amount of permanent income risk. From the section above, you might think that you could simply change the attribute $\\texttt{TranShkStd}$, solve the model again, and it would work.\n", "\n", "That's _almost_ true-- there's one extra step. $\\texttt{TranShkStd}$ is a primitive input, but it's not the thing you _actually_ want to change. Changing $\\texttt{TranShkStd}$ doesn't actually update the income distribution... unless you tell it to (just like changing an agent's preferences does not change the consumption function that was stored for the old set of parameters -- until you invoke the $\\texttt{solve}$ method again). In the cell below, we invoke the method $\\texttt{updateIncomeProcess}$ so HARK knows to reconstruct the attribute $\\texttt{IncomeDstn}$." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPFRaw = 0.984539 \n", "GPFNrm = 1.021965 \n", "GPFAggLivPrb = 0.964848 \n", "Thorn = APF = 0.994384 \n", "PermGroFacAdj = 0.973012 \n", "uInvEpShkuInv = 0.963379 \n", "VAF = 0.906347 \n", "WRPF = 0.213705 \n", "DiscFacGPFNrmMax = 0.919178 \n", "DiscFacGPFAggLivPrbMax = 1.010600 \n" ] } ], "source": [ "OtherExample = deepcopy(IndShockExample) # Make a copy so we can compare consumption functions\n", "OtherExample.PermShkStd = [0.2] # Double permanent income risk (note that it's a one element list)\n", "OtherExample.updateIncomeProcess() # Call the method to reconstruct the representation of F_t\n", "OtherExample.solve()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the cell below, use your blossoming HARK skills to plot the consumption function for $\\texttt{IndShockExample}$ and $\\texttt{OtherExample}$ on the same figure." ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "code_folding": [], "lines_to_next_cell": 2 }, "outputs": [], "source": [ "# Use the remainder of this cell to plot the IndShockExample and OtherExample consumption functions against each other" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Buffer Stock Saving?\n", "\n", "There are some combinations of parameter values under which problems of the kind specified above have \"degenerate\" solutions; for example, if consumers are so patient that they always prefer deferring consumption to the future, the limiting consumption rule can be $c(m)=0$. \n", "\n", "The toolkit has built-in tests for a number of parametric conditions that can be shown to result in various characteristics in the optimal solution.\n", "\n", "Perhaps the most interesting such condition is the [\"Growth Impatience Condition\"](http://econ.jhu.edu/people/ccarroll/Papers/BufferStockTheory/#GIC): If this condition is satisfied, the consumer's optimal behavior is to aim to achieve a \"target\" value of $m$, to serve as a precautionary buffer against income shocks.\n", "\n", "The tests can be invoked using the `check_conditions()` method:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPFRaw = 0.984539 \n", "GPFNrm = 0.993777 \n", "GPFAggLivPrb = 0.964848 \n", "Thorn = APF = 0.994384 \n", "PermGroFacAdj = 1.000611 \n", "uInvEpShkuInv = 0.990704 \n", "VAF = 0.932054 \n", "WRPF = 0.213705 \n", "DiscFacGPFNrmMax = 0.972061 \n", "DiscFacGPFAggLivPrbMax = 1.010600 \n" ] } ], "source": [ "IndShockExample.check_conditions(verbose=True)" ] } ], "metadata": { "jupytext": { "cell_metadata_json": true, "formats": "ipynb,py:percent", "notebook_metadata_filter": "all" }, "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.7.4" } }, "nbformat": 4, "nbformat_minor": 4 }