Generator: QuARK-make/notebooks_byname
" ] }, { "cell_type": "code", "execution_count": 1, "id": "cb263dbc", "metadata": {}, "outputs": [], "source": [ "# Initial imports and notebook setup, click arrow to show\n", "\n", "from HARK.distribution import Uniform\n", "from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n", "import matplotlib.pyplot as plt\n", "\n", "# Import some things from cstwMPC\n", "\n", "from tqdm import tqdm\n", "\n", "import numpy as np\n", "from copy import deepcopy\n", "\n", "from HARK.utilities import plot_funcs" ] }, { "cell_type": "markdown", "id": "182b8dcd", "metadata": {}, "source": [ "### There Was a Big Drop in Consumption ...\n", "Between the second and fourth quarters of 2008, \"discretionary\" spending on nondurables and services in the U.S. dropped by about 4 percent -- an unprecedented collapse. Subsequent analyses of the Great Recession concluded that it was the large drop in consumption expenditures that turned what would otherwise have been a moderate downturn into the largest economic decline since the Great Depresssion.\n", "\n", "" ] }, { "cell_type": "markdown", "id": "17765b7b", "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 4 percent drop in discretionary 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 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/saving 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, "id": "67f13cae", "metadata": {}, "outputs": [], "source": [ "# Choose some calibrated parameters that roughly match steady state\n", "init_infinite = {\n", " \"CRRA\": 1.0, # Coefficient of relative risk aversion\n", " \"Rfree\": 1.01 / (1.0 - 1.0 / 240.0), # Survival probability,\n", " # Permanent income growth factor (no perm growth),\n", " \"PermGroFac\": [1.000**0.25],\n", " \"PermGroFacAgg\": 1.0,\n", " \"BoroCnstArt\": 0.0,\n", " \"CubicBool\": False,\n", " \"vFuncBool\": False,\n", " \"PermShkStd\": [\n", " (0.01 * 4 / 11) ** 0.5\n", " ], # Standard deviation of permanent shocks to income\n", " \"PermShkCount\": 7, # Number of points in permanent income shock grid\n", " \"TranShkStd\": [\n", " (0.01 * 4) ** 0.5\n", " ], # 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\": 0.07,\n", " \"IncUnempRet\": 0.15,\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 / 240.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", " # Number of periods to simulate (idiosyncratic shocks model, perpetual youth)\n", " \"T_sim\": 2000,\n", " \"T_age\": 1000,\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", "id": "832ddfbc", "metadata": {}, "source": [ "Now we import the class itself and make a baseline type." ] }, { "cell_type": "code", "execution_count": 3, "id": "b9742cc1", "metadata": {}, "outputs": [], "source": [ "BaselineType = IndShockConsumerType(**init_infinite)" ] }, { "cell_type": "markdown", "id": "725e0162", "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, "id": "e3e0551a", "metadata": {}, "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", "id": "367addbd", "metadata": {}, "source": [ "Now we can give each of the consumer types their own discount factor. (This approximates the distribution of parameters estimated in [\"The Distribution of Wealth and the Marginal Propensity to Consume\"](https://www.econ2.jhu.edu/people/ccarroll/papers/cstwMPC))." ] }, { "cell_type": "code", "execution_count": 5, "id": "eee39fab", "metadata": {}, "outputs": [], "source": [ "# Seven types is enough to approximate the uniform distribution (5 is not quite enough)\n", "\n", "# Calibrations from cstwMPC\n", "bottomDiscFac = 0.9800\n", "topDiscFac = 0.9934\n", "DiscFac_list = (\n", " Uniform(bot=bottomDiscFac, top=topDiscFac)\n", " .discretize(N=num_consumer_types)\n", " .atoms.flatten()\n", ")\n", "\n", "# Now, assign the discount factors\n", "for j in range(num_consumer_types):\n", " ConsumerTypes[j].DiscFac = DiscFac_list[j]\n", " ConsumerTypes[j].quiet = True # Turn off some output" ] }, { "cell_type": "markdown", "id": "e79b90b0", "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, "id": "0ae58afc", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:37<00:00, 5.35s/it]\n" ] } ], "source": [ "# tqdm presents a pretty bar that interactively shows how far the calculations have gotten\n", "for ConsumerType in tqdm(ConsumerTypes):\n", " # We configured their discount factor above. Now solve\n", " ConsumerType.solve(verbose=False)\n", "\n", " # Now simulate many periods to get to the stationary distribution\n", " ConsumerType.T_sim = 2000\n", " ConsumerType.initialize_sim()\n", " ConsumerType.simulate()" ] }, { "cell_type": "markdown", "id": "98ad3736", "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, "id": "2addf79c", "metadata": {}, "outputs": [], "source": [ "# We just merge the cNrm and pNrm lists already constructed for each ConsumerType\n", "\n", "\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.controls[\"cNrm\"] for ThisType in ConsumerTypes])\n", " pLvl = np.concatenate([ThisType.state_now[\"pLvl\"] 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", "id": "a3815276", "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\n", " * hold the changes in consumption that happen after parameters change, and\n", " * calculate average consumption before the change in uncertainty\n", "2. Loop through the new uncertainty parameter values to assign. For each:\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 popn of agents distributed in the pre-crisis steady state\n", " 4. Simulate one more period-- the first period after the change in risk.\n", " 5. Calculate the popn avg C level given the new consumption rule\n", " 6. Calculate the new average consumption level as percentage change vs the prior level.\n", " 7. Return the list of percentage changes" ] }, { "cell_type": "code", "execution_count": 8, "id": "7d76b40c", "metadata": {}, "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 tqdm(NewVals):\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.update_income_process()\n", " ConsumerTypeNew.solve() # Step 2B\n", "\n", " ConsumerTypeNew.initialize_sim() # Step 2C\n", " ConsumerTypeNew.aNrm = OriginalTypes[index].state_now[\"aNrm\"]\n", " ConsumerTypeNew.pLvl = OriginalTypes[index].state_now[\"pLvl\"]\n", "\n", " ConsumerTypeNew.sim_one_period() # Step 2D\n", "\n", " NewAvgC = calcAvgC(ConsumerTypesNew) # Step 2E\n", " ChangeInConsumption = 100.0 * (NewAvgC - OldAvgC) / OldAvgC # Step 2F\n", " ChangesInConsumption.append(ChangeInConsumption)\n", "\n", " return ChangesInConsumption # Step 3, returning the output" ] }, { "cell_type": "markdown", "id": "d9a92185", "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, "id": "baac89df", "metadata": {}, "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", "\n", "def calcConsChangeAfterTranShkChange(newVals):\n", " return calcConsChangeAfterUncertaintyChange(ConsumerTypes, newVals, \"TranShkStd\")\n", "\n", "\n", "def calcConsChangeAfterUnempPrbChange(newVals):\n", " return calcConsChangeAfterUncertaintyChange(ConsumerTypes, newVals, \"UnempPrb\")" ] }, { "cell_type": "markdown", "id": "3f6d8cd0", "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, "id": "cbf7dd85-62bb-4002-a735-99b14373e0a2", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [01:06<00:00, 6.68s/it]\n" ] }, { "data": { "image/png": "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", "text/plain": [ "