{ "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](./Gentle-Intro-To-HARK-PerfForesightCRRA.ipynb) except that now the model incorporates income uncertainty and (artificial) borrowing constraints." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "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", "from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n", "from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType\n", "from HARK.utilities import plot_funcs\n", "import matplotlib.pyplot as plt\n", "\n", "import numpy as np\n", "from copy import deepcopy\n", "\n", "\n", "def mystr(number):\n", " return \"{:.4f}\".format(number)" ] }, { "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://www.econ2.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": {}, "outputs": [], "source": [ "# This cell defines a parameter dictionary for making an instance of IndShockConsumerType.\n", "\n", "\n", "IndShockDictionary = {\n", " \"PermShkStd\": [\n", " 0.1\n", " ], # ... 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", " # ... and income for unemployed people (30 percent of \"permanent\" income)\n", " \"IncUnemp\": 0.3,\n", " # ... and specifying the location of the borrowing constraint (0 means no borrowing is allowed)\n", " \"BoroCnstArt\": 0.0,\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", " 'PerfMITShk',\n", " 'PermGroFac',\n", " 'PermGroFacAgg',\n", " 'RNG',\n", " 'Rfree',\n", " 'T_age',\n", " 'T_cycle',\n", " '__class__',\n", " '__delattr__',\n", " '__dict__',\n", " '__dir__',\n", " '__doc__',\n", " '__eq__',\n", " '__format__',\n", " '__ge__',\n", " '__getattribute__',\n", " '__getstate__',\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", " '_constructor_errors',\n", " '_missing_key_data',\n", " 'add_to_time_inv',\n", " 'add_to_time_vary',\n", " 'assign_parameters',\n", " 'bilt',\n", " 'calc_impulse_response_manually',\n", " 'calc_limiting_values',\n", " 'calc_stable_points',\n", " 'check_AIC',\n", " 'check_FHWC',\n", " 'check_FVAC',\n", " 'check_GICRaw',\n", " 'check_RIC',\n", " 'check_conditions',\n", " 'check_elements_of_time_vary_are_lists',\n", " 'check_restrictions',\n", " 'clear_history',\n", " 'construct',\n", " 'constructors',\n", " 'controls',\n", " 'cycles',\n", " 'default_',\n", " 'del_from_time_inv',\n", " 'del_from_time_vary',\n", " 'del_param',\n", " 'describe',\n", " 'describe_constructors',\n", " 'describe_model',\n", " 'describe_parameters',\n", " 'distributions',\n", " 'get_Rfree',\n", " 'get_controls',\n", " 'get_mortality',\n", " 'get_parameter',\n", " 'get_poststates',\n", " 'get_shocks',\n", " 'get_states',\n", " 'history',\n", " 'initialize_sim',\n", " 'initialize_sym',\n", " 'kLogInitMean',\n", " 'kLogInitStd',\n", " 'kNrmInitCount',\n", " 'kNrmInitDstn',\n", " 'log_condition_result',\n", " 'make_basic_SSJ',\n", " 'make_shock_history',\n", " 'model_file',\n", " 'newborn_init_history',\n", " 'pLogInitMean',\n", " 'pLogInitStd',\n", " 'pLvlInitCount',\n", " 'pLvlInitDstn',\n", " 'parameters',\n", " 'post_solve',\n", " 'poststate_vars',\n", " 'pre_solve',\n", " 'pseudo_terminal',\n", " 'quiet',\n", " 'read_shocks',\n", " 'read_shocks_from_history',\n", " 'reset_rng',\n", " 'seed',\n", " 'shock_history',\n", " 'shock_vars',\n", " 'shock_vars_',\n", " 'shocks',\n", " 'sim_birth',\n", " 'sim_death',\n", " 'sim_one_period',\n", " 'simulate',\n", " 'simulation_defaults',\n", " 'solution_terminal',\n", " 'solve',\n", " 'solve_one_period',\n", " 'solving_defaults',\n", " 'state_now',\n", " 'state_prev',\n", " 'state_vars',\n", " 'symulate',\n", " 'time_inv',\n", " 'time_inv_',\n", " 'time_vary',\n", " 'time_vary_',\n", " 'tolerance',\n", " 'track_vars',\n", " 'transition',\n", " 'unpack',\n", " 'update',\n", " 'verbose']" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "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": [ "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": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot values for equiprobable distribution of permanent shocks\n", "\n", "plt.scatter(IndShockExample.PermShkDstn[0].atoms, IndShockExample.PermShkDstn[0].pmv)\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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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot terminal consumption function\n", "plt.plot(\n", " IndShockExample.solution_terminal.cFunc.x_list,\n", " IndShockExample.solution_terminal.cFunc.y_list,\n", " color=\"k\",\n", ")\n", "plt.scatter(\n", " IndShockExample.solution_terminal.cFunc.x_list,\n", " IndShockExample.solution_terminal.cFunc.y_list,\n", ")" ] }, { "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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", "text/plain": [ "
" ] }, "metadata": {}, "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, presolve=True, postsolve=True, from_solution=None, from_t=None) 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 : bool, optional\n", " If True, solution progress is printed to screen. Default False.\n", " presolve : bool, optional\n", " If True (default), the pre_solve method is run before solving.\n", " postsolve : bool, optional\n", " If True (default), the post_solve method is run after solving.\n", " from_solution: Solution\n", " If different from None, will be used as the starting point of backward\n", " induction, instead of self.solution_terminal.\n", " from_t : int or None\n", " If not None, indicates which period of the model the solver should start\n", " from. It should usually only be used in combination with from_solution.\n", " Stands for the time index that from_solution represents, and thus is\n", " only compatible with cycles=1 and will be reset to None otherwise.\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": "stdout", "output_type": "stream", "text": [ "Finished cycle #1 in 0.001001596450805664 seconds, solution distance = 100.0\n", "Finished cycle #2 in 0.0009992122650146484 seconds, solution distance = 10.088015890333434\n", "Finished cycle #3 in 0.0009999275207519531 seconds, solution distance = 3.3534114736589693\n", "Finished cycle #4 in 0.001001119613647461 seconds, solution distance = 1.6699529613894306\n", "Finished cycle #5 in 0.00099945068359375 seconds, solution distance = 0.9967360674688486\n", "Finished cycle #6 in 0.0009996891021728516 seconds, solution distance = 0.6602619046109499\n", "Finished cycle #7 in 0.001001596450805664 seconds, solution distance = 0.4680948423143789\n", "Finished cycle #8 in 0.0009999275207519531 seconds, solution distance = 0.34807706501006663\n", "Finished cycle #9 in 0.0010120868682861328 seconds, solution distance = 0.2681341538834978\n", "Finished cycle #10 in 0.0009875297546386719 seconds, solution distance = 0.21223248168627507\n", "Finished cycle #11 in 0.0010097026824951172 seconds, solution distance = 0.17162798586899441\n", "Finished cycle #12 in 0.0009918212890625 seconds, solution distance = 0.14121714401876462\n", "Finished cycle #13 in 0.0010118484497070312 seconds, solution distance = 0.11786112023934692\n", "Finished cycle #14 in 0.0009963512420654297 seconds, solution distance = 0.09954374358267515\n", "Finished cycle #15 in 0.0 seconds, solution distance = 0.08492077965589839\n", "Finished cycle #16 in 0.0009918212890625 seconds, solution distance = 0.07306820983636841\n", "Finished cycle #17 in 0.0010006427764892578 seconds, solution distance = 0.06333371450893921\n", "Finished cycle #18 in 0.0010001659393310547 seconds, solution distance = 0.055246317280595036\n", "Finished cycle #19 in 0.0010123252868652344 seconds, solution distance = 0.04845886926538645\n", "Finished cycle #20 in 0.0009996891021728516 seconds, solution distance = 0.04271110960013802\n", "Finished cycle #21 in 0.000989675521850586 seconds, solution distance = 0.03780486582230225\n", "Finished cycle #22 in 0.0010111331939697266 seconds, solution distance = 0.03358704056809492\n", "Finished cycle #23 in 0.0009970664978027344 seconds, solution distance = 0.02993783577570497\n", "Finished cycle #24 in 0.001003265380859375 seconds, solution distance = 0.026762425833982917\n", "Finished cycle #25 in 0.0009882450103759766 seconds, solution distance = 0.02398495974448922\n", "Finished cycle #26 in 0.0010004043579101562 seconds, solution distance = 0.02154418103929423\n", "Finished cycle #27 in 0.0010120868682861328 seconds, solution distance = 0.019390181762538816\n", "Finished cycle #28 in 0.0009992122650146484 seconds, solution distance = 0.017481967390489572\n", "Finished cycle #29 in 0.0009980201721191406 seconds, solution distance = 0.015785611379662612\n", "Finished cycle #30 in 0.0009908676147460938 seconds, solution distance = 0.014272839895086431\n", "Finished cycle #31 in 0.0010135173797607422 seconds, solution distance = 0.012919936192925974\n", "Finished cycle #32 in 0.00099945068359375 seconds, solution distance = 0.011706884785618321\n", "Finished cycle #33 in 0.0009884834289550781 seconds, solution distance = 0.010616703056520294\n", "Finished cycle #34 in 0.0 seconds, solution distance = 0.009634898474986997\n", "Finished cycle #35 in 0.0010118484497070312 seconds, solution distance = 0.008749044420678587\n", "Finished cycle #36 in 0.0009889602661132812 seconds, solution distance = 0.007948413988064118\n", "Finished cycle #37 in 0.0009992122650146484 seconds, solution distance = 0.007223724470822646\n", "Finished cycle #38 in 0.0010006427764892578 seconds, solution distance = 0.006566906564932307\n", "Finished cycle #39 in 0.001009225845336914 seconds, solution distance = 0.005970916077072452\n", "Finished cycle #40 in 0.0009906291961669922 seconds, solution distance = 0.005429579002498741\n", "Finished cycle #41 in 0.0010123252868652344 seconds, solution distance = 0.004937463273915199\n", "Finished cycle #42 in 0.0009887218475341797 seconds, solution distance = 0.004489772052600927\n", "Finished cycle #43 in 0.0010120868682861328 seconds, solution distance = 0.00408225454644251\n", "Finished cycle #44 in 0.0010004043579101562 seconds, solution distance = 0.0037111311701636396\n", "Finished cycle #45 in 0.0010001659393310547 seconds, solution distance = 0.003373030500464669\n", "Finished cycle #46 in 0.0 seconds, solution distance = 0.0030649359736796278\n", "Finished cycle #47 in 0.0010001659393310547 seconds, solution distance = 0.0027841406665807256\n", "Finished cycle #48 in 0.0010001659393310547 seconds, solution distance = 0.0025282088157077\n", "Finished cycle #49 in 0.0009875297546386719 seconds, solution distance = 0.0022949429754119954\n", "Finished cycle #50 in 0.0010008811950683594 seconds, solution distance = 0.0020823559119378388\n", "Finished cycle #51 in 0.0009992122650146484 seconds, solution distance = 0.0018886464739757969\n", "Finished cycle #52 in 0.001001596450805664 seconds, solution distance = 0.0017121788176552855\n", "Finished cycle #53 in 0.001008749008178711 seconds, solution distance = 0.0015514644867233862\n", "Finished cycle #54 in 0.0010004043579101562 seconds, solution distance = 0.0014051468883913287\n", "Finished cycle #55 in 0.0009915828704833984 seconds, solution distance = 0.0012719878080478253\n", "Finished cycle #56 in 0.0010118484497070312 seconds, solution distance = 0.0011508556554602478\n", "Finished cycle #57 in 0.0009963512420654297 seconds, solution distance = 0.0010407151830378325\n", "Finished cycle #58 in 0.0009918212890625 seconds, solution distance = 0.0009406184572169352\n", "Finished cycle #59 in 0.0010008811950683594 seconds, solution distance = 0.0008496968979514463\n", "Finished cycle #60 in 0.0 seconds, solution distance = 0.000767154229857514\n", "Finished cycle #61 in 0.002000570297241211 seconds, solution distance = 0.0006922602130678968\n", "Finished cycle #62 in 0.0 seconds, solution distance = 0.000624345042195884\n", "Finished cycle #63 in 0.00119781494140625 seconds, solution distance = 0.0005627943195669616\n", "Finished cycle #64 in 0.0008139610290527344 seconds, solution distance = 0.0005070445234864884\n", "Finished cycle #65 in 0.0010004043579101562 seconds, solution distance = 0.0004565789051689251\n", "Finished cycle #66 in 0.0009992122650146484 seconds, solution distance = 0.0004109237583840297\n", "Finished cycle #67 in 0.0009894371032714844 seconds, solution distance = 0.00036964501506320246\n", "Finished cycle #68 in 0.0010018348693847656 seconds, solution distance = 0.00033234512761959323\n", "Finished cycle #69 in 0.0010101795196533203 seconds, solution distance = 0.0002986602050079057\n", "Finished cycle #70 in 0.0010004043579101562 seconds, solution distance = 0.0002682573749837047\n", "Finished cycle #71 in 0.0010020732879638672 seconds, solution distance = 0.00024083234929284103\n", "Finished cycle #72 in 0.0010001659393310547 seconds, solution distance = 0.00021610717220754694\n", "Finished cycle #73 in 0.0 seconds, solution distance = 0.0001938281357389826\n", "Finished cycle #74 in 0.0009982585906982422 seconds, solution distance = 0.0001737638473713332\n", "Finished cycle #75 in 0.001001596450805664 seconds, solution distance = 0.00015570343805260123\n", "Finished cycle #76 in 0.0009987354278564453 seconds, solution distance = 0.00013945489982702952\n", "Finished cycle #77 in 0.0009887218475341797 seconds, solution distance = 0.00012484354371933293\n", "Finished cycle #78 in 0.001214742660522461 seconds, solution distance = 0.00011171056964087711\n", "Finished cycle #79 in 0.0007989406585693359 seconds, solution distance = 9.991174074386322e-05\n", "Finished cycle #80 in 0.0009884834289550781 seconds, solution distance = 8.931615549556682e-05\n", "Finished cycle #81 in 0.0009989738464355469 seconds, solution distance = 7.980511119587419e-05\n", "Finished cycle #82 in 0.0010004043579101562 seconds, solution distance = 7.12710531196592e-05\n", "Finished cycle #83 in 0.0009999275207519531 seconds, solution distance = 6.361660386744461e-05\n", "Finished cycle #84 in 0.0010137557983398438 seconds, solution distance = 5.675366786039859e-05\n", "Finished cycle #85 in 0.0009870529174804688 seconds, solution distance = 5.060260605649347e-05\n", "Finished cycle #86 in 0.0 seconds, solution distance = 4.5091476412739695e-05\n", "Finished cycle #87 in 0.0020008087158203125 seconds, solution distance = 4.0155335675251536e-05\n", "Finished cycle #88 in 0.0010001659393310547 seconds, solution distance = 3.573559836667073e-05\n", "Finished cycle #89 in 0.0 seconds, solution distance = 3.1779449082502964e-05\n", "Finished cycle #90 in 0.0010001659393310547 seconds, solution distance = 2.8239304256771902e-05\n", "Finished cycle #91 in 0.0010006427764892578 seconds, solution distance = 2.507231993220671e-05\n", "Finished cycle #92 in 0.0010135173797607422 seconds, solution distance = 2.2239942116364375e-05\n", "Finished cycle #93 in 0.0009992122650146484 seconds, solution distance = 1.970749654489623e-05\n", "Finished cycle #94 in 0.0009865760803222656 seconds, solution distance = 1.7443814823714376e-05\n", "Finished cycle #95 in 0.001009225845336914 seconds, solution distance = 1.54208941594014e-05\n", "Finished cycle #96 in 0.0009996891021728516 seconds, solution distance = 1.3613587938721139e-05\n", "Finished cycle #97 in 0.0 seconds, solution distance = 1.1999324726730265e-05\n", "Finished cycle #98 in 0.00199127197265625 seconds, solution distance = 1.0557853295622976e-05\n", "Finished cycle #99 in 0.0010013580322265625 seconds, solution distance = 9.271011538913854e-06\n", "Finished cycle #100 in 0.0010094642639160156 seconds, solution distance = 8.122517190400913e-06\n", "Finished cycle #101 in 0.0 seconds, solution distance = 7.097778525810838e-06\n", "Finished cycle #102 in 0.0012743473052978516 seconds, solution distance = 6.183723237906946e-06\n", "Finished cycle #103 in 0.0007164478302001953 seconds, solution distance = 5.368643900993675e-06\n", "Finished cycle #104 in 0.0010094642639160156 seconds, solution distance = 4.642058520687442e-06\n", "Finished cycle #105 in 0.0010356903076171875 seconds, solution distance = 3.99458479938275e-06\n", "Finished cycle #106 in 0.0009560585021972656 seconds, solution distance = 3.4178268535356437e-06\n", "Finished cycle #107 in 0.0010089874267578125 seconds, solution distance = 2.9042732059281207e-06\n", "Finished cycle #108 in 0.0009999275207519531 seconds, solution distance = 2.4472050079715757e-06\n", "Finished cycle #109 in 0.0010004043579101562 seconds, solution distance = 2.0406135377015744e-06\n", "Finished cycle #110 in 0.0010006427764892578 seconds, solution distance = 1.679126009790366e-06\n", "Finished cycle #111 in 0.0009999275207519531 seconds, solution distance = 1.357939007018416e-06\n", "Finished cycle #112 in 0.0009999275207519531 seconds, solution distance = 1.0727586712278026e-06\n", "Finished cycle #113 in 0.0 seconds, solution distance = 8.19747068891985e-07\n" ] } ], "source": [ "# Solve It\n", "# Verbose prints progress as solution proceeds\n", "IndShockExample.solve(verbose=True)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "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(\n", " [IndShockExample.solution[0].cFunc, IndShockExample.solution_terminal.cFunc],\n", " 0.0,\n", " 10.0,\n", ")" ] }, { "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{update\\_income\\_process}$ so HARK knows to reconstruct the attribute $\\texttt{IncomeDstn}$." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "OtherExample = deepcopy(\n", " IndShockExample\n", ") # Make a copy so we can compare consumption functions\n", "OtherExample.PermShkStd = [\n", " 0.2\n", "] # Double permanent income risk (note that it's a one element list)\n", "# Call the method to reconstruct the representation of F_t\n", "OtherExample.update_income_process()\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": {}, "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://www.econ2.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 `checkConditions()` method:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "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 (ipykernel)", "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.12.9" } }, "nbformat": 4, "nbformat_minor": 4 }