From 4ffd9713d6630f5bc332a4ec7c5336cdd3e76f69 Mon Sep 17 00:00:00 2001 From: "Matthew N. White" Date: Fri, 27 Feb 2026 19:29:30 -0500 Subject: [PATCH 1/3] Begin work on AggShock notebooks Also made the solver run 5x faster by changing one line. --- HARK/ConsumptionSaving/ConsAggShockModel.py | 114 ++-- .../AggShockConsumerType.ipynb | 640 ++++++------------ .../AggShockMarkovConsumerType.ipynb | 227 +++++++ 3 files changed, 488 insertions(+), 493 deletions(-) create mode 100644 examples/ConsAggShockModel/AggShockMarkovConsumerType.ipynb diff --git a/HARK/ConsumptionSaving/ConsAggShockModel.py b/HARK/ConsumptionSaving/ConsAggShockModel.py index 8023bbd20..eb4503439 100644 --- a/HARK/ConsumptionSaving/ConsAggShockModel.py +++ b/HARK/ConsumptionSaving/ConsAggShockModel.py @@ -31,7 +31,7 @@ MarkovProcess, MeanOneLogNormal, Uniform, - calc_expectation, + expected, combine_indep_dstns, ) from HARK.interpolation import ( @@ -188,7 +188,6 @@ def solveConsAggShock( AFunc, Rfunc, wFunc, - DeprRte, ): """ Solve one period of a consumption-saving problem with idiosyncratic and @@ -231,8 +230,6 @@ def solveConsAggShock( The net interest factor on assets as a function of capital ratio k. wFunc : function The wage rate for labor as a function of capital-to-labor ratio k. - DeprRte : float - Capital Depreciation Rate Returns ------- @@ -296,9 +293,7 @@ def vPnextFunc(S, a, M): # Compute end-of-period marginal value of assets MaggNow = np.tile(np.reshape(Mgrid, (1, Mcount)), (aCount, 1)) # Tiled Mgrid - EndOfPrdvP = ( - DiscFac * LivPrb * calc_expectation(IncShkDstn, vPnextFunc, *(aNrmNow, MaggNow)) - ) + EndOfPrdvP = DiscFac * LivPrb * expected(vPnextFunc, IncShkDstn, (aNrmNow, MaggNow)) # Calculate optimal consumption from each asset gridpoint and endogenous m_t gridpoint cNrmNow = EndOfPrdvP ** (-1.0 / CRRA) @@ -406,8 +401,6 @@ def solve_ConsAggMarkov( The net interest factor on assets as a function of capital ratio k. wFunc : function The wage rate for labor as a function of capital-to-labor ratio k. - DeprRte : float - Capital Depreciation Rate Returns ------- @@ -836,7 +829,7 @@ class AggShockConsumerType(IndShockConsumerType): "track_vars": ["aNrm", "cNrm", "mNrm", "pLvl"], } time_inv_ = IndShockConsumerType.time_inv_.copy() - time_inv_ += ["Mgrid", "AFunc", "Rfunc", "wFunc", "DeprRte", "PermGroFacAgg"] + time_inv_ += ["Mgrid", "AFunc", "Rfunc", "wFunc", "PermGroFacAgg"] try: time_inv_.remove("vFuncBool") time_inv_.remove("CubicBool") @@ -849,7 +842,6 @@ class AggShockConsumerType(IndShockConsumerType): "AFunc", "Rfunc", "wFunc", - "DeprRte", "PermGroFacAgg", "AggShkDstn", ] @@ -1220,7 +1212,17 @@ def make_assets_grid_KS(aMin, aMax, aCount, aNestFac): def make_KS_transition_arrays( - aGrid, Mgrid, AFunc, LbrInd, UrateB, UrateG, ProdB, ProdG, MrkvIndArray + aGrid, + Mgrid, + AFunc, + LbrInd, + UrateB, + UrateG, + ProdB, + ProdG, + MrkvIndArray, + CapShare, + DeprRte, ): """ Construct the attributes ProbArray, mNextArray, MnextArray, and RnextArray, @@ -1248,6 +1250,10 @@ def make_KS_transition_arrays( TFP in the "good" aggregate state. MrkvIndArray : np.array Markov transition probabilities from the perspective of the individual. + CapShare : float + Capital's share of production. + DeprRte : float + Capital depreciation rate. Returns ------- @@ -1651,52 +1657,24 @@ def get_poststates(self): ############################################################################### -CRRA = 2.0 -DiscFac = 0.96 - -# Parameters for a Cobb-Douglas economy -PermGroFacAgg = 1.00 # Aggregate permanent income growth factor -PermShkAggCount = ( - 3 # Number of points in discrete approximation to aggregate permanent shock dist -) -TranShkAggCount = ( - 3 # Number of points in discrete approximation to aggregate transitory shock dist -) -PermShkAggStd = 0.0063 # Standard deviation of log aggregate permanent shocks -TranShkAggStd = 0.0031 # Standard deviation of log aggregate transitory shocks -DeprRte = 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 -# Damping factor when updating AFunc; puts DampingFac weight on old params, rest on new -DampingFac = 0.5 -max_loops = 20 # Maximum number of AFunc updating loops to allow - - # Make a dictionary to specify a Cobb-Douglas economy init_cobb_douglas = { - "PermShkAggCount": PermShkAggCount, - "TranShkAggCount": TranShkAggCount, - "PermShkAggStd": PermShkAggStd, - "TranShkAggStd": TranShkAggStd, - "DeprRte": DeprRte, - "CapShare": CapShare, - "DiscFac": DiscFacPF, - "CRRA": CRRAPF, - "PermGroFacAgg": PermGroFacAgg, + "PermShkAggCount": 3, # Number of points in discrete approximation to aggregate permanent shock dist + "TranShkAggCount": 3, # Number of points in discrete approximation to aggregate transitory shock dist + "PermShkAggStd": 0.0063, # Standard deviation of log aggregate permanent shocks + "TranShkAggStd": 0.0031, # Standard deviation of log aggregate transitory shocks + "DeprRte": 0.025, # Capital depreciation rate + "CapShare": 0.36, # Capital's share of income + "DiscFac": 0.96, # Discount factor of perfect foresight calibration + "CRRA": 2.0, # Coefficient of relative risk aversion of perfect foresight calibration + "PermGroFacAgg": 1.0, # Aggregate permanent income growth factor "AggregateL": 1.0, - "intercept_prev": intercept_prev, - "slope_prev": slope_prev, - "verbose": verbose_cobb_douglas, - "T_discard": T_discard, - "DampingFac": DampingFac, - "max_loops": max_loops, + "intercept_prev": 0.0, # Intercept of aggregate savings function + "slope_prev": 1.0, # Slope of aggregate savings function, + "verbose": 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 + "max_loops": 20, # Maximum number of AFunc updating loops to allow } @@ -2014,6 +1992,25 @@ def calc_AFunc(self, MaggNow, AaggNow): return AggShocksDynamicRule(AFunc) +# Make a dictionary to specify a small open economy +init_small_open_economy = { + "PermShkAggCount": 3, # Number of points in discrete approximation to aggregate permanent shock dist + "TranShkAggCount": 3, # Number of points in discrete approximation to aggregate transitory shock dist + "PermShkAggStd": 0.0063, # Standard deviation of log aggregate permanent shocks + "TranShkAggStd": 0.0031, # Standard deviation of log aggregate transitory shocks + "Rfree": 1.02, # exogenous and fixed return factor on assets + "wRte": 1.0, # exogenous and fixed wage rate + "PermGroFacAgg": 1.0, # Aggregate permanent income growth factor + "AggregateL": 1.0, + "intercept_prev": 0.0, # Intercept of aggregate savings function + "slope_prev": 1.0, # Slope of aggregate savings function, + "verbose": 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 + "max_loops": 1, # Maximum number of AFunc updating loops to allow, should always be 1 +} + + class SmallOpenEconomy(Market): """ A class for representing a small open economy, where the wage rate and interest rate are @@ -2034,6 +2031,8 @@ class SmallOpenEconomy(Market): def __init__(self, agents=None, tolerance=0.0001, act_T=1000, **kwds): agents = agents if agents is not None else list() + params = init_small_open_economy.copy() + params.update(**kwds) Market.__init__( self, agents=agents, @@ -2052,6 +2051,7 @@ def __init__(self, agents=None, tolerance=0.0001, act_T=1000, **kwds): distributions=["PermShkAggDstn", "TranShkAggDstn", "AggShkDstn"], tolerance=tolerance, act_T=act_T, + **params, ) self.assign_parameters(**kwds) self.update() @@ -2230,8 +2230,8 @@ def get_AggShocks(self): init_mrkv_cobb_douglas["PermGroFacAgg"] = [0.98, 1.02] init_mrkv_cobb_douglas["MrkvArray"] = MrkvArray init_mrkv_cobb_douglas["MrkvInit"] = 0 -init_mrkv_cobb_douglas["slope_prev"] = 2 * [slope_prev] -init_mrkv_cobb_douglas["intercept_prev"] = 2 * [intercept_prev] +init_mrkv_cobb_douglas["slope_prev"] = 2 * [0.0] +init_mrkv_cobb_douglas["intercept_prev"] = 2 * [1.0] class CobbDouglasMarkovEconomy(CobbDouglasEconomy): diff --git a/examples/ConsAggShockModel/AggShockConsumerType.ipynb b/examples/ConsAggShockModel/AggShockConsumerType.ipynb index f8257e819..ea72fdc42 100644 --- a/examples/ConsAggShockModel/AggShockConsumerType.ipynb +++ b/examples/ConsAggShockModel/AggShockConsumerType.ipynb @@ -21,19 +21,16 @@ }, "outputs": [], "source": [ - "from time import process_time\n", + "from time import time\n", "\n", "import matplotlib.pyplot as plt\n", - "import numpy as np\n", "\n", "from HARK.ConsumptionSaving.ConsAggShockModel import (\n", " AggShockConsumerType,\n", - " AggShockMarkovConsumerType,\n", " CobbDouglasEconomy,\n", - " CobbDouglasMarkovEconomy,\n", + " SmallOpenEconomy,\n", ")\n", - "from HARK.distributions import DiscreteDistribution\n", - "from HARK.utilities import plot_funcs\n", + "from HARK.utilities import plot_funcs, plot_func_slices\n", "\n", "\n", "def mystr(number):\n", @@ -41,8 +38,130 @@ ] }, { - "cell_type": "code", - "execution_count": 2, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Most `AgentType` subclasses in HARK are fully \"microeconomic\" models in the sense that they concern the decisions of agents under uncertainty, but with no economy-wide interaction among the agents. In particular, objects like the return factor on retained assets are treated as *exogenous*, and we often omit the wage rate entirely (implicitly normalizing it to 1).\n", + "\n", + "The `AgentType` subclasses in `ConsAggShockModel`, in contrast, are designed to be used with subclasses of `Market` and solved in *dynamic stochastic general equilibrium* (DSGE), or more accurately HA-DSGE. For a primer on the `Market` class generally, see the [notebook here](../../Gentle-Intro/Market-Intro.ipynb).\n", + "\n", + "This notebook concerns `AggShockConsumerType`, representing agents in the canonical consumption-saving framework with labor income risk. Unlike other `AgentType` subclasses that face only idiosyncratic income shocks, `AggShockConsumerType`s are *also* subject to aggregate productivity shocks, both permanent and transitory. Moreover, these agents can be embedded in a `CobbDouglasEconomy` in which the interest and wage factors are determined endogenously based on the ratio of aggregate labor and capital." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Microeconomic Model Statement for `AggShockConsumerType`\n", + "\n", + "`AggShockConsumerType` extends `IndShockConsumerType` by incorporating a second continuous state variable (aggregate market resources $M_t$) as well as two additional shocks: permanent $\\Psi$ and transitory $\\Theta$ shocks to aggregate productivity. Because some objects are idiosyncratic (varying across individuals) and others are aggregate, we explicitly include the $i$ subscript to indicate idiosyncratic values." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\\begin{eqnarray*}\n", + "\\text{v}(m_{it}, M_t) &=& \\max_{c_{it}} \\frac{c_{it}^{1-\\rho}}{1-\\rho} + \\beta \\mathsf{S} \\mathbb{E} \\left[ (\\psi_{it+1} \\Psi_{t+1})^{1-\\rho} \\text{v}(m_{it+1}, M_{t+1}) \\right] \\\\\n", + "&\\text{s.t.}& \\\\\n", + "a_{it} &=& m_{it} - c_{it} \\geq \\underline{a}, \\\\\n", + "A_{t} &=& \\mathbf{A}(M_{it}), \\\\\n", + "K_{t+1} &=& A_t, \\\\\n", + "k_{t+1} &=& K_t / \\Psi_{t+1}, \\\\\n", + "\\mathsf{R}_{t+1} &=& \\mathbf{R}(k_{t+1} / \\Theta_{t+1}), \\\\\n", + "\\mathsf{w}_{t+1} &=& \\mathbf{W}(k_{t+1} / \\Theta_{t+1}), \\\\\n", + "m_{it+1} &=& \\mathsf{R}_{t+1} a_{t} / (\\psi_{it+1} \\Psi_{t+1}) + \\mathsf{w}_{t+1} \\theta_{it+1} \\Theta_{t+1}, \\\\\n", + "M_{t+1} &=& \\mathsf{R}_{t+1} k_{t+1} + \\mathsf{w}_{t+1} \\Theta_{t+1}, \\\\\n", + "(\\psi_{it+1}, \\theta_{it+1}) &\\sim& F, \\\\\n", + "(\\Psi_{t+1}, \\theta_{t+1}) &\\sim& \\Phi.\n", + "\\end{eqnarray*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Much of this model is identical to the workhorse `IndShockConsumerType` model, but with substantial additions and changes. Capitalized and serifed variables represent aggregate normalized variables; e.g. $M_t$ is aggregate market resources normalized by aggregate permanent productivity.\n", + "\n", + "Aggregate capital next period $K_{t+1}$ is simply aggregate retained assets $A_t$. The aggregate productivity shocks $(\\Psi, \\Theta)$ are assumed to affect effective labor, which is inelastically supplied. The ratio of aggregate capital to aggregate *permanent* labor productivity is thus denoted as $k_t$.\n", + "\n", + "The interest $\\mathsf{R}$ and wage $\\mathsf{w}$ factors are determined as functions of the aggregate capital-to-labor ratio (incorporating the transitory aggregate shock as well). At both the individual and aggregate level, next period's market resources are the sum of capital and labor income.\n", + "\n", + "We denote the aggregate productivity shock distribution as $\\Phi$, which does *not* stand for the standard normal distribution." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model Statement for a `CobbDouglasEconomy` \n", + "\n", + "A careful reader will notice that we have not specified *how* the aggregate capital-to-labor ratio determines the interest factor and wage rate. Moreover, we also did not mention the aggregate savings function $\\mathbf{A}(M_t)$ at all. This was intentional, because there are (at least) two possibilities. An `AggShockConsumerType` instance can't be meaningfully solved outside of some `Market` that it lives in, and how aggregate capital and labor determine factor prices is an activity at the `Market`-level.\n", + "\n", + "An instance of `CobbDouglasEconomy`, a subclass of `Market` represents an economy in which capital and labor are used to produce output with a Cobb-Douglas technology, and factor prices are determined competitively via the marginal product of each factor. We denote capital's share of production `CapShare` as $\\alpha$ and the depreciation rate of capital `DeprRte` as $\\delta$.\n", + "\n", + "The interest factor and wage rate can thus be determined from aggregate capital and labor as follows:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\\begin{eqnarray*}\n", + "Y &=& K^\\alpha L^{1-\\alpha}, \\\\\n", + "\\mathsf{w} &=& \\frac{\\partial Y}{\\partial L} = (1-\\alpha) K^\\alpha L^{-\\alpha} = (1-\\alpha) k^{\\alpha}, \\\\\n", + "\\mathsf{r} &=& \\frac{\\partial Y}{\\partial K} = \\alpha K_{t}^{\\alpha-1} L_t^{1-\\alpha} = \\alpha k^{1-\\alpha}, \\\\\n", + "\\mathsf{R} &=& 1 - \\delta + \\mathsf{r}.\n", + "\\end{eqnarray*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the last line, the return factor on capital represents the individual retaining their capital, less depreciation, and being paid the gross interest rate $\\mathsf{r}$ for it. These expressions are used as the functional forms for $\\mathbf{R}$ and $\\mathbf{W}$ above.\n", + "\n", + "Following Krusell \\& Smith (1998), we parameterize the aggregate saving function $\\mathbf{A}(M_{it})$ as linear in logs:\n", + "\n", + "\\begin{equation*}\n", + "A_{it} = \\mathbf{A}(M_{it}) = \\exp(\\kappa_1 \\log(M_{it}) + \\kappa_0).\n", + "\\end{equation*}\n", + "\n", + "This function represents the agents' *parameterized beliefs* about aggregate behavior, rather than true dynamics. It is used by agents when *solving* their microeconomic model to form expectations about future resources (through factor prices), representing a form of bounded rationality: future factor prices depend on *all consumers'* financial position, but the agents only account for the aggregate quantity when making their projection, and then only with a parametric relationship." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The microeconomic model can be solved for *any* such subjective beliefs, but the goal of solving the model in general equilibrium is to find beliefs that are *consistent*: if agents' act optimally given those beliefs about aggregate saving, then the relationship between $M_{t}$ and $A_{t}$ that emerges in the long run is *well approximated by* those same beliefs.\n", + "\n", + "In the terminology of HARK's `Market` class, the only element of `dyn_vars` is `AFunc`, the aggregate saving function, which is characterized by the two coefficients $\\kappa_0$ and $\\kappa_1$. When a `CobbDouglasEconomy` instance has its `solve` method invoked, it executes the following in a loop:\n", + "\n", + "0) Begin with arbitrary initial $\\kappa_0$ and $\\kappa_1$\n", + "1) Agents solve their microeconomic model given beliefs\n", + "2) Simulate market for many periods, generating history of $(M_t, A_t)$\n", + "3) Linearly regress $\\log A_t$ on $\\log M_t$ to generate new $\\kappa_0$ and $\\kappa_1$\n", + "4) If new coefficients are not sufficiently close to old ones, go to step 1\n", + "\n", + "During the simulation, the agents observe the true $M_t$ in each period. Their subjective beliefs are used only when *solving* the model, not when simulating it." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Keeping it Simple: `SmallOpenEconomy`\n", + "\n", + "As an alternative to `CobbDouglasEconomy`, you might instead be interested in an environment in which factor prices do *not* fluctuate with aggregate capital and labor (say, because capital is mobile and thus prices are determined by global factors), but there are still aggregate productivity shocks. HARK handles this with the `SmallOpenEconomy` subclass of `Market`.\n", + "\n", + "The mechanics of a `SmallOpenEconomy` are simple: the user provides a *fixed* `Rfree` and `wRte` (as well as the `AggShkDstn`) and the functions $\\mathbf{R}(\\cdot)$ and $\\mathbf{W}(\\cdot)$ are specified as `ConstantFunctions` with those values. The aggregate saving function $\\mathsf{A}(M_t)$ is *irrelevant* because the agents know that their future state does not depend on the aggregate state at all; it's arbitrarily specified as the identity function. With a `SmallOpenEconomy`, the agents' microeconomic problem thus only needs to be solved *once*, rather than iterated on to find equilibrium beliefs about aggregate saving.\n", + "\n", + "Put differently, the *structure* of the microeconomic problem is identical whether `CobbDouglasEconomy` or `SmallOpenEconomy` is used, but some details are simplified and trivialized under the latter." + ] + }, + { + "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { @@ -50,24 +169,13 @@ }, "tags": [] }, - "outputs": [], "source": [ - "# Solve an AggShockConsumerType's microeconomic problem\n", - "solve_agg_shocks_micro = False\n", - "# Solve for the equilibrium aggregate saving rule in a CobbDouglasEconomy\n", - "solve_agg_shocks_market = True\n", - "# Solve an AggShockMarkovConsumerType's microeconomic problem\n", - "solve_markov_micro = False\n", - "# Solve for the equilibrium aggregate saving rule in a CobbDouglasMarkovEconomy\n", - "solve_markov_market = True\n", - "# Solve a simple Krusell-Smith-style two state, two shock model\n", - "solve_krusell_smith = True\n", - "# Solve a CobbDouglasEconomy with many states, potentially utilizing the \"state jumper\"\n", - "solve_poly_state = False" + "## Example implementations of `AggShockConsumerType`" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 2, "metadata": { "editable": true, "slideshow": { @@ -75,8 +183,21 @@ }, "tags": [] }, + "outputs": [], "source": [ - "### Example implementation of AggShockConsumerType" + "# Make an aggregate shocks consumer type\n", + "AggShockExample = AggShockConsumerType(cycles=0)\n", + "AggShockExampleAlt = AggShockConsumerType(cycles=0, MaggCount=3)\n", + "\n", + "# Make a Cobb-Douglas economy for the agents\n", + "CobbDouglasExample = CobbDouglasEconomy(agents=[AggShockExample])\n", + "CobbDouglasExample.make_AggShkHist() # Simulate a history of aggregate shocks\n", + "CobbDouglasExample.give_agent_params() # Have agents collect market-level parameters and construct themselves\n", + "\n", + "# Make a small open economy for the agents\n", + "SOEexample = SmallOpenEconomy(agents=[AggShockExampleAlt])\n", + "SOEexample.make_AggShkHist() # Simulate a history of aggregate shocks\n", + "SOEexample.give_agent_params() # Have agents collect market-level parameters and construct themselves" ] }, { @@ -89,17 +210,23 @@ }, "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a small open economy took 9.7542 seconds.\n" + ] + } + ], "source": [ - "if solve_agg_shocks_micro or solve_agg_shocks_market:\n", - " # Make an aggregate shocks consumer type\n", - " AggShockExample = AggShockConsumerType()\n", - " AggShockExample.cycles = 0\n", - "\n", - " # Make a Cobb-Douglas economy for the agents\n", - " EconomyExample = CobbDouglasEconomy(agents=[AggShockExample])\n", - " EconomyExample.make_AggShkHist() # Simulate a history of aggregate shocks\n", - " EconomyExample.give_agent_params() # Have agents collect market-level parameters and construct themselves" + "# Solve the small open economy with the default parameters\n", + "t_start = time()\n", + "SOEexample.solve()\n", + "t_end = time()\n", + "print(\n", + " \"Solving a small open economy took \" + mystr(t_end - t_start) + \" seconds.\",\n", + ")" ] }, { @@ -112,32 +239,24 @@ }, "tags": [] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAG0CAYAAADTmjjeAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAATS1JREFUeJzt3Qd4lFX69/Gb9EISUiAhEDqIQAhICSjYQFnXxbauLKuAoL5/WTs2UMGCK/a2FhbWuquC6wrWRQVBVJr03sGEkgrppM973SdkzIQAKUNmMs/3c11jZp5pZ5Lg88s59zmnmc1mswkAAICFebm6AQAAAK5GIAIAAJZHIAIAAJZHIAIAAJZHIAIAAJZHIAIAAJZHIAIAAJZHIAIAAJbnIxZXXl4uhw4dkpCQEGnWrJmrmwMAAGpB15XOzc2V2NhY8fJqeP+O5QORhqG4uDhXNwMAANRDcnKytG3bVhrK8oFIe4Yqv6GhoaGubg4AAKiFnJwc06FReR5vKMsHosphMg1DBCIAAJoWZ5W7UFQNAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsj0AEAAAsz/KbuwIAgKYlNadQFm045NTXJBABAAC3lp5bJCv2ZsryvZmyYk+m7M3Il/KiAqe+B4EIAAC4laP5xfYAtHxPpuxKy3O436uZyNmxoZLsxPckEAEAAJfKPlYiq/YdkWV7MkwA2p6Se8Jjzm4dKoM7Rcq5nSNlQMcIaVZyTMIecF4bCEQAAKBR5RWVyi/7jth7gLYcypZym+NjukU3NwFocOdISewYKeHBfg7355Qcc2qbCEQAAOCMKiguldX7j9oD0KaD2VJWLQF1igo24UcvgzpFSlRzf2lMBCIAAOBUhSVlsvbX3wLQhgNZUlLmGIDaRQTZe4D0Eh0aIK5EIAIAAA1SXFou65OzTPhZvjdD1iZlmWNVtWkRaHp+KgOQ3nYnBCIAAFAnJWXlsvFAdsVMsD2ZsvrXI1JY4hiAWoX4m+CjRdCDO0VJXESgNGvWTNwVgQgAAJyS1vtsPphtHwJbvf+I5BeXOTwmMthPBpnwU9EDpDVB7hyA3DoQLV26VJ577jlZs2aNHD58WObNmydXXXVVrZ77888/ywUXXCC9evWS9evXn/G2AgDgqcrLbbItJceEH+0FWrnviOQWljo8pkWQrwzq+NsQWNdWzZtUAHLrQJSfny8JCQkyYcIEueaaa2r9vKysLBk7dqwMGzZMUlNTz2gbAQDwNDabzSx+qAFI1wLSAJRVUOLwmJAAH0nsGGHqgM7tHCXdY0LES1dI9BBuFYguu+wyc6mrW2+9Vf7yl7+It7e3zJ8//4y0DQAATwpAv2YWyDJTBF0xDJaRV+TwmGA/b7MAYuUQWM/YMPH2oADk1oGoPt555x3Zu3ev/Pvf/5Ynn3zS1c0BAMAtHco6VhGAzCVDDmUXOtwf4Osl/dtH2IfA4tuEia+3l1hFkw5Eu3btksmTJ8uPP/4oPj61+yhFRUXmUiknJ+cMthAAANdtiFrR+1OxHcb+TMfNUH29m0nfduH27TD6tGsh/j7eYlVNNhCVlZWZYbLHH39cunXrVuvnzZgxwzwHAABPklWgG6IeqQhAezNlZ+qJG6L2btvCPhVee4MC/awbgKprZtOBRDekleqnmmWmhdTh4eGmbqhSeXm5GRfVY99++61cfPHFteohiouLk+zsbAkNDT1DnwYAgDOzH5gWQetQ2NbDOVL9jN5DN0Q9HoC0Hig0wFc8RU5OjoSFhTnt/N1ke4j0w2/atMnh2BtvvCHff/+9fPLJJ9KxY8can+fv728uAAA0te0w1vx61B6AdGHE6vuBdWlVsSGqBqDETpESUW1DVDSRQJSXlye7d++23963b59ZUygiIkLatWsnU6ZMkYMHD8r7778vXl5eZs2hqlq1aiUBAQEnHAcAoKnRrS90D7Bluyumwq/T7TDKyk/YD8ysBH18QcRWLt4PrClzq0C0evVqueiii+y3J02aZL6OGzdO3n33XbNYY1JSkgtbCADAmVFaVi6bD1UshqgBSHeHP1biuBp0TGjAbwGoc6S0DQ9yWXs9jdvWEDXVMUgAAGq7GvT2lFz7TLCVe49IblFpjdthVOwHFikdm9h2GGcSNUQAADRB2v+wJz3fPgtMe4KO1rAadMVK0BU9QN1aedZq0O6MQAQAwBmSfERXg65YB0gLodNyHVeDDtLVoDtE2AOQp68G7c4IRAAAOElKdqEs35thCqG1F+jA0WMO9/v5eEm/duEmAJ3bJdKsC2Sl1aDdGYEIAIB6yswrMoshml6gvZmyNz3f4X4fr2aSENfC3gN0TrtwCfBlMUR3RCACAKCWso+VyKrjiyHqMJgWRVel9c69YsPsAUiHw4L9OdU2BfyUAAA4iYLiUvll/1F7ANp8MFuqrYUo3WNC7IXQiR0jJSzIc1aDthICEQAAVVaD1gUQdSaYFkGvT86S0moJqFNUsH0qvAahqObsfuAJCEQAAMsqKSs3W2BUBiDdGqOo1HE16DYtAh0WQ2wdFuiy9uLMIRABACxD9/7aqqtB60ywPZlmc9T8YsfVoFuG+NsXQjy3c5TERQSyGKIFEIgAAB69GOLO1Dx7DdCKvZmSU+i4GnSLIF/7hqjaA9S5ZXMCkAURiAAAHhWA9mcWOASgjLxih8c09/eRxI4R9iGws2NCWQ0aBCIAQNN2MOuYLNv923YYh7MLHe4P8PUy098rd4SPbxMmPiyGiGoIRACAJiUtt9AEH3PZmym/ZhY43O/n7SV92lUshqg1QAlxYeLvw2KIODUCEQDArR3NL5aV+yr2AtMQtCstz+F+3ftLe30qA1C/9uES6EcAQt0QiAAAbiWvqFRWaQDaXRGCtqXkiK3KUkBa76x1P5X7gelwWEgAiyGiYQhEAACXL4a4NumoCUA/78kw6wLp9PiqurZqbmqAKleDDg/2c1l74ZkIRACARlVaVi6bDmab3h+dDbZ6/4mLIbaLCHJYDLFVSIDL2gtrIBABAM74VPgdqbnHh8AyZOXeI5JbVHrCYojnHa8B0mGwtuFBLmsvrIlABABwegBKPnLMDH/9vDujxrWAQgN8jg+BRcl5XVgMEa5HIAIANFhaTqF9COzn3ZlmbaCa1gI6r0uUGQrrGRtmZocB7oJABACos+yCEllhZoJlyM97MmV3tanwPl7NpK9ZC6giAOm6QKwFBHdGIAIAnNax4jL5Zf8RMwymawFtPpgtVSeC6WhXz9hQewDS3qBgf04xaDr4bQUAnKC4tFw2HMiyT4Vfl3RUSsocp8J3bhlsrwFiKjyaOgIRAEDKy22y9XCOvQZIe4MKisscHhMbFiDnHq8B0iAUE8ZUeHgOAhEAWHQm2N6MfFMDZLbE2JspWQUlDo+JCPYzm6HqNPjzOkdJ+8ggZoLBYxGIAMAiDumu8DoT7HgISslx3BU+2M9bEjUAHe8B6h4TIl7MBINFEIgAwEMdyS82BdCVhdD7MvJP2BVeN0Kt2BMsSnq3DRNfby+XtRdwJQIRAHjgpqg6FX7b4RyH+7Wzp3dbnQofadYD0jAU4MtUeEARiACgCW+Kui4p63ghdIZsqGFT1LOiQ0wNkA6BJXaKkFB2hQdqRCACgCa0KermQzkm/OgQmM4Eq2lTVJ0GP7hzlCmI1j3CAJwegQgA3Hgm2M7UPPtU+JX7MiW38MRNUc0QmAagzpESF8GmqEB9EIgAwI0kZRZUBCCdCr8no8ZNUQcdnwmmdUBdWrEpKuAMBCIAcKH03CITgCpXhD5wtOZNUStXhGZTVODMIBABQCPPBFu5N1N+0rWAdmfKjtTcEzZF7RPXwr4itG6QyqaowJlHIAKAM7wnmO4DpoXQOgy2PjnLYSaYjnb1aB1qhr+0Bmggm6ICLuFW/+qWLl0qzz33nKxZs0YOHz4s8+bNk6uuuuqkj//000/lzTfflPXr10tRUZH07NlTHnvsMRkxYkSjthsAqu4Jti0lx/T+aC/Qqn1H5FiJ455gugWGDoENOR6CdIsMAK7lVoEoPz9fEhISZMKECXLNNdfUKkBdcskl8tRTT0mLFi3knXfekZEjR8rKlSulb9++jdJmANBCaK3/+en4dHhdIbqqyGA/MwQ25Ph6QMwEA9xPM5vO63RDOmvidD1ENdFeolGjRsm0adNq9ficnBwJCwuT7OxsCQ0NrWdrAVhJZp4WQmceHwbLkOQjjoXQQbonWMcIMwymF10ckT3BAOdy9vnbrXqIGqq8vFxyc3MlIiLC1U0B4EHydUuM/Ufk510ZNW6JoYXQWvxcGYAS2rYQPx/2BAOaEo8KRM8//7zk5eXJddddd9LHaK2RXqomTACoqqSsXDYkZ9lngq1NOiql1bbE0J3ghxwPQAM7UggNNHUe8y/4ww8/lMcff1w+++wzadWq1UkfN2PGDPM4AKiklQM6/f2nXRlmKEynxecXOxZCt2kRWBGAulZMh49qzpYYgCfxiEA0Z84cufnmm+U///mPDB8+/JSPnTJlikyaNMmhhyguLq4RWgnAnRw4WlBRA7Q70yyMWH1F6PAg3+OLIVYsiKh7hLEiNOC5mnwg+uijj8ysNA1Fl19++Wkf7+/vby4ArOVofrEsP74gogahXzMLTlgRemDHSPtMMF0biEJowDrcKhBp/c/u3bvtt/ft22fWGNIi6Xbt2pnenYMHD8r7779vHyYbN26cvPLKK5KYmCgpKSnmeGBgoKk8B2Bdx4rLzG7wlTPBthzKkapzanX7i4S2YfZCaFaEBqzNrabdL1myRC666KITjmvoeffdd+XGG2+U/fv3m8epCy+8UH744YeTPr42mHYPeIbSsnLZeDD7+EywDFn7a5YUl5U7PKZbdHP7goiJnSIkJMDXZe0F0DDOPn+7VSByBQIR0DTp/7p2p+UdHwKrKITOLSp1eExsWMDxBRErCqFbhQa4rL0AnIt1iABY1uHsY/aZYDoUlpb72xIaKizQVwZ3ijQzwc7rHCkdo4IphAZQKwQiAG4rt7BEVuw9Ij/tSpcfd2fI3vR8h/v9fbxkQIcIObeLFkNHSc/YMFMbBAB1RSAC4HYLIv64q2JfsOo7w2vWiW/bwvT+aAA6p324BPhSCA2g4QhEAFxaB7QnPc8Mg2kA0t6gvGp1QB0ig8wssKFdo2RwpygJC6IQGoDzEYgANKr0XN0YNcP0Amkd0OHsQof7WwT5ynk6E6xrRTE0O8MDaAwEIgBnfD0g3RjV1AHtypDtKbkO9+smqAM6hFf0AnVpKT1jWRARQOMjEAFwKq352XIou6IOaFeGrPn16AnrAekq0JU9QFoUHehHHRAA1yIQAWiwpMwCUwP00+50MyU+q6DkhPWANABVrgrNxqgAPDYQHTt2zGyZAcDzZRUUy/I9mWYqvPYCJR1x3BcsxN9HBh2fCaZBqBPrAQGwSiAaMmSIrFmzxuHY9u3bpXv37s56CwAuUlRaZoa+fj4egHSLjKpr3Pt4NTN7gVXOBkto20J8vL1c2WQAaNxA9MUXX8jWrVvNxqzJyckSFxdnv2/UqFGyYcOGhr4FABdMh9fiZw1AWgu0at8ROVZS5vCYLq2aV/QAdYkyvUHN/RmBB9B0Nfj/YL169TJBKCMjw2yq+uuvv0qbNm2kdevW4uvLeiFAU5GSXVhRB7QrXX7anSkZeY7bYmjdzxBdEbprSzmvS6S0DmOIHIDnaHAg6tixo/z1r381wej88883xw4ePGiCkR4D4J7yi0plxd5M+6rQulFqVQG+XpLYMdIMgelQWPeYEOqAAHisegeiZcuWmd1lK0NPZRhS2kOkFwDuo7zcJlsP58gPO3U9oHRTE1RS9lshkGad3m3C7LPB+rUPF38fpsMDsIZ6B6LbbrtNbr/99hN6gfbs2SOtWrWSkJAQZ7QPQAOk5RTK0l1aB5RuiqEz84sd7m8bHijnd2spQ7tEyeDOkdIiyM9lbQWAJhmIduzYIRdeeOEJxxcuXGgKrb/88suGtg1AHRWWlMkv+4+YYbClO9NPWBU62M9bBneOkvO7Rcn5XVtK+8gghsEAoCGBSIfLjh49esLxoUOHysMPP9zQdgGo5WywXWl5JvxoT9DKvZlSVPrbqtCadeLbhJk6IA1AfduFm60yAABOCkS/+93v5Pnnn5c5c+Y4HPfy8pLiYsdueQDOczS/2BRBawjSnqCUHMfNUaND/WVo15ZmKEynxEcEMwwGAGcsEE2fPl0GDhwof/zjH+Wxxx6T+Ph4KSwslGeeeUZ69+5d35cFUE1JWbms/fVoxTDYrnTZVG1RRH8fLxnYMUIu0Fqgri2lW3RzhsEAoLECkS7AuGLFCpk4caIkJCSIv7+/lJaWSlhYmKkhAlB/+zPyTSH0DzszzNT4vKJSh/vPig4xdUAagDQMBfgyGwwAXLYOUfv27eXrr7+WpKQkWb9+vVmIMTExUSIiIhrUKMBqcgpLzN5glcNg1fcG02EvHf4ytUDdWkp0aIDL2goAnsgpa+23a9fOXADUTlm5zQx9VQSgdFmblGWOVd0bTNcB0vCjxdA9Y0PFy4thMAA4U9h8CGgkuhWGBqDFOypCUFZBicP9HaOC5fyuFcNg7A0GAI2L/+MCZ3BlaN0VfvH2NFmyI+2EHeJDAnzkvM5RMvT4mkBxEUGubC4AWBqBCHDylHidCbZkhxZEp8uRaitD92gdKhd1bykXntVK+sa1EB9v1gQCAHdAIAIa2Au05VCOLN6RZi4bkrOkSimQhPj7mL3BLjqrlVxwFsXQAOCRgWjRokXmkpaWJuXlv62Oq95+++2Gtg1wS9kFJVV6gdIkI8+xF0h3hdceoAvPamkKo33pBQIAzw1Ejz/+uDzxxBPSv39/ad26NQvBwaO3x9Bd4jUAaS2Q7hJftRdI9wfT3eEv6t7KLI4Y2yLQlc0FADRmIJo5c6a8++67MmbMmPq+BODW6wL9vCvDDINpEErLLXK4v2ur5iYAXditpfTvEMH+YABg1UCk+5Wde+65zm0N4EL7MvLlu60psmhbRS9QaZVuoEBf7QWKtA+FtQ1nRhgAeJJ6B6Kbb75ZPvzwQ5k6dapzWwQ0YkH0hgNZ8t3WVHPRXeOr6tQyWC7s1srMChvQge0xAMCT1TsQ6Uaus2bNkoULF5rNXHXbjqpefPFFZ7QPcKqi0jJZtifTBKCFW1MdhsJ0dejEThFyydnRcnH3aGkXSS8QAFhFvQPRxo0bpU+fPub65s2bHe6jwBruNitMa4E0BGlRdH5xmf0+XQ1ap8Nf2iPaDIeFBToGewCANdQ7EC1evNi5LQGc6GDWMfluS4p8ty1VVu494lAPFB3qL8PPjpZLekTL4M6R4u/DUBgAWB0LM8KjpsZrL9C3W1LN9aq6RTeXS3vEmBAU3yaMjVIBAM4LRFlZWfLWW2/Jtm3bzO0ePXrITTfdJGFhYc5qH3DKELQ+OUu+2HBYvtmSYnqFKmne0enwOhSmIah9ZLBL2woAcG/1Xjxl9erV0rlzZ3nppZfkyJEj5qLX9djatWvr9ZpLly6VkSNHSmxsrKlDmj9//mmfs2TJEjnnnHPE399funTpYtZGgmfblZorz3+zQy54bolc/cYyefvnfSYMBfh6mQD03LW9ZfUjl8jH/zdYbh7aiTAEADhzPUT33HOPXHHFFTJ79mzx8al4mdLSUjMd/+677zbhpq7y8/MlISFBJkyYINdcc81pH79v3z65/PLL5dZbb5UPPvjAbCOi768rZ48YMaJenwvu6cDRAtMT9PmGQ7KtynCYrg90ac9ouTy+tQzt2lIC/agHAgDUXTObjjvUQ2BgoKxbt066d+/ucHzr1q1mO4+CgoKGNaxZM5k3b55cddVVJ33Mgw8+KF999ZXDLLc///nPZihvwYIFtXqfnJwcM8SXnZ0toaGhDWoznCszr0i+3nRYPlt/SFb/etR+3Ne7mdki44o+bWT42a0kyI9SOACwmhwnn7/rfSbRN09KSjohECUnJ0tISIg0huXLl8vw4cMdjmnPkPZQnUxRUZG5VP2Gwn3kFpaYomjtCfppd4aUHZ8dpis5DOoYKVf0iZXLesVIiyA/VzcVAOBB6h2IRo0aZQqon3/+efsWHj///LPcf//9Mnr0aGkMKSkpEh0d7XBMb2vIOXbsmOnFqm7GjBlmY1q4j5KycrNdxucbDpqvRaXl9vt6tw2TKxJi5Q+9YyUmLMCl7QQAeK56ByINQjqsNXbsWFM7pCNvfn5+MnHiRHn66afFXU2ZMkUmTZpkv63hKS4uzqVtsqq0nEL5cFWSfLgyyWHFaN0y48qENqY3qGMUBdEAADcORBp+XnnlFdPjsmfPHnNMZ5gFBTXedgcxMTGSmprqcExv63BeTb1DSmej6QWuocFZN059b/mv8r9Nh+0LJkY195drzmljeoN6xoay2jkAwH0DkfasTJ8+XYKDgx16WWrSGHuZDR48WL7++muHY9999505DvdyrLjMDIm9t+xXh0UT+7cPlzGD28tlvVqLn0+9V4EAAKDxApHOKispKbFfP5n6/nWfl5cnu3fvdphWv379eomIiJB27dqZ4a6DBw/K+++/b+7X6favvfaaPPDAA2aq/vfffy8ff/yxmXkG95CUWSD/XvmrzP0lWbKPVfzu+Pt4yVV92pgg1KsNi3gCAJrwtPszQRdZvOiii044Pm7cOLPg4o033ij79+83j6v6HF0TSaf7t23bVqZOnWoeV1tMu3c+/ZVauitD3l+2X77fkSaVv2FtwwNl7OD28qd+cRIezCwxAED9Ofv8Xe9ApFPutRi5pt4gvU97dJoCApHz6K/Sj7sy5IVvd8iGA9n24+d3aynjBrc3u8l7s4cYAMCT1iHq2LGjHD58WFq1auVwPDMz09xXVlbW4Mah6Vi5N1Ne+HanrNp/xL6C9KgBcaZHqFPL5q5uHgAAZyYQaW9ATb1DWgcUEMB6MVahm6tqj5D2DCktjL4hsb1MvLCztAxhNh8AwEMDUeXsMg1DWq9TdZq99gqtXLlS+vTp49xWwu3ofmLaI7RwW8WyBz5ezUyP0O0Xd5HWYTUveQAAgMcEosrZZdpDtGnTJrMeUSW9rpuz3nfffc5tJdzG7rQ8eXnhTvly42FzW0uCrjmnrdw1rKvERTTeGlQAALg0EC1evNh8HT9+vFmYkUJk66wjpEHonz/ts+8vNjIhVu4e3lU6UyMEALBqDdE777xjv145UY3VhT3Tsj0ZMuXTTfJrZoG5PfzsaLn30m5ydmvCMADAMzRoaeC33npLevXqZYqo9aLX//nPfzqvdXApXUhx8n83yl9mrzRhKCY0QP45tr/8c1x/whAAwKPUu4do2rRpZnuOO+64w75VxvLly80iiboO0RNPPOHMdqKRLdh8WKZ+tkXSj2+6en1iO3nwsu4SGuDr6qYBAOB09V6YsWXLlvLqq6/K6NGjHY5/9NFHJiRlZFRMw3Z3LMzoKC23UB79bIv8b3OKud0pKlhmXBMviZ0iXd00AADcb2FG3dOsf//+Jxzv16+flJaWNrRdaGSai/+z5oA8+eVWySksNStK/9/5neTOYV0lwNfb1c0DAMA9a4jGjBkjb7755gnHZ82aJddff31D24VGDkPPfbNDHvhkowlDvdqEyue3nycP/K47YQgAYAn17iGqLKr+9ttvZdCgQea2Lsqo9UNjx461L+CotNYI7huGpn+5Td7+eZ+5fc/wbnLbRZ3Fx7tB9fYAAFgjEG3evFnOOeccc33Pnj3ma1RUlLnofZWYiu++ysttMvWzzfLByiRze/pVvWTMoPaubhYAAE0nEFUu0IimSRdXfPC/G+WTNQdEM+sz1/SW6wbEubpZAAA0vSGzwsJC2bhxo6SlpUl5eblDr9DIkSOd0T6cASVl5XLvxxvk8w2HTPH0i9clyJV92ri6WQAANL1AtGDBAlNYnZmZecJ9Goh0o1e4n+LScrnjo7XyzZZU8fVuJq/+ua9cFt/a1c0CAMCl6l05q2sNXXfddXL48GHTO1T1QhhyT4UlZfJ//1ptwpCft5fMvKEfYQgAgIb0EKWmppqZZNHR0c5tEc7YbLK75qyTxTvSJcDXS2aP7S9Du7Z0dbMAAGjaPUTXXnutLFmyxLmtwRnz5g977D1D79w4kDAEAIAzeohee+01+dOf/iQ//vijxMfHi6+v4x5Xd955Z31fGk72064Mef6bHeb6Y1f0lMGd2YYDAACnBCLds0wXZdRd7rWnqOp6Q3qdQOQeDmYdM0XU5TaR6/q3ldEDmVoPAIDTAtHDDz8sjz/+uEyePFm8vFjV2F2LqCf+e40cLSgx23E8cWUvFsoEAKAG9U4yxcXFMmrUKMKQG3v8iy2y8UC2tAjylTev78e+ZAAAnES908y4ceNk7ty59X06zrC5vyTJR6uSzSrUutZQXESQq5sEAIDnDZnpWkPPPvusfPPNN9K7d+8TiqrZ0NV1Nh7IkqmfbTHX772km5zfjRllAACckUC0adMm6du3r7ledTNXRZ2K6xzJL5aJ/15rVqQefna0/PXCLq5uEgAAbo/NXT1s93pdfFFnlnWIDJIXrksQLy/CKQAAp0NFtAf56Jck+XFXhgT6esvMMf0kLNBxGBMAADi5h+iJJ5445f3Tpk2r70ujHtJyC+Xp/2031+8fcZZ0jwl1dZMAAPD8QDRv3jyH2yUlJbJv3z7x8fGRzp07E4ga2ZNfbpPcwlKz3tC4czu4ujkAAFgjEK1bt+6EYzk5OXLjjTfK1Vdf3dB2oQ6W7kyXzzccEi0XmnF1b/GmbggAANfVEIWGhprVq6dOnerMl8VpVqN+ZH7FLL+xgztIfNswVzcJAIAmx+lF1dnZ2eaCxvHa97sl6UiBxIQGyL2XdnN1cwAAsNaQ2auvvupw22azyeHDh+Vf//qXXHbZZc5oG05jV2qu/GPpHnP9sSt6SEgAs8oAAGjUQPTSSy853NY9zVq2bGm29JgyZUp9XxZ1WHPo4XmbpaTMJsO6t5IRPWNc3SQAAKw3ZKYzyqpe9uzZIytWrJCnnnpKQkJC6t2g119/XTp06CABAQGSmJgoq1atOuXjX375ZTnrrLMkMDBQ4uLi5J577pHCwkLxdJ+sOSCr9h8xaw49fmVPVgcHAMAVgejYsWNSUFBgv/3rr7+acPLtt9/WuzG6WeykSZPk0UcflbVr10pCQoKMGDFC0tLSanz8hx9+KJMnTzaP37Ztm7z11lvmNR566CHxZJl5RfLU/7aZ6/dc0lXahrNxKwAALglEV155pbz//vvmelZWlgwcOFBeeOEFc/zNN9+s12vqhrC33HKLjB8/Xnr06CEzZ86UoKAgefvtt2t8/LJly+S8886Tv/zlL6ZX6dJLL5XRo0eftlepqXvhu52SVVAi3WNCZPx5HV3dHAAArBuItAdn6NCh5vonn3wiMTExppdIQ1L1guvaKC4uljVr1sjw4cN/a5yXl7m9fPnyGp9z7rnnmudUBqC9e/fK119/Lb///e9P+j5FRUVmvaSql6YkKbNAPv4l2Vx//Iqe4uvN7isAALisqFqHyyprhXSY7JprrjEBZtCgQSYY1VVGRoaUlZVJdHS0w3G9vX17xZYU1WnPkD5vyJAhZpZbaWmp3HrrraccMpsxY4ZZK6mpemXRLiktt8nQrlGS2CnS1c0BAMAj1Lt7oUuXLjJ//nxJTk6Wb775xgxXKa330QUaG8OSJUtMEfcbb7xheqw+/fRT+eqrr2T69OknfY7OgKtcK0kv2v6mYk96nsxbd8Bcv/fSs1zdHAAAPEa9e4h0rzLtodFZXcOGDZPBgwfbe4v69u1b59eLiooSb29vSU1NdTiut3U4ria6IvaYMWPk5ptvNrfj4+MlPz9f/t//+3/y8MMPmx6r6vz9/c2lKXp54S4pt4kMP7uV9Ilr4ermAADgMerdQ3TttddKUlKSrF69WhYsWGA/ruGo+hpFteHn5yf9+vWTRYsW2Y+Vl5eb25Vhq6Zhu+qhR0OV0iE0T7IjJVe+3HjIXL/nElakBgDALXqIlPbcVO+90dlm9aVT7nVhx/79+5vX0Wn82uOjs87U2LFjpU2bNqYOSI0cOdLMTNMeKV2zaPfu3abXSI9XBiNP8dJ3O0Uz3u/jY6RnLPuVAQDgNoFIe2/0onVD2ptT1cmmyp/KqFGjJD093QzHpaSkSJ8+fUzvU2WhtfZIVe0ReuSRR8yChPr14MGDZqVsDUN/+9vfxJNsPpgtC7akiK69eM9weocAAHC2ZrZ6ji3pTK0nnnjC9Oa0bt36hJWS582bJ02BTrsPCwszBdaNVQxeVxPe/UW+354mV/WJlZf/XPf6LAAAPE2Ok8/f9e4h0kUT3333XVPUjDNnza9HTRjy9momd9E7BACAexVV60KKujAiznztkPrjOW2kY1Swq5sDAIBHqncg0qnuupcYzpwVezPlp90Z4uvdTO64uKurmwMAgMeq95CZ7ig/a9YsWbhwofTu3Vt8fX0d7tfZX6g/Le168duK3qFRA+IkLoINXAEAcLtAtHHjRjMLTG3evNnhvuoF1qg77Rlatf+I+Pl4ye0X0TsEAIBbBqLFixc7tyVw8I8f9pqv1ye2k5iwAFc3BwAAj8ZW6W66KrX2EHk1E7lpSEdXNwcAAI/XoIUZs7Ky5K233pJt27aZ2z169JCbbrrJrAuA+nt32T7zdUTPGGkbTu0QAABu20Oke5h17tzZ7Ft25MgRc9Hrekx3nkf9ZB8rkXnrDprr48+jdwgAALfuIdJd7q+44gqZPXu2+PhUvExpaamZjn/33XfL0qVLndlOy/h8/UEpLCmXs6JDZECHcFc3BwAAS/BpSA9R1TBkXszHRx544AGznQfqZ+7qZPP1ugFxzNYDAMDdh8x03xDdbLW65ORkCQkJaWi7LCktt1A2H8wxm7he3beNq5sDAIBl1DsQ6c70WkA9d+5cE4L0MmfOHDNkNnr0aOe20iLWJ2WZr91ahUhEsJ+rmwMAgGXUe8js+eefN0M6Y8eONbVDSlernjhxojz99NPObKNlrE+uCER94lq4uikAAFhKvQORn5+fvPLKKzJjxgzZs2ePOaYzzIKCmCbe4EDUjkAEAECTCEQahKKjo2XChAkSHx9vP/72229Lenq6PPjgg85qoyWUldtkAz1EAAA0rRqif/zjH9K9e/cTjvfs2VNmzpzZ0HZZzu60PMkvLpMgP2/pFk1ROgAATSIQpaSkSOvWrU843rJlSzl8+HBD22U565OPmq/xbcLEW/fsAAAA7h+I4uLi5Oeffz7huB6LjY1taLssh/ohAACaYA3RLbfcYlakLikpkYsvvtgcW7RokVmY8d5773VmGy1h3fEp932pHwIAoOkEovvvv18yMzPlr3/9qxQXF5tjAQEBpph6ypQpzmyjx8svKpWdqbnmep84tusAAKDJBCJdg+iZZ56RqVOnmt3uAwMDpWvXruLv7+/cFlrApoPZUm4TiQkNkJiwAFc3BwAAy6l3IKrUvHlzGTBggHNaY1EsyAgAQBMtqobzt+zoS0E1AAAuQSByA/QQAQDgWgQiF0vJLpSUnEKz9lB82zBXNwcAAEsiELnJgoy6OnWQX4NLugAAQD3U6Qw8adKkWj/2xRdfrE97LGcdw2UAADStQLRu3TqH22vXrpXS0lI566yzzO2dO3eKt7e39OvXz7mttEJBNYEIAICmEYgWL17s0AMUEhIi7733noSHVywmePToURk/frwMHTrU+S310B3udQ0ixZYdAAA0wRqiF154QWbMmGEPQ0qvP/nkk+Y+nJ6uTl1QXCbN/X2kc8vmrm4OAACWVe9AlJOTI+np6Scc12O5uRXbUKB20+17t2WHewAAmmQguvrqq83w2KeffioHDhwwl//+979y0003yTXXXOPcVnp4/RAF1QAAuFa953nPnDlT7rvvPvnLX/5idrw3L+bjYwLRc88958w2eiwWZAQAoIkHoqCgIHnjjTdM+NmzZ4851rlzZwkODnZm+zxWnu5wn3Z8h3sKqgEAaNoLM2oA6t27t7k4Iwy9/vrr0qFDBwkICJDExERZtWrVKR+flZUlt912m7Ru3Vr8/f2lW7du8vXXX4u723ggS2w2kTYtAqVVCDvcAwDQZAPRjz/+KDfccIMMHjxYDh48aI7961//kp9++qlerzd37lyz+OOjjz5q1jhKSEiQESNGSFpaWo2PLy4ulksuuUT2798vn3zyiezYsUNmz54tbdq0EXfHcBkAAB4QiLSAWsNKYGCgWbCxqKjIHM/OzpannnqqXq+paxvdcsstpli7R48epk5Jh+befvvtGh+vx48cOSLz58+X8847z/QsXXDBBSZIuTsKqgEA8IBApOsNaWDRHhlfX1/7cQ0m2rtTV9rbs2bNGhk+fPhvjfPyMreXL19e43M+//xz0zulQ2bR0dHSq1cvE8bKyspO+j4a3HTJgKqXxmaz2X7bsoP6IQAAmm4g0uGp888//4TjYWFhpq6nrjIyMkyQ0WBTld5OSUmp8Tl79+41Q2X6PK0bmjp1qlkUUsPayehiktrGyktcXJw0tkPZhZKeW2TWHuoVyw73AAA02UAUExMju3fvPuG41g916tRJGkN5ebm0atVKZs2aZfZPGzVqlDz88MOm5+pkpkyZYob1Ki/JycniquGy7jEhEujn3ejvDwAAnDTtXmt97rrrLlPH06xZMzl06JAZ2tK1ibSnpq6ioqLMxrCpqakOx/W2hq+a6MwyHa7T51U6++yzTY+SDsH5+fmd8BydiaYXV1qffNR8pX4IAIAm3kM0efJksyjjsGHDJC8vzwyf3XzzzfJ///d/cscdd9T59TS8aC/PokWLHHqA9LbWCdVE65W0l0ofV2nnzp0mKNUUhtwFM8wAAPCQQKS9Qjo8pbO8Nm/eLCtWrDD7mE2fPr3ejdEp91qk/d5778m2bdtk4sSJkp+fb2adqbFjx5ohr0p6v76/9lRpEPrqq69MUbUWWburkrJy+w73fSmoBgCgaQ+ZXXzxxWaKu64ZpFPkKx09elT++Mc/yvfff1/n19QaIA1V06ZNM8Neffr0kQULFtgLrZOSkszMs0paEP3NN9/IPffcYxaG1PWHNBw9+OCD4q52pORKYUm5hAT4SKcodrgHAMAdNLPpHPB60GASGRlphq0++OAD+yrVWvMTGxt7yqnv7kSn3etsMy2wDg0NPePv9+8Vv8oj8zfLkC5R8u+bE8/4+wEA4IlynHz+btBK1QsXLjQ9OYMGDTKrReP0qB8CAMD9NCgQafHyDz/8IPHx8TJgwABZsmSJ81rmoQhEAAB4WFG10insH374oand+d3vfidvvPGGM9vnUXIKS2RPep65zgrVAAB4QFF19dKjRx55xKwBNG7cOGe0yyNtTM42O9zHRQRKVHPXroUEAACcEIj27dtnFlOsSmeXnXXWWWZPMpxqQcZwVzcFAAA4IxC1b9++xuO6wapecCLqhwAA8IBApAsn6sKLOsVer5/Kiy++2NC2eRQdYiQQAQDgAYFo3bp1UlJSYr9+uoJr/ObA0WOSkVcsvt7NpGfsmV/vCAAAnKFAtHjx4hqv4/Qqe4fObh0qAb7scA8AgMesQ4TaY7gMAAAPqiGqLWqIHBGIAADwoBqi2qCG6MQd7jcf3+GeQAQAgAfVEKH2th/OlaLScgkL9JWOURWb4AIAAA9Yh6jS1q1bJSkpSYqLix16iEaOHNnQl/a4BRkT4lrQewYAgCcFor1798rVV18tmzZtMif5yq08Kk/4ZWVlzmtlE7eO+iEAADxzlplu5tqxY0dJS0uToKAg2bJliyxdulT69+/PrvcnKajuSyACAMCzeoiWL18u33//vdnPzMvLy1yGDBkiM2bMkDvvvLPWBdieLrugRPam59uHzAAAgAf1EOmQWEhIiLmuoejQoUP2Pc527NjhvBY2cesPVPQOtY8MkohgP1c3BwAAOLOHSDdw3bBhgxk2S0xMlGeffVb8/Pxk1qxZ0qlTp/q+rMdZn0T9EAAAHhuIHnnkEcnPrxgKeuKJJ+QPf/iDDB06VCIjI2Xu3LnObKNHzDAjEAEA4IGBaMSIEfbrXbp0ke3bt8uRI0ckPDycqeXHscM9AAAWWYeoqoiICGe+XJOXdKRAjhaUiJ+3l/Rgh3sAADwzEBUWFsrGjRvN1Pvy8nKH+6644gqxOvsO97Gh4u/DDvcAAHhcIFqwYIGMHTtWMjIyTrhPh8xYmFFk3fGCatYfAgDAQ6fd33HHHfKnP/1JDh8+bHqHql4IQxWoHwIAwMMDUWpqqkyaNEmio6Od2yIPUVRaJlsP5ZjrBCIAADw0EF177bVs0XEK2w7nSnFZuYQH+ZpFGQEAgAfWEL322mtmyOzHH3+U+Ph48fX1dbhft++wsvVJv60/xDIEAAB4aCD66KOP5Ntvv5WAgADTU1T1pK/XLR+I7PVD4a5uCgAAOFOB6OGHH5bHH39cJk+ebDZ2xUkCUTvqhwAAcHf1TjLFxcUyatQowlANjuYXy/7MAnO9T1sCEQAA7q7eaWbcuHHsWXaaHe47RQVLWJBjbRUAAPCgITNda0h3uP/mm2+kd+/eJxRVv/jii2JV7HAPAIBFAtGmTZukb9++5vrmzZsd7rP6rCrqhwAAsEggWrx4sXNb4kE73G84PmRGDxEAAB5cQ1RSUiLDhg2TXbt2Ob9FIvL6669Lhw4dzJT+xMREWbVqVa2eN2fOHNM7ddVVV4mraDF1lu5w7+Ml3WPY4R4AAI8NRFovpLvcnwlaqK1bgjz66KOydu1aSUhIkBEjRkhaWtopn7d//3657777ZOjQoeJK65MrFmTsFRtqQhEAAHB/9T5j33DDDfLWW285tzXHi7FvueUWGT9+vPTo0UNmzpwpQUFB8vbbb5+ywPv666836yJ16tRJXOm3gmoWZAQAwONriEpLS01IWbhwofTr10+Cg4MbPMtM1zZas2aNTJkyxX5M1zkaPny4LF++/KTPe+KJJ6RVq1Zy0003ma1ETqWoqMhcKuXkVGzA6iwUVAMAYKFApDPLzjnnHHN9586dTplllpGRYXp7oqOjHY7r7e3bt9f4nJ9++sn0VK1fv75W7zFjxgzTk3QmFJaUydbDFQGrLwXVAAA0GU16lllubq6MGTNGZs+eLVFRUbV6jvY+aY1S1R6iuLg4p7Rny6EcKSmzSWSwn7QND3TKawIAADcORCorK8v0zmzbts3c7tmzp0yYMEHCwsLq9Xoaary9vSU1NdXhuN6OiYk54fF79uwxxdQjR460HysvLzdffXx8ZMeOHdK5c2eH5/j7+5vLmd3QlR3uAQCwRFH16tWrTdh46aWX5MiRI+aidUN6TGeH1Yefn5+pR1q0aJFDwNHbgwcPPuHx3bt3NwtE6nBZ5eWKK66Qiy66yFx3Vs9PfQIRAACwQA/RPffcY8KHDldpb0xlofXNN98sd999tyxdurRer6vDWbpPWv/+/WXgwIHy8ssvS35+vpl1psaOHStt2rQxtUC6TlGvXr0cnt+iRUUYqX68MafcU1ANAIBFApH2EFUNQ+bFfHzkgQceMGGmvkaNGiXp6ekybdo0SUlJkT59+siCBQvshdZJSUlm5pm7ycwrkuQjx8z13uxwDwCANQJRaGioCSc6bFVVcnKyhISENKhRt99+u7nUZMmSJad87rvvviuuUDlc1rllsIQFssM9AABNiVdDenJ03R9dWVpDkF506wwdMhs9erRYzW/1QyzICACAZXqInn/+eTOTSmt6tHaockuPiRMnytNPPy1Ww4KMAABYMBDpjLBXXnnFFDfv3r3bhCOdYabbbFhNebnNHohYkBEAAIutQ6Q0APXu3VusbG9GvuQWloq/j5ecFdOw+ikAANAEApHO8DrdooN6f+UwmhVU9g7FtwkTX2/3mwEHAACcHIjmzZt30vt0A9ZXX33Vvlq0VVSuP9SX+iEAAKwRiK688soTjukWGZMnT5YvvvhCrr/+erP7vJUwwwwAgKatQeM7hw4dkltuuUXi4+PNEJlul/Hee+9J+/btxSp0h/vth3PNdWaYAQBgoUCUnZ0tDz74oHTp0kW2bNli9hrT3iFXbJfhapsPZktpuU1ahvhLbFiAq5sDAAAaY8js2WeflWeeecbsPv/RRx/VOIRmJexwDwCABQOR1goFBgaa3iEdHtNLTT799FOxgnXscA8AgPUCka5MTU/Ib9YnsSAjAACWC0Su2jzVHaXnFsnBrGOi+TC+bZirmwMAAOqJVQSdUD/UtVVzCQlgh3sAAJoqApETFmSkfggAgKaNQNQALMgIAIBnIBA1YIf7jcnZ5jo9RAAANG0Eonrak54nuUWlEujrLd2im7u6OQAAoAEIRPW07vh0e51d5sMO9wAANGmcyRu4ICPrDwEA0PQRiJywZQcAAGjaCET1UFBcKjtScsx1drgHAKDpIxDVw6YD2VJuE4kO9ZfWYYGubg4AAGggAlE9MFwGAIBnIRDVAwsyAgDgWQhE9UAPEQAAnoVAVEepOYVyOLtQvJqJ9GaHewAAPAKBqJ4LMnaLDpFgfx9XNwcAADgBgaiOGC4DAMDzEIjqaH3yUfO1L+sPAQDgMQhEdVBWbjNrEClmmAEA4DkIRHWwKy1X8ovLJNjPW7q0Yod7AAA8BYGoDtYfL6ju3baFeOs0MwAA4BEIRPUpqKZ+CAAAj0IgqgNmmAEA4JncMhC9/vrr0qFDBwkICJDExERZtWrVSR87e/ZsGTp0qISHh5vL8OHDT/n4+sovKpWdqbnmel8CEQAAHsXtAtHcuXNl0qRJ8uijj8ratWslISFBRowYIWlpaTU+fsmSJTJ69GhZvHixLF++XOLi4uTSSy+VgwcPOrVdG4/vcB8bFiCtQgOc+toAAMC13C4Qvfjii3LLLbfI+PHjpUePHjJz5kwJCgqSt99+u8bHf/DBB/LXv/5V+vTpI927d5d//vOfUl5eLosWLXJqu6gfAgDAc7lVICouLpY1a9aYYa9KXl5e5rb2/tRGQUGBlJSUSERERI33FxUVSU5OjsOlLgsyUj8EAIDncatAlJGRIWVlZRIdHe1wXG+npKTU6jUefPBBiY2NdQhVVc2YMUPCwsLsFx1iq1tBNQsyAgDgadwqEDXU008/LXPmzJF58+aZguyaTJkyRbKzs+2X5OTk077u4exjkppTZNYeim/DDvcAAHgat9quPSoqSry9vSU1NdXhuN6OiYk55XOff/55E4gWLlwovXv3Punj/P39zaU+O9yfFR0igX7edXouAABwf27VQ+Tn5yf9+vVzKIiuLJAePHjwSZ/37LPPyvTp02XBggXSv39/p7eLgmoAADybW/UQKZ1yP27cOBNsBg4cKC+//LLk5+ebWWdq7Nix0qZNG1MLpJ555hmZNm2afPjhh2btospao+bNm5uLM7fsoKAaAADP5HaBaNSoUZKenm5CjoYbnU6vPT+VhdZJSUlm5lmlN99808xOu/baax1eR9cxeuyxxxrcntKyctl0sGKHexZkBADAMzWz2Ww2sTCddq+zzbTAOjQ09IT7txzKlstf/UlC/H1kw6OXihebugIA4Pbn7yZdQ+SOKuuHeseFEYYAAPBQBKLToH4IAADPRyA6DRZkBADA8xGITiG3sER2p+eZ6/QQAQDguQhEp9nhXkvO27QIlJYhdVvMEQAANB0EolNgQUYAAKyBQFSLLTtYfwgAAM9GIDoJXZ7pt4JqAhEAAJ6MQHQSB7OOSUZekfh4NZNe7HAPAIBHIxCdRGXv0NmtQyXAlx3uAQDwZASik2BBRgAArINAdBLUDwEAYB0EohqUVNnhnin3AAB4PgJRDXak5EpRabmEBvhIx8hgVzcHAACcYQSiGqw7PlyWENeCHe4BALAAAtEpCqpZkBEAAGsgENVgffJR85X6IQAArIFAVE32sRLZk55vrie0JRABAGAFBKJqNh6oGC5rFxEkkc3Z4R4AACsgEJ1kQ1fWHwIAwDoIRNWwICMAANZDIDrZDvcUVAMAYBkEoiqSjxyTI/nF4uvdTHq0DnV1cwAAQCMhEFWx7vh0ew1D7HAPAIB1EIiqoH4IAABrIhBVQf0QAADWRCA6rri0XLYcyjHX+8SFu7o5AACgERGIjtuRkmNCUYsgX+kQGeTq5gAAgEZEIDpu08Fs+3YdzZqxwz0AAFZCIDpu44GKQERBNQAA1kMgqtZDREE1AADWQyA67tfMAvO1DzvcAwBgOQSiKjpGBUt4sJ+rmwEAABoZgagK6ocAALAmAlEVBCIAAKzJLQPR66+/Lh06dJCAgABJTEyUVatWnfLx//nPf6R79+7m8fHx8fL111/X630JRAAAWJPbBaK5c+fKpEmT5NFHH5W1a9dKQkKCjBgxQtLS0mp8/LJly2T06NFy0003ybp16+Sqq64yl82bN9fpfX19vORsdrgHAMCSmtlsNpu4Ee0RGjBggLz22mvmdnl5ucTFxckdd9whkydPPuHxo0aNkvz8fPnyyy/txwYNGiR9+vSRmTNnnvb9cnJyJCwsTC5//hv58t5LnfxpAADAmVB5/s7OzpbQ0FDP6iEqLi6WNWvWyPDhw+3HvLy8zO3ly5fX+Bw9XvXxSnuUTvb4k4lvG1bPVgMAgKbOR9xIRkaGlJWVSXR0tMNxvb19+/Yan5OSklLj4/V4TYqKisylasJUvdsQiAAAsCq36iFqDDNmzDBdbJUXHY5TFFQDAGBdbhWIoqKixNvbW1JTUx2O6+2YmJgan6PH6/L4KVOmmPHGyktycrI53iacHe4BALAqtwpEfn5+0q9fP1m0aJH9mBZV6+3BgwfX+Bw9XvXx6rvvvjvp4/39/U3xVdULAACwNreqIVI65X7cuHHSv39/GThwoLz88stmFtn48ePN/WPHjpU2bdqYoS911113yQUXXCAvvPCCXH755TJnzhxZvXq1zJo1y8WfBAAANBVuF4h0Gn16erpMmzbNFEbr9PkFCxbYC6eTkpLMzLNK5557rnz44YfyyCOPyEMPPSRdu3aV+fPnS69evVz4KQAAQFPidusQNfV1DAAAwJnn0esQAQAAuAKBCAAAWB6BCAAAWB6BCAAAWB6BCAAAWB6BCAAAWB6BCAAAWB6BCAAAWB6BCAAAWJ7bbd3R2CoX6tYVLwEAQNNQed521oYblg9EmZmZ5mtcXJyrmwIAAOpxHtctPBrK8oEoIiLCvmmsM76haFja12CanJzMvnJugJ+H++Bn4T74WbgP3cOsXbt29vN4Q1k+EHl5VZRRaRjil9s96M+Bn4X74OfhPvhZuA9+Fu53Hm/w6zjlVQAAAJowAhEAALA8ywcif39/efTRR81XuBY/C/fCz8N98LNwH/wsPPdn0czmrPlqAAAATZTle4gAAAAIRAAAwPIIRAAAwPIIRAAAwPIsH4hef/116dChgwQEBEhiYqKsWrXK1U2ynBkzZsiAAQMkJCREWrVqJVdddZXs2LHD1c2CiDz99NPSrFkzufvuu13dFEs6ePCg3HDDDRIZGSmBgYESHx8vq1evdnWzLKmsrEymTp0qHTt2ND+Lzp07y/Tp0522jxZObunSpTJy5EiJjY01/z+aP3++w/36M5g2bZq0bt3a/GyGDx8uu3btkrqydCCaO3euTJo0yUzbW7t2rSQkJMiIESMkLS3N1U2zlB9++EFuu+02WbFihXz33XdSUlIil156qeTn57u6aZb2yy+/yD/+8Q/p3bu3q5tiSUePHpXzzjtPfH195X//+59s3bpVXnjhBQkPD3d10yzpmWeekTfffFNee+012bZtm7n97LPPyt///ndXN83j5efnm/OzdmDURH8Or776qsycOVNWrlwpwcHB5lxeWFhYtzeyWdjAgQNtt912m/12WVmZLTY21jZjxgyXtsvq0tLS9E8u2w8//ODqplhWbm6urWvXrrbvvvvOdsEFF9juuusuVzfJch588EHbkCFDXN0MHHf55ZfbJkyY4HDsmmuusV1//fUua5MViYht3rx59tvl5eW2mJgY23PPPWc/lpWVZfP397d99NFHdXpty/YQFRcXy5o1a0zXWtX9UPT28uXLXdo2q9MN+5SzNuxD3WmP3eWXX+7w7wON6/PPP5f+/fvLn/70JzOU3LdvX5k9e7arm2VZ5557rixatEh27txpbm/YsEF++uknueyyy1zdNEvbt2+fpKSkOPy/Svcm1RKYup7LLbu5a0ZGhhkTjo6Odjiut7dv3+6ydlldeXm5qVfRoYJevXq5ujmWNGfOHDOErENmcJ29e/eaIRod1n/ooYfMz+POO+8UPz8/GTdunKubZzmTJ082O913795dvL29zfnjb3/7m1x//fWubpqlpaSkmK81ncsr76stywYiuG/PxObNm81fXmh8ycnJctddd5laLp1oANf+caA9RE899ZS5rT1E+m9D6yQIRI3v448/lg8++EA+/PBD6dmzp6xfv9788aaFvvw8PINlh8yioqJMyk9NTXU4rrdjYmJc1i4ru/322+XLL7+UxYsXS9u2bV3dHEvSYWSdVHDOOeeIj4+PuWjRuxYs6nX9qxiNQ2fM9OjRw+HY2WefLUlJSS5rk5Xdf//9ppfoz3/+s5ntN2bMGLnnnnvMLFm4TuX52hnncssGIu127tevnxkTrvoXmd4ePHiwS9tmNVonp2Fo3rx58v3335tprXCNYcOGyaZNm8xfv5UX7aXQYQG9rn9EoHHosHH15Se0fqV9+/Yua5OVFRQUmDrTqvTfg5434Dp6vtDgU/VcrkObOtusrudySw+Z6di8dnXq//AHDhwoL7/8spneN378eFc3zXLDZNoN/dlnn5m1iCrHfbUwTteUQOPR73/12i2dwqrr4FDT1bi090ELeXXI7LrrrjNrpM2aNctc0Ph0HRytGWrXrp0ZMlu3bp28+OKLMmHCBFc3zePl5eXJ7t27HQqp9Q80nXijPw8dunzyySela9euJiDpelE6lKlr2tWJzeL+/ve/29q1a2fz8/Mz0/BXrFjh6iZZjv4a1nR55513XN002GxMu3ehL774wtarVy8zhbh79+62WbNmubpJlpWTk2P+Hej5IiAgwNapUyfbww8/bCsqKnJ10zze4sWLazxHjBs3zj71furUqbbo6Gjzb2XYsGG2HTt21Pl9mul/nJ/nAAAAmg7L1hABAABUIhABAADLIxABAADLIxABAADLIxABAADLIxABAADLIxABAADLIxABAADLIxABAADLIxABHurCCy80e/yc7HZjvKeruVt7ALgvAhFwGjfeeKM0a9ZMnn76aYfj8+fPN8ebik8//VSmT5/u6mY0KQQqwDoIREAtBAQEyDPPPCNHjx512msWFxdLY9KdoXU3eyto7O+tu71/U20b4EoEIqAWhg8fLjExMTJjxoyTPqaoqEjuvPNOadWqlQlQQ4YMkV9++cWht+H22283PQ5RUVEyYsQI+/E77rjDHA8PD5fo6GiZPXu25Ofny/jx402I6dKli/zvf/9zeL8FCxaY92jRooVERkbKH/7wB9mzZ0+tejv2799vereqX/Qxqry83HzWjh07SmBgoCQkJMgnn3zi8HravrFjx0rz5s2ldevW8sILL5z2+1ifz1qbz3my7211X331lYSFhckHH3xw2s+pPYM//PCDvPLKK/bvj37fTva5anr/030f9Xp8fLy5Tz+b/p7p96I2v0+qQ4cO8vLLLzsc69Onjzz22GOnbJu269lnnzXfa39/f2nXrp387W9/sz+nNj//U7W9usrft//+979y/vnnm+cMGDBAkpKS5Mcff5RBgwZJUFCQDBs2TLKysmp8DeCM+23jewA1GTdunO3KK6+0ffrpp7aAgABbcnKyOT5v3jxb1X9Cd955py02Ntb29ddf27Zs2WKeFx4ebsvMzDT3X3DBBbbmzZvb7r//ftv27dvNpfJ4SEiIbfr06badO3ear97e3rbLLrvMNmvWLHNs4sSJtsjISFt+fr79/T755BPbf//7X9uuXbts69ats40cOdIWHx9vKysrs7/uXXfdZX981dulpaW2w4cP2y/6fH39qVOnmvuffPJJW/fu3W0LFiyw7dmzx/bOO+/Y/P39bUuWLLG/nrapXbt2toULF9o2btxo+8Mf/mA+R9X3rK4+n/V0n/N039vK9nzwwQfmvb/44gv78071ObOysmyDBw+23XLLLfbvk37fTva5anr/U73+oUOHbD4+PrYXX3zRtm/fPvM9fP311225ubm1+n1S7du3t7300ksObUlISLA9+uijp2zbAw88YF7r3Xffte3evdv2448/2mbPnl2r74s6Xdurmz9/vvm3MmzYMPNea9eutcXFxdmGDh1q+/3vf2/75ZdfbCtWrDA/d31NwBUIREAtA5EaNGiQbcKECScEory8PJuvr6856VYqLi42J7Rnn33WfmLq27fvCa+vx4cMGWK/rSfd4OBg25gxY+zH9GSs77V8+fKTtjM9Pd08ZtOmTacNRFUdO3bMlpiYaAKNhozCwkJbUFCQbdmyZQ6Pu+mmm2yjR4821/XE5+fnZ/v444/t9+uJOjAw8LSBqKGftfrnPN33Vtvz2muv2cLCwhwCXW0+58m+ZzW9T/X3P93rr1mzxnyO/fv3n/B6tfl9qksgqtq2nJwcE26qBqC6tFudqu01eeyxx2wRERG2jIwM+7EbbrjB1qFDB4eQ/7vf/c6EtUoaxj777LNavQfQUD5nvg8K8BxaR3TxxRfLfffd53Bch3BKSkrkvPPOsx/z9fWVgQMHyrZt2+zH+vXrV+Pr9u7d237d29vbDEHocEQlHVpSaWlp9mO7du2SadOmycqVKyUjI8MMcygdhujVq1etP9OECRMkNzdXvvvuO/Hy8pLdu3dLQUGBXHLJJSfUnvTt29f+efV2YmKiQ43SWWedddr3q+tnre3nPNn3Vod29LV+/vlnM0xTqTafsy6qv//pXl+HoXSISD+7DmNdeumlcu2115qhxNr+PtWnbfp8HY7T965Jbb4vp2p7TTZs2CBXX321+VlX0p/fqFGjzFBZ1WNXXnml/bYOnerv5hVXXFHnzwzUFYEIqAOtf9ATwJQpU0yNSV0FBwfXeFxPdlVpvUXVY5Wz2SrDgBo5cqS0b9/e1ODExsaa+zQg1KVo9sknn5RvvvlGVq1aZS+4zsvLs9fbtGnTxuHxWm/SUHX9rLX9nCf73upJfO3atfL2229L//797a/v7M9Z/f1P9/oaBjWELlu2TL799lv5+9//Lg8//LAJfrWlAVZ7+qvSIHWqtmn9zqnU5vtyqrZr3VF169evN/9mqoeke+65x367sLBQduzYYcKW0vqtqVOnmhA1d+5c+emnn076MwacgaJqoI50+v0XX3why5cvtx/r3Lmz+Pn5mV6IqicmLYLt0aOH09uQmZlpTh6PPPKI+Uv97LPPrvMMOC1wfeKJJ+Tjjz827a+k7dUTn/61rkW3VS9xcXHmMfp4DTFVT976/jt37nS7z6ltXbx4sXz22WemoLsun1N/pmVlZfVqe21eX8OZ9gI9/vjjsm7dOvN+8+bNq/XvU8uWLeXw4cP22zk5ObJv375Ttqtr164mFC1atKje7T5V26vTNmlRddVeN21jdna2w7FNmzaZcFfZW3jBBReY3kQNXvr6hCGcafQQAXWk/8O+/vrr5dVXX7Uf0/9ZT5w4Ue6//34zdKSzdnQWjw493HTTTU5vgw5N6F/Os2bNMjO89OQ1efLkWj9/8+bNZobYgw8+KD179pSUlBRzXE9q2n4dEtS/3rU3Rmc36clLT86hoaEybtw4M7NMP5d+Xm2HzoTSHgLtsXCnz1mpW7duJhTpjCsfHx8zM0t7xE73OXUWl4Y+PaHrZ9bvTW0/4+lev3v37iaU6HCTfv/0fdLT003oq+3vkw7fvvvuu6YXTWfh6dCi9t6cis5Y05/7Aw88YH7eGmr0fbds2WJeuzbfF23rydpenfYEaZuqDm9qj5F+Lu35q3pMg6B+nyvpz1t/BkBjIBAB9aA9K9qNX73nSE8gY8aMMXUPOjyjw1Enq6toCD0pz5kzx0zL1hON1u5oQKucNn86q1evNidXHTLTSyX9q3zJkiVmAUftfdCp13v37jUn23POOUceeugh+2Ofe+45M7yiJ2M9id57773mxOlOn7Mqfe73339vnqsnaF0m4HSfU4OBBgDtNTl27Jjp2ajLCfpUr6/hYunSpSacaS+KhgNt02WXXVbr3ycdhtI26VIEupyAvt/peoiUDkVpMNQAdejQIRM2b7311lq1W52u7dUDkX7vNYhVPVa9TkuPVQ6XqQMHDpghUqCxNNPK6kZ7NwAAakF7pDRw/ec//3F1U2AR1BABANyO9ghq75QOUW/dutXVzYEF0EMEAAAsjx4iAABgeQQiAABgeQQiAABgeQQiAABgeQQiAABgeQQiAABgeQQiAABgeQQiAABgeQQiAABgeQQiAABgeQQiAABgeQQiAAAgVvf/AeheUhR/aN9NAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "if solve_agg_shocks_micro:\n", - " # Solve the microeconomic model for the aggregate shocks example type (and display results)\n", - " t_start = process_time()\n", - " AggShockExample.solve()\n", - " t_end = process_time()\n", - " print(\n", - " \"Solving an aggregate shocks consumer took \"\n", - " + mystr(t_end - t_start)\n", - " + \" seconds.\",\n", - " )\n", - " print(\n", - " \"Consumption function at each aggregate market resources-to-labor ratio gridpoint:\",\n", - " )\n", - " m_grid = np.linspace(0, 10, 200)\n", - " AggShockExample.unpack(\"cFunc\")\n", - " for M in AggShockExample.Mgrid.tolist():\n", - " mMin = AggShockExample.solution[0].mNrmMin(M)\n", - " c_at_this_M = AggShockExample.cFunc[0](m_grid + mMin, M * np.ones_like(m_grid))\n", - " plt.plot(m_grid + mMin, c_at_this_M)\n", - " plt.ylim(0.0, None)\n", - " plt.xlim(0.0, 10.0)\n", - " plt.xlabel(r\"Normalized market resources $m_t$\")\n", - " plt.ylabel(r\"Normalized consumption $c_t$\")\n", - " plt.show()" + "AggShockExampleAlt.unpack(\"cFunc\")\n", + "plt.xlabel(r\"Normalized market resources $m_t$\")\n", + "plt.ylabel(r\"Normalized consumption $c_t$\")\n", + "plot_func_slices(AggShockExampleAlt.cFunc[0], 0.0, 10.0, Z=[1.0])\n", + "plt.show()" ] }, { @@ -168,29 +287,28 @@ "intercept=-0.3343546337095779, slope=1.0651813619488595, r-sq=0.9918971767796609\n", "intercept=-0.3342166296959199, slope=1.0651293833970874, r-sq=0.9919007696687092\n", "intercept=-0.33415813467441513, slope=1.0651074158458098, r-sq=0.9919022896745456\n", - "Solving the \"macroeconomic\" aggregate shocks model took 1916.7344 seconds.\n" + "Solving the \"macroeconomic\" aggregate shocks model took 376.0589 seconds.\n" ] } ], "source": [ - "if solve_agg_shocks_market:\n", - " # Solve the \"macroeconomic\" model by searching for a \"fixed point dynamic rule\"\n", - " t_start = process_time()\n", - " print(\n", - " \"Now solving for the equilibrium of a Cobb-Douglas economy. This might take a few minutes...\",\n", - " )\n", - " EconomyExample.solve()\n", - " t_end = process_time()\n", - " print(\n", - " 'Solving the \"macroeconomic\" aggregate shocks model took '\n", - " + mystr(t_end - t_start)\n", - " + \" seconds.\",\n", - " )" + "# Solve the \"macroeconomic\" model by searching for a \"fixed point dynamic rule\"\n", + "t_start = time()\n", + "print(\n", + " \"Now solving for the equilibrium of a Cobb-Douglas economy. This might take a few minutes...\",\n", + ")\n", + "CobbDouglasExample.solve()\n", + "t_end = time()\n", + "print(\n", + " 'Solving the \"macroeconomic\" aggregate shocks model took '\n", + " + mystr(t_end - t_start)\n", + " + \" seconds.\",\n", + ")" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": { "editable": true, "slideshow": { @@ -210,7 +328,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\Matthew\\Documents\\GitHub\\HARK\\HARK\\ConsumptionSaving\\ConsAggShockModel.py:2994: RuntimeWarning: divide by zero encountered in log\n", + "C:\\Users\\Matthew\\Documents\\GitHub\\HARK\\HARK\\ConsumptionSaving\\ConsAggShockModel.py:3024: RuntimeWarning: divide by zero encountered in log\n", " Aagg = np.exp(self.intercept + self.slope * np.log(Mnow))\n" ] }, @@ -226,17 +344,16 @@ } ], "source": [ - "if solve_agg_shocks_market:\n", - " print(\"Aggregate savings as a function of aggregate market resources:\")\n", - " plt.xlabel(r\"Aggregate market resources $M_t$\")\n", - " plt.ylabel(r\"Aggregate assets retained $A_t$\")\n", - " plt.ylim(0.0, 27.0)\n", - " plot_funcs(EconomyExample.AFunc, 0, 2 * EconomyExample.kSS)" + "print(\"Aggregate savings as a function of aggregate market resources:\")\n", + "plt.xlabel(r\"Aggregate market resources $M_t$\")\n", + "plt.ylabel(r\"Aggregate assets retained $A_t$\")\n", + "plt.ylim(0.0, 27.0)\n", + "plot_funcs(CobbDouglasExample.AFunc, 0, 2 * CobbDouglasExample.kSS)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "metadata": { "editable": true, "slideshow": { @@ -247,16 +364,9 @@ ] }, "outputs": [ - { - "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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", + "image/png": "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", "text/plain": [ "
" ] @@ -266,358 +376,16 @@ } ], "source": [ - "if solve_agg_shocks_market:\n", - " print(\n", - " \"Consumption function at each aggregate market resources gridpoint (in general equilibrium):\",\n", - " )\n", - " AggShockExample.unpack(\"cFunc\")\n", - " m_grid = np.linspace(0, 10, 200)\n", - " for M in AggShockExample.Mgrid.tolist():\n", - " mMin = AggShockExample.solution[0].mNrmMin(M)\n", - " c_at_this_M = AggShockExample.cFunc[0](m_grid + mMin, M * np.ones_like(m_grid))\n", - " plt.plot(m_grid + mMin, c_at_this_M)\n", - " plt.ylim(0.0, None)\n", - " plt.xlim(0.0, 10.0)\n", - " plt.xlabel(r\"Normalized market resources $m_t$\")\n", - " plt.ylabel(r\"Normalized consumption $c_t$\")\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "source": [ - "### Example Implementations of AggShockMarkovConsumerType" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "if solve_markov_micro or solve_markov_market or solve_krusell_smith:\n", - " # Make a Markov aggregate shocks consumer type\n", - " AggShockMrkvExample = AggShockMarkovConsumerType(cycles=0)\n", - "\n", - " # Make a Cobb-Douglas economy for the agents\n", - " MrkvEconomyExample = CobbDouglasMarkovEconomy(agents=[AggShockMrkvExample])\n", - " MrkvEconomyExample.DampingFac = 0.2 # Turn down damping\n", - " MrkvEconomyExample.make_AggShkHist() # Simulate a history of aggregate shocks\n", - " MrkvEconomyExample.give_agent_params() # Have the consumers inherit relevant objects from the economy" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "if solve_markov_micro:\n", - " # Solve the microeconomic model for the Markov aggregate shocks example type (and display results)\n", - " t_start = process_time()\n", - " AggShockMrkvExample.solve()\n", - " t_end = process_time()\n", - " print(\n", - " \"Solving an aggregate shocks Markov consumer took \"\n", - " + mystr(t_end - t_start)\n", - " + \" seconds.\",\n", - " )\n", - "\n", - " print(\n", - " \"Consumption function at each aggregate market \\\n", - " resources-to-labor ratio gridpoint (for each macro state):\",\n", - " )\n", - " m_grid = np.linspace(0, 10, 200)\n", - " AggShockMrkvExample.unpack(\"cFunc\")\n", - " for i in range(2):\n", - " for M in AggShockMrkvExample.Mgrid.tolist():\n", - " mMin = AggShockMrkvExample.solution[0].mNrmMin[i](M)\n", - " c_at_this_M = AggShockMrkvExample.cFunc[0][i](\n", - " m_grid + mMin,\n", - " M * np.ones_like(m_grid),\n", - " )\n", - " plt.plot(m_grid + mMin, c_at_this_M)\n", - " plt.ylim(0.0, None)\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Now solving a two-state Markov economy. This should take a few minutes...\n", - "intercept=[-0.430062793648883, -0.5593886069268711], slope=[1.1093649400605665, 1.1760758345082476], r-sq=[0.9983884180880858, 0.993959087437493]\n", - "intercept=[-0.37367280849863393, -0.414184491383495], slope=[1.0718305801212595, 1.084211446145626], r-sq=[0.9998946141824966, 0.9997702549994318]\n", - "intercept=[-0.32574803203970637, -0.36724527845084626], slope=[1.0619585906358524, 1.0735597295406312], r-sq=[0.9999480288751184, 0.9999328364044875]\n", - "intercept=[-0.33321427631292827, -0.379129293579865], slope=[1.0651300304411082, 1.0781815604554], r-sq=[0.9999438763428687, 0.9999292560206335]\n", - "intercept=[-0.3338414759733823, -0.3794926971269227], slope=[1.0653875774089596, 1.078358385999942], r-sq=[0.9999436563965093, 0.9999287137688387]\n", - "intercept=[-0.33395180326330787, -0.37956105021186426], slope=[1.0654270574481086, 1.0783865741931447], r-sq=[0.9999436370759014, 0.999928664028442]\n", - "intercept=[-0.3339604851607033, -0.3795617690666433], slope=[1.0654299457585314, 1.0783872668348968], r-sq=[0.9999436378361827, 0.9999286603584934]\n", - "Solving the \"macroeconomic\" aggregate shocks model took 452.0156 seconds.\n", - "Consumption function at each aggregate market resources-to-labor ratio gridpoint (for each macro state):\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "if solve_markov_market:\n", - " # Solve the \"macroeconomic\" model by searching for a \"fixed point dynamic rule\"\n", - " t_start = process_time()\n", - " print(\"Now solving a two-state Markov economy. This should take a few minutes...\")\n", - " MrkvEconomyExample.solve()\n", - " t_end = process_time()\n", - " print(\n", - " 'Solving the \"macroeconomic\" aggregate shocks model took '\n", - " + mystr(t_end - t_start)\n", - " + \" seconds.\",\n", - " )\n", - "\n", - " print(\n", - " \"Consumption function at each aggregate market resources-to-labor ratio gridpoint (for each macro state):\",\n", - " )\n", - " m_grid = np.linspace(0, 10, 200)\n", - " AggShockMrkvExample.unpack(\"cFunc\")\n", - " for i in range(2):\n", - " for M in AggShockMrkvExample.Mgrid.tolist():\n", - " mMin = AggShockMrkvExample.solution[0].mNrmMin[i](M)\n", - " c_at_this_M = AggShockMrkvExample.cFunc[0][i](\n", - " m_grid + mMin,\n", - " M * np.ones_like(m_grid),\n", - " )\n", - " plt.plot(m_grid + mMin, c_at_this_M)\n", - " plt.ylim(0.0, None)\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Now solving a Krusell-Smith-style economy. This should take about a minute...\n", - "intercept=[-0.3722306376061314, -0.3682722001474821], slope=[1.0767791693959459, 1.0762410142170347], r-sq=[0.9999975316888602, 0.9999926247573542]\n", - "intercept=[-0.3743372605970883, -0.36746083619881637], slope=[1.0771768050497454, 1.076026193877861], r-sq=[0.9999979658200893, 0.9999931043288537]\n", - "intercept=[-0.37414080445966263, -0.36716559489058087], slope=[1.0770751682085105, 1.075925782470145], r-sq=[0.9999980140055872, 0.9999931577528473]\n", - "intercept=[-0.37413364911298685, -0.36716233243499796], slope=[1.0770698237152097, 1.0759250325580814], r-sq=[0.9999980169013951, 0.9999931595489653]\n", - "Solving the Krusell-Smith model took 48.2500 seconds.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "intercept=[-0.3600899736514895, -0.35512016452337497], slope=[1.0714753213364976, 1.0712256905434414], r-sq=[0.9999986714166439, 0.9999961301697309]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "intercept=[-0.3788395320005977, -0.3715109817321105], slope=[1.0786573434429672, 1.0774887741894947], r-sq=[0.9999982037028008, 0.9999942754223826]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "intercept=[-0.37896012954317376, -0.37156486819095047], slope=[1.0787111353569707, 1.0775241504232804], r-sq=[0.9999982049718272, 0.9999940788572959]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "intercept=[-0.37899550407019866, -0.3715956660284524], slope=[1.0787232463104646, 1.0775357473879463], r-sq=[0.9999982037318698, 0.9999940713848707]\n", - "Solving the Krusell-Smith model took 41.253191999999984 seconds.\n" - ] - } - ], - "source": [ - "if solve_krusell_smith:\n", - " # Make a Krusell-Smith agent type\n", - " # NOTE: These agents aren't exactly like KS, as they don't have serially correlated unemployment\n", - " KSexampleType = AggShockMarkovConsumerType(\n", - " cycles=0,\n", - " PermShkStd=np.array([[0.0, 0.0]]),\n", - " TranShkStd=np.array([[0.0, 0.0]]),\n", - " IncUnemp=np.array([0.0, 0.0]),\n", - " UnempPrb=np.array([0.04, 0.10]),\n", - " )\n", - "\n", - " # Make a KS economy\n", - " KSeconomy = CobbDouglasMarkovEconomy(\n", - " agents=[KSexampleType], DampingFac=0.2, PermGroFacAgg=[1.0, 1.0]\n", - " )\n", - " KSeconomy.AggShkDstn = [\n", - " DiscreteDistribution(\n", - " np.array([1.0]),\n", - " np.array([[1.0], [1.05]]),\n", - " ),\n", - " DiscreteDistribution(\n", - " np.array([1.0]),\n", - " np.array([[1.0], [0.95]]),\n", - " ),\n", - " ]\n", - " KSeconomy.give_agent_params()\n", - " KSeconomy.make_AggShkHist()\n", - "\n", - " # Solve the K-S model\n", - " t_start = process_time()\n", - " print(\n", - " \"Now solving a Krusell-Smith-style economy. This should take about a minute...\",\n", - " )\n", - " KSeconomy.solve()\n", - " t_end = process_time()\n", - " print(\n", - " \"Solving the Krusell-Smith model took \" + mystr(t_end - t_start) + \" seconds.\"\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "if solve_poly_state:\n", - " StateCount = 15 # Number of Markov states\n", - " GrowthAvg = 1.01 # Average permanent income growth factor\n", - " GrowthWidth = 0.02 # PermGroFacAgg deviates from PermGroFacAgg in this range\n", - " Persistence = 0.90 # Probability of staying in the same Markov state\n", - " PermGroFacAgg = np.linspace(\n", - " GrowthAvg - GrowthWidth,\n", - " GrowthAvg + GrowthWidth,\n", - " num=StateCount,\n", - " )\n", - "\n", - " # Make the Markov array with chosen states and persistence\n", - " PolyMrkvArray = np.zeros((StateCount, StateCount))\n", - " for i in range(StateCount):\n", - " for j in range(StateCount):\n", - " if i == j:\n", - " PolyMrkvArray[i, j] = Persistence\n", - " elif (i == (j - 1)) or (i == (j + 1)):\n", - " PolyMrkvArray[i, j] = 0.5 * (1.0 - Persistence)\n", - " PolyMrkvArray[0, 0] += 0.5 * (1.0 - Persistence)\n", - " PolyMrkvArray[StateCount - 1, StateCount - 1] += 0.5 * (1.0 - Persistence)\n", - "\n", - " # Make a consumer type to inhabit the economy\n", - " PolyStateExample = AggShockMarkovConsumerType()\n", - " PolyStateExample.MrkvArray = PolyMrkvArray\n", - " PolyStateExample.PermGroFacAgg = PermGroFacAgg\n", - " PolyStateExample.IncShkDstn[0] = StateCount * [PolyStateExample.IncShkDstn[0]]\n", - " PolyStateExample.cycles = 0\n", - "\n", - " # Make a Cobb-Douglas economy for the agents\n", - " # Use verbose=False to remove printing of intercept\n", - " PolyStateEconomy = CobbDouglasMarkovEconomy(\n", - " agents=[PolyStateExample],\n", - " verbose=False,\n", - " )\n", - " PolyStateEconomy.MrkvArray = PolyMrkvArray\n", - " PolyStateEconomy.PermGroFacAgg = PermGroFacAgg\n", - " PolyStateEconomy.PermShkAggStd = StateCount * [0.006]\n", - " PolyStateEconomy.TranShkAggStd = StateCount * [0.003]\n", - " PolyStateEconomy.slope_prev = StateCount * [1.0]\n", - " PolyStateEconomy.intercept_prev = StateCount * [0.0]\n", - " PolyStateEconomy.update()\n", - " PolyStateEconomy.makeAggShkDstn()\n", - " PolyStateEconomy.make_AggShkHist() # Simulate a history of aggregate shocks\n", - " PolyStateEconomy.give_agent_params() # Have the consumers inherit relevant objects from the economy\n", - "\n", - " # Solve the many state model\n", - " t_start = process_time()\n", - " print(\n", - " \"Now solving an economy with \"\n", - " + str(StateCount)\n", - " + \" Markov states. This might take a while...\",\n", - " )\n", - " PolyStateEconomy.solve()\n", - " t_end = process_time()\n", - " print(\n", - " \"Solving a model with \"\n", - " + str(StateCount)\n", - " + \" states took \"\n", - " + str(t_end - t_start)\n", - " + \" seconds.\",\n", - " )" + "AggShockExample.unpack(\"cFunc\")\n", + "plt.xlabel(r\"Normalized market resources $m_t$\")\n", + "plt.ylabel(r\"Normalized consumption $c_t$\")\n", + "plot_func_slices(AggShockExample.cFunc[0], 0.0, 10.0, Z=AggShockExample.Mgrid)" ] }, { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "metadata": {}, "outputs": [], "source": [] } diff --git a/examples/ConsAggShockModel/AggShockMarkovConsumerType.ipynb b/examples/ConsAggShockModel/AggShockMarkovConsumerType.ipynb new file mode 100644 index 000000000..b9487d189 --- /dev/null +++ b/examples/ConsAggShockModel/AggShockMarkovConsumerType.ipynb @@ -0,0 +1,227 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "f0ea03d5-4348-4efa-98d4-5889376fd810", + "metadata": {}, + "outputs": [], + "source": [ + "# Make a Markov aggregate shocks consumer type\n", + "AggShockMrkvExample = AggShockMarkovConsumerType(cycles=0)\n", + "\n", + "# Make a Cobb-Douglas economy for the agents\n", + "MrkvEconomyExample = CobbDouglasMarkovEconomy(agents=[AggShockMrkvExample])\n", + "MrkvEconomyExample.DampingFac = 0.2 # Turn down damping\n", + "MrkvEconomyExample.make_AggShkHist() # Simulate a history of aggregate shocks\n", + "MrkvEconomyExample.give_agent_params() # Have the consumers inherit relevant objects from the economy" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e66375b6-f313-4643-b977-5e83bb7c6b14", + "metadata": {}, + "outputs": [], + "source": [ + "# Solve the microeconomic model for the Markov aggregate shocks example type (and display results)\n", + "t_start = process_time()\n", + "AggShockMrkvExample.solve()\n", + "t_end = process_time()\n", + "print(\n", + " \"Solving an aggregate shocks Markov consumer took \"\n", + " + mystr(t_end - t_start)\n", + " + \" seconds.\",\n", + ")\n", + "\n", + "print(\n", + " \"Consumption function at each aggregate market \\\n", + " resources-to-labor ratio gridpoint (for each macro state):\",\n", + ")\n", + "m_grid = np.linspace(0, 10, 200)\n", + "AggShockMrkvExample.unpack(\"cFunc\")\n", + "for i in range(2):\n", + " for M in AggShockMrkvExample.Mgrid.tolist():\n", + " mMin = AggShockMrkvExample.solution[0].mNrmMin[i](M)\n", + " c_at_this_M = AggShockMrkvExample.cFunc[0][i](\n", + " m_grid + mMin,\n", + " M * np.ones_like(m_grid),\n", + " )\n", + " plt.plot(m_grid + mMin, c_at_this_M)\n", + " plt.ylim(0.0, None)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "566778e9-5fdc-4374-a310-7e49d483b478", + "metadata": {}, + "outputs": [], + "source": [ + "# Solve the \"macroeconomic\" model by searching for a \"fixed point dynamic rule\"\n", + "t_start = process_time()\n", + "print(\"Now solving a two-state Markov economy. This should take a few minutes...\")\n", + "MrkvEconomyExample.solve()\n", + "t_end = process_time()\n", + "print(\n", + " 'Solving the \"macroeconomic\" aggregate shocks model took '\n", + " + mystr(t_end - t_start)\n", + " + \" seconds.\",\n", + ")\n", + "\n", + "print(\n", + " \"Consumption function at each aggregate market resources-to-labor ratio gridpoint (for each macro state):\",\n", + ")\n", + "m_grid = np.linspace(0, 10, 200)\n", + "AggShockMrkvExample.unpack(\"cFunc\")\n", + "for i in range(2):\n", + " for M in AggShockMrkvExample.Mgrid.tolist():\n", + " mMin = AggShockMrkvExample.solution[0].mNrmMin[i](M)\n", + " c_at_this_M = AggShockMrkvExample.cFunc[0][i](\n", + " m_grid + mMin,\n", + " M * np.ones_like(m_grid),\n", + " )\n", + " plt.plot(m_grid + mMin, c_at_this_M)\n", + " plt.ylim(0.0, None)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0dcaa12a-594d-430a-ab92-a284d0366e28", + "metadata": {}, + "outputs": [], + "source": [ + "# Make a Krusell-Smith agent type\n", + "# NOTE: These agents aren't exactly like KS, as they don't have serially correlated unemployment\n", + "KSexampleType = AggShockMarkovConsumerType(\n", + " cycles=0,\n", + " PermShkStd=np.array([[0.0, 0.0]]),\n", + " TranShkStd=np.array([[0.0, 0.0]]),\n", + " IncUnemp=np.array([0.0, 0.0]),\n", + " UnempPrb=np.array([0.04, 0.10]),\n", + ")\n", + "\n", + "# Make a KS economy\n", + "KSeconomy = CobbDouglasMarkovEconomy(\n", + " agents=[KSexampleType], DampingFac=0.2, PermGroFacAgg=[1.0, 1.0]\n", + ")\n", + "KSeconomy.AggShkDstn = [\n", + " DiscreteDistribution(\n", + " np.array([1.0]),\n", + " np.array([[1.0], [1.05]]),\n", + " ),\n", + " DiscreteDistribution(\n", + " np.array([1.0]),\n", + " np.array([[1.0], [0.95]]),\n", + " ),\n", + "]\n", + "KSeconomy.give_agent_params()\n", + "KSeconomy.make_AggShkHist()\n", + "\n", + "# Solve the K-S model\n", + "t_start = process_time()\n", + "print(\n", + " \"Now solving a Krusell-Smith-style economy. This should take about a minute...\",\n", + ")\n", + "KSeconomy.solve()\n", + "t_end = process_time()\n", + "print(\"Solving the Krusell-Smith model took \" + mystr(t_end - t_start) + \" seconds.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6e6b20c7-3588-47d0-b92a-10df10ff5785", + "metadata": {}, + "outputs": [], + "source": [ + "# Poly-state example\n", + "StateCount = 15 # Number of Markov states\n", + "GrowthAvg = 1.01 # Average permanent income growth factor\n", + "GrowthWidth = 0.02 # PermGroFacAgg deviates from PermGroFacAgg in this range\n", + "Persistence = 0.90 # Probability of staying in the same Markov state\n", + "PermGroFacAgg = np.linspace(\n", + " GrowthAvg - GrowthWidth,\n", + " GrowthAvg + GrowthWidth,\n", + " num=StateCount,\n", + ")\n", + "\n", + "# Make the Markov array with chosen states and persistence\n", + "PolyMrkvArray = np.zeros((StateCount, StateCount))\n", + "for i in range(StateCount):\n", + " for j in range(StateCount):\n", + " if i == j:\n", + " PolyMrkvArray[i, j] = Persistence\n", + " elif (i == (j - 1)) or (i == (j + 1)):\n", + " PolyMrkvArray[i, j] = 0.5 * (1.0 - Persistence)\n", + "PolyMrkvArray[0, 0] += 0.5 * (1.0 - Persistence)\n", + "PolyMrkvArray[StateCount - 1, StateCount - 1] += 0.5 * (1.0 - Persistence)\n", + "\n", + "# Make a consumer type to inhabit the economy\n", + "PolyStateExample = AggShockMarkovConsumerType()\n", + "PolyStateExample.MrkvArray = PolyMrkvArray\n", + "PolyStateExample.PermGroFacAgg = PermGroFacAgg\n", + "PolyStateExample.IncShkDstn[0] = StateCount * [PolyStateExample.IncShkDstn[0]]\n", + "PolyStateExample.cycles = 0\n", + "\n", + "# Make a Cobb-Douglas economy for the agents\n", + "# Use verbose=False to remove printing of intercept\n", + "PolyStateEconomy = CobbDouglasMarkovEconomy(\n", + " agents=[PolyStateExample],\n", + " verbose=False,\n", + ")\n", + "PolyStateEconomy.MrkvArray = PolyMrkvArray\n", + "PolyStateEconomy.PermGroFacAgg = PermGroFacAgg\n", + "PolyStateEconomy.PermShkAggStd = StateCount * [0.006]\n", + "PolyStateEconomy.TranShkAggStd = StateCount * [0.003]\n", + "PolyStateEconomy.slope_prev = StateCount * [1.0]\n", + "PolyStateEconomy.intercept_prev = StateCount * [0.0]\n", + "PolyStateEconomy.update()\n", + "PolyStateEconomy.makeAggShkDstn()\n", + "PolyStateEconomy.make_AggShkHist() # Simulate a history of aggregate shocks\n", + "PolyStateEconomy.give_agent_params() # Have the consumers inherit relevant objects from the economy\n", + "\n", + "# Solve the many state model\n", + "t_start = process_time()\n", + "print(\n", + " \"Now solving an economy with \"\n", + " + str(StateCount)\n", + " + \" Markov states. This might take a while...\",\n", + ")\n", + "PolyStateEconomy.solve()\n", + "t_end = process_time()\n", + "print(\n", + " \"Solving a model with \"\n", + " + str(StateCount)\n", + " + \" states took \"\n", + " + str(t_end - t_start)\n", + " + \" seconds.\",\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 87c89aae523aefa725f02ec35fd1aae21d3d090c Mon Sep 17 00:00:00 2001 From: "Matthew N. White" Date: Tue, 3 Mar 2026 12:32:18 -0500 Subject: [PATCH 2/3] Improved AggShockConsumerType NB The IndShock notebook was also lightly adjusted. --- HARK/ConsumptionSaving/ConsAggShockModel.py | 18 +- HARK/core.py | 2 +- .../AggShockConsumerType.ipynb | 270 ++++++++++++++---- .../IndShockConsumerType.ipynb | 12 +- 4 files changed, 229 insertions(+), 73 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsAggShockModel.py b/HARK/ConsumptionSaving/ConsAggShockModel.py index eb4503439..e492a1d87 100644 --- a/HARK/ConsumptionSaving/ConsAggShockModel.py +++ b/HARK/ConsumptionSaving/ConsAggShockModel.py @@ -758,8 +758,8 @@ def solve_KrusellSmith( default_aXtraGrid_params = { "aXtraMin": 0.001, # Minimum end-of-period "assets above minimum" value "aXtraMax": 20, # Maximum end-of-period "assets above minimum" value - "aXtraNestFac": 3, # Exponential nesting factor for aXtraGrid - "aXtraCount": 24, # Number of points in the grid of "assets above minimum" + "aXtraNestFac": 2, # Exponential nesting factor for aXtraGrid + "aXtraCount": 36, # Number of points in the grid of "assets above minimum" "aXtraExtra": None, # Additional other values to add in grid (optional) } @@ -1668,12 +1668,11 @@ def get_poststates(self): "DiscFac": 0.96, # Discount factor of perfect foresight calibration "CRRA": 2.0, # Coefficient of relative risk aversion of perfect foresight calibration "PermGroFacAgg": 1.0, # Aggregate permanent income growth factor - "AggregateL": 1.0, "intercept_prev": 0.0, # Intercept of aggregate savings function "slope_prev": 1.0, # Slope of aggregate savings function, - "verbose": True, # Whether to print solution progress to screen while solving + "verbose": False, # 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 + "DampingFac": 0.1, # Damping factor when updating AFunc "max_loops": 20, # Maximum number of AFunc updating loops to allow } @@ -2001,12 +2000,9 @@ def calc_AFunc(self, MaggNow, AaggNow): "Rfree": 1.02, # exogenous and fixed return factor on assets "wRte": 1.0, # exogenous and fixed wage rate "PermGroFacAgg": 1.0, # Aggregate permanent income growth factor - "AggregateL": 1.0, "intercept_prev": 0.0, # Intercept of aggregate savings function "slope_prev": 1.0, # Slope of aggregate savings function, - "verbose": 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 + "verbose": False, # Whether to print solution progress to screen while solving "max_loops": 1, # Maximum number of AFunc updating loops to allow, should always be 1 } @@ -2230,8 +2226,8 @@ def get_AggShocks(self): init_mrkv_cobb_douglas["PermGroFacAgg"] = [0.98, 1.02] init_mrkv_cobb_douglas["MrkvArray"] = MrkvArray init_mrkv_cobb_douglas["MrkvInit"] = 0 -init_mrkv_cobb_douglas["slope_prev"] = 2 * [0.0] -init_mrkv_cobb_douglas["intercept_prev"] = 2 * [1.0] +init_mrkv_cobb_douglas["slope_prev"] = 2 * [1.0] +init_mrkv_cobb_douglas["intercept_prev"] = 2 * [0.0] class CobbDouglasMarkovEconomy(CobbDouglasEconomy): diff --git a/HARK/core.py b/HARK/core.py index 912cd69eb..706cffa71 100644 --- a/HARK/core.py +++ b/HARK/core.py @@ -2324,7 +2324,7 @@ def solve_agent(agent, verbose, from_solution=None, from_t=None): "Finished cycle #" + str(completed_cycles) + " in " - + str(t_now - t_last) + + "{:.6f}".format(t_now - t_last) + " seconds, solution distance = " + str(solution_distance) ) diff --git a/examples/ConsAggShockModel/AggShockConsumerType.ipynb b/examples/ConsAggShockModel/AggShockConsumerType.ipynb index ea72fdc42..74ddffdb8 100644 --- a/examples/ConsAggShockModel/AggShockConsumerType.ipynb +++ b/examples/ConsAggShockModel/AggShockConsumerType.ipynb @@ -24,6 +24,7 @@ "from time import time\n", "\n", "import matplotlib.pyplot as plt\n", + "import numpy as np\n", "\n", "from HARK.ConsumptionSaving.ConsAggShockModel import (\n", " AggShockConsumerType,\n", @@ -155,11 +156,103 @@ "\n", "As an alternative to `CobbDouglasEconomy`, you might instead be interested in an environment in which factor prices do *not* fluctuate with aggregate capital and labor (say, because capital is mobile and thus prices are determined by global factors), but there are still aggregate productivity shocks. HARK handles this with the `SmallOpenEconomy` subclass of `Market`.\n", "\n", - "The mechanics of a `SmallOpenEconomy` are simple: the user provides a *fixed* `Rfree` and `wRte` (as well as the `AggShkDstn`) and the functions $\\mathbf{R}(\\cdot)$ and $\\mathbf{W}(\\cdot)$ are specified as `ConstantFunctions` with those values. The aggregate saving function $\\mathsf{A}(M_t)$ is *irrelevant* because the agents know that their future state does not depend on the aggregate state at all; it's arbitrarily specified as the identity function. With a `SmallOpenEconomy`, the agents' microeconomic problem thus only needs to be solved *once*, rather than iterated on to find equilibrium beliefs about aggregate saving.\n", + "The mechanics of a `SmallOpenEconomy` are simple: the user provides a *fixed* `Rfree` and `wRte` (as well as the `AggShkDstn`) and the functions $\\mathbf{R}(\\cdot)$ and $\\mathbf{W}(\\cdot)$ are specified as `ConstantFunctions` with those values. The aggregate saving function $\\mathbf{A}(M_t)$ is *irrelevant* because the agents know that their future state does not depend on the aggregate state at all; it's arbitrarily specified as the identity function. With a `SmallOpenEconomy`, the agents' microeconomic problem thus only needs to be solved *once*, rather than iterated on to find equilibrium beliefs about aggregate saving.\n", "\n", "Put differently, the *structure* of the microeconomic problem is identical whether `CobbDouglasEconomy` or `SmallOpenEconomy` is used, but some details are simplified and trivialized under the latter." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example parameter values for `AggShockConsumerType`\n", + "\n", + "Like other `AgentType` subclasses, `AggShockConsumerType` includes a complete set of default parameters and constructors, so it can be instantiated without any additional arguments. The table below lists the default parameter values.\n", + "\n", + "| Parameter | Description | Code | Value | Time-varying? |\n", + "| :---: | --- | --- | --- | --- |\n", + "| $\\beta$ |Intertemporal discount factor | `DiscFac` | $0.96$ | |\n", + "| $\\rho$|Coefficient of relative risk aversion | `CRRA` | $2.0$ | |\n", + "| $\\mathsf{R}_t$ | Risk free interest factor | `Rfree` | $[1.03]$ | $\\surd$ |\n", + "| $\\mathsf{S}_t$ |Survival probability | `LivPrb` | $[0.98]$ | $\\surd$ |\n", + "| $\\Gamma_{t}$|Permanent income growth factor| `PermGroFac` | $[1.0]$ | $\\surd$ |\n", + "| $\\sigma_\\psi$| Standard deviation of log permanent income shocks | `PermShkStd` | $[0.1]$ |$\\surd$ |\n", + "| $N_\\psi$| Number of discrete permanent income shocks | `PermShkCount` | $7$ | |\n", + "| $\\sigma_\\theta$| Standard deviation of log transitory income shocks | `TranShkStd` | $[0.1]$ | $\\surd$ |\n", + "| $N_\\theta$| Number of discrete transitory income shocks | `TranShkCount` | $7$ | |\n", + "| $\\mho$ | Probability of being unemployed and getting $\\theta=\\underline{\\theta}$ | `UnempPrb` | $0.05$ | |\n", + "| $\\underline{\\theta}$| Transitory shock when unemployed | `IncUnemp` | $0.3$ | |\n", + "| $\\mho^{Ret}$ | Probability of being \"unemployed\" when retired | `UnempPrbRet` | $0.0005$ | |\n", + "| $\\underline{\\theta}^{Ret}$| Transitory shock when \"unemployed\" and retired | `IncUnempRet` | $0.0$ | |\n", + "| $(none)$ | Period of the lifecycle model when retirement begins | `T_retire` | $0$ | |\n", + "| $(none)$ | Minimum value in assets-above-minimum grid | `aXtraMin` | $0.001$ | |\n", + "| $(none)$ | Maximum value in assets-above-minimum grid | `aXtraMax` | $20.0$ | |\n", + "| $(none)$ | Number of points in base assets-above-minimum grid | `aXtraCount` | $36$ | |\n", + "| $(none)$ | Exponential nesting factor for base assets-above-minimum grid | `aXtraNestFac` | $2$ | |\n", + "| $(none)$ | Additional values to add to assets-above-minimum grid | `aXtraExtra` | $None$ | |\n", + "| $\\underline{a}$ | Artificial borrowing constraint (normalized) | `BoroCnstArt` | $0.0$ | |\n", + "| $(none)$ | Number of aggregate $M_t$ gridpoints to use | `MaggCount` | $17$ | |\n", + "| $(none)$ | Base perturbation factor around perfect foresight steady state for grid of $M_t$ | `MaggPerturb` | $0.01$ | |\n", + "| $(none)$ | Log scaling factor for additional $M_t$ gridpoints | `MaggCount` | $0.15$ | |\n", + "\n", + "This model is *usually* used with a standard infinite horizon setup, but the time-varying capabilities are maintained for compatibility across `AgentType` subclasses.\n", + "\n", + "The last three parameters are used to specify the base scaling for the aggregate market resources grid. An `AggShockConsumerType` can build the base for the grid (centered around 1), but needs to be paired with a `CobbDouglasEconomy` (or `SmallOpenEconomy`) to properly rescale the grid around the perfect foresight steady state level-- around where the market will actually be operating." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example parameter values for a `CobbDouglasEconomy`\n", + "\n", + "Some parameters in this model are specified in the `Market` subclass, rather than at the `AgentType` level. The `CobbDouglasEconomy` has the following default parameters:\n", + "\n", + "| Parameter | Description | Code | Value | \n", + "| :---: | --- | --- | --- |\n", + "| $\\delta$ | Capital depreciation rate | `DeprRte` | $0.025$ |\n", + "| $\\alpha$| Capital's share of production | `CapShare` | $0.36$ |\n", + "| $\\beta$ | Intertemporal discount factor (perfect foresight calibration) | `DiscFac` | $0.96$ |\n", + "| $\\rho$ | Coefficient of relative risk aversion (perfect foresight calibration) | `CRRA` | $0.96$ |\n", + "| $\\gimel$ | Aggregate permanent growth factor | `PermGroFacAgg` | $1.0$ |\n", + "| $\\Psi_N$ | Number of discrete aggregate permanent productivity shocks | `PermShkAggCount` | $3$ |\n", + "| $\\Theta_N$ | Number of discrete aggregate transitory productivity shocks | `TranShkAggCount` | $3$ |\n", + "| $\\sigma_\\Psi$ | Standard deviation of log aggregate permanent productivity shocks | `PermShkAggStd` | $0.0063$ |\n", + "| $\\sigma_\\Theta$ | Standard deviation of log aggregate permanent productivity shocks | `TranShkAggStd` | $0.0031$ |\n", + "| (none) | Number of \"burn in\" periods to discard at start of simulation run when updating $mathbf{A}(\\cdot)$ | `T_discard` | $200$ |\n", + "| (none) | Damping factor when updating $\\mathbf{A}(\\cdot)$ (weight on prior value) | `DampingFac` | $0.5$ |\n", + "| (none) | Maximum number of times to update $\\mathbf{A}(\\cdot)$ before terminating | `max_loops` | $20$ |\n", + "| $\\kappa_0$ | Initial guess for intercept $\\kappa_0$, intercept term in $\\mathbf{A}(\\cdot)$ | `intercept_prev` | $0.0$ |\n", + "| $\\kappa_1$ | Initial guess for intercept $\\kappa_1$, slope coefficient for $\\mathbf{A}(\\cdot)$ | `slope_prev` | $1.0$ |\n", + "| (none) | Whether to print progress to screen when solving for equilibrium $\\mathbf{A}(\\cdot)$ | `verbose` | $False$ |\n", + "\n", + "The values of $\\beta$ and $\\rho$ provided to the `CobbDouglasEconomy` do not need to be the same values as the agents who populate the market. The market-level parameters are used *only* to calculate what the perfect foresight steady state level of aggregate market resources would be; this is used to scale the grid of $M_t$ values to an appropriate range around it." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example parameters for a `SmallOpenEconomy`\n", + "\n", + "The parameters for a `SmallOpenEconomy` are similar to the `CobbDouglasEconomy`, but not quite the same. Most obviously, \"technology\" parameters like $\\delta$ and $\\alpha$ are irrelevant, as are parameters governing how $\\mathbf{A}(\\cdot)$ is updated. Moreover, the perfect foresight $\\beta$ and $\\rho$ likewise do not appear, because market resources $M_t$ are a \"dummy\" state with no affect on the agent, so the scaling for the state grid doesn't matter. The initial guesses for $\\kappa_0$ and $\\kappa_1$ are also arbitrary and has no effect; they just need to exist.\n", + "\n", + "On the other hand, the exogenous factor prices $\\mathsf{R}$ and $\\mathsf{w}$ are specified as parameters of a `SmallOpenEconomy`.\n", + "\n", + "| Parameter | Description | Code | Value | \n", + "| :---: | --- | --- | --- |\n", + "| $\\mathsf{R}$ | Exogenous risk-free interest factor | `Rfree` | $1.02$ |\n", + "| $\\mathsf{w}$ | Exogenous wage rate | `wRte` | $1.0$ |\n", + "| $\\gimel$ | Aggregate permanent growth factor | `PermGroFacAgg` | $1.0$ |\n", + "| $\\Psi_N$ | Number of discrete aggregate permanent productivity shocks | `PermShkAggCount` | $3$ |\n", + "| $\\Theta_N$ | Number of discrete aggregate transitory productivity shocks | `TranShkAggCount` | $3$ |\n", + "| $\\sigma_\\Psi$ | Standard deviation of log aggregate permanent productivity shocks | `PermShkAggStd` | $0.0063$ |\n", + "| $\\sigma_\\Theta$ | Standard deviation of log aggregate permanent productivity shocks | `TranShkAggStd` | $0.0031$ |\n", + "| (none) | Maximum number of times to solve the micro model (always 1) | `max_loops` | $1$ |\n", + "| $\\kappa_0$ | Initial guess for intercept $\\kappa_0$, intercept term in $\\mathbf{A}(\\cdot)$ | `intercept_prev` | $0.0$ |\n", + "| $\\kappa_1$ | Initial guess for intercept $\\kappa_1$, slope coefficient for $\\mathbf{A}(\\cdot)$ | `slope_prev` | $1.0$ |" + ] + }, { "cell_type": "markdown", "metadata": { @@ -170,7 +263,20 @@ "tags": [] }, "source": [ - "## Example implementations of `AggShockConsumerType`" + "## Example implementations of `AggShockConsumerType`\n", + "\n", + "We present two examples below, each using (more or less) the default parameters. Note that in each case, a `Market` is created alongside the `AgentType`, and the model is only only fully specified when the two things are paired together." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Small open economy example\n", + "\n", + "First, let's make an `AggShockShockConsumerType` that lives in a `SmallOpenEconomy`, so that the interest factor and wage rate are exogenously determined, but the agents are aware of aggregate productivity shocks. Because the $M_t$ state is irrelevant, we can set its grid to be (nearly) trivial, with only three nodes. The consumption function will be identical at all three $M_t$ values on the grid, and is completely flat with respect to $M_t$.\n", + "\n", + "This model solves in only a few seconds because it just needs to solve the microeconomic model once, rather than iterate on solving, simulating, and updating the aggregate saving rule until convergence." ] }, { @@ -185,19 +291,11 @@ }, "outputs": [], "source": [ - "# Make an aggregate shocks consumer type\n", - "AggShockExample = AggShockConsumerType(cycles=0)\n", - "AggShockExampleAlt = AggShockConsumerType(cycles=0, MaggCount=3)\n", - "\n", - "# Make a Cobb-Douglas economy for the agents\n", - "CobbDouglasExample = CobbDouglasEconomy(agents=[AggShockExample])\n", - "CobbDouglasExample.make_AggShkHist() # Simulate a history of aggregate shocks\n", - "CobbDouglasExample.give_agent_params() # Have agents collect market-level parameters and construct themselves\n", - "\n", - "# Make a small open economy for the agents\n", - "SOEexample = SmallOpenEconomy(agents=[AggShockExampleAlt])\n", - "SOEexample.make_AggShkHist() # Simulate a history of aggregate shocks\n", - "SOEexample.give_agent_params() # Have agents collect market-level parameters and construct themselves" + "# Make agents and a small open economy for the them\n", + "SOEaggShockType = AggShockConsumerType(cycles=0, MaggCount=3)\n", + "SOEmarket = SmallOpenEconomy(agents=[SOEaggShockType])\n", + "SOEmarket.make_AggShkHist() # Simulate a history of aggregate shocks\n", + "SOEmarket.give_agent_params() # Have agents collect market-level parameters and construct themselves" ] }, { @@ -215,20 +313,27 @@ "name": "stdout", "output_type": "stream", "text": [ - "Solving a small open economy took 9.7542 seconds.\n" + "Solving a small open economy took 10.9705 seconds.\n" ] } ], "source": [ "# Solve the small open economy with the default parameters\n", "t_start = time()\n", - "SOEexample.solve()\n", + "SOEmarket.solve()\n", "t_end = time()\n", "print(\n", " \"Solving a small open economy took \" + mystr(t_end - t_start) + \" seconds.\",\n", ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the model solved, we can plot the consumption function. Because the $M_t$ state is irrelevant, we need only plot it at one value of $M_t$ (specified as `Z=[1.0]` in the cell below)." + ] + }, { "cell_type": "code", "execution_count": 4, @@ -242,7 +347,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -252,16 +357,40 @@ } ], "source": [ - "AggShockExampleAlt.unpack(\"cFunc\")\n", + "SOEaggShockType.unpack(\"cFunc\")\n", "plt.xlabel(r\"Normalized market resources $m_t$\")\n", "plt.ylabel(r\"Normalized consumption $c_t$\")\n", - "plot_func_slices(AggShockExampleAlt.cFunc[0], 0.0, 10.0, Z=[1.0])\n", + "plot_func_slices(SOEaggShockType.cFunc[0], 0.0, 10.0, Z=[1.0])\n", "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example Cobb-Douglas production economy\n", + "\n", + "Now we'll make another `AggShockConsumerType` instance, but this one will live in a `CobbDouglasEconomy`. To solve the model, the microeconomic model will be solved and simulated several times, updating the approximate aggregate saving rule $\\mathbf{A}(\\cdot)$ after each pass based on the simulated history of $(M_t, A_t)$. The solution process terminates when successive iterations of $(\\kappa_0, \\kappa_1)$ are sufficiently close.\n", + "\n", + "Because the `verbose` parameter on our `Market` is set to `True`, solution progress will be printed to screen; you can watch the aggregate saving rule converge." + ] + }, { "cell_type": "code", "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Make an aggregate shocks consumer type and a Cobb-Douglas production economy for them\n", + "AggShockExample = AggShockConsumerType(cycles=0)\n", + "CobbDouglasExample = CobbDouglasEconomy(agents=[AggShockExample], verbose=True)\n", + "CobbDouglasExample.make_AggShkHist() # Simulate a history of aggregate shocks\n", + "CobbDouglasExample.give_agent_params() # Have agents collect market-level parameters and construct themselves" + ] + }, + { + "cell_type": "code", + "execution_count": 6, "metadata": { "editable": true, "slideshow": { @@ -275,19 +404,14 @@ "output_type": "stream", "text": [ "Now solving for the equilibrium of a Cobb-Douglas economy. This might take a few minutes...\n", - "intercept=-0.34225704690379455, slope=1.1036802534896566, r-sq=0.9966235168150562\n", - "intercept=-0.5048662684011551, slope=1.1521207801269897, r-sq=0.9967296231268286\n", - "intercept=-0.44009055091285676, slope=1.1073003762357754, r-sq=0.9796571592307225\n", - "intercept=-0.3727583496748521, slope=1.0800958134599425, r-sq=0.9888403549938374\n", - "intercept=-0.3507131461697174, slope=1.0714775734787123, r-sq=0.9913861032824601\n", - "intercept=-0.3412811495116656, slope=1.0678299783323966, r-sq=0.9917042799357173\n", - "intercept=-0.3371997345196811, slope=1.0662638842288006, r-sq=0.9918210930314515\n", - "intercept=-0.33543678369689256, slope=1.065591530676302, r-sq=0.9918686991220076\n", - "intercept=-0.33467883202472837, slope=1.06530389082849, r-sq=0.9918887018640774\n", - "intercept=-0.3343546337095779, slope=1.0651813619488595, r-sq=0.9918971767796609\n", - "intercept=-0.3342166296959199, slope=1.0651293833970874, r-sq=0.9919007696687092\n", - "intercept=-0.33415813467441513, slope=1.0651074158458098, r-sq=0.9919022896745456\n", - "Solving the \"macroeconomic\" aggregate shocks model took 376.0589 seconds.\n" + "intercept=-0.6141494844683355, slope=1.1854774298042328, r-sq=0.9966588059329554\n", + "intercept=-0.27024173618969843, slope=1.0260663446051426, r-sq=0.9731061580758266\n", + "intercept=-0.30693861919404236, slope=1.0556777836169178, r-sq=0.9924442589957739\n", + "intercept=-0.337368853632431, slope=1.0662485062919753, r-sq=0.9921969452409733\n", + "intercept=-0.3339454677400454, slope=1.0650655738930923, r-sq=0.9919036112130921\n", + "intercept=-0.3343527084308289, slope=1.0652055085301424, r-sq=0.9919368983193704\n", + "intercept=-0.33430222097686635, slope=1.0651882067038065, r-sq=0.9919329767253827\n", + "Solving the \"macroeconomic\" aggregate shocks model took 285.0359 seconds.\n" ] } ], @@ -306,9 +430,16 @@ ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The aggregate saving rule isn't much to look at, but we can plot it anyway." + ] + }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": { "editable": true, "slideshow": { @@ -317,24 +448,9 @@ "tags": [] }, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Aggregate savings as a function of aggregate market resources:\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\Matthew\\Documents\\GitHub\\HARK\\HARK\\ConsumptionSaving\\ConsAggShockModel.py:3024: RuntimeWarning: divide by zero encountered in log\n", - " Aagg = np.exp(self.intercept + self.slope * np.log(Mnow))\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -344,16 +460,62 @@ } ], "source": [ - "print(\"Aggregate savings as a function of aggregate market resources:\")\n", "plt.xlabel(r\"Aggregate market resources $M_t$\")\n", "plt.ylabel(r\"Aggregate assets retained $A_t$\")\n", "plt.ylim(0.0, 27.0)\n", - "plot_funcs(CobbDouglasExample.AFunc, 0, 2 * CobbDouglasExample.kSS)" + "plot_funcs(CobbDouglasExample.AFunc, 0.0001, 2 * CobbDouglasExample.kSS)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That equilibrium $\\mathbf{A}(M_t)$ function was generated by regressing the history of $log(A_t)$ on the history of $log(M_t)$, ignoring the first `T_discard=200` periods. The market retains its last recorded `history`, so we can plot that relationship:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Extract the history of $M_t$ and $A_t$\n", + "Magg = CobbDouglasExample.history[\"MaggNow\"]\n", + "Aagg = CobbDouglasExample.history[\"AaggNow\"]\n", + "logM = np.log(Magg)\n", + "logA = np.log(Aagg)\n", + "T0 = CobbDouglasExample.T_discard\n", + "\n", + "# Plot log(M_t) vs log(A_t), taking account of lag\n", + "plt.plot(logM[T0:-1], logA[T0 + 1 :], \".k\")\n", + "plt.xlabel(\"Log aggregate market resources\")\n", + "plt.ylabel(\"Log aggregate retained assets\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that aggregate $M_t$ actually matters, we can plot the consumption function by $m_t$ for different levels of $M_t$. In the plot below, we use the grid of $M_t$ values itself, but the consumption function is also defined in between these levels.\n", + "\n", + "The lower curves are the consumption function when aggregate market resources are low, and thus aggregate capital is expected to be low; wages (labor income) are thus low and returns to retained assets are high, so the agents want to consume less and save more. The upper curves represent consumption when aggregate market resources are high, and thus capital will be high; the return to capital is lower, and labor income is high, so the agents want to consume more and save less." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": { "editable": true, "slideshow": { @@ -366,7 +528,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/examples/ConsIndShockModel/IndShockConsumerType.ipynb b/examples/ConsIndShockModel/IndShockConsumerType.ipynb index 4ef5795a2..226da472f 100644 --- a/examples/ConsIndShockModel/IndShockConsumerType.ipynb +++ b/examples/ConsIndShockModel/IndShockConsumerType.ipynb @@ -119,18 +119,18 @@ "source": [ "## Example parameter values to construct an instance of `IndShockConsumerType`\n", "\n", - "In order to create an instance of `IndShockConsumerType`, the user must specify parameters that characterize the (age-varying) distribution of income shocks $F_{t+1}$, the artificial borrowing constraint $\\underline{a}$, and the exogenous grid of end-of-period assets-above-minimum for use by EGM, along with all of the parameters for the perfect foresight model. The table below presents the complete list of parameter values required to instantiate an `IndShockConsumerType`, along with example values.\n", + "When creating a new instance of `IndShockConsumerType`, the user can specify parameters that characterize the (age-varying) distribution of income shocks $F_{t+1}$, the artificial borrowing constraint $\\underline{a}$, and the exogenous grid of end-of-period assets-above-minimum for use by EGM, along with all of the parameters for the perfect foresight model. The table below presents the complete list of parameter values for `IndShockConsumerType` with its default constructors, along with example values from its default parameter dictionary.\n", "\n", - "| Parameter | Description | Code | Example value | Time-varying? |\n", + "| Parameter | Description | Code | Value | Time-varying? |\n", "| :---: | --- | --- | --- | --- |\n", "| $\\DiscFac$ |Intertemporal discount factor | `DiscFac` | $0.96$ | |\n", "| $\\CRRA$|Coefficient of relative risk aversion | `CRRA` | $2.0$ | |\n", "| $\\Rfree_t$ | Risk free interest factor | `Rfree` | $[1.03]$ | $\\surd$ |\n", "| $\\LivPrb_t$ |Survival probability | `LivPrb` | $[0.98]$ | $\\surd$ |\n", - "|$\\PermGroFac_{t+1}$|Permanent income growth factor| `PermGroFac` | $[1.01]$ | $\\surd$ |\n", + "| $\\PermGroFac_{t}$|Permanent income growth factor| `PermGroFac` | $[1.01]$ | $\\surd$ |\n", "| $\\sigma_\\psi$| Standard deviation of log permanent income shocks | `PermShkStd` | $[0.1]$ |$\\surd$ |\n", "| $N_\\psi$| Number of discrete permanent income shocks | `PermShkCount` | $7$ | |\n", - "| $\\sigma_\\theta$| Standard deviation of log transitory income shocks | `TranShkStd` | $[0.2]$ | $\\surd$ |\n", + "| $\\sigma_\\theta$| Standard deviation of log transitory income shocks | `TranShkStd` | $[0.1]$ | $\\surd$ |\n", "| $N_\\theta$| Number of discrete transitory income shocks | `TranShkCount` | $7$ | |\n", "| $\\mho$ | Probability of being unemployed and getting $\\theta=\\underline{\\theta}$ | `UnempPrb` | $0.05$ | |\n", "| $\\underline{\\theta}$| Transitory shock when unemployed | `IncUnemp` | $0.3$ | |\n", @@ -144,9 +144,7 @@ "| $(none)$ | Additional values to add to assets-above-minimum grid | `aXtraExtra` | $None$ | |\n", "| $\\underline{a}$| Artificial borrowing constraint (normalized) | `BoroCnstArt` | $0.0$ | |\n", "| $(none)$|Indicator for whether `vFunc` should be computed | `vFuncBool` | $True$ | |\n", - "| $(none)$ |Indicator for whether `cFunc` should use cubic splines | `CubicBool` | $False$ | |\n", - "|$T$| Number of periods in this type's \"cycle\" | `T_cycle` | $1$ | |\n", - "|(none)| Number of times the \"cycle\" occurs | `cycles` | $0$ | |" + "| $(none)$ |Indicator for whether `cFunc` should use cubic splines | `CubicBool` | $False$ | |" ] }, { From 20e22f24a8f892518ffb775057a9a63d7aa98568 Mon Sep 17 00:00:00 2001 From: "Matthew N. White" Date: Tue, 3 Mar 2026 20:13:58 -0500 Subject: [PATCH 3/3] Fleshed out AggShockMarkov notebook --- HARK/ConsumptionSaving/ConsAggShockModel.py | 15 +- .../AggShockConsumerType.ipynb | 4 +- .../AggShockMarkovConsumerType.ipynb | 570 ++++++++++++++---- 3 files changed, 461 insertions(+), 128 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsAggShockModel.py b/HARK/ConsumptionSaving/ConsAggShockModel.py index e492a1d87..5033c9671 100644 --- a/HARK/ConsumptionSaving/ConsAggShockModel.py +++ b/HARK/ConsumptionSaving/ConsAggShockModel.py @@ -2619,6 +2619,19 @@ def calc_AFunc(self, MaggNow, AaggNow): return AggShocksDynamicRule(AFunc_list) +# Make a dictionary to specify a small open Markov economy +init_mrkv_small_open_economy = init_small_open_economy.copy() +init_mrkv_small_open_economy["PermShkAggStd"] = [0.012, 0.006] +init_mrkv_small_open_economy["TranShkAggStd"] = [0.006, 0.003] +init_mrkv_small_open_economy["PermGroFacAgg"] = [0.98, 1.02] +init_mrkv_small_open_economy["MrkvArray"] = MrkvArray +init_mrkv_small_open_economy["MrkvInit"] = 0 +init_mrkv_small_open_economy["slope_prev"] = 2 * [1.0] +init_mrkv_small_open_economy["intercept_prev"] = 2 * [0.0] +init_mrkv_small_open_economy["Rfree"] = 1.02 +init_mrkv_small_open_economy["wRte"] = 1.0 + + class SmallOpenMarkovEconomy(CobbDouglasMarkovEconomy, SmallOpenEconomy): """ A class for representing a small open economy, where the wage rate and interest rate are @@ -2629,7 +2642,7 @@ class SmallOpenMarkovEconomy(CobbDouglasMarkovEconomy, SmallOpenEconomy): def __init__(self, agents=None, tolerance=0.0001, act_T=1000, **kwds): agents = agents if agents is not None else list() - temp_dict = init_mrkv_cobb_douglas.copy() + temp_dict = init_mrkv_small_open_economy.copy() temp_dict.update(kwds) CobbDouglasMarkovEconomy.__init__( self, diff --git a/examples/ConsAggShockModel/AggShockConsumerType.ipynb b/examples/ConsAggShockModel/AggShockConsumerType.ipynb index 74ddffdb8..7fe4084de 100644 --- a/examples/ConsAggShockModel/AggShockConsumerType.ipynb +++ b/examples/ConsAggShockModel/AggShockConsumerType.ipynb @@ -213,14 +213,14 @@ "| $\\delta$ | Capital depreciation rate | `DeprRte` | $0.025$ |\n", "| $\\alpha$| Capital's share of production | `CapShare` | $0.36$ |\n", "| $\\beta$ | Intertemporal discount factor (perfect foresight calibration) | `DiscFac` | $0.96$ |\n", - "| $\\rho$ | Coefficient of relative risk aversion (perfect foresight calibration) | `CRRA` | $0.96$ |\n", + "| $\\rho$ | Coefficient of relative risk aversion (perfect foresight calibration) | `CRRA` | $2.0$ |\n", "| $\\gimel$ | Aggregate permanent growth factor | `PermGroFacAgg` | $1.0$ |\n", "| $\\Psi_N$ | Number of discrete aggregate permanent productivity shocks | `PermShkAggCount` | $3$ |\n", "| $\\Theta_N$ | Number of discrete aggregate transitory productivity shocks | `TranShkAggCount` | $3$ |\n", "| $\\sigma_\\Psi$ | Standard deviation of log aggregate permanent productivity shocks | `PermShkAggStd` | $0.0063$ |\n", "| $\\sigma_\\Theta$ | Standard deviation of log aggregate permanent productivity shocks | `TranShkAggStd` | $0.0031$ |\n", "| (none) | Number of \"burn in\" periods to discard at start of simulation run when updating $mathbf{A}(\\cdot)$ | `T_discard` | $200$ |\n", - "| (none) | Damping factor when updating $\\mathbf{A}(\\cdot)$ (weight on prior value) | `DampingFac` | $0.5$ |\n", + "| (none) | Damping factor when updating $\\mathbf{A}(\\cdot)$ (weight on prior value) | `DampingFac` | $0.2$ |\n", "| (none) | Maximum number of times to update $\\mathbf{A}(\\cdot)$ before terminating | `max_loops` | $20$ |\n", "| $\\kappa_0$ | Initial guess for intercept $\\kappa_0$, intercept term in $\\mathbf{A}(\\cdot)$ | `intercept_prev` | $0.0$ |\n", "| $\\kappa_1$ | Initial guess for intercept $\\kappa_1$, slope coefficient for $\\mathbf{A}(\\cdot)$ | `slope_prev` | $1.0$ |\n", diff --git a/examples/ConsAggShockModel/AggShockMarkovConsumerType.ipynb b/examples/ConsAggShockModel/AggShockMarkovConsumerType.ipynb index b9487d189..e4120df5b 100644 --- a/examples/ConsAggShockModel/AggShockMarkovConsumerType.ipynb +++ b/examples/ConsAggShockModel/AggShockMarkovConsumerType.ipynb @@ -1,144 +1,436 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "53ec7e4a-a1d4-4a11-a918-c73c3e6cf06a", + "metadata": {}, + "source": [ + "# Aggregate Productivity Shocks with a Discrete State\n", + "\n", + "This notebook concerns `AggShockMarkovConsumerType`, an extension of `AggShockConsumerType` that incorporates a discrete state at the aggregate (market) level. For the basic version of the aggregate productivity shocks model, see [this notebook](./AggShockConsumerType.ipynb)." + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, + "id": "6a1b2b74-8cf5-412d-b6b9-e85dc63bf146", + "metadata": {}, + "outputs": [], + "source": [ + "from time import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from HARK.ConsumptionSaving.ConsAggShockModel import (\n", + " AggShockMarkovConsumerType,\n", + " CobbDouglasMarkovEconomy,\n", + " SmallOpenMarkovEconomy,\n", + ")\n", + "from HARK.utilities import plot_funcs, plot_func_slices\n", + "\n", + "\n", + "def mystr(number):\n", + " return f\"{number:.4f}\"" + ] + }, + { + "cell_type": "markdown", + "id": "1cf11e5b-611a-453f-a9cc-234ee6a84ff5", + "metadata": {}, + "source": [ + "## Microeconomic model statement for `AggShockMarkovConsumerType`\n", + "\n", + "Agents in this model have a similar problem to `AggShockConsumerType`, but also have a discrete state $z_t$ that evolves at the aggregate level-- all consumers share the same $z_t$. Just like for a `MarkovConsumerType`, agents' idiosyncratic income shock distribution can vary by $z_t$, as can the distribution of aggregate productivity shocks and the growth rate of aggregate productivity.\n", + "\n", + "The microeconomic optimization problem can be written as:\n", + "\n", + "\\begin{eqnarray*}\n", + "\\text{v}(m_{it}, M_t, z_t) &=& \\max_{c_{it}} \\frac{c_{it}^{1-\\rho}}{1-\\rho} + \\beta \\mathsf{S} \\mathbb{E} \\left[ (\\psi_{it+1} \\Psi_{t+1})^{1-\\rho} \\text{v}(m_{it+1}, M_{t+1}) \\right] \\\\\n", + "&\\text{s.t.}& \\\\\n", + "a_{it} &=& m_{it} - c_{it} \\geq \\underline{a}, \\\\\n", + "A_{t} &=& \\mathbf{A}(M_{it}, z_t), \\\\\n", + "K_{t+1} &=& A_t, \\\\\n", + "k_{t+1} &=& K_t / \\Psi_{t+1}, \\\\\n", + "\\mathsf{R}_{t+1} &=& \\mathbf{R}(k_{t+1} / \\Theta_{t+1}), \\\\\n", + "\\mathsf{w}_{t+1} &=& \\mathbf{W}(k_{t+1} / \\Theta_{t+1}), \\\\\n", + "m_{it+1} &=& \\mathsf{R}_{t+1} a_{t} / (\\psi_{it+1} \\Psi_{t+1}) + \\mathsf{w}_{t+1} \\theta_{it+1} \\Theta_{t+1}, \\\\\n", + "M_{t+1} &=& \\mathsf{R}_{t+1} k_{t+1} + \\mathsf{w}_{t+1} \\Theta_{t+1}, \\\\\n", + "z_{t+1} &\\sim& \\Delta, \\\\\n", + "(\\psi_{it+1}, \\theta_{it+1}) &\\sim& F_z, \\\\\n", + "(\\Psi_{t+1}, \\theta_{t+1}) &\\sim& \\Phi_z.\n", + "\\end{eqnarray*}" + ] + }, + { + "cell_type": "markdown", + "id": "5362233f-90d5-4022-b629-7c89e79a4aae", + "metadata": {}, + "source": [ + "Note the dependence on $z_t$ in the aggregate saving function $\\mathbf{A}(\\cdot)$. The function is now parameterized as log-linear *within* each $z_t$, so with $J$ discrete states there are $2J$ coefficients to determine. As in the `MarkovConsumerType`'s model, the next discrete state $z_{t+1}$ is drawn based on the Markov probability matrix $\\Delta$." + ] + }, + { + "cell_type": "markdown", + "id": "b70b863b-ed9f-47a4-a85e-98481c421849", + "metadata": {}, + "source": [ + "## Model statements for a `CobbDouglasMarkovEconomy` and `SmallOpenMarkovEconomy`\n", + "\n", + "The `CobbDouglasMarkovEconomy` has the same model as a `CobbDouglasEconomy`:\n", + "\n", + "\\begin{eqnarray*}\n", + "Y &=& K^\\alpha L^{1-\\alpha}, \\\\\n", + "\\mathsf{w} &=& \\frac{\\partial Y}{\\partial L} = (1-\\alpha) K^\\alpha L^{-\\alpha} = (1-\\alpha) k^{\\alpha}, \\\\\n", + "\\mathsf{r} &=& \\frac{\\partial Y}{\\partial K} = \\alpha K_{t}^{\\alpha-1} L_t^{1-\\alpha} = \\alpha k^{1-\\alpha}, \\\\\n", + "\\mathsf{R} &=& 1 - \\delta + \\mathsf{r}.\n", + "\\end{eqnarray*}\n", + "\n", + "The only difference is that when the $\\mathbf{A}(\\cdot)$ is updated after simulating a history, $\\log(A_t)$ is regressed on $\\log(M_t)$, it is done *conditional* on each $z_t \\in \\{1,\\cdots,J\\}$.\n", + "\n", + "The `SmallOpenMarkovEconomy` is essentially identical to a `SmallOpenEconomy`, but draws its aggregate productivity shocks from the conditional distribution $\\Phi_z$." + ] + }, + { + "cell_type": "markdown", + "id": "6a7ff317-86d2-4b4f-aaeb-921ab403b14e", + "metadata": {}, + "source": [ + "## Example parameters for an `AggShockMarkovConsumerType`\n", + "\n", + "The default parameters for an `AggShockMarkovConsumerType` are very similar to the baseline `AggShockConsumerType`. The primary change is that the income distribution parameters depend on the Markov state $z_t$ and thus are nested lists. Moreover, the `MrkvArray` is a critical new parameter for both the `AggShockMarkovConsumerType` and the `Market` subclass it is paired with; it should be specified at the `Market` level, and then provided to the agents with the `give_agent_params()` method.\n", + "\n", + "| Parameter | Description | Code | Value | Time-varying? |\n", + "| :---: | --- | --- | --- | --- |\n", + "| $\\beta$ |Intertemporal discount factor | `DiscFac` | $0.96$ | |\n", + "| $\\rho$|Coefficient of relative risk aversion | `CRRA` | $2.0$ | |\n", + "| $\\mathsf{R}_t$ | Risk free interest factor | `Rfree` | $[1.03]$ | $\\surd$ |\n", + "| $\\mathsf{S}_t$ |Survival probability | `LivPrb` | $[0.98]$ | $\\surd$ |\n", + "| $\\Gamma_{t}$|Permanent income growth factor| `PermGroFac` | $[1.0]$ | $\\surd$ |\n", + "| $\\sigma_\\psi$| Standard deviation of log permanent income shocks | `PermShkStd` | $[[0.1, 0.1]]$ |$\\surd$ |\n", + "| $N_\\psi$| Number of discrete permanent income shocks | `PermShkCount` | $7$ | |\n", + "| $\\sigma_\\theta$| Standard deviation of log transitory income shocks | `TranShkStd` | $[[0.1, 0.1]]$ | $\\surd$ |\n", + "| $N_\\theta$| Number of discrete transitory income shocks | `TranShkCount` | $7$ | |\n", + "| $\\mho$ | Probability of being unemployed and getting $\\theta=\\underline{\\theta}$ | `UnempPrb` | $[0.05, 0.05]$ | |\n", + "| $\\underline{\\theta}$| Transitory shock when unemployed | `IncUnemp` | $[0.3, 0.3]$ | |\n", + "| $\\mho^{Ret}$ | Probability of being \"unemployed\" when retired | `UnempPrbRet` | $0.0$ | |\n", + "| $\\underline{\\theta}^{Ret}$| Transitory shock when \"unemployed\" and retired | `IncUnempRet` | $None$ | |\n", + "| $(none)$ | Period of the lifecycle model when retirement begins | `T_retire` | $0$ | |\n", + "| $(none)$ | Minimum value in assets-above-minimum grid | `aXtraMin` | $0.001$ | |\n", + "| $(none)$ | Maximum value in assets-above-minimum grid | `aXtraMax` | $20.0$ | |\n", + "| $(none)$ | Number of points in base assets-above-minimum grid | `aXtraCount` | $36$ | |\n", + "| $(none)$ | Exponential nesting factor for base assets-above-minimum grid | `aXtraNestFac` | $2$ | |\n", + "| $(none)$ | Additional values to add to assets-above-minimum grid | `aXtraExtra` | $None$ | |\n", + "| $\\underline{a}$ | Artificial borrowing constraint (normalized) | `BoroCnstArt` | $0.0$ | |\n", + "| $(none)$ | Number of aggregate $M_t$ gridpoints to use | `MaggCount` | $17$ | |\n", + "| $(none)$ | Base perturbation factor around perfect foresight steady state for grid of $M_t$ | `MaggPerturb` | $0.01$ | |\n", + "| $(none)$ | Log scaling factor for additional $M_t$ gridpoints | `MaggCount` | $0.15$ | |" + ] + }, + { + "cell_type": "markdown", + "id": "71b48835-5904-4ee2-9c7c-9fc28df72f2b", + "metadata": {}, + "source": [ + "## Example parameters for `CobbDouglasMarkovEconomy` and `SmallOpenMarkovEconomy`\n", + "\n", + "The default parameters for a `CobbDouglasMarkovEconomy` are nearly identical to those for `CobbDouglasEconomy`, except that the aggregate productivity shock process varies by $z_t$. In the default specification, there is a high risk, low growth state ($z_t=0$) and a low risk, high growth state ($z_t=1$).\n", + "\n", + "| Parameter | Description | Code | Value | \n", + "| :---: | --- | --- | --- |\n", + "| $\\delta$ | Capital depreciation rate | `DeprRte` | $0.025$ |\n", + "| $\\alpha$| Capital's share of production | `CapShare` | $0.36$ |\n", + "| $\\beta$ | Intertemporal discount factor (perfect foresight calibration) | `DiscFac` | $0.96$ |\n", + "| $\\rho$ | Coefficient of relative risk aversion (perfect foresight calibration) | `CRRA` | $2.0$ |\n", + "| $\\gimel$ | Aggregate permanent growth factor | `PermGroFacAgg` | $[0.98, 1.02]$ |\n", + "| $\\Psi_N$ | Number of discrete aggregate permanent productivity shocks | `PermShkAggCount` | $3$ |\n", + "| $\\Theta_N$ | Number of discrete aggregate transitory productivity shocks | `TranShkAggCount` | $3$ |\n", + "| $\\sigma_\\Psi$ | Standard deviation of log aggregate permanent productivity shocks | `PermShkAggStd` | $[0.012, 0.006]$ |\n", + "| $\\sigma_\\Theta$ | Standard deviation of log aggregate permanent productivity shocks | `TranShkAggStd` | $[0.006,0.003]$ |\n", + "| (none) | Number of \"burn in\" periods to discard at start of simulation run when updating $mathbf{A}(\\cdot)$ | `T_discard` | $200$ |\n", + "| (none) | Damping factor when updating $\\mathbf{A}(\\cdot)$ (weight on prior value) | `DampingFac` | $0.2$ |\n", + "| (none) | Maximum number of times to update $\\mathbf{A}(\\cdot)$ before terminating | `max_loops` | $20$ |\n", + "| $\\kappa_0$ | Initial guess for intercept $\\kappa_0$, intercept term in $\\mathbf{A}(\\cdot)$ | `intercept_prev` | $[0.0, 0.0]$ |\n", + "| $\\kappa_1$ | Initial guess for intercept $\\kappa_1$, slope coefficient for $\\mathbf{A}(\\cdot)$ | `slope_prev` | $[1.0, 1.0]$ |\n", + "| (none) | Whether to print progress to screen when solving for equilibrium $\\mathbf{A}(\\cdot)$ | `verbose` | $False$ |\n", + "| $\\Delta$ | Aggregate discrete state Markov transition probabilities | `MrkvArray` | $[[0.90, 0.10], [0.04, 0.96]]$ |\n", + "| $z_0$ | Initial discrete state when starting a simulation | `MrkvInit` | $0$ |" + ] + }, + { + "cell_type": "markdown", + "id": "0397cdce-5819-45ac-9cc8-217c04482360", + "metadata": {}, + "source": [ + "The default parameters for `SmallOpenMarkovEconomy` are analogous to those of the basic `SmallOpenEconomy`:\n", + "\n", + "| Parameter | Description | Code | Value | \n", + "| :---: | --- | --- | --- |\n", + "| $\\mathsf{R}$ | Exogenous risk-free interest factor | `Rfree` | $1.02$ |\n", + "| $\\mathsf{w}$ | Exogenous wage rate | `wRte` | $1.0$ |\n", + "| $\\gimel$ | Aggregate permanent growth factor | `PermGroFacAgg` | $[0.98, 1.02]$ |\n", + "| $\\Psi_N$ | Number of discrete aggregate permanent productivity shocks | `PermShkAggCount` | $3$ |\n", + "| $\\Theta_N$ | Number of discrete aggregate transitory productivity shocks | `TranShkAggCount` | $3$ |\n", + "| $\\sigma_\\Psi$ | Standard deviation of log aggregate permanent productivity shocks | `PermShkAggStd` | $[0.012, 0.006]$ |\n", + "| $\\sigma_\\Theta$ | Standard deviation of log aggregate permanent productivity shocks | `TranShkAggStd` | $[0.006,0.003]$ |\n", + "| (none) | Damping factor when updating $\\mathbf{A}(\\cdot)$ (weight on prior value) | `DampingFac` | $0.2$ |\n", + "| (none) | Maximum number of times to update $\\mathbf{A}(\\cdot)$ (always 1) | `max_loops` | $1$ |\n", + "| $\\Delta$ | Aggregate discrete state Markov transition probabilities | `MrkvArray` | $[[0.90, 0.10], [0.04, 0.96]]$ |\n", + "| $z_0$ | Initial discrete state when starting a simulation | `MrkvInit` | $0$ |" + ] + }, + { + "cell_type": "markdown", + "id": "34782855-98ad-44d9-81c9-b48860077e9e", + "metadata": {}, + "source": [ + "## Example implementations of `AggShockMarkovConsumerType`\n", + "\n", + "As we did for `AggShockConsumerType`, let's demonstrate this model first with a small open economy, then with a Cobb-Douglas production economy." + ] + }, + { + "cell_type": "code", + "execution_count": 2, "id": "f0ea03d5-4348-4efa-98d4-5889376fd810", "metadata": {}, "outputs": [], "source": [ - "# Make a Markov aggregate shocks consumer type\n", - "AggShockMrkvExample = AggShockMarkovConsumerType(cycles=0)\n", + "# Make a Markov aggregate shocks consumer type and a small open economy for them\n", + "SOEmrkvConsumers = AggShockMarkovConsumerType(cycles=0, MaggCount=3)\n", + "SOEmrkvExample = SmallOpenMarkovEconomy(agents=[SOEmrkvConsumers])\n", "\n", - "# Make a Cobb-Douglas economy for the agents\n", - "MrkvEconomyExample = CobbDouglasMarkovEconomy(agents=[AggShockMrkvExample])\n", - "MrkvEconomyExample.DampingFac = 0.2 # Turn down damping\n", - "MrkvEconomyExample.make_AggShkHist() # Simulate a history of aggregate shocks\n", - "MrkvEconomyExample.give_agent_params() # Have the consumers inherit relevant objects from the economy" + "# Distribute parameters to the agents and make a history of shocks\n", + "SOEmrkvExample.make_AggShkHist()\n", + "SOEmrkvExample.give_agent_params()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "e66375b6-f313-4643-b977-5e83bb7c6b14", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a small open Markov economy took 27.3162 seconds.\n" + ] + } + ], "source": [ - "# Solve the microeconomic model for the Markov aggregate shocks example type (and display results)\n", - "t_start = process_time()\n", - "AggShockMrkvExample.solve()\n", - "t_end = process_time()\n", + "# Solve the microeconomic model for the Markov aggregate shocks example type\n", + "t_start = time()\n", + "SOEmrkvExample.solve()\n", + "t_end = time()\n", "print(\n", - " \"Solving an aggregate shocks Markov consumer took \"\n", - " + mystr(t_end - t_start)\n", - " + \" seconds.\",\n", - ")\n", + " \"Solving a small open Markov economy took \" + mystr(t_end - t_start) + \" seconds.\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "56992019-1691-46e9-a2c3-bab6a0635e29", + "metadata": {}, + "source": [ + "Solving a two-discrete-state specification with a small open economy doesn't take long at all, and the consumption function can be plotted by just looking at the two discrete states; recall that aggregate market resources $M_t$ are actually irrelevant with a SOE.\n", "\n", - "print(\n", - " \"Consumption function at each aggregate market \\\n", - " resources-to-labor ratio gridpoint (for each macro state):\",\n", - ")\n", - "m_grid = np.linspace(0, 10, 200)\n", - "AggShockMrkvExample.unpack(\"cFunc\")\n", - "for i in range(2):\n", - " for M in AggShockMrkvExample.Mgrid.tolist():\n", - " mMin = AggShockMrkvExample.solution[0].mNrmMin[i](M)\n", - " c_at_this_M = AggShockMrkvExample.cFunc[0][i](\n", - " m_grid + mMin,\n", - " M * np.ones_like(m_grid),\n", - " )\n", - " plt.plot(m_grid + mMin, c_at_this_M)\n", - " plt.ylim(0.0, None)\n", - " plt.show()" + "In the plot below, the lower blue curve represents the consumption function in the \"bad\" (low growth, high risk) state, and the higher orange curve is the consumption function in the \"good\" (high growth, low risk) state." ] }, { "cell_type": "code", - "execution_count": null, - "id": "566778e9-5fdc-4374-a310-7e49d483b478", + "execution_count": 4, + "id": "e27e7cd1-bf96-4d8b-8516-76c5f9dd65f8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ + "# Plot the consumption function in each Markov state\n", + "SOEmrkvConsumers.unpack(\"cFunc\")\n", + "C0 = lambda m: SOEmrkvConsumers.cFunc[0][0](m, np.ones_like(m))\n", + "C1 = lambda m: SOEmrkvConsumers.cFunc[0][1](m, np.ones_like(m))\n", + "plt.xlabel(r\"Market resources $m_t$\")\n", + "plt.ylabel(r\"Consumption $c_t$\")\n", + "plot_funcs([C0, C1], 0.0, 10.0)" + ] + }, + { + "cell_type": "markdown", + "id": "2c30ca5e-8a22-4d70-953e-69c25ddec643", + "metadata": {}, + "source": [ + "Now let's solve the model with the same parameters, but this time with a proper Cobb-Douglas production economy. This model takes significantly longer to solve, about 12 minutes. Be patient!" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ff030064-29ce-41bb-a460-011edf22648c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Now solving a two-state Markov economy. This should take a few minutes...\n", + "intercept=[-0.482916418198766, -0.6286768645335802], slope=[1.1228671690799255, 1.197592522429975], r-sq=[0.9983566435141922, 0.9939995301868294]\n", + "intercept=[-0.3113689811002257, -0.3166362223917467], slope=[1.0475161827021608, 1.042378386770727], r-sq=[0.9998795814756993, 0.9997235487802074]\n", + "intercept=[-0.31772821019139436, -0.36074676255000726], slope=[1.0600328671370265, 1.0716972339492288], r-sq=[0.9999472964649746, 0.9999330431328163]\n", + "intercept=[-0.3367660807440123, -0.3838533140845085], slope=[1.0664311088106264, 1.0798799983131715], r-sq=[0.9999431892865134, 0.9999287885763215]\n", + "intercept=[-0.33368811861285574, -0.3789886356645603], slope=[1.0653641129930689, 1.0782096210498118], r-sq=[0.9999437881173601, 0.9999287671852368]\n", + "intercept=[-0.33431433435700064, -0.38001751642276016], slope=[1.065578289271903, 1.078561138667419], r-sq=[0.9999437446206524, 0.9999288287833763]\n", + "intercept=[-0.3341768589228506, -0.37979427432824464], slope=[1.0655314178214905, 1.0784848717846809], r-sq=[0.999943756994822, 0.9999288208033832]\n", + "intercept=[-0.33420689039883966, -0.3798428374435816], slope=[1.0655416565055955, 1.078501460303492], r-sq=[0.9999437542500985, 0.9999288225499199]\n", + "Solving the \"macroeconomic\" aggregate shocks model took 759.2743 seconds.\n" + ] + } + ], + "source": [ + "# Make another AggShockMarkovConsumerType and a Cobb-Douglas economy for them\n", + "AggShockMrkvExample = AggShockMarkovConsumerType(cycles=0)\n", + "MrkvEconomyExample = CobbDouglasMarkovEconomy(\n", + " agents=[AggShockMrkvExample], verbose=True\n", + ")\n", + "MrkvEconomyExample.make_AggShkHist() # Simulate a history of aggregate shocks\n", + "MrkvEconomyExample.give_agent_params() # Have the consumers inherit relevant objects from the economy\n", + "\n", "# Solve the \"macroeconomic\" model by searching for a \"fixed point dynamic rule\"\n", - "t_start = process_time()\n", + "t_start = time()\n", "print(\"Now solving a two-state Markov economy. This should take a few minutes...\")\n", "MrkvEconomyExample.solve()\n", - "t_end = process_time()\n", + "t_end = time()\n", "print(\n", " 'Solving the \"macroeconomic\" aggregate shocks model took '\n", " + mystr(t_end - t_start)\n", " + \" seconds.\",\n", - ")\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "da95fb5f-bd67-467a-8f73-35d55356f0f5", + "metadata": {}, + "source": [ + "You may recall that for the basic `AggShockConsumerType`, the $R^2$ of $\\log(A_t)$ on $\\log(M_t)$ was about $0.992$, but it's about $0.99993$ in the model with a discrete aggregate state. That is, the parametric aggregate saving rule appears to be about 100 times more accurate in predicting outcomes. This is merely the result of $M_t$ (and consequently $A_t$) taking on a much wider range of values in this model. In the presence of persistent \"good\" and \"bad\" states, the agents will have significantly different target levels of wealth between the states, and thus *aggregate* market resources will fluctuate by more.\n", "\n", - "print(\n", - " \"Consumption function at each aggregate market resources-to-labor ratio gridpoint (for each macro state):\",\n", - ")\n", - "m_grid = np.linspace(0, 10, 200)\n", + "This can be seen by plotting the history of $M_t$ vs $A_t$ conditional on the discrete aggregate state, as below." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2a82ed29-abf5-4c52-8b76-cdb0396ed3d7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Extract the history of $M_t$, $A_t$, and the Markov state\n", + "Magg = MrkvEconomyExample.history[\"MaggNow\"]\n", + "Aagg = MrkvEconomyExample.history[\"AaggNow\"]\n", + "T0 = MrkvEconomyExample.T_discard\n", + "logM = np.log(Magg)[T0:-1]\n", + "logA = np.log(Aagg)[T0 + 1 :]\n", + "Z = MrkvEconomyExample.MrkvNow_hist[T0:-1]\n", + "\n", + "# Plot log(M) vs log(A) in each state\n", + "bad = Z == 0\n", + "good = Z == 1\n", + "plt.plot(logM[bad], logA[bad], \".r\")\n", + "plt.plot(logM[good], logA[good], \".g\")\n", + "plt.xlabel(\"Log aggregate market resources\")\n", + "plt.ylabel(\"Log aggregate retained assets\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "7f328f6a-e1db-452f-a280-8dacd65846fe", + "metadata": {}, + "source": [ + "To view the consumption function, we can look at slices of it by $M_t$ value within each discrete state." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8d23dd9f-622f-4cd5-b327-a1d791de2eec", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption function in each discrete state for a variety of M_t levels\n", "AggShockMrkvExample.unpack(\"cFunc\")\n", "for i in range(2):\n", - " for M in AggShockMrkvExample.Mgrid.tolist():\n", - " mMin = AggShockMrkvExample.solution[0].mNrmMin[i](M)\n", - " c_at_this_M = AggShockMrkvExample.cFunc[0][i](\n", - " m_grid + mMin,\n", - " M * np.ones_like(m_grid),\n", - " )\n", - " plt.plot(m_grid + mMin, c_at_this_M)\n", - " plt.ylim(0.0, None)\n", - " plt.show()" + " plt.xlabel(r\"Market resources $m_t$\")\n", + " plt.ylabel(r\"Consumption $c_t$\")\n", + " plot_func_slices(\n", + " AggShockMrkvExample.cFunc[0][i], 0.0, 10.0, Z=AggShockMrkvExample.Mgrid\n", + " )" ] }, { - "cell_type": "code", - "execution_count": null, - "id": "0dcaa12a-594d-430a-ab92-a284d0366e28", + "cell_type": "markdown", + "id": "da33f7be-415c-4e63-8e5a-b4000e419c50", "metadata": {}, - "outputs": [], "source": [ - "# Make a Krusell-Smith agent type\n", - "# NOTE: These agents aren't exactly like KS, as they don't have serially correlated unemployment\n", - "KSexampleType = AggShockMarkovConsumerType(\n", - " cycles=0,\n", - " PermShkStd=np.array([[0.0, 0.0]]),\n", - " TranShkStd=np.array([[0.0, 0.0]]),\n", - " IncUnemp=np.array([0.0, 0.0]),\n", - " UnempPrb=np.array([0.04, 0.10]),\n", - ")\n", + "## A (much) bigger example of `AggShockMarkovConsumerType`\n", "\n", - "# Make a KS economy\n", - "KSeconomy = CobbDouglasMarkovEconomy(\n", - " agents=[KSexampleType], DampingFac=0.2, PermGroFacAgg=[1.0, 1.0]\n", - ")\n", - "KSeconomy.AggShkDstn = [\n", - " DiscreteDistribution(\n", - " np.array([1.0]),\n", - " np.array([[1.0], [1.05]]),\n", - " ),\n", - " DiscreteDistribution(\n", - " np.array([1.0]),\n", - " np.array([[1.0], [0.95]]),\n", - " ),\n", - "]\n", - "KSeconomy.give_agent_params()\n", - "KSeconomy.make_AggShkHist()\n", - "\n", - "# Solve the K-S model\n", - "t_start = process_time()\n", - "print(\n", - " \"Now solving a Krusell-Smith-style economy. This should take about a minute...\",\n", - ")\n", - "KSeconomy.solve()\n", - "t_end = process_time()\n", - "print(\"Solving the Krusell-Smith model took \" + mystr(t_end - t_start) + \" seconds.\")" + "The examples above used the default parameters, with two discrete states, and could be solved in a few seconds to a few minutes. It is possible to build a much more elaborate Markov structure, but the model will take significantly longer to solve.\n", + "\n", + "In the cells below, we specify and solve a `CobbDouglasMarkovEconomy` with fifteen discrete aggregate states, which vary in their expected aggregate productivity growth (ranging from $0.99$ to $1.03$). The model will only be solved if `solve_poly` is set to `True`." ] }, { "cell_type": "code", - "execution_count": null, - "id": "6e6b20c7-3588-47d0-b92a-10df10ff5785", + "execution_count": 8, + "id": "adce50ba-c4eb-40ec-9b5e-87c8b20c638b", "metadata": {}, "outputs": [], "source": [ "# Poly-state example\n", + "solve_poly = False\n", "StateCount = 15 # Number of Markov states\n", "GrowthAvg = 1.01 # Average permanent income growth factor\n", "GrowthWidth = 0.02 # PermGroFacAgg deviates from PermGroFacAgg in this range\n", @@ -158,49 +450,77 @@ " elif (i == (j - 1)) or (i == (j + 1)):\n", " PolyMrkvArray[i, j] = 0.5 * (1.0 - Persistence)\n", "PolyMrkvArray[0, 0] += 0.5 * (1.0 - Persistence)\n", - "PolyMrkvArray[StateCount - 1, StateCount - 1] += 0.5 * (1.0 - Persistence)\n", - "\n", + "PolyMrkvArray[StateCount - 1, StateCount - 1] += 0.5 * (1.0 - Persistence)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5ddcb7f9-7997-4650-9029-0ab7398b1ec7", + "metadata": {}, + "outputs": [], + "source": [ "# Make a consumer type to inhabit the economy\n", - "PolyStateExample = AggShockMarkovConsumerType()\n", + "PolyStateExample = AggShockMarkovConsumerType(\n", + " cycles=0,\n", + " PermGroFacAgg=PermGroFacAgg,\n", + " PermShkStd=np.full((1, StateCount), 0.1),\n", + " TranShkStd=np.full((1, StateCount), 0.1),\n", + " UnempPrb=np.full(StateCount, 0.05),\n", + " IncUnemp=np.full(StateCount, 0.3),\n", + " IncUnempRet=None,\n", + ")\n", "PolyStateExample.MrkvArray = PolyMrkvArray\n", - "PolyStateExample.PermGroFacAgg = PermGroFacAgg\n", - "PolyStateExample.IncShkDstn[0] = StateCount * [PolyStateExample.IncShkDstn[0]]\n", - "PolyStateExample.cycles = 0\n", "\n", "# Make a Cobb-Douglas economy for the agents\n", "# Use verbose=False to remove printing of intercept\n", "PolyStateEconomy = CobbDouglasMarkovEconomy(\n", " agents=[PolyStateExample],\n", - " verbose=False,\n", + " verbose=True,\n", + " MrkvArray=PolyMrkvArray,\n", + " PermGroFacAgg=PermGroFacAgg,\n", + " PermShkAggStd=StateCount * [0.006],\n", + " TranShkAggStd=StateCount * [0.003],\n", + " slope_prev=StateCount * [1.0],\n", + " intercept_prev=StateCount * [0.0],\n", ")\n", - "PolyStateEconomy.MrkvArray = PolyMrkvArray\n", - "PolyStateEconomy.PermGroFacAgg = PermGroFacAgg\n", - "PolyStateEconomy.PermShkAggStd = StateCount * [0.006]\n", - "PolyStateEconomy.TranShkAggStd = StateCount * [0.003]\n", - "PolyStateEconomy.slope_prev = StateCount * [1.0]\n", - "PolyStateEconomy.intercept_prev = StateCount * [0.0]\n", - "PolyStateEconomy.update()\n", - "PolyStateEconomy.makeAggShkDstn()\n", "PolyStateEconomy.make_AggShkHist() # Simulate a history of aggregate shocks\n", - "PolyStateEconomy.give_agent_params() # Have the consumers inherit relevant objects from the economy\n", - "\n", + "PolyStateEconomy.give_agent_params() # Have the consumers inherit relevant objects from the economy" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b6e62477-2a06-4dd6-9707-f4639148cf66", + "metadata": {}, + "outputs": [], + "source": [ "# Solve the many state model\n", - "t_start = process_time()\n", - "print(\n", - " \"Now solving an economy with \"\n", - " + str(StateCount)\n", - " + \" Markov states. This might take a while...\",\n", - ")\n", - "PolyStateEconomy.solve()\n", - "t_end = process_time()\n", - "print(\n", - " \"Solving a model with \"\n", - " + str(StateCount)\n", - " + \" states took \"\n", - " + str(t_end - t_start)\n", - " + \" seconds.\",\n", - ")" + "if solve_poly:\n", + " t_start = time()\n", + " print(\n", + " \"Now solving an economy with \"\n", + " + str(StateCount)\n", + " + \" Markov states. This might take a while...\",\n", + " )\n", + " PolyStateEconomy.solve()\n", + " t_end = time()\n", + " print(\n", + " \"Solving a model with \"\n", + " + str(StateCount)\n", + " + \" states took \"\n", + " + str(t_end - t_start)\n", + " + \" seconds.\",\n", + " )" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db8ce3f2-a0d1-4660-bd17-80fd8d0f624b", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": {