diff --git a/Documentation/conf.py b/Documentation/conf.py index d026f4f7a..426933b47 100644 --- a/Documentation/conf.py +++ b/Documentation/conf.py @@ -39,6 +39,7 @@ 'sphinx.ext.coverage', 'sphinx.ext.mathjax', 'sphinx.ext.autosummary', + 'sphinx.ext.imgconverter', 'numpydoc', 'nbsphinx', 'recommonmark', diff --git a/Documentation/index.rst b/Documentation/index.rst index 19c2a4b14..39af57ebc 100644 --- a/Documentation/index.rst +++ b/Documentation/index.rst @@ -8,12 +8,20 @@ Welcome to HARK's documentation! readme .. toctree:: - :maxdepth: 2 + :maxdepth: 3 :caption: Notebooks notebooks/Gentle-Intro-To-HARK notebooks/DCT-Copula-Illustration - + notebooks/Journeys_into_HARK + + +.. toctree:: + :maxdepth: 3 + :caption: Journeys into HARK + + notebooks/Journey_1_PhD + .. toctree:: :maxdepth: 2 :caption: Python API diff --git a/Documentation/notebooks/Chinese-Growth.ipynb b/Documentation/notebooks/Chinese-Growth.ipynb new file mode 100644 index 000000000..bb10fe9c0 --- /dev/null +++ b/Documentation/notebooks/Chinese-Growth.ipynb @@ -0,0 +1,580 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Initial imports and notebook setup, click arrow to show\n", + "%matplotlib inline\n", + "# The first step is to be able to bring things in from different directories\n", + "import sys \n", + "import os\n", + "sys.path.insert(0, os.path.abspath('../../.'))\n", + "\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from copy import deepcopy\n", + "from lib.util import log_progress\n", + "import HARK # Prevents import error from Demos repo" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Do Precautionary Motives Explain China's High Saving Rate?\n", + "\n", + "The notebook [Nondurables-During-Great-Recession](http://econ-ark.org/notebooks/) shows that the collapse in consumer spending in the U.S. during the Great Recession could easily have been caused by a moderate and plausible increase in the degree of uncertainty.\n", + "\n", + "But that exercise might make you worry that invoking difficult-to-measure \"uncertainty\" can explain anything (e.g. \"the stock market fell today because the risk aversion of the representative agent increased\").\n", + "\n", + "The next exercise is designed to show that there are limits to the phenomena that can be explained by invoking plausible changes in uncertainty.\n", + "\n", + "The specific question is whether a high degree of uncertainty can explain China's very high saving rate (approximately 25 percent), as some papers have proposed. Specifically, we ask \"what beliefs about uncertainty would Chinese consumers need to hold in order to generate a saving rate of 25 percent, given the rapid pace of Chinese growth?\"\n", + "\n", + "### The Thought Experiment\n", + "\n", + "In more detail, our consumers will initially live in a stationary, low-growth environment (intended to approximate China before 1978). Then, unexpectedly, income growth will surge at the same time that income uncertainty increases (intended to approximate the effect of economic reforms in China since 1978.) Consumers believe the high-growth, high-uncertainty state is highly persistent, but that ultimately growth will slow to a \"normal\" pace matching that of other advanced countries.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The Baseline Model\n", + "\n", + "We want the model to have these elements:\n", + "1. \"Standard\" infinite horizon consumption/savings model, with mortality and permanent and temporary shocks to income\n", + "0. The capacity to provide a reasonable match to the distribution of wealth inequality in advanced economies\n", + "0. Ex-ante heterogeneity in consumers' discount factors (to capture wealth inequality)\n", + "\n", + "All of these are features of the model in the paper [\"The Distribution of Wealth and the Marginal Propensity to Consume\" by Carroll, Slacalek, Tokuoka, and White (2017)](http://econ.jhu.edu/people/ccarroll/papers/cstwMPC), for which all of the computational results were produced using the HARK toolkit. The results for that paper are available in the $\\texttt{cstwMPC}$ directory.\n", + "\n", + "### But With A Different ConsumerType\n", + "\n", + "One feature that was not present in that model is important here: \n", + "- A Markov state that represents the state of the Chinese economy (to be detailed later)\n", + "\n", + "HARK's $\\texttt{MarkovConsumerType}$ is the right tool for this experiment. So we need to prepare the parameters to create that ConsumerType, and then create it." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "code_folding": [ + 1 + ] + }, + "outputs": [], + "source": [ + "# Initialize the cstwMPC parameters\n", + "init_China_parameters = {\n", + " \"CRRA\":1.0, # Coefficient of relative risk aversion \n", + " \"Rfree\":1.01/(1.0 - 1.0/160.0), # Survival probability,\n", + " \"PermGroFac\":[1.000**0.25], # Permanent income growth factor (no perm growth),\n", + " \"PermGroFacAgg\":1.0,\n", + " \"BoroCnstArt\":0.0,\n", + " \"CubicBool\":False,\n", + " \"vFuncBool\":False,\n", + " \"PermShkStd\":[(0.01*4/11)**0.5], # Standard deviation of permanent shocks to income\n", + " \"PermShkCount\":5, # Number of points in permanent income shock grid\n", + " \"TranShkStd\":[(0.01*4)**0.5], # Standard deviation of transitory shocks to income,\n", + " \"TranShkCount\":5, # Number of points in transitory income shock grid\n", + " \"UnempPrb\":0.07, # Probability of unemployment while working\n", + " \"IncUnemp\":0.15, # Unemployment benefit replacement rate\n", + " \"UnempPrbRet\":None,\n", + " \"IncUnempRet\":None,\n", + " \"aXtraMin\":0.00001, # Minimum end-of-period assets in grid\n", + " \"aXtraMax\":20, # Maximum end-of-period assets in grid\n", + " \"aXtraCount\":20, # Number of points in assets grid,\n", + " \"aXtraExtra\":[None],\n", + " \"aXtraNestFac\":3, # Number of times to 'exponentially nest' when constructing assets grid\n", + " \"LivPrb\":[1.0 - 1.0/160.0], # Survival probability\n", + " \"DiscFac\":0.97, # Default intertemporal discount factor, # dummy value, will be overwritten\n", + " \"cycles\":0,\n", + " \"T_cycle\":1,\n", + " \"T_retire\":0,\n", + " 'T_sim':1200, # Number of periods to simulate (idiosyncratic shocks model, perpetual youth)\n", + " 'T_age': 400,\n", + " 'IndL': 10.0/9.0, # Labor supply per individual (constant),\n", + " 'aNrmInitMean':np.log(0.00001),\n", + " 'aNrmInitStd':0.0,\n", + " 'pLvlInitMean':0.0,\n", + " 'pLvlInitStd':0.0,\n", + " 'AgentCount':0, # will be overwritten by parameter distributor\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set Up the Growth Process\n", + "\n", + "For a Markov model, we need a Markov transition array. Here, we create that array.\n", + "Remember, for this simple example, we just have a low-growth state, and a high-growth state" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "StateCount = 2 #number of Markov states\n", + "ProbGrowthEnds = (1./160.) #probability agents assign to the high-growth state ending\n", + "MrkvArray = np.array([[1.,0.],[ProbGrowthEnds,1.-ProbGrowthEnds]]) #Markov array\n", + "init_China_parameters['MrkvArray'] = [MrkvArray] #assign the Markov array as a parameter" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One other parameter needs to change: the number of agents in simulation. We want to increase this, because later on when we vastly increase the variance of the permanent income shock, things get wonky. (We need to change this value here, before we have used the parameters to initialize the $\\texttt{MarkovConsumerType}$, because this parameter is used during initialization.)\n", + "\n", + "Other parameters that are not used during initialization can also be assigned here, by changing the appropriate value in the $\\texttt{init_China_parameters_dictionary}$; however, they can also be changed later, by altering the appropriate attribute of the initialized $\\texttt{MarkovConsumerType}$." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "init_China_parameters['AgentCount'] = 10000" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Import and initialize the Agents\n", + "\n", + "Here, we bring in an agent making a consumption/savings decision every period, subject to transitory and permanent income shocks, AND a Markov shock" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType\n", + "ChinaExample = MarkovConsumerType(**init_China_parameters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Currently, Markov states can differ in their interest factor, permanent growth factor, survival probability, and income distribution. Each of these needs to be specifically set.\n", + "\n", + "Do that here, except shock distribution, which will be done later (because we want to examine the consequences of different shock distributions)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "GrowthFastAnn = 1.06 # Six percent annual growth \n", + "GrowthSlowAnn = 1.00 # Stagnation\n", + "ChinaExample.assignParameters(PermGroFac = [np.array([GrowthSlowAnn,GrowthFastAnn ** (.25)])], #needs to be a list, with 0th element of shape of shape (StateCount,)\n", + " Rfree = np.array(StateCount*[init_China_parameters['Rfree']]), #needs to be an array, of shape (StateCount,)\n", + " LivPrb = [np.array(StateCount*[init_China_parameters['LivPrb']][0])], #needs to be a list, with 0th element of shape of shape (StateCount,)\n", + " cycles = 0)\n", + "\n", + "ChinaExample.track_vars = ['aNrmNow','cNrmNow','pLvlNow'] # Names of variables to be tracked" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, add in ex-ante heterogeneity in consumers' discount factors.\n", + "\n", + "The cstwMPC parameters do not define a single discount factor; instead, there is ex-ante heterogeneity in the discount factor. To prepare to create this ex-ante heterogeneity, first create the desired number of consumer types:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "num_consumer_types = 7 # declare the number of types we want\n", + "ChineseConsumerTypes = [] # initialize an empty list\n", + "\n", + "for nn in range(num_consumer_types):\n", + " # Now create the types, and append them to the list ChineseConsumerTypes\n", + " newType = deepcopy(ChinaExample) \n", + " ChineseConsumerTypes.append(newType)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "Now, generate the desired ex-ante heterogeneity, by giving the different consumer types each their own discount factor.\n", + "\n", + "First, decide the discount factors to assign:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from HARK.utilities import approxUniform\n", + "\n", + "bottomDiscFac = 0.9800\n", + "topDiscFac = 0.9934 \n", + "DiscFac_list = approxUniform(N=num_consumer_types,bot=bottomDiscFac,top=topDiscFac)[1]\n", + "\n", + "# Now, assign the discount factors we want to the ChineseConsumerTypes\n", + "for j in range(num_consumer_types):\n", + " ChineseConsumerTypes[j].DiscFac = DiscFac_list[j]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setting Up the Experiment\n", + "\n", + "The experiment is performed by a function we will now write.\n", + "\n", + "Recall that all parameters have been assigned appropriately, except for the income process.\n", + "\n", + "This is because we want to see how much uncertainty needs to accompany the high-growth state to generate the desired high savings rate.\n", + "\n", + "Therefore, among other things, this function will have to initialize and assign the appropriate income process." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# First create the income distribution in the low-growth state, which we will not change\n", + "from HARK.ConsumptionSaving.ConsIndShockModel import constructLognormalIncomeProcessUnemployment\n", + "import HARK.ConsumptionSaving.ConsumerParameters as IncomeParams\n", + "\n", + "LowGrowthIncomeDstn = constructLognormalIncomeProcessUnemployment(IncomeParams)[0][0]\n", + "\n", + "# Remember the standard deviation of the permanent income shock in the low-growth state for later\n", + "LowGrowth_PermShkStd = IncomeParams.PermShkStd\n", + "\n", + "\n", + "\n", + "def calcNatlSavingRate(PrmShkVar_multiplier,RNG_seed = 0):\n", + " \"\"\"\n", + " This function actually performs the experiment we want.\n", + " \n", + " Remember this experiment is: get consumers into the steady-state associated with the low-growth\n", + " regime. Then, give them an unanticipated shock that increases the income growth rate\n", + " and permanent income uncertainty at the same time. What happens to the path for \n", + " the national saving rate? Can an increase in permanent income uncertainty\n", + " explain the high Chinese saving rate since economic reforms began?\n", + " \n", + " The inputs are:\n", + " * PrmShkVar_multiplier, the number by which we want to multiply the variance\n", + " of the permanent shock in the low-growth state to get the variance of the\n", + " permanent shock in the high-growth state\n", + " * RNG_seed, an integer to seed the random number generator for simulations. This useful\n", + " because we are going to run this function for different values of PrmShkVar_multiplier,\n", + " and we may not necessarily want the simulated agents in each run to experience\n", + " the same (normalized) shocks.\n", + " \"\"\"\n", + "\n", + " # First, make a deepcopy of the ChineseConsumerTypes (each with their own discount factor), \n", + " # because we are going to alter them\n", + " ChineseConsumerTypesNew = deepcopy(ChineseConsumerTypes)\n", + "\n", + " # Set the uncertainty in the high-growth state to the desired amount, keeping in mind\n", + " # that PermShkStd is a list of length 1\n", + " PrmShkStd_multiplier = PrmShkVar_multiplier ** .5\n", + " IncomeParams.PermShkStd = [LowGrowth_PermShkStd[0] * PrmShkStd_multiplier] \n", + "\n", + " # Construct the appropriate income distributions\n", + " HighGrowthIncomeDstn = constructLognormalIncomeProcessUnemployment(IncomeParams)[0][0]\n", + "\n", + " # To calculate the national saving rate, we need national income and national consumption\n", + " # To get those, we are going to start national income and consumption at 0, and then\n", + " # loop through each agent type and see how much they contribute to income and consumption.\n", + " NatlIncome = 0.\n", + " NatlCons = 0.\n", + "\n", + " for ChineseConsumerTypeNew in ChineseConsumerTypesNew:\n", + " ### For each consumer type (i.e. each discount factor), calculate total income \n", + " ### and consumption\n", + "\n", + " # First give each ConsumerType their own random number seed\n", + " RNG_seed += 19\n", + " ChineseConsumerTypeNew.seed = RNG_seed\n", + " \n", + " # Set the income distribution in each Markov state appropriately \n", + " ChineseConsumerTypeNew.IncomeDstn = [[LowGrowthIncomeDstn,HighGrowthIncomeDstn]]\n", + "\n", + " # Solve the problem for this ChineseConsumerTypeNew\n", + " ChineseConsumerTypeNew.solve()\n", + "\n", + " \"\"\"\n", + " Now we are ready to simulate.\n", + " \n", + " This case will be a bit different than most, because agents' *perceptions* of the probability\n", + " of changes in the Chinese economy will differ from the actual probability of changes. \n", + " Specifically, agents think there is a 0% chance of moving out of the low-growth state, and \n", + " that there is a (1./160) chance of moving out of the high-growth state. In reality, we \n", + " want the Chinese economy to reach the low growth steady state, and then move into the \n", + " high growth state with probability 1. Then we want it to persist in the high growth \n", + " state for 40 years. \n", + " \"\"\"\n", + " \n", + " ## Now, simulate 500 quarters to get to steady state, then 40 years of high growth\n", + " ChineseConsumerTypeNew.T_sim = 660 \n", + " \n", + " # Ordinarily, the simulate method for a MarkovConsumerType randomly draws Markov states\n", + " # according to the transition probabilities in MrkvArray *independently* for each simulated\n", + " # agent. In this case, however, we want the discrete state to be *perfectly coordinated*\n", + " # across agents-- it represents a macroeconomic state, not a microeconomic one! In fact,\n", + " # we don't want a random history at all, but rather a specific, predetermined history: 125\n", + " # years of low growth, followed by 40 years of high growth.\n", + " \n", + " # To do this, we're going to \"hack\" our consumer type a bit. First, we set the attribute\n", + " # MrkvPrbsInit so that all of the initial Markov states are in the low growth state. Then\n", + " # we initialize the simulation and run it for 500 quarters. However, as we do not\n", + " # want the Markov state to change during this time, we change its MrkvArray to always be in\n", + " # the low growth state with probability 1.\n", + " \n", + " ChineseConsumerTypeNew.MrkvPrbsInit = np.array([1.0,0.0]) # All consumers born in low growth state\n", + " ChineseConsumerTypeNew.MrkvArray[0] = np.array([[1.0,0.0],[1.0,0.0]]) # Stay in low growth state\n", + " ChineseConsumerTypeNew.initializeSim() # Clear the history and make all newborn agents\n", + " ChineseConsumerTypeNew.simulate(500) # Simulate 500 quarders of data\n", + " \n", + " # Now we want the high growth state to occur for the next 160 periods. We change the initial\n", + " # Markov probabilities so that any agents born during this time (to replace an agent who\n", + " # died) is born in the high growth state. Moreover, we change the MrkvArray to *always* be\n", + " # in the high growth state with probability 1. Then we simulate 160 more quarters.\n", + " \n", + " ChineseConsumerTypeNew.MrkvPrbsInit = np.array([0.0,1.0]) # All consumers born in low growth state\n", + " ChineseConsumerTypeNew.MrkvArray[0] = np.array([[0.0,1.0],[0.0,1.0]]) # Stay in low growth state\n", + " ChineseConsumerTypeNew.simulate(160) # Simulate 160 quarders of data\n", + " \n", + " # Now, get the aggregate income and consumption of this ConsumerType over time\n", + " IncomeOfThisConsumerType = np.sum((ChineseConsumerTypeNew.aNrmNow_hist*ChineseConsumerTypeNew.pLvlNow_hist*\n", + " (ChineseConsumerTypeNew.Rfree[0] - 1.)) +\n", + " ChineseConsumerTypeNew.pLvlNow_hist, axis=1)\n", + " \n", + " ConsOfThisConsumerType = np.sum(ChineseConsumerTypeNew.cNrmNow_hist*ChineseConsumerTypeNew.pLvlNow_hist,axis=1)\n", + " \n", + " # Add the income and consumption of this ConsumerType to national income and consumption\n", + " NatlIncome += IncomeOfThisConsumerType\n", + " NatlCons += ConsOfThisConsumerType\n", + "\n", + " \n", + " # After looping through all the ConsumerTypes, calculate and return the path of the national \n", + " # saving rate\n", + " NatlSavingRate = (NatlIncome - NatlCons)/NatlIncome\n", + "\n", + " return NatlSavingRate" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can use the function we just defined to calculate the path of the national saving rate following the economic reforms, for a given value of the increase to the variance of permanent income accompanying the reforms. We are going to graph this path for various values for this increase.\n", + "\n", + "Remember, we want to see if a plausible value for this increase in uncertainty can explain the high Chinese saving rate." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "809618fcd60648609f9af11432329edf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HTML(value=''), IntProgress(value=0, max=5)))" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Declare the number of periods before the reforms to plot in the graph\n", + "quarters_before_reform_to_plot = 5\n", + "\n", + "# Declare the quarters we want to plot results for\n", + "quarters_to_plot = np.arange(-quarters_before_reform_to_plot ,160,1)\n", + "\n", + "# Create a list to hold the paths of the national saving rate\n", + "NatlSavingsRates = []\n", + "\n", + "# Create a list of floats to multiply the variance of the permanent shock to income by\n", + "PermShkVarMultipliers = (1.,2.,4.,8.,11.)\n", + "\n", + "# Loop through the desired multipliers, then get the path of the national saving rate\n", + "# following economic reforms, assuming that the variance of the permanent income shock\n", + "# was multiplied by the given multiplier\n", + "index = 0\n", + "for PermShkVarMultiplier in log_progress(PermShkVarMultipliers, every=1):\n", + " NatlSavingsRates.append(calcNatlSavingRate(PermShkVarMultiplier,RNG_seed = index)[-160 - quarters_before_reform_to_plot :])\n", + " index +=1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We've calculated the path of the national saving rate as we wanted. All that's left is to graph the results!" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAE7CAYAAADD6MbAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdeXxU1f0//te5s+/JZJkkk0wWsk4SwhKQtVhFC6VQQFHcl6q1ShXpRz/Vtu7268el/VlFq0VF1CoVqAuuKAqKioQ9CQmE7Hsmy0xmX+75/TGZIXsCZBnCeT4ePh7M3DP3HkbuvO/Z3odQSsEwDMMwA+HGuwIMwzBMaGOBgmEYhhkUCxQMwzDMoFigYBiGYQbFAgXDMAwzKBYoGIZhmEEJx7sCI23//v3RQqFwA4AcsEDIMAwzFB5AodfrvWX69OnN/RWYcIFCKBRuiImJyYqKimrnOI4tEmEYhhkEz/OkpaXF2NjYuAHAsv7KTMQn7pyoqCgLCxIMwzBD4ziORkVFmeHvhem/zBjWZ6xwLEgwDMMMX9dv5oDxYCIGinG3atWqJK1Wm5eWlpY9UBme53HjjTcmGAyGnPT0dON3330nH8s6drdgwYJUk8kkGK/rM8xIeOSRR6JTU1Oz09LSspcuXZpst9tJ7zIOh4MsWbIkxWAw5EyePDmztLRUPB51BYCpU6dmjte1TxcLFKPg5ptvNn344YcnBivz3nvvacrLy6WVlZWFL730UtUdd9xhGKv6BfA8D5/Ph127dpVFRkb6xvr6DDNSKioqRK+88oru0KFDxSdOnCjy+Xxkw4YN2t7lnnvuuUiNRuOtrq4uXLNmTdO6devix7quXq8XAHDw4MGSsb72mWKBYhQsXrzYGhUV5R2szAcffBB2zTXXtHIch4svvthmsViEVVVVou5ldu3aJU9PTzfa7XZisVi41NTU7H379km7l/nd736nf/LJJ6MCr9etWxf30EMP6cxmMzd79ux0o9GYlZ6ebnzrrbfCAKC0tFSckpKSfe211xqys7ONJ0+eFOv1+tyGhgYhACxcuHBSdnZ2VmpqavYzzzwTGTivXC6f+vvf/16fkZFhzMvLy6ypqRECQE1NjfCSSy6ZlJGRYczIyDDu2LFDAQAvvviiNjc3NyszM9N49dVXJwZuDoYZLT6fj9hsNs7j8cDhcHDx8fGe3mW2b98edvPNN7cCwE033dT+/fffq3ie71Fm06ZNYXPmzEnneR5VVVWipKSknOrq6h4Tf5YsWZKyefNmTeD1ZZddlrRx48aw0tJS8fTp0zOMRmOW0WjMCtwP27dvV11wwQXpS5cuTc7IyMgG/PcUAAx1r65evToxNTU1e+7cuWlWq5UAQGFhoWTOnDnpGRkZRqPRmFVUVCQBgL/85S+6nJycrPT0dOM999wTN1LfLQsU46ShoUGUlJTkDryOjY119w4UCxYssC9atKhj7dq1+jvvvDN+1apVrTNmzHB2L3Pttde2bd26Nfjk9MEHH4Rfe+217XK5nP/444/LiouLj+3atev4Aw88EB+4ISorK6U33XRT67Fjx4rT09Pd3c/39ttvVxYVFR07dOhQ8csvv6xrbGwUAIDD4eBmz55tLS0tLZ49e7b1+eefjwKA22+/3TB//vzO0tLS4qKiouJp06Y5Dxw4IN2yZYu2oKCgpKSkpJjjOPrPf/4zYsS/RIbpkpyc7Lnzzjsbk5OTJ0dHR+epVCrfypUrLb3LNTU1iZOTk90AIBKJoFQqfU1NTT2CwPXXX98RFRXlefLJJ6NuvPHGxPvvv7/eYDD0eNK58sor2zZv3hwOAE6nk+zZs0d9+eWXm+Pi4rzffvvt8eLi4mObN28uv+eee4I9BUeOHFE8/fTTdSdPnizqfq7B7tXq6mrpXXfd1VxWVlak0Wh8mzZtCgeAq6++Ovn2229vLi0tLS4oKCgxGAyebdu2qcvKyqRHjhw5duzYseJDhw7JP/30U+VIfL8Tbnpsd/duOZxwvLFzRPv+02NU9qcvz6s52/P0l96dkD5dqnjqqaca8vLysiQSCf/6669X9z4+d+5cR2trq7CyslLU0NAg1Gg0vrS0NLfL5SJr166N//HHH5Ucx6G5uVlcW1srBPxB6eKLL7b1V6//+7//03388cdhANDY2CgqKiqSxsTE2EQiEV29erUZAKZPn2778ssv1QDw/fffq7Zs2VIBAEKhEBEREb6XX35ZW1hYKM/Ly8sCAKfTyUVHR7MmxXmi/oE/JbhOnBjR+06SlmaP++sTA953LS0tgo8//jisrKzsaEREhG/JkiUpL774ovaOO+5o615ugPuuz5sbNmyozs7Ozp46dartt7/9bVvv45dffrn5vvvuMzgcDrJ161bNzJkzO5VKJW1tbeV+85vfJBYXF8s4jkNVVZUk8JnJkyfbMjMz3b3PxfP8gPeqXq93zZkzxwEAU6dOtVdWVkra29u5pqYm8fXXX98BAHK5nAKgn332mXr37t1qo9FoBAC73c6VlJRIFy9ebB34mx2eCR0oQllcXJynsrIyOJDW0NAgNhgMfZrKzc3NArvdznm9XmK32zm1Ws33LrN06dL2t956K7yxsVF02WWXtQHAyy+/rG1tbRUePXr0mEQioXq9PtfhcHCA/wmmvzpt375dtWvXLlVBQUGJSqXiZ86cmRH4jFAopBznb4AKhUJ4vd6+Ua0LpZSsWrWqdf369XWn+bUwzBn56KOP1AaDwRUXF+cFgOXLl3d8//33yt6BIiYmxl1RUSGeNGmSx+PxwGq1CqKjo/uMz1VWVoo4joPJZBL6fD4IBD3nesjlcjpr1qzObdu2qTdv3hx+1VVXtQHAE088oYuOjvZs3bq1gud5yGSy6d0+0+99N9i9KhaLg0FMIBBQh8PBDbSHEKUUa9eubbj33ntNw/3ehmtCB4qRePIfLcuWLet48cUXo2+99da2r7/+WqFSqXyJiYl9AsWNN96Y9Kc//am+oqJCvGbNmvhNmzb1aVVcd911bbfeemtSe3u7cNeuXaUAYDabBZGRkR6JREI/+ugjVX19/ZCzOzo6OgQajcanUqn4gwcPSg8fPqwY6jNz587tfPrpp6MefPDBZq/XC4vFwi1atMiycuXK1AceeKBJr9d7m5qaBGazWdC7m4uZmAZ78h8tSUlJ7gMHDig7Ozs5hULB79y5UzV9+nR773JLlizpeO211yIWLlxoe/3118Nnz57dGXgACvB4PLjpppuSN27cWL5x48aIRx55RPfoo4829T7X6tWr21599dXIo0ePKt57771KwH/fxcfHuwUCAV544YUIn2/oOSKne69qtVo+JibG/eabb4Zdd911HQ6Hg3i9XrJ48WLLww8/HHfbbbe1aTQavqKiQiQWi6lerz/r1jwboxgFS5cuTZ43b15mRUWFRKfTTf773/8eCQBPPfVU1FNPPRUFAFdccYU5MTHRlZiYmPO73/0ucf369VW9z/PCCy9ECIVCevvtt7c98cQTjYcOHZJ/+OGHqt7l8vPznTabjdPpdO5AsLnlllvaDh8+rMjJycl66623tMnJyc7en+vtsssuM3u9XpKenm584IEH4vLy8vrtnurupZdeqt61a5cqPT3dmJOTYzxw4IBs+vTpzj//+c91F198cXp6errxoosuSq+pqRENdS6GOVMXXXSRbenSpe2TJ0/OysjIyOZ5nqxbt64FANauXRv39ttvawDg7rvvNrW3twsNBkPO888/H/PMM8/U9j7X/fffHztr1qzORYsWWV966aWaN998M/LAgQPS3uVWrFhh2bdvn2revHkWqVRKu67V/M4770Tk5eVlHj9+XCqTyfptRXR3JvfqW2+9VbF+/fro9PR0Y35+fmZNTY1w5cqVllWrVrXNmDEjMz093bhixYpJHR0dIzLtnUy0rVAPHz5cmZeXN+JNL4ZhmIns8OHDkXl5eUn9HWMtCoZhGGZQLFAwDMMwg2KBgmEYhhkUCxQMwzDMoFigYBiGYQbFAgXDMAwzKBYoRlhZWZnoggsuSE9JSclOTU3Nfuyxx6L7K8fSjDPMyBoovf9rr70Wnpqams1x3PTdu3cPeJ9t2bJFnZSUlGMwGHIeeOCBmNGvcf+eeuqpqBdeeCGkcqOxQDHCRCIRnn322dry8vKiffv2HXv11Vej9+/f32exDkszzjAja6D0/lOmTHFs3bq1LD8/f8CcR16vF/fcc4/hk08+OX78+PGirVu3avu7b0ebx+PBfffd17JmzZrWsb72YFigGGGJiYmeefPm2QEgPDycnzRpkqO6urrPknyWZpxhRtZA6f2nTZvmzMvLcw322W+++UaRmJjoMhqNbqlUSleuXNm2ZcuWsO5lPB4PcnJysrZv364CgDvvvFP/+9//Xt+9zIEDB6S5ublZgdelpaXi9PR0IwD8z//8T2xOTk5WWlpa9lVXXZUYyBA7c+bMjDVr1uhnzJiR8fjjj+vWrVsX9+CDD+oA4Nlnn43MycnJysjIMP7iF7+Y1NnZyQH+tOY33nhjwtSpUzPj4+NzX3/99fDANf/85z/r0tPTjRkZGcY77rhDDwBFRUWS+fPnp2VnZ2dNnz494+DBg6cVBFmgGEWlpaXi4uJi+YIFC/o8ybA04wwTOmpqasR6vT54L8THx7vr6up6POCJRCJs3Lix4q677jL897//Ve/cuVPz9NNP13cvM23aNKfH4yHFxcViANi0aZN2+fLl7QBw7733NhcWFh47ceJEkcPh4N59993gfhYdHR2Cffv2lT7yyCM9ckpdc8017YWFhcdKS0uLMzIyHP/4xz+CD29NTU2igoKCkg8++ODEQw89pAeA//znP+qPP/44fP/+/SWlpaXFDz30UCMA3HLLLYkvvvhidVFR0bGnn3669ne/+91p9WBM6KSAeP/OBDQXj2zff7TRjuXrh0x6ZjabuZUrV0568skna7RabZ98LyzNODNRfbXpWEJbnXVE7zutXmm/+PqsUUs2ONz04/n5+c4rrriidfXq1ak7d+48Fsjx1N3y5cvb3nrrLe1f//rXxv/+97/hmzdvLgeATz/9VPW3v/0txul0ch0dHUKj0egAYAaAQPbZ3vbv3y978MEH9Z2dnQKbzSZYsGCBOXBs2bJlHQKBANOnT3e2traKAGDHjh3qa6+91qRSqXgA0Ol0PrPZzB08eFC5atWqSYHPut3uAbM/92diB4px4nK5yJIlSyatWrWq7YYbbujorwxLM84wocNgMPRoQdTW1orj4uL63I8AUFRUJFOpVL6GhgYRAEfv49ddd137qlWrUlavXt1OCEFubq7LbreTP/zhD4l79+4tTk1N9axbty7O6XQGe3QCP+y93Xbbbclbtmwpmz17tuMf//hHxK5du4JJQbsHqUCgo5T2eeD0+XxQqVTekpKS4mF/Ib1M7EAxjCf/kcbzPFavXp2Ynp7ufPjhh/ukJg5gacaZiWo0n/xHy4IFC2yVlZXSkpIScVJSkmfbtm3at99+u7x3uTfeeCOsra1NuHPnzpJly5alXXjhhcd6TwTJzs52cRyHBx98MG7FihVtgH8TIQCIiYnxms1m7qOPPgpfunRp+1D1stvtnMFg8LhcLvLuu+9qY2Nj+w1eAYsWLbI88cQTcbfeemubSqXim5qaBDqdzhcfH+9+7bXXwm+++eZ2nuexd+9e2ezZs/sEuYGwMYoRtmPHDuX7778f8d1336kyMzONmZmZxsDeuizNOMOMnoHS+2/atClMp9NNPnTokGLFihVp8+bNSwP8mxMtWLAgFQjOVqxetGhRelpaWvby5cvb8vPze9wzDQ0Nwoceeij+jTfeqJw8ebLrlltuab7tttsS+qvLypUr2z744APtdddd1w4AkZGRvmuuuabFaDRmL168OHU49xYA/PGPf6yfOXNm1vz589PT0tKGvIcvv/xyy+LFizumTJmSlZmZaXzsscdiAOCdd94pf/311yMzMjKMaWlp2Vu3bg0b6lzdsTTjDMMwDEszzjAMw5w5FigYhmGYQbFAwTAMwwyKBQqGYRhmUCxQMAzDMINigYJhGIYZFAsUo8Tr9SIrK8v485//PLW/4w6HgyxZsiTFYDDkTJ48ObO0tHTIBXGjZerUqZnjdW2GYUIfCxSj5PHHH9elpqYOuPLxueeei9RoNN7q6urCNWvWNK1bty5+LOsH+IMZABw8eLBkrK/NMMy5gwWKUXDy5EnR559/rrn11lsHXPi3ffv2sJtvvrkVAG666ab277//XhXI7hqwadOmsDlz5qTzPI+qqipRUlJSTnV1dY+0K0uWLEkJrPwG/OmHN27cGFZaWiqePn16htFozDIajVmB9N/bt29XXXDBBelLly5NzsjIyAb8KcQBfyLDwVKTr169OjE1NTV77ty5aVarlQBAYWGhZM6cOekZGRlGo9GYVVRUJAGAv/zlL7qcnJys9PR04z333BM3Al8rwzDjhAWKUXDnnXcmPPXUU7WBJHr9aWpqEicnJ7sBf/oApVLpa2pq6hEErr/++o6oqCjPk08+GXXjjTcm3n///fUGg6FHFtYrr7yybfPmzeEA4HQ6yZ49e9SXX365OS4uzvvtt98eLy4uPrZ58+bye+65J5hW+MiRI4qnn3667uTJk0XdzzVYavLq6mrpXXfd1VxWVlak0Wh8mzZtCgeAq6++Ovn2229vLi0tLS4oKCgxGAyebdu2qcvKyqRHjhw5duzYseJDhw7JP/30U+XZfasMw4yXCZ0U8C97/pJQ1l42oumOU8NT7Y/NfWzApGfvvPOOJjIy0jt//nx7YIOT/gw3rfGGDRuqs7Ozs6dOnWr77W9/2ycV8eWXX26+7777DA6Hg2zdulUzc+bMTqVSSVtbW7nf/OY3icXFxTKO41BVVSUJfGby5Mm2zMzMPgn6eJ4fMDW5Xq93zZkzxwEAU6dOtVdWVkra29u5pqYm8fXXX98BAHK5nAKgn332mXr37t1qo9FoBPyJzUpKSqSLFy8ecIcxhmFC14QOFOPhu+++U+7YsSNMr9drXC4XZ7PZuF//+tfJH3zwQUX3cjExMe6KigrxpEmTPB6PB1arVRAdHd1nO9LKykoRx3EwmUxCn88HgaDn1tZyuZzOmjWrc9u2berNmzeHB/LaP/HEE7ro6GjP1q1bK3ieh0wmm97tM/2mNB4sNblYLA4GMYFAQB0OBzdQnjBKKdauXdtw7733spxbDDMBTOhAMdiT/2hZv359XWAfhu3bt6ueffZZXe8gAQBLlizpeO211yIWLlxoe/3118Nnz57d2buryuPx4KabbkreuHFj+caNGyMeeeQR3aOPPtondfnq1avbXn311cijR48q3nvvvUrAn2Y8Pj7eLRAI8MILL0T4fENviX26qcm1Wi0fExPjfvPNN8Ouu+66DofDQbxeL1m8eLHl4YcfjrvtttvaNBoNX1FRIRKLxVSv17PNixjmHMTGKMbQ2rVr495++20NANx9992m9vZ2ocFgyHn++edjnnnmmdre5e+///7YWbNmdS5atMj60ksv1bz55puRBw4c6LPX7YoVKyz79u1TzZs3zxLYzGTt2rXN77zzTkReXl7m8ePHpTKZrN9WRHdnkpr8rbfeqli/fn10enq6MT8/P7Ompka4cuVKy6pVq9pmzJiRmZ6eblyxYsWkjo4OwVDnYhgmNLE04wzDMAxLM84wDMOcORYoGIZhmEGxQMEwDMMMaiIGCp7neTLelWAYhjlXdP1mDjjhZSIGisKWlhYNCxYMwzBD43metLS0aAAUDlRmwq2j8Hq9tzQ2Nm5obGzMwcQMhAzDMCOJB1Do9XpvGajAhJseyzAMw4yscX3iJoQsIoSUEkLKCCF/7Of4jYSQFkLIoa7/Box4DMMwzOgYt64nQogAwHoAlwCoBbCPEPIhpbS4V9HNlNI1Y15BhmEYBsD4jlHMBFBGKS0HAELIuwB+DaB3oDgtkZGRNCkp6exrxzAMcx7Zv3+/iVIa1d+x8QwUegDdk/bVArign3KXEUJ+BuA4gHsopX0S/RFCbgNwGwAYDAYUFBSMQnUZhmEmLkJI1UDHxnOMor/pq71H1j8CkEQpnQzgSwBv9HciSukrlNJ8Sml+VFS/AZFhGIY5Q+MZKGoBJHR7HQ+gvnsBSmkrpdTV9fJfAKaDYRiGGVPjGSj2AUgjhCQTQsQAVgP4sHsBQkhst5fLABwbw/oxDMMwGMcxCkqplxCyBsDnAAQAXqOUFhFCHgVQQCn9EMBdhJBlALwA2gDcOF71ZRiGOV9NuAV3+fn5lA1mMwzDnB5CyH5KaX5/x1iKC4ZhGGZQLFAwDMMwg2KBgmEYphefl0fRt3XgfUNuNX9eYIGCYRiml/KDLfjm7VJUFbWNd1VCAgsUDMMwvdSf6AAAtFR3jnNNQgMLFAzDML3Ul/kDhamGBQqABQqGYZgenFYP2uptAAFaWKAAwAIFwzBMD4HWRFJuJKxtLjitnnGu0fhjgYJhGKabhrIOCIQcsufFAQBaalmrggUKhmGYbupPdECXrIYuRQ0AMFVbx7lG448FCoZhmC4elw8tNVbEpmogU4qhDJewcQqwQMEwDBNkMTlAeYoIvRIAEJmgYjOfwAIFwzBMkK3Dv/2NMkwCAIhMUKK9yQ6Pyzee1Rp3LFAwDMN0sZn9gULRFSii4lUAhX+67HmMBQqGYZgutg43AECuEQMAIuIVAIDWuvN7QJsFCoZhmC42swsShRBCkQAAoI6QQSgRwMQCBcMwDAP4xygUGknwNeEIIuIUaK1lgYJhGIYBYDO7g+MTARHxSrTWWTHRdgM9HSxQMAzDdLGbXVB0jU8EROqVcNm9wRlR5yMWKBiGOS90NNmx4/UitDf2P4OJ8tTfotD0alF0ralorTt/Zz6xQMEwzHnh+E+NOL63Cf/56z4c/6mxz3GH1QPK075dT3o284kFCoZhzgut9TYowyWI0Cux880S8HzPMYdA11LvQCGRi6DUSmA6jwe0xzVQEEIWEUJKCSFlhJA/DlLuckIIJYTkj2X9GIaZOFrrrIhOUiNzdix8Hh52s7vH8WCg6NX1BPjHKViLYhwQQgQA1gNYDMAI4CpCiLGfcioAdwHYO7Y1ZBhmovC4fTC3OBChV0KllQIAOtucPcqcWpUt7vP5sBgFzM2O0a9oiBrPFsVMAGWU0nJKqRvAuwB+3U+5xwA8BcDZzzGGYZghtdXbAOofbzgVKHr+8Ns6XAABZOq+gUKqEMLn5eF1n585n8YzUOgB1HR7Xdv1XhAhZCqABErp9rGsGMMwE0ug2ygiTgml1t+11Nnau0XhhkwlhkDQ92dRIhcBAFx27yjXNDSNZ6Ag/bwXHF0ihHAA/g7gD0OeiJDbCCEFhJCClpaWEawiwzABdcfbUfpjw3hX44y01dkgFHNQR8kglgohUQjR2dZzXYStnzUUARK5EADgtJ+f26KOZ6CoBZDQ7XU8gPpur1UAcgB8QwipBDALwIf9DWhTSl+hlOZTSvOjoqJGscoMc/468FkVvnnnOHxefryrctpMdVZoYxXgOP/zqUorhbX3GEWHq8+MpwCpoqtFYWMtirG2D0AaISSZECIGsBrAh4GDlFIzpTSSUppEKU0C8COAZZTSgvGpLsOcW8wtDvh8I/ej3t5oh9flQ1OlZcTOOVba6q3BhXOAP1D0Hczuu9guINCicLEWxdiilHoBrAHwOYBjAP5DKS0ihDxKCFk2XvVimImgqrAVbz34A45+XTsi5/O4fcEf1rrS9hE551ixmV1wdHp6BooIKTpbncH8TR6XDw6LG8rwgQJFzzGKfR9XoHhPfb9lJyLheF6cUvoJgE96vffgAGUvHIs6Mcy5gPIUh3fWwFRjxUU3ZAW7VACgo9mOHa8VAdQfMKYsNJz19Tqa7ME/15a0Y8aS5LM+52ijlGLvh+Uo/s7/g65LUQePqbRSeFw+uOxeSBUitDX403NExCn7PVdwjMLmb1EUfVsPylNkzooB18/g90Qz8f+GDDPBuBxevP/3g9izpQylextRf7znE/6OV4tACMGkadGoL+uAZwSmdAbyIxmytWisMA95zs42J04UNI1rxlWLyYH9n1ZBG6vA0rvyEJOsCR5TRXRNke2a+dRW758VpY1T9HsuiUwIEH+LglIKR6cbdosbtedY6+pMsUDBMOeYkweaUX+iA/OuSINIKkDpT03BYy6HF81VnchbmADjvFjwXor6Ex1nfc32RjsIAbLn68F7KRpPmgctf/DzKnyxoQj7Pq4862ufqcBuddMWJcJgjOhxrPeiu9Z6GwQi/6yo/hCOQCITwmX3wmX3gvf5A2Dp3r45oyYiFigY5hxjaXGAcAS5C/SYNC0aJw80BxeCBdYLRMYrEZcaBoGQQ01R21lfs6PRDnWkDPGZ4eA4gppjg5+zqdICjiPYt70Ch3fWDFp2tARXWvczQN07ULTV23rMiuqPRC6Ey+6B3eIPQFKlCOUHW+B2TvyZUCxQMMw5xmJyQKWVgBNwyJipg8fpQ8UREwAEd2KLjFdBKBYgLk2D6iF+1IejvdGO8Bg5xFIhEoxaHP6qBiUDrKnweXiYaq2YfFE89OlhOPzl+ASKQC4neT9rI6RKEYQi7lSg6Jo+OxiJXASnzQtHp/+8uQv08Lp5VBya+Gu3WKBgmHOMpdUJdaS/iyQuPRyKMAmOd3WBmOqskCiEwXxFCVkRaG+wwdp+5hlweJ6io8mOsBj/D+klNxsRmxqGrzYe67frxVRrBe+jiEnRQJesga3DBcqP/ViF3eICJyDBNRDdEUKgipDC2uqE0+aBzewecHwiQKro2aKYNC0aUqUIdSPQtRfqWKBgmHOMxeSAumswluMI0vKjUV3cBrfDi9ZaKyL1ShDi70IxZGsBYMiuosF0tjrh8/IIj5ED8D9ZL/19HpThElQVtvYpH1hnEZ2khjJcAp6ncFjHfv2B3eyGXC0Ofhe9qSKkaK23DTmQHSCRi+Cyn2pRyNViRMYrz4v9tFmgYJhziNvphaPT02PQNXlKFHgfRVVhK1rrbT3WC2jjFJCrxagpPvNAEZjxFK6TB98TCDmE6eSwmPpmVG2utECuFkMZLgmudD6bFs2ZslXd6foAACAASURBVFn8gWIgaTN06GiyY++HFQDQ43vrT/cxCsL5WyoR8Uq01tvAj+DCxlDEAgXDnEMC0zkDXU8AEJOigUwlwqGvauB1+RARf+oHjxCCBKMWNcfaz7j7J7CGIjym5xO3OkrWf6CosiA6SQ1CSDBQjMd+03azC/IBVloDQMbMGEQZVKg/0QGRVDDgYrsAiVwEl80Lh8UNmVIEwhFExivh8/DomOApyFmgYJhzSOCHWR1xKlBwHEFSbiSau7p8IuN7PhknZGnhtHnQUtN5RtfsaHZAohBCquzZ16+OkMLR6ekx68fl8KK90Q5dkgoAoBzHQOFPyTFwi4JwBHMvTwUAaGMVA3ZRBUgUQvA8hdnkDKYiD3zXptoz+27PFSxQMMw5xGLqalFESXu8nzzFnwyTECC81+ydhKyzG6cwN9uhiey7viDQqgnUCfC3JgD/+ATg39uBcATWboHCafXgnUf3oqbk7GdjDcTn5eG0egZtUQCAPj0c+b9MQs7P9IOWAwBpVxqP9kYb5Cr/n8NjFOAEZMKPU7BAwTDnEIvJAZFE0GcmT0JmOIRiDppoOURiQY9jcrUYkQlKVJ/hegqLyQFNtLzP+5ooWfB4QFudfzwjMt7fouA4AoVGDFv7qUBRuLsObfU21JaM3qrmwMykwVoUARcsS0Hm7NghywXSeNjN7mCLQiDkEB6jgKnWCkrphN0udVxzPTEMM7iDX1Sj4kgLOludmHt5mn/GU6SsTzeJUCzA9EWJEEn6v6UTsrQ4/GUN3E4vxNLh3/Y+L4/OVifSZ8b0OXaqRXEqUAQCmUx1KpApwiTBFoXPw+PoN/5EheZmO0bLqTUUg7coTkcgUACAXHUqAEXGK1FT0oZDX9bg+61luOy+6YhJ0fR3inMWa1EwTIjifTx+/PAk7GY3CCH4flsZ2pvsUEdK+y2f/8tk5F2c0O+x+Ixw8DxFU8XppQj3Z1jtOXgeIJELIZYJe3Q99RfIFGGS4BjF8X1NsFvckKlE6GgavQHgU6uyh25RDJekWyuu+3apEfFK2M1u/PjBSQBAc9XEG69ggYJhQpS5xQHeS5G/JAkLrslAZ6sT5mZHvz/aQ9GlaAACNAyRo6lPHbpaC5rovtckhEAdKe3RojC3OIJdUgHKbi2KwztrEKFXIH1GDMzN9lFbiBfoepKrR6lFoe7ZogD8iQPFMiFa6yde9xMLFAwTotrq/f392lgFDEYtYlP93RkDtSgGI5EJERGnRGP56QUKS0tXoBggWZ4m8tQUWcrTrlXjPeunCJPA4/TBVNuJ1lorsubGIUwng9fDB5/8R5rN7AIIIFf3XZV9pgKD2QAg69b1pEtSIzJBiYuuz0JkvBJtE3CcggUKhglRbQ02oGsWEyEEs5dPAscRRCWozuh8MZM0aCo3gz+Np3hzswNCMTfgwjV1pAwWkxOUp7Bb3PB5+D4tnsBaimPf+3NDJWZHQNO1eK/7Phcjyd611mEk94oQSQUgXUkDu49RiGVCXPmnmUjKjUSEXonWOtu4pCwZTSxQMEyIaqu3QR0hDc5iik0Nw2/+Nh+xqWFndL7YFDXcTh/auzbpGQ6zyd+VNNAaA3WkFD4vD5vZDfMArY/AQrbSvY1QRUihiZYhrGsW1UgvVPtyYzG+3Xy8K33HyHU7Af6utkD300CBM0KvgMfl67PN6rmOzXpimBDV1mCDtteOa6czY6m3mEn+ANNw0jxkuooAc4sDYf2MTwR0n/kUXAw4QIvCZfMidVo0CCFQhkkgEHHoGMGZT611VpT+6E9SKBBy0KefWUAdjEQuhNPqgVTVf5dW4HttrbOe0VhSqGItCoYJQT4fj44mO7SxfdcvnCl1pBQytXjITYcCKE/9aygGGJ/wn9N/rKPZDrPJAUJO7R4XEFidDSC4gRDhCMKiZTCPYNdT4a46CIQcYlM18Hn5ftOLny2JXASpQgTBAF1agcSCrXXDb7WdC1igYJgQZG5ygPfRIfdIOB2EEMSmaNAwzAFtm9kFn4fvd7FdgDpKBrlajMojJlhaHFCGSyEQ9vxZEYoFkMiFIByBPjM8+H5YtHzEup7cTi9K9zYiLT8av7g1B0qtBFEG9dAfPE0ypWjQACSWCruy0k6sAW3W9cQwIaitaxyhd9fT2YpOUqH8UAvcDi/EssFv/8BAc3/pOwI4jiD9ghgc+aoG6ihZn9QiAepIGUQSgX/v6S6aaDkqDpvA+/izHnQ+vrcRHpcPOQviodBIcP3jc4IDzyPpgmUp8LgG39EuMKA9kbBAwTAh5PDOGlQcaoEiXAIQICxm5LqeACBc52+hdDTbEZ3Y/xM3z9PgFqZCEQetfvBWTeasGBzaUY2OJntwCm9vl/4mGwJRz2AQppOB75pSGzZIq2U4Ko60IjxGjuiuZISjESQAIMow9IyzCL0CVYWt8Hn4Pn/ncxULFAwTIiilOPJ1bXDtgjpK1idv09nS6E6NKQwUKCqPmFDwSSVSpkZh5q+S+91zursIvRKRCUqYaqwDjmeE6foGgkDywuYqy1kHCv/fRzVkBtixoImSgfIUNrNrwgxoj2u4I4QsIoSUEkLKCCF/7Of47YSQo4SQQ4SQ7wghxvGoZ3c/vH8S7//tAA5+UY32RhsonVjzpZnx09Fkh6XFgfxfJiFlahQyLuibX+lsaaJkAPGvjxhIxRETxDIhLr0le9izozJn+ZPqnc4PY3SiGnKNGCf399xzurqoFcV76od9Hp+XR6fJcdbBZqRIlf4xDKdt7Hf1Gy3j1qIghAgArAdwCYBaAPsIIR9SSou7Ffs3pfSfXeWXAfgbgEVjXtluKo+Y0NFsR93xDny/rQzqKBmiEpTQRMsRbVBBl6wZcgMUhulP5RH/tqLGeXFQaU9/9fVwCEUCqMKlAy50ozxF1VETErO1A87s6U/mnFiYTY5gSvPh4DiC1OnRKNpd32PM5KftFTDVWpE6PXpY04EtJgco7b/VMh5kXft2jMf2r6NlPLueZgIoo5SWAwAh5F0AvwYQDBSU0u4ZzBQAxv3x3eflMWlqNGavmISqoyZUF7ehtc6GikOm4IrXiHglDFlaqCKkiE5UQ5c8/NkXPi8Pu8UNoZiDVCEKiaY0MzYqj5oQoVeOWpAICNPJBgwUTZUWODo9SJoceVrnlMiE+NmV6addl7R8HY7srEXF4RZkzIqFx+1DS1UneJ6iuqgNqdOjhzxHYOZUf/moxkMgBbyTBYoRoQdQ0+11LYALehcihNwJYB0AMYCL+jsRIeQ2ALcBgMFgGPGKdufz8BAICVRaKXIWxCNnQXzwfVOtFXUn2lF5xITDX9UEA0fsJA0y58QidpIGYdHyfgfaKKUoP9SC7947AWubP/9NglGLX/4uF0LRyPZTM6HHafOg4aQZ034xuv9+Af9soxP7mkApxbf/OQGpQoSZv0oG4G8xE47AkB0x6vUAAF2yGiqtFCcKmpExKxbNFZbgfXPyYPPwAkVX0AudricWKEZSf4/KfVoMlNL1ANYTQq4G8GcAN/RT5hUArwBAfn7+qLY6fF4egn5+uAUiDrpkf+th2qWJ/tw3nW6cPNCMQztq8PWbJQD8Kzt1SWroUjSIjFfCZfegtd6GqqOt6GiyI0KvxPSrk2Btd2L/p1X48rViXHprDrhuwcXR6UZTpQWJORGsxTFBlO1vBuUpknJP70n+TIRFy+Gye2ExOVG0uw5hOnkwUFQcMSEuVdNnY6TRQoi/++nwVzVwdLpRX9YBECB1WjSqjrbC6/ZBOMSAvrnZDqlCNGZ1HopEJgQhbIxipNQC6J48Px7AYCNY7wJ4aVRrNAyBFsVQCEeg0Egw+ecJyF0Qj/YmOxrLzWiqsKCpwox9H1cEwyInINBnhGPqpQZkzooJzimXKkTYs6UM2184jAVXpUMkEaJsfzN++qgcLrsX869Mw+Sf97//AHPuOPZ9PXa/exzRiargFqKjKdBFc+TrGvA+CnOLA5SncFg9aKu3YfbKSaNeh+4y58Ti4I5qFO6u86cXiVMga24syvY3o7q4DSld27wOpKPZjjBdaHQ7Af57X6oUBccoakra4HH4kDJ18L9HKBvPQLEPQBohJBlAHYDVAK7uXoAQkkYpPdH1cgmAExhnPi+F8DTnRhOOQBurgDZWAePcOACAu2sTeqlSFMx709uUhQYIRRy+/+9JvP3gjwhMsIrPDAfHEex5rwyR8SrEpflz2vA87dHyYEIb7+Px4wflOPhFNRKMWiy6LWdM/v8FBn2L9/izufo8PKwdrmDepeGsFRhJ2lgFDNkROPpNLbweHhkzY6DPCIdELkTBJ5UIj5EjPGbgtRwdTQ4kdFvxHQqkChGcVv+eGPs/qYTN7GaB4kxQSr2EkDUAPgcgAPAapbSIEPIogAJK6YcA1hBCFgLwAGhHP91OY4lSCp+XByc8+1nFYplwWIPcOQvikZwXhSNf10KmEiEmRQNdsj8L6JYnC/DR84eQOi0aArEAx39qhDpChktuNg57WiMzPrweH7a/cBh1pR3I/pke869I65P6YrSoI6TgOAKvy9e18ZATHU324GrwiBFeDT4cUxYm4MPnDgEAYlM1EAg4LLg6A9+8XYp3H/sJi27LQXJe3x9aj8sHW4dr0DQj40GqFAXHKDrbXbBb3KCUnrNdxUMGCkJIOvxdPjpKaQ4hZDKAZZTSx8/24pTSTwB80uu9B7v9+e6zvcZI4r3+R/rTbVGcLUWYBLNX9OwOkMiEWPr7POz/rAonCprA+yhSpkShtrQd7/2/AiTmRiBMJ0e4To7wWMWAi5E625w4sa8JJw+2wOv2QSwVInt+HDJmxQTL+7w8PE5fcJBuODxuH3gvD4n89PuNA7n8R2t1bSg4eaAFdaUdWHB1BnJ+ph/Ta3MCDuoo/8ynKQsN2P3ucX+gqLdBqhD12O96rMRnhiNCr0BrnS2YRj0tXwd9ejg2P/ETThQ09xsozC1dA9khMjU2QKoQ+bv0KIWt3QWfl4fb4T2j+yEUDKdF8S8A9wJ4GQAopUcIIf8GcNaB4lzj8/IAMGZPfkNRR8rw82szMf/KNFAeEEkEsFvc+GFbGRorLKg8fGrKbnisAqnTotDeZIfd7IY6QgpLq9M/eEiB6EQVwnRymJvt+OqNYyjeU4+cn+khkgqxZ8sJWNtdmLEkCbkL4uG0eSAUCyBT+afvetw+FO2uQ/nBFoTHKiCWCnDs+wZ43D5csCwFUxYahtWlcuTrGhR8Ugmn1QMKf4K1rLmxmHtZap8gRykFz9M+c/1bqjsh14gHXU1MKQXl6YhuanO6yvY3QxEmQfa8uHG5fli0DJ1tTmTMisH328rQ0ewPFNo4xbg89RJCMHdVGioPm3pMD5arxYhKUAV3++stsO92KI1RAP61FE2VFjhtnuDvhrXdNaEDhZxS+lOvfzyDZ8WaoLye0AoUAd2nz8rVYlx8o38Bu8/Ho9PkRMNJMw7vrMG+jyuh1EqgDJOi5lgbxDIhZixJRvoMXfCJjPIUxXvq8dP2Cux4zb+kRRMtQ0KWFj++X44f3y8PXkskEUAo5uBx+eB184jQK1G2vxkepxfJU6JAeYoftp1EyQ/+rJ7qCClcDn93R0xKz5k19Sfa8d1/TiA2NQyxqRoQQtDeaMPhL2sAHpj6CwPMzQ50NNthqrGi8ogJdosbeRfHY+qliRBLBfjpowrs/6wKkQlKrLp/xoDB6bv3TqDo23rEZ4Rj8kXxwdTXQxmprgOX3YPqolbkXhg/bq2m6YuTkDZDB7FUCE20HB1NDrQ12JA+Qzcu9QGAhEwtEjL7LtjTxipQU9LWb/LAwLiKJirEWhRKMZxWT3CqOwBYO1znbJfwcAKFiRAyCV1zdAghlwNoGNVahahgi+IcSfQlEHAI08kRppMjc3YM3E5fj+yd/SEcQfZ8PYxz49BUaYHF5MCkqdEQiDhUFbXCVNMJmUoMj8sHi8kBn5dCICCYND0acalh4HkKj8t/HUopTuxrQuGuOvz0UUXP6xD/YP0Fy1Ng63Dhi1eLoY6UYcmdk4OrcSml+O4/J3B4Zw0O7zy15EYo4hCfpUWMmMOBz6tx4PPq4LG4tDDUn+hAyQ8NwYkD3VlMDhR+U4fIBCVa66z45KWjWPXHfETolfB5eTSeNKO5uhPGeXHB76q90YZd75TC1uHGkjsmn3U3R/khE3gfRWr+0GsERktMigYxKf4EfmHRctQUt8Lt9AX3Uwgl2jgFeK9/dlbvQe32RhuU4RKIJKG11kiqFIH3UbQ3nmoJ2dpHZ3/wsTCcQHEn/GsUMgkhdQAqAFwzqrUKUb4QbVEMByFkyCDRozxHevyYAP69jhOHWIjFcaeuQwhB+swYpM+Mgd3ihtvhhUgqQEejHaV7G3FwRzXKDjTD2uYEJ+Bw2X3Te6RsIIRg3hVpiIhXwuvmEabzb6Gp1EqDrYUpl1hQc6wNXjePKIMKyXmR+O8zB/Dj+ycxaVp0n79zwSeVIBzB4ttzwQk4vPv4T/ji1SIY58b5u7265r47rR7MXjEJFYdb8Nm/CiESC0AIwbZn9uNXa/IGTKg3HGX7m6CKkEI3BlNhhyNMJ8PJAz4ACNlAAfhTr/cOFG31thHds2OkBFrLpppT+1JY28/d7VGH88tBKaULCSEKAByltLNrSut5J9TGKM4lcrU4uM+wQiOBPiMc8VnhOLKzFmkzdMieF9dvQjlCSL8tg4DoRHWfH+15V6ThvScL8OafvkdiTgQy58QiPj0cDeVmlPzYiNwFeijD/f3gC2/IwkfPH8Z3751AfGY4ci+MR8kPDSjcVYu8ixOwe/NxhOvkWHb3VLjsHnz0j8P47zMHcNENWYhJ0aCqsBXJeZFDZlgFgMZyMw58XoXq4jZMuzQxZGbAdG8hhWKgCNSvvcEGTD31Ps9TtDfaoc8IramxwKl8T6baTv/Dk0IIa8fEblFsBTCNUtp9NGkLgOmjU6XQFQgUYz3raaJKnxGD9BkjnyE1OlGN5WunomRvIyoOt+D4T00QSwX+rje5ENMWJQbLGrIjcOkt2RBLhTBka0GIPz1LxWET3v/bAVjbXLj4HmMw0F32v9Px2cuF+GJDkT+3APX/gM3vJ8+RqbYTzVWdmDQ1CiU/NGLPlhOQyEWYvigR0xcljfjf+0wFUl/IVCLIlCO/fejZCuwa13tAu7PVAZ+HD80WRTBQWCEPE0OuEsM6EbueCCGZALIBaAghK7sdUgMY3axlIepc7no63+gzwqHPCIfXk46y/c2oPdaOuLQwJE+J7PNjmJbfcwA3yqBCglGLmuI2JOdFIr7bE6tCI8Hye6bi4I5qAP7EddXFbX2ub2l14MPnDsHR6cGuf5eC91Ek50Vi4U3GYWVEHUuBQDHSu+mNJG2cIrjOIyAQOEI5UDg6PYhJ0UCuFqN9BPcHH2uD/YvNAPArAGEAlnZ7vxPAraNZqVDl7WpRcMNI4XGmzuVFOaFIKBIgc1ZscL+E4Zr5q2RYTA7MWZna55hAxCH/l0kAAJFEiO/eOwFziwOaKBnsFjccnW58ubEYPg+Pxbfnoq60HUqtFFMuTgjJtSFSpahrJlpojJn0RxujQM2xnjOfAoEjPBQDRbcZfcpwCWRqMWpL+j5QnCsGDBSU0g8AfEAImU0p/WEM6xSyAi2K2ptugFPjgzAiApxSCepygne5IdLHQZxgABGJwMllECcmQpKZCZGu5xMr73TCcfgI7AX7YN9XAHdVFSTJSSAyORwFBRDqdEh46UWI9GO7EIs5JSZFg2sfnT1kOUO2FngPqCluRbNChB2vFvlTrRBgyR2TkZQbOWSuolBw5Z9mQiAO3ZZy95lP6kgZBEIObQ3+GU+nM0ljrEhkQhCOgPIUinAJ5Cox3E7fsPYqD0XDqfHBrlTf2ejW5UQpvXnUahWiAmMUonA1JMnh8La3w9PQAE4iARGLYd9XAMuHH/X5nDh1EsRJSQBP4ampgauiAvB6AUIgycyEfNo0uCsqwNfVQ3nhhej8+mtUXn0NEv71CqTpp5/jnxk7YTo51JFSlB1oQXujDZEJKkz7RSLCdHJExoduV05vof7jFRhk3/rUfrgdXixbOxVt9baQbE0AXYkBFUI4Oj1QhkmCEzmsHS5oQ/y77s9wavwmgBIAvwDwKPxTY4+NZqVCVSBQKLIyEP/0X/otQ30+wOeDz2qFu7ISjkOHYduzB56aWgCASK+H8uc/h2zqFMinTYNA03czemdpKWpuuRWVV1wJ3f33I+yKVaw7KkQRQmAwRqBwdx0AYPHtuYhJ7vv/lDk7EXFKJE2OhEgiQENZB/ZsOYGORjv06aE34ylAqhT7A0W4FHK1vyvK1u4KyTGVoQwnUKRSSlcRQn5NKX2jK33H56NdsVAUHMyWDrwMnwgEgEAAoVYLoVYL+bRpiLj5ptO6jjQjA0lbtqDh/vvR+NBDaHz0UXByOeDzgfI8hLpoCCOjQJ1OgFIIo6P9/+miITYYIElNhUivB6fyZwHlzWY4S0rhrqoC9XnBSWUQGxIgTkyEIDJywCBEeR683QGB8tz7hz2WDNlaFO6uQ8asGBYkRolAxGHJHZMBAKV7G/Hl6/6sAaH8oytTitCOrjEKVaBFcW6upRhOoAjsvtFBCMkB0AggadRqFMJ8XUkBRdLRn0Io0kUjYcO/YNm+Ha7ycvA2OwjHAYTA29wEr6kVXGQEQCk8jY1wHD4MX3t7r5OI/F1cdOC9nDiFAkQqBW+3Q5KSAuWCBZDlTQaEQrQ89w84jx6FauFCaG+4HrK8PBDRuZmrZjQZciIwa3kKjOOUt+l8kz5Dh0NfVsNUYw3JdR8BgQFtZbgkOAvqXJ0iO5xA8QohJBz+3eU+BKAE8ODgH5mYvB7/6lWhfGzmmhOOg2bZsmGX591ueKqq4Dp5Ep7GRvha20BEQnBKFSRpaZBMSgERicDbbHBXV8NdWeVvZXi94KQSOA4fgemll4KBRRgdjfCrroJ5+3Z07tgBIpNBNiUP8un5kGZlQqTXgwgEoF4vJGlpIMJzr+91JAgEXEiti5joCEew4KoM7NteEdLjQFKlCIT4F5tyAg4ylWjiBgpK6YauP+4GkDK61QltPod/IxKBPDSXkXBisT8gpKUNXjAqyj+4/rO+h3wWC1zHj8Pb0gLlggXg5HJErbsHtu++g71gP+z798O0fn2fVoowOhqalSsgy831BxCJBN6mZtj2fAdnaSm8jU3wWTsBjxcSYxZUCxdCMXsORPo4uI4fh7u8HEKdDrzVis4vv4KnqREClbqrOy0RoDx4mx2KuXMgNhjQsn49bN9+h8g1d0J1ySVsDOc8E5OiwdK7pox3NQaVlh8NmVIUnM6r0krR2eoY51qdmUEDBSFEACCcUmrqei2Gf/OgdZTSrDGoX0jxOv2BQiQLzUAxEgRqNeT5+T3fUyqhXrQI6kWLAAC+zk64KyvhqasHQEE9Hpg/+gitL7/St5tLJII0LQ2i+HhI1WqAENh/+gmNu3YDAIhMBuroefNwcjnESUlwl1fA29gI6um29/DT/u4y3maDMC4WdXfdDWlODqRGI2R5eVBdegkEKhW8ra2wfPoZrDu/AjgBBNpwSCalQpKRDmlGBoQxMX1Tl/t8cBw5AvtP+8A77P4xIR8PIhFDmpUFWU4OhLGxLCgxPVBK4ThwANLcXHDiU70N8ZlaxHfLhquJlqOpwjweVTxrg63MXg3/HhQ2QsgJAA/DPwNqH87TpIBepweE94Zsi2KsCFQqyHJzIcvNDb6nWboUPovFH0DqG0A9bnAKJeQzZ/YZDKeUwnX8BOz79sFdfhLS7BxIjVnwmkwACOQzZ4CT+HMnUZ8P3qYmQCgEIQSWTz+F/eBBaK+5BrIpU9D+zruwfPIJOj//HB3/+Q8aH3kERCYDb/bfkJK0VBCpDK7ykz2mLgtjYxF+xSooL7oInEKJzs8+Resbb8DXYur6Swr8Y0JCIajbDfj83Y6CiAholv8a0X/4A6jbjdZ/bYDqkoWQZmaO4jfOhCrq86HxscfQ8e5maH79a8T935N9yvA2G9xVVVBKPChrdcLn5c+57A6EDjDQSQgpBLCcUlpGCJkG4AcAqyml/x3LCp6u/Px8WlBQMCrn3rWhAMd+bMZVyyk0v1oyKtdgzgylFM4jR2D55BPwbjfE8QlQzJsLaUZGsIyvsxOu48fhLCmB9auvYPu+5zpSxZzZ0Fx2GZTz5vWYtsy7XHCVlsJx9CjsP+5F544dUC9bCk91DRyHDkEQEYGkd9+BOCHh1GdsNrjKKwCOQGo0DrsV4uvsBPV6IQwP3WmfjB9vt6P+f/+Izh07IM3NhfPoUcQ++f8Qtnx5sIynvh5V198AT20tGnQzcSzrBlz98AWD7gE+Xggh+yml+f0eGyRQHKCUTuv2uoRSGvKPTaMZKL5a/wNO7m/GVdcoobr44lG5BjN23JWVcJaUwNdhhjQ7G7LcnCE/QymF6cUXYXr+BRCxGFHr7kHrS/8Ep1JBlBAP1/ET4K1WUNepQUuRXg9RfDzcNdUQaMIgy82F/IKZkBqN6PzsM1j37IE0IxMQcOjYshXweBC1bh20N1zvb9V04d1udH72GZylpfDU1wNeHwRhGqiX/ArymTN6lGVGl7umBrVrfg/X8eOI/t/7oL32WlTfeBMcRUXQLF0KaW4OiFAE0/r18JnN0N1/P2oLyrGrbSou+hmHrKsvHO+/Qh9nGihqAfyt21vrur+mlP6tz4dCwGgGii/+/i2qjzTjqltjoZgzZ1SuwZwbLJ9+ClF8AmS5ObAfOID6/7kXgrAwSLON4NRqCNQaiFOSwXdaYfnsU/BmC0QGA3ytrXAUFoK3WILnkmRlwV1ZCep2Q/3LX4K32WDduRPKCy+E/rn/D5xEAtsPP6Dx0cfgrqgAEYn8EwZEQngaGsFbrRCnpCB63T1QXnwxG0MZZbzdjvJfLYXPZoP+mWegnD8PAOBpakLjo4/BdJhtFQAAIABJREFUvncveKt/HwpOrYbh1Q2Q5ebC3mbD6w/sRYbpK1z09oPB7tVQMVigGGww+18AVIO8Pu/4XD4Q3gsiDa39eZmxp168OPhn+bRpSN351YBlw1au6PGa+nxwFhbCceQoFHPnQJKSAurxgHc4IFCrQSlF+9v/RtPjj6P2jjshCA+HZft2iBISEP/Pl6CcP9+/sBP+vGGdX3wB0z9fRu2a30MYEwNJaiqE0dEQqNVQ/eJSyKee2sSBt9ngKiuDdPLkCRVQeJsNvNs9Jl12ppdegqe+Hon/fhvyacFOF4h0OiSsfwHU54OnoRHgfRBoI4JjdLJwOUQiwOoSovGRRxH76CPnzJTywZICPjKWFTkX+Dw+CHgvuAk864kZfUQggCwvD7K8vFPviUQQdC1mJIRAe+014GRSNPz5LyBCISLvuAMRt90KTtrz3x4nlUKzbBnUv/wlzB98ANsPP8JVfhKuEyfga29H28aNUMyfj5iHHoIoOgrVv/0tHAX7IZs6FVF33w3FrAuGXW9vezu8LS3+NTO9goy3pQVtm96EZuUKSJJHf18z+4EDML38MsJWXgaBSon6+x+Az2JB5O23Q3vjDeAkElC3G44jR/xdf7F9swf7J08AwsjIYV/XVVaG1tc3QrNyZY8g0R0RCCCO75vQkxCC8DgVvOJpMG/7I3wWM/TPPnvaLQub2YU9W8rws9XpPbLUjqYBu57G5OKELALwHAABgA2U0id7HV8H4BYAXgAtAG6mlFYNds7R7Hp6/8EdMJ+sw+rHF4zJzcAw9gMHIIyMhNhgOO3P8nY72v/9b5hefgVEKIRs8mRYd+1C+DXXoPPLL+FtaoJ81iyErVwBoS4GspxscIpeM9R4Ht7GRpg/2o7Wl18Gb7dDEBUJcZwevMMB2ZQpUF2yEI0PPwJPXR2IVIroe9Yi7Mor+wS1gVBK4SwshLOoCJ76BhCxGJLUVKguvaTfcRdPUxMqVl7mz0TA+9PqiJOTIU5JgfWrr0AkEkgyM+AurwDf2QnAP04knzEDUmMWeKcLjiOHYf36GxCBABG3/xYRt9zSY2prgLumBvaffoI0Oxue+no0Pv44eJsdkz79BEKttk/5oXyxoRBNlRYsyShH0xNPIGrt3Yi8/fbTOkfh7jrs+ncpLro+C1lzTi99/mDOaIxitHWt0TgO4BIAtfBPu72K0v+/vTOPj6O4Ev/3Tc89o/uwZB22fIKNsSHG3PcRIBwBAjgkXIEQNve1G7L5bXY3N2ST3SRkNyGBwJIQcpGEBRPCDSFgbIMPbIMP2ZZkybrvuafr90e1ZNmWZMmWPJJV38+nP9PTU939umamXtWrV++pTQPKnAusVEpFROQfgHOUUtcPd93xVBR/+PJfiOysY/l/XoanZOwzsxkM40F8xw7qPvFJEtXVFH78Hyj69Kex43E6fvMbWn56H+nWVgCs3Fzyb7mZ4EknAdDx29/S9Zen+yfmwxecT/jss4m89jrpjg5wW0ReX4lKJLAKCyn9xtdpf+QRel9+BVdWFoFFxxHbuhV3fgGl3/omgYULB5Wv8dvfoe2hh/Qby+p3RfYvWEDxl75E6ORl/WXteJyaW24l9u67zHz018S3biW1p5G8Gz6IKxCgd+Ub9LzwArG338ZTUUH43HNI7WkksmoVkdWr+8PcWIWF5L7/SpL19XSteIrA0vdQ+fOf9yu3RE0Nrfc/QMcf/qDD4Dj45s6h9Bvf2Gc0OBpWPl7Nmqd28rEfncPuj99JbOMm5jz37IiVKsALv3qHTa/UM/ekaVx02+B1eigc6hzFeLMM2KaUqgYQkUeBK4F+RaGUemFA+deBDx9RCfcjnVa47BSugJmjMEwefFVVzPztb4isWkX47LMBcPl85N90E7nLl5OsqyNZW0vbI4/Q/F8/6D9PgkFyrrwS/8KFekGj4xWWd+21/WVSLS10rVhB1vnn68jIZ59NZOUbdDz2B+JbtxE+7TR6X1/JzuUfJHTyyahkEt/s2YTPPRdv1Uy6n32WtoceInf59RR+9KO4p08H26ZrxQqavv+f1Nx8M+FzziH/lpvxlFew+wufJ7ZuPWX/+X388+YdEIY/dPKyfRRLH/k33YhSinRbm45v5vP1m8/C55xD/ZfuYvfnPk/OFZfT+eST9Dz3PLjd5F13HbnXfoD41q2oZIqcKy4/rHhnOcUBlIKuligFt91Ozc030/mnP5G3fPmIr9FSo0dJde+0oWx1RJJhHVRROOaf/ekE1iil1h7GvcuA2gHv64DhDKa3AU8dxv0Om3RK4bKTiFEUhkmGFQ6Tde65Bxx3eb34Zs3qDwiZ2LWLRG0ddk8PodNOxcoePuudu7CQ/Jtu6n8vIoROOXmfuY90RweNd99DfOtWxO2m449/pP2RR/o/z7rwAkr+5V/6J+ixLHIuv5ysCy+k7eGHaf3pffS8+KK+fjBI2Q9/QPZFF426DkQEd0HBAcdzrriCdE8PjV/7Oj0vvIBVUEDBRz9K3oc+hGdaMQD+Y8cmEEVf2tnOpigzlp2E//jjab3/AazsbKzCQkLLDlRyA0mnbVp39xLM8RLpTNBa33tE4l2NZESx1Nn6lrW+D20mulNEfqeUuucQ7z2YGhzUDiYiH3ZkOHuIz+8A7gCoPARb7khJpxUelTYRVA1HLd4ZM/DOmDGm17Ryc5n+7W/1v7djMSJr1pDa0wjKJvuyy/YqiQG4/H4KP/pR8m+4gd6VK4muX0/2pZeOSzKv/BtuwFNaihUOEzjxxEHlGQtyinQns6MpwkwppPBjd1D3iU+y+/NfAKD4n/6J3OuupeHL/4z4fJT9x3f3Ob9jT4R0ymbxeRW89sft1G5umzCKogA4USnVAyAi/wr8Hh1Sbg1wqIqiDqgY8L4cqN+/kIhcAHwFOFspNWjoRaXUfcB9oOcoDlGeg2KnwRL7qHIrNBiONC6/n/Dpp4+8fChE1nnnkXXeeeMoFYOOuMYaf9hDINtL0y5tPso6/3xm/+UpVCpF870/pumee2j75cOk6hsA7Vo9cM1Wc60+b+bxhbzzWgN1m9s44ULdOd66qhHbVsw/eeznT0eylLMSSAx4nwRmKKWiwOHEzF0FzBWRKifY4HJ0GPN+ROQEdLypK5RSTYdxrzEhbQsuV+a8xAwGw+RGRCibl0v9lnb6HIm8M2fimzOHsnvuJnTWmdhd3ZT/5H9wTy+l6XvfZ6DDUXNNN26vi9xpQcqPzad+a0d/QrV1z9ey6W8H9LXHhJGMKB4BXheRPzvvLwd+LSIhBkw8jxalVEpEPonOlmcBDyilNorI14DVSqnHge+i81/8zunF1yilRp6gYYxJK8EyURIMBsNhUDYvj22rm+hsipI7Ldh/XLxeKn7yE1QshisYJN3eQcOXv0zNTTcT27KF/BtvpCV+KoXlYVwuoWxuLhteqKO5rpuiyixa6no47uwD12+MBSPJR/F1EXkKOB09r3CnUqrP//SwosgqpVYAK/Y79tUB+xcczvXHGlsJ42S6NBgMU4SyebkA7N7Svo+iAJ2sTIL6WM4Vl9P+yCMkamrwzpxB870/pvmCY5h/ejkA06q0o0Hjji7cHhfppE3xjPEJnjFS99i30PMHbgARqVRK1YyLRBOYtHJhWWZ+wmAwHDq504IEc7zsfredhWcOPQIQy6Lqd79FKZ3zZdOtnyGZEnItPU8RzvMTyvXRuKMLj0/3YIsrh/dSO1QOakgRkU8BjcAzwBPAk87rlEIphY1RFAaD4fDQ8xR57N7SwUgWPIsILq+X5PWfBkD95Gskd+8G9KiicUcnzbu68fqtfq+qsWYkI4rPAPOVUq3jIsEkwbYViAuX2ygKg8FweJTNy2XrqkY6GiMjzk1RtytBdp6bQE8ju265lcCi4whaC+nqrqJmcxtFlVnjtvhuJFOztegFdlOaPs8Ct8dMUhgMhsNj+lw9T9G4o+sgJTWpZJr6Le3MWFJCxY/vRXxeYps243lVL2/rao6S1bWT1p//fFzkHcmIohp4UUSeZIA77ETNRzFepFNaUVge4/ZkMBgOj3Ceju3U2zmyFQYNWztJJW0qF+QTXDSP2U9o63/+Cy/z1qMJEBfW84/ROz9Iwe23j7m8I1EUNc7mdbYpSTqpbYmW14woDAbD4eHxWXj8FtGu5IjK79rUisut5zYGknfuWeQ//wptzUkW3vs1io6fNR7ijsg91uSlANIpHdHS7Z0ciUYMBsPEJpjlJdJ18BGFUoqat1uZPie337tpIOWLphFb3UThoiqUUuMSOWLIVk9E/ksp9VkR+T8GicGUyYVvmSDlzFFYPqMoDAbD4RPM8RLpSgz5eUu0hXvfupfSXQtI7Slk8fkVg5Y75crZLLmwkvvW30d3opsvLP3CmCuL4Vq9h53X/xjTO05SUhGt+d1eExDQYJgKKKV4ZfcrvFj7ItPD07GVzUt1L9Gb6GVx8WKWFC1hSfESZmbPPKSGOZjtpa2+d59jsVSM9c3rWblnJb/e/Gv8nTlcuf5U4iWNBI6bScpO4XbpZntb+zae3PEkZ5SdwQs1L/DQpoe4fNbl2MrGkrE1kQ+XCnWNs5sPrBgqIN9UIdUbBcDtN4pivLCVTWe8k55kD5ZY5Pvz8bv3JnRRStER76Ar0UVJqASfdejJ6ZVSxNIxoqkokWSEaCrav8XTcQLuANnebLK8WeT6cgl6gv3nxdNx4mn9d/BaXrwuL5bLIm2nSakUllhYYpngkZOYbe3b+ObKb7K6cTUBd4BoSv//jys4junh6Ty761ke2/oYALNzZnPd/Os4s/xMysPliAi2snlm1zM8teMpNrdupifZQ1GgiHMrz+XOxXfis3y4gja9nXFqu2p5tuZZXqh9gQ0tG0jZKVzi4tTSUzl9+4fpDkb5dcW9PPz4t/Bbfm449gbOqTiHTz//aTriHfx8g/Z0uuGYG/jSsi/hkrF3uDlohjsR+QVwHvAy8CjwtFIqNexJGWS8Mtztem07Tzy0i/NP7OSYO64a8+tPZpRSdCW62NO7h+0d26ntrqU31dvfAEeSEXqTvbTF2miONuNxecjz5+EWd39jGkvHqO2qJZaO7XNtQfSCI1woFGml54pc4qI0VEpBoIB8fz4F/gIUipZoC0opgp4gIU8Iv+WnM9FJS7SF1mgr7bF2IqkIsVQMNXhU+0Ep8BcQ9oZp7G08QMY+eWxl73PM4/KQ58tjQcECFhQuYGHBQqaHphP2hikMFPb3DA9Wt3t697C9czsuXGR5s/bZXOKiJdpCLBUjy5tFNBWlvqee7mQ3aTtNwB0g35/PMfnHYLmG72Wm7BTrmtdR31NPV6Kr/9x5efMoDZXuo/g6Yh2sbV5Le6ydlEoRcodwu9xsaNnAxtaNtEXbsLGZkzuHhQULOankJKaHpxNPx7HE6lfEh6JM22JtVHdUE01FOb3s9MNuGGOpGPF0HI/Lw86unbxQ+wL3b7ifsCfMx5d8nGvmXUM8FSdhJ8j36/SntrLZ2bmTVXtW8di2x9jUqsPe5fpymZUzi55kD1vat1AaKmVx0WJyfDnUddfxav2rVOVU4bN8BNdXsqz2fdx38uexXWkWFCzg5JKTWVqylBOKT8AV8fLgXa9y6tWzyT9Zsa55HX+v/zsrduioR6WhUn503o+o7qxGRHjvjPceVufksFOhiogHuAS4HjgDeEYpNfY+WGPAeCmKbc9t5OnfNfLe02LMuenSMb/+RMRWNk2RJrZ3bGd7x3aqO6tpijTRm+ylJ9lDb7K3fz9l79t38Fk+gu4gQU+QgDtA0B0k359PUbCIRDpBR7yDVF9/Q+lGtSK7grJwGWFPmLRK0xptJZaO7bN6tSBQQJY3i9ruWmq7a2mLttEWa6M1pteDFgWKEBEiyUi/osr2ZVMQKKDQX0ieP28fmQLugN48e9/7LT/RVJTuRDddiS5aY63UdNXQm+ylNFRKrj8Xv+WkzLQTJNIJknYSt8uNx+UhZadI2SmSdpKmSBMbWzeys3PnPorJ4/JQnlVO2k4TT8cpDBTid/vZ3bOb9lg7trKdaAD2AQroUCgPl3PV3KsoChThdrlJpBNEUhE64510Jbpoj7WzsmEl7fH2Qc/va9g9Lg+xdIyWaMug5TwuD8fmH0txsBhb2bzb/i67e3YPWrY4UMzi4sWcUHwC8/Lm0ZXoQinFCcUnUBQswlY2gqBQrN6zmhU7VvDGnjeo7d6b72xJ0RJuX3Q7u7p20ZnoJNeX2/98PstHrl833OXhct5tf5cdnTvI8eUQSUb42+6/sb55Pbt7dh/Qabh45sV8+eQv9yuG4VBKsbVjK2ub1rKpdRM7OncQTUW5ccGNXFp16T4K+tXdr3LPqnvI9mZzRvdlpF4oIv+2Ns445mQqsvadg3jn9Qaee3Az133lJIoq9sZwWrVnFX/a9ic+vuTjlIXHLgjgmOTMdpTFxcCtwJlKqaIxk3AMGS9F8c4Tb/HcE+2873ybmddOqFiFh0w8Haehp4GG3r1bfU89e3r36NfInn0UQJ4vj5JQCVneLEKeEGFPmKAnSNgTpiBQQFGwiFk5s5iZPROvNWU9qQelJ9HDO23v0BJroTvRTW1XLXU9df3KpTXaSiQVoTxcTmGgUI+ixIUglIRKmJ07G0HoSfbQleiiO9FNT0Ir6MJgIX7LT3eiG5/lozyrnGxvNpbLIpqKUtNVw++3/J43m948QC5ByPJmke3NZlHhIi6ceSFzc+eS48shmorSFGni3bZ32dm1k+5EN0k7ScAdoDyrnBOLT6QkVIJLXERSWinPzpm9j7kQ9KTs6sbVdMW78Lg82MqmJ9nDptZNvNX0Fg29DQfIFXAH+kd9HpeHpJ0k5AmxrGQZJxafyNy8uTRFmvjemu/RGe/sf5bRjBLz/fksnbaUOXlzyPJkEU/HKQuXsaho0Zg2wEOxc30LT/73ej5w11KmzTwwRtOzv9hEzaZWbr37jCOS7vSwcmaLyMXoXBHnAi8CPweuG0sBJwOpqDOZHTx0u/iRpM+e368EBiqEngbqe+tpi7Xtc45LXBQFiigNlbKoaBEXhS6iLFzGrJxZzMqdNaLelWFwwt4wS0sG/Q+OO4uLFnP57MvpiHUQSUVI2kl8lo+AO9BvvhqMPPKYHp7OkuIlh3X/wkAhF8+8eMjP9/TuYUfnDvL8eSTTSdY0rqEp2kTQreeF4uk4x+Yfy3mV5x2ghM6uOJt32t5hXt488v35dCe6Sas0XpeXWDpGa7SVrR1bqe2uZV7ePOblzaM70Y1LXMzLmzcu9vyREsjWnanBPJ+UUtS+00b5/LwjoiQOxkh8PW9Bz018bCpPaKei+sv0hPwHKXlkiKfj1HXXUdNVQ013DXt699AYaaQ50kxztJmmSBNJe9/FPH7LT0mohOnh6czPn09pqJTp4en9x4qDxXhcZrL+aCXXn0suuZkW4wBKQiWUhPZmZVtUtGjE5+b78zlt+t4McDm+nP79MHouaH7+/LERdIwJ9imKQVZntzX0EulMUH7sxOicjWTB3fIjIchEJx1PAoI7eGQURSyl7cCd8U7qe+up6aqhtruWmm792tjbuM8wO+QJURwspjhQ3G/j7RsdlIZLKQ2VkufLM544BsMEIZilFUW0+8ARRd1mPVdUMVkUhYicAvwIOBYdwsMCepVS4xP4fIKSiiUBL+7Q2IXxVUrRHm+nuqOaHV07+l93du6kvqf+AHtrvj+fyqxKlpUsozyrnMqsSr1lV+7TkzIYDBMfy+PCF3QT6UzQXNPNqid3cPoH5uILutn4ym5ypwXJyp8YFoyRmJ7uRc9R/A5YCtwEzBlPoSYi6XgK8OIJj15RJO1kvx12R+cOqjur+1/7JuJAm4aqcqo4vuh4rpxzJSXBEnJ8OZSGSqnIqiDsDY/hExkMhkwTzNarsze8WMeOdS3sqe4klOujsyXKZZ9YnGnx+hlRPAql1DYRsZRSaeAXIvL3cZZrwpGKa++f4UYUtrKp7qhmbfNa1jatZV3zOup66g5wHc3351OVU8VFMy6iKqeKqpwqZuXM6vcgMRgMU4O+MB4N1Z2UzsmhtyNO2+5eLr5z0YQxO8HIFEVERLzAWhG5B2gARpZp4yginUyDsnFn7X10W9m82/Yurze8zht73mBd8zq6EzpNYZ4vj8XFizmv8jyC7mC/62hVTpUxExkMBgCC2T62v9WEnVKccuUsZi0porczQX7pxGpiR6IobkQnOPok8DmgArhmPIWaiKSTKVx2kk1dW3im5lmqO6tZ27SWjngHQP8IYUnxEpYULWFG9gwzcWwwGIYlmOXFTum5yMqFBfiCHnzBied5OBKvp10AIpIGHgd2K6WaxluwiUYqaeNSaT76zB3E0jEqsyo5q/wsTik9hZNLT6Y4WJxpEQ0GwyQjmKM9nwrKw4RyJu4areHCjP8E+JFSaqOI5ACvAWkgX0S+qJT69eHe3FnM9wO0J9XPlVLf2e/zs4D/Ao4Hliulfn+49zxU0kkbsZNEUhEeu+IxZufOzpQoBoPhKKFvLcWMhQUZlmR4hhtRnKmUutPZvxXYopR6v4iUAE8Bh6UoRMQCfgxcCNQBq0TkcaXUpgHFatAL/r54OPcaCa319fz1u/cDaVykQKURbFzKxsKmp20uuD1cPfdqoyQMBsOYkDtNrz6vWlKYYUmGZzhFMXAVyIVo91iUUnvGyPa+DNimlKoGEJFHgSuBfkWhlNrpfHb4UdEOwp6aHbRFTx+6QAjc8Ro+seQT4y2KwWCYIpTMyuHmb5/Wn0N7ojKcougQkcuA3cDpwG0AIuIGxmLVWRlQO+B9HXDyGFz3kJi16Hhq3vswCgvBAuVC2S5SSpFI2+zZ/CqVrk0UBm7JlIgGg+EoZKIrCRheUXwM+CFQAnxWKbXHOX4+8OQY3HuwYcnIQz8OvJDIHcAdAJWVlYckTCCUxSVXfXzIz1/94d84rq12yM8NBoPhaGW4DHdb0GHF9z/+NPD0GNy7Du1q20c5UH8oF1JK3QfcBzrM+OGLdiBptx8fQ+e3NRgMhqOVTC4DXgXMFZEqZ0HfcrT77YTEtgL4SYA97tMlBoPBMKHImKJw0ql+Ej062Qz81nHF/ZqIXAEgIieJSB1wLfBTEdmYKXnTbmdaxsmdazAYDFOFEcV6Gi+UUiuAFfsd++qA/VVok1TGUX0JU5JR8E6s5fUGg8Ewngy34O7zw52olPr+2IszcbGdEYVK9CKhie3zbDAYDGPJcCOKrGE+G5cJ44mMctIyJuMRTDZog8EwlRjO6+nfAUTkdKXUqwM/E5FhVqYdnSiPNj2lY70ZlsRgMBiOLCOZzP7RCI8d3Xj0vEQq3pNhQQwGg+HIMtwcxanAaUDRfvMV2eggflMLj56jSMeN15PBYJhaDDdH4QXCTpmB8xVdwAfGU6iJiHj0HIWdMKYng8EwtRhujuIl4CURebAvJ8WUxhlR2PFIhgUxGAxThnQKXBaIgJ2GTX+GqrMhdGTDko80Fep3gYVAf/QqpdR54ybVBESctRNmRGEwGI4Irdvh4asgpwKW/xKe/yas+hmES+D9/w1zzj9iooxEUfwK+A1wGXAncDPQPJ5CTURc3j7Tk5mjMGSAaLt2qHAfonN29x5o3QZK6d4pAl31sOtVSMUgpxymnwhVZ4IvS5dr2QJNm8GfA+FiCBWBsqF9J3iCULwArDFYs5uIQHcDBPLA7df76QRkTwdxQaQNIq0Q64B0EhI9UPuGfp7cSsibCf5cfW46Ad6gbkyzSiA8TcvqGsJvJ53Sz2On9PPFO6GzDmJdkIzoeyV6tYx9+54AFM3X8tppUGkd2keltbx5VZA1Ddp36WtF27QM5SfpekwntHzD1V39WvjVtbpsVz3cexL0NsOSD8HuNfDLqyF3BpQeD70t+vsqew/MOA2Ovezwv5P9GMm3XKCUul9EPjPAHPXSmEsywbF8zoK7pDE9TXnSSd2IuP3g9kGsEzpq9HtPUDcmsU69xZ1Xy6sbLk9IN7bRdv3HT8UhHdcNYbxHN0KpmL5erGtvw9zbpBuh7DJdxuXWJgmXe98tFdMNa7RdN6yWTyuXWOfgz+LL1lt3vb6XWOAL64Yv0T18PbgDECoEywOBfN3QiktfR9m68U3FtUypuJY7q0Tv9zTqKAfJiG5MR7s0yx2AwjlQt1o/50ERLef+9RXr1PU/onsO+H5Hes5Q+LKh8hR9PTuloz34c/Txxo2w5SnIKoWbn9aK8zc3wuIPwhX36vpc+yuoflEr8nAJqBSsvh/q38yYokg6rw0i8j50hNcJEVbjSGK5faSUS/csDJOPdEo3tt0N0N0InbXQslU31umE06A5jXY6sbch6WvMEhFIOj1LO7n3uu7A2MT/sny6sUjFdU8zt1L3ksUFcy/UPdh4N3TUahntlO7N2qm9WzqlRwO5lbq368/Rz5KMQsEcKJynG0ulAKUb92kLtcJJxXUvfecrEO3QDX3pYt1jjffoeup1DAl5M3UDu/tNrZDSCYi0OA0+esQiLn1dd0DL4fbpHnnzO7rBDU/TPX+3H/Jn6xFNrEM3gtlluu67G7SswXwtayBPK1y3Fwrn61el9HWjHVoOy6Mb8u49eutp1M9mp/T31ldvaWffF4aiY7V8vc26/nLK9b08If2deIN6v28EYKe1Ik/0aMXqsvTziktfs3W7vm/eDN3rD+breqpbretNXLBnPdS8ruvZ5dFKOdYF8S79vZ99Fyy7Q89FFB8D/7hV15WIlmfZR/W2z288qUcX48BIFMU3nJzZX0Cvn8gGPjcu0kxgPG6LKD5U0pieJizpJHTt1o1pZ63+M7fvhIb1uoFS6X3L+7J1D9fy6YbC7QNvWDdGfY1vIE/3+rxB/eoJ6sajr+cf7dA96bwZuqFO9OjGxp+zt4foz3ZMCA36HNDXDRXp61hefc2xyRx5aLh92uxUdebIz1k0AZwfRXR9+/YLJFF87Pjd02UAfbgoAAAey0lEQVRBftXQnxfNP/BYIA/yZx382krpbX9TmWcEueIsD2SXHrzcIXBQRaGUesLZ7QTOHRcpJgFetxDFhxjT05GnrwfXvkP3yKId0LZd92CTMd0T7ajdaz4ZSFYpTDsO5r1X9xSzSrX9OLtc24uPZOOcN/PI3cswORHJbIdhCIZbcPfVoT4DlFLq6+Mgz4TFY7mIKi8+oyjGFqV0Q99Vr7f2nbr339OkTSadddBWfaBN2PJqbxBvUPfaZ56hTS65Ffp4bqVWDG5fRh7LYDiaGG5EMZgfaAidO7sAmFKKwu1yEcWHr890YBg50XaoXQWNG6B5i1YMfXbkrnpt+x+IL1t7vHgCuhc+9wIomAsFs/UQ3pfl2LGnXoAAgyETDLfg7nt9+yKSBXwGuBV4FPjeUOcdrXjdQg9eXCZx0eAopT13elv0RF7bdtizQU/YNW3aWy67DIIFjnvlsXqiNrtMK4accj0ayCqZkMNvg2GqMuwchYjkA58HPgQ8BJyolGo/EoJNNLTpyWcUBUBPs/axb6uGhrXa+6Vl64HulL5sqFgGC6/WroCli/XErsFgmFQMN0fxXeBq4D5gkVJqSodN9VguolNtRKGUNg01rNt3667fW8abBdOXwJIPajfHUKH25imYDVnTh17oZDAYJg3DjSi+AMSB/wd8RfaaAgQ9mT2luoZuS7SiSB9kEdJkRSno2HWgUujznReX9sOvOlOPDIqO0S6CuTPMXIHBcJQz3ByF6QoOwGu5iOHDOlpGFLFOqFkJNX/XpqOGdXtXuLrcehHS3Pc6i64WQ8lxJle4wTBFGYNALVMDj+Uiony405NUUXQ3aqWw6zXY9XdofBtQWilMOw4Wvn+vUiheCB7/QS9pMBimBkZRjBA9R+HDnZ4k7rHdjbDtGa0Udv1dL1YD7W1UsQzO+TLMOBXKluq1CAaDYVCUUsh+XnjJtI2tFF7LRTxl0xVLkh/04rYONMQopUikbeIpG4/Lhd/jOuB6+xNNpLGVIui1+OumRu5/ZQczCoJ85IwqSnP8pGyFz+0i4LEGvedYYxTFCPE4cxRuOzYgAucEQikdIOzdJ+Hdp3SESdCuqJWnwkm3QeVpOnaP5cmsrIZJg1KKZFoH7PO6922QEimbxq4Y9R1ROqNJWnoSrN7VxtbGHnICHsI+NynbJuB1M7MgyPTcAHlBDylb0RlN0hVN6ddYklgyTUHISyxp89KWZmLJNOfOL2butLAjx977Wi6hqihEcZaPjbu72N0RJei1CPnchH1uumNJ6tqjpG2Fz+OitSdBc3ec7ICHkM+iK5oinkoT8rlJ24rGrhiJlI3b5aK1N86ezhgBr5vsgJu23gSd0SRBj0XYr68fT9nUd0SxlZYlbWvhPJZQlhvAVhBPpYklbeKpNPGUvY/8HkuYXRRmfkkWO1t62bynm0TKRgTCPjcCdMVSAAQ8FtFkmor8AOt3d/C7NXUHfEdey0XY76Yw7OXEyjy+c83xY/gL0GRUUYjIxcAP0KlVf66U+s5+n/uA/wXeA7QC1yuldh5pOR1ZSOBDUE4kzAlgmlFKR4t8+zHY/H96Mhp0uOHz/h/Mu1iblSaaUjOMKYmUTUNnlLr2KCJQkadHiK29Cdp7E7RHEiRSNsm0TTKtSNn61e+xqMwPIkBDV4zOSILueIreeIr23iTvNnazo6W3vyH0Wi6y/G6y/G6iyTRN3fF9GkCA/JCXhdOz6Y2naOqO4Xa56ImneHJ9PfYgAWI9lpAT8OC1XLT0JnAJnD67EL/XYsWGBrpXpw6pTrxuF26XaAUU9lEY9rGlqZueWIrsgAef20VvPI3LBSXZfkKOApg3LYuz5hURS6bpjCbJD3nJC3qJJNL0xFL0xFN4LKHihDL8HotIIkXQq+ukoTNGbVsEj+XC59ab32Ppfec1mVZ0RBO8u6ebN3a0UZEf5KZTZhD0ubFtRU88hVKK4mw/LhEau2IsmJ7N1SeU0R1L8eSGBq3ULCGetIkk0kSTabpiSVq64/g94+NYkjFFISIW8GPgQqAOWCUijyulBqzO4jagXSk1R0SWA3cD1x95aTUJl6MckpHMKQql9PzCxj/C23/QIS9cHph9Lpz5ea0cskoyI5vhoCile9Nrazt4e3cnIoLP7SKSSNPWm6CuPUp3LEnIp/+akUSKaCJNpH9LEUmkSaZtcoNePJYM2mAfKl63iyyfbvjmFGdxwbHTCHl149OTSNEd05vP7aIsN0BZboCSHD95QS85AQ8V+YFBzSqJlE1rb5y23gQey0W230NOwLOPGUYp1d9LB0ilbaLJvYEc+8olUjbbmnpo7IpxbGk2VYUhYsk0vXHdkId8borCPlyuo6uDlBfy8uFTZmTk3pkcUSwDtimlqgFE5FHgSmCgorgS+Ddn//fAvSIiSo3V32J0JF1O3KAjHUFWKb2wbdOf9dZWrd1Vq86GM7+o488H8o6sTFOMZNpGoN8e3NITp6EjRlN3jObuOK29CeLJNN3xFNube7VpwlbYSpFWCtsGWyk6Isl9Gr+BhLwW5XlBcgIeGrtizjE3uUEv03Mtgl43Qa9F0GvhtoSOSJJ4ymZ6boCKvABleQFQUNMWweUS8oNe8sO6R+xzu/BYLjyW4LFcuC0hEk9T0xZBAdNz/OQGvQeYl8YKr9tFaU6A0pyho6CKCNaAtt1tucgazP7ug2VV+fscCvnchHxuisdKYMM+ZFJRlAG1A97XAScPVUYplRKRTnScqfEJun4QkuLX+VWOhKJQSs8zbPqTVg4dNTr2/ayz4fTPwPz3Qbho/OU4ilBK0ZtIE0tqu3E8qe3I0WSaNbvaeGlLM5FEGo/lwmu5sJWirj3Kns4YibSNS2Batt/pHScOuL6ItinPKgoxtziM23LhEnCJIM5rTsBDSbafhdOzWVyRi+USEmmbgMfCM0aTkqeNsJzPbZEXOsSMeYYpRSYVxWDjwv1HCiMpg4jcAdwBUFlZefiSDUHS8kMKbXoaD2wb1v9GK4e61ToZTJ9Z6ewvwfxLdRIUw0GJJtL8fXsLf9vWQlN3nObuOFsbu2mPJIc855iSLIqyfCQdk4dSisUVuVyyyE/I6yaVtqnriOJxuZhXkkVlfpCiLB9FWT4Kw1587kOzD4+XXdlgGCsyqSjqgIoB78vR2fMGK1MnIm4gB2jb/0JKqfvQoUZYunTpuJml9iqKMR5R2GnY8jS89B298C1/ls6fMPNMmH8JBHLH9n5HAUopatuivLy1mc0NXbT2JGjtjdPak6ClJ76P10hpjp/8kJf3LixhZmGIkNfC57bwefomHS3mTgtTnmfchA2GwcikolgFzBWRKmA3sBy4Yb8yjwM3A68BHwCez9T8BEDK5dhX9w+Lfah0N8Jb/wurH4SuOh059Zr74bhrjKeSQ9pW1LVH2NbUs3dr7mF7U0+/MsgJeCjO8lEQ9nLs9GwKQ14Kwj5OqMxlWVX+Iff0DQaDJmOKwplz+CTwNNo99gGl1EYR+RqwWin1OHA/8LCIbEOPJJZnSl6AtNXn9XQYIwqlYOffdCL0zf+n021WnQ0Xf1uPHqbgGofdHVHe3NVO2lZ0x5Lsao2wqy1CTWuEHa29JFJ7s9YVhn3MKQ5xxZLpzC/J5rTZBcwqDB10AZPBYDh0MrqOQim1Alix37GvDtiPAdceabmGIu0+DEWRjMJbv4Q3fgYt7+oE6ss+Bks/AoVzxlbQCU4iZbOlsZtXtrbw/DuNrNq5b+R6n9tFZX6QGQVBzp5fxJyiMLOLQ8wpyiInOPUUqcGQaczK7FGQtvpMT6OYzO5qgLW/hJU/1ZFYp58IV/5Y52iYIqEzOiNJXt/RyuvVraysbmNLYzcpZ/XVMSVZfOHCeZx7TLHj+ummOOvo84E3GCYzRlGMArtfUYxgRNH0Drx0t3ZtVWmYfT6c+QWYefr4CplhlFJUt/SyuaGLt2o6eL26lU0NXSilRwrvmZHHR8+axTElWZwyq4Bp2RNghbvBYBgWoyhGge0ZsDJ7KJq3aAXx9h90WO5TPwHvuUUn8jlKaemJ87etLby8pZmXt7bQ0hMH9CKr91Tm8bkL5nHKrAIWV+SYiWWDYRJiFMVoGG4yO9IGz30N3nwI3AE447Nw6qcgVHBkZTwCJFI2q3e18YqjHDbWdwGQF/RwxtwiTp9dwHFlOcydFjaKwWA4CjCKYhR43BYxfPgHjijsNKx+AJ7/BsS7YdkdOqzGUbRqWinFjpZeXt7SzCtbW3itupVIIo3bJZxYmccXL5rHWfOKWDg9pz9Oj8FgOHowimIUeCwhKn78CUdR7F4D//cZ2LNBL4675B6YtiCzQo4RSinerGnnD2/u5uUtzdS161HUjIIgV59Yxllzizh1dgFZfuOFZDAc7RhFMQo8los4Xu299NRdsPInOlLrB34BC6+a9Ivk0rbi5a3NrNrRxstbm3l7dxchr8Vpcwr52FmzOGteETMKTDpUg2GqYRTFKOjLcsfmxwHRyYDO/yr4czIt2mHREUnw/DtN/M+L29na1IPbJSycns3X338cV59Q1h/y2mAwTE1MCzAKPJaLbVRSNS0X3vd9qNw/2O3kYU9njBUbGlixoYE3a9qxFcwpDvOjD57AhQummUB1BoOhH6MoRoHHEv5JPsdb/3BRpkU5JKKJNH9eu5s/vFnXvxr62NJsPnXeXM6aV8iSijwzGW0wGA7AKIpR4LFc/fmDJxNN3TEefHUnv1pZQ2c0ybxpYb540TwuXVTKrKJwpsUzGAwTHKMoRoHHcpFI2wcvOEHY3tzDz16u5rE3d5O0bd67oIRbT5/Jsqp8E0TPYDCMGKMoRoHXElKTQFGs2dXOT1/azjObG/FYLq5dWs7tZ86iqtB4LBkMhtFjFMUocFsubKXdSCeaLd+2Fc+908RPX9rO6l3t5AQ8fOrcOdx02kwKw75Mi2cwGCYxRlGMgr6cxsm0jeWaGF5BSikeX1fPD5/byvbmXspyA/zr5Qu4bmmFcWs1GAxjgmlJRoHH0qOIRNqeEO6ja2s7+OaTm1i1s51jS7P5wfIlvG9RKW5HoRkMBsNYYBTFKPC6dQOcyrDn0+aGLr61YjOvbG0hP+Tl7msWce17KkwOB4PBMC4YRTEK3K69pqdMEEum+cFzW/nZy9VkBzzcdckxfPiUGYSNiclgMIwjpoUZBf2mp9SRVxSvbmvhn/+4gV2tEa5bWs4/X3osuUHvEZfDYDBMPYyiGAV9pqcjOaJo703wjSc384c365hZEOSRj57MabMLj9j9DQaDwSiKUdDn9dSX73k8UUrx57X1fO2JTXRFk3zi3Nl86ry5E2IS3WAwTC2MohgFbteRMT3VtkX4yp/e5uUtzSypyOU71yzimJLscb2nwWAwDEVGFIWI5AO/AWYCO4HrlFLtg5T7C3AK8Del1GVHUsbB8Iyz6SmVtnng1R18/5ktWCL8+xUL+fApMybc4j6DwTC1yJTD/V3Ac0qpucBzzvvB+C5w4xGT6iB4+xfcjb3paUNdJ1f++FW+teIdzphTyDOfP5ubT5tplITBYMg4mTI9XQmc4+w/BLwIfGn/Qkqp50TknP2PZ4r+OYoxHFFEE2m+99d3eeDVHRSEffz3h07kkuNKTNA+g8EwYciUopimlGoAUEo1iEhxhuQYFe4BK7PHgrd3d/LpR9+iurmXDy6r5K5LjiEnYHJQGwyGicW4KQoReRYoGeSjr4zDve4A7gCorKwc68v3M5amp0ffqOFf/vw2+SEvv7ztZM6Ya1xeDQbDxGTcFIVS6oKhPhORRhEpdUYTpUDTYd7rPuA+gKVLl46b7+rAoICHSipt880Vm/nFqzs5c24hP1x+Ankhs3DOYDBMXDI1mf04cLOzfzPw5wzJMSr6VmYfqqLojCa59cFV/OLVnXzk9Cp+cctJRkkYDIYJT6bmKL4D/FZEbgNqgGsBRGQpcKdS6nbn/SvAMUBYROqA25RST2dI5gEjitEPWmpaI9zy4BvUtkX4ztWLWL5s/ExkBoPBMJZkRFEopVqB8wc5vhq4fcD7M4+kXAfjUE1P62o7uO2hVSTTiodvO5lTZhWMh3gGg8EwLpiV2aPgUExPz2xq5FO/fpOiLB+P3rKMOcXh8RLPYDAYxgWjKEbB3pXZIzM9PfzaTv718Y0cV5bD/TefRFGWSUlqMBgmH0ZRjALPCPNR2Lbi7qff4acvVXPBscX88IMnEPSaqjYYDJMT03qNgn7T0zBBAVNpm3/6/Xoee2s3N54yg3+7YqEJw2EwGCY1RlGMAssliAw9okikbD7967f4y8Y9fPGieXzi3DkmFIfBYJj0GEUxCkQEj+UiOUg+ilgyzZ2/XMOL7zbz1csW8JEzqjIgocFgMIw9RlGMEo9LDjA99cZT3PbQKlbuaDNrJAwGw1GHURSjxON27WN6iiRS3PrgKtbsaue/rl/ClUvKMiidwWAwjD2ZCuExafFYLhKOe2w0keb2h1azemcb379usVESBoPhqMSMKEaJ13KRStvEkmnueHg1r1W3GiVhMBiOasyIYpS4LaE3keJjD6/hla0t3H3N8Vx1QnmmxTIYDIZxw4woRonHcrFiwx4Avn31Iq5bWpFhiQwGg2F8MSOKUdIXGPDr7z+ODxrvJoPBMAUwI4pR8pHTZ+K2xJibDAbDlMEoilFyrTE1GQyGKYYxPRkMBoNhWIyiMBgMBsOwGEVhMBgMhmExisJgMBgMw2IUhcFgMBiGxSgKg8FgMAyLURQGg8FgGBajKAwGg8EwLKLUgdnaJjMi0gzsGufbFAIt43yP8WCyyg2TV/bJKjdMXtmN3IfGDKVU0WAfHHWK4kggIquVUkszLcdomaxyw+SVfbLKDZNXdiP32GNMTwaDwWAYFqMoDAaDwTAsRlEcGvdlWoBDZLLKDZNX9skqN0xe2Y3cY4yZozAYDAbDsJgRhcFgMBiGxSiKUSAiF4vIuyKyTUTuyrQ8wyEiFSLygohsFpGNIvIZ5/i/ichuEVnrbJdmWtb9EZGdIrLBkW+1cyxfRJ4Rka3Oa16m5dwfEZk/oF7XikiXiHx2Ita5iDwgIk0i8vaAY4PWsWh+6Pzu14vIiRNM7u+KyDuObH8UkVzn+EwRiQ6o959kSm5HnsFkH/K3ISJfdur8XRF5b2akdlBKmW0EG2AB24FZgBdYByzItFzDyFsKnOjsZwFbgAXAvwFfzLR8B5F9J1C437F7gLuc/buAuzMt5wh+L3uAGROxzoGzgBOBtw9Wx8ClwFOAAKcAKyeY3BcBbmf/7gFyzxxYLtPbELIP+ttw/qvrAB9Q5bQ9VqZkNyOKkbMM2KaUqlZKJYBHgSszLNOQKKUalFJvOvvdwGagLLNSHRZXAg85+w8B78+gLCPhfGC7Umq8F38eEkqpl4G2/Q4PVcdXAv+rNK8DuSJSemQk3ZfB5FZK/VUplXLevg5MyDzFQ9T5UFwJPKqUiiuldgDb0G1QRjCKYuSUAbUD3tcxSRpeEZkJnACsdA590hmmPzARTTiAAv4qImtE5A7n2DSlVANoJQgUZ0y6kbEc+PWA9xO9zmHoOp5Mv/2PoEc/fVSJyFsi8pKInJkpoQ7CYL+NCVXnRlGMHBnk2IR3GRORMPAH4LNKqS7gf4DZwBKgAfheBsUbitOVUicClwCfEJGzMi3QaBARL3AF8Dvn0GSo8+GYFL99EfkKkAJ+5RxqACqVUicAnwceEZHsTMk3BEP9NiZUnRtFMXLqgIoB78uB+gzJMiJExINWEr9SSj0GoJRqVEqllVI28DMyOJwdCqVUvfPaBPwRLWNjn7nDeW3KnIQH5RLgTaVUI0yOOncYqo4n/G9fRG4GLgM+pBwjv2O2aXX216Dt/PMyJ+WBDPPbmFB1bhTFyFkFzBWRKqfHuBx4PMMyDYmICHA/sFkp9f0Bxwfalq8C3t7/3EwiIiERyerbR09Uvo2u65udYjcDf86MhCPigwwwO030Oh/AUHX8OHCT4/10CtDZZ6KaCIjIxcCXgCuUUpEBx4tExHL2ZwFzgerMSDk4w/w2HgeWi4hPRKrQsr9xpOXrJ9OeAJNpQ3t/bEH3TL6SaXkOIusZ6KHqemCts10KPAxscI4/DpRmWtb95J6F9vZYB2zsq2egAHgO2Oq85mda1iHkDwKtQM6AYxOuztGKrAFIonuvtw1Vx2gzyI+d3/0GYOkEk3sb2p7f9zv/iVP2Guc3tA54E7h8Atb5kL8N4CtOnb8LXJJJ2c3KbIPBYDAMizE9GQwGg2FYjKIwGAwGw7AYRWEwGAyGYTGKwmAwGAzDYhSFwWAwGIbFKArDsIhIuYj82YkoWi0i94qIbwyvf4uITB+r6w24rsuJePq2E4l2leOPjois6IswOh7IvtFv14rID8frXqNFRKaLyO9HUf5BEdnhPMc6ETl/BOcc45R/S0RmH57EhomAcY81DImzaG8l8D9KqV84i5fuA3qUUp8Zg+tbaH/9LyqlVo/iPLfaGwRuqDIfRPvRX6eUskWkHOhVSrUfltAjk28neq1By3jfa7wRkQeBJ5RSvxeRc4H7lFJzD3LOXUBAKfWvI7yHoNsi+7AFNowLZkRhGI7zgJhS6hcASqk08Dn0Kt2wMxq4t6+wiDwhIuc4+/8jIqtF58L49wFldorIV0Xkb+gVzEuBXzk90ICIvMcJ4LZGRJ4eEFLiRRH5loi8BHxGRK51RgvrROTlQWQvBRr6Gh+lVF2fknBkKBSdr2CziPzMkfOvIhJwyswRkWed67/Z1zMWkX90RifrBz7XSBjsms5q5+8OGPlc75Q9x3nm34vOtfArp0FFRM53eusbRAeS8w14rm+JyGtO3Z/o1OF2EbnTKTNTnHwIImKJyH8411kvIp86yCO8xoDAdIN9V6LzKXwWuF1EXnDKfd55vrdF5LMD5NgsIv+NXgxXISI9InK3c71nRWSZUwfVInKFc95CEXnD+b2sF5FhlZZhjMjkaj+zTewN+DTwn4McfwsdxOwW4N4Bx58AznH2+1b1WsCLwPHO+53APw0450Wclb6AB/g7UOS8vx54YEC5/x5w3gagzNnPHUTGcudea9GB1k4Y8NlOoBCdryAFLHGO/xb4sLO/ErjK2fejV1xfhB5RCbqT9QRw1iD33unI17dS+HPDXPMa4BmnnqYBNWgldw7Q6TyHC91In+GcVwvMc67zv+iAj333/Qdn/z/Rq32zgCKgyTk+EycfAvAP6Fhg7oHf2X7P8iDwAWf//cAjI/iu/g0nxwLwHqcuQkAYvVL6BEcOGzhlwL0UzgpkdIyvvzr3WQysdY7/CB3PCXRemECm/ydTYXNjMAyNMHjEysEiW+7PdaJDhLvRDd8CdMMF8JshzpkPHAc843SeLXTIgz4Gnvcq8KCI/BZ4bP8LKaXqRGQ+elR0HvCciFyrlHpuv6I7lFJrnf01wEzRsabKlFJ/dK4VAxCRi9DK4i2nfBgdg2ewEc25aoDpaZhrngH8WunRWqMzYjoJ6ALeUErVOeXWohvXbkfmLc6lHwI+AfyX874v/tgGIKx0LpJuEYnJgfMyF6DDXaQcmYbKlfBdEbkHHXb8FOfYwb6rPs4A/qiU6nWe4zHgTEfOXUrnt+gjAfxlgPxxpVRSRDY4zw5aYX5FtCnxMaXU1iFkNowhRlEYhmMjusfbj+gwzdPQ8WeOY1/zpd8pUwV8EThJKdUu2s7tH1Cud4j7CbBRKXXqEJ/3n6eUulNETgbeB6wVkSXKiRQ6oEwcnZvgKRFpRPeI91cU8QH7aSDA0IpQgG8rpX46xOfDMdw1h2J/2dwHKT/wHHu/820O/L8P1RHYn39EK+NPoxXTezj4dzXwHkOx/+8gqZyhAgPkV3qOye3sPyIiK9Hf+9MicrtS6vkRPIPhMDBzFIbheA4IishN0D/5/D20uSmKNnUsEe1hVMHeEMnZ6EagU0SmocNuD0U32jwCWvkUicipzv08IrJwsJNEZLZSaqVS6qtAC/uGZMaxz0939l3A8cCIss0pnbejTkTe75zvE5Eg8DTwEdE5PhCRMhEZUQKlYa75MnC9M19QhE6XOVyU0HfQo545zvsbgZdGIsMg/BW4s68RFpH8YeS3gR8ALtH5m0f6Xb0MvF9EgqKjAV8FvHKI8vZFga1WSv0QPSo5/lCvZRg5RlEYhsTp3V0FfEBEtqKjotpKqW86RV4FdqDNBP+BnpREKbUObZ7ZCDzglBuKB4GfOKYVC/gAcLeIrEPb908b4rzvOpOwb6Mbo3X7fV4M/J/z+Xr0XMS9jJwbgU+LyHq0Lb5EKfVX4BHgNccc8nv2Krn9eUH2usf+71DXRNvi1zvyP4+ev9kzlFCOyepW4HeODDbwk1E810B+jp4TWe/U9w3DFXZ+D99wZEwwgu9K6XS8D6KV30rg50qpt/YvNwquB952fi/HoOdoDOOMcY81jBgROQ0dKvlqpRPBGAyGKYBRFAaDwWAYFmN6MhgMBsOwGEVhMBgMhmExisJgMBgMw2IUhcFgMBiGxSgKg8FgMAyLURQGg8FgGBajKAwGg8EwLP8frESX0rARZRUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.ylabel('Natl Saving Rate')\n", + "plt.xlabel('Quarters Since Economic Reforms')\n", + "plt.plot(quarters_to_plot,NatlSavingsRates[0],label=str(PermShkVarMultipliers[0]) + ' x variance')\n", + "plt.plot(quarters_to_plot,NatlSavingsRates[1],label=str(PermShkVarMultipliers[1]) + ' x variance')\n", + "plt.plot(quarters_to_plot,NatlSavingsRates[2],label=str(PermShkVarMultipliers[2]) + ' x variance')\n", + "plt.plot(quarters_to_plot,NatlSavingsRates[3],label=str(PermShkVarMultipliers[3]) + ' x variance')\n", + "plt.plot(quarters_to_plot,NatlSavingsRates[4],label=str(PermShkVarMultipliers[4]) + ' x variance')\n", + "plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3,\n", + "ncol=2, mode=\"expand\", borderaxespad=0.) #put the legend on top\n", + "plt.show(block=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The figure shows that, if the rate of growth increases the way Chinese growth did, but is not accompanied by any change in the degree of uncertainty, the model's predicted saving rate declines drastically, from an initial (calibrated) value of about 0.1 (ten percent) to close to zero. For this model to have any hope of predicting an increase in the saving rate, it is clear that the increase in uncertainty that accompanies the increase in growth will have to be substantial. \n", + "\n", + "The red line shows that a mere doubling of uncertainty from its baseline value is not enough: The steady state saving rate is still below its slow-growth value.\n", + "\n", + "When we assume that the degree of uncertainty quadruples, the model does finally predict that the new steady-state saving rate will be higher than before, but not much higher, and not remotely approaching 25 percent.\n", + "\n", + "Only when the degree of uncertainty increases by a factor of 8 is the model capable of producing a new equilbrium saving rate in the ballpark of the Chinese value. \n", + "\n", + "But this is getting close to a point where the model starts to break down (for both numerical and conceptual reasons), as shown by the erratic path of the saving rate when we multiply the initial variance by 11. \n", + "\n", + "We do not have historical data on the magnitude of permanent income shocks in China in the pre-1978 period; it would be remarkable if the degree of uncertainty increased by such a large amount, but in the absence of good data it is hard to know for sure. \n", + "\n", + "What the experiment does demonstrate, though, is that it is _not_ the case that \"it is easy to explain anything by invoking some plausible but unmeasurable change in uncertainty.\" Substantial differences in the degree of permanent (or highly persistent) income uncertainty across countries, across periods, and across people have been measured in the literature, and those differences could in principle be compared to differences in saving rates to get a firmer fix on the quantitative importance of the \"precautionary saving\" explanation in the Chinese context." + ] + } + ], + "metadata": { + "jupytext": { + "formats": "ipynb,py:percent" + }, + "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.3" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Documentation/notebooks/DCEGM-Upper-Envelope.ipynb b/Documentation/notebooks/DCEGM-Upper-Envelope.ipynb new file mode 100644 index 000000000..fd58eb4dc --- /dev/null +++ b/Documentation/notebooks/DCEGM-Upper-Envelope.ipynb @@ -0,0 +1,643 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DCEGM Upper Envelope\n", + "## [\"The endogenous grid method for discrete-continuous dynamic choice models with (or without) taste shocks\"](https://onlinelibrary.wiley.com/doi/abs/10.3982/QE643)\n", + "\n", + "

For the following badges: GitHub does not allow click-through redirects; right-click to get the link, then paste into navigation bar

\n", + "\n", + "[![Open in Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/econ-ark/DemARK/master?filepath=notebooks%2FDCEGM-Upper-Envelope.ipynb)\n", + "\n", + "[![Open in CoLab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/econ-ark/DemARK/blob/master/notebooks/DCEGM-Upper-Envelope.ipynb)\n", + "\n", + "\n", + "\n", + "This notebook provides a simple introduction to the upper envelope calculation in the \"DCEGM\" algorithm . It takes the EGM method proposed in , and extends it to the mixed choice (discrete and continuous) case. It handles various constraints. It works on a 1-dimensional problems.\n", + "\n", + "The main challenge in the types of models considered in DCEGM is, that the first order conditions to the Bellman equations are no longer sufficient to find an optimum. Though, they are still necessary in a broad class of models. This means that our EGM step will give us (resource, consumption) pairs that do fulfill the FOCs, but that are sub-optimal (there's another consumption choices for the same initial resources that gives a higher value).\n", + "\n", + "Take a consumption model formulated as:\n", + "$$\n", + "\\max_{\\{c_t\\}^T_{t=1}} \\sum^T_{t=1}\\beta^t\\cdot u(c_t)\n", + "$$\n", + "given some initial condition on $x$ and some laws of motion for the states, though explicit references to states are omitted. Then, if we're in a class of models described in EGM\n", + ", we can show that\n", + "$$\n", + "c_t = {u_{c}}^{-1}[E_t(u_c(c_{t+1}))]\n", + "$$\n", + "uniquely determines an optimal consumption today given the expected marginal utility of consuming tomorrow. However, if there is a another choice in the choice set, and that choice is discrete, we get\n", + "$$\n", + "\\max_{\\{c_t, d_t\\}^T_{t=1}} \\sum^T_{t=1}\\beta^t\\cdot u(c_t, d_t)\n", + "$$\n", + "again given initial conditions and the laws of motion. Then, we can show that\n", + "$$\n", + "c_t = {u_{c}}^{-1}[E_t(u_c(c_{t+1}))]\n", + "$$\n", + "will produce solutions that are necessary but not sufficient. Note, that there is no explicit mentioning of the discrete choices in the expectation, but they obviously vary over the realized states in general. For the optimal consumption, it doesn't matter what the choice is exactly, only what expected marginal utility is tomorrow. The algorithm presented in [1] is designed to take advantage of models with this structure.\n", + "\n", + "To visualize the problem, consider the following pictures that show the output of an EGM step from the model in the REMARK [linkhere]." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# imports\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# here for now, should be\n", + "# from HARK import discontools or whatever name is chosen\n", + "from HARK.interpolation import LinearInterp\n", + "\n", + "def dcegmSegments(x, v):\n", + " \"\"\"\n", + " Find index vectors `rise` and `fall` such that `rise` holds the indices `i`\n", + " such that x[i+1]>x[i] and `fall` holds indices `j` such that either\n", + " - x[j+1] < x[j] or,\n", + " - x[j]>x[j-1] and v[j] x[i-1] # true if grid decreases on index decrement\n", + " val_fell = v[i] < v[i-1] # true if value rises on index decrement\n", + "\n", + " if (ip1_falls and i_rose) or (val_fell and i_rose):\n", + "\n", + " # we are in a region where the endogenous grid is decreasing or\n", + " # the value function rises by stepping back in the grid.\n", + " fall = np.append(fall, i) # add the index to the vector\n", + "\n", + " # We now iterate from the current index onwards until we find point\n", + " # where resources rises again. Unfortunately, we need to check\n", + " # each points, as there can be multiple spells of falling endogenous\n", + " # grids, so we cannot use bisection or some other fast algorithm.\n", + " k = i\n", + " while x[k+1] < x[k]:\n", + " k = k + 1\n", + " # k now holds either the next index the starts a new rising\n", + " # region, or it holds the length of M, `m_len`.\n", + "\n", + " rise = np.append(rise, k)\n", + "\n", + " # Set the index to the point where resources again is rising\n", + " i = k\n", + "\n", + " i = i + 1\n", + "\n", + " fall = np.append(fall, len(v)-1)\n", + "\n", + " return rise, fall\n", + "# think! nanargmax makes everythign super ugly because numpy changed the wraning\n", + "# in all nan slices to a valueerror...it's nans, aaarghgghg\n", + "def calcMultilineEnvelope(M, C, V_T, commonM):\n", + " \"\"\"\n", + " Do the envelope step of the DCEGM algorithm. Takes in market ressources,\n", + " consumption levels, and inverse values from the EGM step. These represent\n", + " (m, c) pairs that solve the necessary first order conditions. This function\n", + " calculates the optimal (m, c, v_t) pairs on the commonM grid.\n", + "\n", + " Parameters\n", + " ----------\n", + " M : np.array\n", + " market ressources from EGM step\n", + " C : np.array\n", + " consumption from EGM step\n", + " V_T : np.array\n", + " transformed values at the EGM grid\n", + " commonM : np.array\n", + " common grid to do upper envelope calculations on\n", + "\n", + " Returns\n", + " -------\n", + "\n", + "\n", + " \"\"\"\n", + " m_len = len(commonM)\n", + " rise, fall = dcegmSegments(M, V_T)\n", + "\n", + " # Add the last point to the vector for convenience below\n", + " num_kinks = len(fall) # number of kinks / falling EGM grids\n", + "\n", + " # Use these segments to sequentially find upper envelopes. commonVARNAME\n", + " # means the VARNAME evaluated on the common grid with a cloumn for each kink\n", + " # discovered in dcegmSegments. This means that commonVARNAME is a matrix\n", + " # common grid length-by-number of segments to consider. In the end, we'll\n", + " # use nanargmax over the columns to pick out the best (transformed) values.\n", + " # This is why we fill the arrays with np.nan's.\n", + " commonV_T = np.empty((m_len, num_kinks))\n", + " commonV_T[:] = np.nan\n", + " commonC = np.empty((m_len, num_kinks))\n", + " commonC[:] = np.nan\n", + "\n", + " # Now, loop over all segments as defined by the \"kinks\" or the combination\n", + " # of \"rise\" and \"fall\" indices. These (rise[j], fall[j]) pairs define regions\n", + " for j in range(num_kinks):\n", + " # Find points in the common grid that are in the range of the points in\n", + " # the interval defined by (rise[j], fall[j]).\n", + " below = M[rise[j]] >= commonM # boolean array of bad indices below\n", + " above = M[fall[j]] <= commonM # boolen array of bad indices above\n", + " in_range = below + above == 0 # pick out elements that are neither\n", + "\n", + " # create range of indices in the input arrays\n", + " idxs = range(rise[j], fall[j]+1)\n", + " # grab ressource values at the relevant indices\n", + " m_idx_j = M[idxs]\n", + "\n", + " # based in in_range, find the relevant ressource values to interpolate\n", + " m_eval = commonM[in_range]\n", + "\n", + " # re-interpolate to common grid\n", + " commonV_T[in_range,j] = LinearInterp(m_idx_j, V_T[idxs], lower_extrap=True)(m_eval)\n", + " commonC[in_range,j] = LinearInterp(m_idx_j, C[idxs], lower_extrap=True)(m_eval) # Interpolat econsumption also. May not be nesserary\n", + " # for each row in the commonV_T matrix, see if all entries are np.nan. This\n", + " # would mean that we have no valid value here, so we want to use this boolean\n", + " # vector to filter out irrelevant entries of commonV_T.\n", + " row_all_nan = np.array([np.all(np.isnan(row)) for row in commonV_T])\n", + " # Now take the max of all these line segments.\n", + " idx_max = np.zeros(commonM.size, dtype = int)\n", + " idx_max[row_all_nan == False] = np.nanargmax(commonV_T[row_all_nan == False], axis=1)\n", + "\n", + " # prefix with upper for variable that are \"upper enveloped\"\n", + " upperV_T = np.zeros(m_len)\n", + "\n", + " # Set the non-nan rows to the maximum over columns\n", + " upperV_T[row_all_nan == False] = np.nanmax(commonV_T[row_all_nan == False, :], axis=1)\n", + " # Set the rest to nan\n", + " upperV_T[row_all_nan] = np.nan\n", + "\n", + " # Add the zero point in the bottom\n", + " if np.isnan(upperV_T[0]):\n", + " # in transformed space space, utility of zero-consumption (-inf) is 0.0\n", + " upperV_T[0] = 0.0\n", + " # commonM[0] is typically 0, so this is safe, but maybe it should be 0.0\n", + " commonC[0] = commonM[0]\n", + "\n", + " # Extrapolate if NaNs are introduced due to the common grid\n", + " # going outside all the sub-line segments\n", + " IsNaN = np.isnan(upperV_T)\n", + " upperV_T[IsNaN] = LinearInterp(commonM[IsNaN == False], upperV_T[IsNaN == False])(commonM[IsNaN])\n", + "\n", + "\n", + " LastBeforeNaN = np.append(np.diff(IsNaN)>0, 0)\n", + " LastId = LastBeforeNaN*idx_max # Find last id-number\n", + " idx_max[IsNaN] = LastId[IsNaN]\n", + " # Linear index used to get optimal consumption based on \"id\" from max\n", + " ncols = commonC.shape[1]\n", + " rowidx = np.cumsum(ncols*np.ones(len(commonM), dtype=int))-ncols\n", + " idx_linear = np.unravel_index(rowidx+idx_max, commonC.shape)\n", + " upperC = commonC[idx_linear]\n", + " upperC[IsNaN] = LinearInterp(commonM[IsNaN==0], upperC[IsNaN==0])(commonM[IsNaN])\n", + "\n", + " # TODO calculate cross points of line segments to get the true vertical drops\n", + "\n", + " upperM = commonM.copy() # anticipate this TODO\n", + "\n", + " return upperM, upperC, upperV_T\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "m_common = np.linspace(0,1.0,100)\n", + "m_egm = np.array([0.0, 0.04, 0.25, 0.15, 0.1, 0.3, 0.6,0.5, 0.35, 0.6, 0.75,0.85])\n", + "c_egm = np.array([0.0, 0.03, 0.1, 0.07, 0.05, 0.36, 0.4, 0.6, 0.8, 0.9,0.9,0.9])\n", + "vt_egm = np.array( [0.0, 0.05, 0.1,0.04, 0.02,0.2, 0.7, 0.5, 0.2, 0.9, 1.0, 1.2])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0,0.5,'transformed values')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(m_egm, vt_egm)\n", + "plt.xlabel(\"resources\")\n", + "plt.ylabel(\"transformed values\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0,0.5,'consumption')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(m_egm, c_egm)\n", + "plt.xlabel(\"resources\")\n", + "plt.ylabel(\"consumption\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The point of DCEGM is to realize, that the segments on the `(m, vt)` curve that are decreasing, cannot be optimal. This leaves us with a set of increasing line segments, as seen below (`dcegmSegments` is the function in HARK that calculates the breaks where the curve goes from increasing to decreasing)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "rise, fall = dcegmSegments(m_egm, vt_egm)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In `rise` we have all the starting indices for the segments that are \"good\", that is `(m, vt)` draws an increasing curve." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 4, 8])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rise" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that `rise` has its first index at `0`, then again at `4`, and lastly at `8`. Let's look at `fall`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 2, 6, 11])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fall" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that the last segment is increasing (as the last element of `rise` is larger than the last element of `fall`), and we see that `len(fall)` is one larger than number of problematic segments in the plot. The index of the last point in `m_egm`/`c_egm`/`vt_egm` is added for convenience when we do the upper envelope step (and is also convenient below for drawing the segments!).\n", + "\n", + "We can use `fall` and `rise` to draw only the relevant segments that we will use to construct an upper envelope." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0,0.5,'transformed values')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for j in range(len(fall)):\n", + " idx = range(rise[j],fall[j]+1)\n", + " plt.plot(m_egm[idx], vt_egm[idx])\n", + "plt.xlabel(\"resources\")\n", + "plt.ylabel(\"transformed values\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us now use the `calcMultilineEnvelope` function to do the full DCEGM step: find segments and calculate upper envelope in one sweep." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "m_upper, c_upper, v_upper = calcMultilineEnvelope(m_egm, c_egm, vt_egm, m_common)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0,0.5,'transformed values')" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for j in range(len(fall)):\n", + " idx = range(rise[j],fall[j]+1)\n", + " plt.plot(m_egm[idx], vt_egm[idx])\n", + "plt.plot(m_upper, v_upper, 'k')\n", + "plt.xlabel(\"resources\")\n", + "plt.ylabel(\"transformed values\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And there we have it! These functions are the building blocks for univariate discrete choice modeling in HARK, so hopefully this little demo helped better understand what goes on under the hood, or it was a help if you're extending some existing class with a discrete choice." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# References\n", + "[1] Iskhakov, F. , Jørgensen, T. H., Rust, J. and Schjerning, B. (2017), The endogenous grid method for discrete‐continuous dynamic choice models with (or without) taste shocks. Quantitative Economics, 8: 317-365. doi:10.3982/QE643\n", + "\n", + "[2] Carroll, C. D. (2006). The method of endogenous gridpoints for solving dynamic stochastic optimization problems. Economics letters, 91(3), 312-320.\n", + "\n" + ] + } + ], + "metadata": { + "cite2c": { + "citations": { + "6202365/4F64GG8F": { + "DOI": "10.3982/QE643", + "URL": "https://onlinelibrary.wiley.com/doi/abs/10.3982/QE643", + "abstract": "We present a fast and accurate computational method for solving and estimating a class of dynamic programming models with discrete and continuous choice variables. The solution method we develop for structural estimation extends the endogenous grid-point method (EGM) to discrete-continuous (DC) problems. Discrete choices can lead to kinks in the value functions and discontinuities in the optimal policy rules, greatly complicating the solution of the model. We show how these problems are ameliorated in the presence of additive choice-specific independent and identically distributed extreme value taste shocks that are typically interpreted as “unobserved state variables” in structural econometric applications, or serve as “random noise” to smooth out kinks in the value functions in numerical applications. We present Monte Carlo experiments that demonstrate the reliability and efficiency of the DC-EGM algorithm and the associated maximum likelihood estimator for structural estimation of a life-cycle model of consumption with discrete retirement decisions.", + "accessed": { + "day": 21, + "month": 3, + "year": 2019 + }, + "author": [ + { + "family": "Iskhakov", + "given": "Fedor" + }, + { + "family": "Jørgensen", + "given": "Thomas H." + }, + { + "family": "Rust", + "given": "John" + }, + { + "family": "Schjerning", + "given": "Bertel" + } + ], + "container-title": "Quantitative Economics", + "id": "6202365/4F64GG8F", + "issue": "2", + "issued": { + "year": 2017 + }, + "language": "en", + "note": "bibtex:ijrsDCEGM2017\n\nhttps://github.com/econ-ark/REMARK/blob/master/remarks\n\nhttps://github.com/econ-ark/DemARK/blob/master/notebooks\n\nfrom HARK import DCEGM", + "page": "317-365", + "page-first": "317", + "title": "The endogenous grid method for discrete-continuous dynamic choice models with (or without) taste shocks", + "type": "article-journal", + "volume": "8" + }, + "6202365/HQ6H9JEI": { + "DOI": "10.1016/j.econlet.2005.09.013", + "URL": "http://econ.jhu.edu/people/ccarroll/EndogenousArchive.zip", + "author": [ + { + "family": "Carroll", + "given": "Christopher D." + } + ], + "container-title": "Economics Letters", + "id": "6202365/HQ6H9JEI", + "issued": { + "month": 9, + "year": 2006 + }, + "page": "312–320", + "page-first": "312", + "title": "The Method of Endogenous Gridpoints for Solving Dynamic Stochastic Optimization Problems", + "type": "article-journal" + } + } + }, + "jupytext": { + "cell_metadata_filter": "collapsed", + "formats": "ipynb,py:light", + "rst2md": false + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.7" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Documentation/notebooks/Fashion-Victim-Model.ipynb b/Documentation/notebooks/Fashion-Victim-Model.ipynb new file mode 100644 index 000000000..35ffb2c21 --- /dev/null +++ b/Documentation/notebooks/Fashion-Victim-Model.ipynb @@ -0,0 +1,469 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fashion Victim Model\n", + "Specifies a dynamic model of fashion selection in a world with only two styles:\n", + "jock and punk. Forward-looking agents receive utility from the style they choose\n", + "based on the proportion of the population with the same style (as well as direct\n", + "preferences each style), and pay switching costs if they change." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# This cell has just a bit of initial setup. You can click the triangle to the left to expand it.\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", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# The first step is to be able to bring things in from different directories\n", + "import sys \n", + "import os\n", + "\n", + "sys.path.insert(0, os.path.abspath('../../.'))\n", + "\n", + "import numpy as np\n", + "from time import clock\n", + "from copy import deepcopy\n", + "\n", + "from HARK.core import AgentType, Solution, NullFunc\n", + "from HARK.interpolation import LinearInterp\n", + "from HARK.utilities import approxUniform, plotFuncs\n", + "import scipy.stats as stats\n", + "from copy import copy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## FashionVictimType" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This module defines a subclass of AgentType called FashionVictimType." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from HARK.FashionVictim.FashionVictimModel import FashionVictimType" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each period, fashion victims make a binary choice of style $s$: to dress as a jock (0) or punk (1). They receive utility directly from the outfit they wear and as a function of the proportion of the population who $\\textit{just wore}$ the same style; they also pay switching costs ($c_{pj}$,$c_{jp}$) if they change styles rather than keep the same as the previous period. Moreover, they receive an idiosyncratic type 1 extreme value (T1EV) preference shock to each style in each period.\n", + "\n", + "Defining the population punk proportion as $p$ and the conformity utility function as $f:[0,1]\\rightarrow \\mathbb{R}$, the current period utility function is thus:\n", + "\n", + "\\begin{equation*}\n", + "u(s_t;s_{t-1},p_t) = s_t f(p_t) + (1-s_t) f(1-p_t) + s_t U_p + (1-s_t) U_j - c_{pj} s_{t-1}(1-s_t) - c_{jp}(1-s_{t-1})s_t.\n", + "\\end{equation*}\n", + "\n", + "Fashion victims are forward looking and discount future utility at a constant rate of $\\beta$ per period. To simplify the analysis, we assume they believe that the population punk proportion in the next period is a linear function of the punk proportion in the current period, subject to a uniformly distributed shock. No restrictions are put on the function $f$; fashion victims might be conformists who like to dress the same as others ($f'(p) > 0$) or hipsters who like to style themselves in the minority ($f'(p) < 0$).\n", + "\n", + "A fashion victim's problem can be written in Bellman form as:\n", + "\\begin{equation*}\n", + "V(s_{t-1},p_t) = E \\left[ \\max_{s_t \\in \\{0,1\\}} u(s_t;s_{t-1},p_t) + \\eta_{s_t} + \\beta E \\left[ V(s_t,p_{t+1}) \\right] \\right], \n", + "\\end{equation*}\n", + "\n", + "\\begin{equation*}\n", + "p_{t+1} = a p_t + b + \\pi_{t+1}, \\qquad \\pi_{t+1} \\sim U[-w,w], \\qquad \\eta_0,\\eta_1 \\sim T1EV.\n", + "\\end{equation*}\n", + "\n", + "An instance of $\\texttt{FashionVictimType}$ is thus characterized by values of $U_p$, $U_j$, $c_{pj}$, $c_{jp}$ and a function $f$, as well as beliefs about $p_{t+1}$ as a function of $p_t$ (summarized by slope $a$, intercept $b$, and uniform shock width $w$). Given this information, a $\\texttt{FashionVictimType}$'s infinite horizon microeconomic model can be solved by backward induction in a few lines; the \"one period solver\" is given by $\\texttt{solveFashion}$. However, while individual agents treat the dynamics of $p_t$ as exogenous, they are in fact endogenously determined by the actions of all the fashion victims in the market. A dynamic general equilibrium of the \"macroeconomic fashion model\" is thus characterized by a triple of $(a,b,w)$ such that when fashion victims believe in this \"punk evolution rule\" and act optimally, their collective fashion choices exhibit this same rule when the model is simulated.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Solving FashionVictimType's Micro Model\n", + "\n", + "First we will define the parameters for test object which is an instance of FashionVictimType." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + "Defines some default parameters for the fashion victim model.\n", + "'''\n", + "\n", + "DiscFac = 0.95 # Intertemporal discount factor\n", + "uParamA = 1.0 # Parameter A in the utility function (pdf of the beta distribution)\n", + "uParamB = 5.0 # Parameter B in the utility function (pdf of the beta distribution)\n", + "punk_utility = 0.0 # Direct utility received from dressing as a punk\n", + "jock_utility = 0.0 # Direct utility received from dressing as a jock\n", + "switchcost_J2P = 2.0 # Cost of switching from jock to punk\n", + "switchcost_P2J = 2.0 # Cost of switching from punk to jock\n", + "pCount = 51 # Number of points in the grid of population punk proportion values\n", + "pref_shock_mag = 0.5 # Scaling factor for the magnitude of transitory style preference shocks\n", + "pNextIntercept = 0.1 # Intercept of linear function of beliefs over next period's punk proportion\n", + "pNextSlope = 0.8 # Slope of linear function of beliefs over next period's punk proportion\n", + "pNextWidth = 0.1 # Width of uniform distribution of next period's punk proportion (around linear function)\n", + "pNextCount = 10 # Number of points in discrete approximation to distribution of next period's p\n", + "pop_size = 20 # Number of fashion victims of this type (for simulation)\n", + "p_init = 0.5 # Probability of being dressed as a punk when the simulation begins\n", + "\n", + "# Make a dictionary for convenient type creation\n", + "default_params={'DiscFac' : DiscFac,\n", + " 'uParamA' : uParamA,\n", + " 'uParamB' : uParamB,\n", + " 'punk_utility' : punk_utility,\n", + " 'jock_utility' : jock_utility,\n", + " 'switchcost_J2P': switchcost_J2P,\n", + " 'switchcost_P2J': switchcost_P2J,\n", + " 'pCount' : pCount,\n", + " 'pref_shock_mag': pref_shock_mag,\n", + " 'pNextIntercept': pNextIntercept,\n", + " 'pNextSlope' : pNextSlope,\n", + " 'pNextWidth' : pNextWidth,\n", + " 'pNextCount' : pNextCount,\n", + " 'pop_size' : pop_size,\n", + " 'p_init' : p_init\n", + " }" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we can create our test object via passing previously defined parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Utility function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "TestType = FashionVictimType(**default_params)\n", + "print('Utility function:')\n", + "plotFuncs(TestType.conformUtilityFunc,0,1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To solve the TestType we can simply use solve method." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "TestType.solve()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And here we can observe the solution from illustrations." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jock value function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Punk value function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jock switch probability:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Punk switch probability:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print('Jock value function:')\n", + "plotFuncs(TestType.VfuncJock,0,1)\n", + "print('Punk value function:')\n", + "plotFuncs(TestType.VfuncPunk,0,1)\n", + "print('Jock switch probability:')\n", + "plotFuncs(TestType.switchFuncJock,0,1)\n", + "print('Punk switch probability:')\n", + "plotFuncs(TestType.switchFuncPunk,0,1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creating a list of different FashionVictimTypes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to illustrate the Market class solution of FashionVictimModel we will create a list of different FashionVictimTypes." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Make a list of different types\n", + "\n", + "do_many_types = True\n", + "\n", + "AltType = deepcopy(TestType)\n", + "AltType(uParamA = uParamB, uParamB = uParamA, seed=20)\n", + "AltType.update()\n", + "AltType.solve()\n", + "type_list = [TestType,AltType]\n", + "u_vec = np.linspace(0.02,0.1,5)\n", + "if do_many_types:\n", + " for j in range(u_vec.size):\n", + " ThisType = deepcopy(TestType)\n", + " ThisType(punk_utility=u_vec[j])\n", + " ThisType.solve()\n", + " type_list.append(ThisType)\n", + " ThisType = deepcopy(AltType)\n", + " ThisType(punk_utility=u_vec[j])\n", + " ThisType.solve()\n", + " type_list.append(ThisType)\n", + " for j in range(u_vec.size):\n", + " ThisType = deepcopy(TestType)\n", + " ThisType(jock_utility=u_vec[j])\n", + " ThisType.solve()\n", + " type_list.append(ThisType)\n", + " ThisType = deepcopy(AltType)\n", + " ThisType(jock_utility=u_vec[j])\n", + " ThisType.solve()\n", + " type_list.append(ThisType)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Market class illustration with FashionVictimModel\n", + "\n", + "The search for a dynamic general equilibrium is implemented in HARK's $\\texttt{Market}$ class with the following definitions:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from HARK import Market\n", + "from HARK.FashionVictim.FashionVictimModel import *\n", + "\n", + "TestMarket = Market(agents = type_list,\n", + " sow_vars = ['pNow'],\n", + " reap_vars = ['sNow'],\n", + " track_vars = ['pNow'],\n", + " dyn_vars = ['pNextIntercept','pNextSlope','pNextWidth'],\n", + " millRule = calcPunkProp,\n", + " calcDynamics = calcFashionEvoFunc,\n", + " act_T = 1000,\n", + " tolerance = 0.01)\n", + "TestMarket.pNow_init = 0.5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The $\\texttt{agents}$ attribute has a list of 22 $\\texttt{FashionVictimType}$s, which vary in their values of $U_p$ and $U_j$, and their $f$ functions. The $\\texttt{marketAction}$ method of $\\texttt{FashionVictimType}$ simulates one period of the microeconomic model: each agent receives style preference shocks $\\eta_0$ and $\\eta_1$, sees the current proportion of punks $p_t$ (sown to them as $\\texttt{pNow}$), and chooses which style to wear, storing it in the binary array $\\texttt{sNow}$, an attribute of $\\texttt{self}$.\n", + "\n", + "The $\\texttt{millRule}$ for this market is extremely simple: it flattens the list of binary arrays of individual style choices (gathered in the $\\texttt{reap}$ step) and averages them into a new value of $p_t$, to be tracked as a history and $\\texttt{sow}$n back to the $\\texttt{agents}$ to begin the cycle again. Once a history of 1000 values of $p_t$ has been generated with the $\\texttt{makeHistory}$ method, we can calculate a new dynamic fashion rule with $\\texttt{calcFashionEvoFunc}$ by regressing $p_t$ on $p_{t-1}$, approximating $w$ as twice the standard deviation of prediction errors. The new fashion rule is an instance of the simple $\\text{FashionEvoFunc}$ class, whose only methods are inherited from $\\texttt{HARKobject}$.\n", + "\n", + "When the $\\texttt{solve}$ method is run, the solver successively solves each agent's microeconomic problem, runs the $\\texttt{makeHistory}$ method to generate a 1000 period history of $p_t$, and calculates a new punk evolution rule based on this history; the solver terminates when consecutive rules differ by less than 0.01 in any dimension.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "**** WARNING: could not execute multiThreadCommands in HARK.core.Market.solveAgents() so using the serial version instead. This will likely be slower. The multiTreadCommands() functions failed with the following error: \n", + " : Can't pickle local object 'FashionVictimType.update..'\n", + "0.04893593293339493, 0.9005414551607444, 0.012243114740746353\n", + "0.09235533086634751, 0.8133069068761191, 0.011962938869738713\n", + "0.055365685737197634, 0.88941863954236, 0.007402845496549826\n", + "0.08070081547965641, 0.8375977202286383, 0.011023488070380874\n", + "0.05474767615269671, 0.8913037394272029, 0.00953356057440743\n", + "0.08992523047026851, 0.8197352655506696, 0.009696418991967175\n", + "0.06313485433778238, 0.8730778229434657, 0.007648012727073657\n", + "0.08488337543454288, 0.8296163885000392, 0.009070975601081529\n", + "0.05739902278377279, 0.8848107340745086, 0.008913331878950373\n", + "0.06642881247865662, 0.8675810070933386, 0.011247536007932633\n", + "0.08485806084416148, 0.8312200277180543, 0.008931607555840895\n", + "0.07484499708855857, 0.850208722370796, 0.007720940202511735\n", + "0.075118521029787, 0.8492356900473627, 0.008247594324347584\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "TestMarket.solve()\n", + "plt.plot(TestMarket.pNow_hist)\n", + "plt.show()" + ] + } + ], + "metadata": { + "@webio": { + "lastCommId": "53391959fde74c29b00f11a03042d79b", + "lastKernelId": "7cef222e-7918-4c27-95f5-bc1aa7f21c6f" + }, + "jupytext": { + "formats": "ipynb,py" + }, + "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.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Documentation/notebooks/Gentle-Intro-To-HARK-Buffer-Stock-Model.ipynb b/Documentation/notebooks/Gentle-Intro-To-HARK-Buffer-Stock-Model.ipynb new file mode 100644 index 000000000..3529a3b89 --- /dev/null +++ b/Documentation/notebooks/Gentle-Intro-To-HARK-Buffer-Stock-Model.ipynb @@ -0,0 +1,223 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A Gentle Introduction to Buffer Stock Saving \n", + "\n", + "This notebook explores the behavior of a consumer identical to the perfect foresight consumer described in \"A Gentle Introduction,\" except that now the model incorporates income uncertainty.\n", + "\n", + "Specifically, our new type of consumer receives two income shocks at the beginning of each period: a completely transitory shock $\\theta_t$ and a completely permanent shock $\\psi_t$. Moreover, lenders will not let the agent borrow money such that his ratio of end-of-period assets $A_t$ to permanent income $P_t$ is less than $\\underline{a}$. As with the perfect foresight problem, this model can be framed in terms of $\\textit{normalized}$ variables, e.g. $m_t \\equiv M_t/P_t$. (See [here](http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/) for all the theory).\n", + "\n", + "\\begin{eqnarray*}\n", + "v_t(m_t) &=& \\max_{c_t} U(c_t) + \\beta (1 - \\mathsf{D}_{t+1}) \\mathbb{E} [(\\Gamma_{t+1}\\psi_{t+1})^{1-\\rho} v_{t+1}(m_{t+1}) ], \\\\\n", + "a_t &=& m_t - c_t, \\\\\n", + "a_t &\\geq& \\underline{a}, \\\\\n", + "m_{t+1} &=& R/(\\Gamma_{t+1} \\psi_{t+1}) a_t + \\theta_{t+1}, \\\\\n", + "(\\psi_t,\\theta_t) \\sim F_{t}, &\\qquad& \\mathbb{E} [F_{\\psi t}] = 1, \\\\\n", + "U(c) &=& \\frac{c^{1-\\rho}}{1-\\rho}.\n", + "\\end{eqnarray*}\n", + "\n", + "HARK represents agents with this kind of problem as instances of the class $\\texttt{IndShockConsumerType}$. To create an $\\texttt{IndShockConsumerType}$, we must specify the same set of parameters as for a $\\texttt{PerfForesightConsumerType}$, as well as an artificial borrowing constraint $\\underline{a}$ and a sequence of income shock distributions $\\{F_t\\}$. It's easy enough to pick a borrowing constraint-- say, zero-- but how would we specify $F_t$? Can't the joint distribution of permanent and transitory shocks be just about anything?\n", + "\n", + "$\\textit{Yes}$, and HARK can handle that. However, the default behavior of $\\texttt{IndShockConsumerType}$ is that the distribution of permanent income shocks is mean one lognormal, and the distribution of transitory shocks is mean one lognormal with a point mass representing unemployment. The distributions are independent of each other by default, and are approximated with $N$ point equiprobable distributions.\n", + "\n", + "Let's make an infinite horizon instance of $\\texttt{IndShockConsumerType}$ with the same parameters as our original perfect foresight agent, plus the extra parameters to specify the income shock distribution and the artificial borrowing constraint. As before, we'll make a dictionary:\n", + "\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$ | 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", + "| $\\mho$ | Unemployment probability | $\\texttt{UnempPrb}$ | 0.05 |\n", + "| $\\underline{\\theta}$ | Transitory shock when unemployed | $\\texttt{IncUnemp}$ | 0.3 |" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# This cell has just a bit of initial setup. You can click the triangle to the left to expand it.\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", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# The first step is to be able to bring things in from different directories\n", + "import sys \n", + "import os\n", + "\n", + "sys.path.insert(0, os.path.abspath('../lib'))\n", + "\n", + "from util import log_progress\n", + "\n", + "import numpy as np\n", + "import HARK \n", + "from time import clock\n", + "from copy import deepcopy\n", + "mystr = lambda number : \"{:.4f}\".format(number)\n", + "from HARK.utilities import plotFuncs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "code_folding": [ + 0, + 2 + ] + }, + "outputs": [], + "source": [ + "# This cell defines a parameter dictionary for making an instance of IndShockConsumerType.\n", + "\n", + "IndShockDictionary = {\n", + " 'CRRA': 2.5, # The dictionary includes our original parameters...\n", + " 'Rfree': 1.03,\n", + " 'DiscFac': 0.96,\n", + " 'LivPrb': [0.98],\n", + " 'PermGroFac': [1.01],\n", + " 'PermShkStd': [0.1], # ... and 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,\n", + " 'BoroCnstArt': 0.0,\n", + " 'aXtraMin': 0.001, # aXtra parameters specify how to construct the grid of assets.\n", + " 'aXtraMax': 50., # Don't worry about these for now\n", + " 'aXtraNestFac': 3,\n", + " 'aXtraCount': 48,\n", + " 'aXtraExtra': [None],\n", + " 'vFuncBool': False, # These booleans indicate whether the value function should be calculated\n", + " 'CubicBool': False, # and whether to use cubic spline interpolation. You can ignore them.\n", + " 'aNrmInitMean' : -10.,\n", + " 'aNrmInitStd' : 0.0, # These parameters specify the (log) distribution of normalized assets\n", + " 'pLvlInitMean' : 0.0, # and permanent income for agents at \"birth\". They are only relevant in\n", + " 'pLvlInitStd' : 0.0, # simulation and you don't need to worry about them.\n", + " 'PermGroFacAgg' : 1.0,\n", + " 'T_retire': 0, # What's this about retirement? ConsIndShock is set up to be able to\n", + " 'UnempPrbRet': 0.0, # handle lifecycle models as well as infinite horizon problems. Swapping\n", + " 'IncUnempRet': 0.0, # out the structure of the income process is easy, but ignore for now.\n", + " 'T_age' : None,\n", + " 'T_cycle' : 1,\n", + " 'cycles' : 0,\n", + " 'AgentCount': 10000,\n", + " 'tax_rate':0.0,\n", + "}\n", + " \n", + "# Hey, there's a lot of parameters we didn't tell you about! Yes, but you don't need to\n", + "# think about them for now." + ] + }, + { + "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": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n", + "IndShockExample = IndShockConsumerType(**IndShockDictionary)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can solve our new agent's problem just like before, using the $\\texttt{solve}$ method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "IndShockExample.solve()\n", + "plotFuncs(IndShockExample.solution[0].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 numeric 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 $\\textbf{constructor}$ or $\\textbf{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 $\\textit{almost}$ true-- there's one extra step. $\\texttt{TranShkStd}$ is a primitive input, but it's not the thing you $\\textit{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": null, + "metadata": {}, + "outputs": [], + "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": null, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# Use the line(s) below to plot the consumptions functions against each other\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Documentation/notebooks/Gentle-Intro-To-HARK-PerfForesightCRRA.ipynb b/Documentation/notebooks/Gentle-Intro-To-HARK-PerfForesightCRRA.ipynb new file mode 100644 index 000000000..ba449d567 --- /dev/null +++ b/Documentation/notebooks/Gentle-Intro-To-HARK-PerfForesightCRRA.ipynb @@ -0,0 +1,374 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A Gentle Introduction to HARK In Perfect Foresight\n", + "\n", + "This notebook provides a simple, hands-on tutorial for first time HARK users -- and potentially first time Python users. It does not go \"into the weeds\" - we have hidden some code cells that do boring things that you don't need to digest on your first experience with HARK. Our aim is to convey a feel for how the toolkit works.\n", + "\n", + "For readers for whom this is your very first experience with Python, we have put important Python concepts in \\textbf{boldface}. \n", + "\n", + "For those for whom this is the first time they have used a Jupyter notebook, we have put Jupyter instructions in \\textit{italics}. Only cursory definitions (if any) are provided here. If you want to learn more, there are many online Python and Jupyter tutorials." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# This cell has just a bit of initial setup. You can click the triangle to the left to expand it.\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", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# The first step is to be able to bring things in from different directories\n", + "import sys \n", + "import os\n", + "\n", + "sys.path.insert(0, os.path.abspath('../lib'))\n", + "\n", + "from util import log_progress\n", + "\n", + "import numpy as np\n", + "import HARK \n", + "from time import clock\n", + "from copy import deepcopy\n", + "mystr = lambda number : \"{:.4f}\".format(number)\n", + "from HARK.utilities import plotFuncs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Your First HARK Model: Perfect Foresight\n", + "\n", + "We start with almost the simplest possible consumption model: A consumer with CRRA utility $U(C) = \\frac{C^{1-\\rho}}{1-\\rho}$ has perfect foresight about everything except the (stochastic) date of death, which occurs with probability $\\mathsf{D}$, implying a \"survival probability\" $(1-\\mathsf{D}) < 1$. Permanent labor income $P_t$ grows from period to period by a factor $\\Gamma_t$. At the beginning of each period $t$, the consumer has some amount of market resources $M_t$ (which includes both market wealth and currrent income) and must choose how much of those resources to consume $C_t$ and how much to retain in a riskless asset $A_t$ which will earn return factor $R$. The agent receives a flow of utility $U(C_t)$ from consumption (with CRRA preferences) and geometrically discounts future utility flows by factor $\\beta$. Between periods, the agent dies with probability $\\mathsf{D}_t$, ending his problem.\n", + "\n", + "The agent's problem can be written in Bellman form as:\n", + "\n", + "\\begin{eqnarray*}\n", + "V_t(M_t,P_t) &=& \\max_{C_t} U(C_t) + \\beta (1-\\mathsf{D}_{t+1}) V_{t+1}(M_{t+1},P_{t+1}), \\\\\n", + "& s.t. & \\\\\n", + "%A_t &=& M_t - C_t, \\\\\n", + "M_{t+1} &=& R (M_{t}-C_{t}) + Y_{t+1}, \\\\\n", + "P_{t+1} &=& \\Gamma_{t+1} P_t, \\\\\n", + "\\end{eqnarray*}\n", + "\n", + "A particular perfect foresight agent's problem can be characterized by values of risk aversion $\\rho$, discount factor $\\beta$, and return factor $R$, along with sequences of income growth factors $\\{ \\Gamma_t \\}$ and death probabilities $\\{\\mathsf{D}_t\\}$. To keep things simple, let's forget about \"sequences\" of income growth and mortality, and just think about an \\textit{infinite horizon} consumer with constant income growth and survival probability.\n", + "\n", + "## Representing Agents in HARK\n", + "\n", + "HARK represents agents solving this type of problem as \\textbf{instances} of the \\textbf{class} $\\texttt{PerfForesightConsumerType}$, a \\textbf{subclass} of $\\texttt{AgentType}$. To make agents of this class, we must import the class itself into our workspace. (Run the cell below in order to do this)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The $\\texttt{PerfForesightConsumerType}$ class contains within itself the python code that constructs the solution for the perfect foresight model we are studying here, as specifically articulated in [these lecture notes](http://econ.jhu.edu/people/ccarroll/public/lecturenotes/consumption/PerfForesightCRRA/). \n", + "\n", + "To create an instance of $\\texttt{PerfForesightConsumerType}$, we simply call the class as if it were a function, passing as arguments the specific parameter values we want it to have. In the hidden cell below, we define a \\textbf{dictionary} named $\\texttt{PF_dictionary}$ with these parameter values:\n", + "\n", + "| Param | Description | Code | Value |\n", + "| :---: | --- | --- | --- | \n", + "| $\\rho$ | Relative risk aversion | $\\texttt{CRRA}$ | 2.5 |\n", + "| $\\beta$ | Discount factor | $\\texttt{DiscFac}$ | 0.96 |\n", + "| $R$ | Risk free interest factor | $\\texttt{Rfree}$ | 1.03 |\n", + "| $1 - \\mathsf{D}$ | Survival probability | $\\texttt{LivPrb}$ | 0.98 |\n", + "| $\\Gamma$ | Income growth factor | $\\texttt{PermGroFac}$ | 1.01 |\n", + "\n", + "\n", + "For now, don't worry about the specifics of dictionaries. All you need to know is that a dictionary lets us pass many arguments wrapped up in one simple data structure." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "code_folding": [], + "collapsed": true + }, + "outputs": [], + "source": [ + "# This cell defines a parameter dictionary. You can expand it if you want to see what that looks like.\n", + "PF_dictionary = {\n", + " 'CRRA' : 2.5,\n", + " 'DiscFac' : 0.96,\n", + " 'Rfree' : 1.03,\n", + " 'LivPrb' : [0.98],\n", + " 'PermGroFac' : [1.01],\n", + " 'T_cycle' : 1,\n", + " 'cycles' : 0,\n", + " 'AgentCount' : 10000\n", + "}\n", + "\n", + "# To those curious enough to open this hidden cell, you might notice that we defined\n", + "# a few extra parameters in that dictionary: T_cycle, cycles, and AgentCount. Don't\n", + "# worry about these for now." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's make an \\textbf{object} named $\\texttt{PFexample}$ which is an \\textbf{instance} of the $\\texttt{PerfForesightConsumerType}$ class. The object $\\texttt{PFexample}$ will bundle together the abstract mathematical description of the solution embodied in $\\texttt{PerfForesightConsumerType}$, and the specific set of parameter values defined in $\\texttt{PF_dictionary}$. Such a bundle is created passing $\\texttt{PF_dictionary}$ to the class $\\texttt{PerfForesightConsumerType}$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "PFexample = PerfForesightConsumerType(**PF_dictionary) \n", + "# the asterisks ** basically say \"here come some arguments\" to PerfForesightConsumerType" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In $\\texttt{PFexample}$, we now have _defined_ the problem of a particular infinite horizon perfect foresight consumer who knows how to solve this problem. \n", + "\n", + "## Solving an Agent's Problem\n", + "\n", + "To tell the agent actually to solve the problem, we call the agent's $\\texttt{solve}$ \\textbf{method}. (A \\textbf{method} is essentially a function that an object runs that affects the object's own internal characteristics -- in this case, the method adds the consumption function to the contents of $\\texttt{PFexample}$.)\n", + "\n", + "The cell below calls the $\\texttt{solve}$ method for $\\texttt{PFexample}$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "PFexample.solve()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Running the $\\texttt{solve}$ method creates the \\textbf{attribute} of $\\texttt{PFexample}$ named $\\texttt{solution}.$ In fact, every subclass of $\\texttt{AgentType}$ works the same way: The class definition contains the abstract algorithm that knows how to solve the model, but to obtain the particular solution for a specific instance (paramterization/configuration), that instance must be instructed to $\\texttt{solve()}$ its problem. \n", + "\n", + "The $\\texttt{solution}$ attribute is always a \\textit{list} of solutions to a single period of the problem. In the case of an infinite horizon model like the one here, there is just one element in that list -- the solution to all periods of the infinite horizon problem. The consumption function stored as the first element (element 0) of the solution list can be retrieved by:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "PFexample.solution[0].cFunc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One of the results proven in the associated [the lecture notes](http://econ.jhu.edu/people/ccarroll/public/lecturenotes/consumption/PerfForesightCRRA/) is that, for the specific problem defined above, there is a solution in which the _ratio_ $c = C/P$ is a linear function of the _ratio_ of market resources to permanent income, $m = M/P$. \n", + "\n", + "This is why $\\texttt{cFunc}$ can be represented by a linear interpolation. It can be plotted using the command below:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mPlotTop=10\n", + "plotFuncs(PFexample.solution[0].cFunc,0.,mPlotTop)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The figure illustrates one of the surprising features of the perfect foresight model: A person with zero money should be spending at a rate more than double their income ($\\texttt{cFunc}(0.) \\approx 2.08$). What gives?\n", + "\n", + "The answer is that we have not incorporated any constraint that would prevent the agent from borrowing against the entire PDV of future earnings -- human wealth. \n", + "\n", + "How much is that? An equivalent question is: What's the minimum value of $m_t$ where the consumption function is defined (that is, where the consumer has a positive expected _total wealth_ (the sum of human and nonuman wealth)? Let's check:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "humanWealth = PFexample.solution[0].hNrm\n", + "mMinimum = PFexample.solution[0].mNrmMin\n", + "print(\"This agent's human wealth is \" + str(humanWealth) + ' times his current income level.')\n", + "print(\"This agent's consumption function is defined down to m_t = \" + str(mMinimum))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Yikes! Let's take a look at the bottom of the consumption function. In the cell below, set the bounds of the $\\texttt{plotFuncs}$ function to display down to the lowest defined value of the consumption function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# YOUR FIRST HANDS-ON EXERCISE!\n", + "# Fill in the value for \"mPlotBottom\" to plot the consumption function from the point where it is zero.\n", + "plotFuncs(PFexample.solution[0].cFunc,mPlotBottom,mPlotTop)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Changing Agent Parameters\n", + "\n", + "Suppose you wanted to change one (or more) of the parameters of the agent's problem and see what that does. We want to compare consumption functions before and after we change parameters, so let's make a new instance of $\\texttt{PerfForesightConsumerType}$ by copying $\\texttt{PFexample}$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "NewExample = deepcopy(PFexample)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In Python, you can set an \\textbf{attribute} of an object just like any other variable. For example, we could make the new agent less patient:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "NewExample.DiscFac = 0.90\n", + "NewExample.solve()\n", + "mPlotBottom = mMinimum\n", + "plotFuncs([PFexample.solution[0].cFunc,NewExample.solution[0].cFunc],mPlotBottom,mPlotTop)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(Note that you can pass a list of functions to $\\texttt{plotFuncs}$ as the first argument rather than just a single function. Lists are written inside of [square brackets].)\n", + "\n", + "Let's try to deal with the \"problem\" of massive human wealth by making another consumer who has essentially no future income. We can almost eliminate human wealth by making the permanent income growth factor $\\textit{very}$ small.\n", + "\n", + "In $\\texttt{PFexample}$, the agent's income grew by 1 percent per period-- his $\\texttt{PermGroFac}$ took the value 1.01. What if our new agent had a growth factor of 0.01 -- his income \\textit{shrinks} by 99 percent each period? In the cell below, set $\\texttt{NewExample}$'s discount factor back to its original value, then set its $\\texttt{PermGroFac}$ attribute so that the growth factor is 0.01 each period.\n", + "\n", + "Important: Recall that the model at the top of this document said that an agent's problem is characterized by a sequence of income growth factors, but we tabled that concept. Because $\\texttt{PerfForesightConsumerType}$ treats $\\texttt{PermGroFac}$ as a \\textit{time-varying} attribute, it must be specified as a \\textbf{list} (with a single element in this case)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Revert NewExample's discount factor and make his future income minuscule\n", + "your lines here!\n", + "\n", + "# Compare the old and new consumption functions\n", + "plotFuncs([PFexample.solution[0].cFunc,NewExample.solution[0].cFunc],0.,10.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now $\\texttt{NewExample}$'s consumption function has the same slope (MPC) as $\\texttt{PFexample}$, but it emanates from (almost) zero-- he has basically no future income to borrow against!\n", + "\n", + "If you'd like, use the cell above to alter $\\texttt{NewExample}$'s other attributes (relative risk aversion, etc) and see how the consumption function changes. However, keep in mind that _no solution exists_ for some combinations of parameters. HARK should let you know if this is the case if you try to solve such a model.\n", + "\n", + "\n" + ] + } + ], + "metadata": { + "jupytext": { + "formats": "ipynb,py:percent" + }, + "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.3" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Documentation/notebooks/Gentle-Intro-To-HARK.ipynb b/Documentation/notebooks/Gentle-Intro-To-HARK.ipynb deleted file mode 120000 index f27c3cca7..000000000 --- a/Documentation/notebooks/Gentle-Intro-To-HARK.ipynb +++ /dev/null @@ -1 +0,0 @@ -../../Examples/Gentle-Intro-To-HARK.ipynb \ No newline at end of file diff --git a/Documentation/notebooks/Gentle-Intro-To-HARK.ipynb b/Documentation/notebooks/Gentle-Intro-To-HARK.ipynb new file mode 100644 index 000000000..24ffd28a7 --- /dev/null +++ b/Documentation/notebooks/Gentle-Intro-To-HARK.ipynb @@ -0,0 +1,589 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A Gentle Introduction to HARK\n", + "\n", + "This notebook provides a simple, hands-on tutorial for first time HARK users -- and potentially first time Python users. It does not go \"into the weeds\" - we have hidden some code cells that do boring things that you don't need to digest on your first experience with HARK. Our aim is to convey a feel for how the toolkit works.\n", + "\n", + "For readers for whom this is your very first experience with Python, we have put important Python concepts in $\\textbf{boldface}$. For those for whom this is the first time they have used a Jupyter notebook, we have put Jupyter instructions in $\\textit{italics}.$ Only cursory definitions (if any) are provided here. If you want to learn more, there are many online Python and Jupyter tutorials." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# This cell has a bit of initial setup. You can click the triangle to the left to expand it.\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", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# The first step is to be able to bring things in from different directories\n", + "import sys \n", + "import os\n", + "\n", + "sys.path.insert(0, os.path.abspath('../lib'))\n", + "\n", + "from util import log_progress\n", + "\n", + "import numpy as np\n", + "import HARK \n", + "from time import clock\n", + "from copy import deepcopy\n", + "mystr = lambda number : \"{:.4f}\".format(number)\n", + "from HARK.utilities import plotFuncs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Your First HARK Model: Perfect Foresight\n", + "\n", + "$$\\newcommand{\\CRRA}{\\rho}\\newcommand{\\DiscFac}{\\beta}$$\n", + "We start with almost the simplest possible consumption model: A consumer with CRRA utility \n", + "\n", + "\\begin{equation}\n", + "U(C) = \\frac{C^{1-\\CRRA}}{1-\\rho}\n", + "\\end{equation}\n", + "\n", + "has perfect foresight about everything except the (stochastic) date of death, which occurs with constant probability implying a \"survival probability\" $\\newcommand{\\LivPrb}{\\aleph}\\LivPrb < 1$. Permanent labor income $P_t$ grows from period to period by a factor $\\Gamma_t$. At the beginning of each period $t$, the consumer has some amount of market resources $M_t$ (which includes both market wealth and currrent income) and must choose how much of those resources to consume $C_t$ and how much to retain in a riskless asset $A_t$ which will earn return factor $R$. The agent's flow of utility $U(C_t)$ from consumption is geometrically discounted by factor $\\beta$. Between periods, the agent dies with probability $\\mathsf{D}_t$, ending his problem.\n", + "\n", + "The agent's problem can be written in Bellman form as:\n", + "\n", + "\\begin{eqnarray*}\n", + "V_t(M_t,P_t) &=& \\max_{C_t}~U(C_t) + \\beta \\aleph V_{t+1}(M_{t+1},P_{t+1}), \\\\\n", + "& s.t. & \\\\\n", + "%A_t &=& M_t - C_t, \\\\\n", + "M_{t+1} &=& R (M_{t}-C_{t}) + Y_{t+1}, \\\\\n", + "P_{t+1} &=& \\Gamma_{t+1} P_t, \\\\\n", + "\\end{eqnarray*}\n", + "\n", + "A particular perfect foresight agent's problem can be characterized by values of risk aversion $\\rho$, discount factor $\\beta$, and return factor $R$, along with sequences of income growth factors $\\{ \\Gamma_t \\}$ and survival probabilities $\\{\\mathsf{\\aleph}_t\\}$. To keep things simple, let's forget about \"sequences\" of income growth and mortality, and just think about an $\\textit{infinite horizon}$ consumer with constant income growth and survival probability.\n", + "\n", + "## Representing Agents in HARK\n", + "\n", + "HARK represents agents solving this type of problem as $\\textbf{instances}$ of the $\\textbf{class}$ $\\texttt{PerfForesightConsumerType}$, a $\\textbf{subclass}$ of $\\texttt{AgentType}$. To make agents of this class, we must import the class itself into our workspace. (Run the cell below in order to do this)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The $\\texttt{PerfForesightConsumerType}$ class contains within itself the python code that constructs the solution for the perfect foresight model we are studying here, as specifically articulated in [these lecture notes](http://econ.jhu.edu/people/ccarroll/public/lecturenotes/consumption/PerfForesightCRRA/). \n", + "\n", + "To create an instance of $\\texttt{PerfForesightConsumerType}$, we simply call the class as if it were a function, passing as arguments the specific parameter values we want it to have. In the hidden cell below, we define a $\\textbf{dictionary}$ named $\\texttt{PF_dictionary}$ with these parameter values:\n", + "\n", + "| Param | Description | Code | Value |\n", + "| :---: | --- | --- | :---: |\n", + "| $\\rho$ | Relative risk aversion | $\\texttt{CRRA}$ | 2.5 |\n", + "| $\\beta$ | Discount factor | $\\texttt{DiscFac}$ | 0.96 |\n", + "| $R$ | Risk free interest factor | $\\texttt{Rfree}$ | 1.03 |\n", + "| $\\newcommand{\\LivFac}{\\aleph}\\LivFac$ | Survival probability | $\\texttt{LivPrb}$ | 0.98 |\n", + "| $\\Gamma$ | Income growth factor | $\\texttt{PermGroFac}$ | 1.01 |\n", + "\n", + "\n", + "For now, don't worry about the specifics of dictionaries. All you need to know is that a dictionary lets us pass many arguments wrapped up in one simple data structure." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# This cell defines a parameter dictionary. You can expand it if you want to see what that looks like.\n", + "PF_dictionary = {\n", + " 'CRRA' : 2.5,\n", + " 'DiscFac' : 0.96,\n", + " 'Rfree' : 1.03,\n", + " 'LivPrb' : [0.98],\n", + " 'PermGroFac' : [1.01],\n", + " 'T_cycle' : 1,\n", + " 'cycles' : 0,\n", + " 'AgentCount' : 10000\n", + "}\n", + "\n", + "# To those curious enough to open this hidden cell, you might notice that we defined\n", + "# a few extra parameters in that dictionary: T_cycle, cycles, and AgentCount. Don't\n", + "# worry about these for now." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's make an $\\textbf{object}$ named $\\texttt{PFexample}$ which is an $\\textbf{instance}$ of the $\\texttt{PerfForesightConsumerType}$ class. The object $\\texttt{PFexample}$ will bundle together the abstract mathematical description of the solution embodied in $\\texttt{PerfForesightConsumerType}$, and the specific set of parameter values defined in $\\texttt{PF_dictionary}$. Such a bundle is created passing $\\texttt{PF_dictionary}$ to the class $\\texttt{PerfForesightConsumerType}$:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "PFexample = PerfForesightConsumerType(**PF_dictionary) \n", + "# the asterisks ** basically say \"here come some arguments\" to PerfForesightConsumerType" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In $\\texttt{PFexample}$, we now have _defined_ the problem of a particular infinite horizon perfect foresight consumer who knows how to solve this problem. \n", + "\n", + "## Solving an Agent's Problem\n", + "\n", + "To tell the agent actually to solve the problem, we call the agent's $\\texttt{solve}$ $\\textbf{method}$. (A $\\textbf{method}$ is essentially a function that an object runs that affects the object's own internal characteristics -- in this case, the method adds the consumption function to the contents of $\\texttt{PFexample}$.)\n", + "\n", + "The cell below calls the $\\texttt{solve}$ method for $\\texttt{PFexample}$" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "PFexample.solve()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Running the $\\texttt{solve}$ method creates the $\\textbf{attribute}$ of $\\texttt{PFexample}$ named $\\texttt{solution}$. In fact, every subclass of $\\texttt{AgentType}$ works the same way: The class definition contains the abstract algorithm that knows how to solve the model, but to obtain the particular solution for a specific instance (paramterization/configuration), that instance must be instructed to $\\texttt{solve()}$ its problem. \n", + "\n", + "The $\\texttt{solution}$ attribute is always a $\\textit{list}$ of solutions to a single period of the problem. In the case of an infinite horizon model like the one here, there is just one element in that list -- the solution to all periods of the infinite horizon problem. The consumption function stored as the first element (element 0) of the solution list can be retrieved by:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "PFexample.solution[0].cFunc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One of the results proven in the associated [the lecture notes](http://econ.jhu.edu/people/ccarroll/public/lecturenotes/consumption/PerfForesightCRRA/) is that, for the specific problem defined above, there is a solution in which the _ratio_ $c = C/P$ is a linear function of the _ratio_ of market resources to permanent income, $m = M/P$. \n", + "\n", + "This is why $\\texttt{cFunc}$ can be represented by a linear interpolation. It can be plotted between an $m$ ratio of 0 and 10 using the command below." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvDW2N/gAAIABJREFUeJzt3Xl8VPW9//HXlyVAwk4IS0IIexI2gQgo7uLCqlbrUkVt9Ufb69Vqbaul1aRQd0u11o26W63Xq7aGTUBEBXdAFCYLCfsSCGs2ss/n90dyr1wKkkCSM8v7+Xj4YDJzZs7bMXl78p1zPjgzQ0REQlczrwOIiEjjUtGLiIQ4Fb2ISIhT0YuIhDgVvYhIiFPRi4iEOBW9iEiIU9GLiIQ4Fb2ISIhr4dWOo6OjLSEhwavdi4gEpVWrVu01s671eY5nRZ+QkMDKlSu92r2ISFByzm2p73O0dCMiEuJU9CIiIU5FLyIS4o5b9M65Xs65Zc65TOeczzn3i6Nsc45zrsA5t6b2n3sbJ66IiNRXXT6MrQLuNLPVzrl2wCrn3BIzyzhiu+VmNrnhI4qIyMk47hG9meWZ2era20VAJhDb2MFERKRh1GuN3jmXAIwAvjjKw6c5575xzi10zg1ugGwiItIA6nwevXOuLfA2cLuZFR7x8Gqgt5kVO+cmAv8CBhzlNaYD0wHi4+NPOLSISLgxM+avzTuh59bpiN4515Kakn/NzN45SoBCMyuuvb0AaOmciz7KdnPMLMXMUrp2rdeFXSIiYStrVyHX/O1z/vP1r0/o+XU568YBzwOZZjb7GNt0r90O59zo2tfdd0KJREQEgILSStLSfUz6ywqydhXxx0uHnNDr1GXpZhwwDVjrnFtTe98MIB7AzJ4BrgB+7pyrAkqBq83MTiiRiEiY8/uN/161jYffy+bAoQp+NCaeOy8YRKeoCKadwOsdt+jNbAXgjrPNX4G/nsD+RUTkMGu2HST13XV8s72AlN6deHnqaIbEdjip1/RsqJmIiHxnb3E5D7+XxZsrtxPTrhV/vmo4l54SS+2q+ElR0YuIeKiy2s+rn23hz++vp7Simp+e1Zdbzx9A21YNV88qehERj3y6YS9p6T7W7y7mzAHRpE4ZTP+Ytg2+HxW9iEgT23GwlPvnZzJ/bR5xndrw7LRRXJjcrUGWaY5GRS8i0kTKKqt5bvlG/rosFzO4Y/xAfnp2X1q3bN6o+1XRi4g0MjNjaWY+M+dlsHX/ISYM6c7vJiUR1ymySfavohcRaUQb9xQzc14GH2bvoX9MW/5+0xjOGPBvgwMalYpeRKQRlJRX8cQHuTy/YiOtWjTn95OSuOH0BFo2b/q/70lFLyLSgMyM9G928sCCLHYVlnH5yDjumjCImHatPcukohcRaSCZeYWkpvv4ctN+hsZ24MlrRzKqdyevY6noRURO1sFDFcxesp6/f76FDm1a8sAPhnJlSi+aN2uc0yXrS0UvInKCqv3Gf321jUcWZVFQWsl1Y3vzywsG0jEywuto/4eKXkTkBKzacoC0dB9rdxQwOqEzaVMHk9yzvdexjkpFLyJSD/lFZTy0MJu3V2+nW/tWPH71KUwd3rPRrmptCCp6EZE6qKz28/Knm3ns/RzKq6r52dn9uPW8/kQ14PCxxhL4CUVEPLYiZy9pc33k5hdzzqCu3Ds5mb5dG374WGNR0YuIHMP2A4e4b34mC9ftIr5zJM9dn8L5STEBvUxzNCp6EZEjlFVW8+xHG3n6o1wAfnXhQG4+s/GHjzUWFb2ISC0zY3HGbmbNy2D7gVImDe3BjElJxHZs43W0k6KiFxEBNuwpJi3dx/KcvQzs1pbXbx7D6f2bdvhYY1HRi0hYKy6v4omlObzwySZat2jOvZOTmXZab0+GjzUWFb2IhCUz419rdvDAgizyi8q5MiWO31ycSHTbVl5Ha3AqehEJO+t2FJCW7mPllgMMj+vAs9NGMSLe++FjjUVFLyJh40BJBY8uzuYfX26lU2QED10+lB+O6kWzABk+1lhU9CIS8qr9xj++3Mqji7MpKqvi+tMSuOOCgXRo09LraE1CRS8iIW3l5v2kpvvw7SxkbN+a4WOJ3QNz+FhjUdGLSEjKLyzjgYVZ/PPrHfTo0JonrhnB5GE9gu6q1oagoheRkFJR5efFTzbxl6U5VFYbt5zbj1vO7U9kRPjWXfj+m4tIyPl4/R7S5vrYuKeE8xNjuGdyMgnRUV7H8pyKXkSC3rb9h5g1L4PFGbtJ6BLJizeeyrmJMV7HChgqehEJWqUV1Tz90Qae/WgDzZzjNxcP4qYz+tCqRXAOH2ssKnoRCTpmxiLfLmbNy2THwVKmDO/JjImJ9OgQ3MPHGouKXkSCSm5+EWnpGazI3Uti93a8MX0sY/t28TpWQFPRi0hQKCqr5PH3c3jp081ERjQnbUoy143tTYsQGj7WWFT0IhLQ/H7jna938ODCLPaVlHNVSi9+fdEguoTg8LHGoqIXkYC1dnsBqenrWL31IKf06sgLN6YwLK6j17GCjopeRALO/pIKHlmUzRtfbaVLVASPXDGMy0fGhfzwscaioheRgFFV7ef1L7fyp8XrKS6v4ifj+vCL8QNo3zo8ho81FhW9iASELzft595315G1q4jT+3UhbepgBnZr53WskHDconfO9QJeAboDfmCOmT1+jG1PBT4HrjKztxoyqIiEpl0FZdy/IJP0b3YS27ENT107kglDuofl8LHGUpcj+irgTjNb7ZxrB6xyzi0xs4zDN3LONQceAhY1Qk4RCTHlVdW8sGIzT3yQQ5XfuO28/vz8nP60idBVrQ3tuEVvZnlAXu3tIudcJhALZByx6a3A28CpDR1SRELLsux8Zs7NYNPeEi5I7sY9k5KJ7xLpdayQVa81eudcAjAC+OKI+2OBy4DzUNGLyDFs2VfCrHkZvJ+ZT9/oKF768amcM0jDxxpbnYveOdeWmiP2282s8IiHHwPuMrPq71tXc85NB6YDxMfH1z+tiASl0opqnvowl2c/3kjLZo67JyTyk3F9iGihq1qbgjOz42/kXEtgHrDIzGYf5fFNwP80fDRwCJhuZv861mumpKTYypUrTyi0iAQHM2PB2l3cNz+DnQVlXHpKT347MYlu7Vt7HS1oOedWmVlKfZ5Tl7NuHPA8kHm0kgcwsz6Hbf8SMO/7Sl5EQt/63UWkvuvjs437SOrRnseuHsHoPp29jhWW6rJ0Mw6YBqx1zq2pvW8GEA9gZs80UjYRCUIFpZU89v56XvlsC21btWDWJYP50ZjeNNdVrZ6py1k3K/huWea4zOzGkwkkIsHJ7zfeWrWdhxdlsa+kgmtGx/OrCwfROSrC62hhT1fGishJ+2bbQe5N9/HNtoOM6t2Jl348miGxHbyOJbVU9CJywvYWl/PIe9m8uWobXaJaMfvK4Vw2IlZXtQYYFb2I1FtVtZ9XP9/C7CXrKa2o5uYz+nDb+QNop+FjAUlFLyL18tmGfaSl+8jeXcSZA6JJnZJM/xgNHwtkKnoRqZOdB0u5b0Em87/NI7ZjG565bhQXDe6mZZogoKIXke9VXlXNc8s38dcPcvGbcfv4Afzs7H60bqnhY8FCRS8ix7Q0czcz52WwZd8hLhrcjd9PSqZXZw0fCzYqehH5N5v2ljBzro9l2Xvo1zWKV28azZkDunodS06Qil5E/ldJeRVPLsvlueWbiGjRjN9NTOKG0xM0fCzIqehFBDNj7rd53D8/k12FZfxgRCx3T0gkRsPHQoKKXiTMZeYVkpbu44tN+xncsz1PXjuCUb01fCyUqOhFwlTBoUpmL8nm1c+30L5NS+67bAhXnxqv4WMhSEUvEmb8fuPNldt4eFE2Bw9VcO2Y3tx54UA6Rmr4WKhS0YuEka+3HiA13ce32ws4NaETaVNHM7inho+FOhW9SBjYU1TOQ+9l8daq7cS0a8VjV53CJaf01FWtYUJFLxLCKqv9vPLZFh5bsp6yqmp+enZfbj1vAG1b6Uc/nOi/tkiI+jR3L6npPnLyizl7YFfunZJMv65tvY4lHlDRi4SYHQdLuW9+BgvW7qJX5zb87foUxifFaJkmjKnoRUJEWWU1cz7eyFMf5gLwywsGMv2svho+Jip6kWBnZryfmc/MeT627S9l4tDuzJiYRFwnDR+TGip6kSC2cU8xf5ibwUfr9zAgpi2v3TyGcf2jvY4lAUZFLxKEisureOKDHF5YsYnWLZrz+0k1w8daNtfwMfl3KnqRIGJmvLtmJw8szGR3YTlXjIrjrosT6dquldfRJICp6EWChG9nAWnpPr7afIBhcR14+rpRjIzv5HUsCQIqepEAd/BQBX9avJ7XvthCx8gIHvzBUK5M6UUzDR+TOlLRiwSoar/xxldbeXRRNgWllVx/WgJ3jB9Ih8iWXkeTIKOiFwlAq7bsJzXdx7odhYzu05k/TB1MUo/2XseSIKWiFwkg+UVlPLgwi3dW76B7+9b85ZoRTBnWQ1e1yklR0YsEgIoqPy9/upnHl+ZQUeXnP87pxy3n9idKw8ekAei7SMRjy3P2kJbuY8OeEs5LjOGeycn0iY7yOpaEEBW9iEe27T/EH+dnsMi3m95dInn+hhTOT+rmdSwJQSp6kSZWVlnNMx9t4OkPN9DMOX590SBuOqOPho9Jo1HRizQRM2ORbzd/nJ/B9gOlTB7WgxkTk+jZsY3X0STEqehFmkBufjF/mOtjec5eBnVrx+v/bwyn99PwMWkaKnqRRlRUVslflubw4iebaRPRnNQpyUwb25sWGj4mTUhFL9II/H7jn1/v4MH3sthbXM6Vo3rx64sHEd1Ww8ek6anoRRrYuh0FpKb7WLXlAMN7deS561MY3quj17EkjKnoRRrIgZIKHlmczT++3ErnyAgevmIYV4yM0/Ax8ZyKXuQkVfuN17+sGT5WXF7FjacncPv4gXRoo+FjEhiOW/TOuV7AK0B3wA/MMbPHj9jmEmBW7eNVwO1mtqLh44oElq827yf1XR8ZeYWc1rcLaVMHM6h7O69jifwfdTmirwLuNLPVzrl2wCrn3BIzyzhsm6VAupmZc24Y8CaQ2Ah5RQLC7sIyHliQyb/W7KRnh9Y8+aORTBzaXcPHJCAdt+jNLA/Iq71d5JzLBGKBjMO2KT7sKVGANXBOkYBQUeXnhU828cTSHCqrjf88tz//cW4/IiO0CiqBq17fnc65BGAE8MVRHrsMeACIASY1QDaRgPJhdj4z52awcW8J45Nqho/17qLhYxL46lz0zrm2wNvUrL8XHvm4mf0T+Kdz7ixq1uvHH+U1pgPTAeLj4080s0iT2rrvELPmZ7AkYzd9oqN48cencu6gGK9jidRZnYreOdeSmpJ/zcze+b5tzexj51w/51y0me094rE5wByAlJQULe9IQCutqObpD3N55uONtGjmuOviRH5yRgKtWmj4mASXupx144DngUwzm32MbfoDG2o/jB0JRAD7GjSpSBMxMxau28V98zPZcbCUS07pyW8nJNG9Q2uvo4mckLoc0Y8DpgFrnXNrau+bAcQDmNkzwOXA9c65SqAUuMrMdMQuQSdndxFpc318kruPxO7t+K/pYxnTt4vXsUROSl3OulkBfO85Y2b2EPBQQ4USaWqFZZU8tiSHlz/bTFREc2ZeMpgfjY7X8DEJCTonTMKa32+8vXo7D72Xxb6SCq4+NZ5fXzSIzlERXkcTaTAqeglb324/SGq6j6+3HmREfEdevHE0Q+M6eB1LpMGp6CXs7Csu55FF2fzXym10iWrFoz8czg9GxGr4mIQsFb2EjapqP699sZU/Lc7mUEU1N43rw23jB9C+tYaPSWhT0UtY+HzjPtLSfWTtKuKM/tGkTU2mf4yGj0l4UNFLSMsrKOX+BVnM/WYnsR3b8PS1I7l4iIaPSXhR0UtIKq+q5rnlm3hyWS5VfuO28wfw87P70SZCV7VK+FHRS8hZlpXPH+b62LzvEBcmd+Oeycn06hzpdSwRz6joJWRs3lvCrHkZLM3Kp2/XKF75yWjOGtjV61ginlPRS9A7VFHFk8ty+dvHm2jZ3DFjYiI3nt6HiBa6qlUEVPQSxMyMed/mcf+CTPIKyrhsRCx3T0ikW3sNHxM5nIpeglLWrkLS0n18vnE/yT3a88Q1I0hJ6Ox1LJGApKKXoFJQWsmfl6zn1c+30K51C/546RCuGR1Pc13VKnJMKnoJCn6/8d+rtvHwe9nsP1TBj0bH86sLB9FJw8dEjktFLwFvzbaDpL67jm+2F5DSuxMvTx3NkFgNHxOpKxW9BKy9xeU8/F4Wb67cTky7Vvz5quFcekqsrmoVqScVvQScymo/r362hT+/v57Simp+elZfbj1/AG1b6dtV5EToJ0cCyqcb9pKW7mP97mLOHBBN6pTB9I9p63UskaCmopeAsONgKffPz2T+2jziOrXh2WmjuDC5m5ZpRBqAil48VVZZzXPLN/LXZbmYwR3jB/LTs/vSuqWGj4k0FBW9eMLMWJqZz8x5GWzdf4gJQ7rzu0lJxHXS8DGRhqailya3cU8xM+dl8GH2HvrHtOXvN43hjAHRXscSCVkqemkyJeVVPPFBLs+v2EirFs35/aQkbjg9gZbNNXxMpDGp6KXRmRnp3+zkgQVZ7Cos4/KRcdw1YRAx7TR8TKQpqOilUWXmFZKa7uPLTfsZGtuBJ68dyajenbyOJRJWVPTSKA4eqmD2kvX8/fMtdGjTkvsvG8pVp/bS8DERD6jopUFV+403V27j4feyKCit5LqxvfnlBQPpGKnhYyJeUdFLg1m99QCp7/pYu6OA0QmdSZs6mOSe7b2OJRL2VPRy0vKLynhoYTZvr95Ot/atePzqU5g6vKeuahUJECp6OWGV1X5e/nQzj72fQ3lVNT87ux+3ntefKA0fEwko+omUE7IiZy9pc33k5hdzzqCu3Ds5mb5dNXxMJBCp6KVeth84xH3zM1m4bhfxnSN57voUzk+K0TKNSABT0UudlFVW8+xHG3n6o1wAfnXhQG4+U8PHRIKBil6+l5mxOGM3s+ZlsP1AKZOG9mDGpCRiO7bxOpqI1JGKXo5pw55i0tJ9LM/Zy8BubXn95jGc3l/Dx0SCjYpe/k1xeRVPLM3hhU820bpFc+6dnMy003pr+JhIkFLRy/8yM/61ZgcPLMgiv6icK1Pi+M3FiUS3beV1NBE5CSp6AWDdjgLS0n2s3HKA4XEdeHbaKEbEa/iYSChQ0Ye5AyUV/GlJNq9/sZVOkRE8dPlQfjiqF800fEwkZBy36J1zvYBXgO6AH5hjZo8fsc21wF21XxYDPzezbxo4qzSgar/xjy+38ujibIrKqrj+tATuuGAgHdq09DqaiDSwuhzRVwF3mtlq51w7YJVzbomZZRy2zSbgbDM74JybAMwBxjRCXmkAKzfvJzXdh29nIWP71gwfS+yu4WMioeq4RW9meUBe7e0i51wmEAtkHLbNp4c95XMgroFzSgPILyzjgYVZ/PPrHfTo0JonrhnB5GE9dFWrSIir1xq9cy4BGAF88T2b3QQsPMbzpwPTAeLj4+uzazkJFVV+XvxkE39ZmkNltXHLuf245dz+REboIxqRcFDnn3TnXFvgbeB2Mys8xjbnUlP0ZxztcTObQ82yDikpKVbvtFJvH6/fQ9pcHxv3lHB+Ygz3TE4mITrK61gi0oTqVPTOuZbUlPxrZvbOMbYZBjwHTDCzfQ0XUU7Etv2HmDUvg8UZu0noEsmLN57KuYkxXscSEQ/U5awbBzwPZJrZ7GNsEw+8A0wzs/UNG1Hqo7Simqc/2sCzH22gmXP85uJB3HRGH1q10PAxkXBVlyP6ccA0YK1zbk3tfTOAeAAzewa4F+gCPFX7wV6VmaU0fFw5FjNjkW8Xs+ZlsuNgKVOG92TGxER6dNDwMZFwV5ezblYA33tahpndDNzcUKGkfnLzi0hLz2BF7l4Su7fjjeljGdu3i9exRCRA6LSLIFZUVsnj7+fw0qebiYxoTtqUZK4b25sWGj4mIodR0Qchv9945+sdPLgwi30l5VyV0otfXzSILho+JiJHoaIPMut2FHDvu+tYvfUgp/TqyPM3pDC8V0evY4lIAFPRB4n9JRU8siibN77aSpeoCB65YhiXj4zT8DEROS4VfYCrqvbz+pdb+dPi9RSXV/GTcX34xfgBtG+t4WMiUjcq+gD25ab93PvuOrJ2FXF6vy6kTR3MwG7tvI4lIkFGRR+AdhWUcf+CTNK/2UnPDq156tqRTBjSXcPHROSEqOgDSHlVNS+s2MwTH+RQ5TduO68/Pz+nP20idFWriJw4FX2AWJadz8y5GWzaW8IFyd24Z1Iy8V0ivY4lIiFARe+xLftKmDUvg/cz8+kbHcVLPz6VcwZp+JiINBwVvUdKK6p56sNcnv14Iy2bOe6ekMhPxvUhooWuahWRhqWib2JmxoK1u7hvfgY7C8q49JSe/HZiEt3at/Y6moiEKBV9E1q/u4jUd318tnEfST3a89jVIxjdp7PXsUQkxKnom0BBaSWPvb+eVz7bQttWLZh1yWB+NKY3zXVVq4g0ARV9I/L7jbdWb+fh97LYV1LBNaPj+dWFg+gcFeF1NBEJIyr6RvLNtoOkpvtYs+0go3p34qUfj2ZIbAevY4lIGFLRN7C9xeU88l42b67aRpeoVsy+cjiXjYjVVa0i4hkVfQOpqvbz6udbmL1kPaUV1dx8Rh9uO38A7TR8TEQ8pqJvAJ9t2Edauo/s3UWcOSCa1CnJ9I/R8DERCQwq+pOQV1DKffMzmfdtHrEd2/DMdaO4aHA3LdOISEBR0Z+A8qpqnlu+ib9+kIvfjNvHD+BnZ/ejdUsNHxORwKOir6elmbuZOS+DLfsOcdHgbvx+UjK9Omv4mIgELhV9HW3aW8LMuT6WZe+hX9coXr1pNGcO6Op1LBGR41LRH0dJeRVPLsvlueWbiGjRjN9NTOKG0xM0fExEgoaK/hjMjLnf5nH//Ex2FZbxgxGx3D0hkRgNHxORIKOiP4rMvELS0n18sWk/g3u258lrRzCqt4aPiUhwUtEfpuBQJbOXZPPq51to36Yl9102hKtPjdfwMREJaip6aoaPvblyGw8vyubgoQquHdObOy8cSMdIDR8TkeAX9kX/9dYDpKb7+HZ7AacmdCJt6mgG99TwMREJHWFb9HuKynnovSzeWrWdmHateOyqU7jklJ66qlVEQk7YFX1ltZ9XPtvCY0vWU1ZVzU/P7sut5w2gbauweytEJEyEVbt9mruX1HQfOfnFnD2wK/dOSaZf17ZexxIRaVRhUfQ7DpZy3/wMFqzdRa/Obfjb9SmMT4rRMo2IhIWQLvqyymrmfLyRpz7MBeCXFwxk+ll9NXxMRMJKSBa9mfF+Zj4z5/nYtr+UiUO7M2NiEnGdNHxMRMJPyBX9xj3F/GFuBh+t38OAmLa8dvMYxvWP9jqWiIhnQqboi8ureOKDHF5YsYnWLZrz+0k1w8daNtfwMREJb0Ff9GbGu2t28sDCTHYXlnPFqDjuujiRru1aeR1NRCQgBHXR+3YWkJbu46vNBxgW14GnrxvFyPhOXscSEQkoxy1651wv4BWgO+AH5pjZ40dskwi8CIwEfmdmjzZC1v918FAFf1q8nte+2ELHyAge/MFQrkzpRTMNHxMR+Td1OaKvAu40s9XOuXbAKufcEjPLOGyb/cBtwKWNEfJ/VPuNN77ayqOLsikoreT60xK4Y/xAOkS2bMzdiogEteMWvZnlAXm1t4ucc5lALJBx2Db5QL5zblJjBV21ZT+p6T7W7ShkdJ/O/GHqYJJ6tG+s3YmIhIx6rdE75xKAEcAXJ7Iz59x0YDpAfHx8nZ6TX1TGgwuzeGf1Drq3b81frhnBlGE9dFWriEgd1bnonXNtgbeB282s8ER2ZmZzgDkAKSkp9n3bVlb7eemTzTy+NIeKKj//cU4/bjm3P1EaPiYiUi91ak3nXEtqSv41M3uncSPB8pw9pKX72LCnhPMSY7hncjJ9oqMae7ciIiGpLmfdOOB5INPMZjdmmG37D/HH+Rks8u2md5dInr8hhfOTujXmLkVEQl5djujHAdOAtc65NbX3zQDiAczsGedcd2Al0B7wO+duB5LrusRTVlnNMx9t4OkPN9DMOX590SBuOqOPho+JiDSAupx1swL43k8+zWwXEFffnZsZi3y7+eP8DLYfKGXysB7MmJhEz45t6vtSIiJyDJ59slle5ef6F75kec5eBnVrx+v/bwyn99PwMRGRhuZZ0efsLoJtB0mdksy0sb1poeFjIiKNwrOi7xgZwbJfnUN0Ww0fExFpTJ4dRsd1aqOSFxFpAlovEREJcSp6EZEQp6IXEQlxKnoRkRCnohcRCXEqehGREKeiFxEJcSp6EZEQ58y+9+//aLwdO1cEZHuy88ATDez1OkSA0HvxHb0X39F78Z1BZtauPk/w8q9ryjazFA/3HzCccyv1XtTQe/EdvRff0XvxHefcyvo+R0s3IiIhTkUvIhLivCz6OR7uO9DovfiO3ovv6L34jt6L79T7vfDsw1gREWkaWroREQlxnhS9c+5i51y2cy7XOXe3FxkCgXOul3NumXMu0znnc879wutMXnLONXfOfe2cm+d1Fq855zo6595yzmXVfn+c5nUmrzjn7qj9+VjnnPuHc66115mainPuBedcvnNu3WH3dXbOLXHO5dT+2el4r9PkRe+caw48CUwAkoFrnHPJTZ0jQFQBd5pZEjAWuCWM3wuAXwCZXocIEI8D75lZIjCcMH1fnHOxwG1AipkNAZoDV3ubqkm9BFx8xH13A0vNbACwtPbr7+XFEf1oINfMNppZBfAGcIkHOTxnZnlmtrr2dhE1P8yx3qbyhnMuDpgEPOd1Fq8559oDZwHPA5hZhZkd9DaVp1oAbZxzLYBIYKfHeZqMmX0M7D/i7kuAl2tvvwxcerzX8aLoY4Fth329nTAtt8M55xKAEcAX3ibxzGPAbwC/10ECQF9gD/Bi7VLWc865KK9DecHMdgCPAluBPKDAzBZ7m8pz3cwsD2oOFoGY4z3Bi6J3R7kvrE/9cc61Bd4GbjezQq/zNDXn3GQg38xWeZ0lQLQARgJPm9kIoIQ6/HoeimrXny8B+gAP8OWGAAABWUlEQVQ9gSjn3HXepgo+XhT9dqDXYV/HEUa/ih3JOdeSmpJ/zcze8TqPR8YBU51zm6lZyjvPOfd3byN5ajuw3cz+57e7t6gp/nA0HthkZnvMrBJ4Bzjd40xe2+2c6wFQ+2f+8Z7gRdF/BQxwzvVxzkVQ88FKugc5POecc9Ssw2aa2Wyv83jFzH5rZnFmlkDN98MHZha2R21mtgvY5pwbVHvX+UCGh5G8tBUY65yLrP15OZ8w/WD6MOnADbW3bwDePd4TmnyomZlVOef+E1hEzSfoL5iZr6lzBIhxwDRgrXNuTe19M8xsgYeZJDDcCrxWezC0Efixx3k8YWZfOOfeAlZTc5ba14TRVbLOuX8A5wDRzrntQCrwIPCmc+4mav5H+MPjvo6ujBURCW26MlZEJMSp6EVEQpyKXkQkxKnoRURCnIpeRCTEqehFREKcil5EJMSp6EVEQtz/B+xSx1XvewGeAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mPlotTop=10\n", + "plotFuncs(PFexample.solution[0].cFunc,0.,mPlotTop)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The figure illustrates one of the surprising features of the perfect foresight model: A person with zero money should be spending at a rate more than double their income (that is, $\\texttt{cFunc}(0.) \\approx 2.08$ - the intersection on the vertical axis). How can this be?\n", + "\n", + "The answer is that we have not incorporated any constraint that would prevent the agent from borrowing against the entire PDV of future earnings-- human wealth. How much is that? What's the minimum value of $m_t$ where the consumption function is defined? We can check by retrieving the $\\texttt{hNrm}$ **attribute** of the solution, which calculates the value of human wealth normalized by permanent income:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This agent's human wealth is 50.49994992551661 times his current income level.\n", + "This agent's consumption function is defined (consumption is positive) down to m_t = -50.49994992551661\n" + ] + } + ], + "source": [ + "humanWealth = PFexample.solution[0].hNrm\n", + "mMinimum = PFexample.solution[0].mNrmMin\n", + "print(\"This agent's human wealth is \" + str(humanWealth) + ' times his current income level.')\n", + "print(\"This agent's consumption function is defined (consumption is positive) down to m_t = \" + str(mMinimum))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Yikes! Let's take a look at the bottom of the consumption function. In the cell below, set the bounds of the $\\texttt{plotFuncs}$ function to display down to the lowest defined value of the consumption function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# YOUR FIRST HANDS-ON EXERCISE!\n", + "# Fill in the value for \"mPlotBottom\" to plot the consumption function from the point where it is zero.\n", + "plotFuncs(PFexample.solution[0].cFunc,mPlotBottom,mPlotTop)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Changing Agent Parameters\n", + "\n", + "Suppose you wanted to change one (or more) of the parameters of the agent's problem and see what that does. We want to compare consumption functions before and after we change parameters, so let's make a new instance of $\\texttt{PerfForesightConsumerType}$ by copying $\\texttt{PFexample}$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "NewExample = deepcopy(PFexample)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In Python, you can set an $\\textbf{attribute}$ of an object just like any other variable. For example, we could make the new agent less patient:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "NewExample.DiscFac = 0.90\n", + "NewExample.solve()\n", + "mPlotBottom = mMinimum\n", + "plotFuncs([PFexample.solution[0].cFunc,NewExample.solution[0].cFunc],mPlotBottom,mPlotTop)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(Note that you can pass a **list** of functions to $\\texttt{plotFuncs}$ as the first argument rather than just a single function. Lists are written inside of [square brackets].)\n", + "\n", + "Let's try to deal with the \"problem\" of massive human wealth by making another consumer who has essentially no future income. We can virtually eliminate human wealth by making the permanent income growth factor $\\textit{very}$ small.\n", + "\n", + "In $\\texttt{PFexample}$, the agent's income grew by 1 percent per period -- his $\\texttt{PermGroFac}$ took the value 1.01. What if our new agent had a growth factor of 0.01 -- his income $\\textit{shrinks}$ by 99 percent each period? In the cell below, set $\\texttt{NewExample}$'s discount factor back to its original value, then set its $\\texttt{PermGroFac}$ attribute so that the growth factor is 0.01 each period.\n", + "\n", + "Important: Recall that the model at the top of this document said that an agent's problem is characterized by a sequence of income growth factors, but we tabled that concept. Because $\\texttt{PerfForesightConsumerType}$ treats $\\texttt{PermGroFac}$ as a $\\textit{time-varying}$ attribute, it must be specified as a $\\textbf{list}$ (with a single element in this case)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Revert NewExample's discount factor and make his future income minuscule\n", + "# print(\"your lines here\")\n", + "\n", + "# Compare the old and new consumption functions\n", + "plotFuncs([PFexample.solution[0].cFunc,NewExample.solution[0].cFunc],0.,10.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now $\\texttt{NewExample}$'s consumption function has the same slope (MPC) as $\\texttt{PFexample}$, but it emanates from (almost) zero-- he has basically no future income to borrow against!\n", + "\n", + "If you'd like, use the cell above to alter $\\texttt{NewExample}$'s other attributes (relative risk aversion, etc) and see how the consumption function changes. However, keep in mind that \\textit{no solution exists} for some combinations of parameters. HARK should let you know if this is the case if you try to solve such a model.\n", + "\n", + "\n", + "## Your Second HARK Model: Adding Income Shocks\n", + "\n", + "Linear consumption functions are pretty boring, and you'd be justified in feeling unimpressed if all HARK could do was plot some lines. Let's look at another model that adds two important layers of complexity: income shocks and (artificial) borrowing constraints.\n", + "\n", + "Specifically, our new type of consumer receives two income shocks at the beginning of each period: a completely transitory shock $\\theta_t$ and a completely permanent shock $\\psi_t$. Moreover, lenders will not let the agent borrow money such that his ratio of end-of-period assets $A_t$ to permanent income $P_t$ is less than $\\underline{a}$. As with the perfect foresight problem, this model can be framed in terms of $\\textit{normalized}$ variables, e.g. $m_t \\equiv M_t/P_t$. (See [here](http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/) for all the theory).\n", + "\n", + "\\begin{eqnarray*}\n", + "v_t(m_t) &=& \\max_{c_t} ~ U(c_t) ~ + \\phantom{\\LivFac} \\beta \\mathbb{E} [(\\Gamma_{t+1}\\psi_{t+1})^{1-\\rho} v_{t+1}(m_{t+1}) ], \\\\\n", + "a_t &=& m_t - c_t, \\\\\n", + "a_t &\\geq& \\underline{a}, \\\\\n", + "m_{t+1} &=& R/(\\Gamma_{t+1} \\psi_{t+1}) a_t + \\theta_{t+1}, \\\\\n", + "\\mathbb{E}[\\psi]=\\mathbb{E}[\\theta] &=& 1, \\\\\n", + "u(c) &=& \\frac{c^{1-\\rho}}{1-\\rho}.\n", + "\\end{eqnarray*}\n", + "\n", + "HARK represents agents with this kind of problem as instances of the class $\\texttt{IndShockConsumerType}$. To create an $\\texttt{IndShockConsumerType}$, we must specify the same set of parameters as for a $\\texttt{PerfForesightConsumerType}$, as well as an artificial borrowing constraint $\\underline{a}$ and a sequence of income shock joint. It's easy enough to pick a borrowing constraint -- say, zero -- but how would we specify the distributions of the shocks? Can't the joint distribution of permanent and transitory shocks be just about anything?\n", + "\n", + "$\\textit{Yes}$, and HARK can handle whatever correlation structure a user might care to specify. However, the default behavior of $\\texttt{IndShockConsumerType}$ is that the distribution of permanent income shocks is mean one lognormal, and the distribution of transitory shocks is mean one lognormal augmented with a point mass representing unemployment. The distributions are independent of each other by default, and are approximated with $N$ point equiprobable distributions.\n", + "\n", + "Let's make an infinite horizon instance of $\\texttt{IndShockConsumerType}$ with the same parameters as our original perfect foresight agent, plus the extra parameters to specify the income shock distribution and the artificial borrowing constraint. As before, we'll make a dictionary:\n", + "\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$ | 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", + "| $\\mho$ | Unemployment probability | $\\texttt{UnempPrb}$ | 0.05 |\n", + "| $\\underline{\\theta}$ | Transitory shock when unemployed | $\\texttt{IncUnemp}$ | 0.3 |" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "code_folding": [ + 2 + ], + "collapsed": true + }, + "outputs": [], + "source": [ + "# This cell defines a parameter dictionary for making an instance of IndShockConsumerType.\n", + "\n", + "IndShockDictionary = {\n", + " 'CRRA': 2.5, # The dictionary includes our original parameters...\n", + " 'Rfree': 1.03,\n", + " 'DiscFac': 0.96,\n", + " 'LivPrb': [0.98],\n", + " 'PermGroFac': [1.01],\n", + " 'PermShkStd': [0.1], # ... and 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,\n", + " 'BoroCnstArt': 0.0,\n", + " 'aXtraMin': 0.001, # aXtra parameters specify how to construct the grid of assets.\n", + " 'aXtraMax': 50., # Don't worry about these for now\n", + " 'aXtraNestFac': 3,\n", + " 'aXtraCount': 48,\n", + " 'aXtraExtra': [None],\n", + " 'vFuncBool': False, # These booleans indicate whether the value function should be calculated\n", + " 'CubicBool': False, # and whether to use cubic spline interpolation. You can ignore them.\n", + " 'aNrmInitMean' : -10.,\n", + " 'aNrmInitStd' : 0.0, # These parameters specify the (log) distribution of normalized assets\n", + " 'pLvlInitMean' : 0.0, # and permanent income for agents at \"birth\". They are only relevant in\n", + " 'pLvlInitStd' : 0.0, # simulation and you don't need to worry about them.\n", + " 'PermGroFacAgg' : 1.0,\n", + " 'T_retire': 0, # What's this about retirement? ConsIndShock is set up to be able to\n", + " 'UnempPrbRet': 0.0, # handle lifecycle models as well as infinite horizon problems. Swapping\n", + " 'IncUnempRet': 0.0, # out the structure of the income process is easy, but ignore for now.\n", + " 'T_age' : None,\n", + " 'T_cycle' : 1,\n", + " 'cycles' : 0,\n", + " 'AgentCount': 10000,\n", + " 'tax_rate':0.0,\n", + "}\n", + " \n", + "# Hey, there's a lot of parameters we didn't tell you about! Yes, but you don't need to\n", + "# think about them for now." + ] + }, + { + "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": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n", + "IndShockExample = IndShockConsumerType(**IndShockDictionary)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can solve our new agent's problem just like before, using the $\\texttt{solve}$ method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "IndShockExample.solve()\n", + "plotFuncs(IndShockExample.solution[0].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 numeric 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 $\\textbf{constructor}$ or $\\textbf{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 $\\textit{almost}$ true-- there's one extra step. $\\texttt{TranShkStd}$ is a primitive input, but it's not the thing you $\\textit{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": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "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": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Use the line(s) below to plot the consumptions functions against each other\n" + ] + } + ], + "metadata": { + "jupytext": { + "formats": "ipynb,py", + "metadata_filter": { + "cells": "collapsed" + } + }, + "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.3" + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Documentation/notebooks/HARK_ind_sh.png b/Documentation/notebooks/HARK_ind_sh.png new file mode 100644 index 000000000..dd5e7d175 Binary files /dev/null and b/Documentation/notebooks/HARK_ind_sh.png differ diff --git a/Documentation/notebooks/HARK_struct_2.png b/Documentation/notebooks/HARK_struct_2.png new file mode 100644 index 000000000..376b70e22 Binary files /dev/null and b/Documentation/notebooks/HARK_struct_2.png differ diff --git a/Documentation/notebooks/HARK_struct_3.png b/Documentation/notebooks/HARK_struct_3.png new file mode 100644 index 000000000..e71b9f2b9 Binary files /dev/null and b/Documentation/notebooks/HARK_struct_3.png differ diff --git a/Documentation/notebooks/HARK_struct_4.png b/Documentation/notebooks/HARK_struct_4.png new file mode 100644 index 000000000..7ea46af57 Binary files /dev/null and b/Documentation/notebooks/HARK_struct_4.png differ diff --git a/Documentation/notebooks/IncExpectationExample.ipynb b/Documentation/notebooks/IncExpectationExample.ipynb new file mode 100644 index 000000000..2b84cfe12 --- /dev/null +++ b/Documentation/notebooks/IncExpectationExample.ipynb @@ -0,0 +1,415 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The Persistent Shock Model and Income Expectations\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This module creates an example application extending $\\texttt{PersistentShockConsumerType}$ from $\\texttt{ConsGenIndShockModel}$. It uses the HARK tool $\\texttt{GenIncProcessModel}$ (whose documentation you can find [here](https://github.com/econ-ark/DemARK/blob/master/notebooks/IncExpectationExample.ipynb).)\n", + "\n", + "Most simply, it solves a consumption-saving model with shocks that are neither necessarily fully transitory nor fully permanent. Persistent income is tracked as a state variable and follows an AR(1) process." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### What if beliefs about persistent income differ from actual ?\n", + "\n", + "What if the consumer has beliefs about the persistence of his/her income process which differ from the *actual* persistence?\n", + "\n", + "We can use the class $\\texttt{PersistentShockConsumerType}$ to solve the problem of a consumer with a given set of beliefs, but then simulate a population of consumers for whom that actual persistence differs from what they believe.\n", + "\n", + "(This thought experiment is motivated by an interesting recennt paper presented at the NBER Summer Institute's _Behavioral Macroeconomics Conference_ " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Initial imports and notebook setup, click arrow to show\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import sys\n", + "import os\n", + "from copy import copy\n", + "sys.path.insert(0, os.path.abspath('../../.'))\n", + "\n", + "\n", + "from HARK.ConsumptionSaving.ConsGenIncProcessModel import *\n", + "import HARK.ConsumptionSaving.ConsumerParameters as Params\n", + "\n", + "from HARK.utilities import approxUniform, getLorenzShares, calcSubpopAvg\n", + "from time import clock\n", + "mystr = lambda number : \"{:.4f}\".format(number)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "code_folding": [ + 1, + 2 + ] + }, + "outputs": [], + "source": [ + "# This cell makes a subclass of PersistentShockConsumerType including the MPC \n", + "class PersistentShockConsumerTypeX(PersistentShockConsumerType):\n", + " def getControls(self):\n", + " cLvlNow = np.zeros(self.AgentCount) + np.nan\n", + " MPCnow = np.zeros(self.AgentCount) + np.nan\n", + " for t in range(self.T_cycle):\n", + " these = t == self.t_cycle\n", + " cLvlNow[these] = self.solution[t].cFunc(self.mLvlNow[these],self.pLvlNow[these])\n", + " MPCnow[these] =self.solution[t].cFunc.derivativeX(self.mLvlNow[these],self.pLvlNow[these])\n", + " self.cLvlNow = cLvlNow\n", + " self.MPCnow = MPCnow" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# This cell defines a dictionary to make an instance of \"persistent shocks\" consumer for the infinite horizon model\n", + "BaselineDict = {\n", + " \"CRRA\": 2.0, # Coefficient of relative risk aversion\n", + " \"Rfree\": 1.01/(1.0 - 1.0/160.0), # Interest factor on assets\n", + " \"DiscFac\": 0.97, # Default intertemporal discount factor\n", + " \"LivPrb\" : [1.0 - 1.0/160.0], # Survival probability\n", + " \"AgentCount\" : 10000, # Number of agents of this type (only matters for simulation)\n", + " \"IndL\": 10.0/9.0, # Labor supply per individual (constant)\n", + " \"aNrmInitMean\" : np.log(0.00001), # Mean of log initial assets (only matters for simulation)\n", + " \"aNrmInitStd\" : 0.0, # Standard deviation of log initial assets (only for simulation)\n", + " \"pLvlInitMean\" : 0.0, # Mean of log initial permanent income (only matters for simulation)\n", + " \"pLvlInitStd\" : 0.0, # Standard deviation of log initial permanent income (only matters for simulation)\n", + " \"PermGroFacAgg\" : 1.0, # Aggregate permanent income growth factor (only matters for simulation)\n", + " \"T_age\" : 400, # Age after which simulated agents are automatically killed\n", + " \"T_cycle\" : 1, # Number of periods in the cycle for this agent type\n", + " \"T_sim\":1200, # Number of periods to simulate (idiosyncratic shocks model, perpetual youth)\n", + " \"aXtraMin\" : 0.001, # Minimum end-of-period \"assets above minimum\" value\n", + " \"aXtraMax\" : 30, # Maximum end-of-period \"assets above minimum\" value \n", + " \"aXtraExtra\" : [0.005,0.01], # Some other value of \"assets above minimum\" to add to the grid\n", + " \"aXtraNestFac\" : 3, # Exponential nesting factor when constructing \"assets above minimum\" grid\n", + " \"aXtraCount\" : 48, # Number of points in the grid of \"assets above minimum\"\n", + " \"PermShkCount\" : 7, # Number of points in discrete approximation to permanent income shocks\n", + " \"TranShkCount\" : 7, # Number of points in discrete approximation to transitory income shocks\n", + " \"PermShkStd\" : [(0.01*4/11)**0.5], # Standard deviation of permanent shocks to income\n", + " \"TranShkStd\" : [(0.01*4)**0.5], # Standard deviation of transitory shocks to income\n", + " \"UnempPrb\" : 0.05, # Probability of unemployment while working\n", + " \"UnempPrbRet\" : 0.005, # Probability of \"unemployment\" while retired\n", + " \"IncUnemp\" : 0.3, # Unemployment benefits replacement rate\n", + " \"IncUnempRet\" : 0.0, # \"Unemployment\" benefits when retired\n", + " \"tax_rate\" : 0.0, # Flat income tax rate\n", + " \"T_retire\" : 0, # Period of retirement (0 --> no retirement)\n", + " \"BoroCnstArt\" : 0.0, # Artificial borrowing constraint; imposed minimum level of end-of period assets\n", + " \"CubicBool\" : False, # Use cubic spline interpolation when True, linear interpolation when False\n", + " \"vFuncBool\" : True, # Whether to calculate the value function during solution \n", + " \"cycles\": 0, # Make this type have an infinite horizon\n", + " \"pLvlPctiles\" : np.concatenate(([0.001, 0.005, 0.01, 0.03], np.linspace(0.05, 0.95, num=19),[0.97, 0.99, 0.995, 0.999])),\n", + " \"PermGroFac\" :[1.000**0.25], # Permanent income growth factor (no perm growth) \n", + " \"PrstIncCorr\": 0.99, # Serial correlation coefficient for persistence of income\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "code_folding": [ + 1 + ], + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "# This cell defines a function to solve and simulate a consumer misperceiving the correlation of persistent income shocks\n", + "def runRoszypalSchlaffmanExperiment(CorrAct, CorrPcvd, DiscFac_center, DiscFac_spread):\n", + " '''\n", + " Solve and simulate a consumer type who misperceives the extent of serial correlation\n", + " of persistent shocks to income.\n", + " \n", + " Parameters\n", + " ----------\n", + " CorrAct : float\n", + " Serial correlation coefficient for *actual* persistent income.\n", + " CorrPcvd : float\n", + " List or array of *perceived* persistent income.\n", + " DiscFac_center : float\n", + " A measure of centrality for the distribution of the beta parameter, DiscFac.\n", + " DiscFac_spread : float\n", + " A measure of spread or diffusion for the distribution of the beta parameter.\n", + "\n", + "\n", + " Returns\n", + " -------\n", + " AggWealthRatio: float\n", + " Ratio of Aggregate wealth to income.\n", + " Lorenz: numpy.array\n", + " A list of two 1D array reprensenting the Lorenz curve for assets in the most recent simulated period.\n", + " Gini: float\n", + " Gini coefficient for assets in the most recent simulated period.\n", + " Avg_MPC: numpy.array\n", + " Average marginal propensity to consume by income quintile in the latest simulated period.\n", + " \n", + " ''' \n", + " \n", + " # Make a dictionary to construct our consumer type\n", + " ThisDict = copy(BaselineDict)\n", + " ThisDict['PrstIncCorr'] = CorrAct\n", + " \n", + " # Make a 7 point approximation to a uniform distribution of DiscFac\n", + " DiscFac_list = approxUniform(N=7,bot=DiscFac_center-DiscFac_spread,top=DiscFac_center+DiscFac_spread)[1]\n", + " \n", + " type_list = []\n", + " # Make a PersistentShockConsumerTypeX for each value of beta saved in DiscFac_list\n", + " for i in range(len(DiscFac_list)): \n", + " ThisDict['DiscFac'] = DiscFac_list[i] \n", + " ThisType = PersistentShockConsumerTypeX(**ThisDict)\n", + " \n", + " # Make the consumer type *believe* he will face a different level of persistence\n", + " ThisType.PrstIncCorr = CorrPcvd\n", + " ThisType.updatepLvlNextFunc() # Now he *thinks* E[p_{t+1}] as a function of p_t is different than it is\n", + " \n", + " # Solve the consumer's problem with *perceived* persistence \n", + " ThisType.solve()\n", + " \n", + " # Make the consumer type experience the true level of persistence during simulation\n", + " ThisType.PrstIncCorr = CorrAct\n", + " ThisType.updatepLvlNextFunc()\n", + " \n", + " # Simulate the agents for many periods\n", + " ThisType.T_sim = 100\n", + " #ThisType.track_vars = ['cLvlNow','aLvlNow','pLvlNow','MPCnow']\n", + " ThisType.initializeSim()\n", + " ThisType.simulate()\n", + " type_list.append(ThisType)\n", + " \n", + " # Get the most recent simulated values of X = cLvlNow, MPCnow, aLvlNow, pLvlNow for all types \n", + " cLvl_all = np.concatenate([ThisType.cLvlNow for ThisType in type_list])\n", + " aLvl_all = np.concatenate([ThisType.aLvlNow for ThisType in type_list])\n", + " MPC_all = np.concatenate([ThisType.MPCnow for ThisType in type_list])\n", + " pLvl_all = np.concatenate([ThisType.pLvlNow for ThisType in type_list])\n", + " \n", + " # The ratio of aggregate assets over the income\n", + " AggWealthRatio = np.mean(aLvl_all) / np.mean(pLvl_all)\n", + "\n", + " # first 1D array: Create points in the range (0,1)\n", + " wealth_percentile = np.linspace(0.001,0.999,201)\n", + "\n", + " # second 1D array: Compute Lorenz shares for the created points\n", + " Lorenz_init = getLorenzShares(aLvl_all, percentiles=wealth_percentile)\n", + "\n", + " # Stick 0 and 1 at the boundaries of both arrays to make it inclusive on the range [0,1]\n", + " Lorenz_init = np.concatenate([[0],Lorenz_init,[1]])\n", + " wealth_percentile = np.concatenate([[0],wealth_percentile,[1]])\n", + " \n", + " # Create a list of wealth_percentile 1D array and Lorenz Shares 1D array\n", + " Lorenz = np.stack((wealth_percentile, Lorenz_init))\n", + "\n", + " # Compute the Gini coefficient\n", + " Gini = 1.0 - 2.0*np.mean(Lorenz_init[1])\n", + " \n", + " # Compute the average MPC by income quintile in the latest simulated period\n", + " Avg_MPC = calcSubpopAvg(MPC_all, pLvl_all, cutoffs=[(0.0,0.2), (0.2,0.4), (0.4,0.6), (0.6,0.8), (0.8,1.0)])\n", + " \n", + " return AggWealthRatio, Lorenz, Gini, Avg_MPC" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "code_folding": [] + }, + "source": [ + "The user needs to call the function $\\texttt{runRoszypalSchlaffmanExperiment}$ with specific values for $\\texttt{CorrAct}$, $\\texttt{CorrPcvd}$ and estimates of $\\texttt{DiscFac_center}$, $\\texttt{DiscFac_spread}$ to solve the model accordingly.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "code_folding": [ + 0 + ], + "lines_to_next_cell": 2 + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The Lorenz curve for assests is\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The aggregate wealth to income ratio is 5.722878745432177\n", + "The Gini Coefficient for assests is 1.0\n", + "The average MPC by income quintile is [0.0591159174132672, 0.051551301726577924, 0.05000504062141127, 0.043722840170633326, 0.027826462422222857]\n" + ] + } + ], + "source": [ + "# Call the function with test values for (CorrAct, CorrPcvd, DiscFac_center, DiscFac_spread)\n", + "AggWealthRatio, Lorenz, Gini, Avg_MPC = runRoszypalSchlaffmanExperiment(0.97, 0.9831, 0.9867, 0.0067)\n", + "\n", + "# Plot the Lorenz curve \n", + "print('The Lorenz curve for assests is')\n", + "plt.plot(Lorenz[0],Lorenz[1])\n", + "plt.xlabel('Wealth percentile')\n", + "plt.ylabel('Cumulative wealth share')\n", + "plt.xlim([0.,1.])\n", + "plt.ylim([0.,1.])\n", + "plt.show()\n", + " \n", + "print('The aggregate wealth to income ratio is ' + str(AggWealthRatio))\n", + "print('The Gini Coefficient for assests is ' + str(Gini))\n", + "print('The average MPC by income quintile is ' + str(Avg_MPC))" + ] + } + ], + "metadata": { + "cite2c": { + "citations": { + "6202365/574VIUMA": { + "URL": "https://sites.google.com/site/kathrinschlafmann/RozsypalSchlafmann.pdf", + "abstract": "Using micro level data, we document a systematic, income-related component in household income forecast errors. We show that these errors can be formalized by a modest deviation from rational expectations, where agents overestimate the persistence of their income process. We then investigate the implications of these distortions on consumption and savings behavior and find two effects. First, these distortions allow an otherwise fully optimization-based quantitative model to match the joint distribution of liquid assets and income. Second, the bias alters the distribution of marginal propensities to consume which makes government stimulus policies less effective.", + "author": [ + { + "family": "Rozsypal", + "given": "Filip" + }, + { + "family": "Schlafmann", + "given": "Kathrin" + } + ], + "id": "6202365/574VIUMA", + "issued": { + "year": 2019 + }, + "note": "Citation Key: RozsypalSchlafmann:2019", + "title": "Overpersistence Bias in Individual Income Expectations and its Aggregate Implications", + "type": "manuscript" + }, + "undefined": { + "URL": "https://sites.google.com/site/kathrinschlafmann/RozsypalSchlafmann.pdf", + "abstract": "Using micro level data, we document a systematic, income-related component in household income forecast errors. We show that these errors can be formalized by a modest deviation from rational expectations, where agents overestimate the persistence of their income process. We then investigate the implications of these distortions on consumption and savings behavior and find two effects. First, these distortions allow an otherwise fully optimization-based quantitative model to match the joint distribution of liquid assets and income. Second, the bias alters the distribution of marginal propensities to consume which makes government stimulus policies less effective.", + "author": [ + { + "family": "Rozsypal", + "given": "Filip" + }, + { + "family": "Schlafmann", + "given": "Kathrin" + } + ], + "id": "6202365/574VIUMA", + "issued": { + "year": 2019 + }, + "note": "Citation Key: RozsypalSchlafmann:2019", + "title": "Overpersistence Bias in Individual Income Expectations and its Aggregate Implications", + "type": "manuscript" + } + } + }, + "jupytext": { + "formats": "ipynb,py:percent", + "metadata_filter": { + "cells": "collapsed" + }, + "text_representation": { + "extension": ".py", + "format_name": "percent", + "format_version": "1.1", + "jupytext_version": "0.8.3" + } + }, + "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.3" + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Documentation/notebooks/IndShockConsumerType.ipynb b/Documentation/notebooks/IndShockConsumerType.ipynb new file mode 100644 index 000000000..1df1cdf5d --- /dev/null +++ b/Documentation/notebooks/IndShockConsumerType.ipynb @@ -0,0 +1,943 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# IndShockConsumerType Documentation\n", + "## Consumption-Saving model with Idiosyncratic Income Shocks" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Initial imports and notebook setup, click arrow to show\n", + "import sys #set path of the notebook \n", + "import os\n", + "sys.path.insert(0, os.path.abspath('../../.'))\n", + "\n", + "from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n", + "from HARK.utilities import plotFuncsDer, plotFuncs\n", + "from time import clock\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "mystr = lambda number : \"{:.4f}\".format(number)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you acquire some knowledge about the deterministic consumer model in HARK from [Quickstart](../notebooks/Quickstart_tutorial/Quick_start_with_solution.ipynb), you can now proceed to the second of the models from the module $\\texttt{HARK.ConsumptionSaving.ConsIndShockModel}$ - a model with risk over transitory and permanent income shocks. In HARK it is represented by a class $\\texttt{IndShockConsumerType}$ which is a child of $\\textit{PerfForesightConsumerType}$ (on the diagram you can observe the agent-type classes structure). In this tutorial we will show you the main functionalities and attributes of this class. \n", + "\n", + "![HARK structure](../notebooks/HARK_ind_sh.png)\n", + "\n", + "$\\newcommand{\\CRRA}{\\rho}$\n", + "$\\newcommand{\\DiePrb}{\\mathsf{D}}$\n", + "$\\newcommand{\\PermGroFac}{\\Gamma}$\n", + "$\\newcommand{\\Rfree}{\\mathsf{R}}$\n", + "$\\newcommand{\\DiscFac}{\\beta}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Statement of idiosyncratic income shocks model\n", + "\n", + "Suppose we want to solve a model like the one analyzed in [BufferStockTheory](http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/), with all the same features as the perfect foresight consumer, plus idiosyncratic shocks to income each period. Agents with this kind of model are represented by the class $\\texttt{IndShockConsumerType}$.\n", + "\n", + "Specifically, this type of consumer receives two income shocks at the beginning of each period: a completely transitory shock $\\newcommand{\\tShkEmp}{\\theta}{\\tShkEmp_t}$ and a completely permanent shock $\\newcommand{\\pShk}{\\psi}{\\pShk_t}$. Moreover, lenders will not let the agent borrow money such that his ratio of end-of-period assets $A_t$ to permanent income $P_t$ is less than $\\underline{a}$. As with the perfect foresight problem, this model can be framed in terms of *normalized* variables, dividing all real variables by $P_t$:\n", + "\n", + "\\begin{eqnarray*}\n", + "v_t(m_t) &=& \\max_{c_t} {~} u(c_t) + \\DiscFac (1-\\DiePrb_{t+1}) \\mathbb{E}_{t} \\left[ (\\PermGroFac_{t+1}\\psi_{t+1})^{1-\\CRRA} v_{t+1}(m_{t+1}) \\right], \\\\\n", + "a_t &=& m_t - c_t, \\\\\n", + "a_t &\\geq& \\underline{a}, \\\\\n", + "m_{t+1} &=& \\Rfree/(\\PermGroFac_{t+1} \\psi_{t+1}) a_t + \\theta_{t+1}, \\\\\n", + "(\\psi_{t+1},\\theta_{t+1}) &\\sim& F_{t+1}, \\\\\n", + "\\mathbb{E}[\\psi]=\\mathbb{E}[\\theta] &=& 1, \\\\\n", + "u(c) &=& \\frac{c^{1-\\rho}}{1-\\rho}.\n", + "\\end{eqnarray*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solution method for IndShockConsumerType\n", + "\n", + "With the introduction of (non-trivial) risk, the idiosyncratic income shocks model has no closed form solution and must be solved numerically. The function $\\texttt{solveConsIndShock}$ solves the one period problem for the $\\texttt{IndShockConsumerType}$ class. To do so, HARK uses the original version of the endogenous grid method (EGM) first described [here](http://www.econ2.jhu.edu/people/ccarroll/EndogenousGridpoints.pdf) ; see also the [SolvingMicroDSOPs](http://www.econ2.jhu.edu/people/ccarroll/SolvingMicroDSOPs/) lecture notes. \n", + "\n", + "Briefly, the transition equation for $m_{t+1}$ can be substituted into the problem definition; the second term of the reformulated maximand represents \"end of period value of assets\" $\\mathfrak{v}_t(a_t)$ (\"Gothic v\"):\n", + "\n", + "\\begin{eqnarray*}\n", + "v_t(m_t) &=& \\max_{c_t} {~} U(c_t) + \\underbrace{\\DiscFac (1-\\DiePrb_{t+1}) \\mathbb{E}_{t} \\left[ (\\PermGroFac_{t+1}\\psi_{t+1})^{1-\\CRRA} v_{t+1}(\\Rfree/(\\PermGroFac_{t+1} \\psi_{t+1}) a_t + \\theta_{t+1}) \\right]}_{\\equiv \\mathfrak{v}_t(a_t)}.\n", + "\\end{eqnarray*}\n", + "\n", + "The first order condition with respect to $c_t$ is thus simply:\n", + "\n", + "\\begin{eqnarray*}\n", + "U'(c_t) - \\mathfrak{v}'_t(a_t) = 0 \\Longrightarrow c_t^{-\\CRRA} = \\mathfrak{v}'_t(a_t) \\Longrightarrow c_t = \\mathfrak{v}'_t(a_t)^{-1/\\CRRA}.\n", + "\\end{eqnarray*}\n", + "\n", + "Where the marginal value of end-of-period assets can be computed as:\n", + "\n", + "\\begin{eqnarray*}\n", + "\\mathfrak{v}'_t(a_t) = \\DiscFac (1-\\DiePrb_{t+1}) \\mathbb{E}_{t} \\left[ \\Rfree (\\PermGroFac_{t+1}\\psi_{t+1})^{-\\CRRA} v'_{t+1}(\\Rfree/(\\PermGroFac_{t+1} \\psi_{t+1}) a_t + \\theta_{t+1}) \\right].\n", + "\\end{eqnarray*}\n", + "\n", + "To solve the model, we choose an exogenous grid of $a_t$ values that spans the range of values that could plausibly be achieved, compute $\\mathfrak{v}'_t(a_t)$ at each of these points, calculate the value of consumption $c_t$ whose marginal utility is consistent with the marginal value of assets, then find the endogenous $m_t$ gridpoint as $m_t = a_t + c_t$. The set of $(m_t,c_t)$ gridpoints is then interpolated to construct the consumption function." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## How to construct IndShockConsumerType\n", + "In the previous notebook describe the basic parameters to create an agent-type object. In case of the $\\texttt{IndShockConsumerType}$, the few additional parameters are needed. \n", + "\n", + "Firstly, the parameters of the shocks distributions need to be specified. In this setting, the lognormality is assumed, thus the variation of the shocks need to be set. In the code, $\\texttt{PermGroFac}$ (standard deviation of the permanent income shocks) and $\\texttt{TranShkStd}$ (standard deviation of the transitory income shocks, may change with age). Next the probability of unemployment need to be set by the parameter $\\texttt{UnempPrb}$. Lastly, the standard deviation of the transitory shock for unemployed agents. \n", + "\n", + "Optionally, the user can specify the period when the individual retires and escapes essentially all income risk as $\\texttt{T_retire}$; this can be turned off by setting the parameter to $0$. In retirement, all permanent income shocks are turned off, and the only transitory shock is an \"unemployment\" shock, likely with small probability; this prevents the retired problem from degenerating into a perfect foresight model.\n", + "\n", + "Combining the parameters common with the $\\texttt{PerfForesightConsumerType}, we need to determine the list of the parameters presented in the table below (with the distinction between time-varying and time stable values). \n", + "\n", + "\n", + "| Parameter | Description | Code | Example value | Time-varying? |\n", + "| :---: | --- | --- | --- | --- |\n", + "| $\\DiscFac$ |Intertemporal discount factor | $\\texttt{DiscFac}$ | $0.96$ | |\n", + "| $\\CRRA $ |Coefficient of relative risk aversion | $\\texttt{CRRA}$ | $2.0$ | |\n", + "| $\\Rfree$ | Risk free interest factor | $\\texttt{Rfree}$ | $1.03$ | |\n", + "| $1 - \\DiePrb_{t+1}$ |Survival probability | $\\texttt{LivPrb}$ | $[0.98]$ | $\\surd$ |\n", + "|$\\PermGroFac_{t+1}$|Permanent income growth factor|$\\texttt{PermGroFac}$| $[1.01]$ | $\\surd$ |\n", + "| $\\sigma_\\psi $ | Standard deviation of log permanent income shocks | $\\texttt{PermShkStd}$ | $[0.1]$ |$\\surd$ |\n", + "| $\\sigma_\\theta $ | Standard deviation of log transitory income shocks | $\\texttt{TranShkStd}$ | $[0.2]$ | $\\surd$ |\n", + "| $\\mho$ | Probability of being unemployed and getting $\\theta=\\underline{\\theta}$ | $\\texttt{UnempPrb}$ | $0.05$ | |\n", + "| $\\underline{a} $ | Artificial borrowing constraint (normalized) | $\\texttt{BoroCnstArt}$ | $0.0$ | |\n", + "| $(none) $ |Indicator for whether $\\texttt{vFunc}$ should be computed | $\\texttt{vFuncBool}$ | $True$ | |\n", + "|$T$| Number of periods in this type's \"cycle\" |$\\texttt{T_cycle}$| $1$ | |\n", + "|(none)| Number of times the \"cycle\" occurs |$\\texttt{cycles}$| $0$ | |\n", + "\n", + "Observe that the distribution of permanent income shocks is specified as mean one lognormal, with an age-varying (underlying) standard deviation.\n", + "\n", + "In order to avoid the technicalities induced by using the endogenous grid method we propose to use the prepared set of parameters and then overwrite only the parameters which directly concern the model. " + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "import Documentation.notebooks.Jounery_1_param as Params \n", + "IdiosyncDict={\n", + " # Parameters shared with the perfect foresight model\n", + " \"CRRA\": 2.0, # Coefficient of relative risk aversion\n", + " \"Rfree\": 1.03, # Interest factor on assets\n", + " \"DiscFac\": 0.96, # Intertemporal discount factor\n", + " \"LivPrb\" : [0.98], # Survival probability\n", + " \"PermGroFac\" :[1.01], # Permanent income growth factor\n", + " \n", + " # Parameters that specify the income distribution over the lifecycle\n", + " \"PermShkStd\" : [0.1], # Standard deviation of log permanent shocks to income\n", + " \"TranShkStd\" : [0.2], # Standard deviation of log transitory shocks to income\n", + " \"UnempPrb\" : 0.05, # Probability of unemployment while working\n", + " \"IncUnemp\" : 0.3, # Unemployment benefits replacement rate\n", + " # A few other paramaters\n", + " \"BoroCnstArt\" : 0.0, # Artificial borrowing constraint; imposed minimum level of end-of period assets\n", + " \"T_cycle\" : 1, # Number of periods in the cycle for this agent type \n", + " \"UnempPrbRet\" : 0.0005, # Probability of \"unemployment\" while retired\n", + " \"IncUnempRet\" : 0.0, # \"Unemployment\" benefits when retired\n", + " \"T_retire\" : 0, # Period of retirement (0 --> no retirement)\n", + "\n", + " \n", + " # Parameters only used in simulation\n", + " \"AgentCount\" : 10000, # Number of agents of this type\n", + " \"T_sim\" : 120, # Number of periods to simulate\n", + " \"aNrmInitMean\" : -6.0, # Mean of log initial assets\n", + " \"aNrmInitStd\" : 1.0, # Standard deviation of log initial assets\n", + " \"pLvlInitMean\" : 0.0, # Mean of log initial permanent income\n", + " \"pLvlInitStd\" : 0.0, # Standard deviation of log initial permanent income\n", + " \"PermGroFacAgg\" : 1.0, # Aggregate permanent income growth factor\n", + " \"T_age\" : None, # Age after which simulated agents are automatically killed\n", + "}\n", + "\n", + "Aggregate_params = Params.init_idiosyncratic_shocks\n", + "Aggregate_params.update(IdiosyncDict) \n", + "#set the technical paramaters \n", + "BaselineType = IndShockConsumerType(**Aggregate_params)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Obviously, the \"technical\" parameters are also possible to set the \"technical\" parameters. The good reference how the endogenous grid method works and how to set the parameters is in the SolvingMicroDSOPs](http://www.econ2.jhu.edu/people/ccarroll/SolvingMicroDSOPs/) lecture notes. The list of all parameters is contained in the table. \n", + "The distribution of transitory income shocks is also mean one lognormal, but with an additional point mass representing unemployment; the transitory shocks are adjusted so that the distribution is still mean one. The continuous distributions are discretized with an equiprobable distribution.\n", + "\n", + "| Parameter | Description | Code | Example value | Time-varying? |\n", + "| :---: | --- | --- | --- | --- |\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", + "| $(none)$ | Minimum value in assets-above-minimum grid | $\\texttt{aXtraMin}$ | $0.001$ | |\n", + "| $(none)$ | Maximum value in assets-above-minimum grid | $\\texttt{aXtraMax}$ | $20.0$ | |\n", + "| $(none)$ | Number of points in base assets-above-minimum grid | $\\texttt{aXtraCount}$ | $48$ | |\n", + "| $(none)$ | Exponential nesting factor for base assets-above-minimum grid | $\\texttt{aXtraNestFac}$ | $3$ | |\n", + "| $(none)$ | Additional values to add to assets-above-minimum grid | $\\texttt{aXtraExtra}$ | $None$ | |\n", + "| $(none) $ |Indicator for whether $\\texttt{vFunc}$ should be computed | $\\texttt{vFuncBool}$ | $True$ | |\n", + "| $(none)$ |Indicator for whether $\\texttt{cFunc}$ should use cubic splines | $\\texttt{CubicBool}$ | $False$ | |\n", + "\n", + "Thus, using this parameters, it is possible to build an independent dictionary to create the $\\texttt{IndShockConsumerType}$ object. " + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "IdiosyncDict={\n", + " # Parameters shared with the perfect foresight model\n", + " \"CRRA\": 2.0, # Coefficient of relative risk aversion\n", + " \"Rfree\": 1.03, # Interest factor on assets\n", + " \"DiscFac\": 0.96, # Intertemporal discount factor\n", + " \"LivPrb\" : [0.98], # Survival probability\n", + " \"PermGroFac\" :[1.01], # Permanent income growth factor\n", + " \n", + " # Parameters that specify the income distribution over the lifecycle\n", + " \"PermShkStd\" : [0.1], # Standard deviation of log permanent shocks to income\n", + " \"PermShkCount\" : 7, # Number of points in discrete approximation to permanent income shocks\n", + " \"TranShkStd\" : [0.2], # Standard deviation of log transitory shocks to income\n", + " \"TranShkCount\" : 7, # Number of points in discrete approximation to transitory income shocks\n", + " \"UnempPrb\" : 0.05, # Probability of unemployment while working\n", + " \"IncUnemp\" : 0.3, # Unemployment benefits replacement rate\n", + " \"UnempPrbRet\" : 0.0005, # Probability of \"unemployment\" while retired\n", + " \"IncUnempRet\" : 0.0, # \"Unemployment\" benefits when retired\n", + " \"T_retire\" : 0, # Period of retirement (0 --> no retirement)\n", + " \"tax_rate\" : 0.0, # Flat income tax rate (legacy parameter, will be removed in future)\n", + " # Parameters for constructing the \"assets above minimum\" grid\n", + " \"aXtraMin\" : 0.001, # Minimum end-of-period \"assets above minimum\" value\n", + " \"aXtraMax\" : 20, # Maximum end-of-period \"assets above minimum\" value\n", + " \"aXtraCount\" : 48, # Number of points in the base grid of \"assets above minimum\"\n", + " \"aXtraNestFac\" : 3, # Exponential nesting factor when constructing \"assets above minimum\" grid\n", + " \"aXtraExtra\" : [None], # Additional values to add to aXtraGrid\n", + " \n", + " # A few other paramaters\n", + " \"BoroCnstArt\" : 0.0, # Artificial borrowing constraint; imposed minimum level of end-of period assets\n", + " \"vFuncBool\" : True, # Whether to calculate the value function during solution \n", + " \"CubicBool\" : False, # Preference shocks currently only compatible with linear cFunc\n", + " \"T_cycle\" : 1, # Number of periods in the cycle for this agent type \n", + " \n", + " # Parameters only used in simulation\n", + " \"AgentCount\" : 10000, # Number of agents of this type\n", + " \"T_sim\" : 120, # Number of periods to simulate\n", + " \"aNrmInitMean\" : -6.0, # Mean of log initial assets\n", + " \"aNrmInitStd\" : 1.0, # Standard deviation of log initial assets\n", + " \"pLvlInitMean\" : 0.0, # Mean of log initial permanent income\n", + " \"pLvlInitStd\" : 0.0, # Standard deviation of log initial permanent income\n", + " \"PermGroFacAgg\" : 1.0, # Aggregate permanent income growth factor\n", + " \"T_age\" : None, # Age after which simulated agents are automatically killed\n", + "}\n", + "\n", + "BaselineType = IndShockConsumerType(**IdiosyncDict)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A few comments \n", + "The grid of assets above minimum $\\texttt{aXtraGrid}$ is specified by its minimum and maximum level, the number of gridpoints, and the extent of exponential nesting. The greater the (integer) value of $\\texttt{aXtraNestFac}$, the more dense the gridpoints will be at the bottom of the grid (and more sparse near the top); setting $\\texttt{aXtraNestFac}$ to $0$ will generate an evenly spaced grid of $a_t$.\n", + "\n", + "The artificial borrowing constraint $\\texttt{BoroCnstArt}$ can be set to $\\texttt{None}$ to turn it off.\n", + "\n", + "The distributions were discretized using equiprobable grid points.\n", + "\n", + "It is not necessary to compute the value function in this model, and it is not computationally free to do so. You can choose whether the value function should be calculated and returned as part of the solution of the model with $\\texttt{vFuncBool}$. The consumption function will be constructed as a piecewise linear interpolation when $\\texttt{CubicBool}$ is $\\texttt{False}$, and will be a piecewise cubic spline interpolator if $\\texttt{True}$." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "## Solving and examining the solution of the idiosyncratic income shocks model\n", + "\n", + "The cell below creates an infinite horizon instance of $\\texttt{IndShockConsumerType}$ and solves its model by calling its $\\texttt{solve}$ method." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "hidden": true, + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "IndShockExample = IndShockConsumerType(**IdiosyncDict)\n", + "IndShockExample.cycles = 0 # Make this type have an infinite horizon\n", + "IndShockExample.solve()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "After solving the model, we can examine an element of this type's $\\texttt{solution}$:" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'cFunc': , 'vFunc': , 'vPfunc': , 'vPPfunc': , 'mNrmMin': 0.0, 'hNrm': 44.991920196607595, 'MPCmin': 0.044536273404377116, 'MPCmax': 1.0, 'mNrmSS': 1.5488165705077046}\n" + ] + } + ], + "source": [ + "print(vars(IndShockExample.solution[0]))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "The single-period solution to an idiosyncratic shocks consumer's problem has all of the same attributes as in the perfect foresight model, with a couple additions. The solution can include the marginal marginal value of market resources function $\\texttt{vPPfunc}$, but this is only constructed if $\\texttt{CubicBool}$ is $\\texttt{True}$, so that the MPC can be accurately computed; when it is $\\texttt{False}$, then $\\texttt{vPPfunc}$ merely returns $\\texttt{NaN}$ everywhere.\n", + "\n", + "The $\\texttt{solveConsIndShock}$ function calculates steady state market resources and stores it in the attribute $\\texttt{mNrmSS}$. This represents the steady state level of $m_t$ if *this period* were to occur indefinitely, but with income shocks turned off. This is relevant in a \"one period infinite horizon\" model like we've specified here, but is less useful in a lifecycle model.\n", + "\n", + "Let's take a look at the consumption function by plotting it, along with its derivative (the MPC):" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption function for an idiosyncratic shocks consumer type:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Marginal propensity to consume for an idiosyncratic shocks consumer type:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print('Consumption function for an idiosyncratic shocks consumer type:')\n", + "plotFuncs(IndShockExample.solution[0].cFunc,IndShockExample.solution[0].mNrmMin,5)\n", + "print('Marginal propensity to consume for an idiosyncratic shocks consumer type:')\n", + "plotFuncsDer(IndShockExample.solution[0].cFunc,IndShockExample.solution[0].mNrmMin,5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "The lower part of the consumption function is linear with a slope of 1, representing the *constrained* part of the consumption function where the consumer *would like* to consume more by borrowing-- his marginal utility of consumption exceeds the marginal value of assets-- but he is prevented from doing so by the artificial borrowing constraint.\n", + "\n", + "The MPC is a step function, as the $\\texttt{cFunc}$ itself is a piecewise linear function; note the large jump in the MPC where the borrowing constraint begins to bind.\n", + "\n", + "If you want to look at the interpolation nodes for the consumption function, these can be found by \"digging into\" attributes of $\\texttt{cFunc}$:" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mNrmGrid for unconstrained cFunc is [-0.25017509 -0.23682357 -0.04309334 0.08570877 0.19249704 0.28773035\n", + " 0.37527975 0.4572262 0.53458817 0.60902763 0.68157147 0.75266421\n", + " 0.82159155 0.89091324 0.96108615 1.03297006 1.10702535 1.18386894\n", + " 1.26405846 1.34797683 1.43498517 1.52575439 1.62247992 1.7264799\n", + " 1.83886328 1.96091089 2.09399047 2.23965509 2.39978161 2.57666105\n", + " 2.77296758 2.99185309 3.23706867 3.51312387 3.82546834 4.18073875\n", + " 4.58704087 5.05438059 5.59517832 6.2249668 6.96332613 7.83514604\n", + " 8.87231638 10.11613869 11.62057399 13.45688075 15.72024305 18.53939481\n", + " 22.09098021]\n", + "cNrmGrid for unconstrained cFunc is [0. 0.01235151 0.18691037 0.29541926 0.38070319 0.45312275\n", + " 0.51644051 0.57261755 0.62253956 0.66772112 0.70902525 0.74671381\n", + " 0.77986847 0.81082056 0.8397706 0.86728992 0.89351353 0.91869035\n", + " 0.94296058 0.9662323 0.98732483 1.00628889 1.02460772 1.04277873\n", + " 1.06096172 1.07933575 1.0979846 1.11695897 1.13637025 1.15642563\n", + " 1.17732806 1.19928447 1.22251841 1.24729118 1.27390725 1.30273462\n", + " 1.33419368 1.3688058 1.40720505 1.45016983 1.49866721 1.55391366\n", + " 1.61742883 1.69119491 1.77777206 1.88053049 2.00400672 2.15448643\n", + " 2.3411553 ]\n", + "mNrmGrid for borrowing constrained cFunc is [0. 1.]\n", + "cNrmGrid for borrowing constrained cFunc is [0. 1.]\n" + ] + } + ], + "source": [ + "print('mNrmGrid for unconstrained cFunc is ',IndShockExample.solution[0].cFunc.functions[0].x_list)\n", + "print('cNrmGrid for unconstrained cFunc is ',IndShockExample.solution[0].cFunc.functions[0].y_list)\n", + "print('mNrmGrid for borrowing constrained cFunc is ',IndShockExample.solution[0].cFunc.functions[1].x_list)\n", + "print('cNrmGrid for borrowing constrained cFunc is ',IndShockExample.solution[0].cFunc.functions[1].y_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "The consumption function in this model is an instance of $\\texttt{LowerEnvelope1D}$, a class that takes an arbitrary number of 1D interpolants as arguments to its initialization method. When called, a $\\texttt{LowerEnvelope1D}$ evaluates each of its component functions and returns the lowest value. Here, the two component functions are the *unconstrained* consumption function-- how the agent would consume if the artificial borrowing constraint did not exist for *just this period*-- and the *borrowing constrained* consumption function-- how much he would consume if the artificial borrowing constraint is binding. \n", + "\n", + "The *actual* consumption function is the lower of these two functions, pointwise. We can see this by plotting the component functions on the same figure:" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW0AAAD4CAYAAAAn3bdmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3deXxU5aHG8d+bfSckIWwhBBABFQUMqOAGIsqi1bpgxapt7+XetrfuVdyriFSlYKvWFutSa6u2Wq1lRxYBZVe2EhbZd0hCyEYmy7z3jzMgKJABMjmzPN/PZz4zmZyZPMPycDjnPe9rrLWIiEhoiHI7gIiI+E+lLSISQlTaIiIhRKUtIhJCVNoiIiEkJhBvmpWVZfPy8gLx1iIiYWnp0qWF1tpm9W0XkNLOy8tjyZIlgXhrEZGwZIzZ4s92OjwiIhJCVNoiIiFEpS0iEkJU2iIiIUSlLSISQvwaPWKM2QyUAXVArbU2P5ChRETk2E5myF9fa21hwJKIiEi9dHhERMRtxRv93tTf0rbANGPMUmPM8GNtYIwZboxZYoxZsm/fPr8DiIhErNpqmPMC/P4iv1/ib2n3sdb2AAYCPzfGXPrtDay14621+dba/GbN6r0SU0Qksm2eB3+4GGY+A2de5ffL/Cpta+1O3/1e4COg1ymFFBGJdBVF8PHP4K3BUHsQbv0H3Py23y+v90SkMSYZiLLWlvkeDwCePvXEIiIRyFr46h2Y/jh4yuDie+HSByEu6aTexp/RI82Bj4wxh7b/m7V2ysknFhGJUHvXwIR7YesX0OZCGDIOmp91Sm9Vb2lbazcC553Su4uIRLLqSpg7Bj7/HcSnwLUvQbfbIOrUB+4FZGpWEZGIt/5TmHgflGyB826FASMhOeu031alLSLSkEp3wdSH4T8fQWZHuGMCtLukwd5epS0i0hC8dbD4dZg5Emo90Pcx6HMXxMQ36I9RaYuInK6dy2DCPbDzK2jfFwb/BjI7BORHqbRFRE6VpwxmjoJFf4SkLLjhdTjnBnBG2wWESltE5GRZCwX/hskPQdkuyP8xXPEEJKYH/EertEVETsb+LTD5QVg3BZp3da5mbNOz0X68SltExB91NTD/FfjsOcDAgGfggp9CdOPWqEpbRKQ+Wxc6Jxr3roZOg2Hgc5DexpUoKm0RkeOpLIZPfwVf/hnScuCWv0Hnwa5GUmmLiHybtbDifZj6KBzcDxf9H1z+sHMpustU2iIiRypc71x+vmkOtM6H2z+GFl3dTnWYSltEBKCmCuaNhXnjICYRBo+F8390WpM7BYJKW0RkwyyYeD8Ub4CuN8GAUZDa3O1Ux6TSFpHIVb7XOW698u+Q0R5++BF06Od2qhNSaYtI5PF64cu3nJEhNQfhsofg4vsgNsHtZPVSaYtIZNm9yhlzvX0x5F3iHLtudqbbqfym0haRyFBdAbNHw/zfO3OEXP9HOHdoQCd3CgSVtoiEvzWTnPlCDmyDHrdD/6cgKcPtVKdEpS0i4evAdmcmvjUToFkX+NEUaHuR26lOi0pbRMJPXa0zx/WsZ50VZfr/Ci78OcTEuZ3stKm0RSS8bF8KE+6G3Suh4wAY9AI0zXM7VYNRaYtIeKg6ADOedtZpTG0BN/0ZzvpeyJ1orI9KW0RCm7Ww6kOY+ghU7IML/gf6PgoJaW4nCwiVtoiEruKNzuXnG2ZCy25w6/vQqrvbqQJKpS0ioafWA5//DuaOgahYGPg89PwviIp2O1nAqbRFJLRsngcT7oXCdXDWdXD1aEhr5XaqRqPSFpHQUFEE0x6D5X+D9Fy49R9w5gC3UzU6lbaIBDevF5b9FaY/Dp4yZ2KnS38JcUluJ3OFSltEgtfeAphwH2z9AnIvgiHjILuL26lcpdIWkeBTXQlzXoAvfgfxqXDty9BtWNCtIuMGv0vbGBMNLAF2WGuHBC6SiES09dOdYXwlW+C8W2HASEjOcjtV0DiZPe27gQIgPEesi4i7SnfBlBGw+mPI7Ah3TIB2l7idKuj4VdrGmBxgMDAKuC+giUQksnjrYPGfYMZIqKuGvo9Bn7sgJt7tZEHJ3z3tF4EHgdTjbWCMGQ4MB8jNzT39ZCIS/nYuc1aR2fkVtO8Lg38DmR3cThXU6j2qb4wZAuy11i490XbW2vHW2nxrbX6zZs0aLKCIhCFPGUweAa/1hQM74IbXnUV1Vdj18mdPuw9wrTFmEJAApBlj3rHW3hbYaCISdqyFgk+cwi7bBfk/hiuecJb/Er/UW9rW2oeBhwGMMZcDD6iwReSk7d8Ck34J66dC864w9C+Qk+92qpCjcdoiElh1NTD/ZZj9HJgoGDAKLvhfiFb9nIqT+lWz1s4GZgckiYiEn60LnMmd9q6GzkPg6l9Dehu3U4U0/VMnIg2vshg+fRK+fBvScuCWd6HzILdThQWVtog0HGthxfsw9VE4uB96/wIuGwHxKW4nCxsqbRFpGIXrnUMhm+dCTk8Y8jG06Op2qrCj0haR01NTBfPGwrxxEJvozMTX405N7hQgKm0ROXUbZsHE+5y1GrveBFc9CynZbqcKayptETl55Xud1c9X/gMy2sMPP4YOfd1OFRFU2iLiP68Xlr4Jnz4FtQfhsoeclWRiE9xOFjFU2iLin90rnRON2xdD3iUweCw0O9PtVBFHpS0iJ+Yph9mjYcGrzhwh1/8Rzh0KxridLCKptEXk+NZMcuYLKd0OPW6H/k9BUobbqSKaSltEvuvAdpj8EKyZANlnwY1TIfdCt1MJKm0ROVJdLSz8A8x6FqwX+v8KLvo/iI51O5n4qLRFxLF9KUy42znh2HEADHoBmua5nUq+RaUtEukOlsCMp2HJG5DaAm5+G7pcqxONQUqlLRKprIVVHzoXyVTsc+a47vsIJKS5nUxOQKUtEomKNsCkB2DDTGjVHW5937mXoKfSFokktR74/Hcw5wWIjoOBL0DPn0BUtNvJxE8qbZFIsWmuM7lT4To46zpnFZm0lm6nkpOk0hYJdxWFMO1xWP43SG8Lwz6Ajle6nUpOkUpbJFx5vbDsHZj+BHjKnImdLv0lxCW5nUxOg0pbJBztLXAmd9o6H3J7w5CxkN3F7VTSAFTaIuGkuhLmPA9fvATxqXDty9BtmFaRCSMqbZFwsX46TLwfSrbAebfCgJGQnOV2KmlgKm2RUFe6C6Y8BKv/BVlnwh0ToN0lbqeSAFFpi4Qqbx0s/hPMGAl11dD3MehzF8TEu51MAkilLRKKdi6DCffAzq+gQz8YNAYyO7idShqBSlsklFSVwqxRsGg8JGXBDa/DOTdocqcIotIWCQXWQsEnzsIEZbudS8/7Pe4s/yURRaUtEuz2b3Emd1o/DVp0haHvQE6+26nEJSptkWBVVwPzX4bZz4GJgquehV7/A9H6axvJ6v3dN8YkAHOAeN/2H1hrnwx0MJGItnUB/Pse2FcAnYfAwOegSY7bqSQI+PNPtgfoZ60tN8bEAvOMMZOttQsCnE0k8lQWw6dPwpdvQ5M2cMu70HmQ26kkiNRb2tZaC5T7voz13WwgQ4lEHGth+Xsw7VFn+a/ev4DLRkB8itvJJMj4dXDMGBMNLAXOAF6x1i48xjbDgeEAubm5DZlRJLwVrncmd9o8F3J6wpAXocU5bqeSIOXXLDLW2jprbTcgB+hljPnOnyhr7Xhrbb61Nr9Zs2YNnVMk/NRUwcxR8Gpv2L0ChoyDH09TYcsJndRpaGttiTFmNnA1sCogiUQiwYaZzuROxRuh603OyJCUbLdTSQjwZ/RIM6DGV9iJQH/guYAnEwlHZXuc1c9XfQAZ7eGHH0OHvm6nkhDiz552S+DPvuPaUcDfrbUTAhtLJMx4vbD0Tfj0Kag9CJc95KwkE5vgdjIJMf6MHlkBdG+ELCLhafdKZ8z1jiWQd4lz7Dqro9upJETp0iqRQPGUw+zRsOBVSGwK1/8Rzh2qyZ3ktKi0RQJhzSSY9Eso3Q497oD+v4KkDLdTSRhQaYs0pAPbYdKDsHYiZJ8FN06F3AvdTiVhRKUt0hDqamHhH2DWs2C90P8puOjnEB3rdjIJMyptkdO1fYlzonHPSuh4FQx6AZq2dTuVhCmVtsipOlgCM56GJW9Aaku4+S/Q5RqdaJSAUmmLnCxrYdWHMOVhqCyEC/4X+j0K8aluJ5MIoNIWORlFG5zLzzfOglbdYdg/oFU3t1NJBFFpi/ij1gOf/xbmjIHoOBj4grNOY1S028kkwqi0Reqzaa4zdWrRejj7erhqNKS1dDuVRCiVtsjxVBTCtMdg+buQ3haGfQgd+7udSiKcSlvk27xeWPYOTH8CPGXOxE6X/hLiktxOJqLSFjnK3gLnUMjW+ZDbG4aMhewubqcSOUylLQJQXQlznocvXnKG7l37MnQbBlF+Le4k0mhU2iLrpsGk+6Fkq1PUV46E5Ey3U4kck0pbIlfpLpjyEKz+F2SdCXdOhLyL3U4lckIqbYk83jpY/CeYMRK8NdDvMeh9F8TEu51MpF4qbYksO79yJnfatQw69IPBv3HWahQJESptiQxVpTBrFCwaD8nN4MY34Ozva3InCTkqbQlv1jrHrKeMgLLdzqXn/R6HxHS3k4mcEpW2hK/9m50lv9ZPgxZdYehfIed8t1OJnBaVtoSfuhpnvPVnz4OJgquehV7/A9H64y6hT3+KJbxsme9c0bivADoPgYHPQZMct1OJNBiVtoSHymJnrpCv/gJN2sAP3oNOA91OJdLgVNoS2qyF5e/BtEed5b963wWXj4C4ZLeTiQSESltC1751MPE+2DwXcnrCkBehxTlupxIJKJW2hJ6agzB3LMwb50yXOmQc9LhTkztJRFBpS2jZMBMm3Af7N0HXm+GqUZCS7XYqkUaj0pbQULYHpj4Cqz6AjA7ww4+hQ1+3U4k0OpW2BDevF5a+AZ8+DbUH4bIRcPG9EJvgdjIRV6i0JXjtXulM7rRjCbS7FAaPhayObqcScVW9pW2MaQO8DbQAvMB4a+1vAx1MIpinHGaPhgWvQmJTuH48nHuzJncSwb897Vrgfmvtl8aYVGCpMWa6tXZ1gLNJJFozESY9CKXboccd0P9XkJThdiqRoFFvaVtrdwG7fI/LjDEFQGtApS0Np2QbTH4I1k6E7LPgxmmQe4HbqUSCzkkd0zbG5AHdgYXH+N5wYDhAbm5uA0STiFBXCwtfhVmjwXqh/1Nw0c8hOtbtZCJBye/SNsakAB8C91hrS7/9fWvteGA8QH5+vm2whBK+ti12JnfasxLOvBoGPg9N27qdSiSo+VXaxphYnML+q7X2n4GNJGHvYAnMeAqWvAmpLeHmv0CXa3SiUcQP/oweMcDrQIG1dmzgI0nYshZWfQhTHobKQrjwp9D3EYhPdTuZSMjwZ0+7D/BDYKUxZpnvuUestZMCF0vCTtEGmHg/bJwFrbrDsH9Aq25upxIJOf6MHpkH6P+tcmpqPfD5b2HOGIiOg0FjIP/HEBXtdjKRkKQrIiVwNs1xJncqWg9nXw9XjYa0lm6nEglpKm1peBWFMO0xWP4upLeFYR9Cx/5upxIJCyptaTher7Pc1/QnoLoCLrkfLnnAmfNaRBqESlsaxp7VzpjrbQsgt7ezMEF2Z7dTiYQdlbacnupK+Ow5mP8yxKfB916BbsM05lokQFTacurWTYNJ90PJVqeorxwJyZlupxIJayptOXmlO2HKCFj9L8jqBHdOhLyL3U4lEhFU2uI/bx0seg1mPgPeGuj3GPS+G2Li3E4mEjFU2uKfHV86Jxp3LYMOV8DgMZDR3u1UIhFHpS0nVlXq7Fkvfg2Sm8GNb8DZ39eJRhGXqLTl2KyF1R/D5BFQvgd6/hdc8TgkNHE7mUhEU2nLd+3fDBMfgK+nQ4uucMvfIOd8t1OJCCptOVJttTPe+rPnnQmdrhoNvYZDtP6YiAQL/W0Ux5b5zonGfQXOggRXPwdNWrudSkS+RaUd6SqLnblCvvoLNGkDP3gfOl3tdioROQ6VdqSy1pmFb9pjzvJfve+Cy0dAXLLbyUTkBFTakWjfOudQyJZ5kNPLmdypxTlupxIRP6i0I0nNQZj7G5j3ojNd6pAXoccdEBXldjIR8ZNKO1J8PcNZo3H/Jjh3KAx4BlKy3U4lEhbqvJbK6loqq+uo8Bx9X1ldR0V1LZWeWiqq6w5vV+nxPe/b1l8q7XBXtgemPuysgp7RAW7/F7S/3O1UIq7xei0Ha5zCrPAcXbJOuR76nq9kPbWUe5yy/ebrQ4XsPK6q8fr986OjDElx0STFRZMcF0NSfDRJsf5XsUo7XHm9sPQN+PRpqD0Il42Ai++F2AS3k4n4zVpLVY33cJk6ZemUZ4Wn9pvCPVSyh8r10F7st15T6amlsqYOa/37+XHRUSTF+8o1Lprk+BiS46NpmpxESvwRz8U5zycdeR8XTaLv+05JO/fxMVGYY0wDYX7qXyaVdjjatcI50bhjCbS7FAaPg6wz3E4lEaK2zkuFp44yTw0VnjrKPTWUe+oor3KKtcxXtuWeWsqqvnl8vD1er58FG2UgOT7mqDJNioumVXrC4TJ19mydQj1UwElxR78m2ff9pLgY4mKC73yPSjuceMph9mhY8CokNoXrx8O5N2tyJ6lXndceLs7yQ7eqox8f9T3ftmVVTsEeua2/hwoSYqNI8ZXsobLMSokjNzOJFN9hA2cP9shy/WZv9tAe7qGyPd4ebLhRaYeLggkw+UEo3QHn3wn9f+UUt4Q1r9dSUe2Up3OroayqllLf/ZHPHdqzLT+8B/xNIR+sqfPr58XH+Io2wSnMlIQYslMTaJ/llGvqEc+nxEeTEh9Lcnw0qQkx3zyOjyUpPprY6ODbiw0FKu1QV7LNKeu1kyD7bLjxTci9wO1U4gev11JefXSxflO6333u249Lq2oo99TWe3w2Jso4pekrzlTfHm1eVrJvT/focj10iOHIcj70vIrWfSrtUFVX4xwGmT3a+frKp+HCn0F0rLu5IkxVTR2lB2s4cIxb6cHab31dc3gP+GQLNzUh1ncfQ5uMJFITYkjzPZd2+HvfbJOaEEua7z4hNjIOG0QKlXYo2rYYJtwDe1bBmVfDoBcgPdftVCGrqqaOksoaSg5Wf6doD5Xt8Z7z1J74+G1KfAxNEmNJS3RKNDcj6XC5ph1VtCpc8Y9KO5Qc3A8znoYlb0JqSxj6DnQeohONPtY6J9NKKmvYX1lNcUX14cf7K2vYX1HN/krnOed7zvP1Hc9NTXCK99CtY3bK4cdpvluTY9zSEmKI0eEEaWAq7VBgLaz8wLlIprIILvwp9H0E4lPdThZQXq9lf2U1RRXVFJZ7KCr/5r6owsP+ihqKK78p35LKamrqjn28wRhokhhL06Q40pNiadkkgS4t02iaFEvTZOe59MS4o0s30dnbjY7SP4oSPFTawa5oA0y8DzbOhlbdYdgH0Kqb26lOmae2jn1lHgrLqynyFfC+I4r4UDEXlldTXOE55hjdKAMZyXE0TYqjaXIc7bKS6ZEUR3pSHBnJsaQnOd878nGTRJWvhId6S9sY8wYwBNhrrdVUcI2l1uNM7DT3NxATD4PGQP6PnRVlglBNnZd9ZR72lFaxp9TD3rKqw4/3lFax1/fc/sqaY74+OS6arNR4MpPjaJORRPfcdLJSnK8zU+LJTImjWUo8mSnxpCfGEqUClgjlz572W8DLwNuBjSKHbZrjXNFY9LWz8vlVz0JaS9fiVFbXsrOkip0lB53bgSr2llYdVdBFFdXfGQkRHWXITo0nOy2BtplJ9GqXQfO0eJqlxpOV4twyU+LITI4nMS44/zESCTb1lra1do4xJi/wUYTyfc6iBCveg6Z5MOxD6Ng/4D+2qqaObcWVbC6qZEtRBduKK9nhK+ldBw5+Z+84ykBWSjzN0xJolZ5At9x0slOdr5unxZOdmkDztAQyk+O0RyzSwBrsmLYxZjgwHCA3V8PPTorXC1+9DdOfhOoKuOQBuPQBiE1ssB9xsLqOjYXlbCmqZHNRBVt991uKKtl1oOqobVPjY2jdNJFW6Yn0aJtOq/REWqcn0rJJIq3SnULWRRYi7miw0rbWjgfGA+Tn5/s5xYuwZ7VzKGTbAmjbBwaPhezOp/x2dV7L1uJK1u4upWBXGWt3l7F2TxmbiyqOOnyRlRJH28xkLuqQSduMZPKykmibmUxeZhLpSXEN8MFEJBA0esQt1ZXw2XMw/2WIT4PvvQLdhp3UmOuyqhpW7SilYFcpa3eXsWZ3Kev2lB8ed2wM5GUm06l5Kt/r1oqO2am0zUyibaZzgYeIhB6VthvWTYVJD0DJVuh2m3MJenLmCV/iqa1jza4ylm8vYfm2AyzfXsKGfeWH954zkuPo3CKVW3q1oUuLNDq1SKVj8xSS4vRbLBJO/Bny9y5wOZBljNkOPGmtfT3QwcJS6U6Y/BAUfAJZneDOSZDX5zubWWvZWFjBV1tLWL6thBXbS1i9q/TwhSNZKfGcl9OEa89rxbk5TTirVRrNUuJ1ubNIBPBn9MgPGiNIWPPWwaLxMPMZ8NZCv8eh910Q4xw79not6/aWsWhTMQs3FrNwUzGF5R7Ambuia+sm/OTi9pyX04Rz26TTqkmCClokQun/zoG240tncqddy6HDFTB4DHXp7Vi9s5SFm7azcFMxizcXU+IbVteqSQKXdMyiV7sM8ts2pUOzFA2bE5HDVNqBUnXA2bNe9BqkZFM86I9Msxfx2aRC5n29nrIqZ/XltplJXNmlORe0z+SCdhnkNE3UXrSIHJdKu6FZC6s/xk4eAeV7WJJ9A6OqbmDZPy2wipZNEhh0Tkt6n5HJBe0yadFEC+2KiP9U2g2oYvfXVHx0D9l75lJg2zGi+mnW7OhIz3ZNeTQ/m8s6NaNjdor2pEXklKm0T1NxRTUzV23HzH+Jwfv/QhLRjIm6k+Jz7uCus1pzUYdMkuP1yywiDUNtcgrKPbVMXrmLj5ftoHbj54yMeZ0zo3ZQ0PRyqq4Yxb1nn61pQEUkIFTafqqt8zL360I++nIH01bvJqHmAKNS/s7guBlUp7TGXvMeXToNdDumiIQ5lfYJWGv5z85S/vnlDj5ZvpPCcg9NEmJ4Jm8F1+19lejqUuhzN3GXPQRxyW7HFZEIoNI+hpLKav755Q7eX7yNtXvKiI029OuczW0dPPRZM4qorZ9DTi+45kVofrbbcUUkgqi0fay1LNxUzHuLtjJp1W6qa72c1yadZ647hyFd0klf+hJ8+iLEJcE1v4Xut0OUpicVkcYV8aW9v6KaD5Zu593FW9m4r4LUhBhu6dmGW3rmclarNPh6Brx1P+zfBOcOhQGjIKWZ27FFJEJFbGmv3lnKn7/YzMfLduCp9ZLftik/u+kMBndt6Sx9VbYHPrgHVn0IGR3g9n9B+8vdji0iES6iSru2zsu01Xt464vNLNpUTEJsFN/v0Zo7eufRuUWas5G3zrn0fMZIqD0Ilz8Mfe6BWF25KCLui4jSLvfU8t6irbz5+WZ2lBwkp2kijwzqzM35bY5epWXXCmdypx1Lod1lzioyWWe4F1xE5FvCurR3H6jizS828beFWymrqqVXuwyevOYsrujS/OiLXzzlMOtZWPgqJGXC91+Drjed1CoyIiKNISxLu2BXKa/N2cgny3fitZaBXVvy35e0p1ub9GNsPAEmPwilO+D8H0H/JyGxaeOHFhHxQ1iV9tIt+3ll1tfMXLOXpLhobruwLT+5uB1tMpK+u3HJVmcVmbWTIPtsuOktaNOr0TOLiJyMkC9tay2ff13Ey7PWs2BjMelJsdx35ZncflHbY68qXlcDC16F2aOdr68cCRf+FKK10K2IBL+QLW2v1/JpwR5emb2B5dtKyE6N57HBXfhBr9zjz6q3bRFMuBf2rIIzB8Kg5yE9t3GDi4ichpArba/XMuU/u/ndjPWs2V1Gm4xERl1/Djeen0N8TPSxX3RwP3z6FCx9C1JbwtB3oPMQnWgUkZATMqVtrWXa6j2Mm76ONbvL6NAsmXFDz+Oac1sRE32cy8mthZX/gKmPQGURXPgz6PswxKc2bngRkQYS9KVtrWXW2r2Mnb6OVTtKaZeVzItDu3HNea1OPGd10QaYeB9snA2tesBtH0LL8xott4hIIARtaVtrmbu+kLHT17FsWwm5GUmMuek8rut2gj1rgFoPzBsHc8dCTDwMGgP5P4ao4xw6EREJIUFZ2l9sKGTc9HUs3ryf1umJ/Pr7Xbnh/BxiT1TWABs/c/aui76Gs78PV4+G1BaNE1pEpBEEVWmv2F7Cryev4YsNRbRIS2Dkdedwc/4JTjAeUr4Ppj0KK96HpnnOoZAz+jdKZhGRxhQUpb2lqIIXpq5lwopdZCTH8cSQs7j1glwSYuspa68Xvnobpj8J1RVwyQNw6QMQm9g4wUVEGpmrpV1Y7uGlGev568KtxEZH8Yt+ZzD80vakJvhxocue1c6Y620LoG0fGDIOmnUKfGgRERe5UtoVnlpen7eJP362gapaL0N7tuGeKzqSnebH9KfVFfDZczD/FYhPg+/9HrrdqjHXIhIRGrW067yWD5Zu4zfT1rG3zMNVZzfnl1d15ozsFP/eYN1UmPgAHNgK3W+D/k9DcmZgQ4uIBJFGK+156wt5ZuJq1uwuo3tuOq/e1oPz22b49+IDO2DKQ1Dwb8jqBHdOgrw+gQ0sIhKEAl7a6/eU8eykAmat3UdO00Re+kF3hpzbEuPP4Yy6Wlj8Gsx8Bry1cMUTcNEvIOYYE0GJiEQAv0rbGHM18FsgGviTtfbX9b2msNzDi5+u491F20iKjebhgZ25o3de/SNCDtmx1DnRuGu5M3xv0BjIaOffa0VEwlS9pW2MiQZeAa4EtgOLjTGfWGtXH+81+8o89H1hNpU1dQy7IJe7r+hIZkq8f4mqDjh71oteg5RsuPFNOPt6nWgUEcG/Pe1ewNfW2o0Axpj3gO8Bxy3t3aVVXNk+gxEDu/h/khGc+ULeHATle6DXf0O/xyChif+vFxEJc/6Udmtg2xFfbwcu+PZGxpjhwHCAFm3y+NMdPU8+TdM8OOMK6PkTaH3+yb9eRCTM1TOZBwDHOi5hv/OEteOttfnW2vzW2ac4DC8qGq77vQpbROQ4/Cnt7UCbI77OAXYGJqlp18oAAANYSURBVI6IiJyIP6W9GOhojGlnjIkDbgE+CWwsERE5lnqPaVtra40x/wdMxRny94a19j8BTyYiIt/h1zhta+0kYFKAs4iISD38OTwiIiJBQqUtIhJCVNoiIiFEpS0iEkKMtd+5Tub039SYfcCW03iLLKCwgeKEmkj+7KDPr88fuZ+/k7U2tb6NAjI1q7W22em83hizxFqb31B5Qkkkf3bQ59fnj9zPb4xZ4s92OjwiIhJCVNoiIiEkWEt7vNsBXBTJnx30+fX5I5dfnz0gJyJFRCQwgnVPW0REjkGlLSISQoKqtI0xVxtj1hpjvjbGjHA7T2MyxrxhjNlrjFnldhY3GGPaGGNmGWMKjDH/Mcbc7XamxmKMSTDGLDLGLPd99qfczuQGY0y0MeYrY8wEt7M0NmPMZmPMSmPMsvqG/gXNMW3fAsLrOGIBYeAHJ1pAOJwYYy4FyoG3rbXnuJ2nsRljWgItrbVfGmNSgaXAdZHw+2+MMUCytbbcGBMLzAPuttYucDlaozLG3AfkA2nW2iFu52lMxpjNQL61tt4Li4JpT/vwAsLW2mrg0ALCEcFaOwcodjuHW6y1u6y1X/oelwEFOOuThj3rKPd9Geu7BcfeVCMxxuQAg4E/uZ0l2AVTaR9rAeGI+EsrRzPG5AHdgYXuJmk8vkMDy4C9wHRrbcR8dp8XgQcBr9tBXGKBacaYpb5F0o8rmErbrwWEJbwZY1KAD4F7rLWlbudpLNbaOmttN5w1WHsZYyLmEJkxZgiw11q71O0sLupjre0BDAR+7jtcekzBVNpaQDjC+Y7nfgj81Vr7T7fzuMFaWwLMBq52OUpj6gNc6zuu+x7QzxjzjruRGpe1dqfvfi/wEc7h4mMKptLWAsIRzHcy7nWgwFo71u08jckY08wYk+57nAj0B9a4m6rxWGsfttbmWGvzcP7ez7TW3uZyrEZjjEn2nXzHGJMMDACOO4osaErbWlsLHFpAuAD4eyQtIGyMeReYD3Qyxmw3xvzE7UyNrA/wQ5y9rGW+2yC3QzWSlsAsY8wKnJ2X6dbaiBv2FsGaA/OMMcuBRcBEa+2U420cNEP+RESkfkGzpy0iIvVTaYuIhBCVtohICFFpi4iEEJW2iEgIUWmLiIQQlbaISAj5fyQGHeDRYSOcAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plotFuncs(IndShockExample.solution[0].cFunc.functions,-0.25,5.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simulating the idiosyncratic income shocks model\n", + "\n", + "In order to generate simulated data, an instance of $\\texttt{IndShockConsumerType}$ needs to know how many agents there are that share these particular parameters (and are thus *ex ante* homogeneous), the distribution of states for newly \"born\" agents, and how many periods to simulated. These simulation parameters are described in the table below, along with example values.\n", + "\n", + "| Description | Code | Example value |\n", + "| :---: | --- | --- |\n", + "| Number of consumers of this type | $\\texttt{AgentCount}$ | $10000$ |\n", + "| Number of periods to simulate | $\\texttt{T_sim}$ | $120$ |\n", + "| Mean of initial log (normalized) assets | $\\texttt{aNrmInitMean}$ | $-6.0$ |\n", + "| Stdev of initial log (normalized) assets | $\\texttt{aNrmInitStd}$ | $1.0$ |\n", + "| Mean of initial log permanent income | $\\texttt{pLvlInitMean}$ | $0.0$ |\n", + "| Stdev of initial log permanent income | $\\texttt{pLvlInitStd}$ | $0.0$ |\n", + "| Aggregrate productivity growth factor | $\\texttt{PermGroFacAgg}$ | $1.0$ |\n", + "| Age after which consumers are automatically killed | $\\texttt{T_age}$ | $None$ |\n", + "\n", + "Here, we will simulate 10,000 consumers for 120 periods. All newly born agents will start with permanent income of exactly $P_t = 1.0 = \\exp(\\texttt{pLvlInitMean})$, as $\\texttt{pLvlInitStd}$ has been set to zero; they will have essentially zero assets at birth, as $\\texttt{aNrmInitMean}$ is $-6.0$; assets will be less than $1\\%$ of permanent income at birth.\n", + "\n", + "These example parameter values were already passed as part of the parameter dictionary that we used to create $\\texttt{IndShockExample}$, so it is ready to simulate. We need to set the $\\texttt{track_vars}$ attribute to indicate the variables for which we want to record a *history*." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "IndShockExample.track_vars = ['aNrmNow','mNrmNow','cNrmNow','pLvlNow']\n", + "IndShockExample.initializeSim()\n", + "IndShockExample.simulate()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now look at the simulated data in aggregate or at the individual consumer level. Like in the perfect foresight model, we can plot average (normalized) market resources over time, as well as average consumption:" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(np.mean(IndShockExample.mNrmNow_hist,axis=1))\n", + "plt.xlabel('Time')\n", + "plt.ylabel('Mean market resources')\n", + "plt.show()\n", + "\n", + "plt.plot(np.mean(IndShockExample.cNrmNow_hist,axis=1))\n", + "plt.xlabel('Time')\n", + "plt.ylabel('Mean consumption')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We could also plot individual consumption paths for some of the consumers-- say, the first five:" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(IndShockExample.cNrmNow_hist[:,0:5])\n", + "plt.xlabel('Time')\n", + "plt.ylabel('Individual consumption paths')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Other example specifications of idiosyncratic income shocks consumers\n", + "\n", + "$\\texttt{IndShockConsumerType}$-- and $\\texttt{HARK}$ in general-- can also represent models that are not infinite horizon. \n", + "\n", + "### Lifecycle example\n", + "\n", + "Suppose we wanted to represent consumers with a *lifecycle*-- parameter values that differ by age, with a finite end point beyond which the individual cannot surive. This can be done very easily by simply specifying the time-varying attributes $\\texttt{PermGroFac}$, $\\texttt{LivPrb}$, $\\texttt{PermShkStd}$, and $\\texttt{TranShkStd}$ as Python *lists* specifying the sequence of periods these agents will experience, from beginning to end.\n", + "\n", + "In the cell below, we define a parameter dictionary for a rather short ten period lifecycle, with arbitrarily chosen parameters. For a more realistically calibrated (and much longer) lifecycle model, see the [SolvingMicroDSOPs REMARK](https://github.com/econ-ark/REMARK/blob/master/REMARKs/SolvingMicroDSOPs.md)." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "LifecycleDict={ # Click arrow to expand this fairly large parameter dictionary\n", + " # Parameters shared with the perfect foresight model\n", + " \"CRRA\": 2.0, # Coefficient of relative risk aversion\n", + " \"Rfree\": 1.03, # Interest factor on assets\n", + " \"DiscFac\": 0.96, # Intertemporal discount factor\n", + " \"LivPrb\" : [0.99,0.9,0.8,0.7,0.6,0.5,0.4,0.3,0.2,0.1],\n", + " \"PermGroFac\" : [1.01,1.01,1.01,1.02,1.02,1.02,0.7,1.0,1.0,1.0],\n", + " \n", + " # Parameters that specify the income distribution over the lifecycle\n", + " \"PermShkStd\" : [0.1,0.2,0.1,0.2,0.1,0.2,0.1,0,0,0],\n", + " \"PermShkCount\" : 7, # Number of points in discrete approximation to permanent income shocks\n", + " \"TranShkStd\" : [0.3,0.2,0.1,0.3,0.2,0.1,0.3,0,0,0],\n", + " \"TranShkCount\" : 7, # Number of points in discrete approximation to transitory income shocks\n", + " \"UnempPrb\" : 0.05, # Probability of unemployment while working\n", + " \"IncUnemp\" : 0.3, # Unemployment benefits replacement rate\n", + " \"UnempPrbRet\" : 0.0005, # Probability of \"unemployment\" while retired\n", + " \"IncUnempRet\" : 0.0, # \"Unemployment\" benefits when retired\n", + " \"T_retire\" : 7, # Period of retirement (0 --> no retirement)\n", + " \"tax_rate\" : 0.0, # Flat income tax rate (legacy parameter, will be removed in future)\n", + " \n", + " # Parameters for constructing the \"assets above minimum\" grid\n", + " \"aXtraMin\" : 0.001, # Minimum end-of-period \"assets above minimum\" value\n", + " \"aXtraMax\" : 20, # Maximum end-of-period \"assets above minimum\" value\n", + " \"aXtraCount\" : 48, # Number of points in the base grid of \"assets above minimum\"\n", + " \"aXtraNestFac\" : 3, # Exponential nesting factor when constructing \"assets above minimum\" grid\n", + " \"aXtraExtra\" : [None], # Additional values to add to aXtraGrid\n", + " \n", + " # A few other paramaters\n", + " \"BoroCnstArt\" : 0.0, # Artificial borrowing constraint; imposed minimum level of end-of period assets\n", + " \"vFuncBool\" : True, # Whether to calculate the value function during solution \n", + " \"CubicBool\" : False, # Preference shocks currently only compatible with linear cFunc\n", + " \"T_cycle\" : 10, # Number of periods in the cycle for this agent type \n", + " \n", + " # Parameters only used in simulation\n", + " \"AgentCount\" : 10000, # Number of agents of this type\n", + " \"T_sim\" : 120, # Number of periods to simulate\n", + " \"aNrmInitMean\" : -6.0, # Mean of log initial assets\n", + " \"aNrmInitStd\" : 1.0, # Standard deviation of log initial assets\n", + " \"pLvlInitMean\" : 0.0, # Mean of log initial permanent income\n", + " \"pLvlInitStd\" : 0.0, # Standard deviation of log initial permanent income\n", + " \"PermGroFacAgg\" : 1.0, # Aggregate permanent income growth factor\n", + " \"T_age\" : 11, # Age after which simulated agents are automatically killed \n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this case, we have specified a ten period model in which retirement happens in period $t=7$. Agents in this model are more likely to die as they age, and their permanent income drops by 30\\% at retirement. Let's make and solve this lifecycle example, then look at the $\\texttt{solution}$ attribute." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First element of solution is \n", + "Solution has 11 elements.\n" + ] + } + ], + "source": [ + "LifecycleExample = IndShockConsumerType(**LifecycleDict)\n", + "LifecycleExample.cycles = 1 # Make this consumer live a sequence of periods -- a lifetime -- exactly once\n", + "LifecycleExample.solve()\n", + "print('First element of solution is',LifecycleExample.solution[0])\n", + "print('Solution has', len(LifecycleExample.solution),'elements.')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This was supposed to be a *ten* period lifecycle model-- why does our consumer type have *eleven* elements in its $\\texttt{solution}$? It would be more precise to say that this specification has ten *non-terminal* periods. The solution to the 11th and final period in the model would be the same for every set of parameters: consume $c_t = m_t$, because there is no future. In a lifecycle model, the terminal period is assumed to exist; the $\\texttt{LivPrb}$ parameter does not need to end with a $0.0$ in order to guarantee that survivors die.\n", + "\n", + "We can quickly plot the consumption functions in each period of the model:" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption functions across the lifecycle:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print('Consumption functions across the lifecycle:')\n", + "mMin = np.min([LifecycleExample.solution[t].mNrmMin for t in range(LifecycleExample.T_cycle)])\n", + "LifecycleExample.unpackcFunc() # This makes all of the cFuncs accessible in the attribute cFunc\n", + "plotFuncs(LifecycleExample.cFunc,mMin,5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### \"Cyclical\" example\n", + "\n", + "We can also model consumers who face an infinite horizon, but who do *not* face the same problem in every period. Consider someone who works as a ski instructor: they make most of their income for the year in the winter, and make very little money in the other three seasons.\n", + "\n", + "We can represent this type of individual as a four period, infinite horizon model in which expected \"permanent\" income growth varies greatly across seasons." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "CyclicalDict = { # Click the arrow to expand this parameter dictionary\n", + " # Parameters shared with the perfect foresight model\n", + " \"CRRA\": 2.0, # Coefficient of relative risk aversion\n", + " \"Rfree\": 1.03, # Interest factor on assets\n", + " \"DiscFac\": 0.96, # Intertemporal discount factor\n", + " \"LivPrb\" : 4*[0.98], # Survival probability\n", + " \"PermGroFac\" : [1.082251, 2.8, 0.3, 1.1],\n", + " \n", + " # Parameters that specify the income distribution over the lifecycle\n", + " \"PermShkStd\" : [0.1,0.1,0.1,0.1],\n", + " \"PermShkCount\" : 7, # Number of points in discrete approximation to permanent income shocks\n", + " \"TranShkStd\" : [0.2,0.2,0.2,0.2],\n", + " \"TranShkCount\" : 7, # Number of points in discrete approximation to transitory income shocks\n", + " \"UnempPrb\" : 0.05, # Probability of unemployment while working\n", + " \"IncUnemp\" : 0.3, # Unemployment benefits replacement rate\n", + " \"UnempPrbRet\" : 0.0005, # Probability of \"unemployment\" while retired\n", + " \"IncUnempRet\" : 0.0, # \"Unemployment\" benefits when retired\n", + " \"T_retire\" : 0, # Period of retirement (0 --> no retirement)\n", + " \"tax_rate\" : 0.0, # Flat income tax rate (legacy parameter, will be removed in future)\n", + " \n", + " # Parameters for constructing the \"assets above minimum\" grid\n", + " \"aXtraMin\" : 0.001, # Minimum end-of-period \"assets above minimum\" value\n", + " \"aXtraMax\" : 20, # Maximum end-of-period \"assets above minimum\" value\n", + " \"aXtraCount\" : 48, # Number of points in the base grid of \"assets above minimum\"\n", + " \"aXtraNestFac\" : 3, # Exponential nesting factor when constructing \"assets above minimum\" grid\n", + " \"aXtraExtra\" : [None], # Additional values to add to aXtraGrid\n", + " \n", + " # A few other paramaters\n", + " \"BoroCnstArt\" : 0.0, # Artificial borrowing constraint; imposed minimum level of end-of period assets\n", + " \"vFuncBool\" : True, # Whether to calculate the value function during solution \n", + " \"CubicBool\" : False, # Preference shocks currently only compatible with linear cFunc\n", + " \"T_cycle\" : 4, # Number of periods in the cycle for this agent type \n", + " \n", + " # Parameters only used in simulation\n", + " \"AgentCount\" : 10000, # Number of agents of this type\n", + " \"T_sim\" : 120, # Number of periods to simulate\n", + " \"aNrmInitMean\" : -6.0, # Mean of log initial assets\n", + " \"aNrmInitStd\" : 1.0, # Standard deviation of log initial assets\n", + " \"pLvlInitMean\" : 0.0, # Mean of log initial permanent income\n", + " \"pLvlInitStd\" : 0.0, # Standard deviation of log initial permanent income\n", + " \"PermGroFacAgg\" : 1.0, # Aggregate permanent income growth factor\n", + " \"T_age\" : None, # Age after which simulated agents are automatically killed \n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This consumer type's parameter dictionary is nearly identical to the original infinite horizon type we made, except that each of the time-varying parameters now have *four* values, rather than just one. Most of these have the same value in each period *except* for $\\texttt{PermGroFac}$, which varies greatly over the four seasons. Note that the product of the four \"permanent\" income growth factors is almost exactly 1.0-- this type's income does not grow on average in the long run!\n", + "\n", + "Let's make and solve this consumer type, then plot his quarterly consumption functions:" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\janro\\Desktop\\HARK\\HARK\\interpolation.py:1675: RuntimeWarning: All-NaN slice encountered\n", + " y = np.nanmin(fx,axis=1)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quarterly consumption functions:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "CyclicalExample = IndShockConsumerType(**CyclicalDict)\n", + "CyclicalExample.cycles = 0 # Make this consumer type have an infinite horizon\n", + "CyclicalExample.solve()\n", + "\n", + "CyclicalExample.unpackcFunc()\n", + "print('Quarterly consumption functions:')\n", + "mMin = min([X.mNrmMin for X in CyclicalExample.solution])\n", + "plotFuncs(CyclicalExample.cFunc,mMin,5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The very low green consumption function corresponds to the quarter in which the ski instructors make most of their income. They know that they are about to experience a 70% drop in \"permanent\" income, so they do not consume much *relative to their income this quarter*. In the other three quarters, *normalized* consumption is much higher, as current \"permanent\" income is low relative to future expectations. In *level*, the consumption chosen in each quarter is much more similar" + ] + } + ], + "metadata": { + "@webio": { + "lastCommId": "779f6c5616b04b58baaaa0f6c348270c", + "lastKernelId": "a944b08f-0ae0-4c26-883f-9fab53a82ac3" + }, + "cite2c": { + "citations": { + "6202365/HQ6H9JEI": { + "DOI": "10.1016/j.econlet.2005.09.013", + "URL": "http://econ.jhu.edu/people/ccarroll/EndogenousArchive.zip", + "author": [ + { + "family": "Carroll", + "given": "Christopher D." + } + ], + "container-title": "Economics Letters", + "id": "6202365/HQ6H9JEI", + "issued": { + "month": 9, + "year": 2006 + }, + "page": "312–320", + "page-first": "312", + "title": "The Method of Endogenous Gridpoints for Solving Dynamic Stochastic Optimization Problems", + "type": "article-journal" + } + } + }, + "jupytext": { + "cell_metadata_filter": "collapsed,code_folding", + "formats": "ipynb,py:percent" + }, + "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.3" + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Documentation/notebooks/Jounery_1_param.py b/Documentation/notebooks/Jounery_1_param.py new file mode 100644 index 000000000..cf012e692 --- /dev/null +++ b/Documentation/notebooks/Jounery_1_param.py @@ -0,0 +1,158 @@ +''' +Set if parameters for the first journey +''' +from __future__ import division, print_function +from copy import copy +import numpy as np + +# ----------------------------------------------------------------------------- +# --- Define all of the parameters for the perfect foresight model ------------ +# ----------------------------------------------------------------------------- + +CRRA = 2.0 # Coefficient of relative risk aversion +Rfree = 1.03 # Interest factor on assets +DiscFac = 0.96 # Intertemporal discount factor +LivPrb = [1.0] # Survival probability +PermGroFac = [1.0] # Permanent income growth factor +AgentCount = 10000 # Number of agents of this type (only matters for simulation) +aNrmInitMean = 0.0 # Mean of log initial assets (only matters for simulation) +aNrmInitStd = 1.0 # Standard deviation of log initial assets (only for simulation) +pLvlInitMean = 0.0 # Mean of log initial permanent income (only matters for simulation) +pLvlInitStd = 0.0 # Standard deviation of log initial permanent income (only matters for simulation) +PermGroFacAgg = 1.0 # Aggregate permanent income growth factor (only matters for simulation) +T_age = None # Age after which simulated agents are automatically killed +T_cycle = 1 # Number of periods in the cycle for this agent type + +# Make a dictionary to specify a perfect foresight consumer type +init_perfect_foresight = { 'CRRA': CRRA, + 'Rfree': Rfree, + 'DiscFac': DiscFac, + 'LivPrb': LivPrb, + 'PermGroFac': PermGroFac, + 'AgentCount': AgentCount, + 'aNrmInitMean' : aNrmInitMean, + 'aNrmInitStd' : aNrmInitStd, + 'pLvlInitMean' : pLvlInitMean, + 'pLvlInitStd' : pLvlInitStd, + 'PermGroFacAgg' : PermGroFacAgg, + 'T_age' : T_age, + 'T_cycle' : T_cycle + } + +# ----------------------------------------------------------------------------- +# --- Define additional parameters for the idiosyncratic shocks model --------- +# ----------------------------------------------------------------------------- + +# Parameters for constructing the "assets above minimum" grid +aXtraMin = 0.001 # Minimum end-of-period "assets above minimum" value +aXtraMax = 20 # Maximum end-of-period "assets above minimum" value +aXtraExtra = [None] # Some other value of "assets above minimum" to add to the grid, not used +aXtraNestFac = 3 # Exponential nesting factor when constructing "assets above minimum" grid +aXtraCount = 48 # Number of points in the grid of "assets above minimum" + +# Parameters describing the income process +PermShkCount = 7 # Number of points in discrete approximation to permanent income shocks +TranShkCount = 7 # Number of points in discrete approximation to transitory income shocks +PermShkStd = [0.1] # Standard deviation of log permanent income shocks +TranShkStd = [0.2] # Standard deviation of log transitory income shocks +UnempPrb = 0.005 # Probability of unemployment while working +UnempPrbRet = 0.005 # Probability of "unemployment" while retired +IncUnemp = 0.3 # Unemployment benefits replacement rate +IncUnempRet = 0.0 # "Unemployment" benefits when retired +tax_rate = 0.0 # Flat income tax rate +T_retire = 0 # Period of retirement (0 --> no retirement) + +# A few other parameters +BoroCnstArt = 0.0 # Artificial borrowing constraint; imposed minimum level of end-of period assets +CubicBool = True # Use cubic spline interpolation when True, linear interpolation when False +vFuncBool = False # Whether to calculate the value function during solution + +# Make a dictionary to specify an idiosyncratic income shocks consumer +init_idiosyncratic_shocks = { 'CRRA': CRRA, + 'Rfree': Rfree, + 'DiscFac': DiscFac, + 'LivPrb': LivPrb, + 'PermGroFac': PermGroFac, + 'AgentCount': AgentCount, + 'aXtraMin': aXtraMin, + 'aXtraMax': aXtraMax, + 'aXtraNestFac':aXtraNestFac, + 'aXtraCount': aXtraCount, + 'aXtraExtra': [aXtraExtra], + 'PermShkStd': PermShkStd, + 'PermShkCount': PermShkCount, + 'TranShkStd': TranShkStd, + 'TranShkCount': TranShkCount, + 'UnempPrb': UnempPrb, + 'UnempPrbRet': UnempPrbRet, + 'IncUnemp': IncUnemp, + 'IncUnempRet': IncUnempRet, + 'BoroCnstArt': BoroCnstArt, + 'tax_rate':0.0, + 'vFuncBool':vFuncBool, + 'CubicBool':CubicBool, + 'T_retire':T_retire, + 'aNrmInitMean' : aNrmInitMean, + 'aNrmInitStd' : aNrmInitStd, + 'pLvlInitMean' : pLvlInitMean, + 'pLvlInitStd' : pLvlInitStd, + 'PermGroFacAgg' : PermGroFacAgg, + 'T_age' : T_age, + 'T_cycle' : T_cycle + } + +# Make a dictionary to specify a lifecycle consumer with a finite horizon + +# ----------------------------------------------------------------------------- +# ----- Define additional parameters for the aggregate shocks model ----------- +# ----------------------------------------------------------------------------- +MgridBase = np.array([0.1,0.3,0.6,0.8,0.9,0.98,1.0,1.02,1.1,1.2,1.6,2.0,3.0]) # Grid of capital-to-labor-ratios (factors) + +# Parameters for a Cobb-Douglas economy +PermGroFacAgg = 1.00 # Aggregate permanent income growth factor +PermShkAggCount = 1 # Number of points in discrete approximation to aggregate permanent shock dist +TranShkAggCount = 1 # Number of points in discrete approximation to aggregate transitory shock dist +PermShkAggStd = 0.00 # Standard deviation of log aggregate permanent shocks +TranShkAggStd = 0.00 # Standard deviation of log aggregate transitory shocks +DeprFac = 0.025 # Capital depreciation rate +CapShare = 0.36 # Capital's share of income +DiscFacPF = DiscFac # Discount factor of perfect foresight calibration +CRRAPF = CRRA # Coefficient of relative risk aversion of perfect foresight calibration +intercept_prev = 0.0 # Intercept of aggregate savings function +slope_prev = 1.0 # Slope of aggregate savings function +verbose_cobb_douglas = True # Whether to print solution progress to screen while solving +T_discard = 200 # Number of simulated "burn in" periods to discard when updating AFunc +DampingFac = 0.5 # Damping factor when updating AFunc; puts DampingFac weight on old params, rest on new +max_loops = 20 # Maximum number of AFunc updating loops to allow + +# Make a dictionary to specify an aggregate shocks consumer +init_agg_shocks = copy(init_idiosyncratic_shocks) +del init_agg_shocks['Rfree'] # Interest factor is endogenous in agg shocks model +del init_agg_shocks['CubicBool'] # Not supported yet for agg shocks model +del init_agg_shocks['vFuncBool'] # Not supported yet for agg shocks model +init_agg_shocks['PermGroFac'] = [1.0] +init_agg_shocks['MgridBase'] = MgridBase +init_agg_shocks['aXtraCount'] = 24 +init_agg_shocks['aNrmInitStd'] = 0.0 +init_agg_shocks['LivPrb'] = LivPrb + + +# Make a dictionary to specify a Cobb-Douglas economy +init_cobb_douglas = {'PermShkAggCount': PermShkAggCount, + 'TranShkAggCount': TranShkAggCount, + 'PermShkAggStd': PermShkAggStd, + 'TranShkAggStd': TranShkAggStd, + 'DeprFac': DeprFac, + 'CapShare': CapShare, + 'DiscFac': DiscFacPF, + 'CRRA': CRRAPF, + 'PermGroFacAgg': PermGroFacAgg, + 'AggregateL':1.0, + 'act_T':1200, + 'intercept_prev': intercept_prev, + 'slope_prev': slope_prev, + 'verbose': verbose_cobb_douglas, + 'T_discard': T_discard, + 'DampingFac': DampingFac, + 'max_loops': max_loops + } diff --git a/Documentation/notebooks/Journey_1_PhD.ipynb b/Documentation/notebooks/Journey_1_PhD.ipynb new file mode 100644 index 000000000..63aa8582a --- /dev/null +++ b/Documentation/notebooks/Journey_1_PhD.ipynb @@ -0,0 +1,435 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Journey 1: 1st year PhD student \n", + "====\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1 Introduction\n", + "\n", + "This notebook is a one of the possible journeys into HARK - the Python package designed to solve economic models with the heterogeneous agents. As it is a \"journey\", it is not a one big tutorial, but a set of the links to the notebooks/other resources which will help you understand the different HARK objects and functionalities.\n", + "\n", + "This journey does not require a special skill in programing. However, we propose a few introductions to Python and object-oriented programing (OOP), to make you familiar with the basic concepts. Moreover, we assume some knowledge in the economic theory.\n", + "\n", + "As you have found this journey, you probably have a concept of heterogeneous agent model, but here is a short recap. Think about a basic infinitely lived consumer problem as you know from first-year graduate courses (letting alone the companies and general equilibrium). Using the Bellman equation, we can write it as:\n", + "\n", + "\\begin{eqnarray*}\n", + "V(M_t) &=& \\max_{C_t} U(C_t) + \\beta V(M_{t+1}), \\\\\n", + "& s.t. & \\\\\n", + "A_t &=& M_t - C_t, \\\\\n", + "M_{t+1} &=& R (M_{t}-C_{t}) + Y_t, \\\\\n", + "\\end{eqnarray*}\n", + "\n", + "\n", + "Where $\\beta <1$ is a discount factor, $C_t$ is a consumption, $A_t$ - assets, $Y_t$ - income and $U(C)$ is a standard CRRA utility function:\n", + "\n", + "$$\n", + "U(C)=\\frac{C^{1-\\rho}}{1-\\rho}\n", + "$$\n", + "Now assume that every consumer faces some uncertainty on hers income (e.g. it follows AR (1) process), which is idiosyncratic - the realizations of each shock is (potentially) different for each agent. In this setting the bellman equation looks like:\n", + "\\begin{eqnarray*}\n", + "V(M_t, Y_t) &=& \\max_{C_t} U(C_t) + E\\[\\beta V(M_{t+1}, Y_{t+1})\\], \\\\\n", + "& s.t. & \\\\\n", + "A_t &=& M_t - C_t, \\\\\n", + "M_{t+1} &=& R (M_{t}-C_{t}) + Y_t, \\\\\n", + "\\end{eqnarray*}\n", + "\n", + "Therefore, finding a distribution of agent assets (consumption, savings) involves many much more advanced numerical tools than in the case of a representative agent. Obviously, this is more demanding to master. Moreover, the knowledge about involved numerical methods is less systematic, and often hard to find. It was mentioned in the HARK manual:\n", + "\n", + "*\"After months of effort, you may have had the character-improving experience of\n", + "proudly explaining to your adviser that not only had you grafted two ideas\n", + "together, you also found a trick that speeded the solution by an order of\n", + "magnitude, only to be told that your breathtaking insight had been understood\n", + "for many years, as reflected in an appendix to a 2008 paper; or, worse, your\n", + "discovery was something that “everybody knows” but did not exist at all in\n", + "published form!\"*\n", + "\n", + "\n", + "HARK was designed to help you avoid similar experiences. We see two main ways how you can use this package:\n", + "\n", + "- To simulate the standard heterogeneous agent models without learning all the numerical methods\n", + "- To solve your own models building-on the already implemented algorithms \n", + "\n", + "This journey will help you mostly with using HARK in the first way. We do not elaborate here the numerical methods, however in the last sections you can find some guidance which were used and how the source code is structured. \n", + "\n", + "Although using the prepared package is easier than writing your own solution (what sooner or later you will need to do if you create an original heterogeneous agent model), you still need some effort to comprehend the main classes and functionalities of HARK. We hope that this journey will make this easier! We believe that it also will be your first step into the world of the heterogeneous agents modeling.\n", + "\n", + "---\n", + "NOTE\n", + "***\n", + "We will be very happy to see your feedback. If you have any questions regarding this tutorial or HARK as a whole please see our [Github page](https://github.com/econ-ark/HARK). \n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2 Before you start\n", + "\n", + "As we have mentioned before, this journey does not require a special skill in programing. However, some knowledge about Python and object-oriented programing (OOP) is needed. We propose two possible ways to gather the basic concepts, however, plenty of others are available:\n", + "\n", + "- Quick introduction to Python and OOP: the first three chapters from [Quantecon](https://lectures.quantecon.org/py/index_postgrad.html) should familiarize you with everything what you need for the first tutorials.\n", + "- A little longer introduction (if you want to learn something about used numerical methods):\n", + " - Start with the basic Python [tutorial](https://docs.python.org/3/tutorial)\n", + " - Get some knowledge about [Numpy](https://docs.scipy.org/doc/numpy/user/quickstart.html)\n", + "- You can also learn Python by learning Machine learning, as there are many tutorials constructed in that way. For example [scikit-learn tutorials](https://scikit-learn.org/stable/tutorial/index.html). " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3 Few words about HARK structure\n", + "\n", + "HARK was written using OOP (we hope that you skimmed the tutorials and have some understanding of this). This means that different parts of the model, like different type of consumers', firms, general equilibrium conditions (if you have these components in the model) are implemented as different objects.\n", + "\n", + "Such structure enables you to build your own models with different consumer type distributions / company structure (if you want some). Importantly, learning the package with a such structure implies learning the different types of objects (classes). In HARK there are two main classes: $\\texttt{Agent-type}$ (think consumers, macroeconomic models) and $\\texttt{Market}$ (think general equilibrium, macro models). As Agent-type objects are the attributes of the Market, we first present you this type (additionally, if you are interested only in microeconomic research, you may not want to study the Market class).\n", + "\n", + "However, only two classes cannot accommodate the huge variety of the currently used models. Thus, each of the classes have subclasses and they have their own subclasses... In general more sophisticated class is a subclass. This journey will reflect this structure, by showing you first the most primitive models, then go ahead to the more fancy ones.\n", + "\n", + "---\n", + "NOTE\n", + "***\n", + "In OOP objects are organized in **classes** (the general structure of the objects) and more specific **subclasses**. The subclass inherits the methods and attributes from the its parent class. Thus everything which you can do with the object from a general class can be done with the object from its subclass. Therefore, in case of the economic models the basic one are always the parent classes of the more sophisticated ones. \n", + "\n", + "---\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4 Agent-type class \n", + "Agent-type class enables you to build the macroeconomic models, such as presented in the introduction. It is also the essential part of the macroeconomic model in HARK. Therefore, to use HARK, you always need to use agent-type classes! \n", + "### 4.1 Introductory example\n", + "As an example, let's solve the stochastic model from the introduction. Assume the income process of the agent i in the period t: $Y_{i,t}$, is given by: \n", + "\n", + "\\begin{eqnarray*} \n", + "Y_{i,t} &=& \\varepsilon_t(\\theta_{i,t} p_{i,t}) \\\\\n", + "p_{i,t+1} &=& p_{i,t}\\psi_{i,t+1}\\\\\n", + "\\psi_{i,t} & \\sim & N(1,\\sigma_{\\varrho})\\\\\n", + "\\theta_{i,t} & \\sim & N(1,\\sigma_{\\theta})\\\\\n", + "\\end{eqnarray*}\n", + "\n", + "To get a universal solution of this problem we need to find a policy function (in this case consumption function), we can easily use the HARK solve function. Before we need to declare our model (we assume standard parametrization: R= 1.03, $\\rho = 2$, $\\beta = 0.96$, $P(\\varepsilon=0)= 0.005$, $P(\\varepsilon=1)= 0.995$, $\\sigma_{\\psi}= \\sigma_{\\theta}=0.1)$:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'<' not supported between instances of 'NoneType' and 'NoneType'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0mHARK\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mutilities\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mplotFuncs\u001b[0m \u001b[1;31m#useful function\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0mExample\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mIndShockConsumerType\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0mParams\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minit_idiosyncratic_shocks\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32m~\\Desktop\\HARK\\HARK\\ConsumptionSaving\\ConsIndShockModel.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, cycles, time_flow, verbose, quiet, **kwds)\u001b[0m\n\u001b[0;32m 1793\u001b[0m \u001b[1;31m# Add consumer-type specific objects, copying to create independent versions\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 1794\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msolveOnePeriod\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msolveConsIndShock\u001b[0m \u001b[1;31m# idiosyncratic shocks solver\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1795\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# Make assets grid, income process, terminal solution\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 1796\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 1797\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\Desktop\\HARK\\HARK\\ConsumptionSaving\\ConsIndShockModel.py\u001b[0m in \u001b[0;36mupdate\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 1848\u001b[0m '''\n\u001b[0;32m 1849\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mupdateIncomeProcess\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1850\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mupdateAssetsGrid\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 1851\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mupdateSolutionTerminal\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 1852\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\Desktop\\HARK\\HARK\\ConsumptionSaving\\ConsIndShockModel.py\u001b[0m in \u001b[0;36mupdateAssetsGrid\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 1831\u001b[0m \u001b[0mnone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 1832\u001b[0m '''\n\u001b[1;32m-> 1833\u001b[1;33m \u001b[0maXtraGrid\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mconstructAssetsGrid\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 1834\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0maXtraGrid\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0maXtraGrid\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 1835\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0maddToTimeInv\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'aXtraGrid'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\Desktop\\HARK\\HARK\\ConsumptionSaving\\ConsIndShockModel.py\u001b[0m in \u001b[0;36mconstructAssetsGrid\u001b[1;34m(parameters)\u001b[0m\n\u001b[0;32m 2441\u001b[0m \u001b[1;32mif\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2442\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0ma\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[0maXtraGrid\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2443\u001b[1;33m \u001b[0mj\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0maXtraGrid\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msearchsorted\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2444\u001b[0m \u001b[0maXtraGrid\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minsert\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0maXtraGrid\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2445\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mTypeError\u001b[0m: '<' not supported between instances of 'NoneType' and 'NoneType'" + ] + } + ], + "source": [ + "import sys #set path of the notebook \n", + "import os\n", + "sys.path.insert(0, os.path.abspath('../../.'))\n", + "from HARK.ConsumptionSaving.ConsIndShockModel import * #import the module for the idiosyncratic shocks\n", + "#we previously defined the paramters to not bother you about it now\n", + "import Documentation.notebooks.Jounery_1_param as Params #imported paramters \n", + "from HARK.utilities import plotFuncs #useful function\n", + "\n", + "Example = IndShockConsumerType(**Params.init_idiosyncratic_shocks) \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we can solve the model and plot the consumption function:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Example.solve()\n", + "min_v = Example.solution[0].mNrmMin #minimal value for which the consumption function is defined\n", + "max_v = 20\n", + "print(\"Consumption function\")\n", + "plotFuncs([Example.solution[0].cFunc],min_v,max_v)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.2 The Agent-Type structure\n", + "To understand the microeconomic models in HARK, you need to have some concept of the Agent-type class structure. As it was mentioned, in HARK more advanced models are subclasses of the more primitive ones. The diagram, illustrates this structure: the deterministic class $\\texttt{PerfForesightConsumerType}$, is then a parent for the class of the consumers with idiosyncratic income shocks $\\texttt{IndShockConsumerType}$. Next there is a class with the idiosyncratic and aggregate income shocks $\\texttt{𝙼𝚊𝚛𝚔𝚘𝚟ConsumerType}$. However, it is not the end! There are subclass of the $\\texttt{AggShockConsumerType}$ which are designed to be integrated with the macroeconomic models (we will discuss them in the section devoted to the Market class), as well as there are many other subclasses (which we will mention in the supplementary section).\n", + "\n", + "![HARK structure](../notebooks/HARK_struct_2.png)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.3 Main tutorials\n", + "\n", + "To reflect the agent-type structure, we propose Quickstart to be your first HARK notebook as it is devoted to the deterministic case. Then proceed to the idiosyncratic consumers and then consumers with aggregate and idiosyncratic shocks. The exact order of the suggested tutorials is given in the table.\n", + "\n", + "\n", + "|Number | Tutorial | Description|\n", + "| :---- | :---- | :---- |\n", + "|1 |[Quickstart](../notebooks/Quickstart_tutorial/Quick_start_with_solution.ipynb) |This tutorial familiarize you with the basic HARK objects and functionalities.
You will learn how to create, solve, plot and simulate the deterministic
microeconomic models ($\\texttt{PerfForesightConsumerType}$ class).|\n", + "|2 |[Idiosyncratic consumers](../notebooks/IndShockConsumerType.ipynb) |In this tutorial you will learn how to deal
with the microeconomic models with agents with idiosyncratic shocks:
individual productivity shocks ($\\texttt{IndShockConsumerType}$ class). It builds on the Quickstart. | \n", + "|3|[Nondurables during great recession](../notebooks/Nondurables-During-Great-Recession.ipynb)| Use you knowledge about HARK to conduct a few economic experiments!
You will examine the effects of the uncertinity increase on the heterogenous
agents with idiosyncratic income risk.|\n", + "|4|[Chinese-Growth](../notebooks/Chinese-Growth.ipynb.ipynb)|Learn how to dealt with models with idiosyncratic
and aggregate risk ($\\texttt{𝙼𝚊𝚛𝚔𝚘𝚟ConsumerType}$ class).
Next build advanced simulation with many agent types.|\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.4 Supplementary tutorials\n", + "\n", + "The aforementioned four tutorials are the most essential ones. However, in HARK there are a few other classes, with a similar but, not-the same structure as three basic ones. Here is a list of the notebooks which familiarize you with them (if you so wish, as it is not required to understand the next topics).\n", + "\n", + "|Number | Tutorial | Description|\n", + "| :---- | :---- | :---- |\n", + "|1* |[Kinked consumer](../notebooks/KinkedRconsumerType.ipynb) | $\\texttt{KinkedConsumerType}$ is a subclass of $\\texttt{IndShockConsumerType}$.
In enables to set different borrowing and lending interest rate. |\n", + "|2* |[Buffer-stock consumer](../notebooks/TractableBufferStockQuickDemo.ipynb) | In the Buffer Stock model, the unemployment state (zero income stat) is irreversible.
This framework is implemented by $\\texttt{TractableConsumerType}$ class.
For the analytical properties of buffer stock model check this [lecture notes](http://www.econ2.jhu.edu/people/ccarroll/public/LectureNotes/Consumption/TractableBufferStock/).| \n", + "|3*|[Generalized income process](../notebooks/IndShockConsumerType.ipynb)| In $\\texttt{IndShockConsumerType}$ class, the idiosyncratic income shocks
were assumed to be or purely permanent or purely transitory. In the similar class
$\\texttt{PersistentShockConsumerType}$ the income shocks follows AR(1) process with parameter <1,
thus there are not full permanent nor transitory
(it was called generalized income process).|\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5 Market class\n", + "\n", + "In macroeconomic models, the consumers are only one type of agents. In such models, the economy contains also firms and a government (or other types of agents). In HARK, several standard macro models were implemented using the **Market** class and its subclasses. \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5.1 Introductory example\n", + "\n", + "Let's extend our model from the previous section. Assume the prefect competition and Cobb-Douglas production function:\n", + "\n", + "\\begin{eqnarray*}\n", + "y_t = k_t^{\\alpha} n_t^{1-\\alpha}\n", + "\\end{eqnarray*}\n", + "Thus producers' problem is:\n", + "\\begin{eqnarray*}\n", + "\\max_{k_t, n_t} &\\: k_t^{\\alpha} n_t^{1-\\alpha} - (R_t +\\delta)k_t-w_t n_t \n", + "\\end{eqnarray*}\n", + "\n", + "Where $k_t$ is a capital, $n_t$ labour, $\\delta$ is a depreciation rate. \n", + "\n", + "In this case, consumers' income is determined by the wage:\n", + "\n", + "\\begin{eqnarray*}\n", + "V(M_{i,t}, Y_{i,t}) &=& \\max_{C_{i,t}, M_{i,t+1}} U(C_{i,t}) + E[\\beta V(M_{i,t+1}, Y_{i,t+1})], \\\\\n", + "& s.t. & \\\\\n", + "A_{i,t} &=& M_{i,t} - C_{i,t}, \\\\\n", + "M_{i,t+1} &=& R_{t+1} (M_{i,t}-C_{i,t}) + w_{t+1} Y_{i,t+1}, \\\\\n", + "\\end{eqnarray*}\n", + "\n", + "Additionally, assume that the distribution of the consumers over capital is given by the measure $\\Gamma_t$. To close the economy, there are the market clearing conditions:\n", + "\\begin{eqnarray*}\n", + "n_t &= \\int Y{_i,t} d \\Gamma_t \\\\\n", + "k_{t+1} &= \\int A_{i,t}^i d \\Gamma_t \\\\\n", + "k_{t+1}+ \\int C_{i,t} d\\Gamma_t &= y_t+(1-\\delta)k_t\n", + "\\end{eqnarray*}\n", + "\n", + "In HARK, you can solve this basic case by using **CobbDouglasEconomy** class. However, to add the consumers to the economy you need **AggShockConsumerType** class, which is a subclass of **IndShockConsumerType** Let's declare the economy (assuming depreciation rate $delta = 0.025$): \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "from HARK.ConsumptionSaving.ConsAggShockModel import * #module with the economy classes\n", + "\n", + "AggShockExample = AggShockConsumerType(**Params.init_agg_shocks) #declare the consumer, using the previously prepared parameters \n", + "\n", + "# Make a Cobb-Douglas economy for the agents\n", + "EconomyExample = CobbDouglasEconomy(agents=[AggShockExample], **Params.init_cobb_douglas)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, you can solve the economy and plot the aggregate savings function: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "EconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks\n", + "\n", + "# Have the consumers inherit relevant objects from the economy\n", + "AggShockExample.getEconomyData(EconomyExample)\n", + "\n", + "AggShockExample.solve() #solve the model\n", + "\n", + "print(\"capital-level steady state: \", EconomyExample.kSS) #print the capital-level steady stae\n", + "\n", + "plotFuncs(AggShockExample.AFunc,0.1,2*EconomyExample.kSS) # plot the aggregate savings function\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5.2 Market class structure\n", + "\n", + "As in case of the agent-type the more complicated macroeconomic models are the subclasses of the more primitive ones. The subclasses of Market include $\\texttt{CobbDouglasEconomy}$ and $\\texttt{SmallOpenEconomy}$. The main difference between them is that for $\\texttt{CobbDouglasEconomy}$, the capital and labour prices are endogenous, while in the (small) open economy class there are set exogenously. Nevertheless, both basic classes enable the aggregate fluctuation in the economy, that is:\n", + "\n", + "\\begin{eqnarray*} \n", + "Y_{i,t} &=& \\varepsilon_t(\\epsilon_{i,t}p_{i,t}\\Theta_t P_t )\\\\\n", + "P_{t+1} &=& P_{t}\\Psi_{t+1}\\\\\n", + "\\Psi_{t} &\\sim & {N}(1,\\sigma_{\\Psi})\\\\\n", + "\\Theta_t &\\sim &{N}(1,\\sigma_{\\Theta})\\\\\n", + "\\end{eqnarray*}\n", + "\n", + "Therefore, the consumers, which are attributes of such market classes, need to include the aggregate fluctuations of the whole economy in their optimization problem. This is the reason why the $\\texttt{AggShockConsumerType}$ consumer type class (and their subclasses) must be used to construct the macro-model. \n", + "\n", + "The subclass of $\\texttt{CobbDouglasEconomy}$ is $\\texttt{CobbDouglasMarkovEconomy}$. In this setting, in the economy there exist an additional aggregate fluctuation, which distribution is given by the finite Markov matrix. \n", + "\n", + "\n", + "![HARK_struct_2](../notebooks/HARK_struct_4.png)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5.3 Tutorial\n", + "\n", + "To learn the functionalities of the market type classes in HARK we suggest to study a notebook devoted to [Krussel-Smith economy](../notebooks/KrusellSmith.ipynb). In this notebook classical [Krussell-Smith model](https://www.journals.uchicago.edu/doi/abs/10.1086/250034?journalCode=jpe) is implemented (with some extensions) using $\\texttt{CobbDouglasMarkovEconomy}$ class. \n", + "\n", + "Before, you can also check the main function from [ConsAggShockModel module](https://github.com/econ-ark/HARK/blob/master/HARK/ConsumptionSaving/ConsAggShockModel.py) to see the basic steps to create the market type objects. \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 5.3.1 If you want to learn (a little) how the Market class works\n", + "\n", + "The Market class was designed to be a general framework for many different macro models. It involves a procedure of aggregating the agents' choices: eg. aggregating consumption and savings ($\\texttt{reap_vars}$ in the code) and then transforming the aggregated variables ($\\texttt{mill_rule}$ n the code). \n", + "\n", + "If you would like to get better knowledge about this structure firstly look at the [Hark manual](../HARKmanual/index.html). Next, to understand how the HARK Market class works in less standard setting look at the [Fashion victim model](../notebooks/Fashion-Victim-Model.ipynb). \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6 If you need to study a source code\n", + "\n", + "In the previous sections we showed how to solve different models using HARK. However, we know that you may also need to work with the source code for a few reasons (e.g. to learn used numerical methods, write your own code).\n", + "\n", + "Obviously, working with the code, even well-written, is much more complicated tasks than just working with finished functions, and no tutorial will let you go through this painlessly. However, we hope that this part which elaborate a little the HARK structure and numerical methods, will help you with this task. \n", + "\n", + "### 6.1 A few more words on HARK structure \n", + " \n", + "When you look at the [HARK](https://github.com/econ-ark/HARK) sources, you find the subdirectory called HARK. Next there is a script called \"core. py\". Surprisingly, you will not find this code in many of the subclasses which you learned during this journey! \n", + "\n", + "The reason for this is that HARK.core is a core of the package, kind of a framework for all models which can be coded in HARK. It contains the general framework of the Agent-type classes (AgentType class) and for the market. The exact structure of modules in the HARK core you can find in the [manual](../HARKmanual/index.html) in section 0.2 General Purpose Tools. For the general structure of the AgentType and Market classes also look at the manual, for the sections 0.3 and 0.4 (you can skip the examples, as you already made a lot of them in the tutorials).\n", + "\n", + "Where are the subclasses which you learned during the journey? In HARK, the subclasses are in the separate directories. For the AgentType subclasses, you need to look at HARK.ConsumptionSaving directory. For example, $\\texttt{PerfForesightConsumerType}$ and $\\texttt{IndShockConsumerType}$ can be found in ConsIndShockModel.py. Nevertheless, if you want to understand any of the HARK modules, you firstly need to understand HARK.core. \n", + "\n", + "\n", + "### 6.2 HARK solution \n", + "\n", + "For the consumer problems, solutions of the one-period consumer's problem are found using the attribute function $\\texttt{solveOnePeriod}$. The inputs passed to this function includes also data from the subsequent periods. Before solveOnePeriod is called, the function presolve() is applied, which prepare the solution (eg. transmit the solution of the sub-sequent period as an input).\n", + "\n", + "The structure of the functions which are used as solveOnePeriod reflects the agent-type class structures. Thus when you will study the source code, you firstly will read the solve classes. \n", + "\n", + "![Hark_struct3](../notebooks/HARK_struct_3.png)\n", + "\n", + "\n", + "#### 6.2.1 Solution method for agent problem\n", + "However, knowing the structure of the code does not be very beneficial if you do not know the solution method! While for the perfect foresight consumer it is analytic, for the stochastic consumer (thus with the idiosyncratic or the aggregate shocks) the policy functions are solved by the **endogenous grid method**.\n", + "\n", + "The endogenous grid method is now widely used in the macroeconomic simulations. There are a few resources to learn it, we suggest professor Carroll [lecture notes](http://www.econ2.jhu.edu/people/ccarroll/SolvingMicroDSOPs/). If you prefer a very quick version, we suggest appendix to the Kruger and Kindermann [paper](https://www.nber.org/papers/w20601.pdf) (they develop a little bigger model with a different notation, but the idea is the same).\n", + "\n", + "#### 6.2.2 Finding general equilibrium\n", + "In the most basic case the rational expectations general equilibrium is found by updating the agents' expectations and the aggregate choices to the point when actual aggregated variables (like intrest rate or capital) are equal to the expected ones. However, refer to the papers cited in the notebooks, to understand the exact used mathods. \n", + "\n", + "\n", + "### 6.3 How to study HARK codes\n", + "\n", + "We hope that this section gave you some idea how the HARK codes work. However, HARK contains a pretty high number of separate modules and directories. Here we give you some guidance how to start:\n", + "\n", + "- Before you start make sure that you understand the endogenous grid method, and general framework structure for AgentType and Market from manual.\n", + "- Start with the HARK.core, make sure that you see the connection between the structure in the manual and the code, check autodoc from the [HARK documentation](https://hark.readthedocs.io/en/latest/generated/HARK.core.html) webpage. \n", + "- Proceed to the ConsumptionSaving\\ConsIndShockModel.py and compare the tutorials with the source code.\n", + "- Proceed to the ConsumptionSaving\\ConsAggShockModel.py and compare the tutorial on the Market class with the source code, check [autodoc](https://hark.readthedocs.io/en/latest/generated/HARK.ConsumptionSaving.ConsAggShockModel.html).\n", + "- When you want to learn any of the modules, always firstly check autodoc from the [HARK documentation](https://hark.readthedocs.io/en/latest/generated/HARK.core.html) webpage.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Documentation/notebooks/Journeys_into_HARK.ipynb b/Documentation/notebooks/Journeys_into_HARK.ipynb new file mode 100644 index 000000000..28bae1e60 --- /dev/null +++ b/Documentation/notebooks/Journeys_into_HARK.ipynb @@ -0,0 +1,67 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Journeys into HARK\n", + "======\n", + "\n", + "HARK is a tool designed for many types of users. Consequently, the ways how it can be learned are different depending on your knowledge about the structural modeling in economics, object oriented programing and economic modeling in general. Thus here we propose a few \"journeys\" which are intended to match your experience:\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## [1st year PhD student's track](../notebooks/Journey_1_PhD.ipynb)\n", + "You have some knowledge in economic theory and structural modeling but you are not an expert in programing, in particular projects built in object-oriented programing paradigma. Therefore, this journey put a special effort to discuss how to create, solve and simulate HARK objects, not requiring a special skill in programming. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Engineer's track\n", + "\n", + "You are familiar with numerical simulations as well as object oriented programming and Python. However, you do not work (much) with economic problems. Thus we propose you a quick tutorials to get used to the models and the basic classes of HARK\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lecturer's track\n", + "You want to use HARK during your classes. We propose you a quick tutorials to get used to the models and the basic classes of HARK. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Documentation/notebooks/KinkedRconsumerType.ipynb b/Documentation/notebooks/KinkedRconsumerType.ipynb new file mode 100644 index 000000000..6533edc71 --- /dev/null +++ b/Documentation/notebooks/KinkedRconsumerType.ipynb @@ -0,0 +1,438 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# KinkedRconsumerType: Consumption-saving model with idiosyncratic income shocks and different interest rates on borrowing and saving" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Initial imports and notebook setup, click arrow to show\n", + "import sys \n", + "import os\n", + "sys.path.insert(0, os.path.abspath('../../.'))\n", + "\n", + "from HARK.ConsumptionSaving.ConsIndShockModel import KinkedRconsumerType\n", + "from HARK.utilities import plotFuncsDer, plotFuncs\n", + "from time import clock\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "mystr = lambda number : \"{:.4f}\".format(number)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The module $\\texttt{HARK.ConsumptionSaving.ConsIndShockModel}$ concerns consumption-saving models with idiosyncratic shocks to (non-capital) income. All of the models assume CRRA utility with geometric discounting, no bequest motive, and income shocks are fully transitory or fully permanent.\n", + "\n", + "$\\texttt{ConsIndShockModel}$ currently includes three models:\n", + "1. A very basic \"perfect foresight\" model with no uncertainty.\n", + "2. A model with risk over transitory and permanent income shocks.\n", + "3. The model described in (2), with an interest rate for debt that differs from the interest rate for savings.\n", + "\n", + "This notebook provides documentation for the third of these models.\n", + "$\\newcommand{\\CRRA}{\\rho}$\n", + "$\\newcommand{\\DiePrb}{\\mathsf{D}}$\n", + "$\\newcommand{\\PermGroFac}{\\Gamma}$\n", + "$\\newcommand{\\Rfree}{\\mathsf{R}}$\n", + "$\\newcommand{\\DiscFac}{\\beta}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Statement of \"kinked R\" model\n", + "\n", + "Consider a small extension to the model faced by $\\texttt{IndShockConsumerType}$s: that the interest rate on borrowing $a_t < 0$ is greater than the interest rate on saving $a_t > 0$. Consumers who face this kind of problem are represented by the $\\texttt{KinkedRconsumerType}$ class.\n", + "\n", + "For a full theoretical treatment, this model analyzed in [A Theory of the Consumption Function, With\n", + "and Without Liquidity Constraints](http://www.econ2.jhu.edu/people/ccarroll/ATheoryv3JEP.pdf)\n", + "and its [expanded edition](http://www.econ2.jhu.edu/people/ccarroll/ATheoryv3NBER.pdf).\n", + "\n", + "Continuing to work with *normalized* variables (e.g. $m_t$ represents the level of market resources divided by permanent income), the \"kinked R\" model can be stated as:\n", + "\n", + "\\begin{eqnarray*}\n", + "v_t(m_t) &=& \\max_{c_t} {~} U(c_t) + \\DiscFac (1-\\DiePrb_{t+1}) \\mathbb{E}_{t} \\left[ (\\PermGroFac_{t+1}\\psi_{t+1})^{1-\\CRRA} v_{t+1}(m_{t+1}) \\right], \\\\\n", + "a_t &=& m_t - c_t, \\\\\n", + "a_t &\\geq& \\underline{a}, \\\\\n", + "m_{t+1} &=& \\Rfree_t/(\\PermGroFac_{t+1} \\psi_{t+1}) a_t + \\theta_{t+1}, \\\\\n", + "\\Rfree_t &=& \\cases{\\Rfree_{boro} \\texttt{ if } a_t < 0 \\\\\n", + " \\Rfree_{save} \\texttt{ if } a_t \\geq 0},\\\\\n", + "\\Rfree_{boro} &>& \\Rfree_{save}, \\\\\n", + "(\\psi_{t+1},\\theta_{t+1}) &\\sim& F_{t+1}, \\\\\n", + "\\mathbb{E}[\\psi]=\\mathbb{E}[\\theta] &=& 1.\n", + "\\end{eqnarray*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solving the \"kinked R\" model\n", + "\n", + "The solution method for the \"kinked R\" model is nearly identical to that of the $\\texttt{IndShockConsumerType}$ on which it is based, using the endogenous grid method; see the notebook for that model for more information. The only significant difference is that the interest factor varies by $a_t$ across the exogenously chosen grid of end-of-period assets, with a discontinuity in $\\Rfree$ at $a_t=0$.\n", + "\n", + "To correctly handle this, the $\\texttt{solveConsKinkedR}$ function inserts *two* instances of $a_t=0$ into the grid of $a_t$ values: the first corresponding to $\\Rfree_{boro}$ ($a_t = -0$) and the other corresponding to $\\Rfree_{save}$ ($a_t = +0$). The two consumption levels (and corresponding endogenous $m_t$ gridpoints) represent points at which the agent's first order condition is satisfied at *exactly* $a_t=0$ at the two different interest factors. In between these two points, the first order condition *does not hold with equality*: the consumer will end the period with exactly $a_t=0$, consuming $c_t=m_t$, but his marginal utility of consumption exceeds the marginal value of saving and is less than the marginal value of borrowing. This generates a consumption function with *two* kinks: two concave portions (for borrowing and saving) with a linear segment of slope 1 in between." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example parameter values to construct an instance of KinkedRconsumerType\n", + "\n", + "The parameters required to create an instance of $\\texttt{KinkedRconsumerType}$ are nearly identical to those for $\\texttt{IndShockConsumerType}$. The only difference is that the parameter $\\texttt{Rfree}$ is replaced with $\\texttt{Rboro}$ and $\\texttt{Rsave}$.\n", + "\n", + "While the parameter $\\texttt{CubicBool}$ is required to create a valid $\\texttt{KinkedRconsumerType}$ instance, it must be set to $\\texttt{False}$; cubic spline interpolation has not yet been implemented for this model. In the future, this restriction will be lifted.\n", + "\n", + "| Parameter | Description | Code | Example value | Time-varying? |\n", + "| :---: | --- | --- | --- | --- |\n", + "| $\\DiscFac$ |Intertemporal discount factor | $\\texttt{DiscFac}$ | $0.96$ | |\n", + "| $\\CRRA $ |Coefficient of relative risk aversion | $\\texttt{CRRA}$ | $2.0$ | |\n", + "| $\\Rfree_{boro}$ | Risk free interest factor for borrowing | $\\texttt{Rboro}$ | $1.20$ | |\n", + "| $\\Rfree_{save}$ | Risk free interest factor for saving | $\\texttt{Rsave}$ | $1.01$ | |\n", + "| $1 - \\DiePrb_{t+1}$ |Survival probability | $\\texttt{LivPrb}$ | $[0.98]$ | $\\surd$ |\n", + "|$\\PermGroFac_{t+1}$|Permanent income growth factor|$\\texttt{PermGroFac}$| $[1.01]$ | $\\surd$ |\n", + "| $\\sigma_\\psi $ | Standard deviation of log permanent income shocks | $\\texttt{PermShkStd}$ | $[0.1]$ |$\\surd$ |\n", + "| $N_\\psi $ | Number of discrete permanent income shocks | $\\texttt{PermShkCount}$ | $7$ | |\n", + "| $\\sigma_\\theta $ | Standard deviation of log transitory income shocks | $\\texttt{TranShkStd}$ | $[0.2]$ | $\\surd$ |\n", + "| $N_\\theta $ | Number of discrete transitory income shocks | $\\texttt{TranShkCount}$ | $7$ | |\n", + "| $\\mho$ | Probability of being unemployed and getting $\\theta=\\underline{\\theta}$ | $\\texttt{UnempPrb}$ | $0.05$ | |\n", + "| $\\underline{\\theta} $ | Transitory shock when unemployed | $\\texttt{IncUnemp}$ | $0.3$ | |\n", + "| $\\mho^{Ret}$ | Probability of being \"unemployed\" when retired | $\\texttt{UnempPrb}$ | $0.0005$ | |\n", + "| $\\underline{\\theta}^{Ret} $ | Transitory shock when \"unemployed\" and retired | $\\texttt{IncUnemp}$ | $0.0$ | |\n", + "| $(none)$ | Period of the lifecycle model when retirement begins | $\\texttt{T_retire}$ | $0$ | |\n", + "| $(none)$ | Minimum value in assets-above-minimum grid | $\\texttt{aXtraMin}$ | $0.001$ | |\n", + "| $(none)$ | Maximum value in assets-above-minimum grid | $\\texttt{aXtraMax}$ | $20.0$ | |\n", + "| $(none)$ | Number of points in base assets-above-minimum grid | $\\texttt{aXtraCount}$ | $48$ | |\n", + "| $(none)$ | Exponential nesting factor for base assets-above-minimum grid | $\\texttt{aXtraNestFac}$ | $3$ | |\n", + "| $(none)$ | Additional values to add to assets-above-minimum grid | $\\texttt{aXtraExtra}$ | $None$ | |\n", + "| $\\underline{a} $ | Artificial borrowing constraint (normalized) | $\\texttt{BoroCnstArt}$ | $None$ | |\n", + "| $(none) $ |Indicator for whether $\\texttt{vFunc}$ should be computed | $\\texttt{vFuncBool}$ | $True$ | |\n", + "| $(none)$ |Indicator for whether $\\texttt{cFunc}$ should use cubic splines | $\\texttt{CubicBool}$ | $False$ | |\n", + "|$T$| Number of periods in this type's \"cycle\" |$\\texttt{T_cycle}$| $1$ | |\n", + "|(none)| Number of times the \"cycle\" occurs |$\\texttt{cycles}$| $0$ | |\n", + "\n", + "These example parameters are almostidentical to those used for $\\texttt{IndShockExample}$ in the prior notebook, except that the interest rate on borrowing is 20% (like a credit card), and the interest rate on saving is 1%. Moreover, the artificial borrowing constraint has been set to $\\texttt{None}$. The cell below defines a parameter dictionary with these example values." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "KinkedRdict={ # Click the arrow to expand this parameter dictionary\n", + " # Parameters shared with the perfect foresight model\n", + " \"CRRA\" : 2.0, # Coefficient of relative risk aversion\n", + " \"DiscFac\": 0.96, # Intertemporal discount factor\n", + " \"LivPrb\" : [0.98], # Survival probability\n", + " \"PermGroFac\" :[1.01], # Permanent income growth factor\n", + " \n", + " # New parameters unique to the \"kinked R\" model\n", + " \"Rboro\" : 1.20, # Interest factor on borrowing (a < 0)\n", + " \"Rsave\" : 1.01, # Interest factor on saving (a > 0)\n", + " \n", + " # Parameters that specify the income distribution over the lifecycle\n", + " \"PermShkStd\" : [0.1], # Standard deviation of log permanent shocks to income\n", + " \"PermShkCount\" : 7, # Number of points in discrete approximation to permanent income shocks\n", + " \"TranShkStd\" : [0.2], # Standard deviation of log transitory shocks to income\n", + " \"TranShkCount\" : 7, # Number of points in discrete approximation to transitory income shocks\n", + " \"UnempPrb\" : 0.05, # Probability of unemployment while working\n", + " \"IncUnemp\" : 0.3, # Unemployment benefits replacement rate\n", + " \"UnempPrbRet\" : 0.0005, # Probability of \"unemployment\" while retired\n", + " \"IncUnempRet\" : 0.0, # \"Unemployment\" benefits when retired\n", + " \"T_retire\" : 0, # Period of retirement (0 --> no retirement)\n", + " \"tax_rate\" : 0.0, # Flat income tax rate (legacy parameter, will be removed in future)\n", + " \n", + " # Parameters for constructing the \"assets above minimum\" grid\n", + " \"aXtraMin\" : 0.001, # Minimum end-of-period \"assets above minimum\" value\n", + " \"aXtraMax\" : 20, # Maximum end-of-period \"assets above minimum\" value\n", + " \"aXtraCount\" : 48, # Number of points in the base grid of \"assets above minimum\"\n", + " \"aXtraNestFac\" : 3, # Exponential nesting factor when constructing \"assets above minimum\" grid\n", + " \"aXtraExtra\" : [None], # Additional values to add to aXtraGrid\n", + " \n", + " # A few other paramaters\n", + " \"BoroCnstArt\" : None, # Artificial borrowing constraint; imposed minimum level of end-of period assets\n", + " \"vFuncBool\" : True, # Whether to calculate the value function during solution \n", + " \"CubicBool\" : False, # Preference shocks currently only compatible with linear cFunc\n", + " \"T_cycle\" : 1, # Number of periods in the cycle for this agent type \n", + " \n", + " # Parameters only used in simulation\n", + " \"AgentCount\" : 10000, # Number of agents of this type\n", + " \"T_sim\" : 500, # Number of periods to simulate\n", + " \"aNrmInitMean\" : -6.0, # Mean of log initial assets\n", + " \"aNrmInitStd\" : 1.0, # Standard deviation of log initial assets\n", + " \"pLvlInitMean\" : 0.0, # Mean of log initial permanent income\n", + " \"pLvlInitStd\" : 0.0, # Standard deviation of log initial permanent income\n", + " \"PermGroFacAgg\" : 1.0, # Aggregate permanent income growth factor\n", + " \"T_age\" : None, # Age after which simulated agents are automatically killed\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solving and examining the solution of the \"kinked R\" model\n", + "\n", + "The cell below creates an infinite horizon instance of $\\texttt{KinkedRconsumerType}$ and solves its model by calling its $\\texttt{solve}$ method." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "KinkyExample = KinkedRconsumerType(**KinkedRdict)\n", + "KinkyExample.cycles = 0 # Make the example infinite horizon\n", + "KinkyExample.solve()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An element of a $\\texttt{KinkedRconsumerType}$'s solution will have all the same attributes as that of a $\\texttt{IndShockConsumerType}$; see that notebook for details.\n", + "\n", + "We can plot the consumption function of our \"kinked R\" example, as well as the MPC:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kinked R consumption function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kinked R marginal propensity to consume:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print('Kinked R consumption function:')\n", + "plotFuncs(KinkyExample.solution[0].cFunc,KinkyExample.solution[0].mNrmMin,5)\n", + "\n", + "print('Kinked R marginal propensity to consume:')\n", + "plotFuncsDer(KinkyExample.solution[0].cFunc,KinkyExample.solution[0].mNrmMin,5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simulating the \"kinked R\" model\n", + "\n", + "In order to generate simulated data, an instance of $\\texttt{KinkedRconsumerType}$ needs to know how many agents there are that share these particular parameters (and are thus *ex ante* homogeneous), the distribution of states for newly \"born\" agents, and how many periods to simulated. These simulation parameters are described in the table below, along with example values.\n", + "\n", + "| Description | Code | Example value |\n", + "| :---: | --- | --- |\n", + "| Number of consumers of this type | $\\texttt{AgentCount}$ | $10000$ |\n", + "| Number of periods to simulate | $\\texttt{T_sim}$ | $500$ |\n", + "| Mean of initial log (normalized) assets | $\\texttt{aNrmInitMean}$ | $-6.0$ |\n", + "| Stdev of initial log (normalized) assets | $\\texttt{aNrmInitStd}$ | $1.0$ |\n", + "| Mean of initial log permanent income | $\\texttt{pLvlInitMean}$ | $0.0$ |\n", + "| Stdev of initial log permanent income | $\\texttt{pLvlInitStd}$ | $0.0$ |\n", + "| Aggregrate productivity growth factor | $\\texttt{PermGroFacAgg}$ | $1.0$ |\n", + "| Age after which consumers are automatically killed | $\\texttt{T_age}$ | $None$ |\n", + "\n", + "Here, we will simulate 10,000 consumers for 500 periods. All newly born agents will start with permanent income of exactly $P_t = 1.0 = \\exp(\\texttt{pLvlInitMean})$, as $\\texttt{pLvlInitStd}$ has been set to zero; they will have essentially zero assets at birth, as $\\texttt{aNrmInitMean}$ is $-6.0$; assets will be less than $1\\%$ of permanent income at birth.\n", + "\n", + "These example parameter values were already passed as part of the parameter dictionary that we used to create $\\texttt{KinkyExample}$, so it is ready to simulate. We need to set the $\\texttt{track_vars}$ attribute to indicate the variables for which we want to record a *history*." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "KinkyExample.track_vars = ['mNrmNow','cNrmNow','pLvlNow']\n", + "KinkyExample.initializeSim()\n", + "KinkyExample.simulate()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can plot the average (normalized) market resources in each simulated period:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(np.mean(KinkyExample.mNrmNow_hist,axis=1))\n", + "plt.xlabel('Time')\n", + "plt.ylabel('Mean market resources')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's plot the distribution of (normalized) assets $a_t$ for the current population, after simulating for $500$ periods; this should be fairly close to the long run distribution:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(np.sort(KinkyExample.aNrmNow),np.linspace(0.,1.,KinkyExample.AgentCount))\n", + "plt.xlabel('End-of-period assets')\n", + "plt.ylabel('Cumulative distribution')\n", + "plt.ylim(-0.01,1.01)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see there's a significant point mass of consumers with *exactly* $a_t=0$; these are consumers who do not find it worthwhile to give up a bit of consumption to begin saving (because $\\Rfree_{save}$ is too low), and also are not willing to finance additional consumption by borrowing (because $\\Rfree_{boro}$ is too high).\n", + "\n", + "The smaller point masses in this distribution are due to $\\texttt{HARK}$ drawing simulated income shocks from the discretized distribution, rather than the \"true\" lognormal distributions of shocks. For consumers who ended $t-1$ with $a_{t-1}=0$ in assets, there are only 8 values the transitory shock $\\theta_{t}$ can take on, and thus only 8 values of $m_t$ thus $a_t$ they can achieve; the value of $\\psi_t$ is immaterial to $m_t$ when $a_{t-1}=0$. You can verify this by changing $\\texttt{TranShkCount}$ to some higher value, like 25, in the dictionary above, then running the subsequent cells; the smaller point masses will not be visible to the naked eye." + ] + } + ], + "metadata": { + "@webio": { + "lastCommId": "779f6c5616b04b58baaaa0f6c348270c", + "lastKernelId": "a944b08f-0ae0-4c26-883f-9fab53a82ac3" + }, + "jupytext": { + "cell_metadata_filter": "collapsed,code_folding", + "formats": "ipynb,py:percent" + }, + "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.3" + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Documentation/notebooks/KrusellSmith.ipynb b/Documentation/notebooks/KrusellSmith.ipynb new file mode 100644 index 000000000..727bdd3fd --- /dev/null +++ b/Documentation/notebooks/KrusellSmith.ipynb @@ -0,0 +1,1020 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# [Krusell Smith (1998)](https://www.journals.uchicago.edu/doi/pdf/10.1086/250034)\n", + "\n", + "- Original version by Tim Munday \n", + "- Comments and extensions by Tao Wang\n", + "- Further edits by Chris Carroll" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/econ-ark/DemARK/master?filepath=notebooks%2FKrusellSmith.ipynb)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Overview\n", + "\n", + "The benchmark Krusell-Smith model has the following broad features:\n", + " * The aggregate state switches between \"good\" and \"bad\" with known probabilities\n", + " * All consumers experience the same aggregate state for the economy (good or bad)\n", + " * _ex ante_ there is only one type of consumer, which is infinitely lived\n", + " * _ex post_ heterogeneity arises from uninsurable idiosyncratic income shocks\n", + " * Specifically, individuals are at risk of spells of unemployment\n", + " * In a spell of unemployment, their income is zero\n", + " \n", + "Thus, each agent faces two types of uncertainty: About their employment state, and about the income they will earn when employed. And the values of income and unemployment risk depend on the aggregate state.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Details\n", + "\n", + "#### Idiosyncratic\n", + "Each agent _attempts_ to supply an amount of productive labor $\\ell$ in each period. (Here and below we mostly follow the notation of Krusell and Smith (1998)).\n", + "\n", + "However, whether they _succeed_ in supplying that labor (and earning a corresponding wage) is governed by the realization of the stochastic variable $\\epsilon$. If the agent is unlucky, $\\epsilon$ is zero and the agent is unemployed. The amount of labor they succeed in supplying is thus $\\epsilon\\ell$.\n", + "\n", + "#### Aggregate\n", + "Aggregate output ($\\bar{y}$) is produced using a Cobb-Douglas production function using capital and labor. (Bars over variables indicate the aggregate value of a variable that has different values across different idiosyncratic consumers).\n", + "\n", + "$z$ denotes the aggregate shock to productivity. $z$ can take two values, either $z_g$ -- the \"good\" state, or $z_b < z_g$ -- the \"bad\" state. Consumers gain income from providing labor, and from the rental return on any capital they own. Labor and capital markets are perfectly efficient so both factors are both paid their marginal products.\n", + "\n", + "The agent can choose to save by buying capital $k$ which is bounded below at the borrowing constraint of 0.\n", + "\n", + "\n", + "Putting all of this together, aggregate output is given by: \n", + "\\begin{eqnarray}\n", + "\\bar{y} & = & z\\bar{k}^\\alpha \\bar{\\ell}^{1-\\alpha}\n", + "\\end{eqnarray}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The aggregate shocks $z$ follow first-order Markov chains with the transition probability of moving from state $s$ to state $s'$ denoted by $\\pi_{ss'}$. The aggregate shocks and individual shocks are correlated: The probability of being unemployed is higher in bad times, when aggregate productivity is low, than in good times, when aggregate productivity is high.\n", + "\n", + "#### Idiosyncratic and Aggregate Together\n", + "\n", + "The individual shocks satisfy the law of large numbers, and the model is constructed so that the number of agents who are unemployed in the good state always equals $u_g$, and is always $u_b$ in the bad state. Given the aggregate state, individual shocks are independent from each other.\n", + "\n", + "For the individual, the probability of moving between a good state and employment to a bad state and unemployment is denoted $\\pi_{gb10}$ with similar notation for the other transition probabilities.\n", + "\n", + "(Krusell and Smith allow for serially correlated unemployment at the idiosyncratic level. Here we will simplify this and have unemployment be serially uncorrelated.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, $\\Gamma$ denotes the current distribution of consumers over capital and employment status, and $H$ denotes the law of motion of this distribution. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### The Idiosyncratic Individual's Problem Given the Aggregate State\n", + "\n", + "The individual's problem is:\n", + "\\begin{eqnarray*}\n", + "V(k, \\epsilon; \\Gamma, z) &=& \\max_{k'}\\{U(c) + \\beta \\mathbb{E}[V(k' ,\\epsilon'; \\Gamma', z')|z, \\epsilon]\\} \\\\\n", + "c + k' &=& r(\\bar{k}, \\bar{\\ell}, z)k + w(\\bar{k}, \\bar{\\ell}, z)\\ell\\epsilon + (1-\\delta)k \\\\\n", + "\\Gamma' &=& H(\\Gamma, z, z') \\\\\n", + "k' &\\geq& 0 \\\\\n", + "\\end{eqnarray*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Krusell and Smith define an equilibrium as a law of motion $H$, a value function $V$, a rule for updating capital $f$ and pricing functions $r$ and $w$, such that $V$ and $f$ solve the consumers problem, $r$ and $w$ denote the marginal products of capital and labour, and $H$ is consistent with $f$ (i.e. if we add up all of the individual agents capital choices we get the correct distribution of capital)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Discussion of the KS Algorithm\n", + "\n", + "In principle, $\\Gamma$ is a high-dimensional object because it includes the whole distribution of individuals' wealth in the economy. Because the optimal amount to save is a nonlinear function of the level of idiosyncratic $k$, next period's aggregate capital stock $\\bar{k}'$ depends on the distribution of the holdings of idiosyncratic $k$ across the population of consumers. Therefore the law of motion $H$ is not a trivial function of the $\\Gamma$. \n", + "\n", + "KS simplified this problem by noting the following. \n", + "\n", + "1. The agent cares about the future aggregate aggregate state only insofar as that state affects their own personal value of $c$\n", + "1. Future values of $c$ depend on the aggregate state only through the budget constraint\n", + "1. The channels by which the budget constraint depends on the aggregate state are:\n", + " * The probability distributions of $\\epsilon$ and $z$ are affected by the aggregate state\n", + " * Interest rates and wages depend on the future values of $\\bar{k}$ and $\\bar{\\ell}$\n", + "1. The probability distributions for the future values of $\\{\\epsilon, z\\}$ are known\n", + " * They are fully determined by the Markov transition matrices\n", + "1. But the values of $r$ and $w$ are both determined by the future value of $\\bar{k}$ (in combination with the exogenous value of $\\bar{\\ell}$)\n", + " * So the only _endogenous_ object that the agent needs to form expectations about, in order to have a complete rational expectation about everything affecting them, is $\\bar{k}'$\n", + "\n", + "The key result in Krusell and Smith is the discovery that a very simple linear rule does an extraordinarily good job (though not quite perfect) in forecasting $\\bar{k'}$\n", + "\n", + "They then argue that, since rationality is surely bounded to some degree, the solution that an agent obtains using a good forecasting rule for $\\bar{k}'$ is \"good enough\" to compute an \"approximate\" solution to the consumer's optimization problem.\n", + "\n", + "They define a generic algorithm to find a forecasting rule for $\\bar{k}$ as follows\n", + "\n", + "1. Choose the number of moments $n$ of the distribution of $k$ to be included in the set of variables to forecast $\\bar{k}'$. In the simplest case, $n=1$, the only forecasting variable for next period's $\\bar{k}'$ is the mean (the first moment, $n=1$)) of current capital, $\\bar{k}$.\n", + "2. Each individual adopts the same belief about the law motion of these moments, $H_I$ and finds the optimal decision policy, $f_I$, contingent on that guess.\n", + "3. Use the optimal policy to simulate a history of aggregate capital with a large number of agents. \n", + "4. Characterize the realized law of motion using the same number of moments $n$ \n", + "5. Compare it with the $H_I$, what is taken as given by individuals. \n", + "6. Iterate until the two converge. \n", + "\n", + "In the end, the solution to the original problem is well approximated by the following simplified problem:\n", + "\n", + "\\begin{eqnarray*}\n", + "V(k, \\epsilon; \\bar k, z) &=& max_{c, k'}\\{U(c) + \\beta E[V(k' ,\\epsilon'; \\bar k', z')|z, \\epsilon]\\} \\\\\n", + "c + k' &=& r(\\bar{k}, \\bar{\\ell}, z)k + w(\\bar{k}, \\bar{\\ell}, z)l\\epsilon + (1-\\delta)k \\\\\n", + "\\text{When }~ z=z_g, \\quad \\mathbb{E}[\\log\\bar{k}'] & = & a_0 + a_1 \\log\\bar k \\\\\n", + "\\text{When }~ z=z_b, \\quad \\mathbb{E}[\\log\\bar{k}'] & = & b_0 + b_1 \\log\\bar k \\\\\n", + "k' &\\geq& 0 \\\\\n", + "\\end{eqnarray*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Implementation Using the HARK Toolkit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### The Consumer" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "code_folding": [ + 6, + 17 + ] + }, + "outputs": [], + "source": [ + "# Import generic setup tools\n", + "\n", + "# This is a jupytext paired notebook that autogenerates KrusellSmith.py\n", + "# which can be executed from a terminal command line via \"ipython KrusellSmith.py\"\n", + "# But a terminal does not permit inline figures, so we need to test jupyter vs terminal\n", + "# Google \"how can I check if code is executed in the ipython notebook\"\n", + "def in_ipynb():\n", + " try:\n", + " if str(type(get_ipython())) == \"\":\n", + " return True\n", + " else:\n", + " return False\n", + " except NameError:\n", + " return False\n", + "\n", + "# Determine whether to make the figures inline (for spyder or jupyter)\n", + "# vs whatever is the automatic setting that will apply if run from the terminal\n", + "if in_ipynb():\n", + " # %matplotlib inline generates a syntax error when run from the shell\n", + " # so do this instead\n", + " get_ipython().run_line_magic('matplotlib', 'inline') \n", + "else:\n", + " get_ipython().run_line_magic('matplotlib', 'auto') \n", + "\n", + "# Import the plot-figure library matplotlib\n", + "\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "matplotlib.rcParams['text.usetex'] = True\n", + "\n", + "import sys\n", + "import os\n", + "from copy import copy\n", + "from HARK.utilities import plotFuncs, plotFuncsDer" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Import components of HARK needed for solving the KS model\n", + "from HARK.ConsumptionSaving.ConsAggShockModel import *\n", + "import HARK.ConsumptionSaving.ConsumerParameters as Params\n", + "\n", + "# Markov consumer type that allows aggregate shocks (redundant but instructive)\n", + "from HARK.ConsumptionSaving.ConsAggShockModel import AggShockMarkovConsumerType" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "code_folding": [ + 0, + 4 + ] + }, + "outputs": [], + "source": [ + "# Define a dictionary to make an 'instance' of our Krusell-Smith consumer.\n", + "\n", + "# The folded dictionary below contains many parameters to the \n", + "# AggShockMarkovConsumerType agent that are not needed for the KS model\n", + "KSAgentDictionary = { \n", + " \"CRRA\": 1.0, # Coefficient of relative risk aversion\n", + " \"DiscFac\": 0.99, # Intertemporal discount factor\n", + " \"LivPrb\" : [1.0], # Survival probability\n", + " \"AgentCount\" : 10000, # Number of agents of this type (only matters for simulation)\n", + " \"aNrmInitMean\" : 0.0, # Mean of log initial assets (only matters for simulation)\n", + " \"aNrmInitStd\" : 0.0, # Standard deviation of log initial assets (only for simulation)\n", + " \"pLvlInitMean\" : 0.0, # Mean of log initial permanent income (only matters for simulation)\n", + " \"pLvlInitStd\" : 0.0, # Standard deviation of log initial permanent income (only matters for simulation)\n", + " \"PermGroFacAgg\" : 1.0, # Aggregate permanent income growth factor (only matters for simulation)\n", + " \"T_age\" : None, # Age after which simulated agents are automatically killed\n", + " \"T_cycle\" : 1, # Number of periods in the cycle for this agent type\n", + "# Parameters for constructing the \"assets above minimum\" grid\n", + " \"aXtraMin\" : 0.001, # Minimum end-of-period \"assets above minimum\" value\n", + " \"aXtraMax\" : 20, # Maximum end-of-period \"assets above minimum\" value \n", + " \"aXtraExtra\" : [None], # Some other value of \"assets above minimum\" to add to the grid\n", + " \"aXtraNestFac\" : 3, # Exponential nesting factor when constructing \"assets above minimum\" grid\n", + " \"aXtraCount\" : 24, # Number of points in the grid of \"assets above minimum\"\n", + "# Parameters describing the income process\n", + " \"PermShkCount\" : 1, # Number of points in discrete approximation to permanent income shocks - no shocks of this kind!\n", + " \"TranShkCount\" : 1, # Number of points in discrete approximation to transitory income shocks - no shocks of this kind!\n", + " \"PermShkStd\" : [0.], # Standard deviation of log permanent income shocks - no shocks of this kind!\n", + " \"TranShkStd\" : [0.], # Standard deviation of log transitory income shocks - no shocks of this kind!\n", + " \"UnempPrb\" : 0.0, # Probability of unemployment while working - no shocks of this kind!\n", + " \"UnempPrbRet\" : 0.00, # Probability of \"unemployment\" while retired - no shocks of this kind!\n", + " \"IncUnemp\" : 0.0, # Unemployment benefits replacement rate\n", + " \"IncUnempRet\" : 0.0, # \"Unemployment\" benefits when retired\n", + " \"tax_rate\" : 0.0, # Flat income tax rate\n", + " \"T_retire\" : 0, # Period of retirement (0 --> no retirement)\n", + " \"BoroCnstArt\" : 0.0, # Artificial borrowing constraint; imposed minimum level of end-of period assets \n", + " \"cycles\": 0, # Consumer is infinitely lived\n", + " \"PermGroFac\" : [1.0], # Permanent income growth factor\n", + "# New Parameters that we need now \n", + " 'MgridBase': np.array([0.1,0.3,0.6,\n", + " 0.8,0.9,0.98,\n", + " 1.0,1.02,1.1,\n", + " 1.2,1.6,2.0,\n", + " 3.0]), # Grid of capital-to-labor-ratios (factors)\n", + " 'MrkvArray': np.array([[0.825,0.175],\n", + " [0.175,0.825]]), # Transition probabilities for macroecon. [i,j] is probability of being in state j next\n", + " # period conditional on being in state i this period. \n", + " 'PermShkAggStd' : [0.0,0.0], # Standard deviation of log aggregate permanent shocks by state. No continous shocks in a state.\n", + " 'TranShkAggStd' : [0.0,0.0], # Standard deviation of log aggregate transitory shocks by state. No continuous shocks in a state.\n", + " 'PermGroFacAgg' : 1.0\n", + "}\n", + "\n", + "# Here we restate just the \"interesting\" parts of the consumer's specification\n", + "\n", + "KSAgentDictionary['CRRA'] = 1.0 # Relative risk aversion \n", + "KSAgentDictionary['DiscFac'] = 0.99 # Intertemporal discount factor\n", + "KSAgentDictionary['cycles'] = 0 # cycles=0 means consumer is infinitely lived\n", + "\n", + "# KS assume that 'good' and 'bad' times are of equal expected duration\n", + "# The probability of a change in the aggregate state is p_change=0.125\n", + "p_change=0.125\n", + "p_remain=1-p_change\n", + "\n", + "# Now we define macro transition probabilities for AggShockMarkovConsumerType\n", + "# [i,j] is probability of being in state j next period conditional on being in state i this period. \n", + "# In both states, there is 0.875 chance of staying, 0.125 chance of switching\n", + "AggMrkvArray = \\\n", + "np.array([[p_remain,p_change], # Probabilities of states 0 and 1 next period if in state 0\n", + " [p_change,p_remain]]) # Probabilities of states 0 and 1 next period if in state 1\n", + "KSAgentDictionary['MrkvArray'] = AggMrkvArray" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Create the Krusell-Smith agent as an instance of AggShockMarkovConsumerType \n", + "KSAgent = AggShockMarkovConsumerType(**KSAgentDictionary)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we need to specify the income distribution. \n", + "\n", + "The HARK toolkit allows for two components of labor income: Persistent (or permanent), and transitory. \n", + "\n", + "Using the KS notation above, a HARK consumer's income is\n", + "\\begin{eqnarray}\n", + "y & = & w p \\ell \\epsilon \n", + "\\end{eqnarray}\n", + "where $p$ is the persistent component of income. Krusell and Smith did not incorporate a persistent component of income, however, so we will simply calibrate $p=1$ for all states.\n", + "\n", + "For each of the two aggregate states we need to specify:\n", + " * The _proportion_ of consumers in the $e$ and the $u$ states\n", + " * The level of persistent/permanent productivity $p$ (always 1)\n", + " * The ratio of actual to permanent productivity in each state $\\{e,u\\}$\n", + " * In the KS notation, this is $\\epsilon\\ell$ \n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Construct the income distribution for the Krusell-Smith agent\n", + "prb_eg = 0.96 # Probability of employment in the good state\n", + "prb_ug = 1-prb_eg # Probability of unemployment in the good state\n", + "prb_eb = 0.90 # Probability of employment in the bad state\n", + "prb_ub = 1-prb_eb # Probability of unemployment in the bad state\n", + "p_ind = 1 # Persistent component of income is always 1\n", + "ell_ug = ell_ub = 0 # Labor supply is zero for unemployed consumers in either agg state\n", + "ell_eg = 1.0/prb_eg # Labor supply for employed consumer in good state\n", + "ell_eb = 1.0/prb_eb # 1=pe_g*ell_ge+pu_b*ell_gu=pe_b*ell_be+pu_b*ell_gu\n", + "\n", + "# IncomeDstn is a list of lists, one for each aggregate Markov state\n", + "# Each contains three arrays of floats, representing a discrete approximation to the income process. \n", + "# Order: \n", + "# state probabilities \n", + "# idiosyncratic persistent income level by state (KS have no persistent shocks p_ind is always 1.0)\n", + "# idiosyncratic transitory income level by state\n", + "\n", + "KSAgent.IncomeDstn[0] = \\\n", + "[[np.array([prb_eg,prb_ug]),np.array([p_ind,p_ind]),np.array([ell_eg,ell_ug])], # Agg state good\n", + " [np.array([prb_eb,prb_ub]),np.array([p_ind,p_ind]),np.array([ell_eb,ell_ub])] # Agg state bad\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Up to this point, individual agents do not have enough information to solve their decision problem yet. What is missing are beliefs about the endogenous macro variables $r$ and $w$, both of which are functions of $\\bar{k}$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### The Aggregate Economy" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "code_folding": [ + 2 + ] + }, + "outputs": [], + "source": [ + "from HARK.ConsumptionSaving.ConsAggShockModel import CobbDouglasMarkovEconomy\n", + "\n", + "KSEconomyDictionary = {\n", + " 'PermShkAggCount': 1, \n", + " 'TranShkAggCount': 1, \n", + " 'PermShkAggStd': [0.0,0.0], \n", + " 'TranShkAggStd': [0.0,0.0], \n", + " 'DeprFac': 0.025, # Depreciation factor\n", + " 'CapShare': 0.36, # Share of capital income in cobb-douglas production function\n", + " 'DiscFac': 0.99,\n", + " 'CRRA': 1.0,\n", + " 'PermGroFacAgg': [1.0,1.0],\n", + " 'AggregateL':1.0, # Not sure on this. Looks like we have fixed the labour level...\n", + " 'act_T':1200, # Number of periods for economy to run in simulation\n", + " 'intercept_prev': [0.0,0.0], # Make some initial guesses at linear savings rule intercepts for each state\n", + " 'slope_prev': [1.0,1.0], # Make some initial guesses at linear savings rule slopes for each state\n", + " 'MrkvArray': np.array([[0.875,0.125],\n", + " [0.125,0.875]]), # Transition probabilities\n", + " 'MrkvNow_init': 0 # Pick a state to start in (we pick the first state)\n", + "}\n", + "\n", + "# The 'interesting' parts of the CobbDouglasMarkovEconomy\n", + "KSEconomyDictionary['CapShare'] = 0.36\n", + "KSEconomyDictionary['MrkvArray'] = AggMrkvArray\n", + "\n", + "KSEconomy = CobbDouglasMarkovEconomy(agents = [KSAgent], **KSEconomyDictionary) # Combine production and consumption sides into an \"Economy\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have now populated the $\\texttt{KSEconomy}$ with $\\texttt{KSAgents}$ defined before. That is basically telling the agents to take the macro state from the $\\texttt{KSEconomy}$. \n", + "\n", + "Now we construct the $\\texttt{AggShkDstn}$ that specifies the evolution of the dynamics of the $\\texttt{KSEconomy}$.\n", + "\n", + "The structure of the inputs for $\\texttt{AggShkDstn}$ follows the same logic as for $\\texttt{IncomeDstn}$. Now there is only one possible outcome for each aggregate state (the KS aggregate states are very simple), therefore, each aggregate state has only one possible condition which happens with probability 1." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Calibrate the magnitude of the aggregate shocks\n", + "\n", + "Tran_g = 1.01 # Productivity z in the good aggregate state\n", + "Tran_b = 0.99 # and the bad state\n", + "\n", + "# The HARK framework allows permanent shocks\n", + "Perm_g = Perm_b = 1.0 # KS assume there are no aggregate permanent shocks\n", + "\n", + "# Aggregate productivity shock distribution by state.\n", + "# First element is probabilities of different outcomes, given the state you are in. \n", + "# Second element is agg permanent shocks (here we don't have any, so just they are just 1.).\n", + "# Third element is agg transitory shocks, which are calibrated the same as in Krusell Smith.\n", + "\n", + "KSAggShkDstn = [\n", + " [np.array([1.0]),np.array([Perm_g]),np.array([Tran_g])], # Aggregate good\n", + " [np.array([1.0]),np.array([Perm_b]),np.array([Tran_b])] # Aggregate bad\n", + "]\n", + "\n", + "KSEconomy.AggShkDstn = KSAggShkDstn" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Summing Up\n", + "\n", + "The combined idiosyncratic and aggregate assumptions can be summarized mathematically as follows.\n", + "\n", + "$\\forall \\{s,s'\\}=\\{g,b\\}\\times\\{g,b\\}$, the following two conditions hold:\n", + "\n", + "$$\\underbrace{\\pi_{ss'01}}_{p(s \\rightarrow s',u \\rightarrow e)}+\\underbrace{\\pi_{ss'00}}_{p(s \\rightarrow s', u \\rightarrow u)} = \\underbrace{\\pi_{ss'11}}_{p(s\\rightarrow s', e \\rightarrow e) } + \\underbrace{\\pi_{ss'10}}_{p(s \\rightarrow s', e \\rightarrow u)} = \\underbrace{\\pi_{ss'}}_{p(s\\rightarrow s')}$$\n", + "\n", + "$$u_s \\frac{\\pi_{ss'00}}{\\pi_{ss'}}+ (1-u_s) \\frac{\\pi_{ss'10}}{\\pi_{ss'}} = u_{s'}$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Solving the Model\n", + "Now, we have fully defined all of the elements of the macroeconomy, and we are in postion to construct an object that represents the economy and to construct a rational expectations equilibrium." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "code_folding": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "intercept=[-0.23916250431706865, -0.23612394642292456], slope=[1.0589379022340042, 1.058397266583046], r-sq=[0.9999007630097769, 0.9998101850187018]\n", + "intercept=[-0.23284348000118416, -0.2300503731400092], slope=[1.0437242579937296, 1.0430192001137875], r-sq=[0.999597842568587, 0.9995228787583216]\n", + "intercept=[-0.1417937791330211, -0.13978458794360915], slope=[1.0195222342774009, 1.0190138495183079], r-sq=[0.9999999957550048, 0.9999999943223272]\n", + "intercept=[-0.1616557089433215, -0.15967857273677427], slope=[1.0243223215052295, 1.0237962498020787], r-sq=[0.9999999330730815, 0.9999998121130936]\n", + "intercept=[-0.15367980777946966, -0.15237090663001576], slope=[1.0228330019333411, 1.0224883026048959], r-sq=[0.9999999953306511, 0.999999995858353]\n" + ] + } + ], + "source": [ + "# Construct the economy, make an initial history, then solve \n", + "\n", + "KSAgent.getEconomyData(KSEconomy) # Makes attributes of the economy, attributes of the agent\n", + "\n", + "KSEconomy.makeAggShkHist() # Make a simulated history of the economy\n", + "\n", + "# set a higher tolerance level. \n", + "\n", + "KSEconomy.tolerance = 0.01\n", + "\n", + "# Solve macro problem by finding a fixed point for beliefs\n", + "\n", + "KSEconomy.solve() # Solve the economy using the market method. \n", + "# i.e. guess the saving function, and iterate until a fixed point" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The last line above is the converged aggregate saving rule for good and bad times, respectively." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Aggregate savings as a function of aggregate market resources:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption function at each aggregate market resources gridpoint (in general equilibrium):\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saving at each individual market resources gridpoint (in general equilibrium):\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot some key results\n", + "\n", + "print('Aggregate savings as a function of aggregate market resources:')\n", + "plotFuncs(KSEconomy.AFunc,0.1,2*KSEconomy.kSS)\n", + "\n", + "print('Consumption function at each aggregate market resources gridpoint (in general equilibrium):')\n", + "KSAgent.unpackcFunc()\n", + "m_grid = np.linspace(0,10,200)\n", + "KSAgent.unpackcFunc()\n", + "for M in KSAgent.Mgrid:\n", + " c_at_this_M = KSAgent.solution[0].cFunc[0](m_grid,M*np.ones_like(m_grid)) #Have two consumption functions, check this\n", + " plt.plot(m_grid,c_at_this_M)\n", + "plt.show()\n", + "\n", + "print('Saving at each individual market resources gridpoint (in general equilibrium):')\n", + "KSAgent.unpackcFunc()\n", + "m_grid = np.linspace(0,10,200)\n", + "KSAgent.unpackcFunc()\n", + "for M in KSAgent.Mgrid:\n", + " s_at_this_M = m_grid-KSAgent.solution[0].cFunc[1](m_grid,M*np.ones_like(m_grid))\n", + " c_at_this_M = KSAgent.solution[0].cFunc[1](m_grid,M*np.ones_like(m_grid)) #Have two consumption functions, check this\n", + " plt.plot(m_grid,s_at_this_M)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The Wealth Distribution in KS\n", + "\n", + "#### Benchmark Model\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The mean of individual wealth is 41.38763295741192;\n", + " the standard deviation is 7.757414089666179;\n", + " the median is 41.56896057547499.\n" + ] + } + ], + "source": [ + "sim_wealth = KSEconomy.aLvlNow[0]\n", + "\n", + "print(\"The mean of individual wealth is \"+ str(sim_wealth.mean()) + \";\\n the standard deviation is \"\n", + " + str(sim_wealth.std())+\";\\n the median is \" + str(np.median(sim_wealth)) +\".\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# Get some tools for plotting simulated vs actual wealth distributions\n", + "from HARK.utilities import getLorenzShares, getPercentiles\n", + "\n", + "# The cstwMPC model conveniently has data on the wealth distribution \n", + "# from the U.S. Survey of Consumer Finances\n", + "from HARK.cstwMPC.SetupParamsCSTW import SCF_wealth, SCF_weights" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'SCF_wealth' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mpctiles\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.001\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.999\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m15\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mSCF_Lorenz_points\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetLorenzShares\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mSCF_wealth\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mweights\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mSCF_weights\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpercentiles\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpctiles\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0msim_Lorenz_points\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetLorenzShares\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msim_wealth\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpercentiles\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpctiles\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'SCF_wealth' is not defined" + ] + } + ], + "source": [ + "# Construct the Lorenz curves and plot them\n", + "\n", + "pctiles = np.linspace(0.001,0.999,15)\n", + "SCF_Lorenz_points = getLorenzShares(SCF_wealth,weights=SCF_weights,percentiles=pctiles)\n", + "sim_Lorenz_points = getLorenzShares(sim_wealth,percentiles=pctiles)\n", + "\n", + "# Plot \n", + "plt.figure(figsize=(5,5))\n", + "plt.title('Wealth Distribution')\n", + "plt.plot(pctiles,SCF_Lorenz_points,'--k',label='SCF')\n", + "plt.plot(pctiles,sim_Lorenz_points,'-b',label='Benchmark KS')\n", + "plt.plot(pctiles,pctiles,'g-.',label='45 Degree')\n", + "plt.xlabel('Percentile of net worth')\n", + "plt.ylabel('Cumulative share of wealth')\n", + "plt.legend(loc=2)\n", + "plt.ylim([0,1])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'SCF_Lorenz_points' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Calculate a measure of the difference between the simulated and empirical distributions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mlorenz_distance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mSCF_Lorenz_points\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0msim_Lorenz_points\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"The Euclidean distance between simulated wealth distribution and the estimates from the SCF data is \"\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlorenz_distance\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'SCF_Lorenz_points' is not defined" + ] + } + ], + "source": [ + "# Calculate a measure of the difference between the simulated and empirical distributions\n", + "lorenz_distance = np.sqrt(np.sum((SCF_Lorenz_points - sim_Lorenz_points)**2))\n", + "print(\"The Euclidean distance between simulated wealth distribution and the estimates from the SCF data is \"+str(lorenz_distance) )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Heterogeneous Time Preference Rates\n", + "\n", + "As the figures show, the distribution of wealth that the baseline KS model produces is very far from matching the empirical degree of inequality in the US data.\n", + "\n", + "This could matter for macroeconomic purposes. For example, the SCF data indicate that many agents are concentrated at low values of wealth where the MPC is very large. We might expect, therefore, that a fiscal policy \"stimulus\" that gives a fixed amount of money to every agent would have a large effect on the consumption of the low-wealth households who have a high Marginal Propensity to Consume.\n", + "\n", + "KS attempt to address this problem by assuming that an individual agent's time preference rate can change over time.\n", + "\n", + "The rationale is that this represents a generational transition: The \"agent\" is really a \"dynasty\" and the time preference rate of the \"child\" dynast may differ from that of the \"parent.\"\n", + "\n", + "Specifically, KS assume that $\\beta$ can take on three values, 0.9858, 0.9894, and 0.9930, and that the transition probabilities are such that \n", + "- The invariant distribution for $\\beta$’s has 80 percent of the population at the middle $\\beta$ and 10 percent at each of the other $\\beta$’s.\n", + "- Immediate transitions between the extreme values of $\\beta$ occur with probability zero. \n", + "- The average duration of the highest and lowest $\\beta$’s is 50 years. \n", + "\n", + "The HARK toolkit is not natively set up to accommodate stochastic time preference factors (though an extension to accommodate this would be easy). \n", + "\n", + "Here, instead, we assume that different agents have different values of $\\beta$ that are uniformly distributed over some range. We approximate the uniform distribution by three points. The agents are heterogeneous _ex ante_ (and permanently)." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Construct the distribution of types\n", + "from HARK.utilities import approxUniform\n", + "\n", + "# Specify the distribution of the discount factor\n", + "num_types = 3 # number of types we want;\n", + "DiscFac_mean = 0.9858 # center of beta distribution \n", + "DiscFac_spread = 0.0085 # spread of beta distribution\n", + "DiscFac_dstn = approxUniform(num_types, DiscFac_mean-DiscFac_spread, DiscFac_mean+DiscFac_spread)[1]\n", + "BaselineType = deepcopy(KSAgent)\n", + "\n", + "MyTypes = [] # initialize an empty list to hold our consumer types\n", + "for nn in range(len(DiscFac_dstn)):\n", + " # Now create the types, and append them to the list MyTypes\n", + " NewType = deepcopy(BaselineType)\n", + " NewType.DiscFac = DiscFac_dstn[nn]\n", + " NewType.seed = nn # give each consumer type a different RNG seed\n", + " MyTypes.append(NewType)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "code_folding": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "**** WARNING: could not execute multiThreadCommands in HARK.core.Market.solveAgents() so using the serial version instead. This will likely be slower. The multiTreadCommands() functions failed with the following error: \n", + " : Can't pickle local object 'CobbDouglasEconomy.update..'\n" + ] + } + ], + "source": [ + "# Put all agents into the economy\n", + "KSEconomy_sim = CobbDouglasMarkovEconomy(agents = MyTypes, **KSEconomyDictionary) \n", + "KSEconomy_sim.AggShkDstn = KSAggShkDstn # Agg shocks are the same as defined earlier\n", + "\n", + "for ThisType in MyTypes:\n", + " ThisType.getEconomyData(KSEconomy_sim) # Makes attributes of the economy, attributes of the agent\n", + "\n", + "KSEconomy_sim.makeAggShkHist() # Make a simulated prehistory of the economy\n", + "KSEconomy_sim.solve() # Solve macro problem by getting a fixed point dynamic rule" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Get the level of end-of-period assets a for all types of consumers\n", + "aLvl_all = np.concatenate([KSEconomy_sim.aLvlNow[i] for i in range(len(MyTypes))])\n", + "\n", + "print('Aggregate capital to income ratio is ' + str(np.mean(aLvl_all)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Plot the distribution of wealth across all agent types\n", + "sim_3beta_wealth = aLvl_all\n", + "pctiles = np.linspace(0.001,0.999,15)\n", + "sim_Lorenz_points = getLorenzShares(sim_wealth,percentiles=pctiles)\n", + "SCF_Lorenz_points = getLorenzShares(SCF_wealth,weights=SCF_weights,percentiles=pctiles)\n", + "sim_3beta_Lorenz_points = getLorenzShares(sim_3beta_wealth,percentiles=pctiles)\n", + "\n", + "## Plot\n", + "plt.figure(figsize=(5,5))\n", + "plt.title('Wealth Distribution')\n", + "plt.plot(pctiles,SCF_Lorenz_points,'--k',label='SCF')\n", + "plt.plot(pctiles,sim_Lorenz_points,'-b',label='Benchmark KS')\n", + "plt.plot(pctiles,sim_3beta_Lorenz_points,'-*r',label='3 Types')\n", + "plt.plot(pctiles,pctiles,'g-.',label='45 Degree')\n", + "plt.xlabel('Percentile of net worth')\n", + "plt.ylabel('Cumulative share of wealth')\n", + "plt.legend(loc=2)\n", + "plt.ylim([0,1])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# The mean levels of wealth for the three types of consumer are \n", + "[np.mean(KSEconomy_sim.aLvlNow[0]),np.mean(KSEconomy_sim.aLvlNow[1]),np.mean(KSEconomy_sim.aLvlNow[2])]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "code_folding": [ + 0 + ], + "scrolled": true + }, + "outputs": [], + "source": [ + "# Plot the distribution of wealth \n", + "for i in range(len(MyTypes)):\n", + " if i<=2:\n", + " plt.hist(np.log(KSEconomy_sim.aLvlNow[i])\\\n", + " ,label=r'$\\beta$='+str(round(DiscFac_dstn[i],4))\\\n", + " ,bins=np.arange(-2.,np.log(max(aLvl_all)),0.05))\n", + " plt.yticks([])\n", + "plt.legend(loc=2)\n", + "plt.title('Log Wealth Distribution of 3 Types')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Distribution of wealth in original model with one type\n", + "plt.hist(np.log(sim_wealth),bins=np.arange(-2.,np.log(max(aLvl_all)),0.05))\n", + "plt.yticks([])\n", + "plt.title('Log Wealth Distribution of Original Model with One Type')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Target Wealth is Nonlinear in Time Preference Rate\n", + "\n", + "Note the nonlinear relationship between wealth and time preference in the economy with three types. Although the three groups are uniformly spaced in $\\beta$ values, there is a lot of overlap in the distribution of wealth of the two impatient types, who are both separated from the most patient type by a large gap. \n", + "\n", + "A model of buffer stock saving that has simplified enough to be [tractable](http://econ.jhu.edu/people/ccarroll/public/lecturenotes/Consumption/TractableBufferStock) yields some insight. If $\\sigma$ is a measure of income risk, $r$ is the interest rate, and $\\theta$ is the time preference rate, then for an 'impatient' consumer (for whom $\\theta > r$), in the logarithmic utility case an approximate formula for the target level of wealth is:\n", + "\n", + "\n", + "\n", + "\\begin{eqnarray}\n", + " a & \\approx & \\left(\\frac{1}{ \\theta(1+(\\theta-r)/\\sigma)-r}\\right)\n", + "\\end{eqnarray}\n", + "\n", + "Conceptually, this reflects the fact that the only reason any of these agents holds positive wealth is the precautionary motive. (If there is no uncertainty, $\\sigma=0$ and thus $a=0$). \n", + "\n", + "For positive uncertainty $\\sigma>0$, as the degree of impatience (given by $\\theta-r$) approaches zero, the target level of wealth approaches infinity. \n", + "\n", + "A plot of $a$ as a function of $\\theta$ for a particular parameterization is shown below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Plot target wealth as a function of time preference rate for calibrated tractable model\n", + "fig = plt.figure()\n", + "ax = plt.axes()\n", + "sigma = 0.01\n", + "r = 0.02\n", + "theta = np.linspace(0.023,0.10,100)\n", + "plt.plot(theta,1/(theta*(1+(theta-r)/sigma)-r))\n", + "plt.xlabel(r'$\\theta$')\n", + "plt.ylabel('Target wealth')\n", + "plt.show()" + ] + } + ], + "metadata": { + "jupytext": { + "formats": "ipynb,py:percent" + }, + "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.3" + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Documentation/notebooks/KrusellSmith.py b/Documentation/notebooks/KrusellSmith.py new file mode 100644 index 000000000..30188418d --- /dev/null +++ b/Documentation/notebooks/KrusellSmith.py @@ -0,0 +1,591 @@ +# -*- coding: utf-8 -*- +# --- +# jupyter: +# jupytext: +# formats: ipynb,py:percent +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.2' +# jupytext_version: 1.1.3 +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# --- + +# %% [markdown] +# # [Krusell Smith (1998)](https://www.journals.uchicago.edu/doi/pdf/10.1086/250034) +# +# - Original version by Tim Munday +# - Comments and extensions by Tao Wang +# - Further edits by Chris Carroll + +# %% [markdown] +# [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/econ-ark/DemARK/master?filepath=notebooks%2FKrusellSmith.ipynb) +# + +# %% [markdown] +# ### Overview +# +# The benchmark Krusell-Smith model has the following broad features: +# * The aggregate state switches between "good" and "bad" with known probabilities +# * All consumers experience the same aggregate state for the economy (good or bad) +# * _ex ante_ there is only one type of consumer, which is infinitely lived +# * _ex post_ heterogeneity arises from uninsurable idiosyncratic income shocks +# * Specifically, individuals are at risk of spells of unemployment +# * In a spell of unemployment, their income is zero +# +# Thus, each agent faces two types of uncertainty: About their employment state, and about the income they will earn when employed. And the values of income and unemployment risk depend on the aggregate state. +# + +# %% [markdown] +# ### Details +# +# #### Idiosyncratic +# Each agent _attempts_ to supply an amount of productive labor $\ell$ in each period. (Here and below we mostly follow the notation of Krusell and Smith (1998)). +# +# However, whether they _succeed_ in supplying that labor (and earning a corresponding wage) is governed by the realization of the stochastic variable $\epsilon$. If the agent is unlucky, $\epsilon$ is zero and the agent is unemployed. The amount of labor they succeed in supplying is thus $\epsilon\ell$. +# +# #### Aggregate +# Aggregate output ($\bar{y}$) is produced using a Cobb-Douglas production function using capital and labor. (Bars over variables indicate the aggregate value of a variable that has different values across different idiosyncratic consumers). +# +# $z$ denotes the aggregate shock to productivity. $z$ can take two values, either $z_g$ -- the "good" state, or $z_b < z_g$ -- the "bad" state. Consumers gain income from providing labor, and from the rental return on any capital they own. Labor and capital markets are perfectly efficient so both factors are both paid their marginal products. +# +# The agent can choose to save by buying capital $k$ which is bounded below at the borrowing constraint of 0. +# +# +# Putting all of this together, aggregate output is given by: +# \begin{eqnarray} +# \bar{y} & = & z\bar{k}^\alpha \bar{\ell}^{1-\alpha} +# \end{eqnarray} +# + +# %% [markdown] +# The aggregate shocks $z$ follow first-order Markov chains with the transition probability of moving from state $s$ to state $s'$ denoted by $\pi_{ss'}$. The aggregate shocks and individual shocks are correlated: The probability of being unemployed is higher in bad times, when aggregate productivity is low, than in good times, when aggregate productivity is high. +# +# #### Idiosyncratic and Aggregate Together +# +# The individual shocks satisfy the law of large numbers, and the model is constructed so that the number of agents who are unemployed in the good state always equals $u_g$, and is always $u_b$ in the bad state. Given the aggregate state, individual shocks are independent from each other. +# +# For the individual, the probability of moving between a good state and employment to a bad state and unemployment is denoted $\pi_{gb10}$ with similar notation for the other transition probabilities. +# +# (Krusell and Smith allow for serially correlated unemployment at the idiosyncratic level. Here we will simplify this and have unemployment be serially uncorrelated.) + +# %% [markdown] +# Finally, $\Gamma$ denotes the current distribution of consumers over capital and employment status, and $H$ denotes the law of motion of this distribution. + +# %% [markdown] +# #### The Idiosyncratic Individual's Problem Given the Aggregate State +# +# The individual's problem is: +# \begin{eqnarray*} +# V(k, \epsilon; \Gamma, z) &=& \max_{k'}\{U(c) + \beta \mathbb{E}[V(k' ,\epsilon'; \Gamma', z')|z, \epsilon]\} \\ +# c + k' &=& r(\bar{k}, \bar{\ell}, z)k + w(\bar{k}, \bar{\ell}, z)\ell\epsilon + (1-\delta)k \\ +# \Gamma' &=& H(\Gamma, z, z') \\ +# k' &\geq& 0 \\ +# \end{eqnarray*} + +# %% [markdown] +# Krusell and Smith define an equilibrium as a law of motion $H$, a value function $V$, a rule for updating capital $f$ and pricing functions $r$ and $w$, such that $V$ and $f$ solve the consumers problem, $r$ and $w$ denote the marginal products of capital and labour, and $H$ is consistent with $f$ (i.e. if we add up all of the individual agents capital choices we get the correct distribution of capital). + +# %% [markdown] +# ##### Discussion of the KS Algorithm +# +# In principle, $\Gamma$ is a high-dimensional object because it includes the whole distribution of individuals' wealth in the economy. Because the optimal amount to save is a nonlinear function of the level of idiosyncratic $k$, next period's aggregate capital stock $\bar{k}'$ depends on the distribution of the holdings of idiosyncratic $k$ across the population of consumers. Therefore the law of motion $H$ is not a trivial function of the $\Gamma$. +# +# KS simplified this problem by noting the following. +# +# 1. The agent cares about the future aggregate aggregate state only insofar as that state affects their own personal value of $c$ +# 1. Future values of $c$ depend on the aggregate state only through the budget constraint +# 1. The channels by which the budget constraint depends on the aggregate state are: +# * The probability distributions of $\epsilon$ and $z$ are affected by the aggregate state +# * Interest rates and wages depend on the future values of $\bar{k}$ and $\bar{\ell}$ +# 1. The probability distributions for the future values of $\{\epsilon, z\}$ are known +# * They are fully determined by the Markov transition matrices +# 1. But the values of $r$ and $w$ are both determined by the future value of $\bar{k}$ (in combination with the exogenous value of $\bar{\ell}$) +# * So the only _endogenous_ object that the agent needs to form expectations about, in order to have a complete rational expectation about everything affecting them, is $\bar{k}'$ +# +# The key result in Krusell and Smith is the discovery that a very simple linear rule does an extraordinarily good job (though not quite perfect) in forecasting $\bar{k'}$ +# +# They then argue that, since rationality is surely bounded to some degree, the solution that an agent obtains using a good forecasting rule for $\bar{k}'$ is "good enough" to compute an "approximate" solution to the consumer's optimization problem. +# +# They define a generic algorithm to find a forecasting rule for $\bar{k}$ as follows +# +# 1. Choose the number of moments $n$ of the distribution of $k$ to be included in the set of variables to forecast $\bar{k}'$. In the simplest case, $n=1$, the only forecasting variable for next period's $\bar{k}'$ is the mean (the first moment, $n=1$)) of current capital, $\bar{k}$. +# 2. Each individual adopts the same belief about the law motion of these moments, $H_I$ and finds the optimal decision policy, $f_I$, contingent on that guess. +# 3. Use the optimal policy to simulate a history of aggregate capital with a large number of agents. +# 4. Characterize the realized law of motion using the same number of moments $n$ +# 5. Compare it with the $H_I$, what is taken as given by individuals. +# 6. Iterate until the two converge. +# +# In the end, the solution to the original problem is well approximated by the following simplified problem: +# +# \begin{eqnarray*} +# V(k, \epsilon; \bar k, z) &=& max_{c, k'}\{U(c) + \beta E[V(k' ,\epsilon'; \bar k', z')|z, \epsilon]\} \\ +# c + k' &=& r(\bar{k}, \bar{\ell}, z)k + w(\bar{k}, \bar{\ell}, z)l\epsilon + (1-\delta)k \\ +# \text{When }~ z=z_g, \quad \mathbb{E}[\log\bar{k}'] & = & a_0 + a_1 \log\bar k \\ +# \text{When }~ z=z_b, \quad \mathbb{E}[\log\bar{k}'] & = & b_0 + b_1 \log\bar k \\ +# k' &\geq& 0 \\ +# \end{eqnarray*} + +# %% [markdown] +# ## Implementation Using the HARK Toolkit + +# %% [markdown] +# #### The Consumer + +# %% {"code_folding": [6, 17]} +# Import generic setup tools + +# This is a jupytext paired notebook that autogenerates KrusellSmith.py +# which can be executed from a terminal command line via "ipython KrusellSmith.py" +# But a terminal does not permit inline figures, so we need to test jupyter vs terminal +# Google "how can I check if code is executed in the ipython notebook" +def in_ipynb(): + try: + if str(type(get_ipython())) == "": + return True + else: + return False + except NameError: + return False + +# Determine whether to make the figures inline (for spyder or jupyter) +# vs whatever is the automatic setting that will apply if run from the terminal +if in_ipynb(): + # %matplotlib inline generates a syntax error when run from the shell + # so do this instead + get_ipython().run_line_magic('matplotlib', 'inline') +else: + get_ipython().run_line_magic('matplotlib', 'auto') + +# Import the plot-figure library matplotlib + +import matplotlib +import matplotlib.pyplot as plt +matplotlib.rcParams['text.usetex'] = True + +import sys +import os +from copy import copy +from HARK.utilities import plotFuncs, plotFuncsDer + +# %% {"code_folding": [0]} +# Import components of HARK needed for solving the KS model +from HARK.ConsumptionSaving.ConsAggShockModel import * +import HARK.ConsumptionSaving.ConsumerParameters as Params + +# Markov consumer type that allows aggregate shocks (redundant but instructive) +from HARK.ConsumptionSaving.ConsAggShockModel import AggShockMarkovConsumerType + +# %% {"code_folding": [0, 4]} +# Define a dictionary to make an 'instance' of our Krusell-Smith consumer. + +# The folded dictionary below contains many parameters to the +# AggShockMarkovConsumerType agent that are not needed for the KS model +KSAgentDictionary = { + "CRRA": 1.0, # Coefficient of relative risk aversion + "DiscFac": 0.99, # Intertemporal discount factor + "LivPrb" : [1.0], # Survival probability + "AgentCount" : 10000, # Number of agents of this type (only matters for simulation) + "aNrmInitMean" : 0.0, # Mean of log initial assets (only matters for simulation) + "aNrmInitStd" : 0.0, # Standard deviation of log initial assets (only for simulation) + "pLvlInitMean" : 0.0, # Mean of log initial permanent income (only matters for simulation) + "pLvlInitStd" : 0.0, # Standard deviation of log initial permanent income (only matters for simulation) + "PermGroFacAgg" : 1.0, # Aggregate permanent income growth factor (only matters for simulation) + "T_age" : None, # Age after which simulated agents are automatically killed + "T_cycle" : 1, # Number of periods in the cycle for this agent type +# Parameters for constructing the "assets above minimum" grid + "aXtraMin" : 0.001, # Minimum end-of-period "assets above minimum" value + "aXtraMax" : 20, # Maximum end-of-period "assets above minimum" value + "aXtraExtra" : [None], # Some other value of "assets above minimum" to add to the grid + "aXtraNestFac" : 3, # Exponential nesting factor when constructing "assets above minimum" grid + "aXtraCount" : 24, # Number of points in the grid of "assets above minimum" +# Parameters describing the income process + "PermShkCount" : 1, # Number of points in discrete approximation to permanent income shocks - no shocks of this kind! + "TranShkCount" : 1, # Number of points in discrete approximation to transitory income shocks - no shocks of this kind! + "PermShkStd" : [0.], # Standard deviation of log permanent income shocks - no shocks of this kind! + "TranShkStd" : [0.], # Standard deviation of log transitory income shocks - no shocks of this kind! + "UnempPrb" : 0.0, # Probability of unemployment while working - no shocks of this kind! + "UnempPrbRet" : 0.00, # Probability of "unemployment" while retired - no shocks of this kind! + "IncUnemp" : 0.0, # Unemployment benefits replacement rate + "IncUnempRet" : 0.0, # "Unemployment" benefits when retired + "tax_rate" : 0.0, # Flat income tax rate + "T_retire" : 0, # Period of retirement (0 --> no retirement) + "BoroCnstArt" : 0.0, # Artificial borrowing constraint; imposed minimum level of end-of period assets + "cycles": 0, # Consumer is infinitely lived + "PermGroFac" : [1.0], # Permanent income growth factor +# New Parameters that we need now + 'MgridBase': np.array([0.1,0.3,0.6, + 0.8,0.9,0.98, + 1.0,1.02,1.1, + 1.2,1.6,2.0, + 3.0]), # Grid of capital-to-labor-ratios (factors) + 'MrkvArray': np.array([[0.825,0.175], + [0.175,0.825]]), # Transition probabilities for macroecon. [i,j] is probability of being in state j next + # period conditional on being in state i this period. + 'PermShkAggStd' : [0.0,0.0], # Standard deviation of log aggregate permanent shocks by state. No continous shocks in a state. + 'TranShkAggStd' : [0.0,0.0], # Standard deviation of log aggregate transitory shocks by state. No continuous shocks in a state. + 'PermGroFacAgg' : 1.0 +} + +# Here we restate just the "interesting" parts of the consumer's specification + +KSAgentDictionary['CRRA'] = 1.0 # Relative risk aversion +KSAgentDictionary['DiscFac'] = 0.99 # Intertemporal discount factor +KSAgentDictionary['cycles'] = 0 # cycles=0 means consumer is infinitely lived + +# KS assume that 'good' and 'bad' times are of equal expected duration +# The probability of a change in the aggregate state is p_change=0.125 +p_change=0.125 +p_remain=1-p_change + +# Now we define macro transition probabilities for AggShockMarkovConsumerType +# [i,j] is probability of being in state j next period conditional on being in state i this period. +# In both states, there is 0.875 chance of staying, 0.125 chance of switching +AggMrkvArray = \ +np.array([[p_remain,p_change], # Probabilities of states 0 and 1 next period if in state 0 + [p_change,p_remain]]) # Probabilities of states 0 and 1 next period if in state 1 +KSAgentDictionary['MrkvArray'] = AggMrkvArray + +# %% +# Create the Krusell-Smith agent as an instance of AggShockMarkovConsumerType +KSAgent = AggShockMarkovConsumerType(**KSAgentDictionary) + +# %% [markdown] +# Now we need to specify the income distribution. +# +# The HARK toolkit allows for two components of labor income: Persistent (or permanent), and transitory. +# +# Using the KS notation above, a HARK consumer's income is +# \begin{eqnarray} +# y & = & w p \ell \epsilon +# \end{eqnarray} +# where $p$ is the persistent component of income. Krusell and Smith did not incorporate a persistent component of income, however, so we will simply calibrate $p=1$ for all states. +# +# For each of the two aggregate states we need to specify: +# * The _proportion_ of consumers in the $e$ and the $u$ states +# * The level of persistent/permanent productivity $p$ (always 1) +# * The ratio of actual to permanent productivity in each state $\{e,u\}$ +# * In the KS notation, this is $\epsilon\ell$ +# + +# %% {"code_folding": [0]} +# Construct the income distribution for the Krusell-Smith agent +prb_eg = 0.96 # Probability of employment in the good state +prb_ug = 1-prb_eg # Probability of unemployment in the good state +prb_eb = 0.90 # Probability of employment in the bad state +prb_ub = 1-prb_eb # Probability of unemployment in the bad state +p_ind = 1 # Persistent component of income is always 1 +ell_ug = ell_ub = 0 # Labor supply is zero for unemployed consumers in either agg state +ell_eg = 1.0/prb_eg # Labor supply for employed consumer in good state +ell_eb = 1.0/prb_eb # 1=pe_g*ell_ge+pu_b*ell_gu=pe_b*ell_be+pu_b*ell_gu + +# IncomeDstn is a list of lists, one for each aggregate Markov state +# Each contains three arrays of floats, representing a discrete approximation to the income process. +# Order: +# state probabilities +# idiosyncratic persistent income level by state (KS have no persistent shocks p_ind is always 1.0) +# idiosyncratic transitory income level by state + +KSAgent.IncomeDstn[0] = \ +[[np.array([prb_eg,prb_ug]),np.array([p_ind,p_ind]),np.array([ell_eg,ell_ug])], # Agg state good + [np.array([prb_eb,prb_ub]),np.array([p_ind,p_ind]),np.array([ell_eb,ell_ub])] # Agg state bad +] + +# %% [markdown] +# Up to this point, individual agents do not have enough information to solve their decision problem yet. What is missing are beliefs about the endogenous macro variables $r$ and $w$, both of which are functions of $\bar{k}$. + +# %% [markdown] +# #### The Aggregate Economy + +# %% {"code_folding": [2]} +from HARK.ConsumptionSaving.ConsAggShockModel import CobbDouglasMarkovEconomy + +KSEconomyDictionary = { + 'PermShkAggCount': 1, + 'TranShkAggCount': 1, + 'PermShkAggStd': [0.0,0.0], + 'TranShkAggStd': [0.0,0.0], + 'DeprFac': 0.025, # Depreciation factor + 'CapShare': 0.36, # Share of capital income in cobb-douglas production function + 'DiscFac': 0.99, + 'CRRA': 1.0, + 'PermGroFacAgg': [1.0,1.0], + 'AggregateL':1.0, # Not sure on this. Looks like we have fixed the labour level... + 'act_T':1200, # Number of periods for economy to run in simulation + 'intercept_prev': [0.0,0.0], # Make some initial guesses at linear savings rule intercepts for each state + 'slope_prev': [1.0,1.0], # Make some initial guesses at linear savings rule slopes for each state + 'MrkvArray': np.array([[0.875,0.125], + [0.125,0.875]]), # Transition probabilities + 'MrkvNow_init': 0 # Pick a state to start in (we pick the first state) +} + +# The 'interesting' parts of the CobbDouglasMarkovEconomy +KSEconomyDictionary['CapShare'] = 0.36 +KSEconomyDictionary['MrkvArray'] = AggMrkvArray + +KSEconomy = CobbDouglasMarkovEconomy(agents = [KSAgent], **KSEconomyDictionary) # Combine production and consumption sides into an "Economy" + +# %% [markdown] +# We have now populated the $\texttt{KSEconomy}$ with $\texttt{KSAgents}$ defined before. That is basically telling the agents to take the macro state from the $\texttt{KSEconomy}$. +# +# Now we construct the $\texttt{AggShkDstn}$ that specifies the evolution of the dynamics of the $\texttt{KSEconomy}$. +# +# The structure of the inputs for $\texttt{AggShkDstn}$ follows the same logic as for $\texttt{IncomeDstn}$. Now there is only one possible outcome for each aggregate state (the KS aggregate states are very simple), therefore, each aggregate state has only one possible condition which happens with probability 1. + +# %% {"code_folding": [0]} +# Calibrate the magnitude of the aggregate shocks + +Tran_g = 1.01 # Productivity z in the good aggregate state +Tran_b = 0.99 # and the bad state + +# The HARK framework allows permanent shocks +Perm_g = Perm_b = 1.0 # KS assume there are no aggregate permanent shocks + +# Aggregate productivity shock distribution by state. +# First element is probabilities of different outcomes, given the state you are in. +# Second element is agg permanent shocks (here we don't have any, so just they are just 1.). +# Third element is agg transitory shocks, which are calibrated the same as in Krusell Smith. + +KSAggShkDstn = [ + [np.array([1.0]),np.array([Perm_g]),np.array([Tran_g])], # Aggregate good + [np.array([1.0]),np.array([Perm_b]),np.array([Tran_b])] # Aggregate bad +] + +KSEconomy.AggShkDstn = KSAggShkDstn + +# %% [markdown] +# #### Summing Up +# +# The combined idiosyncratic and aggregate assumptions can be summarized mathematically as follows. +# +# $\forall \{s,s'\}=\{g,b\}\times\{g,b\}$, the following two conditions hold: +# +# $$\underbrace{\pi_{ss'01}}_{p(s \rightarrow s',u \rightarrow e)}+\underbrace{\pi_{ss'00}}_{p(s \rightarrow s', u \rightarrow u)} = \underbrace{\pi_{ss'11}}_{p(s\rightarrow s', e \rightarrow e) } + \underbrace{\pi_{ss'10}}_{p(s \rightarrow s', e \rightarrow u)} = \underbrace{\pi_{ss'}}_{p(s\rightarrow s')}$$ +# +# $$u_s \frac{\pi_{ss'00}}{\pi_{ss'}}+ (1-u_s) \frac{\pi_{ss'10}}{\pi_{ss'}} = u_{s'}$$ + +# %% [markdown] +# ### Solving the Model +# Now, we have fully defined all of the elements of the macroeconomy, and we are in postion to construct an object that represents the economy and to construct a rational expectations equilibrium. + +# %% {"code_folding": [0]} +# Construct the economy, make an initial history, then solve + +KSAgent.getEconomyData(KSEconomy) # Makes attributes of the economy, attributes of the agent + +KSEconomy.makeAggShkHist() # Make a simulated history of the economy + +# Set tolerance level. + +KSEconomy.tolerance = 0.001 + +# Solve macro problem by finding a fixed point for beliefs + +KSEconomy.solve() # Solve the economy using the market method. +# i.e. guess the saving function, and iterate until a fixed point + +# %% [markdown] +# The last line above is the converged aggregate saving rule for good and bad times, respectively. + +# %% {"code_folding": [0]} +# Plot some key results + +print('Aggregate savings as a function of aggregate market resources:') +plotFuncs(KSEconomy.AFunc,0.1,2*KSEconomy.kSS) + +print('Consumption function at each aggregate market resources gridpoint (in general equilibrium):') +KSAgent.unpackcFunc() +m_grid = np.linspace(0,10,200) +KSAgent.unpackcFunc() +for M in KSAgent.Mgrid: + c_at_this_M = KSAgent.solution[0].cFunc[0](m_grid,M*np.ones_like(m_grid)) #Have two consumption functions, check this + plt.plot(m_grid,c_at_this_M) +plt.show() + +print('Saving at each individual market resources gridpoint (in general equilibrium):') +KSAgent.unpackcFunc() +m_grid = np.linspace(0,10,200) +KSAgent.unpackcFunc() +for M in KSAgent.Mgrid: + s_at_this_M = m_grid-KSAgent.solution[0].cFunc[1](m_grid,M*np.ones_like(m_grid)) + c_at_this_M = KSAgent.solution[0].cFunc[1](m_grid,M*np.ones_like(m_grid)) #Have two consumption functions, check this + plt.plot(m_grid,s_at_this_M) +plt.show() + +# %% [markdown] +# ### The Wealth Distribution in KS +# +# #### Benchmark Model +# + +# %% +sim_wealth = KSEconomy.aLvlNow[0] + +print("The mean of individual wealth is "+ str(sim_wealth.mean()) + ";\n the standard deviation is " + + str(sim_wealth.std())+";\n the median is " + str(np.median(sim_wealth)) +".") + +# %% {"code_folding": [0]} +# Get some tools for plotting simulated vs actual wealth distributions +from HARK.utilities import getLorenzShares, getPercentiles + +# The cstwMPC model conveniently has data on the wealth distribution +# from the U.S. Survey of Consumer Finances +from HARK.cstwMPC.SetupParamsCSTW import SCF_wealth, SCF_weights + +# %% {"code_folding": [0]} +# Construct the Lorenz curves and plot them + +pctiles = np.linspace(0.001,0.999,15) +SCF_Lorenz_points = getLorenzShares(SCF_wealth,weights=SCF_weights,percentiles=pctiles) +sim_Lorenz_points = getLorenzShares(sim_wealth,percentiles=pctiles) + +# Plot +plt.figure(figsize=(5,5)) +plt.title('Wealth Distribution') +plt.plot(pctiles,SCF_Lorenz_points,'--k',label='SCF') +plt.plot(pctiles,sim_Lorenz_points,'-b',label='Benchmark KS') +plt.plot(pctiles,pctiles,'g-.',label='45 Degree') +plt.xlabel('Percentile of net worth') +plt.ylabel('Cumulative share of wealth') +plt.legend(loc=2) +plt.ylim([0,1]) +plt.show() + +# %% +# Calculate a measure of the difference between the simulated and empirical distributions +lorenz_distance = np.sqrt(np.sum((SCF_Lorenz_points - sim_Lorenz_points)**2)) +print("The Euclidean distance between simulated wealth distribution and the estimates from the SCF data is "+str(lorenz_distance) ) + +# %% [markdown] +# #### Heterogeneous Time Preference Rates +# +# As the figures show, the distribution of wealth that the baseline KS model produces is very far from matching the empirical degree of inequality in the US data. +# +# This could matter for macroeconomic purposes. For example, the SCF data indicate that many agents are concentrated at low values of wealth where the MPC is very large. We might expect, therefore, that a fiscal policy "stimulus" that gives a fixed amount of money to every agent would have a large effect on the consumption of the low-wealth households who have a high Marginal Propensity to Consume. +# +# KS attempt to address this problem by assuming that an individual agent's time preference rate can change over time. +# +# The rationale is that this represents a generational transition: The "agent" is really a "dynasty" and the time preference rate of the "child" dynast may differ from that of the "parent." +# +# Specifically, KS assume that $\beta$ can take on three values, 0.9858, 0.9894, and 0.9930, and that the transition probabilities are such that +# - The invariant distribution for $\beta$’s has 80 percent of the population at the middle $\beta$ and 10 percent at each of the other $\beta$’s. +# - Immediate transitions between the extreme values of $\beta$ occur with probability zero. +# - The average duration of the highest and lowest $\beta$’s is 50 years. +# +# The HARK toolkit is not natively set up to accommodate stochastic time preference factors (though an extension to accommodate this would be easy). +# +# Here, instead, we assume that different agents have different values of $\beta$ that are uniformly distributed over some range. We approximate the uniform distribution by three points. The agents are heterogeneous _ex ante_ (and permanently). + +# %% {"code_folding": [0]} +# Construct the distribution of types +from HARK.utilities import approxUniform + +# Specify the distribution of the discount factor +num_types = 3 # number of types we want; +DiscFac_mean = 0.9858 # center of beta distribution +DiscFac_spread = 0.0085 # spread of beta distribution +DiscFac_dstn = approxUniform(num_types, DiscFac_mean-DiscFac_spread, DiscFac_mean+DiscFac_spread)[1] +BaselineType = deepcopy(KSAgent) + +MyTypes = [] # initialize an empty list to hold our consumer types +for nn in range(len(DiscFac_dstn)): + # Now create the types, and append them to the list MyTypes + NewType = deepcopy(BaselineType) + NewType.DiscFac = DiscFac_dstn[nn] + NewType.seed = nn # give each consumer type a different RNG seed + MyTypes.append(NewType) + +# %% {"code_folding": [0]} +# Put all agents into the economy +KSEconomy_sim = CobbDouglasMarkovEconomy(agents = MyTypes, **KSEconomyDictionary) +KSEconomy_sim.AggShkDstn = KSAggShkDstn # Agg shocks are the same as defined earlier + +for ThisType in MyTypes: + ThisType.getEconomyData(KSEconomy_sim) # Makes attributes of the economy, attributes of the agent + +KSEconomy_sim.makeAggShkHist() # Make a simulated prehistory of the economy +KSEconomy_sim.solve() # Solve macro problem by getting a fixed point dynamic rule + +# %% {"code_folding": [0]} +# Get the level of end-of-period assets a for all types of consumers +aLvl_all = np.concatenate([KSEconomy_sim.aLvlNow[i] for i in range(len(MyTypes))]) + +print('Aggregate capital to income ratio is ' + str(np.mean(aLvl_all))) + +# %% {"code_folding": [0]} +# Plot the distribution of wealth across all agent types +sim_3beta_wealth = aLvl_all +pctiles = np.linspace(0.001,0.999,15) +sim_Lorenz_points = getLorenzShares(sim_wealth,percentiles=pctiles) +SCF_Lorenz_points = getLorenzShares(SCF_wealth,weights=SCF_weights,percentiles=pctiles) +sim_3beta_Lorenz_points = getLorenzShares(sim_3beta_wealth,percentiles=pctiles) + +## Plot +plt.figure(figsize=(5,5)) +plt.title('Wealth Distribution') +plt.plot(pctiles,SCF_Lorenz_points,'--k',label='SCF') +plt.plot(pctiles,sim_Lorenz_points,'-b',label='Benchmark KS') +plt.plot(pctiles,sim_3beta_Lorenz_points,'-*r',label='3 Types') +plt.plot(pctiles,pctiles,'g-.',label='45 Degree') +plt.xlabel('Percentile of net worth') +plt.ylabel('Cumulative share of wealth') +plt.legend(loc=2) +plt.ylim([0,1]) +plt.show() + +# %% {"code_folding": [0]} +# The mean levels of wealth for the three types of consumer are +[np.mean(KSEconomy_sim.aLvlNow[0]),np.mean(KSEconomy_sim.aLvlNow[1]),np.mean(KSEconomy_sim.aLvlNow[2])] + +# %% {"code_folding": [0]} +# Plot the distribution of wealth +for i in range(len(MyTypes)): + if i<=2: + plt.hist(np.log(KSEconomy_sim.aLvlNow[i])\ + ,label=r'$\beta$='+str(round(DiscFac_dstn[i],4))\ + ,bins=np.arange(-2.,np.log(max(aLvl_all)),0.05)) + plt.yticks([]) +plt.legend(loc=2) +plt.title('Log Wealth Distribution of 3 Types') +plt.show() + +# %% {"code_folding": [0]} +# Distribution of wealth in original model with one type +plt.hist(np.log(sim_wealth),bins=np.arange(-2.,np.log(max(aLvl_all)),0.05)) +plt.yticks([]) +plt.title('Log Wealth Distribution of Original Model with One Type') +plt.show() + +# %% [markdown] +# ### Target Wealth is Nonlinear in Time Preference Rate +# +# Note the nonlinear relationship between wealth and time preference in the economy with three types. Although the three groups are uniformly spaced in $\beta$ values, there is a lot of overlap in the distribution of wealth of the two impatient types, who are both separated from the most patient type by a large gap. +# +# A model of buffer stock saving that has simplified enough to be [tractable](http://econ.jhu.edu/people/ccarroll/public/lecturenotes/Consumption/TractableBufferStock) yields some insight. If $\sigma$ is a measure of income risk, $r$ is the interest rate, and $\theta$ is the time preference rate, then for an 'impatient' consumer (for whom $\theta > r$), in the logarithmic utility case an approximate formula for the target level of wealth is: +# +# +# +# \begin{eqnarray} +# a & \approx & \left(\frac{1}{ \theta(1+(\theta-r)/\sigma)-r}\right) +# \end{eqnarray} +# +# Conceptually, this reflects the fact that the only reason any of these agents holds positive wealth is the precautionary motive. (If there is no uncertainty, $\sigma=0$ and thus $a=0$). +# +# For positive uncertainty $\sigma>0$, as the degree of impatience (given by $\theta-r$) approaches zero, the target level of wealth approaches infinity. +# +# A plot of $a$ as a function of $\theta$ for a particular parameterization is shown below. + +# %% {"code_folding": [0]} +# Plot target wealth as a function of time preference rate for calibrated tractable model +fig = plt.figure() +ax = plt.axes() +sigma = 0.01 +r = 0.02 +theta = np.linspace(0.023,0.10,100) +plt.plot(theta,1/(theta*(1+(theta-r)/sigma)-r)) +plt.xlabel(r'$\theta$') +plt.ylabel('Target wealth') +plt.show() diff --git a/Documentation/notebooks/LifecycleModelExample.ipynb b/Documentation/notebooks/LifecycleModelExample.ipynb new file mode 100644 index 000000000..ef0eb0413 --- /dev/null +++ b/Documentation/notebooks/LifecycleModelExample.ipynb @@ -0,0 +1,378 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# The Distribution of Assets By Age\n", + "\n", + "National registry data on income and wealth from Scandinavian countries has recently become available (with a lot of security) to some (lucky!) researchers. These data offer a uniquely powerful tool for testing (and improving) our models of consumption and saving behavior over the life cycle.\n", + "\n", + "\n", + "But as of this writing (in March of 2019), the data are so new that there do not seem to be any published attempts to compare the data to the implications a standard life cycle model with income uncertainty, constraints, and other modern features.\n", + "\n", + "This notebook is an example of how one could counstruct a life cycle model with the HARK toolkit that would make predictions about the model analogues of the raw data statistics that are available. \n", + "\n", + "For example, the papers have shown information about the growth rate of assets at different ages over the life cycle. Here, we show how (under a given parameterization) we could produce the life cycle model's prediction about the distribution of assets at age 65 and age 66, and the growth rate between 65 and 66. \n", + "\n", + "The parameters of the model have not been optmized to match features of the Norwegian data; a first step in \"structural\" estimation would be to calibrate the inputs to the model (like the profile of income over the life cycle, and the magnitude of income shocks), and then to find the values of parameters like the time preference rate that allow the model to fit the data best.\n", + "\n", + "An interesting question is whether this exercise will suggest that it is necessary to allow for _ex ante_ heterogeneity in such preference parameters.\n", + "\n", + "This seems likely; a paper by [](http://econ.jhu.edu/people/ccarroll/papers/cstwMPC) (all of whose results were constructed using the HARK toolkit) finds that, if all other parameters (e.g., rates of return on savings) are the same, models of this kind require substantial heterogeneity in preferences to generate the degree of inequality in U.S. data.\n", + "\n", + "But in one of the many new and interesting findings from the Norwegian data, have shown that there is substantial heterogeneity in rates of return, even on wealth held in public markets. \n", + "[Derin Aksit](https://github.com/econ-ark/REMARK) has shown that the degree of time preference heterogeneity needed to match observed inequality is considerably less when rate-of-return heterogeneity is calibrated to match these data." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "# Initial imports and notebook setup, click arrow to show\n", + "\n", + "import HARK.ConsumptionSaving.ConsIndShockModel as Model # The consumption-saving micro model\n", + "import HARK.SolvingMicroDSOPs.EstimationParameters as Params # Parameters for the consumer type and the estimation\n", + "from HARK.utilities import plotFuncsDer, plotFuncs # Some tools\n", + "\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Set up default values for CRRA, DiscFac, and simulation variables in the dictionary \n", + "Params.init_consumer_objects[\"CRRA\"]= 2.00 # Default coefficient of relative risk aversion (rho)\n", + "Params.init_consumer_objects[\"DiscFac\"]= 0.97 # Default intertemporal discount factor (beta)\n", + "Params.init_consumer_objects[\"PermGroFacAgg\"]= 1.0 # Aggregate permanent income growth factor \n", + "Params.init_consumer_objects[\"aNrmInitMean\"]= -10.0 # Mean of log initial assets \n", + "Params.init_consumer_objects[\"aNrmInitStd\"]= 1.0 # Standard deviation of log initial assets\n", + "Params.init_consumer_objects[\"pLvlInitMean\"]= 0.0 # Mean of log initial permanent income \n", + "Params.init_consumer_objects[\"pLvlInitStd\"]= 0.0 # Standard deviation of log initial permanent income" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Make a lifecycle consumer to be used for estimation\n", + "LifeCyclePop = Model.IndShockConsumerType(**Params.init_consumer_objects)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Solve and simulate the model (ignore the \"warning\" message)\n", + "LifeCyclePop.solve() # Obtain consumption rules by age \n", + "LifeCyclePop.unpackcFunc() # Expose the consumption rules\n", + "\n", + "# Which variables do we want to track\n", + "LifeCyclePop.track_vars = ['aNrmNow','pLvlNow','mNrmNow','cNrmNow','TranShkNow']\n", + "\n", + "LifeCyclePop.T_sim = 120 # Nobody lives to be older than 145 years (=25+120)\n", + "LifeCyclePop.initializeSim() # Construct the age-25 distribution of income and assets\n", + "LifeCyclePop.simulate() # Simulate a population behaving according to this model" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption as a function of market resources while working:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption functions during working life\n", + "\n", + "print('Consumption as a function of market resources while working:')\n", + "mMin = min([LifeCyclePop.solution[t].mNrmMin for t in range(LifeCyclePop.T_cycle)])\n", + "plotFuncs(LifeCyclePop.cFunc[:LifeCyclePop.T_retire],mMin,5)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Define the saving rate function\n", + "def savingRateFunc(SomeType, m):\n", + " \"\"\"\n", + " Parameters:\n", + " ----------\n", + " SomeType: \n", + " Agent type that has been solved and simulated.\n", + " \n", + " \n", + " Returns:\n", + " --------\n", + " SavingRate: float\n", + " \n", + " \"\"\"\n", + " inc = (SomeType.Rfree -1.)*(m-1.)+1.\n", + " cons = SomeType.solution[0].cFunc(m)\n", + " Saving = inc - cons\n", + " SavingRate = Saving / inc\n", + " return SavingRate " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# Create a Giant matrix gathering useful data:\n", + "# 't_now', 'aNrmNow_hist', 'cNrmNow_hist', employment-status in date t, in date t-1, aLvlGro_hist, Saving rate\n", + "\n", + "w, h = 1, LifeCyclePop.T_cycle\n", + "giant_list = [[0 for x in range(w)] for y in range(h)]\n", + "SavingRate_list = []\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\") # Suppress some disturbing but harmless warnings\n", + "\n", + "for t in range(1,LifeCyclePop.T_cycle+1):\n", + " #aLvlGro_hist[0] = 0 # set the first growth rate to 0, since there is no data for period 0\n", + " aLvlGroNow = np.log(LifeCyclePop.aNrmNow_hist[t]/LifeCyclePop.aNrmNow_hist[t-1]) # (10000,)\n", + "\n", + " # Call the saving rate function with test value for \n", + " SavingRate = savingRateFunc(LifeCyclePop, LifeCyclePop.mNrmNow_hist[t] )\n", + " \n", + " SavingRate_list.append(SavingRate)\n", + "\n", + " # Create elements of matrix list\n", + " matrix_list = [0 for number in range(7)]\n", + " matrix_list[0] = t\n", + " matrix_list[1] = LifeCyclePop.aNrmNow_hist[t]\n", + " matrix_list[2] = LifeCyclePop.cNrmNow_hist[t]\n", + " matrix_list[3] = LifeCyclePop.TranShkNow_hist[t]\n", + " matrix_list[4] = LifeCyclePop.TranShkNow_hist[t-1]\n", + " matrix_list[5] = aLvlGroNow\n", + " matrix_list[6] = SavingRate\n", + " \n", + " giant_list[t-1] = matrix_list\n", + " \n", + "# Print command disabled to prevent giant print!\n", + "#print giant_list" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# Construct the level of assets A from a*p where a is the ratio to permanent income p\n", + "LifeCyclePop.aLvlNow_hist = LifeCyclePop.aNrmNow_hist*LifeCyclePop.pLvlNow_hist\n", + "aGro41=LifeCyclePop.aLvlNow_hist[41]/LifeCyclePop.aLvlNow_hist[40]\n", + "aGro41NoU=aGro41[aGro41[:]>0.2] # Throw out extreme outliers" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the distribution of growth rates of wealth between age 65 and 66 (=25 + 41)\n", + "from matplotlib import pyplot as plt\n", + "n, bins, patches = plt.hist(aGro41NoU,50,density=True)" + ] + } + ], + "metadata": { + "cite2c": { + "citations": { + "6202365/7MR8GUVS": { + "DOI": "10.3982/QE694", + "URL": "https://onlinelibrary.wiley.com/doi/abs/10.3982/QE694", + "abstract": "In a model calibrated to match micro- and macroeconomic evidence on household income dynamics, we show that a modest degree of heterogeneity in household preferences or beliefs is sufficient to match empirical measures of wealth inequality in the United States. The heterogeneity-augmented model's predictions are consistent with microeconomic evidence that suggests that the annual marginal propensity to consume (MPC) is much larger than the roughly 0.04 implied by commonly used macroeconomic models (even ones including some heterogeneity). The high MPC arises because many consumers hold little wealth despite having a strong precautionary motive. Our model also plausibly predicts that the aggregate MPC can differ greatly depending on how the shock is distributed across households (depending, e.g., on their wealth, or employment status).", + "accessed": { + "day": 5, + "month": 2, + "year": 2019 + }, + "author": [ + { + "family": "Carroll", + "given": "Christopher" + }, + { + "family": "Slacalek", + "given": "Jiri" + }, + { + "family": "Tokuoka", + "given": "Kiichi" + }, + { + "family": "White", + "given": "Matthew N." + } + ], + "container-title": "Quantitative Economics", + "id": "6202365/7MR8GUVS", + "issue": "3", + "issued": { + "year": 2017 + }, + "language": "en", + "note": "Citation Key: carrollDistributionWealthMarginal2017", + "page": "977-1020", + "page-first": "977", + "title": "The distribution of wealth and the marginal propensity to consume", + "type": "article-journal", + "volume": "8" + }, + "6202365/B9BGV9W3": { + "URL": "http://www.nber.org/papers/w22822", + "abstract": "We provide a systematic analysis of the properties of individual returns to wealth using twenty years of population data from Norway’s administrative tax records. We document a number of novel results. First, in a given cross-section, individuals earn markedly different returns on their assets, with a difference of 500 basis points between the 10th and the 90th percentile. Second, heterogeneity in returns does not arise merely from differences in the allocation of wealth between safe and risky assets: returns are heterogeneous even within asset classes. Third, returns are positively correlated with wealth. Fourth, returns have an individual permanent component that accounts for 60% of the explained variation. Fifth, for wealth below the 95th percentile, the individual permanent component accounts for the bulk of the correlation between returns and wealth; the correlation at the top reflects both compensation for risk and the correlation of wealth with the individual permanent component. Finally, the permanent component of the return to wealth is also (mildly) correlated across generations. We discuss the implications of these findings for several strands of the wealth inequality debate.", + "accessed": { + "day": 17, + "month": 3, + "year": 2019 + }, + "author": [ + { + "family": "Fagereng", + "given": "Andreas" + }, + { + "family": "Guiso", + "given": "Luigi" + }, + { + "family": "Malacrino", + "given": "Davide" + }, + { + "family": "Pistaferri", + "given": "Luigi" + } + ], + "genre": "Working Paper", + "id": "6202365/B9BGV9W3", + "issued": { + "month": 11, + "year": 2016 + }, + "note": "DOI: 10.3386/w22822", + "number": "22822", + "publisher": "National Bureau of Economic Research", + "title": "Heterogeneity and Persistence in Returns to Wealth", + "type": "report" + } + } + }, + "jupytext": { + "formats": "ipynb,py:percent", + "metadata_filter": { + "cells": "collapsed" + }, + "text_representation": { + "extension": ".py", + "format_name": "percent", + "format_version": "1.1", + "jupytext_version": "0.8.3" + } + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.7" + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Documentation/notebooks/Nondurables-During-Great-Recession.ipynb b/Documentation/notebooks/Nondurables-During-Great-Recession.ipynb new file mode 100644 index 000000000..2edfb7b43 --- /dev/null +++ b/Documentation/notebooks/Nondurables-During-Great-Recession.ipynb @@ -0,0 +1,562 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Spending on Nondurables During the Great Recession" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# Initial imports and notebook setup, click arrow to show\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "## Import some things from cstwMPC\n", + "\n", + "# The first step is to be able to bring things in from different directories\n", + "import sys \n", + "import os\n", + "\n", + "# Let python find any useful library files\n", + "sys.path.insert(0, os.path.abspath('../../.'))\n", + "\n", + "\n", + "from lib.util import log_progress\n", + "\n", + "import numpy as np\n", + "from copy import deepcopy\n", + "\n", + "import HARK # Prevents import error from Demos repo\n", + "from HARK.utilities import plotFuncs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### There Was a Big Drop in Consumption ... \n", + "Between the second and fourth quarters of 2018, nondurables consumption spending in the U.S. dropped by an unprecedented 6.4 percent. High frequency data show a drop in retail sales of something like 10 percent between the weekend before the Lehmann collapse and the weekend after Lehmann. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ... and Uncertainty Could Induce A Drop In Consumption ... \n", + "Increased \"uncertainty\" has become a popular explanation of much of what happened in the Great Recession -- including this drop. Qualitatively, it is well known that a perceived increase in labor income uncertainty should induce more saving (less consumption) for precautionary reasons.\n", + "\n", + "### ... But Is the Story _Quantitatively_ Plausible?\n", + "But if explaining a 6.4 percent drop in consumption would require an implausibly large increase in uncertainty, the story that uncertainty explains the consumption drop is implausible. \n", + "\n", + "### Transitory Shocks, Permanent Shocks, or Unemployment\n", + "The $\\texttt{ConsIndShockConsumerType}$ model incorporates three kinds of uncertainty: Unemployment spells, during which income is reduced to some small proportion of its normal level; and, for consumers who remain employed, transitory and permanent shocks with standard deviations $\\sigma_{\\theta}$ and $\\sigma_{\\psi}$. \n", + "\n", + "### The Question:\n", + "How large an increase in the standard deviation of $\\sigma_{\\psi}$ would be necessary to induce a 6.4 percent drop in consumption in one quarter? What about $\\sigma_{\\theta}$? How high would the perceived unemployment probability have to be?\n", + "\n", + "The first step is to create the agents we want to solve the model for.\n", + "\n", + "Model set up:\n", + "- \"Standard\" infinite horizon consumption/savings model, with mortality and permanent and temporary shocks to income\n", + "- Ex-ante heterogeneity in consumers' discount factors\n", + " \n", + "With this basic setup, HARK's IndShockConsumerType is the appropriate subclass of $\\texttt{AgentType}$. So we need to prepare the parameters to create instances of that class.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# Import calibrated parameters from the cstwMPC project.\n", + "init_infinite = {\n", + " \"CRRA\":1.0, # Coefficient of relative risk aversion \n", + " \"Rfree\":1.01/(1.0 - 1.0/160.0), # Survival probability,\n", + " \"PermGroFac\":[1.000**0.25], # Permanent income growth factor (no perm growth),\n", + " \"PermGroFacAgg\":1.0,\n", + " \"BoroCnstArt\":0.0,\n", + " \"CubicBool\":False,\n", + " \"vFuncBool\":False,\n", + " \"PermShkStd\":[(0.01*4/11)**0.5], # Standard deviation of permanent shocks to income\n", + " \"PermShkCount\":5, # Number of points in permanent income shock grid\n", + " \"TranShkStd\":[(0.01*4)**0.5], # Standard deviation of transitory shocks to income,\n", + " \"TranShkCount\":5, # Number of points in transitory income shock grid\n", + " \"UnempPrb\":0.07, # Probability of unemployment while working\n", + " \"IncUnemp\":0.15, # Unemployment benefit replacement rate\n", + " \"UnempPrbRet\":None,\n", + " \"IncUnempRet\":None,\n", + " \"aXtraMin\":0.00001, # Minimum end-of-period assets in grid\n", + " \"aXtraMax\":20, # Maximum end-of-period assets in grid\n", + " \"aXtraCount\":20, # Number of points in assets grid,\n", + " \"aXtraExtra\":[None],\n", + " \"aXtraNestFac\":3, # Number of times to 'exponentially nest' when constructing assets grid\n", + " \"LivPrb\":[1.0 - 1.0/160.0], # Survival probability\n", + " \"DiscFac\":0.97, # Default intertemporal discount factor, # dummy value, will be overwritten\n", + " \"cycles\":0,\n", + " \"T_cycle\":1,\n", + " \"T_retire\":0,\n", + " 'T_sim':1200, # Number of periods to simulate (idiosyncratic shocks model, perpetual youth)\n", + " 'T_age': 400,\n", + " 'IndL': 10.0/9.0, # Labor supply per individual (constant),\n", + " 'aNrmInitMean':np.log(0.00001),\n", + " 'aNrmInitStd':0.0,\n", + " 'pLvlInitMean':0.0,\n", + " 'pLvlInitStd':0.0,\n", + " 'AgentCount':10000,\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we import the class itself and make a baseline type." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n", + "BaselineType = IndShockConsumerType(**init_infinite)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For this exercise, we will introduce _ex ante_ heterogeneity, so the baseline type will be copied several times.\n", + "\n", + "First, let's create a list with seven copies of our baseline type." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# A list in python can contain anything -- including consumers\n", + "num_consumer_types = 7 # declare the number of types we want\n", + "ConsumerTypes = [] # initialize an empty list\n", + "\n", + "for nn in range(num_consumer_types):\n", + " # Now create the types, and append them to the list ConsumerTypes\n", + " NewType = deepcopy(BaselineType)\n", + " NewType.seed = nn # give each consumer type a different RNG seed\n", + " ConsumerTypes.append(NewType)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can give each of the consumer types their own discount factor. (This distribution of parameters was estimated in the paper [\"The Distribution of Wealth and the Marginal Propensity to Consume\" by Carroll, Slacalek, Tokuoka, and White (2017) (cstwMPC)](http://econ.jhu.edu/people/ccarroll/papers/cstwMPC). " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# Seven types is enough to approximate the uniform distribution (5 is not quite enough)\n", + "from HARK.utilities import approxUniform\n", + "\n", + "# Calibrations from cstwMPC\n", + "bottomDiscFac = 0.9800\n", + "topDiscFac = 0.9934 \n", + "DiscFac_list = approxUniform(N=num_consumer_types,bot=bottomDiscFac,top=topDiscFac)[1]\n", + "\n", + "# Now, assign the discount factors\n", + "for j in range(num_consumer_types):\n", + " ConsumerTypes[j].DiscFac = DiscFac_list[j]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our agents now exist and have a concept of the problem they face, but we still need them to solve that problem.\n", + "\n", + "Once we have solved each type of consumer's individual problem, we need to know the distribution of wealth (and permanent income) that the population would achieve in the long run.\n", + "\n", + "The cell below does both of those tasks, looping through the consumer types. For each one, it solves that type's infinite horizon model, then simulates 1000 periods to generate an approximation to the long run distribution of wealth." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "code_folding": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8253aad09d7f46adb68a453692eeea07", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HTML(value=''), IntProgress(value=0, max=7)))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00043 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00237 \n" + ] + } + ], + "source": [ + "# log_progress presents a pretty bar that interactively shows how far the calculations have gotten\n", + "for ConsumerType in log_progress(ConsumerTypes, every=1):\n", + " ## We configured their discount factor above. Now solve\n", + " ConsumerType.solve()\n", + " \n", + " # Now simulate many periods to get to the stationary distribution\n", + " ConsumerType.T_sim = 1000\n", + " ConsumerType.initializeSim()\n", + " ConsumerType.simulate()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With all of that setup taken care of, let's write some functions to run our counterfactual exercise and extract the information we want.\n", + "\n", + "First, let's define a simple function that merely calculates the average consumption level across the entire population in the most recent simulated period." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# We just merge the cNrm and pNrm lists already constructed for each ConsumerType\n", + "def calcAvgC(ConsumerTypes):\n", + " \"\"\"\n", + " This function calculates average consumption in the economy in last simulated period,\n", + " averaging across ConsumerTypes.\n", + " \"\"\"\n", + " # Make arrays with all types' (normalized) consumption and permanent income level\n", + " # The brackets indicate that the contents will be a list (in this case, of lists)\n", + " cNrm = np.concatenate([ThisType.cNrmNow for ThisType in ConsumerTypes])\n", + " pLvl = np.concatenate([ThisType.pLvlNow for ThisType in ConsumerTypes])\n", + " \n", + " # Calculate and return average consumption level in the economy\n", + " avgC = np.mean(cNrm*pLvl) # c is the ratio to p, so C = c*p\n", + " return avgC" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's create a function to run the experiment we want -- change income uncertainty, and see how consumption changes.\n", + "To keep the code block below (mostly) clean, we'll describe the procedure below step by step here, with accompanying annotations in the codeblock.\n", + "\n", + "1. Initialize an empty list to hold the changes in consumption that happen after parameters change, and calculate average consumption before the change in uncertainty.\n", + "2. Loop through the new uncertainty parameter values to assign. For each parameter value:\n", + " 1. Assign the parameter value to the agents\n", + " 2. Re-solve the agent's model under that degree of uncertainty\n", + " 3. Construct a population of agents distributed according to the pre-crisis steady state\n", + " 4. Simulate one more period-- the first period after the change in risk.\n", + " 5. Calculate the population average consumption level given the new consumption rule\n", + " 6. Calculate the new average consumption level as percentage change vs the prior level.\n", + "3. Return the list of percentage changes" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# Whenever you define a function, you should describe it (with a \"docstring\")\n", + "def calcConsChangeAfterUncertaintyChange(OriginalTypes,NewVals,ParamToChange):\n", + " '''\n", + " Calculate the change in aggregate consumption for a list of values that a \n", + " parameter will take on.\n", + " \n", + " Parameters\n", + " ----------\n", + " OriginalTypes : [IndShockConsumerType]\n", + " List of consumer types, who have already had their \"pre-shock\" problem solved and simulated.\n", + " NewVals : np.array\n", + " List or array of new values that the parameter of interest will take on.\n", + " ParamToChange : str\n", + " Name of the income distribution parameter that will be changed.\n", + " \n", + " Returns\n", + " -------\n", + " ChangesInConsumption : [float]\n", + " List of changes in aggregate consumption corresponding to the values in NewVals, as a percentage\n", + " of the original aggregate consumption level.\n", + " '''\n", + " ChangesInConsumption = [] # Step 1\n", + " OldAvgC = calcAvgC(OriginalTypes)\n", + "\n", + " # Step 2 (the loop over counterfactual parameter values)\n", + " for NewVal in log_progress(NewVals, every=1):\n", + " if ParamToChange in [\"PermShkStd\",\"TranShkStd\"]:\n", + " ThisVal = [NewVal]\n", + " else:\n", + " ThisVal = NewVal\n", + "\n", + " ConsumerTypesNew = deepcopy(OriginalTypes) \n", + " for index,ConsumerTypeNew in enumerate(ConsumerTypesNew):\n", + " setattr(ConsumerTypeNew,ParamToChange,ThisVal) # Step 2A \n", + " ConsumerTypeNew.updateIncomeProcess()\n", + " ConsumerTypeNew.solve() # Step 2B\n", + " \n", + " ConsumerTypeNew.initializeSim() # Step 2C\n", + " ConsumerTypeNew.aNrmNow = OriginalTypes[index].aNrmNow\n", + " ConsumerTypeNew.pLvlNow = OriginalTypes[index].pLvlNow\n", + " \n", + " ConsumerTypeNew.simOnePeriod() # Step 2D\n", + "\n", + " NewAvgC = calcAvgC(ConsumerTypesNew) # Step 2E\n", + " ChangeInConsumption = 100. * (NewAvgC - OldAvgC) / OldAvgC # Step 2F\n", + " ChangesInConsumption.append(ChangeInConsumption)\n", + "\n", + " return ChangesInConsumption # Step 3, returning the output" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our counterfactual experiment function takes three inputs-- consumer types, counterfactual values, and the name of the parameter we want to change. For the sake of convenience, let's define small functions to run the experiment for each parameter with just a single input." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# Trivial functions can be useful in making the logic of your program clear\n", + "def calcConsChangeAfterPermShkChange(newVals):\n", + " return calcConsChangeAfterUncertaintyChange(ConsumerTypes,newVals,\"PermShkStd\")\n", + "\n", + "def calcConsChangeAfterTranShkChange(newVals):\n", + " return calcConsChangeAfterUncertaintyChange(ConsumerTypes,newVals,\"TranShkStd\")\n", + "\n", + "def calcConsChangeAfterUnempPrbChange(newVals):\n", + " return calcConsChangeAfterUncertaintyChange(ConsumerTypes,newVals,\"UnempPrb\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can finally run our experiment. In the cell below, we generate a plot of the change in aggregate consumption vs the (underlying) standard deviation of permanent income shocks." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "code_folding": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "12d979d73c00420d9ed7f88e36e9b014", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HTML(value=''), IntProgress(value=0, max=10)))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00043 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00237 \n", + "The given parameter values violate the growth impatience condition for this consumer type; the GIF is: 1.0003\n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00043 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00237 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00043 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00237 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00043 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00237 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00043 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00237 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00043 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00237 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00043 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00237 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00043 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00237 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00043 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00237 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00043 \n", + "The given type violates the absolute impatience condition with the supplied parameter values; the AIF is 1.00237 \n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate the consequences of an \"MIT shock\" to the standard deviation of permanent shocks\n", + "ratio_min = 0.8 # minimum number to multiply uncertainty parameter by\n", + "TargetChangeInC = -6.3 # Source: FRED\n", + "num_points = 10 # number of parameter values to plot in graphs. More=slower\n", + "\n", + "# First change the variance of the permanent income shock\n", + "perm_ratio_max = 2.0 # Put whatever value in you want! maximum number to multiply std of perm income shock by\n", + "\n", + "perm_min = BaselineType.PermShkStd[0] * ratio_min\n", + "perm_max = BaselineType.PermShkStd[0] * perm_ratio_max\n", + "\n", + "plt.ylabel('% Change in Consumption')\n", + "plt.xlabel('Std. Dev. of Perm. Income Shock (Baseline = ' + str(round(BaselineType.PermShkStd[0],2)) + ')')\n", + "plt.title('Change in Cons. Following Increase in Perm. Income Uncertainty')\n", + "plt.ylim(-20.,5.)\n", + "plt.hlines(TargetChangeInC,perm_min,perm_max)\n", + "# The expression below shows the power of python\n", + "plotFuncs([calcConsChangeAfterPermShkChange],perm_min,perm_max,N=num_points)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "The figure shows that if people's beliefs about the standard deviation of permanent shocks to their incomes had changed from 0.06 (the default value) to about 0.095, the model would predict an immediate drop in consumption spending of about the magnitude seen in 2008. \n", + "\n", + "The question is whether this is a reasonable or an unreasonable magnitude for a change in uncertainty. Some perspective on that question is offered by the large literature that attempts to estimate the magnitude of persistent or permanent shocks to household income. The answer varies substantially across household types, countries, and time periods, but our sense of the literature is that the whole span of the territory between 0.04 and ranging nearly up to 0.20 is well populated (in the sense that substantial populations of people or countries have been estimated to experience shocks of this magnitude).\n", + "\n", + "So, the degree to which income uncertainty would have had to rise in order to explain the drop in consumption in the Great Recession is quite moderate, compared to the variation that is estimated already to exist across people, places, times, and countries." + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "collapsed", + "formats": "ipynb,py:percent", + "text_representation": { + "extension": ".py", + "format_name": "percent", + "format_version": "1.1", + "jupytext_version": "0.8.3" + } + }, + "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.3" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Documentation/notebooks/Quickstart_tutorial/HARK_diagram.png b/Documentation/notebooks/Quickstart_tutorial/HARK_diagram.png new file mode 100644 index 000000000..404fdbde3 Binary files /dev/null and b/Documentation/notebooks/Quickstart_tutorial/HARK_diagram.png differ diff --git a/Documentation/notebooks/Quickstart_tutorial/Jounery_1_param.py b/Documentation/notebooks/Quickstart_tutorial/Jounery_1_param.py new file mode 100644 index 000000000..cf012e692 --- /dev/null +++ b/Documentation/notebooks/Quickstart_tutorial/Jounery_1_param.py @@ -0,0 +1,158 @@ +''' +Set if parameters for the first journey +''' +from __future__ import division, print_function +from copy import copy +import numpy as np + +# ----------------------------------------------------------------------------- +# --- Define all of the parameters for the perfect foresight model ------------ +# ----------------------------------------------------------------------------- + +CRRA = 2.0 # Coefficient of relative risk aversion +Rfree = 1.03 # Interest factor on assets +DiscFac = 0.96 # Intertemporal discount factor +LivPrb = [1.0] # Survival probability +PermGroFac = [1.0] # Permanent income growth factor +AgentCount = 10000 # Number of agents of this type (only matters for simulation) +aNrmInitMean = 0.0 # Mean of log initial assets (only matters for simulation) +aNrmInitStd = 1.0 # Standard deviation of log initial assets (only for simulation) +pLvlInitMean = 0.0 # Mean of log initial permanent income (only matters for simulation) +pLvlInitStd = 0.0 # Standard deviation of log initial permanent income (only matters for simulation) +PermGroFacAgg = 1.0 # Aggregate permanent income growth factor (only matters for simulation) +T_age = None # Age after which simulated agents are automatically killed +T_cycle = 1 # Number of periods in the cycle for this agent type + +# Make a dictionary to specify a perfect foresight consumer type +init_perfect_foresight = { 'CRRA': CRRA, + 'Rfree': Rfree, + 'DiscFac': DiscFac, + 'LivPrb': LivPrb, + 'PermGroFac': PermGroFac, + 'AgentCount': AgentCount, + 'aNrmInitMean' : aNrmInitMean, + 'aNrmInitStd' : aNrmInitStd, + 'pLvlInitMean' : pLvlInitMean, + 'pLvlInitStd' : pLvlInitStd, + 'PermGroFacAgg' : PermGroFacAgg, + 'T_age' : T_age, + 'T_cycle' : T_cycle + } + +# ----------------------------------------------------------------------------- +# --- Define additional parameters for the idiosyncratic shocks model --------- +# ----------------------------------------------------------------------------- + +# Parameters for constructing the "assets above minimum" grid +aXtraMin = 0.001 # Minimum end-of-period "assets above minimum" value +aXtraMax = 20 # Maximum end-of-period "assets above minimum" value +aXtraExtra = [None] # Some other value of "assets above minimum" to add to the grid, not used +aXtraNestFac = 3 # Exponential nesting factor when constructing "assets above minimum" grid +aXtraCount = 48 # Number of points in the grid of "assets above minimum" + +# Parameters describing the income process +PermShkCount = 7 # Number of points in discrete approximation to permanent income shocks +TranShkCount = 7 # Number of points in discrete approximation to transitory income shocks +PermShkStd = [0.1] # Standard deviation of log permanent income shocks +TranShkStd = [0.2] # Standard deviation of log transitory income shocks +UnempPrb = 0.005 # Probability of unemployment while working +UnempPrbRet = 0.005 # Probability of "unemployment" while retired +IncUnemp = 0.3 # Unemployment benefits replacement rate +IncUnempRet = 0.0 # "Unemployment" benefits when retired +tax_rate = 0.0 # Flat income tax rate +T_retire = 0 # Period of retirement (0 --> no retirement) + +# A few other parameters +BoroCnstArt = 0.0 # Artificial borrowing constraint; imposed minimum level of end-of period assets +CubicBool = True # Use cubic spline interpolation when True, linear interpolation when False +vFuncBool = False # Whether to calculate the value function during solution + +# Make a dictionary to specify an idiosyncratic income shocks consumer +init_idiosyncratic_shocks = { 'CRRA': CRRA, + 'Rfree': Rfree, + 'DiscFac': DiscFac, + 'LivPrb': LivPrb, + 'PermGroFac': PermGroFac, + 'AgentCount': AgentCount, + 'aXtraMin': aXtraMin, + 'aXtraMax': aXtraMax, + 'aXtraNestFac':aXtraNestFac, + 'aXtraCount': aXtraCount, + 'aXtraExtra': [aXtraExtra], + 'PermShkStd': PermShkStd, + 'PermShkCount': PermShkCount, + 'TranShkStd': TranShkStd, + 'TranShkCount': TranShkCount, + 'UnempPrb': UnempPrb, + 'UnempPrbRet': UnempPrbRet, + 'IncUnemp': IncUnemp, + 'IncUnempRet': IncUnempRet, + 'BoroCnstArt': BoroCnstArt, + 'tax_rate':0.0, + 'vFuncBool':vFuncBool, + 'CubicBool':CubicBool, + 'T_retire':T_retire, + 'aNrmInitMean' : aNrmInitMean, + 'aNrmInitStd' : aNrmInitStd, + 'pLvlInitMean' : pLvlInitMean, + 'pLvlInitStd' : pLvlInitStd, + 'PermGroFacAgg' : PermGroFacAgg, + 'T_age' : T_age, + 'T_cycle' : T_cycle + } + +# Make a dictionary to specify a lifecycle consumer with a finite horizon + +# ----------------------------------------------------------------------------- +# ----- Define additional parameters for the aggregate shocks model ----------- +# ----------------------------------------------------------------------------- +MgridBase = np.array([0.1,0.3,0.6,0.8,0.9,0.98,1.0,1.02,1.1,1.2,1.6,2.0,3.0]) # Grid of capital-to-labor-ratios (factors) + +# Parameters for a Cobb-Douglas economy +PermGroFacAgg = 1.00 # Aggregate permanent income growth factor +PermShkAggCount = 1 # Number of points in discrete approximation to aggregate permanent shock dist +TranShkAggCount = 1 # Number of points in discrete approximation to aggregate transitory shock dist +PermShkAggStd = 0.00 # Standard deviation of log aggregate permanent shocks +TranShkAggStd = 0.00 # Standard deviation of log aggregate transitory shocks +DeprFac = 0.025 # Capital depreciation rate +CapShare = 0.36 # Capital's share of income +DiscFacPF = DiscFac # Discount factor of perfect foresight calibration +CRRAPF = CRRA # Coefficient of relative risk aversion of perfect foresight calibration +intercept_prev = 0.0 # Intercept of aggregate savings function +slope_prev = 1.0 # Slope of aggregate savings function +verbose_cobb_douglas = True # Whether to print solution progress to screen while solving +T_discard = 200 # Number of simulated "burn in" periods to discard when updating AFunc +DampingFac = 0.5 # Damping factor when updating AFunc; puts DampingFac weight on old params, rest on new +max_loops = 20 # Maximum number of AFunc updating loops to allow + +# Make a dictionary to specify an aggregate shocks consumer +init_agg_shocks = copy(init_idiosyncratic_shocks) +del init_agg_shocks['Rfree'] # Interest factor is endogenous in agg shocks model +del init_agg_shocks['CubicBool'] # Not supported yet for agg shocks model +del init_agg_shocks['vFuncBool'] # Not supported yet for agg shocks model +init_agg_shocks['PermGroFac'] = [1.0] +init_agg_shocks['MgridBase'] = MgridBase +init_agg_shocks['aXtraCount'] = 24 +init_agg_shocks['aNrmInitStd'] = 0.0 +init_agg_shocks['LivPrb'] = LivPrb + + +# Make a dictionary to specify a Cobb-Douglas economy +init_cobb_douglas = {'PermShkAggCount': PermShkAggCount, + 'TranShkAggCount': TranShkAggCount, + 'PermShkAggStd': PermShkAggStd, + 'TranShkAggStd': TranShkAggStd, + 'DeprFac': DeprFac, + 'CapShare': CapShare, + 'DiscFac': DiscFacPF, + 'CRRA': CRRAPF, + 'PermGroFacAgg': PermGroFacAgg, + 'AggregateL':1.0, + 'act_T':1200, + 'intercept_prev': intercept_prev, + 'slope_prev': slope_prev, + 'verbose': verbose_cobb_douglas, + 'T_discard': T_discard, + 'DampingFac': DampingFac, + 'max_loops': max_loops + } diff --git a/Documentation/notebooks/Quickstart_tutorial/Quick_start_with_solution.ipynb b/Documentation/notebooks/Quickstart_tutorial/Quick_start_with_solution.ipynb new file mode 100644 index 000000000..7fd7c67e2 --- /dev/null +++ b/Documentation/notebooks/Quickstart_tutorial/Quick_start_with_solution.ipynb @@ -0,0 +1,1591 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "solution": "shown" + }, + "source": [ + "Quickstart tutorial\n", + "======\n", + "\n", + "## Summary\n", + "\n", + "This notebook provides the basics of the microeconomic, agent-type class which is fundamental for HARK.\n", + "\n", + "____\n", + "### Structure:\n", + "\n", + "- **Part 1**: basics of the perfect-foresight agent model\n", + "- **Part 2**: more advanced methods for the perfect-foresight agent model\n", + "\n", + "### Learning outcomes:\n", + "- **Part 1**:\n", + " - Learn how to declare basic agent-type objects\n", + " - Learn solution methods for the agent-type objects\n", + " - Plot value function and consumption function\n", + " - Learn how to simulate the agent-type objects\n", + " - Plot value function\n", + "- **Part 2**:\n", + " - Learn how to build life-cycle models\n", + " - Learn more advanced simulation techniques\n", + " - Learn advanced plots\n", + "____\n", + "## Introduction to the consumer problem\n", + "\n", + "HARK AGentType classes were designed to solve the consumer problem. \n", + "\n", + "In the most basic formulation, the consumer problem is given as follows. The consumer lives T+1 periods (T $\\leq \\infty$) and during hers lifetime receive the same income $Y$. In each period t (0$\\leq$ t$\\leq$ T) she can spent it on the consumption $C_t$ or invest $A_t$ with a risk free interest rate R. She maximize the lifetime utility, by solving the following Bellman equation defined on the \"cash in hand\" state space $M_t = C_t +A_t$: \n", + "\n", + "For $t\n", + "\n", + "Obviously, HARK was designed to solve much more complicated consumer problems. However, it was written in the object programming paradigma (OPP). Thus, the class designed to solve such basic problem: $\\texttt{PerfForesightConsumerType}$ is then a foundation (parent/subclass in the OPP language) for the more advanced classes with the heterogeneous agents. In the diagram you can observe the inheritance between some of the HARK Agent-type classes: \n", + "\n", + "\n", + "As you can observe, the $\\texttt{AgentType}$ superclass is the most general; type of framework for the microeconomic models implemented in HARK. The child/subclass of $\\texttt{AgentType}$ is $\\texttt{PerfForesightConsumerType}$, for which you need to define parameters (**attributes** in OPP): $T$, $\\beta$... Next, there are classes with the heterogeneous agents for which you need to *additionally* define parameters of the income process/aggregate shocks, etc.. Moreover, **methods** (thus the way how the object is created, how the solution is presented) of the subclasses are the same or modified methods of the parent class.\n", + "\n", + "Therefore, to master the basics of HARK microclass you firstly need to understand $\\texttt{PerfForesightConsumerType}$ class. Consequently, this tutorial firstly shows how to deal with it, however, the majority of the presented methods are general for the HARK agent-type objects (though it may involve assigning more parameters). In the next notebooks, the class $\\texttt{IndShockConsumerType}$ with idiosyncratic income shocks is presented. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Part I: Basics of the perfect foresight model\n", + "\n", + "In this part, you learn basics of the perfect foresight model. We will solve the example of the consumer problem presented in the introduction. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Getting started\n", + "Firsty, you need to import HARK and a few additional libraries. Importantly, to use \\texttt{PerfForesightConsumerType}$ you also need to import HARK.ConsumptionSaving.ConsIndShockModel sublibrary. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import sys \n", + "import os\n", + "sys.path.insert(0, os.path.abspath('../../../.'))\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import HARK \n", + "\n", + "from copy import deepcopy\n", + "from HARK.ConsumptionSaving.ConsIndShockModel import *\n", + "from HARK.utilities import plotFuncsDer, plotFuncs \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Agent-type object creation \n", + "The most basic way of creating HARK object is to call constructor (in OPP method which create the object, called by the class name). \n", + "\n", + "For $\\texttt{PerfForesightConsumerType}$ we need to set:\n", + "- $T+1$: a consumer's lifespan, called $\\texttt{cycles}$ in the code, if $T= \\infty$, set $\\texttt{cycles}$=0. \n", + "- $R$: risk free intrest rate, called $\\texttt{Rfree}$ in the code.\n", + "- $\\beta$: a discount factor, $\\texttt{DiscFac}$ in the code.\n", + "- $\\rho$: CRRA utility function parameter, $\\texttt{CRRA}$ in the code. \n", + "\n", + "Additionally, you need to define two parameters which does not occur in the presented example, however can be useful:\n", + "\n", + "- Probability of surviving to the next period, called $\\texttt{LivPrb}$ in the code. \n", + "- Income $Y$ growth factor, $\\texttt{PermGroFac}$ in the code.\n", + "\n", + "We call our first HARK object **Example_agent_1** and set the example values of the parameters. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "Example_agent_1 = PerfForesightConsumerType(cycles=0,\n", + "\n", + "CRRA = 2.0, Rfree = 1.03, DiscFac = 0.99,\n", + "\n", + "LivPrb = 1.0,\n", + "\n", + "PermGroFac = 1.0)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Because we did not assume growth in 𝑌 or survival uncertainty , we set these values to 1." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The second method involves creating a **dictionary**: a list of parameters' names and values. Here we define the dictionary with the same values as in the first example. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "First_dictionary = {\n", + " 'CRRA' : 2.0,\n", + " 'DiscFac' : 0.99,\n", + " 'Rfree' : 1.03,\n", + " 'cycles' : 0,\n", + " 'LivPrb' : [1.00],\n", + " 'PermGroFac' : [1.00],\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To create an object with a dictionary, use the constructor with the previously defined dictionary as an argument: \n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "Example_agent_2 = PerfForesightConsumerType(**First_dictionary)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Although the first method is easier, we recommend defining a dictionary whenever you create a HARK object. Firstly, it makes your code cleaner. Secondly, it enables you to create multiple objects with the same dictionary (what will be important when it comes to creating macro classes). \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The presented here methods work also for the more sophisticated HARK object (however you will need to specify more parameters). " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creating an agent-type object by copy\n", + "\n", + "Once creating an agent-type object, you can use its set of parameters to create another. To do so you need to use **deepcopy** method from copy package. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "Example_agent_3 = deepcopy(Example_agent_2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Do not** use an assignment operator (=) because it does not create new object. For example a command: " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "Example_agent_4 = Example_agent_2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "does not create a new object, it only gives a new name to the object Example_agent_2 (this object simply gets two names: Example_agent_2, Example_agent_4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Modifying parameter values \n", + "\n", + "You can easily change the parameter value of the object by \".\" operator. \n", + "\n", + "For example, to change the discount factor value of the object created in the previous subsection:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "Example_agent_3.DiscFac = 0.95" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solving an agent-type problems\n", + "\n", + "To solve agent type problem presented in the example, you need to find a **value function** from the Bellman equations and **the policy functions**. In our case, the only policy function is a consumption function: a function that for each age t and cash-in-hand $M_t$, specify the optimal consumption level: $c_t(M_t)$.\n", + "\n", + "To solve a model in HARK, you need to use $\\texttt{solve}$ method. For example, if we want to solve the model with parameters of the object Example_agent_2: " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "Example_agent_2.solve()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Solution elements\n", + "\n", + "Solve method finds value function and consumption function for each period t of the consumer's life (in case of the infinite T, it specify only one set of functions, because all the parameters are stable and lifespan is always infinite, the functions are the same, no matter of t). Besides consumption and value functions, solve method create also a few attributes, the most important is minimal cash-in-hand value for which the problem has a solution. \n", + "\n", + "The exact name of these attributes in HARK are:\n", + "\n", + "- vFunc: value function\n", + "- cFunc: consumption function\n", + "- mNrmMin: Minimum value of $M_t$ such that cFunc and vFunc are defined.\n", + "\n", + "To get access to the value/consumption function you need to specify the period t and the object name, using two times operator. So to get access to the value function, consumption function and mNrmMin for the solved example:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-33.33330059492335" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Example_agent_2.solution[0].vFunc\n", + "Example_agent_2.solution[0].cFunc\n", + "Example_agent_2.solution[0].mNrmMin\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you can see, only mNrmMin can be printed as a value. However, value and consumption functions can be plotted.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting the solution\n", + "\n", + "After $\\texttt{solve}$ method is used, the value and consumption functions can be plotted. HARK dedicated function for doing so is $\\texttt{plotFuncs}$. As arguments, you need to give a function from the solution (possible a few functions) and the limits of interval for which you want to make a plot. \n", + "\n", + "For example, we can plot consumption and value functions on the interval from mNrmMin to -mNrmMin.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption function\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Value function\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\janro\\Desktop\\HARK\\HARK\\utilities.py:141: RuntimeWarning: divide by zero encountered in reciprocal\n", + " return( c**(1.0 - gam) / (1.0 - gam) )\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "min_v = Example_agent_2.solution[0].mNrmMin\n", + "max_v = -Example_agent_2.solution[0].mNrmMin\n", + "print(\"Consumption function\")\n", + "plotFuncs([Example_agent_2.solution[0].cFunc],min_v,max_v)\n", + "print(\"Value function\")\n", + "plotFuncs([Example_agent_2.solution[0].vFunc],min_v,max_v)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simulation\n", + "\n", + "Next step is to simulate the agent behavior. To do so, you firstly need to set a few parameters for the sake of the simulation:\n", + "\n", + "- $\\texttt{AgentCount}$: number of simulated agents\n", + "- $\\texttt{T_cycle}$: logical parameter which governs the time flow during the simulation (if it is moving forward or backward)\n", + "- $\\texttt{T_sim}$: number of simulation periods\n", + "- $\\texttt{T_age}$: Age after which simulated agents die with certainty\n", + "\n", + "Moreover, HARK enables to simulate the model with the log-normal distributions of the initial assets and incomes. You need to set the parameters:\n", + "\n", + "- $\\texttt{aNrmInitMean}$: Mean of log initial assets\n", + "- $\\texttt{aNrmInitStd}$: Standard deviation of log initial assets\n", + "- $\\texttt{pLvlInitMean}$: Mean of log initial permanent income\n", + "- $\\texttt{pLvlInitStd}$: Standard deviation of log initial permanent income\n", + "\n", + "Lastly, using HARK agent type class, you can also set the aggregate income increase (so the rate of the income increase common to all agents). You set then a parameter:\n", + "\n", + "- $\\texttt{PermGroFacAgg}$: Aggregate permanent income growth factor\n", + "\n", + "In our example, we simulate 1 agent, as it is a representative agent model. Time flow is chronological, there is no initial heterogeneity, thus std of the initial assets and income distributions are set to 0. The initial assets and income are set to 1.0. There is no aggregate income increase, so we set the income growth factor to 1. We simulate 1000 periods and assume infinitely lived agent. \n", + "\n", + "To declare the values of these parameters, we create a new dictionary: " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "Simulation_dictionary = { 'AgentCount': 1,\n", + " 'aNrmInitMean' : 0.0,\n", + " 'aNrmInitStd' : 0.0,\n", + " 'pLvlInitMean' : 0.0,\n", + " 'pLvlInitStd' : 0.0,\n", + " 'PermGroFacAgg' : 1.0,\n", + " 'T_cycle' : 1,\n", + " 'T_sim' : 1000,\n", + " 'T_age' : None \n", + " }\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, you need to update the object. To do so we use **setattr** function, which add parameter's values to the object." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "for key,value in Simulation_dictionary.items():\n", + " setattr(Example_agent_2,key,value)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, you can start our simulation. Firstly, you need to decide which variables you want to track, we choose an assets level and consumption level, in the code they are called: $\\texttt{aNrmNow}$ and $\\texttt{cNrmNow}$. Next, you need to initialize the simulation by $\\texttt{initializeSim}$ method. Lastly, run the simulation by $\\texttt{simulate()}$ method. " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "Example_agent_2.track_vars = ['aNrmNow','cNrmNow']\n", + "Example_agent_2.initializeSim()\n", + "Example_agent_2.simulate()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting the simulation\n", + "\n", + "Plotting the simulation is a little bit more complicated than plotting the solution, as you cannot use a dedicated function. Instead, use **matplot** library. \n", + "\n", + "To see the consumption and asset history, use objects created by simulation, which contains the history of every agent, in each of the simulation periods. They are called the same as the tracked variables with a **\\_hist** ending. Thus the history of assets and consumption are called $\\texttt{aNrmNow_hist}$ and $\\texttt{cNrmNow_hist}$. \n", + "\n", + "Let's make a plot of the assets level and consumption level during the simulated periods. Firstly, define the vectors of mean assets and consumption. Here, there is only one consumer, so we do not need to use a mean function, which we write here. However, if you want to plot the mean asset/consumption level for many agents, you need to use this method. method. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "periods= np.linspace(0,1000,1000)\n", + "asset_level = np.mean(Example_agent_2.aNrmNow_hist[0:1000], axis = 1)\n", + "cons_level = np.mean(Example_agent_2.cNrmNow_hist[0:1000], axis = 1)\n", + "\n", + "plt.figure(figsize=(5,5))\n", + "plt.plot(periods,asset_level,label='Assets level')\n", + "plt.plot(periods,cons_level,label='Consumption level')\n", + "plt.legend(loc=2)\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's plot the mean asset and consumption increase: " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "increase_assets = asset_level[1:1000]/asset_level[0:999] \n", + "increase_cons = cons_level[1:1000]/cons_level[0:999] \n", + "plt.figure(figsize=(5,5))\n", + "plt.plot(periods[1:1000],increase_assets, label='Assets increase' )\n", + "plt.plot(periods[1:1000],increase_cons,label='Consumption increase')\n", + "plt.legend(loc=2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise\n", + "\n", + "Congratulations! You've just learned the basics of the agent-type class in HARK. It is time for some exercises:\n", + "\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 1: create the agent-type object\n", + "\n", + "Define a dictionary and then use it to create the agent-type object with the parameters:\n", + "\n", + "- $\\beta = 0.96$\n", + "- $\\rho = 2.0$\n", + "- $T = \\infty$\n", + "- Risk free interest rate $R= 1.05$\n", + "Assume no survival uncertainty and income growth factor 1.01\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "#Write your solution here\n", + "\n", + "# fill the dictionary and then use it to create the object\n", + "\n", + "#First_dictionary = {\n", + "# 'CRRA' : ,\n", + "# 'DiscFac' : ,\n", + "# 'Rfree' : ,\n", + "# 'cycles' : ,\n", + "# 'LivPrb' : [],\n", + "# 'PermGroFac' : [],\n", + "#}\n", + "#Exercise_agent = " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "solution": "hidden", + "solution_first": true + }, + "source": [ + "**Solution**: click on the box on the left to expand the solution" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "solution": "hidden" + }, + "outputs": [], + "source": [ + "#Solution\n", + "First_dictionary = {\n", + " 'CRRA' : 2.0,\n", + " 'DiscFac' : 0.96,\n", + " 'Rfree' : 1.05,\n", + " 'cycles' : 0,\n", + " 'LivPrb' : [1.0],\n", + " 'PermGroFac' : [1.0],\n", + "}\n", + "Exercise_agent = PerfForesightConsumerType(**First_dictionary)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 2: Solve the model and plot the value function\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "#Write your solution here, use methods from \"solving the model\" subsection" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "solution": "hidden", + "solution_first": true + }, + "source": [ + "**Solution**: click on the box on the left to expand the solution" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "scrolled": true, + "solution": "hidden" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Value function\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Solution\n", + "Exercise_agent.solve()\n", + "\n", + "min_v = Exercise_agent.solution[0].mNrmMin\n", + "max_v = -Exercise_agent.solution[0].mNrmMin\n", + "print(\"Value function\")\n", + "plotFuncs([Exercise_agent.solution[0].vFunc],min_v,max_v)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 3: Prepare the simulation\n", + "\n", + "Next prepare the simulation. Assume that **there exsists the initial assets and income heterogenity**. Assume, the initial income and assets distributions are log-normal, have mean 1 and std =1. Simulate 1000 agents for 1000 periods. \n", + "\n", + "Add the new parameters to the object:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "#Write your solution here. \n", + "\n", + "#Fill the dictionary\n", + "#Simulation_dictionary = { 'AgentCount': ,\n", + "# 'aNrmInitMean' : ,\n", + "# 'aNrmInitStd' : ,\n", + "# 'pLvlInitMean' : ,\n", + "# 'pLvlInitStd' : ,\n", + "# 'PermGroFacAgg' : 1.0, #assume no income aggregate growth\n", + "# 'T_cycle' : 1, #assume forward time flow\n", + "# 'T_sim' : , \n", + "# 'T_age' : None #assume immortal agents \n", + "# }\n", + "\n", + "#for key,value in Simulation_dictionary.items():\n", + "# setattr(Exercise_agent,key,value)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "solution": "hidden", + "solution_first": true + }, + "source": [ + "**Solution**: click on the box on the left to expand the solution" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "solution": "hidden" + }, + "outputs": [], + "source": [ + "#Solution\n", + "Simulation_dictionary = { 'AgentCount': 1000,\n", + " 'aNrmInitMean' : 0.0,\n", + " 'aNrmInitStd' : 1.0,\n", + " 'pLvlInitMean' : 0.0,\n", + " 'pLvlInitStd' : 1.0,\n", + " 'PermGroFacAgg' : 1.0,\n", + " 'T_cycle' : 1,\n", + " 'T_sim' : 1000,\n", + " 'T_age' : None \n", + " }\n", + "\n", + "for key,value in Simulation_dictionary.items():\n", + " setattr(Exercise_agent,key,value)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 4: Simulate \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "#Write your solution here. Use the commands from \"simulation\" subsection, track consumption values\n" + ] + }, + { + "cell_type": "raw", + "metadata": { + "solution": "hidden", + "solution_first": true + }, + "source": [ + "**Solution**: click on the box on the left to expand the solution" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "solution": "hidden" + }, + "outputs": [], + "source": [ + "#Solution\n", + "Exercise_agent.track_vars = ['aNrmNow','cNrmNow']\n", + "Exercise_agent.initializeSim()\n", + "Exercise_agent.simulate()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "solution": "hidden" + }, + "source": [ + "### Exercise 5: Plot the simulations\n", + "\n", + "Plot mean consumption level and consumption increase: " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "#Write your solution here.\n", + "\n", + "#Firstly prepare the vectors which you would like to plot:\n", + "#periods= np.linspace(0,1000,1000)\n", + "#cons_level = np.mean(Exercise_agent.cNrmNow_hist[0:1000], axis = 1)\n", + "#increase_cons = cons_level[1:1000]/cons_level[0:999] \n", + "\n", + "#next plot your solution\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "solution": "hidden", + "solution_first": true + }, + "source": [ + "**Solution**: click on the box on the left to expand the solution" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "solution": "hidden" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAATkAAAE6CAYAAABtdSVfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3deXwV9b3/8dfnZCUbZGdJIOwQtrAWUcIioiIVqaBYr8XaYrXW6u3P9qq9tY/2dtFyb0Vbb9XWit5SpahU64pQFCwgm+xb2AlrFpaEkP3z++MMETEhB0gyZ/k8H4/zOOfMmTPnM0x4P+Y735nviKpijDHByuN2AcYY05ws5IwxQc1CzhgT1CzkjDFBzULOGBPULOSMMUGtxUNORP4sIsdEZFMTLe83IrJZRLaKyNMiIj5+L1dE1opItYhMucB8g0Vko4jsPHf5IpIkIh+KSJ7znOhMnyQiG0RknYisFpGrzlnWEyKyyXnces70sU4tm0TkJREJd6b3EpHlIlIhIg9d6r+RMaHMjT252cB1TbEgERkBXAn0B/oCQ4FR582TJSIf1fP1/cCdwF8b+Zk/AHcD3Z3H2dofBhapandgkfMe5/UAVc0B7gL+5NRxAzAIyAG+AvxQRBJExAO8BExT1b7APmC6s6xi4PvAfzdSozGmAS0ecqq6BO9/3joi0lVE3heRNSKyVER6+bo4IBqIBKKACOCoj3XsVdUNQG1D84hIOyBBVZer96zpl4GbnI8n4Q0nnOebnOWW6udnWMc6NQJkAx+rarWqngbW4w3MZKBCVXc4830I3Ows65iqrgKqfFknY8yX+csxueeB+1V1MPAQ8L++fElVlwOLgcPO4wNV3dqEdXUA8s95n+9MA0hX1cNOHYeBtLMzichkEdkGvIN3bw68oXa9iMSISAowBsgECoEIERnizDfFmW6MaQLhbhcgInHACGDeOYfTopzPvgb8vJ6vHVTVa0WkG9AbyHCmfygiuaq6RETmA53x7uV1FJF1zjxPqeqLvpZXz7RGr4NT1fnAfBHJBf4LGKeqC0RkKLAMKACWA9WqqiIyDXhSRKKABUC1j/UZYxrhesjh3Zs84RzD+gJVfQN44wLfnQysUNVSABF5DxgOLFHVyc60LGC2qo6+hNry+TxAcV4fcl4fFZF2qnrYadYeq6f+JU5TPEVVC1X1l8Avnbr+CuQ58y0HRjrTxwM9LqFWY0w9XG+uquopYI+ITAUQrwE+fn0/MEpEwkUkAm+nQ5M1V51maImIDHd6Vb8BvOl8/BafdxBMPztdRLqd0wM7CO+eZJGIhIlIsjO9P97OkgXO+zTnOQr4D+DZploHY0KeqrboA3gF7/GzKrx7St/C26x8H+9xqy3AYz4uKwx4Dm+wbQF+W888WcBH9Uwf6vz+aaAI2HzOZ+vOeT0E2ATsAn4PiDM9GW9Pap7znORM/w9gM7AOb5P0Kmd6tFPjFmAFkHPOb8x01mE78OA509s6NZ4CTjivE1p6m9nDHoH8OPsf1hhjgpLrzVVjjGlOFnLGmKDWor2rKSkpmpWV1ZI/aYwJAWvWrClU1dT6PmvRkMvKymL16tUt+ZPGmBAgIvsa+syaq8aYoGYhZ4wJahZyxpig5vplXVVVVeTn51NeXu52KSaARUdHk5GRQUREhNulGD/jesjl5+cTHx9PVlYWPo53acwXqCpFRUXk5+fTuXNnt8sxfsb15mp5eTnJyckWcOaSiQjJycnWGjD1cj3kAAs4c9nsb8g0xC9Czm1Hjhxh2rRpdO3alezsbCZMmMCOHTsa/6LL1q1bx7vvvlv3/q233uLxxx9vkmWPGDGiSZZjjNtCPuRUlcmTJzN69Gh27drFli1b+NWvfsXRoz6Nou6q80Puxhtv5OGHH77AN3y3bNmyy15GdbWN/Wnc57chV11bS/HpCiqqa5r1dxYvXkxERAT33HNP3bScnBxGjhyJqvLDH/6Qvn370q9fP+bOnQvARx99xOjRo5kyZQq9evXi9ttv5+xoLg8//DDZ2dn079+fhx7y3mDrzjvv5LXXXqtbflxcXN1yRo0axS233EKPHj14+OGHmTNnDsOGDaNfv37s2rWr7vv33HMPI0eOpEePHrz99ttUVlby2GOPMXfuXHJycpg7dy6zZ8/me9/7HgD79u3j6quvpn///lx99dXs37+/blnf//73GTFiBF26dPlCXec6t8aG1nXVqlWMGDGCAQMGMGzYMEpKSpg9ezZTp07lq1/9KuPHjwdg5syZDB06lP79+/PTn/607jduuukmBg8eTJ8+fXj++ecBqKmp4c4776z7N3/yyScB2LVrF9dddx2DBw9m5MiRbNu27dI2uAk9LTmu0+DBg/V8W7Zs+dI0VdWKqhpdf+C4HjtVXu/nTeWpp57SBx98sN7PXnvtNR03bpxWV1frkSNHNDMzUw8dOqSLFy/WhIQEPXDggNbU1Ojw4cN16dKlWlRUpD169NDa2lpVVT1+/Liqqk6fPl3nzZtXt9zY2FhVVV28eLG2bt1aDx06pOXl5dq+fXt97LHHVFV11qxZ+sADD9R9/9prr9WamhrdsWOHdujQQc+cOaMvvvii3nfffXXLPff9xIkTdfbs2aqq+sILL+ikSZPqljVlyhStqanRzZs3a9euXetd93NrrG9dKyoqtHPnzrpy5UpVVT158qRWVVXpiy++qB06dNCioiJVVf3ggw90xowZWltbqzU1NXrDDTfoxx9/rKpaN09ZWZn26dNHCwsLdfXq1Tpu3Li6Os7+G44dO1Z37NihqqorVqzQMWPGfKnmhv6WTPADVmsDueP6KSTn+tk/NrPl0Km692cqaxCB6IiwS15mdvsEfvrVPpf03U8++YTbbruNsLAw0tPTGTVqFKtWrSIhIYFhw4aRkeEdGT0nJ4e9e/cyfPhwoqOj+fa3v80NN9zAxIkTG/2NoUOH0q5dOwC6du1at/fTr18/Fi9eXDffLbfcgsfjoXv37nTp0qXRPZnly5fzxhvekePvuOMOfvSjH9V9dtNNN+HxeMjOzvapWV7furZu3Zp27doxdOhQABISEurmv+aaa0hKSgJgwYIFLFiwgIEDBwJQWlpKXl4eubm5PP3008yfPx+AAwcOkJeXR8+ePdm9ezf3338/N9xwA+PHj6e0tJRly5YxderUut+oqKhotG5jwA/Ok7uQMI9QVdvgHQObRJ8+fRpssukFBhSNioqqex0WFkZ1dTXh4eGsXLmSRYsW8eqrr/L73/+ef/7zn4SHh1PrrIeqUllZWe9yPB5P3XuPx/OFY1rn9x5ebG/iufOf+5sXWsf65j+7rqraYA2xsbFfWP4jjzzCd77znS/M89FHH7Fw4UKWL19OTEwMo0ePpry8nMTERNavX88HH3zAM888w9/+9jdmzZpFmzZtWLdu3fk/ZUyj/Crkzt/jOllWyb7iMrqmxhEb1Tyljh07lkcffZQ//vGPzJgxA/AeayorKyM3N5fnnnuO6dOnU1xczJIlS5g5c2aDe1GlpaWUlZUxYcIEhg8fTrdu3QDv6Ctr1qzhlltu4c0336Sq6uJvozpv3jymT5/Onj172L17Nz179mTnzp2UlJTUO/+IESN49dVXueOOO5gzZw5XXXXVRf/mhfTq1YtDhw6xatUqhg4dSklJCa1atfrSfNdeey0/+clPuP3224mLi+PgwYNERERw8uRJEhMTiYmJYdu2baxYsQKAwsJCIiMjufnmm+natSt33nknCQkJdO7cmXnz5jF16lRUlQ0bNjBggK+3AjGhzK9C7nxng620orrZQk5EmD9/Pg8++CCPP/440dHRZGVlMWvWLHJzc1m+fDkDBgxARPjNb35D27ZtGwy5kpISJk2aRHl5Oapad9B8xowZTJo0iWHDhnH11Vd/YU/HVz179mTUqFEcPXqUZ599lujoaMaMGcPjjz9OTk4OjzzyyBfmf/rpp7nrrruYOXMmqampvPiir3dh9E1kZCRz587l/vvv58yZM7Rq1YqFCxd+ab7x48ezdetWrrjiCsDbofGXv/yF6667jmeffZb+/fvTs2dPhg8fDsDBgwf55je/Wbfn++tf/xqAOXPmcO+99/KLX/yCqqoqpk2bZiFnfNKi93gYMmSInj+e3NatW+ndu3eD38k7WoLHI3RNjWvu8vzWnXfeycSJE5kyZYrbpfi1xv6WTPASkTWqOqS+z/z2FJKz4qLDKausobbWbrhjjLl4ft1cBYiLCqegpILTldXER4fmCBOzZ892uwRjApbf78nFRIYjCKUVdva8Mebi+UXIXei4YJhHiIkMs5AzF9SSx5ZNYHE95KKjoykqKrrgH2lcdDhnKmuormnec+ZMYFJnPLno6Gi3SzF+yPVjchkZGeTn51NQUNDgPBXVtRSUVFBdFEmryEu/+sEEr7MjAxtzPtdDLiIiotHRXCuraxnwswVMHZLBzyfZKQLGGN+53lz1RWS4h6Gdk1i2q8jtUowxASYgQg7gyq7J7DxWytFTNsS1McZ3PoWciDwgIptEZLOIPHjeZw+JiIpISvOU6HVVd+/il+YVNufPGGOCTKMhJyJ9gRnAMGAAMFFEujufZQLXAPubs0iA3m0TSImLZMmOhjsojDHmfL7syfUGVqhqmapWAx8Dk53PngR+BDT7SUoejzCyeyqf7Cy0S7yMMT7zJeQ2AbkikiwiMcAEIFNEbgQOqur6Zq3wHLk9Uig+XcmmQydb6ieNMQGu0VNIVHWriDwBfAiUAuuBauDHwPjGvi8idwN3A3Ts2PGyih3ZPRWAJTsK6J/R5rKWZYwJDT51PKjqC6o6SFVzgWJgL9AZWC8ie4EMYK2ItK3nu8+r6hBVHZKamnpZxabERdGnfQJLdljngzHGN772rqY5zx2BrwEvq2qaqmapahaQDwxS1SPNVqkjt0cqa/cfp6T84kfXNcaEHl/Pk3tdRLYA/wDuU9XjzVjTBeV2T6W6VlluJwYbY3zg02Vdqjqykc+zmqQaHwzulEhsZBhL8goY3+dLrWNjjPmCgLni4azIcA9XdE2243LGGJ8EXMiB97jc/uIy9haedrsUY4yfC8yQO3sqSZ5d/WCMubCADLmslFg6JsXYJV7GmEYFZMiB9+qHZbuKqKiucbsUY4wfC9iQG90jjbLKGlbtce1sFmNMAAjYkBvRLZnIcA//3HbM7VKMMX4sYEMuJjKcEV2T+ee2o26XYozxYwEbcgBje6Wxt6iM3QWlbpdijPFTAR1yY3qmAViT1RjToIAOucykGHqkx7F4u4WcMaZ+AR1yAGN6pfHp7mIblcQYU6+AD7mxPdOorlU+sRvcGGPqEfAhN7hTIgnR4XZczhhTr4APufAwD6N6prF4e4Hd4MYY8yUBH3IAY3ulUlhawcaDdoMbY8wXBUXIjeqRhkfsVBJjzJcFRcglxUYysGOihZwx5kuCIuQAxvVOZ+PBkxw6ccbtUowxfiRoQm58n3QAFm61a1mNMZ8LmpDrmhpH19RYFmy2kDPGfC5oQg5gfJ+2rNhdxMkyu/rBGOMVXCGXnU51rdq1rMaYOkEVcgMy2pAWH8WCLUfcLsUY4yeCKuQ8HuGa7HQ+2l5AeZXd+8EYE2QhB97jcmWVNSzbZRfsG2OCMOSu6JJMfFS49bIaY4AgDLnIcA+je6WxcOtRauyCfWNCXtCFHHh7WQtLK1l3wG5XaEyoC8qQG90zlYgw4QNrshoT8oIy5OKjI7iyWwrvbjyMqjVZjQllQRlyABP6tSP/+BkbY86YEBe0ITc+O51wj/DOxsNul2KMcVHQhlybmEhGdEvhvY1HrMlqTAgL2pADuKFfW/YXl7H50Cm3SzHGuCSoQ258dlvCrMlqTEgL6pBLjI1kRNdk62U1JoQFdcgB3NCvHfuKrMlqTKgK+pAb38fbZH3XmqzGhKSgD7mk2Eiu6GJNVmNCVdCHHHhPDN5bVMaWw9ZkNSbUhETIXdsnnTCP8PYGa7IaE2pCIuSS46K4qlsKb607ZE1WY0JMSIQcwKSc9hw8cYa1+234JWNCSciE3Pg+bYkK9/DmukNul2KMaUEhE3JxUeGMy07nnQ2HqaqpdbscY0wLCZmQA5g0oD1Fpyv51067yY0xoSKkQm5Uz1QSosN5y5qsxoSMkAq5qPAwJvRrxwebj3Cm0u7LakwoCKmQA7gxpz2nK2tYtM3u/2BMKAi5kPtK52TSE6L4+2fWZDUmFPgUciLygIhsEpHNIvKgM+2/RGSDiKwTkQUi0r55S20aYR7hq/3b8/GOY5woq3S7HGNMM2s05ESkLzADGAYMACaKSHdgpqr2V9Uc4G3gsWattAndNLADVTVql3kZEwJ82ZPrDaxQ1TJVrQY+Biar6rlXu8cCAXO9VJ/2CfRMj+f1tflul2KMaWa+hNwmIFdEkkUkBpgAZAKIyC9F5ABwOw3syYnI3SKyWkRWFxQUNFXdl0VEmDI4g8/2n2BXQanb5RhjmlGjIaeqW4EngA+B94H1QLXz2Y9VNROYA3yvge8/r6pDVHVIampqkxV+uSYNbE+YR3h9je3NGRPMfOp4UNUXVHWQquYCxUDeebP8Fbi5qYtrTmnx0Yzqkcobaw9SUxswLW1jzEXytXc1zXnuCHwNeMXpfDjrRmBb05fXvG4elMGRU+V2mZcxQSzcx/leF5FkoAq4T1WPi8ifRKQnUAvsA+5priKby9W902jdKoLX1+aT28N/mtLGmKbjU8ip6sh6pgVU87Q+0RFh3DigPX9bfYBT5VUkREe4XZIxpomF3BUP57t5cAYV1bW8a+fMGROUQj7kBmS0pltaHK9ZL6sxQSnkQ+7sOXOr9x23c+aMCUIhH3IAXxvUgXCPMHfVAbdLMcY0MQs5vOfMXZOdzmtr8qmotnHmjAkmFnKOacM6Uny6kgWbbZw5Y4KJhZxjZLcUOrRpxSsr97tdijGmCVnIOTwe4bZhmSzbVcTewtNul2OMaSIWcueYOiSTMI/wqnVAGBM0LOTOkZ4Qzdheaby25gCV1XZvVmOCgYXceb4+rCOFpZUs3GodEMYEAwu58+T2SKV962jrgDAmSFjInSfMI9wyNJOleYXsK7IOCGMCnYVcPaYN7Ui4R/jLin1ul2KMuUwWcvVo2zqaa/u2Ze6qA5RVVrtdjjHmMljINWD6FVmcKq/mzXV2E2pjApmFXAOGZiXSu10CLy3bi6rdA8KYQGUh1wARYfoVndh2pISVe4rdLscYc4ks5C5gUk4HWreK4OXl1gFhTKCykLuAVpFh3Do0k/c3H+HwyTNul2OMuQQWco34t690olaVv35qJwcbE4gs5BrRMTmGq3ul8crK/TagpjEByELOB9NHZFFYWslbdjqJMQHHQs4HV3VLoVfbeP60dI+dTmJMgLGQ84GI8O2RXdh+tIQleYVul2OMuQgWcj66cUB70uKj+NPS3W6XYoy5CBZyPooM93DnlVkszStky6FTbpdjjPGRhdxFuH1YJ2Iiw/jTJ7Y3Z0ygsJC7CK1jIrhlSCZvrTvEkZPlbpdjjPGBhdxF+tZVnalVZfayvW6XYozxgYXcRcpMiuH6vu2Y8+k+SitsrDlj/J2F3CWYkduFkvJqXrFLvYzxexZylyAnsw1Xdkvm+aW7Ka+yS72M8WcWcpfovjHdKCipYN5quxG1Mf7MQu4SXdElmUEd2/Dsx7upqrEbURvjryzkLpGI8L2x3Th44gx//+yg2+UYYxpgIXcZxvRMI7tdAn/4aBc1tXbhvjH+yELuMpzdm9tdeJp3Nx52uxxjTD0s5C7TdX3a0jU1lmcW77RhmIzxQxZyl8njEb47uhvbjpTw4ZajbpdjjDmPhVwTmJTTnk7JMTy5MI9aOzZnjF+xkGsC4WEeHhzXna2HT/H+5iNul2OMOYeFXBO5cUAHuqXF8dsPd1hPqzF+xEKuiYR5hAfHdWfnsVL+sd5ueGOMv7CQa0IT+rajV9t4nlqUR7VdBWGMX7CQa0Iej/CDa3qwp/A0b9hVEMb4BQu5JnZNdjr9M1rz1MI8Kqttb84Yt1nINTER4d+v6cHBE2eYu8rGmzPGbRZyzWB0j1SGdU7iqUV5NnqwMS6zkGsGIsKjE3pTWFrJ80vszl7GuMmnkBORB0Rkk4hsFpEHnWkzRWSbiGwQkfki0qZ5Sw0sOZltuKF/O/64ZDfHTtmdvYxxS6MhJyJ9gRnAMGAAMFFEugMfAn1VtT+wA3ikOQsNRD8c35OqmlpmLcpzuxRjQpYve3K9gRWqWqaq1cDHwGRVXeC8B1gBZDRXkYEqKyWWfxveibmrDrDzWInb5RgTknwJuU1Arogki0gMMAHIPG+eu4D3mrq4YHD/2G60igjjife3u12KMSGp0ZBT1a3AE3ibp+8D64G6LkMR+bHzfk593xeRu0VktYisLigoaJKiA0lyXBT3ju7Kh1uOsnJPsdvlGBNyfOp4UNUXVHWQquYCxUAegIhMByYCt2sDI0aq6vOqOkRVh6SmpjZV3QHlris70651ND9/e7NdvG9MC/O1dzXNee4IfA14RUSuA/4DuFFVy5qvxMDXKjKMh6/vxaaDp+wWhsa0MF/Pk3tdRLYA/wDuU9XjwO+BeOBDEVknIs82V5HB4MYB7RmalcjMD7Zz8kyV2+UYEzJ8ba6OVNVsVR2gqoucad1UNVNVc5zHPc1bamATEX761T4Ul1XytJ1SYkyLsSseWlDfDq2ZNjSTl5bttVNKjGkhFnIt7KHxPWkVGcbP/rHF7u5lTAuwkGthyXFRPDiuB0vzCu3uXsa0AAs5F3zjik50T4vjZ//YQlmljVJiTHOykHNBRJiHX07ux8ETZ3hqoXVCGNOcLORcMqxzErcMyeBPn+xh6+FTbpdjTNCykHPRI9f3pnWrCB6dv9FuSm1MM7GQc1FibCSPTujNZ/tP8IoNlW5Ms7CQc9nNgzowvEsST7y3jYKSCrfLMSboWMi5TET4xU39OFNVw8/+sdntcowJOhZyfqBbWhz3j+3O2xsO8/6mI26XY0xQsZDzE/eO7kp2uwT+8++bOH660u1yjAkaFnJ+IiLMw8yp/TlRVsnP397idjnGBA0LOT/Sp31rvjumG/M/O8iirXbJlzFNwULOz3xvTDd6tY3n0fkbbdw5Y5qAhZyfiQz3MHPKAApLK6231ZgmYCHnh/pltOa+Md14Y+1B3tlw2O1yjAloFnJ+6v6x3RiQ2YZH52/k8MkzbpdjTMCykPNTEWEeZt2aQ1VNLQ/NW2/XthpziSzk/FjnlFgem5jNv3YW8ed/7XG7HGMCkoWcn7t1aCbjs9P5zfvb2XLIhmQy5mJZyPk5EeHxm/vTOiaC77/6mY0kbMxFspALAEmxkcy6NYddBaX859832Q1wjLkIFnIB4spuKTxwdXfeWHuQeavz3S7HmIBhIRdA7h/bnSu7JfOTNzex7YgdnzPGFxZyASTMI8y6dSAJrSK4b85aTlfY8TljGmMhF2BS46N4aloOewpP8+P5G+34nDGNsJALQCO6pvDv43rw93WHeGnZXrfLMcavWcgFqPvGdGNc73T+652tLNtV6HY5xvgtC7kA5fEIT946gM4psdw3Zy0HisvcLskYv2QhF8DioyN4/o7BVNcq3/m/NZyprHG7JGP8joVcgOuSGsfT0way9cgp/uP1DdYRYcx5LOSCwJheaTw0vidvrT/E/360y+1yjPEr4W4XYJrGd0d3ZcfREmZ+sJ2MxFZMyungdknG+AULuSAhIvxmSn8Onyjnh/M20L5NK4ZmJbldljGus+ZqEIkKD+O5OwbTIbEVd7+8mr2Fp90uyRjXWcgFmcTYSF68cygiwjdnr7IbVZuQZyEXhLJSYvnjNwZz8MQZvvXSKhuDzoQ0C7kgNbhTEk9Py2HdgRPc+5e1VFbXul2SMa6wkAti1/Vtx68m9+PjHQV2MxwTsqx3NchNG9aR42VVPPH+NtrERPCzG/sgIm6XZUyLsZALAfeM6sLxskqeX7KbNjGR/OCaHm6XZEyLsZALASLCI9f34vjpSp5elEd0hIfvju7mdlnGtAgLuRBx9q5flTW1/Ob97YSJ8J1RXd0uy5hmZyEXQsI8wv9MHUCtwq/f24ZHhBm5Xdwuy5hmZSEXYsLDPDx5ywBqa5VfvrsVEfj2SAs6E7ws5EJQeJiHWdNyqFXlF+9sBSzoTPCy8+RCVESYh6dvG8j1fdvyi3e2MmvhDhuLzgQlC7kQFhHm4Xe3DeTmQRnMWpjHL97ZakFngo41V0NceJiHmVP6Ex8dzguf7KG0vJpffa0fYR47YdgEBws5g8cj/PSr2cRHh/O7f+6ktLKa394ygKjwMLdLM+ay+dRcFZEHRGSTiGwWkQedaVOd97UiMqR5yzTNTUT4f+N78uiEXryz4TDT/7ySk2eq3C7LmMvWaMiJSF9gBjAMGABMFJHuwCbga8CSZq3QtKi7c7vy5K0DWLPvOFP+sIyDJ864XZIxl8WXPbnewApVLVPVauBjYLKqblXV7c1bnnHD5IEZvHTXMI6cKmfyM/9i08GTbpdkzCXzJeQ2AbkikiwiMcAEILN5yzJuG9E1hdfuGUG4R7j1ueUs3n7M7ZKMuSSNhpyqbgWeAD4E3gfWAz4PNSsid4vIahFZXVBQcMmFmpbXs2088++7kk7JsXxr9iqeX7LLTjExAcenjgdVfUFVB6lqLlAM5Pn6A6r6vKoOUdUhqampl1qncUl6QjSv3XsF1/Vty6/e3cYP/rae8qoat8syxme+9q6mOc8d8XY2vNKcRRn/EhMZzjNfH8RD43sw/7OD3PLccg6ftA4JExh8veLhdRHZAvwDuE9Vj4vIZBHJB64A3hGRD5qtSuM6EeF7Y7vzx28MYdexUr76u3+xam+x22UZ0yhpyWMsQ4YM0dWrV7fY75nmseNoCXe/vJoDx8/wo2t7MmNkFzx2hYRxkYisUdV6z9e1a1fNReuRHs9b91/FtX3S+fV725jx8mpOlNn9XY1/spAzlyQhOoJnvj6In93YhyV5Bdzw9Ces3X/c7bKM+RILOXPJRITpI7J4/d4RiMAtzy7nDx/tosZufWj8iIWcuWz9M9rwzvdHMr5POk+8v43bnl/BgeIyt8syBrCQM6ezvOcAAAyjSURBVE2kdStv8/V/pg5gy+FTXP/UUl5bk28nDxvXWciZJiMi3Dw4g/ceGEl2uwQemree785ZS/Fp65Qw7rGQM00uMymGV+4ezsPX92Lh1qOM++3HvLnuoO3VGVdYyJlmEeYR7hnVlbfvH0nHpBgeeHUdd81exSEbusm0MAs506x6to3n9XtH8JOJ2azYXcw1v/2Yl5fvpdZ6YE0LsZAzzS7MI3zrqs4s+PdcBnVK5LE3N/O1PyxjQ/4Jt0szIcBCzrSYzKQYXr5rGE/eOoD842eY9My/eOSNjdYxYZqVhZxpUSLC5IEZLH5oFN+6sjN/W32Asf/zEX9Zsc9OIjbNwkLOuCI+OoL/nJhdd7rJf/59ExN/9wlL82xgVdO0LOSMq3qkxzPn21/hma8PorSiijteWMkdL3zK5kN2XwnTNCzkjOtEhBv6t2PhD0bxk4nZbDx4kom/+4QfzF1H/nG7PMxcHhtPzvidk2eq+MNHu/jzv/YA8PVhHbl3dFfSE6Jdrsz4qwuNJ2chZ/zWoRNneGphHq+tzSfMIxZ2pkEWciag7S8q45nFO3ltbT7hHuHrX+nIPaMs7MznLORMUNhfVMbvF+fx+tqDhIkweWAHZuR2oVtanNulGZdZyJmgsq/oNH9cupt5q/OpqK5lXO907hnVhSFZSW6XZlxiIWeCUlFpBS8t38f/Ld/L8bIqBnVsw7dHduGa7HQiwuzEgVBiIWeC2pnKGuatOcCflu5hf3EZ6QlRfH1YJ24blkmaHbcLCRZyJiTU1CqLtx3j5RX7WLKjgHCPcF3fttwxvBPDOichYrdNDFYXCrnwli7GmOYS5hHGZaczLjudPYWn+cuKfcxbfYC3Nxyme1ocU4dkcNPADqTF295dKLE9ORPUzlTW8Nb6g7y66gCf7T9BmEcY0zOVKYMzGdsrjchwO3YXDKy5agyw81gJ89bk88bagxSUVJAUG8mknPZMyunAgIzW1pwNYBZyxpyjuqaWpXmFzFtzgIVbjlFZU0tmUism9m/PxP7tyG6XYIEXYCzkjGnAyTNVLNh8hLc3HOaTnYXU1CpdUmOZ2L89N/RrR4/0OAu8AGAhZ4wPik9X8t6mw7y9/jAr9hShCh2TYrgmO51xvdMZmpVIuJ1/55cs5Iy5SMdOlfPh1qN8uOUoy3YWUVlTS5uYCMb2TOOa7HRG9kglLspOTvAXFnLGXIbSimqW7ijgwy1H+ef2Y5woqyLcIwzqlEhu9xRye6TSt31rPB5r1rrFQs6YJlJdU8vqfcf5eEcBS3YUsPnQKQASYyK4sps38EZ2T6Fd61YuVxpaLOSMaSaFpRV8klfIkrwCluYVUlBSAXiP5X2lcxJf6ZLMVzonkZHYyjowmpGFnDEtQFXZdqSEf+0sZOWeYlbuLeZEWRUA7VtH1wXekKxEuqTEWfO2CVnIGeOC2lplx7ESPt1dzMo9xXy6p4jCUu89ZuOjw8nJbENOZhsGdmxDTmYiSbGRLlccuCzkjPEDqsruwtOs3XecdQdO8Nn+E2w/WlJ3v9lOyTHkZLahf0YbstslkN0+gdatIlyuOjBYyBnjp8oqq9mYf7Iu9NYdOMGRU+V1n2cktqJP+wSy27X2PrdPoF3raDu+dx4bhcQYPxUTGe49VtcluW5aQUkFmw+dZMvhU2w+dIqth06xYMtRzu6PJMZE0D09nh7pcXRPi6d7Whzd0+NJiYu08KuHhZwxfiY1PorRPdMY3TOtblppRTXbDp9iy+FTbDl0ih1HS3hz3SFKyqvr5mkTE0H3tDi6pXkDsHNKLJ1TYunQplVIX6lhIWdMAIiLCmdIVtIX7mOhqhwrqSDvaCk7jpaQd6yUncdKeHfjYV5ZWVU3X7hHyEyKoVNyDFnJsWQlx5CVEktWciwZicEfgBZyxgQoESE9IZr0hGiu6p5SN11VKSitYG9hGXuLTrO38DT7iryvV+0p5nRlTd284R6hbetoOrRpRYfEVmS0aUV753UH53V0RJgbq9dkLOSMCTIiQlp8NGnx0Qzr/MU7mKkqhaWV7Cs6zR4n/PKPl3HwxBlW7CriyKlyas/ri0yJi3JCL7ouVNMTokiPjya9tfe9P1/H67+VGWOanIiQGh9FanxUvbdwrKqp5cjJcg6eOMPB42e+8LztcAkfbS+g7Jw9wbNiI8NIT4gmLSGqLghT46JIio0kOS6S5NgokuIiSY6NbPE9Qws5Y0ydiDAPmUkxZCbFNDhPaUU1R0+Vc/RUOcdOVTivKzhW4n2/7sAJjpwsp6K6tt7vx0aGkewEYEpcJEmxkSTFRpESF0liTCSJsRHkdk9tsmOFFnLGmIsSFxVOXGocXVPjGpxHVSmtqKaotJKi05UUlVZQfPrs60qKT1dQdLqSQyfK2XjwJMWnK6mq+bydnPfL65usXgs5Y0yTExHioyOIj44gKyW20flVlVPl1Rw/XcnJM1VNenNwCzljjOtEhNatIprlMrbgPkHGGBPyLOSMMUHNQs4YE9Qs5IwxQc2nkBORB0Rkk4hsFpEHnWlJIvKhiOQ5z4nNW6oxxly8RkNORPoCM4BhwABgooh0Bx4GFqlqd2CR894YY/yKL3tyvYEVqlqmqtXAx8BkYBLwkjPPS8BNzVOiMcZcOl9CbhOQKyLJIhIDTAAygXRVPQzgPKddYBnGGOOKRk8GVtWtIvIE8CFQCqwHqi/8rc+JyN3A3QAdO3a8xDKNMebS+NTxoKovqOogVc0FioE84KiItANwno818N3nVXWIqg5JTU1tqrqNMcYnPt3IRkTSVPWYiHQEFgBXAI8CRar6uIg8DCSp6o8aWU4BsO8i6ksBCi9ifn9m6+KfgmVdgmU94NLWpZOq1rsX5WvILQWSgSrgB6q6SESSgb8BHYH9wFRVLb7Iwhr73dUN3YEn0Ni6+KdgWZdgWQ9o+nXx6QJ9VR1Zz7Qi4OqmKsQYY5qDXfFgjAlq/h5yz7tdQBOydfFPwbIuwbIe0MTr4tMxOWOMCVT+vidnjDGXxW9DTkSuE5HtIrLTOUXFb4lIpogsFpGtziAGDzjT6x3EQLyedtZtg4gMcncNvkxEwkTkMxF523nfWUQ+ddZlrohEOtOjnPc7nc+z3Kz7fCLSRkReE5Ftzva5IlC3i4j8u/P3tUlEXhGR6EDZLiLyZxE5JiKbzpl20dtBRKY78+eJyHSfflxV/e4BhAG7gC5AJN6rLLLdrusC9bYDBjmv44EdQDbwG+BhZ/rDwBPO6wnAe4AAw4FP3V6HetbpB8Bfgbed938DpjmvnwXudV5/F3jWeT0NmOt27eetx0vAt53XkUCbQNwuQAdgD9DqnO1xZ6BsFyAXGARsOmfaRW0HIAnY7TwnOq8TG/1ttzdeA/8gVwAfnPP+EeARt+u6iPrfBK4BtgPtnGntgO3O6+eA286Zv24+f3gAGXhHlhkLvO38sRUC4edvH+AD4Arndbgzn7i9Dk49CU4wyHnTA267OCF3wPkPHu5sl2sDabsAWeeF3EVtB+A24Llzpn9hvoYe/tpcPbtBz8p3pvk9p1kwEPiUhgcx8Pf1mwX8CDh748xk4IR6R6GBL9Zbty7O5yed+f1BF6AAeNFpev9JRGIJwO2iqgeB/8Z74v1hvP/OawjM7XLWxW6HS9o+/hpyUs80v+8GFpE44HXgQVU9daFZ65nmF+snIhOBY6q65tzJ9cyqPnzmtnC8TaQ/qOpA4DQXHvfQb9fFOV41CegMtAdigfpuThoI26UxDdV+SevkryGXj3c4p7MygEMu1eITEYnAG3BzVPUNZ3JDgxj48/pdCdwoInuBV/E2WWcBbUTk7BUy59Zbty7O563xDuLgD/KBfFX91Hn/Gt7QC8TtMg7Yo6oFqloFvAGMIDC3y1kXux0uafv4a8itAro7PUeReA+cvuVyTQ0SEQFeALaq6m/P+egt4GwP0HS8x+rOTv+G04s0HDh5drfdbar6iKpmqGoW3n/3f6rq7cBiYIoz2/nrcnYdpzjz+8Ueg6oeAQ6ISE9n0tXAFgJwu+Btpg4XkRjn7+3sugTcdjnHxW6HD4DxIpLo7NmOd6ZdmNsHVC9wkHIC3l7KXcCP3a6nkVqvwrvbvAFY5zwm4D0Gsgjv0FSL8I7UAt7d7mecddsIDHF7HRpYr9F83rvaBVgJ7ATmAVHO9Gjn/U7n8y5u133eOuQAq51t83e8vXIBuV2AnwHb8A5k+39AVKBsF+AVvMcSq/DukX3rUrYDcJezTjuBb/ry23bFgzEmqPlrc9UYY5qEhZwxJqhZyBljgpqFnDEmqFnIGWOCmoWcMSaoWcgZY4KahZwxJqj9f4aUuUlvfT/mAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Solution\n", + "periods= np.linspace(0,1000,1000)\n", + "cons_level = np.mean(Exercise_agent.cNrmNow_hist[0:1000], axis = 1)\n", + "increase_cons = cons_level[1:1000]/cons_level[0:999]\n", + "\n", + "plt.figure(figsize=(5,5))\n", + "plt.plot(periods,cons_level,label='Consumption level')\n", + "plt.legend(loc=2)\n", + "plt.show()\n", + "\n", + "plt.figure(figsize=(5,5))\n", + "plt.plot(periods[1:1000],increase_cons,label='Consumption increase')\n", + "plt.legend(loc=2)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# PART II: advanced methods for the perfect foresight agent\n", + "\n", + "# PART II: advanced methods for the perfect foresight agent\n", + "\n", + "In this part we focus on more complicated cases of the deterministic agent model.\n", + "\n", + "In the previous example survival probability (in the code **LivPrb**) and income increase factor (in the code **PermGroFac**) were stable and set to 1. However, if you want to build deterministic life-cycle model you need to add a age-dependent survival probability or income growth. Consumer problem in this setting is:\n", + "\\begin{eqnarray*}\n", + "V_t(M_t,Y_t) &=& \\max_{C_t}~U(C_t) + \\beta \\pi_t V_{t+1}(M_{t+1},Y_{t+1}), \\\\\n", + "& s.t. & \\\\\n", + "%A_t &=& M_t - C_t, \\\\\n", + "M_{t+1} &=& R (M_{t}-C_{t}) + Y_{t+1}, \\\\\n", + "Y_{t+1} &=& \\Gamma_{t+1} Y_t, \\\\\n", + "\\end{eqnarray*}\n", + "\n", + "Where $Y_t$ is an age-dependent income, $\\pi_t$ is a survival probability and $\\Gamma_{t+1}$ is an income growth rate. Also $\\pi_{T+1} =0$ \n", + "\n", + "While it does not reduce the computational complexity of the problem (as permanent income is deterministic, given its initial condition $Y_0$), HARK represents this problem with normalized variables (represented in lower case), dividing all real variables by permanent income $Y_t$ and utility levels by $Y_t^{1-\\rho}$. The Bellman form of the model thus reduces to:\n", + "\n", + "\\begin{eqnarray*}\n", + "v_t(m_t) &=& \\max_{c_t}~U(c_t) ~+ \\beta_{t+1}\\pi_{t+1} \\Gamma_{t+1}^{1-\\rho} v_{t+1}(m_{t+1}), \\\\\n", + "& s.t. & \\\\\n", + "a_t &=& m_t - c_t, \\\\\n", + "m_{t+1} &=& R / \\Gamma_{t+1} a_t + 1.\n", + "\\end{eqnarray*}\n", + "\n", + "To solve this problem we need to study **cycles** parameter more carefully.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cycles and time-dependent parameters \n", + "\n", + "$\\texttt{cycles}$ parameter has more general usage than it was presented in the previous example. In general it tells HARK **how many times the one period consumer's problem need to be solved with the given set of time-changing paramters**. In our microeconomic case these parameters are $\\texttt{LivPrb}$ and $\\texttt{PermGroFac}$, as the discount factor, the CRRA parameter and risk free interest rate are assumed to be stable. \n", + "\n", + "For the life cycle model, **the survival probabilities and income growth rates are different in each period** and consumer **never faces the same parameter's combination**. Thus in the HARK implementation, you need to set cycles = 1. To set the length of the lifespan, you simply need to specify the survival probabilities and the income growth vectors, with T+1 non-zero values. \n", + "\n", + "For example, we create an agent-type object with with maximal lifespan set to 11, and decreasing survival probability and inverse u-shaped income dynamics up to period 6 (then consumer retired and obtain )" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "LifeCycle_dictionary = {\n", + " 'CRRA' : 2.0,\n", + " 'Rfree' : 1.04,\n", + " 'DiscFac' : 0.98,\n", + " 'LivPrb' : [0.99,0.98,0.97,0.96,0.95,0.94,0.93,0.92,0.91,0.90],\n", + " 'PermGroFac' : [1.01,1.01,1.01,1.02,1.00,0.99,0.5,1.0,1.0,1.0],\n", + " 'cycles' : 1,\n", + "}\n", + "\n", + "LC_agent = PerfForesightConsumerType(**LifeCycle_dictionary)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Understanding the solution \n", + "\n", + "As it was mentioned in the first part of the tutorial, solve method finds value and consumption function. In case of $\\Gamma_t \\neq 1.0$, these functions are defined on the **normalized by $Y_t$** space of the cash-in hands arguments. It is important to remember that, when you will plot them. \n", + "\n", + "Nevertheless, as in the first part, to solve the model, we use the $\\texttt{solve()}$ method. " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "LC_agent.solve()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Quick exercise\n", + "\n", + "Consider the case, when consumer lives with certainty 40 periods. However, her income perform cycles. During each cycles she experience two periods of the income increase and two of the decrease.\n", + "Create HARK agent-type object with the described above income cycles. Solve the model. \n", + "\n", + "Assume that for each cycle the income growth factors are: [1.05,1.1, 0.95, 0.92]. Assume, that survival probability is 1 and the rest of the parameters is the same as in the previous example. \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "#Write your solution here" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "solution": "hidden", + "solution_first": true + }, + "source": [ + "**Solution**: click on the box on the left to expand the solution" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "solution": "hidden" + }, + "outputs": [], + "source": [ + "#Solution\n", + "Cyc_dictionary = {\n", + " 'CRRA' : 2.0,\n", + " 'Rfree' : 1.03,\n", + " 'DiscFac' : 0.96,\n", + " 'LivPrb' : [1.05,1.1, 0.95, 0.92],\n", + " 'PermGroFac' : 4*[1.0],\n", + " 'cycles' : 4,\n", + "}\n", + "\n", + "Cyc_agent = PerfForesightConsumerType(**Cyc_dictionary)\n", + "Cyc_agent.solve()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Methods of plotting the solution\n", + "\n", + "$\\texttt{plotFuncs()}$ enables to plot many functions at the same graph. You need to declare them as vector of functions. \n", + "\n", + "To see this, just follow an example. We plot the consumption functions for each age $t$ of the consumer. \n", + "\n", + "To get better access to the consumption functions, you can use $\\texttt{unpackcFunc()}$ method, which will create the attribute $\\texttt{cFunc}$ of the object (so you do not have to use is as a solution attribute).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "LC_agent.unpackcFunc()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we set the minimal value of the gird such that at least one of the consumption functions is defined.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption functions\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "min_v = min(LC_agent.solution[t].mNrmMin for t in range(11) )\n", + "max_v = -min_v\n", + "print(\"Consumption functions\")\n", + "plotFuncs(LC_agent.cFunc[:],min_v,max_v)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you want to compare a few functions (eg. value functions), you can also construct the vector by yourself, for example:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Value functions\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Value functions\")\n", + "plotFuncs([LC_agent.solution[0].vFunc, LC_agent.solution[5].vFunc, LC_agent.solution[9].vFunc],min_v,max_v)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Advanced simulation techniques\n", + "Here we present more advanced simulation techniques with the mortal agents and income dynamics. \n", + "\n", + "We will also present how to plot assets distribution of agents. \n", + "\n", + "Firstly, as in the part 1 of the tutorial, you need to define simulation dictionary. However, you need to be careful with T_age parameter: because a maximal lifespan is 11 (T=10), T_age is set to 10, to ensure that all agents die after this age. \n", + "\n", + "For the rest of the parameters, we set number consumers alive in each period to 1000. Initial asset level is near 0 (log of -10). The initial income level is given by log-normal distribution with mean 0 and std 1. We set the rest of parameters as in the previous example. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "Simulation_dictionary = { 'AgentCount': 1000,\n", + " 'aNrmInitMean' : -10.0,\n", + " 'aNrmInitStd' : 0.0,\n", + " 'pLvlInitMean' : 0.0,\n", + " 'pLvlInitStd' : 1.0,\n", + " 'PermGroFacAgg' : 1.0,\n", + " 'T_cycle' : 1,\n", + " 'T_sim' : 200,\n", + " 'T_age' : 10 \n", + " }\n", + "\n", + "for key,value in Simulation_dictionary.items():\n", + " setattr(LC_agent,key,value)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we simulate the economy and plot the mean asset level. However, be careful! $\\texttt{aNrmNow}$ gives the asset levels normalized by the income. To get the original asset level we need to use $\\texttt{aLvlNow}$ (unfortunately, cLvlNow is not implemented). " + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "LC_agent.track_vars = ['aNrmNow','cNrmNow', 'aLvlNow']\n", + "LC_agent.initializeSim()\n", + "LC_agent.simulate()\n", + "\n", + " \n", + "periods= np.linspace(0,200,200)\n", + "assets_level = np.mean(LC_agent.aLvlNow_hist[0:200], axis = 1)\n", + "\n", + "plt.figure(figsize=(5,5))\n", + "plt.plot(periods,assets_level,label='assets level')\n", + "plt.legend(loc=2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you can see, for the first 10 periods the asset level much more fluctuate. It is because in the first periods the agents which were born in period 0 strictly dominate the population (as only a small fraction die in the first periods of life). \n", + "\n", + "You can simply cut the first observations, to get asset levels for more balanced population. " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "after_burnout = np.mean(LC_agent.aLvlNow_hist[10:200], axis = 1)\n", + "\n", + "plt.figure(figsize=(5,5))\n", + "plt.plot(periods[10:200],after_burnout,label='assets level')\n", + "plt.legend(loc=2)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting the distribution of assets\n", + "\n", + "When you plot similar simulations, often the main interest is not to get exact assets/consumption levels during the simulation but rather a general distribution of assets. \n", + "\n", + "In our case, we plot the asset distribution. \n", + "\n", + "Firstly, get one vector of the asset levels: \n" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "sim_wealth = np.reshape(LC_agent.aLvlNow_hist,-1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we plot simple histogram of assets level using a standard **hist** function from matplotlib library" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wealth distribution histogram\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAARbUlEQVR4nO3df5BdZ13H8ffHtID8EApZEJuWFI1YfrawE8A6UARKoNjgiEPCDwuWyQzTAqKjk+pMy5R/gjgqDhWIJRYUWrGARAm05Zd1LMVsoUJbKMRQ6BI0C+E3DDXl6x/3BC/b3exJ9u7e5Mn7NXNnz3me55z7PZPkc5+cPefcVBWSpHb9zLgLkCQtLYNekhpn0EtS4wx6SWqcQS9JjTtu3AXMZeXKlbV69epxlyFJR40bb7zx61U1MVffERn0q1evZmpqatxlSNJRI8mX5+vz1I0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXuiLwzdjFWb/7AT5Zv33L2GCuRpCODM3pJalxzM/phzu4lyRm9JDXPoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEL3jCVZBvwXGBvVT16jv4/BF40tL9TgYmq2pfkduC7wF3A/qqaHFXhkqR++szoLwfWzddZVW+oqtOq6jTgQuBfq2rf0JCndf2GvCSNwYJBX1XXAfsWGtfZCFyxqIokSSM1snP0Se7NYOb/nqHmAq5JcmOSTQtsvynJVJKpmZmZUZUlSce8Uf4y9jeAf5912uaMqno88Gzg/CRPmW/jqtpaVZNVNTkxMTHCsiTp2DbKoN/ArNM2VbWn+7kXeB+wdoTvJ0nqYSRBn+T+wFOB9w+13SfJ/Q4sA2cBN4/i/SRJ/fW5vPIK4ExgZZJp4GLgeICqeks37DeBa6rq+0ObPgR4X5ID7/OuqvrQ6EqXJPWxYNBX1cYeYy5ncBnmcNtu4HGHW5gkaTS8M1aSGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMWDPok25LsTTLnF3snOTPJt5Pc1L0uGupbl+S2JLuSbB5l4ZKkfvrM6C8H1i0w5t+q6rTudQlAkhXApcCzgUcCG5M8cjHFSpIO3YJBX1XXAfsOY99rgV1Vtbuq7gSuBNYfxn4kSYswqnP0T07yn0k+mORRXduJwB1DY6a7NknSMjpuBPv4FPCwqvpekucA/wSsATLH2JpvJ0k2AZsATj755BGUJUmCEczoq+o7VfW9bnkHcHySlQxm8CcNDV0F7DnIfrZW1WRVTU5MTCy2LElSZ9FBn+Tnk6RbXtvt8xvATmBNklOS3APYAGxf7PtJkg7NgqduklwBnAmsTDINXAwcD1BVbwGeD7wiyX7gh8CGqipgf5ILgKuBFcC2qrplSY5CkjSvBYO+qjYu0P8m4E3z9O0AdhxeaZKkUfDOWElqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekho3iu+MPSqs3vyBnyzfvuXsMVYiScvLGb0kNc6gl6TGGfSS1LgFgz7JtiR7k9w8T/+Lknyme12f5HFDfbcn+WySm5JMjbJwSVI/fWb0lwPrDtL/JeCpVfVY4HXA1ln9T6uq06pq8vBKlCQtxoJX3VTVdUlWH6T/+qHVG4BViy9LkjQqoz5Hfx7wwaH1Aq5JcmOSTQfbMMmmJFNJpmZmZkZcliQdu0Z2HX2SpzEI+l8baj6jqvYkeTBwbZLPV9V1c21fVVvpTvtMTk7WqOqSpGPdSGb0SR4LXAasr6pvHGivqj3dz73A+4C1o3g/SVJ/iw76JCcD7wVeUlVfGGq/T5L7HVgGzgLmvHJHkrR0Fjx1k+QK4ExgZZJp4GLgeICqegtwEfAg4K+TAOzvrrB5CPC+ru044F1V9aElOAZJ0kH0uepm4wL9LwdePkf7buBxd99CkrScvDNWkhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJalyvoE+yLcneJDfP058kf5VkV5LPJHn8UN+5Sb7Yvc4dVeGSpH76zugvB9YdpP/ZwJrutQl4M0CSBwIXA08E1gIXJznhcIuVJB26XkFfVdcB+w4yZD3wjhq4AXhAkocCzwKurap9VfVN4FoO/oEhSRqxUZ2jPxG4Y2h9umubr/1ukmxKMpVkamZmZkRlSZJGFfSZo60O0n73xqqtVTVZVZMTExMjKkuSNKqgnwZOGlpfBew5SLskaZmMKui3A7/TXX3zJODbVfU14GrgrCQndL+EPatrkyQtk+P6DEpyBXAmsDLJNIMraY4HqKq3ADuA5wC7gB8AL+v69iV5HbCz29UlVXWwX+pKkkasV9BX1cYF+gs4f56+bcC2Qy9t6aze/IGfLN++5ewxViJJS887YyWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNa5X0CdZl+S2JLuSbJ6j/y+S3NS9vpDkW0N9dw31bR9l8ZKkhS34nbFJVgCXAs8EpoGdSbZX1a0HxlTVa4bGvxI4fWgXP6yq00ZXsiTpUPSZ0a8FdlXV7qq6E7gSWH+Q8RuBK0ZRnCRp8foE/YnAHUPr013b3SR5GHAK8NGh5nslmUpyQ5LnzfcmSTZ146ZmZmZ6lCVJ6qNP0GeOtppn7Abgqqq6a6jt5KqaBF4I/GWSX5xrw6raWlWTVTU5MTHRoyxJUh99gn4aOGlofRWwZ56xG5h12qaq9nQ/dwMf56fP30uSllifoN8JrElySpJ7MAjzu109k+QRwAnAJ4baTkhyz255JXAGcOvsbSVJS2fBq26qan+SC4CrgRXAtqq6JcklwFRVHQj9jcCVVTV8WudU4K1JfszgQ2XL8NU6R4LVmz/wk+Xbt5w9xkokaWksGPQAVbUD2DGr7aJZ66+dY7vrgccsoj5J0iJ5Z6wkNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1rtc3TB0r/FpBSS1yRi9JjesV9EnWJbktya4km+fof2mSmSQ3da+XD/Wdm+SL3evcURYvSVrYgqdukqwALgWeCUwDO5Nsr6pbZw39h6q6YNa2DwQuBiaBAm7stv3mSKqXJC2oz4x+LbCrqnZX1Z3AlcD6nvt/FnBtVe3rwv1aYN3hlSpJOhx9gv5E4I6h9emubbbfSvKZJFclOekQtyXJpiRTSaZmZmZ6lCVJ6qNP0GeOtpq1/s/A6qp6LPBh4O2HsO2gsWprVU1W1eTExESPsiRJffQJ+mngpKH1VcCe4QFV9Y2q+lG3+jfAE/puK0laWn2CfiewJskpSe4BbAC2Dw9I8tCh1XOAz3XLVwNnJTkhyQnAWV2bJGmZLHjVTVXtT3IBg4BeAWyrqluSXAJMVdV24FVJzgH2A/uAl3bb7kvyOgYfFgCXVNW+JTgOSdI8et0ZW1U7gB2z2i4aWr4QuHCebbcB2xZRoyRpEbwzVpIaZ9BLUuN8qNk8fMCZpFY4o5ekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMZ5Z2wP3iUr6WjmjF6SGmfQS1LjDHpJapxBL0mNM+glqXG9rrpJsg54I4PvjL2sqrbM6v994OUMvjN2Bvjdqvpy13cX8Nlu6Feq6pwR1T4WXoEj6WizYNAnWQFcCjwTmAZ2JtleVbcODfs0MFlVP0jyCuBPgRd0fT+sqtNGXLckqac+p27WAruqandV3QlcCawfHlBVH6uqH3SrNwCrRlumJOlw9Qn6E4E7htanu7b5nAd8cGj9XkmmktyQ5HnzbZRkUzduamZmpkdZkqQ++pyjzxxtNefA5MXAJPDUoeaTq2pPkocDH03y2ar6r7vtsGorsBVgcnJyzv1Lkg5dnxn9NHDS0PoqYM/sQUmeAfwJcE5V/ehAe1Xt6X7uBj4OnL6IeiVJh6jPjH4nsCbJKcBXgQ3AC4cHJDkdeCuwrqr2DrWfAPygqn6UZCVwBoNf1DbBK3AkHQ0WDPqq2p/kAuBqBpdXbquqW5JcAkxV1XbgDcB9gX9MAv9/GeWpwFuT/JjB/x62zLpaR5K0xHpdR19VO4Ads9ouGlp+xjzbXQ88ZjEFSpIWxztjJalxPo9+RDxfL+lI5Yxekhpn0EtS4zx1swQ8jSPpSOKMXpIaZ9BLUuM8dbPEPI0jadyc0UtS45zRLyNn95LGwRm9JDXOGf2YOLuXtFyc0UtS45zRHwGc3UtaSgb9EWY49MHgl7R4Bv0Rztm+pMUy6I8ihr6kw2HQH6Vmn+I5wA8ASbMZ9I3xA0DSbL2CPsk64I0Mvhz8sqraMqv/nsA7gCcA3wBeUFW3d30XAucBdwGvqqqrR1a9epvvA2A+fjBI7Vgw6JOsAC4FnglMAzuTbK+qW4eGnQd8s6p+KckG4PXAC5I8EtgAPAr4BeDDSX65qu4a9YFotA71g2GYHxLSkaXPjH4tsKuqdgMkuRJYDwwH/Xrgtd3yVcCbkqRrv7KqfgR8Kcmubn+fGE35OhIt5kPiaOIHmo4WfYL+ROCOofVp4Inzjamq/Um+DTyoa79h1rYnzvUmSTYBm7rV7yW5rUdtc1kJfP0wtz1aecxjkNcv69uN/XjHwGM+NA+br6NP0GeOtuo5ps+2g8aqrcDWHvUcVJKpqppc7H6OJh5z+4614wWPeZT6POtmGjhpaH0VsGe+MUmOA+4P7Ou5rSRpCfUJ+p3AmiSnJLkHg1+ubp81Zjtwbrf8fOCjVVVd+4Yk90xyCrAG+I/RlC5J6mPBUzfdOfcLgKsZXF65rapuSXIJMFVV24G3AX/X/bJ1H4MPA7px72bwi9v9wPnLcMXNok//HIU85vYda8cLHvPIZDDxliS1yufRS1LjDHpJalwzQZ9kXZLbkuxKsnnc9Sy1JCcl+ViSzyW5Jcmrx13TckmyIsmnk/zLuGtZDkkekOSqJJ/v/ryfPO6allqS13R/r29OckWSe427plFLsi3J3iQ3D7U9MMm1Sb7Y/TxhFO/VRNAPPabh2cAjgY3d4xdath/4g6o6FXgScP4xcMwHvBr43LiLWEZvBD5UVb8CPI7Gjz3JicCrgMmqejSDi0A2jLeqJXE5sG5W22bgI1W1BvhIt75oTQQ9Q49pqKo7gQOPaWhWVX2tqj7VLX+XwT/+Oe86bkmSVcDZwGXjrmU5JPk54CkMrmyjqu6sqm+Nt6plcRzws919Ofemwftvquo6BlcpDlsPvL1bfjvwvFG8VytBP9djGpoPvQOSrAZOBz453kqWxV8CfwT8eNyFLJOHAzPA33anqy5Lcp9xF7WUquqrwJ8BXwG+Bny7qq4Zb1XL5iFV9TUYTOaAB49ip60Efe9HLbQmyX2B9wC/V1XfGXc9SynJc4G9VXXjuGtZRscBjwfeXFWnA99nRP+dP1J156XXA6cweOrtfZK8eLxVHd1aCfpj8lELSY5nEPLvrKr3jrueZXAGcE6S2xmcnvv1JH8/3pKW3DQwXVUH/rd2FYPgb9kzgC9V1UxV/S/wXuBXx1zTcvmfJA8F6H7uHcVOWwn6Po9paEr3GOi3AZ+rqj8fdz3LoaourKpVVbWawZ/xR6uq6ZleVf03cEeSR3RNT+enHxHeoq8AT0py7+7v+dNp/BfQQ4YfJ3Mu8P5R7LSJrxKc7zENYy5rqZ0BvAT4bJKburY/rqodY6xJS+OVwDu7Scxu4GVjrmdJVdUnk1wFfIrB1WWfpsHHISS5AjgTWJlkGrgY2AK8O8l5DD7wfnsk7+UjECSpba2cupEkzcOgl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY37P0GtEUbzUk+vAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Wealth distribution histogram\")\n", + "n, bins, patches = plt.hist(sim_wealth,100,density=True, range=[0.0,10.0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With HARK, you can also easily plot the Lorenz curve. To do so import some HARK utilities which help us plot Lorenz curve:" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "from HARK.utilities import getLorenzShares, getPercentiles\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, use $\\texttt{getLorenzShares}$ to plot the Lornez curve. " + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pctiles = np.linspace(0.001,0.999,15)\n", + "#SCF_Lorenz_points = getLorenzShares(SCF_wealth,weights=SCF_weights,percentiles=pctiles)\n", + "sim_Lorenz_points = getLorenzShares(sim_wealth,percentiles=pctiles)\n", + "\n", + "plt.figure(figsize=(5,5))\n", + "plt.title('Lorenz curve')\n", + "plt.plot(pctiles,sim_Lorenz_points,'-b',label='Lorenz curve')\n", + "plt.plot(pctiles,pctiles,'g-.',label='45 Degree')\n", + "plt.xlabel('Percentile of net worth')\n", + "plt.ylabel('Cumulative share of wealth')\n", + "plt.legend(loc=2)\n", + "plt.ylim([0,1])\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise \n", + "\n", + "Let's make a model with a little more realistic assumptions. \n", + "\n", + "In files 'life_table.csv' you find the death-probablities for Americans in age 25-105 in 2017 from Human Mortality Database. The age-dependent income for American males in file 'productivity_profile.csv' are deduced from Heathcote et al. (2010). Try to build a model with this data, assuming additionaly CRRA parameter to be 2.0, discount rate set to 0.99 and interest rate set to 1.05. Moreover, assume that initial income is given by log-normal distribution with mean 0 and std 0.05. Assume that initial asset is near 0 for all agents.\n", + "\n", + "Do the following tasks:\n", + "- Build a dictionary and create an object with a given data and parameters\n", + "- Solve model and plot a consumption functions for each age\n", + "- Simulate 1000 agents for 2000 periods\n", + "- Plot a histogram of the assets distribution and the Lorenz curve" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "solution": "hidden" + }, + "outputs": [], + "source": [ + "# Write your solution here \n", + "\n", + "#Firstly import data, you can use this part of code (however, there are other ways to do this)\n", + "import sys \n", + "import os\n", + "\n", + "sys.path.insert(0, os.path.abspath('..'))\n", + "\n", + "\n", + "prob_dead = np.genfromtxt('life_table.csv', delimiter=',', skip_header =1)\n", + "prob_surv = 1 - prob_dead\n", + "\n", + "# The HARK argument need to be a list, thus convert it from numpy array\n", + "prob_surv_list= np.ndarray.tolist(prob_surv[:80])\n", + "\n", + "income_profile = np.genfromtxt('productivity_profile.csv', delimiter=',', skip_header =1)\n", + "income_profile_list=np.ndarray.tolist(income_profile[:80])\n", + "\n", + "#Continue your solution\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "solution": "hidden", + "solution_first": true + }, + "source": [ + "**Solution**: click on the box on the left to expand the solution" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "solution": "hidden" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption functions\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wealth distribution histogram\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAAD5CAYAAAAOXX+6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAANX0lEQVR4nO3df6xk5V3H8c/HXSi2xdKy0xYL9LpJg78SC7nBtpimQmsQGtBYE5qoxWBuiKmhiYlZ06SJ/iP1j6Y1/spKUYxIsRQUobSisCFNZNu72+XHstACWdN1V3aokbKagNCPf8y56+XuzM65e+fMfO+971cyuWfmPDP7febc+9lnnnnOjJMIAFDXD8y6AADAyRHUAFAcQQ0AxRHUAFAcQQ0AxRHUAFDc1nENbF8g6fZlN22X9Kkknx11n23btmVubm7t1QHAJrFnz57nk/SG7Rsb1EmekvRuSbK9RdK/S7rrZPeZm5vT4uLiKZQKAJuT7X8btW+1Ux+XSXomycgHBABM1mqD+hpJtw3bYXvB9qLtxX6/v/bKAACSVhHUtk+XdJWkLw7bn2Rnkvkk873e0GkWAMApWM2I+ucl7U3yXFfFAABOtJqg/qhGTHsAALrTKqhtv17ShyTd2W05AICVxi7Pk6Qk/yPp7I5rAQAMwZmJAFAcQQ0AxbWa+gAkaW7HvUNvP3jjlVOuBNhcGFEDQHEENQAUR1ADQHEENQAUR1ADQHEENQAUR1ADQHEENQAUR1ADQHEENQAUR1ADQHEENQAUR1ADQHEENQAUR1ADQHEENQAUR1ADQHEENQAUR1ADQHGtgtr2WbbvsP2k7QO239t1YQCAgbZfbvs5SV9J8hHbp0t6fYc1AQCWGRvUtn9I0vslXStJSV6W9HK3ZQEAlrSZ+tguqS/pL21/0/ZNtt+wspHtBduLthf7/f7ECwWAzapNUG+VdJGkP0tyoaT/lrRjZaMkO5PMJ5nv9XoTLhMANq82QX1I0qEku5vrd2gQ3ACAKRgb1En+Q9J3bF/Q3HSZpCc6rQoAcFzbVR+/JenWZsXHs5J+vbuSAADLtQrqJPskzXdcCwBgCM5MBIDiCGoAKI6gBoDiCGoAKI6gBoDiCGoAKI6gBoDiCGoAKI6gBoDiCGoAKI6gBoDiCGoAKI6gBoDiCGoAKI6gBoDiCGoAKI6gBoDiCGoAKI6gBoDiCGoAKI6gBoDiWn0Lue2Dkl6U9KqkV5LwjeQAMCWtgrrxs0me76wSAMBQTH0AQHFtgzqS/sn2HtsLXRYEAHittlMflyQ5bPutku63/WSSh5Y3aAJ8QZLOP//8CZcJAJtXqxF1ksPNz6OS7pJ08ZA2O5PMJ5nv9XqTrRIANrGxQW37DbbPXNqW9HOSHu+6MADAQJupj7dJusv2Uvu/TfKVTqsCABw3NqiTPCvpp6ZQCwBgCJbnAUBxBDUAFEdQA0BxBDUAFEdQA0BxBDUAFEdQA0BxBDUAFEdQA0BxBDUAFEdQA0BxBDUAFEdQA0BxBDUAFEdQA0BxBDUAFEdQA0BxBDUAFEdQA0BxBDUAFEdQA0BxBDUAFNc6qG1vsf1N2/d0WRAA4LVWM6K+QdKBrgoBAAzXKqhtnyvpSkk3dVsOAGCltiPqz0r6HUnfH9XA9oLtRduL/X5/IsUBAFoEte0PSzqaZM/J2iXZmWQ+yXyv15tYgQCw2bUZUV8i6SrbByV9QdKltv+m06oAAMeNDeokv5vk3CRzkq6R9ECSX+m8MgCAJNZRA0B5W1fTOMkuSbs6qQQAMBQjagAojqAGgOJWNfUBDDO3496htx+88copVwJsTIyoAaA4ghoAiiOoAaA4ghoAiiOoAaA4ghoAiiOoAaA4ghoAiiOoAaA4ghoAiiOoAaA4ghoAiiOoAaA4ghoAiiOoAaA4ghoAiiOoAaA4ghoAiiOoAaC4sUFt+wzbX7f9iO39tn9vGoUBAAbafLntS5IuTXLM9mmSvmb7viQPd1wbAEAtgjpJJB1rrp7WXNJlUQCA/9dqjtr2Ftv7JB2VdH+S3UPaLNhetL3Y7/cnXScAbFqtgjrJq0neLelcSRfb/skhbXYmmU8y3+v1Jl0nAGxaq1r1keS/JO2SdHkn1QAATtBm1UfP9lnN9g9K+qCkJ7suDAAw0GbVxzmSbrG9RYNg/7sk93RbFgBgSZtVH49KunAKtQAAhuDMRAAojqAGgOIIagAojqAGgOIIagAojqAGgOIIagAojqAGgOIIagAojqAGgOIIagAojqAGgOIIagAojqAGgOIIagAojqAGgOIIagAojqAGgOIIagAojqAGgOIIagAobmxQ2z7P9oO2D9jeb/uGaRQGABjY2qLNK5J+O8le22dK2mP7/iRPdFwbAEAtRtRJjiTZ22y/KOmApHd0XRgAYGBVc9S25yRdKGl3F8UAAE7UOqhtv1HSlyR9Isn3huxfsL1oe7Hf70+yRgDY1FoFte3TNAjpW5PcOaxNkp1J5pPM93q9SdYIAJtam1UflvR5SQeSfKb7kgAAy7UZUV8i6VclXWp7X3O5ouO6AACNscvzknxNkqdQCwBgiDbrqIFTMrfj3pH7Dt545RQrAdY3TiEHgOIIagAojqAGgOIIagAojqAGgOIIagAojqAGgOIIagAojqAGgOIIagAojqAGgOIIagAojg9lwkyM+sAmPqwJOBEjagAojqAGgOIIagAojqAGgOIIagAojqAGgOIIagAojqAGgOLGBrXtm20ftf34NAoCALxWmxH1X0m6vOM6AAAjjD2FPMlDtue6LwXg1HJgmInNUdtesL1oe7Hf70/qYQFg05tYUCfZmWQ+yXyv15vUwwLApseqDwAojqAGgOLaLM+7TdK/SrrA9iHb13VfFgBgSZtVHx+dRiEAgOGY+gCA4ghqACiOoAaA4vhyW6wLnLGIzYwRNQAUR1ADQHEENQAUR1ADQHEENQAUR1ADQHEENQAUxzpqrGusr8ZmwIgaAIojqAGgOIIaAIojqAGgOIIaAIpj1Qc2JFaDYCNhRA0AxRHUAFAcUx/YVJgSwXrEiBoAims1orZ9uaTPSdoi6aYkN3ZaFTBljLRR2digtr1F0p9I+pCkQ5K+YfvuJE90XRwwa6MCfBSCHV1oM6K+WNLTSZ6VJNtfkHS1JIIaWGG1wX4yhD6WtAnqd0j6zrLrhyT99MpGthckLTRXj9l+6hRr2ibp+VO8bzUbpS8bpR/SOuqLPz22ybrpyxgbpR/S2vryzlE72gS1h9yWE25IdkrauYqihv9j9mKS+bU+TgUbpS8bpR8Sfaloo/RD6q4vbVZ9HJJ03rLr50o6POlCAADDtQnqb0h6l+0fsX26pGsk3d1tWQCAJWOnPpK8Yvvjkr6qwfK8m5Ps77CmNU+fFLJR+rJR+iHRl4o2Sj+kjvri5ITpZgBAIZyZCADFEdQAUNzMg9r2L9veb/v7tkcua7F9ue2nbD9te8c0a2zL9lts32/7283PN49o96rtfc2lzBuz455j26+zfXuzf7ftuelX2U6Lvlxru7/sOPzGLOocx/bNto/afnzEftv+o6afj9q+aNo1ttWiLx+w/cKyY/KpadfYhu3zbD9o+0CTXTcMaTPZ45JkphdJPybpAkm7JM2PaLNF0jOStks6XdIjkn581rUPqfMPJe1otndI+vSIdsdmXeupPMeSflPSnzfb10i6fdZ1r6Ev10r641nX2qIv75d0kaTHR+y/QtJ9Gpzv8B5Ju2dd8xr68gFJ98y6zhb9OEfSRc32mZK+NeT3a6LHZeYj6iQHkow7i/H4aexJXpa0dBp7NVdLuqXZvkXSL8ywltVq8xwv798dki6zPeyEqFlbL78vYyV5SNJ/nqTJ1ZL+OgMPSzrL9jnTqW51WvRlXUhyJMneZvtFSQc0OIN7uYkel5kHdUvDTmNf+cRU8LYkR6TBwZT01hHtzrC9aPth21XCvM1zfLxNklckvSDp7KlUtzptf19+qXlZeoft84bsXw/Wy99GW++1/Yjt+2z/xKyLGaeZ/rtQ0u4VuyZ6XKbyxQG2/1nS24fs+mSSf2jzEENum8m6wpP1ZRUPc36Sw7a3S3rA9mNJnplMhaeszXNc5jiM0abOf5R0W5KXbF+vwSuFSzuvbPLWyzFpY6+kdyY5ZvsKSX8v6V0zrmkk22+U9CVJn0jyvZW7h9zllI/LVII6yQfX+BBlTmM/WV9sP2f7nCRHmpc5R0c8xuHm57O2d2nwP/Ksg7rNc7zU5pDtrZLepJovZcf2Jcl3l139C0njPwKppjJ/G2u1POySfNn2n9relqTcBzbZPk2DkL41yZ1Dmkz0uKyXqY/1chr73ZI+1mx/TNIJrxZsv9n265rtbZIuUY2PjG3zHC/v30ckPZDmnZNixvZlxXzhVRrMM65Hd0v6tWaVwXskvbA0/bbe2H770nseti/WIJ++e/J7TV9T4+clHUjymRHNJntcCryD+osa/O/zkqTnJH21uf2HJX15xbuo39Jg5PnJWdc9oi9nS/oXSd9ufr6luX1eg2/GkaT3SXpMg5UIj0m6btZ1n+w5lvT7kq5qts+Q9EVJT0v6uqTts655DX35A0n7m+PwoKQfnXXNI/pxm6Qjkv63+Tu5TtL1kq5v9luDL/Z4pvl9GrpyqsKlRV8+vuyYPCzpfbOueUQ/fkaDaYxHJe1rLld0eVw4hRwAilsvUx8AsGkR1ABQHEENAMUR1ABQHEENAMUR1ABQHEENAMX9HymaKbcA4RYvAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import sys \n", + "import os\n", + "\n", + "sys.path.insert(0, os.path.abspath('..'))\n", + "\n", + "\n", + "prob_dead = np.genfromtxt('life_table.csv', delimiter=',', skip_header =1)\n", + "prob_surv = 1 - prob_dead\n", + "prob_surv_list= np.ndarray.tolist(prob_surv[:80])\n", + "\n", + "income_profile = np.genfromtxt('productivity_profile.csv', delimiter=',', skip_header =1)\n", + "income_profile_list=np.ndarray.tolist(income_profile[:80])\n", + "\n", + "Ex_dictionary = {\n", + " 'CRRA' : 2.0,\n", + " 'Rfree' : 1.05,\n", + " 'DiscFac' : 0.99,\n", + " 'LivPrb' : prob_surv_list,\n", + " 'PermGroFac' : income_profile_list,\n", + " 'cycles' : 1,\n", + " 'T_cycle' : 1,\n", + "}\n", + "\n", + "Ex_agent = PerfForesightConsumerType(**Ex_dictionary)\n", + "Ex_agent.solve()\n", + "\n", + "Ex_agent.unpackcFunc()\n", + "\n", + "min_v = min(Ex_agent.solution[t].mNrmMin for t in range(11) )\n", + "max_v = -min_v\n", + "print(\"Consumption functions\")\n", + "plotFuncs(Ex_agent.cFunc[:],min_v,max_v)\n", + "\n", + "\n", + "Simulation_dictionary = { 'AgentCount': 1000,\n", + " 'aNrmInitMean' : -10.0,\n", + " 'aNrmInitStd' : 0.0,\n", + " 'pLvlInitMean' : 0.0,\n", + " 'pLvlInitStd' : 0.05,\n", + " 'PermGroFacAgg' : 1.0,\n", + " 'T_cycle' : 1,\n", + " 'T_sim' : 2000,\n", + " 'T_age' : 80,\n", + " 'BoroCnstArt' : 0.0, \n", + " }\n", + "\n", + "for key,value in Simulation_dictionary.items():\n", + " setattr(Ex_agent,key,value)\n", + "\n", + "Ex_agent.track_vars = ['aNrmNow','cNrmNow', 'aLvlNow']\n", + "Ex_agent.initializeSim()\n", + "Ex_agent.simulate()\n", + "\n", + "\n", + "sim_wealth = np.reshape(Ex_agent.aLvlNow_hist,-1)\n", + "print(\"Wealth distribution histogram\")\n", + "n, bins, patches = plt.hist(sim_wealth,50,density=True, range=[-1.0,2.0])\n", + "\n", + "pctiles = np.linspace(0.001,0.999,15)\n", + "#SCF_Lorenz_points = getLorenzShares(SCF_wealth,weights=SCF_weights,percentiles=pctiles)\n", + "sim_Lorenz_points = getLorenzShares(sim_wealth,percentiles=pctiles)\n", + "\n", + "plt.figure(figsize=(5,5))\n", + "plt.title('Lorenz curve')\n", + "plt.plot(pctiles,sim_Lorenz_points,'-b',label='Lorenz curve')\n", + "plt.plot(pctiles,pctiles,'g-.',label='45 Degree')\n", + "plt.xlabel('Percentile of net worth')\n", + "plt.ylabel('Cumulative share of wealth')\n", + "plt.legend(loc=2)\n", + "plt.ylim([0,1])\n", + "plt.show()\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Documentation/notebooks/Quickstart_tutorial/README.md b/Documentation/notebooks/Quickstart_tutorial/README.md new file mode 100644 index 000000000..cfaf33f67 --- /dev/null +++ b/Documentation/notebooks/Quickstart_tutorial/README.md @@ -0,0 +1,19 @@ +This is quickstart for HARK Agent-type classes. + +Structure: +- **Part 1**: basics of the perfect-foresight agent model +- **Part 2**: more advanced methods for the perfect-foresight agent model +**Learning outcomes:** + - **Part 1**: + - Learn how to declare basic agent-type objects + - Learn solution methods for the agent-type objects + - Plot value function and consumption function + - Learn how to simulate the agent-type objects + - Plot value function + - **Part 2**: + - Learn how to build life-cycle models + - Learn more advanced simulation techniques + - Learn advanced plots + +To use the notebook you need a jupyter notebook with nbextension ([check](https://jupyter-contrib-nbextensions.readthedocs.io/en/latest/install.html) for the installation instructions). +After the installation, you need to enable the packages: [exercise](https://jupyter-contrib-nbextensions.readthedocs.io/en/latest/nbextensions/exercise/readme.html) and [rubberband](https://jupyter-contrib-nbextensions.readthedocs.io/en/latest/nbextensions/rubberband/readme.html). diff --git a/Documentation/notebooks/Quickstart_tutorial/life_table.csv b/Documentation/notebooks/Quickstart_tutorial/life_table.csv new file mode 100644 index 000000000..2d941e920 --- /dev/null +++ b/Documentation/notebooks/Quickstart_tutorial/life_table.csv @@ -0,0 +1,80 @@ +0.00091 +0.00096 +0.00099 +0.00099 +0.00102 +0.00107 +0.0011 +0.00112 +0.00119 +0.00126 +0.00132 +0.00133 +0.0014 +0.00146 +0.00158 +0.00171 +0.00182 +0.00199 +0.00214 +0.0023 +0.00254 +0.00282 +0.00312 +0.00338 +0.00378 +0.00412 +0.00455 +0.00485 +0.00528 +0.00569 +0.00623 +0.00675 +0.00718 +0.00774 +0.00822 +0.00889 +0.00953 +0.01009 +0.01083 +0.01165 +0.01258 +0.01347 +0.01456 +0.01577 +0.01765 +0.01908 +0.02087 +0.02236 +0.02438 +0.02679 +0.02925 +0.03211 +0.03564 +0.03929 +0.0429 +0.04774 +0.05291 +0.05878 +0.06472 +0.07151 +0.07918 +0.08647 +0.09764 +0.10901 +0.12222 +0.13661 +0.15133 +0.16756 +0.18959 +0.20295 +0.21888 +0.23795 +0.25777 +0.27821 +0.29914 +0.32039 +0.34181 +0.36322 +0.38443 +0.40529 diff --git a/Documentation/notebooks/Quickstart_tutorial/productivity_profile.csv b/Documentation/notebooks/Quickstart_tutorial/productivity_profile.csv new file mode 100644 index 000000000..72dadf57a --- /dev/null +++ b/Documentation/notebooks/Quickstart_tutorial/productivity_profile.csv @@ -0,0 +1,100 @@ +1.046336984 +1.044447175 +1.042556738 +1.040665689 +1.038774044 +1.036881819 +1.034989028 +1.033095689 +1.031201816 +1.029307426 +1.027412533 +1.025517154 +1.023621304 +1.021724999 +1.019828253 +1.017931084 +1.016033505 +1.014135533 +1.012237183 +1.01033847 +1.008439411 +1.006540019 +1.004640311 +1.002740302 +1.000840007 +0.998939441 +0.99703862 +0.995137558 +0.993236272 +0.991334775 +0.989433084 +0.987531214 +0.985629178 +0.983726994 +0.981824674 +0.979922235 +0.978019692 +0.976117059 +0.974214352 +0.972311584 +0.970408772 +0.968505929 +0.966603071 +0.964700213 +0.546376415 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 diff --git a/Documentation/notebooks/TractableBufferStockQuickDemo.ipynb b/Documentation/notebooks/TractableBufferStockQuickDemo.ipynb new file mode 100644 index 000000000..58a1e4e9b --- /dev/null +++ b/Documentation/notebooks/TractableBufferStockQuickDemo.ipynb @@ -0,0 +1,347 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# The Tractable Buffer Stock Model" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# This cell has just a bit of initial setup. You can click the arrow to expand it.\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import sys \n", + "import os\n", + "sys.path.insert(0, os.path.abspath('../../.'))\n", + "\n", + "import numpy as np\n", + "import HARK \n", + "from time import clock\n", + "from copy import deepcopy\n", + "mystr = lambda number : \"{:.3f}\".format(number)\n", + "\n", + "from ipywidgets import interact, interactive, fixed, interact_manual\n", + "import ipywidgets as widgets\n", + "\n", + "from HARK.utilities import plotFuncs\n", + "from HARK.ConsumptionSaving.TractableBufferStockModel import TractableConsumerType" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The [TractableBufferStock](http://www.econ2.jhu.edu/people/ccarroll/public/LectureNotes/Consumption/TractableBufferStock/) model is a (relatively) simple framework that captures all of the qualitative, and many of the quantitative features of optimal consumption in the presence of labor income uncertainty. \n", + "\n", + "The key assumption behind the model's tractability is that there is only a single, stark form of uncertainty. So long as an employed consumer remains employed, his labor income will rise at a constant rate. But between any period and the next there is constant hazard $p$ of transitioning to the \"unemployed\" state. Unemployment is irreversible, like retirement or disability. When unemployed, the consumer receives a fixed amount of income (for simplicity, zero).\n", + "\n", + "\\begin{eqnarray*}\n", + "\\mathbb{E}_{t}[V_{t+1}^{\\bullet}(M_{t+1})] & = & (1-p)V_{t+1}^{e}(M_{t+1})+p V_{t+1}^{u}(M_{t+1})\n", + "\\end{eqnarray*}\n", + "\n", + "A consumer with CRRA utility $U(C) = \\frac{C^{1-\\rho}}{1-\\rho}$ solves an optimization problem that looks standard (where $P$ is Permanent income and $\\Gamma$ is the income growth factor):\n", + "\n", + "\\begin{eqnarray*}\n", + "V_t(M_t) &=& \\max_{C_t} ~ U(C_t) + \\beta \\mathbb{E}[V_{t+1}^{\\bullet}], \\\\\n", + "M_{t+1} &=& R A_t + \\mathbb{1}(P_{t+1}), \\\\\n", + "P_{t+1} &=& \\Gamma_{t+1} P_t,\n", + "\\end{eqnarray*}\n", + "\n", + "where $\\mathbb{1}$ is an indicator of whether the consumer is employed in the next period.\n", + "\n", + "Under plausible parameter values the model has a target level of $m = M/P$ (market resources to permanent income) with an analytical solution that exhibits plausible relationships among all of the parameters. (See the linked handout for details)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# Define a parameter dictionary and representation of the agents for the tractable buffer stock model\n", + "TBS_dictionary = {'UnempPrb' : .00625, # Probability of becoming unemployed\n", + " 'DiscFac' : 0.975, # Intertemporal discount factor\n", + " 'Rfree' : 1.01, # Risk-free interest factor on assets\n", + " 'PermGroFac' : 1.0025, # Permanent income growth factor (uncompensated)\n", + " 'CRRA' : 2.5} # Coefficient of relative risk aversion\n", + "MyTBStype = TractableConsumerType(**TBS_dictionary)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Define a function that plots the employed consumption function and sustainable consumption function \n", + "# for given parameter values\n", + "\n", + "def makeTBSplot(DiscFac,CRRA,Rfree,PermGroFac,UnempPrb,mMax,mMin,cMin,cMax,plot_emp,plot_ret,plot_mSS,show_targ):\n", + " MyTBStype.DiscFac = DiscFac\n", + " MyTBStype.CRRA = CRRA\n", + " MyTBStype.PermGroFac = PermGroFac\n", + " MyTBStype.UnempPrb = UnempPrb\n", + " \n", + " try:\n", + " MyTBStype.solve()\n", + " except:\n", + " print('Those parameter values violate a condition required for solution!') \n", + " \n", + " plt.xlabel('Market resources $M_t$')\n", + " plt.ylabel('Consumption $C_t$')\n", + " plt.ylim([cMin,cMax])\n", + " plt.xlim([mMin,mMax])\n", + " \n", + " m = np.linspace(mMin,mMax,num=100,endpoint=True)\n", + " if plot_emp:\n", + " c = MyTBStype.solution[0].cFunc(m)\n", + " c[m==0.] = 0.\n", + " plt.plot(m,c,'-b')\n", + " \n", + " if plot_mSS:\n", + " plt.plot([mMin,mMax],[(MyTBStype.PermGroFacCmp/MyTBStype.Rfree + mMin*(1.0-MyTBStype.PermGroFacCmp/MyTBStype.Rfree)),(MyTBStype.PermGroFacCmp/MyTBStype.Rfree + mMax*(1.0-MyTBStype.PermGroFacCmp/MyTBStype.Rfree))],'--k')\n", + " \n", + " if plot_ret:\n", + " c = MyTBStype.solution[0].cFunc_U(m)\n", + " plt.plot(m,c,'-g')\n", + " \n", + " if show_targ:\n", + " mTarg = MyTBStype.mTarg\n", + " cTarg = MyTBStype.cTarg\n", + " targ_label = '$m^* =$' + mystr(mTarg) + '\\n$c^* =$' + mystr(cTarg)\n", + " plt.annotate(targ_label,xy=(0.0,0.0),xytext=(0.8,0.05),textcoords='axes fraction')\n", + " \n", + " plt.show()\n", + " return None\n", + "\n", + "# Define widgets to control various aspects of the plot\n", + "\n", + "# Define a slider for the discount factor\n", + "DiscFac_widget = widgets.FloatSlider(\n", + " min=0.9,\n", + " max=0.99,\n", + " step=0.0002,\n", + " value=0.95,\n", + " continuous_update=False,\n", + " readout_format='.4f',\n", + " description='$\\\\beta$')\n", + "\n", + "# Define a slider for relative risk aversion\n", + "CRRA_widget = widgets.FloatSlider(\n", + " min=0.1,\n", + " max=8.0,\n", + " step=0.01,\n", + " value=2.5,\n", + " continuous_update=False,\n", + " readout_format='.2f',\n", + " description='$\\\\rho$')\n", + "\n", + "# Define a slider for permanent income growth\n", + "PermGroFac_widget = widgets.FloatSlider(\n", + " min=0.9,\n", + " max=1.1,\n", + " step=0.0002,\n", + " value=1.0025,\n", + " continuous_update=False,\n", + " readout_format='.4f',\n", + " description='$\\\\Gamma$')\n", + "\n", + "# Define a slider for unemployment (or retirement) probability\n", + "UnempPrb_widget = widgets.FloatSlider(\n", + " min=0.00001,\n", + " max=0.10,\n", + " step=0.00001,\n", + " value=0.00625,\n", + " continuous_update=False,\n", + " readout_format='.5f',\n", + " description='$\\\\mho$')\n", + "\n", + "# Define a slider for unemployment (or retirement) probability\n", + "Rfree_widget = widgets.FloatSlider(\n", + " min=1.0,\n", + " max=1.1,\n", + " step=0.0001,\n", + " value=1.01,\n", + " continuous_update=False,\n", + " readout_format='.4f',\n", + " description='$R$')\n", + "\n", + "# Define a text box for the lower bound of M_t\n", + "mMin_widget = widgets.FloatText(\n", + " value=0.0,\n", + " step=0.1,\n", + " description='$M$ min',\n", + " disabled=False)\n", + "\n", + "# Define a text box for the upper bound of M_t\n", + "mMax_widget = widgets.FloatText(\n", + " value=50.0,\n", + " step=0.1,\n", + " description='$M$ max',\n", + " disabled=False)\n", + "\n", + "# Define a text box for the lower bound of C_t\n", + "cMin_widget = widgets.FloatText(\n", + " value=0.0,\n", + " step=0.1,\n", + " description='$C$ min',\n", + " disabled=False)\n", + "\n", + "# Define a text box for the upper bound of C_t\n", + "cMax_widget = widgets.FloatText(\n", + " value=1.5,\n", + " step=0.1,\n", + " description='$C$ max',\n", + " disabled=False)\n", + "\n", + "# Define a check box for whether to plot the employed consumption function\n", + "plot_emp_widget = widgets.Checkbox(\n", + " value=True,\n", + " description='Plot employed $C$ function',\n", + " disabled=False)\n", + "\n", + "# Define a check box for whether to plot the retired consumption function\n", + "plot_ret_widget = widgets.Checkbox(\n", + " value=True,\n", + " description='Plot retired $C$ function',\n", + " disabled=False)\n", + "\n", + "# Define a check box for whether to plot the sustainable consumption line\n", + "plot_mSS_widget = widgets.Checkbox(\n", + " value=True,\n", + " description='Plot sustainable $C$ line',\n", + " disabled=False)\n", + "\n", + "# Define a check box for whether to show the target annotation\n", + "show_targ_widget = widgets.Checkbox(\n", + " value=True,\n", + " description = 'Show target $(M,C)$',\n", + " disabled = False)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Target Wealth\n", + "\n", + "Whether the model exhibits a \"target\" or \"stable\" level of wealth for employed consumers depends on whether the 'Growth Impatience Condition' (the GIC) holds:\n", + "\n", + "\\begin{equation}\\label{eq:GIC}\n", + " \\left(\\frac{(R \\beta (1-\\mho))^{1/\\rho}}{\\Gamma}\\right) < 1\n", + "\\end{equation}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "code_folding": [], + "scrolled": false + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "07c8e21b6c424a91a2a79a530f15d619", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=0.95, continuous_update=False, description='$\\\\beta$', max=0.99, min=0…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Make an interactive plot of the tractable buffer stock solution\n", + "\n", + "# To make some of the widgets not appear, replace X_widget with fixed(desired_fixed_value) in the arguments below.\n", + "interact(makeTBSplot,\n", + " DiscFac = DiscFac_widget,\n", + "# CRRA = CRRA_widget,\n", + " CRRA = fixed(2.5),\n", + " Rfree = Rfree_widget,\n", + " PermGroFac = PermGroFac_widget,\n", + " UnempPrb = UnempPrb_widget,\n", + " mMin = mMin_widget,\n", + " mMax = mMax_widget,\n", + " cMin = cMin_widget,\n", + " cMax = cMax_widget,\n", + " show_targ = show_targ_widget,\n", + " plot_emp = plot_emp_widget,\n", + " plot_ret = plot_ret_widget,\n", + " plot_mSS = plot_mSS_widget,\n", + " );\n" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "collapsed", + "formats": "ipynb,py:percent" + }, + "kernel_info": { + "name": "python3" + }, + "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.3" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "nteract": { + "version": "0.14.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Documentation/notebooks/Uncertainty-and-the-Saving-Rate.ipynb b/Documentation/notebooks/Uncertainty-and-the-Saving-Rate.ipynb new file mode 100644 index 000000000..48c09097b --- /dev/null +++ b/Documentation/notebooks/Uncertainty-and-the-Saving-Rate.ipynb @@ -0,0 +1,764 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Uncertainty and Saving in Partial Equilibrium\n", + "\n", + "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/econ-ark/DemARK/master?filepath=notebooks%2FUncertainty-and-the-Saving-Rate.ipynb)\n", + "\n", + "Saving rates vary widely across countries, but there is no consensus about the main causes of those differences.\n", + "\n", + "One commonly mentioned factor is differences across countries in the degree of uncertainty that individuals face, which should induce different amounts of precautionary saving.\n", + "\n", + "Uncertainty might differ for \"fundamental\" reasons, having to do with, say, the volatility of demand for the goods and services supplied by the country, or might differ as a result of economic policies, such as the strucutre of the social insurance system.\n", + "\n", + "A challenge in evaluating the importance of precautionary motives for cross-country saving differences has been a lack of consensus about what measures of uncertainty ought, in principle, to be the right ones to look at in any attempt to measure a relationship between uncertainty and saving.\n", + "\n", + "This notebook uses [a standard model](https://econ.jhu.edu/people/ccarroll/papers/cstwMPC) to construct a theoretical benchmark for the relationship of saving to two kinds of uncertainty: Permanent shocks and transitory shocks to income. \n", + "\n", + "Conclusions:\n", + "1. The model implies a close to linear relationship between the variance of either kind of shock (transitory or permanent) and the saving rate\n", + "2. The _slope_ of that relationship is much steeper for permanent than for transitory shocks\n", + " * Over ranges of values calibrated to be representative of microeconomically plausible magnitudes\n", + "\n", + "Thus, the quantitative theory of precautionary saving says that the principal determinant of precautionary saving should be the magnitude of permanent (or highly persistent) shocks to income.\n", + "\n", + "(Because the result was obtained in a partial equilibrium model, the conclusion applies also to attempts to measure the magnitude of precautionary saving across groups of people who face different degrees of uncertainty within a country).\n", + "\n", + "@authors: Derin Aksit, Tongli Zhang, Christopher Carroll" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "code_folding": [ + 0, + 11 + ] + }, + "outputs": [], + "source": [ + "# Boring non-HARK setup stuff\n", + "\n", + "Generator = True # This notebook can be used as a source for generating derivative notebooks\n", + "nb_name = 'Uncertainty-and-the-Saving-Rate'\n", + "\n", + "# This is a jupytext paired notebook that autogenerates BufferStockTheory.py\n", + "# which can be executed from a terminal command line via \"ipython BufferStockTheory.py\"\n", + "# But a terminal does not permit inline figures, so we need to test jupyter vs terminal\n", + "# Google \"how can I check if code is executed in the ipython notebook\"\n", + "\n", + "from IPython import get_ipython # In case it was run from python instead of ipython\n", + "def in_ipynb():\n", + " try:\n", + " if str(type(get_ipython())) == \"\":\n", + " return True\n", + " else:\n", + " return False\n", + " except NameError:\n", + " return False\n", + "\n", + "# Determine whether to make the figures inline (for spyder or jupyter)\n", + "# vs whatever is the automatic setting that will apply if run from the terminal\n", + "if in_ipynb():\n", + " # %matplotlib inline generates a syntax error when run from the shell\n", + " # so do this instead\n", + " get_ipython().run_line_magic('matplotlib', 'inline')\n", + "else:\n", + " get_ipython().run_line_magic('matplotlib', 'auto')\n", + " print('You appear to be running from a terminal')\n", + " print('By default, figures will appear one by one')\n", + " print('Close the visible figure in order to see the next one')\n", + "\n", + "# Import the plot-figure library matplotlib\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# In order to use LaTeX to manage all text layout in our figures, we import rc settings from matplotlib.\n", + "from matplotlib import rc\n", + "plt.rc('font', family='serif')\n", + "\n", + "# LaTeX is huge and takes forever to install on mybinder\n", + "# so if it is not installed then do not use it \n", + "from distutils.spawn import find_executable\n", + "iflatexExists=False\n", + "if find_executable('latex'):\n", + " iflatexExists=True\n", + " \n", + "plt.rc('font', family='serif')\n", + "plt.rc('text', usetex=iflatexExists)\n", + "\n", + "# The warnings package allows us to ignore some harmless but alarming warning messages\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "# The tools for navigating the filesystem\n", + "import sys\n", + "import os\n", + "\n", + "sys.path.insert(0, os.path.abspath('../lib')) # directory is one down from root \n", + "\n", + "from copy import copy, deepcopy\n", + "\n", + "# Define (and create, if necessary) the figures directory \"Figures\"\n", + "if Generator:\n", + " nb_file_path = os.path.dirname(os.path.abspath(nb_name+\".ipynb\")) # Find pathname to this file:\n", + " FigDir = os.path.join(nb_file_path,\"Figures/\") # LaTeX document assumes figures will be here\n", + "# FigDir = os.path.join(nb_file_path,\"/tmp/Figures/\") # Uncomment to make figures outside of git path\n", + " if not os.path.exists(FigDir):\n", + " os.makedirs(FigDir)\n", + "\n", + "from copy import deepcopy\n", + "from scipy.optimize import golden, brentq\n", + "from time import clock\n", + "import numpy as np\n", + "import scipy as sp" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# Import HARK tools and cstwMPC parameter values\n", + "from HARK.utilities import plotFuncsDer, plotFuncs\n", + "from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType\n", + "import HARK.cstwMPC.cstwMPC as cstwMPC\n", + "import HARK.cstwMPC.SetupParamsCSTW as Params\n", + "\n", + "# Double the default value of variance\n", + "# Params.init_infinite['PermShkStd'] = [i*2 for i in Params.init_infinite['PermShkStd']]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "code_folding": [ + 0 + ], + "scrolled": false + }, + "outputs": [], + "source": [ + "# Setup stuff for general equilibrium version\n", + "\n", + "# Set targets for K/Y and the Lorenz curve\n", + "lorenz_target = cstwMPC.getLorenzShares(Params.SCF_wealth,weights=\n", + " Params.SCF_weights,percentiles=\n", + " Params.percentiles_to_match)\n", + "\n", + "lorenz_long_data = np.hstack((np.array(0.0),\\\n", + " cstwMPC.getLorenzShares(Params.SCF_wealth,weights=\\\n", + " Params.SCF_weights,percentiles=\\\n", + " np.arange(0.01,1.0,0.01).tolist()),np.array(1.0)))\n", + "KY_target = 10.26" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Setup and calibration of the agent types\n", + "\n", + "# The parameter values below are taken from\n", + "# http://econ.jhu.edu/people/ccarroll/papers/cjSOE/#calibration\n", + "\n", + "Params.init_cjSOE = Params.init_infinite # Get default values of all parameters\n", + "# Now change some of the parameters for the individual's problem to those of cjSOE\n", + "Params.init_cjSOE['CRRA'] = 2\n", + "Params.init_cjSOE['Rfree'] = 1.04**0.25\n", + "Params.init_cjSOE['PermGroFac'] = [1.01**0.25] # Indiviual-specific income growth (from experience, e.g.)\n", + "Params.init_cjSOE['PermGroFacAgg'] = 1.04**0.25 # Aggregate productivity growth \n", + "Params.init_cjSOE['LivPrb'] = [0.95**0.25] # Matches a short working life \n", + "\n", + "PopGroFac_cjSOE = [1.01**0.25] # Irrelevant to the individual's choice; attach later to \"market\" economy object\n", + "\n", + "# Instantiate the baseline agent type with the parameters defined above\n", + "BaselineType = cstwMPC.cstwMPCagent(**Params.init_cjSOE)\n", + "BaselineType.AgeDstn = np.array(1.0) # Fix the age distribution of agents\n", + "\n", + "# Make desired number of agent types (to capture ex-ante heterogeneity)\n", + "EstimationAgentList = []\n", + "for n in range(Params.pref_type_count):\n", + " EstimationAgentList.append(deepcopy(BaselineType))\n", + " EstimationAgentList[n].seed = n # Give every instance a different seed" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# Make an economy for the consumers to live in\n", + "\n", + "EstimationEconomy = cstwMPC.cstwMPCmarket(**Params.init_market)\n", + "EstimationEconomy.print_parallel_error_once = True # Avoids a bug in the code\n", + "\n", + "EstimationEconomy.agents = EstimationAgentList\n", + "EstimationEconomy.act_T = Params.T_sim_PY # How many periods of history are good enough for \"steady state\"" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Uninteresting parameters that also need to be set \n", + "EstimationEconomy.KYratioTarget = KY_target\n", + "EstimationEconomy.LorenzTarget = lorenz_target\n", + "EstimationEconomy.LorenzData = lorenz_long_data\n", + "EstimationEconomy.PopGroFac = PopGroFac_cjSOE # Population growth characterizes the entire economy\n", + "EstimationEconomy.ignore_periods = Params.ignore_periods_PY # Presample periods\n", + "\n", + "#Display statistics about the estimated model (or not)\n", + "EstimationEconomy.LorenzBool = False\n", + "EstimationEconomy.ManyStatsBool = False\n", + "EstimationEconomy.TypeWeight = [1.0]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "code_folding": [ + 0 + ], + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "# construct spread_estimate and center_estimate if true, otherwise use the default values\n", + "Params.do_param_dist=True # Whether to use a distribution of ex-ante heterogeneity\n", + "\n", + "# Discount factors assumed to be uniformly distributed around center_pre for spread_pre on either side\n", + "\n", + "spread_pre=0.0019501105739768 #result under the default calibration of cjSOE\n", + "center_pre=1.0065863855906343 #result under the default calibration of cjSOE\n", + "\n", + "do_optimizing=False # Set to True to reestimate the distribution of time preference rates\n", + "\n", + "if do_optimizing: # If you want to rerun the cstwMPC estimation, change do_optimizing to True\n", + " # Finite value requires discount factor from combined pure and mortality-induced\n", + " # discounting to be less than one, so maximum DiscFac is 1/LivPrb\n", + " DiscFacMax = 1/Params.init_cjSOE['LivPrb'][0] # \n", + " param_range = [0.995,-0.0001+DiscFacMax] \n", + " spread_range = [0.00195,0.0205] # \n", + "\n", + " if Params.do_param_dist: # If configured to estimate the distribution\n", + " LorenzBool = True\n", + " # Run the param-dist estimation\n", + " paramDistObjective = lambda spread : cstwMPC.findLorenzDistanceAtTargetKY(\n", + " Economy = EstimationEconomy,\n", + " param_name = Params.param_name,\n", + " param_count = Params.pref_type_count,\n", + " center_range = param_range,\n", + " spread = spread,\n", + " dist_type = Params.dist_type) # Distribution of DiscFac\n", + " t_start = clock()\n", + " \n", + " spread_estimate = golden(paramDistObjective \n", + " ,brack=spread_range\n", + " ,tol=1e-4) \n", + " center_estimate = EstimationEconomy.center_save\n", + " t_end = clock()\n", + " else: # Run the param-point estimation only\n", + " paramPointObjective = lambda center : cstwMPC.getKYratioDifference(Economy = EstimationEconomy,\n", + " param_name = Params.param_name,\n", + " param_count = Params.pref_type_count,\n", + " center = center,\n", + " spread = 0.0,\n", + " dist_type = Params.dist_type)\n", + " t_start = clock()\n", + " center_estimate = brentq(paramPointObjective # Find best point estimate \n", + " ,param_range[0]\n", + " ,param_range[1],xtol=1e-6)\n", + " spread_estimate = 0.0\n", + " t_end = clock()\n", + " \n", + " print(spread_estimate)\n", + " print('****************')\n", + " print(center_estimate)\n", + " print('****************')\n", + "else: # Just use the hard-wired numbers from cstwMPC\n", + " center_estimate=center_pre\n", + " spread_estimate=spread_pre" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "code_folding": [ + 0 + ], + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "# Construct the economy at date 0\n", + "EstimationEconomy.distributeParams( # Construct consumer types whose heterogeneity is in the given parameter\n", + " 'DiscFac',\n", + " Params.pref_type_count,# How many different types of consumer are there \n", + " center_estimate, # Increase patience slightly vs cstwMPC so that maximum saving rate is higher\n", + " spread_estimate, # How much difference is there across consumers\n", + " Params.dist_type) # Default is for a uniform distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "code_folding": [ + 0 + ], + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "# Function to calculate the saving rate of a cstw economy\n", + "def calcSavRte(Economy,ParamToChange,NewVals):\n", + " '''\n", + " Calculates the saving rate as income minus consumption divided by income.\n", + " \n", + " Parameters\n", + " ----------\n", + " Economy : [cstwMPCmarket] \n", + " A fully-parameterized instance of a cstwMPCmarket economy\n", + " ParamToChange : string\n", + " Name of the parameter that should be varied from the original value in Economy\n", + " NewVals : [float] or [list]\n", + " The alternative value (or list of values) that the parameter should take\n", + "\n", + " Returns\n", + " -------\n", + " savRte : [float]\n", + " The aggregate saving rate in the last year of the generated history\n", + " '''\n", + " for NewVal in NewVals:\n", + " if ParamToChange in [\"PermShkStd\",\"TranShkStd\"]:\n", + " ThisVal = [NewVal]\n", + " else:\n", + " ThisVal = NewVal # If they asked to change something else, assume it's a scalar\n", + " \n", + " for j in range(len(Economy.agents)): # For each agent, set the new parameter value\n", + " setattr(Economy.agents[j],ParamToChange,ThisVal)\n", + " cstwMPC.cstwMPCagent.updateIncomeProcess(Economy.agents[j]) \n", + " \n", + " Economy.solve()\n", + " \n", + " C_NrmNow=[]\n", + " A_NrmNow=[]\n", + " M_NrmNow=[]\n", + " for j in range (len(Economy.agents)): # Combine the results across all the agents\n", + " C_NrmNow=np.hstack((C_NrmNow,Economy.agents[j].cNrmNow))\n", + " A_NrmNow=np.hstack((A_NrmNow,Economy.agents[j].aNrmNow))\n", + " M_NrmNow=np.hstack((M_NrmNow,Economy.agents[j].mNrmNow))\n", + " CAgg=np.sum(np.hstack(Economy.pLvlNow)*C_NrmNow) # cNrm times pLvl = level of c; sum these for CAgg\n", + " AAgg=np.sum(np.hstack(Economy.pLvlNow)*A_NrmNow) # Aggregate Assets\n", + " MAgg=np.sum(np.hstack(Economy.pLvlNow)*M_NrmNow) # Aggregate Market Resources\n", + " YAgg=np.sum(np.hstack(Economy.pLvlNow)*np.hstack(Economy.TranShkNow)) # Aggregate Labor Income\n", + " BAgg=MAgg-YAgg # Aggregate \"Bank Balances\" (at beginning of period; before consumption decision)\n", + " IncAgg=(BaselineType.Rfree-1)*BAgg+YAgg # Interest income plus noninterest income\n", + " savRte=(IncAgg-CAgg)/IncAgg # Unspent income divided by the level of income\n", + " return savRte" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "code_folding": [ + 0 + ], + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "# Function to plot relationship between x and y; x is the parameter varied and y is saving rate\n", + "def plotReg(x,y,xMin,xMax,yMin,yMax,xLbl,yLbl,Title,fileName):\n", + " # Result_data_path = os.path.join(Folder_path,'SavingVSPermShr_Youth_MPC_15.png')\n", + " plt.ylabel(yLbl)\n", + " plt.xlabel(xLbl)\n", + " plt.title(Title)\n", + " plt.xlim(xMin,xMax)\n", + " plt.ylim(yMin,yMax)\n", + " plt.scatter(x,y)\n", + " # Draw the linear fitted line\n", + " m, b = np.polyfit(x, y, 1)\n", + "# plt.plot(x, m*np.asarray(x) + b, '-')\n", + " if Generator:\n", + " plt.savefig(FigDir + nb_name + '-' + fileName + '.png')\n", + " plt.savefig(FigDir + nb_name + '-' + fileName + '.svg')\n", + " plt.savefig(FigDir + nb_name + '-' + fileName + '.pdf')\n", + " slope, intercept, r_value, p_value, std_err = sp.stats.linregress(x,y)\n", + " print('Slope=' + str(slope) + ', intercept=' + str(intercept) + ', r_value=' + str(r_value) + ', p_value=' + str(p_value)+', std=' + str(std_err))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Proportion of base value for uncertainty parameter to take (up to 1 = 100 percent)\n", + "# Do not go above one to avoid having to worry about whether the most patient consumer violates the \n", + "# Growth Impatience Condition (https://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/#GIC)\n", + "bottom=0.5\n", + "points=np.arange(bottom,1.+0.025,0.025)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "code_folding": [ + 0 + ], + "scrolled": true + }, + "outputs": [], + "source": [ + "# Calculate variance of permanent shock vs saving measures\n", + "savRteList = []\n", + "KtoYList = []\n", + "pVarList = []\n", + "pVarBase = BaselineType.PermShkStd[0] ** 2\n", + "for pVar in points * pVarBase:\n", + " pVarList.append(pVar) # Variance is square of standard deviation\n", + " pStd = pVar ** 0.5\n", + "# print(pStd)\n", + " savRteList.append(calcSavRte(EstimationEconomy,\"PermShkStd\",[pStd]))\n", + " KtoYList.append(0.25*np.mean(np.array(EstimationEconomy.KtoYnow_hist)[EstimationEconomy.ignore_periods:]))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "code_folding": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Halving the magnitude of the permanent variance causes target wealth to fall to 0.646\n", + "of its original value.\n" + ] + } + ], + "source": [ + "# Calculate how much net worth shrinks when permanent variance is halved \n", + "ShrinksBy = KtoYList[1]/KtoYList[-1]\n", + "print('Halving the magnitude of the permanent variance causes target wealth to fall to %1.3f' % ShrinksBy)\n", + "print('of its original value.')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "code_folding": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Slope=43.87569286985961, intercept=0.07612904106465898, r_value=0.9957594503438054, p_value=3.715857043912896e-21, std=0.9299464143538145\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Slope=530.7061985365614, intercept=0.6766240453921681, r_value=0.9969394089293704, p_value=1.6852816164419637e-22, std=9.547588506159919\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot pVar vs saving measures\n", + "plotReg(pVarList,savRteList,\n", + " xMin=pVarList[1]-0.0002,xMax=pVarList[-1]+0.0002,yMin=savRteList[1]-0.01,yMax=savRteList[-1]+0.01,\n", + " xLbl=r'Variance of Permanent Shocks, $\\sigma^{2}_{\\psi}$',\n", + " yLbl='Aggregate Saving Rate',\n", + " Title='Uncertainty vs Saving',\n", + " fileName='savRtevsPermShkVar'\n", + " )\n", + "plt.show(block=False)\n", + "plotReg(pVarList,KtoYList,\n", + " xMin=pVarList[1]-0.0002,xMax=pVarList[-1]+0.0002,yMin=1.7,yMax=KtoYList[-1]+0.1,\n", + " xLbl=r'Variance of Permanent Shocks, $\\sigma^{2}_{\\psi}$',\n", + " yLbl='Net Worth/Income',\n", + " Title='Uncertainty vs Net Worth Ratio',\n", + " fileName='BvsPermShkVar'\n", + " )\n", + "plt.ylabel('Net Worth/Income')\n", + "plt.xlabel(r'Variance of Permanent Shocks, $\\sigma^{2}_{\\psi}$')\n", + "plt.title('Uncertainty vs Net Worth Ratio',fontsize=16)\n", + "plt.xlim(pVarList[1]-0.0002,pVarList[-1]+0.0002)\n", + "plt.ylim(1.6,KtoYList[-1]+0.1)\n", + "plt.scatter(pVarList,KtoYList)\n", + "plt.xticks([pVarList[1],pVarList[-1]],[r'$\\bar{\\sigma}^{2}_{\\psi}/2$',r'$\\bar{\\sigma}^{2}_{\\psi}$'])\n", + "fileName='BvsPermShkVar'\n", + "if Generator:\n", + " plt.savefig(FigDir + nb_name + '-' + fileName + '.png')\n", + " plt.savefig(FigDir + nb_name + '-' + fileName + '.svg')\n", + " plt.savefig(FigDir + nb_name + '-' + fileName + '.pdf')\n", + "plt.show(block=False) " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "code_folding": [ + 0 + ], + "scrolled": false + }, + "outputs": [], + "source": [ + "# Calculate variance of transitory shock vs saving measures\n", + "# Restore benchmark solution\n", + "EstimationEconomy.distributeParams( # Construct consumer types whose heterogeneity is in the given parameter\n", + " 'DiscFac',\n", + " Params.pref_type_count,# How many different types of consumer are there \n", + " center_estimate, # Increase patience slightly vs cstwMPC so that maximum saving rate is higher\n", + " spread_estimate, # How much difference is there across consumers\n", + " Params.dist_type) # Default is for a uniform distribution\n", + "EstimationEconomy.solve()\n", + "\n", + "savRteList_Tran = []\n", + "KtoYList_Tran = []\n", + "tVarList = []\n", + "tVarBase = BaselineType.TranShkStd[0] ** 2\n", + "for tVar in points * tVarBase:\n", + " tVarList.append(tVar) # Variance is std squared\n", + " savRteList_Tran.append(calcSavRte(EstimationEconomy,\"TranShkStd\",[tVar ** 0.5]))\n", + " KtoYList_Tran.append(0.25*np.mean(np.array(EstimationEconomy.KtoYnow_hist)[EstimationEconomy.ignore_periods:]))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Slope=0.04425458972691994, intercept=0.22993889217509514, r_value=0.9997560905067558, p_value=6.235938075080433e-33, std=0.00022427988559214007\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEWCAYAAABi5jCmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvDW2N/gAAGnpJREFUeJzt3c+PG+d9x/HPt3ZaCEVtemUVSF24ErdtggBBrRV9ak42lbSHAoGztnqPteqtPSSS3UPhAAWUldtD0UOidf8BWbKbSw+pVgF66CXeXRXIpW67dHtwe5C1otwCLpCk3x7mGe3zjIbkkMvhkNz3C1gsOTPP8MtZ7nz5/JhnzN0FAEDuF5oOAAAwX0gMAIAEiQEAkCAxAAASJAYAQILEAABIkBgAAAkSAwAgQWIAACSebDoAHC9m1pa0Kakt6aK775lZS9I7kg4kXXH3fpMx5sxs391Xm44jZmYb4eFB+L3i7lsT7Gfu3hvmBzUGzJS79yTdlrTj7nthWV/SVUmbdSeF6MQ60qgT5zj7mgYzW5PUcvctd78laU/SRCd3kgKGITHg2Ag1k0sVt22b2fo09jVFK5JezJ+EJHtj3J2Mem8AiQFzx8y6ZrYffnfN7Ho4EefrN8LytfAtWmZ2OSzbCCe+eB83Q/m2pJaZreflotdbM7PN0NQlZU01m2bWKotH0gvxvsLyB1E8183s8oD39th2YR/5vjbLjou7b4cy+6FcN691lb2PITENfW+FY70Z9pkfcxLKMUAfA+aOu2+bWU9Sz9174cTWkbQdTkyr7r4VTuJXzGw3LydJZnbT3V8N+zhw91fDrvfMrB+aYWKXwvaSdCU874fyg+J5UlKyLzPbUvatXpJu5vGUvLfHtgvJ4IPQ5zLs2Lwa3ndX0nUz24z6GJL34e6XBsU04r3lx7qtrOlqz8y64XHx2GEJUWNAE3o6PFnlVnTYoZqLn+ffYl+U9IGUNaW4+yVJ5yT1oxrEB/k+42/UQ1wJCaczYruyeGJXw75ayt7jIPF2B+G9XJHUDkmutIkq/+Yf3vdW6CeIty17H4+9VtX3lvcHhdfdIykcHyQGNGFHWbNOrFWx4/kDRe3s4YR3W5LcfS8kgmGjdA5CuW70+0o46eXfpouxVdpXiL8naSOcVEuF7fphu72wjw13v+bueZIri6Gdv1Yo01J2LAe+j7LXGlc4ro/VfrC8aErCzIVmmouhvTs/gT468YRvqG1Jr5nZu5LOS+qZ2ba734o6T/vKmopuhTbwR8tCc0o7nHDjRHHTstFE+eseRK8pZTWXdtQn8ZqZ7agkHkl/V9iXJF3X40mvzFWl3+xbUfz7QxJLvp3C61wZ9j5CbMlrFY5v6XsLx7ov6ZKZXQj7351kaCwWj3EHN+DowrfzXugQXopv1yHpbYf31VLWrzHRdRNYLNQYgOlYN7NtDe9bWDQ7ktbiUUqKanZYXtQYAAAJOp8BAIlampKiTrQ1d79Wsj6fSmA1DNOL110uKxN79tln/fTp09MKFwCOhd3d3U/c/dSo7aaeGKKx1tth9Mha8epMHXZo3Yw768K685KGJobTp09rZ2dn2qEDwFIzs/+osl0dTUkXlNUWpKwjrltY346W9VRtaB8AYEbqSAzFKyxPxivDFZv5cLc1HV6gs7Ysw/wAYJE11vkcXWafNzMVp0gobr9hZjtmtnPv3r36AwSAY6qOxNDX4Um+Jen+gO26ecdzldpCqGl03L1z6tTIvhMAwITqGJV0Q4eX37d1OG/Lo7lw8nlhwuOussv828oSykqxwxoAMDtTrzFEk4J1lU1LnJ/g70TLN8Mc8A9CmVvRzI1ls1YCAGZkIa987nQ6znBVABiPme26+6jp5bnyGQCQIjEAABIkBgBAgsQAAEiQGAAACRIDACBBYgAAJEgMAIAEiQEAkCAxAAASJAYAQKKWez4DAA794O7HevuHH+o/+5/p11on9O2vfUFfP/vczMqPi8SAY6Hpf0zKH9/yP7j7sd58/yf67Kc/lyR93P9Mb77/E0mqtI+jlp/EQs6u+kuf/y3v/PH1hfpwUP7o/1zT+seUpBOfe0JXX/nyRP+YlKf8OOV/97s/0sf9zx5b/lzrhP7xjZdqLx9b+tlV86z5g7sfV9o+/+N+3P9MTvmFKn/U1377hx8m/9SS9NlPf663f/gh5Slfe/n/LDmpD1s+7fKTWNjEIC3Wh4Pyk5df9H9Myh/v8r/WOjHW8mmXn8RCJwZpcT4clJ+8/KL/Y1L+eJf/9te+oBOfeyJZduJzT+jbX/vCTMpPYuETw6J8OCg/eflF/8ek/PEu//Wzz+nqK1/Wc60TMmV9A1X7J6ZRfhJPvPXWW7XtvC5//pd//davvPB7OvG5J/Rnf/AlffHzT40sc/KXf1H/8C/39LP/O+xsp/xilD/qa3/x80/p1585oZ98/FD/878/03OtE/qzP/hS5X8sylP+KOXzfXzzK2f0J93f1je/cqbS53aa5XPf+c53/uutt97aGrUdo5IovxDlZz2OG1hGVUclLWRi6HQ6vrOz03QYALBQln64KgCgHiQGAECCxAAASJAYAAAJEgMAIEFiAAAkSAwAgASJAQCQIDEAABIkBgBAgsQAAEiQGAAACRIDACBBYgAAJEgMAIAEiQEAkHiyjp2a2bqkvqQ1d79Wsn4jPFx19yuDlgEAZm/qNQYzW5Mkd9+W1M+fR+u7krbdfUtS28y6ZcumHRcAoJo6mpIuKKstSFJPUvEk346W9cLzsmUAgAbU0ZTUknQQPT8Zrwy1gtyapBvuvldcVkNcAIAKGut8Dk1Me3FSKFsWrdswsx0z27l3794sQwWAY6WOxNCXtBIetyTdH7Bdt6STuWyZpKym4e4dd++cOnVqSqECAIrqSAw3dNhH0Ja0LUlm1so3MLONfLRS3tFctgwAMHtTTwx5M1A4ufejZqE70fJNM9s3sweDlgEAmlHLdQyFDuZ82bnwe1vSMyXFypYBAGaMK58BAAkSAwAgQWIAACRIDACABIkBAJAgMQAAEpWGq5rZRUmrkj6RtCWp4+4/qjMwAEAzql7HsO/u75jZWXf/1MxqDQoA0JyqieFcSAYtM3NJ5yRRYwCAJVQ1MWxJelPZ3Ec/dve36wsJANCkSonB3R9KekOSzOysmT3l7p/WGhkAoBGVRiWZ2Sv5Y3e/q8fvygYAWBJDawxm9g1J5yV1zOxSWNxXdvvN92uODQDQgKGJwd3fM7NtZcNT78woJgBAg0Y2Jbn7wzgpmNnpuGkJALBcxrnA7ZKy23SapF3RlAQAS6nyjXrcvWNmL7v7HTN7uc6gAADNqTpX0oGZfUvS02b2uqSzNcYEAGhQpcTg7u9JuuPu70v6ZUn/UmtUAIDGVJ5dNVy/IHf/K0m/WltEAIBGDUwM4QrnAzO7b2a/Y2ZnzOz7ZvZDZdc2AACW0LDO55fdfcXM2pK+L+ldSbcl9bmmAQCW17DE8FCS3L1nZpskAwA4HoYlhraZvRAen4keS9IFd3+zxrgAAA0ZlhheVTbNdn5Xnq9G684om4YbALBkhiWGS4Oaj8zsTE3xAAAaNnBU0rA+BXf/qJ5wAABNq3wdAwDgeKh6o57XC8+fNrPvmtlL9YQFAGhK1RrDM2Z2w8xOh+dvSLou6Zk6ggIANKdqYth39wvKRilJUjv0M/TrCQsA0JSq026v5s1JZvZReP6UpKdriwwA0IiqNYYtSQ/c/W8ktdy9o+zGPdQYAGDJVKoxuPtDSe+Fx3fN7Cl3f7vWyAAAjah6a8+zki5IcmVXQp+V9LUa4wIANKRqH0NX2Sik3HoNsQAA5kDVxLAbX+1sZrdrigcA0LCqieENM9uUdKCsKemMpN8atLGZrSvrmF5z92sl6zfCw1V3v1KlDABgNqomhuR+DGb28qANzWxNktx928zaZrbm7nvR+q6k7XCfh5vh+cGwMgCA2ak0XLVkQr39IZtf0OEw1p6y/olYO1rWC89HlQEAzMjAGoOZ3ZB0UdKqpE1JD/JVykYlDWpKainUAIKT8Up334qerkm6IencsDIAgNkZ1pT0hrt/amZ9ZfdmiDufzx71hUOT056775lZle03JG1I0vPPP3/UlwcADDDsfgwfRb+/W1h3d8g++5JWwuOWpPsDtuvmHc9Vyrj7lrt33L1z6tSpIS8PADiKqlNivGtmZ83spcK9n8vcUDTZnqRtSTKzVr6BmW3kI49C53NpGQDA7FVNDLdDLeEZSX9qZt8btGE+miic8PvR6KI70fJNM9s3swcjygAAZqzqcNU9M9uXdFPSxTB30kCFDuZ82bnwe1sl93EoKwMAmL2qieGKu79XayQAgLlQ9TqGR0nBzE6b2Sv1hQQAaFLV2VUvKrv/wn1l1zHsSnq/xrgAAA2p2pQkd++Y2cvufmfYlBgAgMVWdVTSgZl9S9LT4RafR77ADQAwn8bpY7jj7u8ra0oadoEbAGCBjdOUdDf8fqe+cAAATRtYYzCzb5vZ9/IrncPjvzezGxWufgYALKhhNYaeu78tZUlC0oq7fzU8f13SP80gPgDAjA3rY/Do8WtK7/n8QACApTSsxrBqZi9J+qokc/cfSdkFbkqTBgBgiQybdvttZSOQPnD3jiSZ2RlJ52cUGwCgAUNHJRVv6RnuzcCoJABYYlUvcAMAHBMkBgBAgsQAAEiMM7vqqqRPJG1J6uSjlAAAy6XqlBj77v6OmZ1190/NrNagAADNqZoYzoVk0DIzl3ROEjUGAFhCVRPDlqQ3JbUl/TifKgMAsHwqJQZ3fyjpDUkys7Nm9pS7f1prZACARlQalRTf4zlMv92tLSIAQKOG1hjM7BvKpsDomNmlsLgvqSfu+QwAS2nUlBjvmdm2suGpd4ZtCwBYDiObktz9YZwUzOx03LQEAFgu41zgdknSfWUzru6KpiQAWErj3PO5Y2Yvu/sdM3u5zqAAAM2pOlfSgZl9S9LT4baeZ2uMCQDQoEqJwd3fk3TH3d9X1pR0t9aoAACNqXodw+vh+gW5+zuSdszsu+HWnwCAJVK1KekZM7sR7vcsZVdBX5f0TB1BAQCaUzUx7Lv7BWVzJUlSO9zms19PWACAplQdlbQaOp1lZh+F509Jerq2yAAAjahaY9iSdODufyOp5e4dZdc1UGMAgCVTtcbwmrJaQlvSO2b2ElNvA8BymuQObg+5gxsALK9a7uBmZuvKmpnW3P3agG3W3H2vpEzb3bcqxgUAmLJx+hi+KukPJXWHNSOZ2Zokufu2pH7+vLBNV9LNQpleKNMrKwMAmI2qieGipKvu/pq7/8WIbS/osFO6p5Kb+uQJoLB4M/xuxzUJAMBsVU0MvXB7T0mSmb0wZNuWpIPo+clROw+JoGdmDwplAQAzVjUx/JGZ/Wu4+vldRc1A02BmLWW1jKvKRj21RxQBANSkaufz9TCRniRpxLTbfUkr4XFL2T0cRtlQ1lTVN7OepHVJSae1mW2E7fT8889XDBsAMK7KcyUVng+bRO+GoqkzJG1Lj2oFI7n7LZVcOOfuW+7ecffOqVOnKoYNABjX1CfRyzuOw8ijftSRHN8edF1SJ/xWGNK6YWbrZrbBcFUAaM44F7i9HWoI/64wid6gvoCyE7u7n4se35J0q7C+9HoHAMBsHXUSvUrNQwCAxTHOBW4PCpPobUh6UFtkAIBGVE0Mr+ajktz9bqgtPFtfWACApkza+fymss5nmpIAYMkc9Q5uD4eUAQAsIO7gBgBIHKXzmTu4AcASqlRjCBPoxZ3P3+IObgCwnKrWGGRmL5nZ98zs35R1PgMAltDAGkPoQ+gqu7/CeUk7kvaV3b2N2U8BYEkNa0r6U2WznN509xVJMrNXQrPS3VkEBwCYvYFNSe7+hrv/pqR3zex1M7so6UVp5I16AAALbGTns7vfVaghmNkZM/uGstlVX6w5NgBAA6pexyBJChe1fWRmDFMFgCVVeVRSzN3vjN4KALCIJkoMAIDlRWIAACRIDACABIkBAJAgMQAAEiQGAECCxAAASJAYAAAJEgMAIEFiAAAkSAwAgASJAQCQIDEAABIkBgBAgsQAAEiQGAAACRIDACBBYgAAJEgMAIAEiQEAkCAxAAASJAYAQOLJOnZqZuuS+pLW3P3agG3W3H0vfi6pLUnufquOuAAAo029xhBO8HL3bUn9/Hlhm66km4XFb4aE0C4rAwCYjTqaki4oqy1IUk9St7hBSBq9/HmoYXwQ1l2LaxIAgNmqIzG0JB1Ez09WKPOipJNmtmZml2uICQBQ0Tx1Pt/PawqhBpEwsw0z2zGznXv37s0+OgA4JupIDH1JK+FxS9L9CmXu67Bpqa+sBpFw9y1377h759SpU1MJFADwuDoSww2F0UXh97YkmVlrSJlbUZmWQn8DAGD2pp4YouagrqR+1JF8J98mNBV18iYjd+8pG8G0Lukkw1UBoDnm7k3HMLZOp+M7OztNhwEAC8XMdt29M2q7eep8BgDMARIDACBBYgAAJEgMAIAEiQEAkCAxAAASJAYAQILEAABIkBgAAAkSAwAgQWIAACRIDACABIkBAJAgMQAAEiQGAECCxAAASJAYAAAJEgMAIEFiAAAkSAwAgASJAQCQIDEAABIkBgBAgsQAAEiQGAAACRIDACBh7t50DGMzs/+W9GHTcQzxrKRPmg5iiHmOb55jk4jvqIjvaI4a32+4+6lRGz15hBdo0ofu3mk6iEHMbIf4JjPPsUnEd1TEdzSzio+mJABAgsQAAEgsamLYajqAEYhvcvMcm0R8R0V8RzOT+Bay8xkAUJ9FrTEAwEIzs3Uz65rZ5XHXx8vKthu171EaTwyTHBwz2wg/myO2O9LBmXJ8Zcs283VzEN9jsczL8TOzNTNzM9sPP9cHxTyj+Lrhp9bP3xRjm6fPXll88/TZS+Kr67NnZmuS5O7bkvr58yrrzawr6fyg7Ubtu4pGE8MkBycclG1335LUDn/EWg7OFON7bFnYxYaZ7UvqjRvbNOMri2Wejp+kFXc3d1+V9Kqk/KTS1PF7NSxbG/RZO+rxm2Js8/bZS+Iri6Xhz14xvlo+e5IuSOqHxz1J3THXD9uuatmBmq4xTHJw2tF2vfC8loMzxfjKlknSRXdfDR/ESUwrvrJY5ub4FY5Px93zf8aZHz9333b3S2FZ2933BuznqMdvWrHNzWdvQHxlsTTy2SuLr8bPXkvSQfT8ZJX1ZrZWeM2y7Ubte6SmL3Ab++C4+7Xo+ZqkG5LOleznyAdnWvFF/wBxzNLhN7i1QrmZxjcglrk5fvmTEN+70fqZH78olsuSLg3Z7qjHbyqxhZpCrtHPXll8A2Jp5LM3JL46PnuTWpnFizRdY5hYqObtFU66c6MsvuIyd78Wsv/JqIrfSHxNxlJmwN/3vLvn3/IajTmcDC6ZWWuWr1tFWWzz9Pcuxjdvn70Bf9tpf/b6OjzJtyTdH7W+pLYwaD+j9j1S04lh7IMTreu6+5Uh2x354EwxvseWWdYZuB6W39dhFX/m8Q2IZR6PX9wB18jxi/sPlDVBbAzYz1GP37RiyzX+2SuLb54+eyOO37Q/ezeicm1J22HfrSHr25Z1mG9IWgmxlm1Xuu9xNJ0YJjk4MrONvPoWsnUtB2eK8ZUt24liWg3Pm4qvLJZ5O37Ff76mjl9X6QmlN2C7ox6/acU2T5+9svjm6bM36PhN/bOX19zC36Mf1YzvDFrv7rfc/VYU36DtBu27skYTwyQHJzzetGzo2INB203j4EwrviExvxa+eew3GV9ZLPN0/CKPRoA0dfyUXXnaDt/aFP5Zp/75m1Zs8/TZK4tvnj57ZfFFu5zqZy/sZyt0eG9Fy84NWx8tX42aBcv2U1q2Kq58BgAkmm5KAgDMGRIDACDR9HUMAI6B0IHbUtbBe8sPLxTDHKLGgMosm97jgaVz2lw2s9tVxvObWdvMbtYb5cDXXi8MM8xj3wzrPKy/bGE+nCm+dq3vO8S8Hn4uh2VdM7s94f7Wa4h3TVkH7rak9RHbomEkBlQWLq55V+kVo3vK5pfpl5dKyvckXawpvFEuhBEa8dDHvrtfCaNPemEkxzVJu9N84eL7jpPTUYVRNfFQxtXwmts6nPJhLIXROFMR4usr1BimvX9MF4kB47qpbJ6ZXKtKUpAeNSdMcjHQ1BRiHTT+fJJx/QPF7zvUrM5PcffF/U21tjNNdjihH81Ic47EgLGEb6KlUwBEzTUb0fPbcROHDmenLNu+G7bvhuaR+GrTy2H5hpm14uclcWzE68J+2sVv6oPGn4frKR6LvWq8djh1cz6zbvy+O5I6hSatYrzJa4ff++F9J8084dt918x2zexy8T0NOJbF1xt2LHej7YvvqVTY5npodszfR1fSFWVTTdCUNO/cnR9+xvpR9q10XVmCaIVla5Iuh8e70bb74Xe+3c0R2++G321Jm+HxhqT18PiyspNsNzzfLMR2OVrXjV7j5oj3tD9ombJv5ePEG8fXLr6+pNsV4h143AbE31VWm7s+Irbi6/1tfGyjsjfD+vag9zQgjlYeQ/iMrDf9eeVn/B9qDJhE3pz0qBnJs2+qvfDNsNgHIS80Nw3ZPn6cO6dw5alnfQBtSa3wLbg4B86LOrxKtReeT+pR7GPGe1XSeTPbVZi6YIhB8RaP243wTTuZXTM0U8mzq1xfVdpUVxZb8fVeUHpsc21lM4zm8Vd9Txs6rB2taMJ+DjSLxICxeUlzUmiGWAnryuaX0RG231faRv+Bss7ifBqDWHzPgXbY9sjGjLfrWaf2OZU3u/XDPvKROiPj9azJ6JIevzFMtxDLqBNx8fX+Wemxjbe7qMOT/GPvacBItJN+2IdwzqPZQEMT0/qopig0j+sYMKniCJ+esrtedZV9210LJ6w1y6YL3gsnwnz5oO3bYbtuWNZy92uWDSuVlH2zDe3i+bfnR3G4+5WwTgpz5Uev2/XCtMXh5PZaeN3LCmPsQ1yPYh8nXkkv5rFKuhW/73DS7IVv/9sD4i2+du62P95xe5Bvq+wb+tXwvroDjmXx9X4/PrYh3q6yprOVsK/ryu5yFm/TUjZ6a7UQz/WQRA8UdYSH7c+H19/UZBPjYUaYKwmYc1FifSyxNSlKdFW2TTq2fcLJ3TAbNCUB8++Cma3PU1IIxrlJ0WpIBqtK74SGOUSNAUDtouGyK3OY4FBAYgAAJGhKAgAkSAwAgASJAQCQIDEAABIkBgBAgsQAAEiQGAAAif8HV5mSJcS5+AwAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Slope=0.24992735556376564, intercept=2.554920083325562, r_value=0.9999887157190909, p_value=1.3035255504050127e-45, std=0.0002723909104974136\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot transitory variance versus saving measures\n", + "plotReg(tVarList,savRteList_Tran,\n", + " xMin=tVarList[1]-0.001,xMax=tVarList[-1]+0.001,yMin=savRteList[1]-0.01,yMax=savRteList[-1]+0.01,\n", + " xLbl=r'Variance of Transitory Shocks, $\\sigma^{2}_{\\theta}$',\n", + " yLbl='Aggregate Saving Rate',\n", + " Title='Uncertainty vs Saving',\n", + " fileName='savRteVSTranShkVar'\n", + " )\n", + "plt.show(block=False)\n", + "plotReg(tVarList,KtoYList_Tran,\n", + " xMin=tVarList[1]-0.001,xMax=tVarList[-1]+0.001,yMin=savRteList[1]-0.01,yMax=KtoYList[-1]+0.1,\n", + " xLbl=r'Variance of Permanent Shocks, $\\sigma^{2}_{\\psi}$',\n", + " yLbl='Net Worth/Income',\n", + " Title='Uncertainty vs Net Worth Ratio',\n", + " fileName='BvsTranShkVar'\n", + " )\n", + "plt.show(block=False) " + ] + } + ], + "metadata": { + "cite2c": { + "citations": { + "6202365/7MR8GUVS": { + "DOI": "10.3982/QE694", + "URL": "https://onlinelibrary.wiley.com/doi/abs/10.3982/QE694", + "abstract": "In a model calibrated to match micro- and macroeconomic evidence on household income dynamics, we show that a modest degree of heterogeneity in household preferences or beliefs is sufficient to match empirical measures of wealth inequality in the United States. The heterogeneity-augmented model's predictions are consistent with microeconomic evidence that suggests that the annual marginal propensity to consume (MPC) is much larger than the roughly 0.04 implied by commonly used macroeconomic models (even ones including some heterogeneity). The high MPC arises because many consumers hold little wealth despite having a strong precautionary motive. Our model also plausibly predicts that the aggregate MPC can differ greatly depending on how the shock is distributed across households (depending, e.g., on their wealth, or employment status).", + "accessed": { + "day": 5, + "month": 2, + "year": 2019 + }, + "author": [ + { + "family": "Carroll", + "given": "Christopher" + }, + { + "family": "Slacalek", + "given": "Jiri" + }, + { + "family": "Tokuoka", + "given": "Kiichi" + }, + { + "family": "White", + "given": "Matthew N." + } + ], + "container-title": "Quantitative Economics", + "id": "6202365/7MR8GUVS", + "issue": "3", + "issued": { + "year": 2017 + }, + "language": "en", + "note": "Citation Key: carrollDistributionWealthMarginal2017", + "page": "977-1020", + "page-first": "977", + "title": "The distribution of wealth and the marginal propensity to consume", + "type": "article-journal", + "volume": "8" + } + } + }, + "jupytext": { + "formats": "ipynb,py:percent", + "text_representation": { + "extension": ".py", + "format_name": "percent", + "format_version": "1.1", + "jupytext_version": "0.8.3" + } + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.7" + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Documentation/notebooks/Untitled.ipynb b/Documentation/notebooks/Untitled.ipynb new file mode 100644 index 000000000..8aa9d8cb3 --- /dev/null +++ b/Documentation/notebooks/Untitled.ipynb @@ -0,0 +1,84 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Journey 2: Engineering background\n", + "\n", + "This is a second of the possible journeys into HARK - the Python package designed to solve economic models with the heterogeneous agents. As it is a \"journey\", it is not a one big tutorial, but a set of the links to the notebooks/other resources which will help you understand the different HARK objects and functionalities.\n", + "\n", + "This notebook was designed for users with some skill in programming. It does not require any knowledge of the economic theory - we are going to give you a very basic examples (which cannot substitute the macroeconomic textbooks if you want to learn theory more systematically, here we give you same examples: ) \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Microeconomic agent-type problems\n", + "\n", + "In the economic analysis, one of the most used problems are \"consumers problems\" which are designed to model the consumer choices. In this class of problems consumers need to find the optimal set of goods given her resources. In the basic formulation of the problem there is only one good but can be consumed in different time periods (let us denote it by $C_t$, where $0\\leq t\\leq T\\leq \\infty$ denotes periods). Consumer receives some resources $w_t$ (think wages), which she can invest with interest rate $R$ (denote the investments by $A_t$) or consume. The utility of the consumption in the period $t=0$ is given by function $U()$, for the next periods it is given by the function $\\beta^t U ()$ as consumer prefer consumption now then in the future, $\\beta<1$. The consumption problem can be then formalize by the maximization problem:\n", + "\n", + "\\begin{eqnarray*}\n", + " \\max_{C_t}& \\sum_{t=0}^T \\beta^t U(C_t)\n", + "\\end{eqnarray*}\n", + "\n", + "With the condition in each t:\n", + "\\begin{eqnarray*}\n", + "C_t + A_{t+1} = w_t+RA_t \n", + "\\end{eqnarray*}\n", + "\n", + "U is typically assumed to be a constant risk aversion function:\n", + "$$\n", + "U(C)=\\frac{C^{1-\\rho}}{1-\\rho}\n", + "$$\n", + "\n", + "As you see, the following problem enables to analyze the consumer's saving decisions. Obviously, the complexity of the problem depends on the $w_t$, if it is deterministic it is much easier to track down than in case if $w_t$ is given by a stochastic process. \n", + "\n", + "|Number | Tutorial | Description|\n", + "| :---- | :---- | :---- |\n", + "|1 |[Gentle_intro_I](../notebooks/Quickstart_tutorial/Gentle-Intro-To-HARK-PerfForesightCRRA.ipynb) |Here is your first tutorial in HARK, to solve the case when $w_t$ is deterministic|\n", + "|2 |[Gentle_intro_II](../notebooks/Gentle-Intro-To-HARK-Buffer-Stock-Model.ipynb) |The notebook concerning the case when $w_t$ follows the idiosyncratic AR process| \n", + "|3|[Chinese-Growth](../notebooks/Chinese-Growth.ipynb.ipynb)|The third notebook concern the case when $w_t$|\n", + "\n", + "\n", + "O\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Documentation/notebooks/Untitled1.ipynb b/Documentation/notebooks/Untitled1.ipynb new file mode 100644 index 000000000..a749437ec --- /dev/null +++ b/Documentation/notebooks/Untitled1.ipynb @@ -0,0 +1,85 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import sys \n", + "import os\n", + "\n", + "sys.path.insert(0, os.path.abspath('..'))\n", + "\n", + "\n", + "prob_dead = np.genfromtxt('life_table.csv', delimiter=',', skip_header =1)\n", + "prob_surv = 1 - prob_dead\n", + "prob_surv_list= np.ndarray.tolist(prob_surv[:80])\n", + "\n", + "income_profile = np.genfromtxt('productivity_profile.csv', delimiter=',', skip_header =1)\n", + "income_profile_list=np.ndarray.tolist(income_profile[:80])\n", + "\n", + "Ex_dictionary = {\n", + " 'CRRA' : 2.0,\n", + " 'Rfree' : 1.05,\n", + " 'DiscFac' : 0.99,\n", + " 'LivPrb' : prob_surv_list,\n", + " 'PermGroFac' : income_profile_list,\n", + " 'cycles' : 1,\n", + " 'T_cycle' : 1,\n", + "}\n", + "\n", + "Ex_agent = PerfForesightConsumerType(**Ex_dictionary)\n", + "Ex_agent.solve()\n", + "\n", + "Ex_agent.unpackcFunc()\n", + "\n", + "min_v = min(Ex_agent.solution[t].mNrmMin for t in range(11) )\n", + "max_v = -min_v\n", + "print(\"Consumption functions\")\n", + "plotFuncs(Ex_agent.cFunc[:],min_v,max_v)\n", + "\n", + "\n", + "Simulation_dictionary = { 'AgentCount': 1000,\n", + " 'aNrmInitMean' : -10.0,\n", + " 'aNrmInitStd' : 0.0,\n", + " 'pLvlInitMean' : 0.0,\n", + " 'pLvlInitStd' : 0.05,\n", + " 'PermGroFacAgg' : 1.0,\n", + " 'T_cycle' : 1,\n", + " 'T_sim' : 2000,\n", + " 'T_age' : 80,\n", + " 'BoroCnstArt' : 0.0, \n", + " }\n", + "\n", + "for key,value in Simulation_dictionary.items():\n", + " setattr(Ex_agent,key,value)\n", + "\n", + "Ex_agent.track_vars = ['aNrmNow','cNrmNow', 'aLvlNow']\n", + "Ex_agent.initializeSim()\n", + "Ex_agent.simulate()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}