From a7b271d4f200823eebd3df114a9b163b5e16acab Mon Sep 17 00:00:00 2001 From: sb Date: Sun, 15 Mar 2020 11:33:45 -0400 Subject: [PATCH 01/19] removing timeFlip() etc. methods and tests. breaks solvers before revisions. --- HARK/core.py | 64 ----------------------------------------- HARK/tests/test_core.py | 19 +----------- 2 files changed, 1 insertion(+), 82 deletions(-) diff --git a/HARK/core.py b/HARK/core.py index e33ab7aec..39035cf16 100644 --- a/HARK/core.py +++ b/HARK/core.py @@ -227,70 +227,6 @@ def __init__(self, solution_terminal=None, cycles=1, time_flow=True, pseudo_term self.assignParameters(**kwds) # NOQA self.resetRNG() # NOQA - def timeReport(self): - ''' - Report to the user the direction that time is currently "flowing" for - this instance. Only exists as a reminder of how time_flow works. - - Parameters - ---------- - none - - Returns - ------- - none - ''' - if self.time_flow: - print('Time varying objects are listed in ordinary chronological order.') - else: - print('Time varying objects are listed in reverse chronological order.') - - def timeFlip(self): - ''' - Reverse the flow of time for this instance. - - Parameters - ---------- - none - - Returns - ------- - none - ''' - for name in self.time_vary: - self.__dict__[name].reverse() - self.time_flow = not self.time_flow - - def timeFwd(self): - ''' - Make time flow forward for this instance. - - Parameters - ---------- - none - - Returns - ------- - none - ''' - if not self.time_flow: - self.timeFlip() - - def timeRev(self): - ''' - Make time flow backward for this instance. - - Parameters - ---------- - none - - Returns - ------- - none - ''' - if self.time_flow: - self.timeFlip() - def addToTimeVary(self, *params): ''' Adds any number of parameters to time_vary for this instance. diff --git a/HARK/tests/test_core.py b/HARK/tests/test_core.py index e32fc0517..2fe91c96f 100644 --- a/HARK/tests/test_core.py +++ b/HARK/tests/test_core.py @@ -80,23 +80,6 @@ class testAgentType(unittest.TestCase): def setUp(self): self.agent = AgentType() - def test_time(self): - self.agent.time_vary = ['var_1', 'var_2'] - self.agent.var_1 = [4.3, 2, 1] - self.agent.var_2 = [1, 2, 3, 4, 5] - self.agent.timeFlip() - self.assertEqual(self.agent.var_1, [1, 2, 4.3]) - self.assertEqual(self.agent.var_2, [5, 4, 3, 2, 1]) - self.assertEqual(self.agent.time_flow, False) - self.agent.timeFlip() - self.assertEqual(self.agent.var_1, [4.3, 2, 1]) - self.assertEqual(self.agent.var_2, [1, 2, 3, 4, 5]) - self.assertEqual(self.agent.time_flow, True) - self.agent.timeRev() - self.assertEqual(self.agent.time_flow, False) - self.agent.timeFwd() - self.assertEqual(self.agent.time_flow, True) - def test_solve(self): self.agent.time_vary = ['vary_1'] self.agent.time_inv = ['inv_1'] @@ -107,4 +90,4 @@ def test_solve(self): self.agent.solveOnePeriod = lambda vary_1: HARKobject() self.agent.solve() self.assertEqual(len(self.agent.solution), 4) - self.assertTrue(isinstance(self.agent.solution[0], HARKobject)) \ No newline at end of file + self.assertTrue(isinstance(self.agent.solution[0], HARKobject)) From 96c9485eaea48ebcdd8e873b931bbf3a4772d364 Mon Sep 17 00:00:00 2001 From: sb Date: Sun, 15 Mar 2020 11:45:05 -0400 Subject: [PATCH 02/19] removing time fixing from ConsumptionSaving models; always assume forward time --- HARK/ConsumptionSaving/ConsGenIncProcessModel.py | 14 -------------- HARK/ConsumptionSaving/ConsIndShockModel.py | 4 ---- .../tests/test_modelcomparisons.py | 3 --- HARK/core.py | 12 +----------- 4 files changed, 1 insertion(+), 32 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsGenIncProcessModel.py b/HARK/ConsumptionSaving/ConsGenIncProcessModel.py index 83f51501e..b39401b98 100644 --- a/HARK/ConsumptionSaving/ConsGenIncProcessModel.py +++ b/HARK/ConsumptionSaving/ConsGenIncProcessModel.py @@ -1095,8 +1095,6 @@ def updatepLvlGrid(self): ------- None ''' - orig_time = self.time_flow - self.timeFwd() LivPrbAll = np.array(self.LivPrb) # Simulate the distribution of persistent income levels by t_cycle in a lifecycle model @@ -1144,8 +1142,6 @@ def updatepLvlGrid(self): # Store the result and add attribute to time_vary self.pLvlGrid = pLvlGrid self.addToTimeVary('pLvlGrid') - if not orig_time: - self.timeRev() def simBirth(self, which_agents): ''' @@ -1261,18 +1257,12 @@ def updatepLvlNextFunc(self): ------- None ''' - orig_time = self.time_flow - self.timeFwd() - pLvlNextFunc = [] for t in range(self.T_cycle): pLvlNextFunc.append(LinearInterp(np.array([0., 1.]), np.array([0., self.PermGroFac[t]]))) self.pLvlNextFunc = pLvlNextFunc self.addToTimeVary('pLvlNextFunc') - if not orig_time: - self.timeRev() - ############################################################################### @@ -1300,8 +1290,6 @@ def updatepLvlNextFunc(self): ------- None ''' - orig_time = self.time_flow - self.timeFwd() pLvlNextFunc = [] pLogMean = self.pLvlInitMean # Initial mean (log) persistent income @@ -1312,5 +1300,3 @@ def updatepLvlNextFunc(self): self.pLvlNextFunc = pLvlNextFunc self.addToTimeVary('pLvlNextFunc') - if not orig_time: - self.timeRev() diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index 7dee73e0d..40af10221 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -2047,15 +2047,11 @@ def updateIncomeProcess(self): ----------- none ''' - original_time = self.time_flow - self.timeFwd() IncomeDstn, PermShkDstn, TranShkDstn = constructLognormalIncomeProcessUnemployment(self) self.IncomeDstn = IncomeDstn self.PermShkDstn = PermShkDstn self.TranShkDstn = TranShkDstn self.addToTimeVary('IncomeDstn','PermShkDstn','TranShkDstn') - if not original_time: - self.timeRev() def updateAssetsGrid(self): ''' diff --git a/HARK/ConsumptionSaving/tests/test_modelcomparisons.py b/HARK/ConsumptionSaving/tests/test_modelcomparisons.py index 5177b4cd3..752a8921d 100644 --- a/HARK/ConsumptionSaving/tests/test_modelcomparisons.py +++ b/HARK/ConsumptionSaving/tests/test_modelcomparisons.py @@ -49,8 +49,6 @@ def setUp(self): InfiniteType.updateIncomeProcess() InfiniteType.solve() - InfiniteType.timeFwd() - InfiniteType.unpackcFunc() # Make and solve a perfect foresight consumer type with the same parameters PerfectForesightType = PerfForesightConsumerType(**test_dictionary) @@ -58,7 +56,6 @@ def setUp(self): PerfectForesightType.solve() PerfectForesightType.unpackcFunc() - PerfectForesightType.timeFwd() self.InfiniteType = InfiniteType self.PerfectForesightType = PerfectForesightType diff --git a/HARK/core.py b/HARK/core.py index 39035cf16..e2b19c057 100644 --- a/HARK/core.py +++ b/HARK/core.py @@ -660,8 +660,6 @@ def simulate(self, sim_periods=None): # tions with well-defined answers such as 1.0/0.0 that is np.inf, -1.0/0.0 that is # -np.inf, np.inf/np.inf is np.nan and so on. with np.errstate(divide='ignore', over='ignore', under='ignore', invalid='ignore'): - orig_time = self.time_flow - self.timeFwd() if sim_periods is None: sim_periods = self.T_sim @@ -671,9 +669,6 @@ def simulate(self, sim_periods=None): exec('self.' + var_name + '_hist[self.t_sim,:] = self.' + var_name) self.t_sim += 1 - if not orig_time: - self.timeRev() - def clearHistory(self): ''' Clears the histories of the attributes named in self.track_vars. @@ -709,9 +704,7 @@ def solveAgent(agent, verbose): A list of solutions to the one period problems that the agent will encounter in his "lifetime". Returns in reverse chronological order. ''' - # Record the flow of time when the Agent began the process, and make sure time is flowing backwards - original_time_flow = agent.time_flow - agent.timeRev() + ## TODO: This requires Reversed Time # Check to see whether this is an (in)finite horizon problem cycles_left = agent.cycles # NOQA @@ -769,9 +762,6 @@ def solveAgent(agent, verbose): if infinite_horizon: solution = solution_cycle # PseudoTerminal=False impossible for infinite horizon - # Restore the direction of time to its original orientation, then return the solution - if original_time_flow: - agent.timeFwd() return solution From 486cd5138ddcec9afb044f2e3e722717ef69183e Mon Sep 17 00:00:00 2001 From: sb Date: Sun, 15 Mar 2020 12:15:27 -0400 Subject: [PATCH 03/19] remove time_flow as a model initializer parameter --- HARK/ConsumptionSaving/ConsAggShockModel.py | 7 +++-- .../ConsGenIncProcessModel.py | 8 +++--- HARK/ConsumptionSaving/ConsIndShockModel.py | 18 ++++-------- HARK/ConsumptionSaving/ConsLaborModel.py | 28 ++++--------------- HARK/ConsumptionSaving/ConsMarkovModel.py | 6 ++-- HARK/ConsumptionSaving/ConsMedModel.py | 15 +++------- HARK/ConsumptionSaving/ConsPortfolioModel.py | 6 ++-- HARK/ConsumptionSaving/ConsPrefShockModel.py | 13 +-------- HARK/ConsumptionSaving/ConsRepAgentModel.py | 13 ++++----- .../TractableBufferStockModel.py | 8 +++--- HARK/core.py | 14 ++-------- 11 files changed, 42 insertions(+), 94 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsAggShockModel.py b/HARK/ConsumptionSaving/ConsAggShockModel.py index dc1c0a43f..c05aabef5 100644 --- a/HARK/ConsumptionSaving/ConsAggShockModel.py +++ b/HARK/ConsumptionSaving/ConsAggShockModel.py @@ -79,7 +79,7 @@ class AggShockConsumerType(IndShockConsumerType): evolves over time and take aggregate shocks into account when making their decision about how much to consume. ''' - def __init__(self, time_flow=True, **kwds): + def __init__(self, **kwds): ''' Make a new instance of AggShockConsumerType, an extension of IndShockConsumerType. Sets appropriate solver and input lists. @@ -87,8 +87,9 @@ def __init__(self, time_flow=True, **kwds): params = Params.init_agg_shocks.copy() params.update(kwds) kwds = params - AgentType.__init__(self, solution_terminal=deepcopy(IndShockConsumerType.solution_terminal_), - time_flow=time_flow, pseudo_terminal=False, **kwds) + AgentType.__init__(self, + solution_terminal=deepcopy(IndShockConsumerType.solution_terminal_), + pseudo_terminal=False, **kwds) # Add consumer-type specific objects, copying to create independent versions self.time_vary = deepcopy(IndShockConsumerType.time_vary_) diff --git a/HARK/ConsumptionSaving/ConsGenIncProcessModel.py b/HARK/ConsumptionSaving/ConsGenIncProcessModel.py index b39401b98..a461625ad 100644 --- a/HARK/ConsumptionSaving/ConsGenIncProcessModel.py +++ b/HARK/ConsumptionSaving/ConsGenIncProcessModel.py @@ -970,7 +970,7 @@ class GenIncProcessConsumerType(IndShockConsumerType): solution_terminal_ = ConsumerSolution(cFunc=cFunc_terminal_, mNrmMin=0.0, hNrm=0.0, MPCmin=1.0, MPCmax=1.0) poststate_vars_ = ['aLvlNow', 'pLvlNow'] - def __init__(self, cycles=0, time_flow=True, **kwds): + def __init__(self, cycles=0, **kwds): ''' Instantiate a new ConsumerType with given data. See ConsumerParameters.init_explicit_perm_inc for a dictionary of the @@ -980,8 +980,6 @@ def __init__(self, cycles=0, time_flow=True, **kwds): ---------- cycles : int Number of times the sequence of periods should be solved. - time_flow : boolean - Whether time is currently "flowing" forward for this instance. Returns ------- @@ -992,7 +990,9 @@ def __init__(self, cycles=0, time_flow=True, **kwds): kwds = params # Initialize a basic ConsumerType - IndShockConsumerType.__init__(self, cycles=cycles, time_flow=time_flow, **kwds) + IndShockConsumerType.__init__(self, + cycles=cycles, + **kwds) self.solveOnePeriod = solveConsGenIncProcess # idiosyncratic shocks solver with explicit persistent income def preSolve(self): diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index 40af10221..f4b3d43b6 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -1598,7 +1598,6 @@ class PerfForesightConsumerType(AgentType): def __init__(self, cycles=1, - time_flow=True, verbose=False, quiet=False, **kwds): @@ -1611,8 +1610,6 @@ def __init__(self, ---------- cycles : int Number of times the sequence of periods should be solved. - time_flow : boolean - Whether time is currently "flowing" forward for this instance. Returns ------- @@ -1624,7 +1621,8 @@ def __init__(self, # Initialize a basic AgentType AgentType.__init__(self,solution_terminal=deepcopy(self.solution_terminal_), - cycles=cycles,time_flow=time_flow,pseudo_terminal=False,**kwds) + cycles=cycles, + pseudo_terminal=False,**kwds) # Add consumer-type specific objects, copying to create independent versions self.time_vary = deepcopy(self.time_vary_) @@ -1997,7 +1995,6 @@ class IndShockConsumerType(PerfForesightConsumerType): def __init__(self, cycles=1, - time_flow=True, verbose=False, quiet=False, **kwds): @@ -2010,8 +2007,6 @@ def __init__(self, ---------- cycles : int Number of times the sequence of periods should be solved. - time_flow : boolean - Whether time is currently "flowing" forward for this instance. Returns ------- @@ -2025,7 +2020,6 @@ def __init__(self, # Initialize a basic AgentType PerfForesightConsumerType.__init__(self, cycles=cycles, - time_flow=time_flow, verbose=verbose, quiet=quiet, **kwds) @@ -2495,7 +2489,7 @@ class KinkedRconsumerType(IndShockConsumerType): time_inv_.remove('Rfree') time_inv_ += ['Rboro', 'Rsave'] - def __init__(self,cycles=1,time_flow=True,**kwds): + def __init__(self,cycles=1,**kwds): ''' Instantiate a new ConsumerType with given data. See ConsumerParameters.init_kinked_R for a dictionary of @@ -2505,8 +2499,6 @@ def __init__(self,cycles=1,time_flow=True,**kwds): ---------- cycles : int Number of times the sequence of periods should be solved. - time_flow : boolean - Whether time is currently "flowing" forward for this instance. Returns ------- @@ -2517,7 +2509,9 @@ def __init__(self,cycles=1,time_flow=True,**kwds): kwds = params # Initialize a basic AgentType - PerfForesightConsumerType.__init__(self,cycles=cycles,time_flow=time_flow,**kwds) + PerfForesightConsumerType.__init__(self, + cycles=cycles, + **kwds) # Add consumer-type specific objects, copying to create independent versions self.solveOnePeriod = solveConsKinkedR # kinked R solver diff --git a/HARK/ConsumptionSaving/ConsLaborModel.py b/HARK/ConsumptionSaving/ConsLaborModel.py index cf34826e5..23351ff11 100644 --- a/HARK/ConsumptionSaving/ConsLaborModel.py +++ b/HARK/ConsumptionSaving/ConsLaborModel.py @@ -246,7 +246,7 @@ def solveConsLaborIntMarg(solution_next,PermShkDstn,TranShkDstn,LivPrb,DiscFac,C class LaborIntMargConsumerType(IndShockConsumerType): - ''' + ''' A class representing agents who make a decision each period about how much to consume vs save and how much labor to supply (as a fraction of their time). They get CRRA utility from a composite good x_t = c_t*z_t^alpha, and discount @@ -256,7 +256,7 @@ class LaborIntMargConsumerType(IndShockConsumerType): time_vary_ += ['WageRte'] time_inv_ = copy(IndShockConsumerType.time_inv_) - def __init__(self,cycles=1,time_flow=True,**kwds): + def __init__(self,cycles=1,**kwds): ''' Instantiate a new consumer type with given data. See ConsumerParameters.init_labor_intensive for a dictionary of @@ -266,8 +266,6 @@ def __init__(self,cycles=1,time_flow=True,**kwds): ---------- cycles : int Number of times the sequence of periods should be solved. - time_flow : boolean - Whether time is currently "flowing" forward for this instance. Returns ------- @@ -277,7 +275,8 @@ def __init__(self,cycles=1,time_flow=True,**kwds): params.update(kwds) kwds = params - IndShockConsumerType.__init__(self,cycles = cycles,time_flow=time_flow,**kwds) + IndShockConsumerType.__init__(self,cycles = cycles, + **kwds) self.pseudo_terminal = False self.solveOnePeriod = solveConsLaborIntMarg self.update() @@ -320,13 +319,8 @@ def updateLbrCost(self): for n in range(N): LbrCostBase += Coeffs[n]*age_vec**n LbrCost = np.exp(LbrCostBase) - time_orig = self.time_flow - self.timeFwd() self.LbrCost = LbrCost.tolist() self.addToTimeVary('LbrCost') - if not time_orig: - self.timeRev() - def calcBoundingValues(self): ''' @@ -458,18 +452,11 @@ def updateTranShkGrid(self): ------- None ''' - time_orig=self.time_flow - self.timeFwd() - TranShkGrid = [] # Create an empty list for TranShkGrid that will be updated for t in range(self.T_cycle): TranShkGrid.append(self.TranShkDstn[t][1]) # Update/ Extend the list of TranShkGrid with the TranShkVals for each TranShkPrbs self.TranShkGrid = TranShkGrid # Save that list in self (time-varying) self.addToTimeVary('TranShkGrid') # Run the method addToTimeVary from AgentType to add TranShkGrid as one parameter of time_vary list - - if not time_orig: - self.timeRev() - def updateSolutionTerminal(self): ''' @@ -483,11 +470,8 @@ def updateSolutionTerminal(self): Returns ------- None - ''' - if self.time_flow: # To make sure we pick the last element of the list, depending on the direction time is flowing - t=-1 - else: - t=0 + ''' + t=-1 TranShkGrid = self.TranShkGrid[t] LbrCost = self.LbrCost[t] WageRte = self.WageRte[t] diff --git a/HARK/ConsumptionSaving/ConsMarkovModel.py b/HARK/ConsumptionSaving/ConsMarkovModel.py index 2641dd9eb..13d280eff 100644 --- a/HARK/ConsumptionSaving/ConsMarkovModel.py +++ b/HARK/ConsumptionSaving/ConsMarkovModel.py @@ -682,8 +682,10 @@ class MarkovConsumerType(IndShockConsumerType): time_vary_ = IndShockConsumerType.time_vary_ + ['MrkvArray'] shock_vars_ = IndShockConsumerType.shock_vars_ + ['MrkvNow'] - def __init__(self,cycles=1,time_flow=True,**kwds): - IndShockConsumerType.__init__(self,cycles=1,time_flow=True,**kwds) + def __init__(self, + cycles=1, + **kwds): + IndShockConsumerType.__init__(self,cycles=1,**kwds) self.solveOnePeriod = _solveConsMarkov self.poststate_vars += ['MrkvNow'] if not hasattr(self, 'global_markov'): diff --git a/HARK/ConsumptionSaving/ConsMedModel.py b/HARK/ConsumptionSaving/ConsMedModel.py index 32aaea065..cf22c205f 100644 --- a/HARK/ConsumptionSaving/ConsMedModel.py +++ b/HARK/ConsumptionSaving/ConsMedModel.py @@ -513,7 +513,7 @@ class MedShockConsumerType(PersistentShockConsumerType): ''' shock_vars_ = PersistentShockConsumerType.shock_vars_ + ['MedShkNow'] - def __init__(self,cycles=0,time_flow=True,**kwds): + def __init__(self,cycles=0,**kwds): ''' Instantiate a new ConsumerType with given data, and construct objects to be used during solution (income distribution, assets grid, etc). @@ -524,8 +524,6 @@ def __init__(self,cycles=0,time_flow=True,**kwds): ---------- cycles : int Number of times the sequence of periods should be solved. - time_flow : boolean - Whether time is currently "flowing" forward for this instance. Returns ------- @@ -604,14 +602,9 @@ def updateSolutionTerminal(self): None ''' # Take last period data, whichever way time is flowing - if self.time_flow: - MedPrice = self.MedPrice[-1] - MedShkVals = self.MedShkDstn[-1][1] - MedShkPrbs = self.MedShkDstn[-1][0] - else: - MedPrice = self.MedPrice[0] - MedShkVals = self.MedShkDstn[0][1] - MedShkPrbs = self.MedShkDstn[0][0] + MedPrice = self.MedPrice[-1] + MedShkVals = self.MedShkDstn[-1][1] + MedShkPrbs = self.MedShkDstn[-1][0] # Initialize grids of medical need shocks, market resources, and optimal consumption MedShkGrid = MedShkVals diff --git a/HARK/ConsumptionSaving/ConsPortfolioModel.py b/HARK/ConsumptionSaving/ConsPortfolioModel.py index 87cecd7ce..37405393e 100644 --- a/HARK/ConsumptionSaving/ConsPortfolioModel.py +++ b/HARK/ConsumptionSaving/ConsPortfolioModel.py @@ -403,13 +403,12 @@ class PortfolioConsumerType(IndShockConsumerType): time_inv_ = time_inv_ + ["RiskyShareLimitFunc", "PortfolioDomain"] time_inv_ = time_inv_ + ["AdjustPrb", "PortfolioGrid", "AdjustCount"] - def __init__(self, cycles=1, time_flow=True, verbose=False, quiet=False, **kwds): + def __init__(self, cycles=1, verbose=False, quiet=False, **kwds): # Initialize a basic AgentType PerfForesightConsumerType.__init__( self, cycles=cycles, - time_flow=time_flow, verbose=verbose, quiet=quiet, **kwds @@ -1430,12 +1429,11 @@ class LogNormalPortfolioConsumerType(PortfolioConsumerType): # time_inv_ = PortfolioConsumerType.time_inv_ + ['approxRiskyDstn', 'RiskyCount', 'RiskyShareCount', 'RiskyShareLimitFunc', 'AdjustPrb', 'PortfolioGrid'] - def __init__(self, cycles=1, time_flow=True, verbose=False, quiet=False, **kwds): + def __init__(self, cycles=1, verbose=False, quiet=False, **kwds): PortfolioConsumerType.__init__( self, cycles=cycles, - time_flow=time_flow, verbose=verbose, quiet=quiet, **kwds diff --git a/HARK/ConsumptionSaving/ConsPrefShockModel.py b/HARK/ConsumptionSaving/ConsPrefShockModel.py index 340c3aff2..91a5a4120 100644 --- a/HARK/ConsumptionSaving/ConsPrefShockModel.py +++ b/HARK/ConsumptionSaving/ConsPrefShockModel.py @@ -28,7 +28,6 @@ class PrefShockConsumerType(IndShockConsumerType): def __init__(self, cycles=1, - time_flow=True, **kwds): ''' Instantiate a new ConsumerType with given data, and construct objects @@ -40,8 +39,6 @@ def __init__(self, ---------- cycles : int Number of times the sequence of periods should be solved. - time_flow : boolean - Whether time is currently "flowing" forward for this instance. Returns ------- @@ -53,7 +50,6 @@ def __init__(self, IndShockConsumerType.__init__(self, cycles=cycles, - time_flow=time_flow, **kwds) self.solveOnePeriod = solveConsPrefShock # Choose correct solver @@ -91,9 +87,6 @@ def updatePrefShockProcess(self): ------- none ''' - time_orig = self.time_flow - self.timeFwd() - PrefShkDstn = [] # discrete distributions of preference shocks for t in range(len(self.PrefShkStd)): PrefShkStd = self.PrefShkStd[t] @@ -103,8 +96,6 @@ def updatePrefShockProcess(self): # Store the preference shocks in self (time-varying) and restore time flow self.PrefShkDstn = PrefShkDstn self.addToTimeVary('PrefShkDstn') - if not time_orig: - self.timeRev() def getShocks(self): ''' @@ -201,7 +192,7 @@ class KinkyPrefConsumerType(PrefShockConsumerType,KinkedRconsumerType): utility each period, specified as iid lognormal and different interest rates on borrowing vs saving. ''' - def __init__(self,cycles=1,time_flow=True,**kwds): + def __init__(self,cycles=1,**kwds): ''' Instantiate a new ConsumerType with given data, and construct objects to be used during solution (income distribution, assets grid, etc). @@ -212,8 +203,6 @@ def __init__(self,cycles=1,time_flow=True,**kwds): ---------- cycles : int Number of times the sequence of periods should be solved. - time_flow : boolean - Whether time is currently "flowing" forward for this instance. Returns ------- diff --git a/HARK/ConsumptionSaving/ConsRepAgentModel.py b/HARK/ConsumptionSaving/ConsRepAgentModel.py index b0b755ccb..5400d147a 100644 --- a/HARK/ConsumptionSaving/ConsRepAgentModel.py +++ b/HARK/ConsumptionSaving/ConsRepAgentModel.py @@ -194,20 +194,18 @@ class RepAgentConsumerType(IndShockConsumerType): ''' time_inv_ = IndShockConsumerType.time_inv_ + ['CapShare','DeprFac'] - def __init__(self,time_flow=True,**kwds): + def __init__(self,**kwds): ''' Make a new instance of a representative agent. Parameters ---------- - time_flow : boolean - Whether time is currently "flowing" forward for this instance. Returns ------- None ''' - IndShockConsumerType.__init__(self,cycles=0,time_flow=time_flow,**kwds) + IndShockConsumerType.__init__(self,cycles=0,**kwds) self.AgentCount = 1 # Hardcoded, because this is rep agent self.solveOnePeriod = solveConsRepAgent self.delFromTimeInv('Rfree','BoroCnstArt','vFuncBool','CubicBool') @@ -247,20 +245,19 @@ class RepAgentMarkovConsumerType(RepAgentConsumerType): ''' time_inv_ = RepAgentConsumerType.time_inv_ + ['MrkvArray'] - def __init__(self,time_flow=True,**kwds): + def __init__(self,**kwds): ''' Make a new instance of a representative agent with Markov state. Parameters ---------- - time_flow : boolean - Whether time is currently "flowing" forward for this instance. + Returns ------- None ''' - RepAgentConsumerType.__init__(self,time_flow=time_flow,**kwds) + RepAgentConsumerType.__init__(self,**kwds) self.solveOnePeriod = solveConsRepAgentMarkov def preSolve(self): diff --git a/HARK/ConsumptionSaving/TractableBufferStockModel.py b/HARK/ConsumptionSaving/TractableBufferStockModel.py index f47425fe2..0a2025060 100644 --- a/HARK/ConsumptionSaving/TractableBufferStockModel.py +++ b/HARK/ConsumptionSaving/TractableBufferStockModel.py @@ -226,7 +226,7 @@ def addToStableArmPoints(solution_next,DiscFac,Rfree,CRRA,PermGroFacCmp,UnempPrb class TractableConsumerType(AgentType): - def __init__(self,cycles=0,time_flow=False,**kwds): + def __init__(self,cycles=0,**kwds): ''' Instantiate a new TractableConsumerType with given data. @@ -234,15 +234,15 @@ def __init__(self,cycles=0,time_flow=False,**kwds): ---------- cycles : int Number of times the sequence of periods should be solved. - time_flow : boolean - Whether time is currently "flowing" forward for this instance. Returns: ----------- New instance of TractableConsumerType. ''' # Initialize a basic AgentType - AgentType.__init__(self,cycles=cycles,time_flow=time_flow,pseudo_terminal=True,**kwds) + AgentType.__init__(self, + cycles=cycles, + pseudo_terminal=True,**kwds) # Add consumer-type specific objects, copying to create independent versions self.time_vary = [] diff --git a/HARK/core.py b/HARK/core.py index e2b19c057..4a7e395e5 100644 --- a/HARK/core.py +++ b/HARK/core.py @@ -173,7 +173,7 @@ class AgentType(HARKobject): that varies over time in the model. Each element of time_inv is the name of a field in AgentSubType that is constant over time in the model. ''' - def __init__(self, solution_terminal=None, cycles=1, time_flow=True, pseudo_terminal=True, + def __init__(self, solution_terminal=None, cycles=1, pseudo_terminal=True, tolerance=0.000001, seed=0, **kwds): ''' Initialize an instance of AgentType by setting attributes. @@ -190,10 +190,6 @@ def __init__(self, solution_terminal=None, cycles=1, time_flow=True, pseudo_term model, with a certain sequence of one period problems experienced once before terminating. cycles=0 corresponds to an infinite horizon model, with a sequence of one period problems repeating indefinitely. - time_flow : boolean - Whether time is currently "flowing" forward(True) or backward(False) for this - instance. Used to flip between solving (using backward iteration) - and simulating (etc). pseudo_terminal : boolean Indicates whether solution_terminal isn't actually part of the solution to the problem (as a known solution to the terminal period @@ -216,7 +212,6 @@ def __init__(self, solution_terminal=None, cycles=1, time_flow=True, pseudo_term solution_terminal = NullFunc() self.solution_terminal = solution_terminal # NOQA self.cycles = cycles # NOQA - self.time_flow = time_flow # NOQA self.pseudo_terminal = pseudo_terminal # NOQA self.solveOnePeriod = NullFunc() # NOQA self.tolerance = tolerance # NOQA @@ -317,8 +312,7 @@ def solve(self, verbose=False): with np.errstate(divide='ignore', over='ignore', under='ignore', invalid='ignore'): self.preSolve() # Do pre-solution stuff self.solution = solveAgent(self, verbose) # Solve the model by backward induction - if self.time_flow: # Put the solution in chronological order if this instance's time flow runs that way - self.solution.reverse() + self.solution.reverse() self.addToTimeVary('solution') # Add solution to the list of time-varying attributes self.postSolve() # Do post-solution stuff @@ -467,8 +461,6 @@ def makeShockHistory(self): None ''' # Make sure time is flowing forward and re-initialize the simulation - orig_time = self.time_flow - self.timeFwd() self.initializeSim() # Make blank history arrays for each shock variable @@ -488,8 +480,6 @@ def makeShockHistory(self): # Restore the flow of time and flag that shocks can be read rather than simulated self.read_shocks = True - if not orig_time: - self.timeRev() def getMortality(self): ''' From 7ce6239fee8cb1290ca84cd60ff2eb90c88423a7 Mon Sep 17 00:00:00 2001 From: sb Date: Sun, 15 Mar 2020 17:42:20 -0400 Subject: [PATCH 04/19] whoops; putting back in an unpackFunc --- HARK/ConsumptionSaving/tests/test_modelcomparisons.py | 1 + 1 file changed, 1 insertion(+) diff --git a/HARK/ConsumptionSaving/tests/test_modelcomparisons.py b/HARK/ConsumptionSaving/tests/test_modelcomparisons.py index 752a8921d..d3b1238d6 100644 --- a/HARK/ConsumptionSaving/tests/test_modelcomparisons.py +++ b/HARK/ConsumptionSaving/tests/test_modelcomparisons.py @@ -49,6 +49,7 @@ def setUp(self): InfiniteType.updateIncomeProcess() InfiniteType.solve() + InfiniteType.unpackcFunc() # Make and solve a perfect foresight consumer type with the same parameters PerfectForesightType = PerfForesightConsumerType(**test_dictionary) From f98f2f0818c0b22ffea9c22a0c0bbe6cbbb4a385 Mon Sep 17 00:00:00 2001 From: sb Date: Sun, 15 Mar 2020 17:43:54 -0400 Subject: [PATCH 05/19] moving solution reversal inside solveAgent() --- HARK/core.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/HARK/core.py b/HARK/core.py index 4a7e395e5..efae28171 100644 --- a/HARK/core.py +++ b/HARK/core.py @@ -312,7 +312,6 @@ def solve(self, verbose=False): with np.errstate(divide='ignore', over='ignore', under='ignore', invalid='ignore'): self.preSolve() # Do pre-solution stuff self.solution = solveAgent(self, verbose) # Solve the model by backward induction - self.solution.reverse() self.addToTimeVary('solution') # Add solution to the list of time-varying attributes self.postSolve() # Do post-solution stuff @@ -692,7 +691,7 @@ def solveAgent(agent, verbose): ------- solution : [Solution] A list of solutions to the one period problems that the agent will - encounter in his "lifetime". Returns in reverse chronological order. + encounter in his "lifetime". ''' ## TODO: This requires Reversed Time @@ -752,6 +751,7 @@ def solveAgent(agent, verbose): if infinite_horizon: solution = solution_cycle # PseudoTerminal=False impossible for infinite horizon + solution.reverse() return solution From 8a7bcb23ce61dd5c44ee7cee328dbd8701843970 Mon Sep 17 00:00:00 2001 From: sb Date: Mon, 16 Mar 2020 10:19:14 -0400 Subject: [PATCH 06/19] just some line breaks/cleanup --- HARK/core.py | 33 ++++++++++++++++++--------------- 1 file changed, 18 insertions(+), 15 deletions(-) diff --git a/HARK/core.py b/HARK/core.py index efae28171..6e0b706cc 100644 --- a/HARK/core.py +++ b/HARK/core.py @@ -676,14 +676,19 @@ def clearHistory(self): def solveAgent(agent, verbose): ''' - Solve the dynamic model for one agent type. This function iterates on "cycles" - of an agent's model either a given number of times or until solution convergence - if an infinite horizon model is used (with agent.cycles = 0). + Solve the dynamic model for one agent type + using backwards induction. + This function iterates on "cycles" + of an agent's model either a given number of times + or until solution convergence + if an infinite horizon model is used + (with agent.cycles = 0). Parameters ---------- agent : AgentType - The microeconomic AgentType whose dynamic problem is to be solved. + The microeconomic AgentType whose dynamic problem + is to be solved. verbose : boolean If True, solution progress is printed to screen (when cycles != 1). @@ -785,16 +790,12 @@ def solveOneCycle(agent, solution_last): else: T = 1 - # Construct a dictionary to be passed to the solver - # time_inv_string = '' - # for name in agent.time_inv: - # time_inv_string += ' \'' + name + '\' : agent.' + name + ',' - # time_vary_string = '' - # for name in agent.time_vary: - # time_vary_string += ' \'' + name + '\' : None,' - # solve_dict = eval('{' + time_inv_string + time_vary_string + '}') - solve_dict = {parameter: agent.__dict__[parameter] for parameter in agent.time_inv} - solve_dict.update({parameter: None for parameter in agent.time_vary}) + solve_dict = {parameter: agent.__dict__[parameter] + for parameter + in agent.time_inv} + solve_dict.update({parameter: None + for parameter + in agent.time_vary}) # Initialize the solution for this cycle, then iterate on periods solution_cycle = [] @@ -816,7 +817,9 @@ def solveOneCycle(agent, solution_last): solve_dict['solution_next'] = solution_next # Make a temporary dictionary for this period - temp_dict = {name: solve_dict[name] for name in these_args} + temp_dict = {name: solve_dict[name] + for name + in these_args} # Solve one period, add it to the solution, and move to the next period solution_t = solveOnePeriod(**temp_dict) From a0320affb0b7002521e376e5a1e266756da71e5a Mon Sep 17 00:00:00 2001 From: sb Date: Mon, 16 Mar 2020 11:12:06 -0400 Subject: [PATCH 07/19] stack solutions in solveAgent and solveOneCycle in forward order --- HARK/core.py | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/HARK/core.py b/HARK/core.py index 6e0b706cc..dadd06164 100644 --- a/HARK/core.py +++ b/HARK/core.py @@ -698,15 +698,13 @@ def solveAgent(agent, verbose): A list of solutions to the one period problems that the agent will encounter in his "lifetime". ''' - ## TODO: This requires Reversed Time - # Check to see whether this is an (in)finite horizon problem cycles_left = agent.cycles # NOQA infinite_horizon = cycles_left == 0 # NOQA # Initialize the solution, which includes the terminal solution if it's not a pseudo-terminal period solution = [] if not agent.pseudo_terminal: - solution.append(deepcopy(agent.solution_terminal)) + solution.insert(0, deepcopy(agent.solution_terminal)) # Initialize the process, then loop over cycles @@ -720,10 +718,11 @@ def solveAgent(agent, verbose): # Solve a cycle of the model, recording it if horizon is finite solution_cycle = solveOneCycle(agent, solution_last) if not infinite_horizon: - solution += solution_cycle + solution = solution_cycle + solution - # Check for termination: identical solutions across cycle iterations or run out of cycles - solution_now = solution_cycle[-1] + # Check for termination: identical solutions across + # cycle iterations or run out of cycles + solution_now = solution_cycle[0] if infinite_horizon: if completed_cycles > 0: solution_distance = solution_now.distance(solution_last) @@ -756,7 +755,6 @@ def solveAgent(agent, verbose): if infinite_horizon: solution = solution_cycle # PseudoTerminal=False impossible for infinite horizon - solution.reverse() return solution @@ -823,7 +821,7 @@ def solveOneCycle(agent, solution_last): # Solve one period, add it to the solution, and move to the next period solution_t = solveOnePeriod(**temp_dict) - solution_cycle.append(solution_t) + solution_cycle.insert(0, solution_t) solution_next = solution_t # Return the list of per-period solutions From c7d383699d25b8bf0ed471f440eb030f44414335 Mon Sep 17 00:00:00 2001 From: sb Date: Mon, 16 Mar 2020 11:12:42 -0400 Subject: [PATCH 08/19] comment fixes --- HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py | 2 +- HARK/core.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py index 5f08ea347..dc67d54d0 100644 --- a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py +++ b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py @@ -301,7 +301,7 @@ def test_lifecyle(self): self.assertAlmostEqual(LifecycleExample.solution[5].cFunc(3).tolist(), 2.129983771775666) -CyclicalDict = { # Click the arrow to expand this parameter dictionary +CyclicalDict = { # Parameters shared with the perfect foresight model "CRRA": 2.0, # Coefficient of relative risk aversion "Rfree": 1.03, # Interest factor on assets diff --git a/HARK/core.py b/HARK/core.py index dadd06164..4022ec027 100644 --- a/HARK/core.py +++ b/HARK/core.py @@ -778,7 +778,7 @@ def solveOneCycle(agent, solution_last): ------- solution_cycle : [Solution] A list of one period solutions for one "cycle" of the AgentType's - microeconomic model. Returns in reverse chronological order. + microeconomic model. ''' # Calculate number of periods per cycle, defaults to 1 if all variables are time invariant if len(agent.time_vary) > 0: From 877fa6424ae1de42044f9f3229d43540a8a48624 Mon Sep 17 00:00:00 2001 From: sb Date: Mon, 16 Mar 2020 11:14:03 -0400 Subject: [PATCH 09/19] add test of the solution terminal in the LifecycleExample --- .../tests/test_IndShockConsumerType.py | 28 +++++++++++-------- 1 file changed, 17 insertions(+), 11 deletions(-) diff --git a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py index dc67d54d0..881997a7e 100644 --- a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py +++ b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py @@ -35,17 +35,23 @@ def test_ConsIndShockSolverBasic(self): LifecycleExample.cycles = 1 LifecycleExample.solve() - solver = ConsIndShockSolverBasic(LifecycleExample.solution[1], - LifecycleExample.IncomeDstn[0], - LifecycleExample.LivPrb[0], - LifecycleExample.DiscFac, - LifecycleExample.CRRA, - LifecycleExample.Rfree, - LifecycleExample.PermGroFac[0], - LifecycleExample.BoroCnstArt, - LifecycleExample.aXtraGrid, - LifecycleExample.vFuncBool, - LifecycleExample.CubicBool) + # test the solution_terminal + self.assertAlmostEqual( + LifecycleExample.solution[10].cFunc(2).tolist(), + 2) + + solver = ConsIndShockSolverBasic( + LifecycleExample.solution[-2], + LifecycleExample.IncomeDstn[0], + LifecycleExample.LivPrb[0], + LifecycleExample.DiscFac, + LifecycleExample.CRRA, + LifecycleExample.Rfree, + LifecycleExample.PermGroFac[0], + LifecycleExample.BoroCnstArt, + LifecycleExample.aXtraGrid, + LifecycleExample.vFuncBool, + LifecycleExample.CubicBool) solver.prepareToSolve() From b6be2408392607488b5f840f475c27448f430be2 Mon Sep 17 00:00:00 2001 From: sb Date: Mon, 16 Mar 2020 11:30:58 -0400 Subject: [PATCH 10/19] adding tests for LifecycleExample solution consumption function --- .../tests/test_IndShockConsumerType.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py index 881997a7e..b14454ba8 100644 --- a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py +++ b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py @@ -35,6 +35,16 @@ def test_ConsIndShockSolverBasic(self): LifecycleExample.cycles = 1 LifecycleExample.solve() + self.assertAlmostEqual( + LifecycleExample.solution[0].cFunc(1).tolist(), + 0.87362789) + self.assertAlmostEqual( + LifecycleExample.solution[1].cFunc(1).tolist(), + 0.9081621) + self.assertAlmostEqual( + LifecycleExample.solution[2].cFunc(1).tolist(), + 0.9563899) + # test the solution_terminal self.assertAlmostEqual( LifecycleExample.solution[10].cFunc(2).tolist(), From 7c2f6c5b4778331c485c61af674585918bf347fe Mon Sep 17 00:00:00 2001 From: sb Date: Mon, 16 Mar 2020 12:06:03 -0400 Subject: [PATCH 11/19] More tests for the IndShockConsumerType LifecycleExample --- .../tests/test_IndShockConsumerType.py | 20 +++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py index b14454ba8..b650c8726 100644 --- a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py +++ b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py @@ -35,6 +35,19 @@ def test_ConsIndShockSolverBasic(self): LifecycleExample.cycles = 1 LifecycleExample.solve() + # test the solution_terminal + self.assertAlmostEqual( + LifecycleExample.solution[10].cFunc(2).tolist(), + 2) + + + self.assertAlmostEqual(LifecycleExample.solution[9].cFunc(1), + 0.97769632) + self.assertAlmostEqual(LifecycleExample.solution[8].cFunc(1), + 0.96624445) + self.assertAlmostEqual(LifecycleExample.solution[7].cFunc(1), + 0.95691449) + self.assertAlmostEqual( LifecycleExample.solution[0].cFunc(1).tolist(), 0.87362789) @@ -44,12 +57,7 @@ def test_ConsIndShockSolverBasic(self): self.assertAlmostEqual( LifecycleExample.solution[2].cFunc(1).tolist(), 0.9563899) - - # test the solution_terminal - self.assertAlmostEqual( - LifecycleExample.solution[10].cFunc(2).tolist(), - 2) - + solver = ConsIndShockSolverBasic( LifecycleExample.solution[-2], LifecycleExample.IncomeDstn[0], From 6af22a0e2cf7ba14339d7691ccea8e889edf7d61 Mon Sep 17 00:00:00 2001 From: sb Date: Mon, 16 Mar 2020 12:19:22 -0400 Subject: [PATCH 12/19] in solveOneCycle, assume data is forward, not backward --- HARK/core.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/HARK/core.py b/HARK/core.py index 4022ec027..ef4d4d53c 100644 --- a/HARK/core.py +++ b/HARK/core.py @@ -811,7 +811,7 @@ def solveOneCycle(agent, solution_last): for name in agent.time_vary: if name in these_args: # solve_dict[name] = eval('agent.' + name + '[t]') - solve_dict[name] = agent.__dict__[name][t] + solve_dict[name] = agent.__dict__[name][T - 1 - t] solve_dict['solution_next'] = solution_next # Make a temporary dictionary for this period From 4dfc6c9e0e74eb2e9dad9a6c356d67cebab2d7f5 Mon Sep 17 00:00:00 2001 From: sb Date: Mon, 16 Mar 2020 12:20:20 -0400 Subject: [PATCH 13/19] reverting bad change to test suite --- HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py index b650c8726..a4d34f392 100644 --- a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py +++ b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py @@ -40,7 +40,6 @@ def test_ConsIndShockSolverBasic(self): LifecycleExample.solution[10].cFunc(2).tolist(), 2) - self.assertAlmostEqual(LifecycleExample.solution[9].cFunc(1), 0.97769632) self.assertAlmostEqual(LifecycleExample.solution[8].cFunc(1), @@ -59,7 +58,7 @@ def test_ConsIndShockSolverBasic(self): 0.9563899) solver = ConsIndShockSolverBasic( - LifecycleExample.solution[-2], + LifecycleExample.solution[1], LifecycleExample.IncomeDstn[0], LifecycleExample.LivPrb[0], LifecycleExample.DiscFac, From d545b556caa3b512ee4543a1e068f29cca4ac04a Mon Sep 17 00:00:00 2001 From: sb Date: Mon, 16 Mar 2020 17:08:56 -0400 Subject: [PATCH 14/19] remove references to time flow from comments --- HARK/core.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/HARK/core.py b/HARK/core.py index ef4d4d53c..dcdd8a61e 100644 --- a/HARK/core.py +++ b/HARK/core.py @@ -459,7 +459,7 @@ def makeShockHistory(self): ------- None ''' - # Make sure time is flowing forward and re-initialize the simulation + # Re-initialize the simulation self.initializeSim() # Make blank history arrays for each shock variable @@ -477,7 +477,7 @@ def makeShockHistory(self): self.t_cycle = self.t_cycle + 1 # Age all consumers within their cycle self.t_cycle[self.t_cycle == self.T_cycle] = 0 # Resetting to zero for those who have reached the end - # Restore the flow of time and flag that shocks can be read rather than simulated + # Flag that shocks can be read rather than simulated self.read_shocks = True def getMortality(self): From e4e18d5a05d14e81ac058e28ea75dbc55e583c0e Mon Sep 17 00:00:00 2001 From: sb Date: Tue, 17 Mar 2020 11:23:52 -0400 Subject: [PATCH 15/19] don't bother adding solution to time_vary, fixes #573 --- HARK/core.py | 1 - 1 file changed, 1 deletion(-) diff --git a/HARK/core.py b/HARK/core.py index dcdd8a61e..62f72de8a 100644 --- a/HARK/core.py +++ b/HARK/core.py @@ -312,7 +312,6 @@ def solve(self, verbose=False): with np.errstate(divide='ignore', over='ignore', under='ignore', invalid='ignore'): self.preSolve() # Do pre-solution stuff self.solution = solveAgent(self, verbose) # Solve the model by backward induction - self.addToTimeVary('solution') # Add solution to the list of time-varying attributes self.postSolve() # Do post-solution stuff def resetRNG(self): From 5a9f77e3818a0a296dd5029b4da00d1c1191de59 Mon Sep 17 00:00:00 2001 From: sb Date: Tue, 17 Mar 2020 13:48:06 -0400 Subject: [PATCH 16/19] adding back in init_lifecycle and init_cyclical, lost in merge --- HARK/ConsumptionSaving/ConsIndShockModel.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index 927e6d194..ae65683ad 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -2887,3 +2887,22 @@ def constructAssetsGrid(parameters): aXtraGrid = np.insert(aXtraGrid, j, a) return aXtraGrid + + +# Make a dictionary to specify a lifecycle consumer with a finite horizon +init_lifecycle = copy(init_idiosyncratic_shocks) +init_lifecycle['PermGroFac'] = [1.01,1.01,1.01,1.01,1.01,1.02,1.02,1.02,1.02,1.02] +init_lifecycle['PermShkStd'] = [0.1,0.2,0.1,0.2,0.1,0.2,0.1,0,0,0] +init_lifecycle['TranShkStd'] = [0.3,0.2,0.1,0.3,0.2,0.1,0.3,0,0,0] +init_lifecycle['LivPrb'] = [0.99,0.9,0.8,0.7,0.6,0.5,0.4,0.3,0.2,0.1] +init_lifecycle['T_cycle'] = 10 +init_lifecycle['T_retire'] = 7 +init_lifecycle['T_age'] = 11 # Make sure that old people die at terminal age and don't turn into newborns! + +# Make a dictionary to specify an infinite consumer with a four period cycle +init_cyclical = copy(init_idiosyncratic_shocks) +init_cyclical['PermGroFac'] = [1.082251, 2.8, 0.3, 1.1] +init_cyclical['PermShkStd'] = [0.1,0.1,0.1,0.1] +init_cyclical['TranShkStd'] = [0.1,0.1,0.1,0.1] +init_cyclical['LivPrb'] = 4*[0.98] +init_cyclical['T_cycle'] = 4 From 2b66c1b04fc0215ede628b3639dd82e29246cbce Mon Sep 17 00:00:00 2001 From: sb Date: Wed, 18 Mar 2020 11:55:10 -0400 Subject: [PATCH 17/19] remove time_flow from examples/ --- .../Assets/One/Luetticke_wrapper.py | 1 - .../BayerLuetticke/BayerLuetticke_wrapper.py | 1 - .../ConsIndShockModel_extension.py | 6 +- examples/FashionVictim/FashionVictimModel.py | 2 +- .../GenIncProcessModel.ipynb.orig | 702 ++++++++++++++++++ 5 files changed, 705 insertions(+), 7 deletions(-) create mode 100644 examples/GenIncProcessModel/GenIncProcessModel.ipynb.orig diff --git a/examples/BayerLuetticke/Assets/One/Luetticke_wrapper.py b/examples/BayerLuetticke/Assets/One/Luetticke_wrapper.py index 1f0018912..82f80d638 100644 --- a/examples/BayerLuetticke/Assets/One/Luetticke_wrapper.py +++ b/examples/BayerLuetticke/Assets/One/Luetticke_wrapper.py @@ -41,7 +41,6 @@ def __init__(self,AgentCount,seed=0): self.track_vars = [] self.seed = seed self.resetRNG() - self.time_flow = False self.time_vary = [] self.time_inv = [] self.read_shocks = False diff --git a/examples/BayerLuetticke/BayerLuetticke_wrapper.py b/examples/BayerLuetticke/BayerLuetticke_wrapper.py index 749ad1e50..edbd96175 100644 --- a/examples/BayerLuetticke/BayerLuetticke_wrapper.py +++ b/examples/BayerLuetticke/BayerLuetticke_wrapper.py @@ -42,7 +42,6 @@ def __init__(self,AgentCount,seed=0): self.track_vars = [] self.seed = seed self.resetRNG() - self.time_flow = False self.time_vary = [] self.time_inv = [] self.read_shocks = False diff --git a/examples/BayerLuetticke/ConsIndShockModel_extension.py b/examples/BayerLuetticke/ConsIndShockModel_extension.py index 19503a743..ccf6357fe 100644 --- a/examples/BayerLuetticke/ConsIndShockModel_extension.py +++ b/examples/BayerLuetticke/ConsIndShockModel_extension.py @@ -21,7 +21,7 @@ class IndShockConsumerType_extend(IndShockConsumerType): These methods could eventually become part of IndShockConsumterType itself ''' - def __init__(self,cycles=1,time_flow=True,**kwds): + def __init__(self,cycles=1,**kwds): ''' Just calls on IndShockConsumperType @@ -29,15 +29,13 @@ def __init__(self,cycles=1,time_flow=True,**kwds): ---------- cycles : int Number of times the sequence of periods should be solved. - time_flow : boolean - Whether time is currently "flowing" forward for this instance. Returns ------- None ''' # Initialize an IndShockConsumerType - IndShockConsumerType.__init__(self,cycles=cycles,time_flow=time_flow,**kwds) + IndShockConsumerType.__init__(self,cycles=cycles,**kwds) def DefineDistributionGrid(self, Dist_mGrid=None, Dist_pGrid=None): ''' diff --git a/examples/FashionVictim/FashionVictimModel.py b/examples/FashionVictim/FashionVictimModel.py index 8b921ac80..d8a1794f3 100644 --- a/examples/FashionVictim/FashionVictimModel.py +++ b/examples/FashionVictim/FashionVictimModel.py @@ -137,7 +137,7 @@ def __init__(self,**kwds): new instance of FashionVictimType ''' # Initialize a basic AgentType - AgentType.__init__(self,solution_terminal=FashionVictimType._solution_terminal,cycles=0,time_flow=True,pseudo_terminal=True,**kwds) + AgentType.__init__(self,solution_terminal=FashionVictimType._solution_terminal,cycles=0,pseudo_terminal=True,**kwds) # Add class-specific features self.time_inv = ['DiscFac','conformUtilityFunc','punk_utility','jock_utility','switchcost_J2P','switchcost_P2J','pGrid','pEvolution','pref_shock_mag'] diff --git a/examples/GenIncProcessModel/GenIncProcessModel.ipynb.orig b/examples/GenIncProcessModel/GenIncProcessModel.ipynb.orig new file mode 100644 index 000000000..44a3ff9e0 --- /dev/null +++ b/examples/GenIncProcessModel/GenIncProcessModel.ipynb.orig @@ -0,0 +1,702 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Permanent versus Persistent Income Shocks\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# Initial imports and notebook setup\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import sys\n", + "import os\n", + "from copy import copy\n", + "from HARK.utilities import plotFuncs\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from HARK.ConsumptionSaving.ConsGenIncProcessModel import *\n", + "from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n", + "import HARK.ConsumptionSaving.ConsumerParameters as Params" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`ConsIndShockModel` assumes that income has a permanent component $p$ which is subject to \"permanent\" shocks:\n", + "\n", + " $\\log p_{t+1} = \\log p_{t} + \\log \\psi_{t+1}$\n", + "\n", + "Many papers in the literature instead examine models in which shocks merely have some persistence,\n", + "\n", + "$\\log p_{t+1} = \\gamma \\log p_{t} + \\log \\psi_{t+1}$\n", + "\n", + "where if $0 < \\gamma < 1$ then $\\lim_{n \\uparrow \\infty} \\mathbb{E}_{t}[\\log p_{t+n}]=0$ (which means that the level of $p$ reverts to its mean of $p=1$. The two models become identical as $\\gamma$ approaches 1.\n", + "\n", + "This notebook describes HARK's tools to solve models with persistent shocks.\n", + "\n", + "1. `ConsGenIncProcessModel` extends `ConsIndShockModel` by explicitly tracking persistent income $p_t$ as a state variable.\n", + "1. `IndShockExplicitPermIncConsumerType` is a type of consumer created for comparison and for whom we know for sure that their income process is one in which $\\gamma=1$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## General Income Process model\n", + "In `ConsGenIncProcessModel` the user can define a generic function $G$ that translates current $p_{t}$ into expected next period persistent income $p_{t+1}$ (subject to shocks). \n", + "\n", + "\n", + "The agent's problem can be written in Bellman form as:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\\begin{eqnarray*}\n", + "v_t(M_t,p_t) &=& \\max_{c_t} U(c_t) + \\beta (1-\\mathsf{D}_{t+1}) \\mathbb{E}_{t} [v_{t+1}(M_{t+1}, p_{t+1})] \\\\\n", + "a_t &=& M_t - c_t \\\\\n", + "a_t &\\geq& \\underline{a} \\\\\n", + "M_{t+1} &=& R a_t + \\theta_{t+1} \\\\\n", + "p_{t+1} &=& G_{t+1}(p_t)\\psi_{t+1} \\\\\n", + "\\psi_t \\sim F_{\\psi t} &\\qquad& \\theta_t \\sim F_{\\theta t} \\\\\n", + " \\mathbb{E} [F_{\\psi t}] = 1 & & \\mathbb{E} [F_{\\psi t}] =1 \\\\\n", + "U(c) &=& \\frac{c^{1-\\rho}}{1-\\rho}\n", + "\\end{eqnarray*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The one-period problem for this model is solved by the function $\\texttt{solveConsGenIncProcess}$, which creates an instance of the class $\\texttt{ConsGenIncProcessSolver}$. The class $\\texttt{GenIncProcessConsumerType}$ extends $\\texttt{IndShockConsumerType}$ to represent agents in this model. To construct an instance of this class, several parameters must be passed to the constructor, as shown in the table below (parameters can be either \"primitive\" or \"constructed\" if they have already built-in capabilities from previous models).\n", + "\n", + "### Example parameter values to solve GenIncProcess model\n", + "\n", + "| Parameter | Description | Code | Value | Constructed |\n", + "| :---: | --- | --- | --- | :---: |\n", + "| $\\beta$ |Intertemporal discount factor | $\\texttt{DiscFac}$ | 0.96 | |\n", +<<<<<<< HEAD + "| $\\rho$ |Coefficient of relative risk aversion | $\\texttt{CRRA}$ | 2.0 | |\n", + "| $R$ | Risk free interest factor | $\\texttt{Rfree}$ | 1.03 | |\n", + "| $1 - \\mathsf{D}$ |Survival probability | $\\texttt{LivPrb}$ | [0.98] | |\n", + "| $\\underline{a}$ |Artificial borrowing constraint | $\\texttt{BoroCnstArt}$ | 0.0 | | \n", + "| $(none)$ |Indicator of whether $\\texttt{vFunc}$ should be computed | $\\texttt{vFuncBool}$ | 'True' | |\n", + "| $(none)$ |Indicator of whether $\\texttt{cFunc}$ should use cubic lines | $\\texttt{CubicBool}$ | 'False' | |\n", + "|$F$ |A list containing three arrays of floats, representing a discrete
approximation to the income process:
event probabilities, persistent shocks, transitory shocks | $\\texttt{IncomeDstn}$ | - |$\\surd$ |\n", + "| $G$ |Expected persistent income next period | $\\texttt{pLvlNextFunc}$ | - | $\\surd$ |\n", + "| $(none)$ |Array of time-varying persistent income levels | $\\texttt{pLvlGrid}$ | - |$\\surd$ |\n", + "| $(none)$ | Array of \"extra\" end-of-period asset values | $\\texttt{aXtraGrid}$ | - |$\\surd$ |\n", +======= + "| $\\rho$|Coefficient of relative risk aversion | $\\texttt{CRRA}$ | 2.0 | |\n", + "| $R$| Risk free interest factor | $\\texttt{Rfree}$ | 1.03 | |\n", + "| $1 - \\mathsf{D}$ |Survival probability | $\\texttt{LivPrb}$ | [0.98] | |\n", + "| $\\underline{a}$|Artificial borrowing constraint | $\\texttt{BoroCnstArt}$ | 0.0 | | \n", + "| $(none)~$|Indicator of whether $\\texttt{vFunc}$ should be computed | $\\texttt{vFuncBool}$ | 'True' | |\n", + "| $(none)$ |Indicator of whether $\\texttt{cFunc}$ should use cubic lines | $\\texttt{CubicBool}$ | 'False' | |\n", + "|$F$|A list containing three arrays of floats, representing a discrete
approximation to the income process:
event probabilities, persistent shocks, transitory shocks | $\\texttt{IncomeDstn}$ | - |$\\surd$ |\n", + "| $G$ |Expected persistent income next period | $\\texttt{pLvlNextFunc}$ | - | $\\surd$ |\n", + "|$(none)$|Array of time-varying persistent income levels | $\\texttt{pLvlGrid}$ | - |$\\surd$ |\n", + "|$(none)$| Array of \"extra\" end-of-period asset values | $\\texttt{aXtraGrid}$ | - |$\\surd$ |\n", +>>>>>>> master + "\n", + "### Constructed inputs to solve GenIncProcess\n", + "The \"constructed\" inputs above are using expected attributes and are drawn on various methods as explained below.\n", + "\n", + "\n", + "* The input $\\texttt{IncomeDstn}$ is created by the method $\\texttt{updateIncomeProcess}$ which inherits from $\\texttt{IndShockConsumerType}$. (*hyperlink to that noteboook*)\n", + "\n", + "* The input $\\texttt{pLvlNextFunc}$ is created by the method $\\texttt{updatepLvlNextFunc}$ which uses the initial sequence of $\\texttt{pLvlNextFunc}$, the mean and standard deviation of the (log) initial permanent income, $\\texttt{pLvlInitMean}$ and $\\texttt{pLvlInitStd}$. \n", + "In this model, the method creates a trivial $\\texttt{pLvlNextFunc}$ attribute with no persistent income dynamics. But we can overwrite it by subclasses in order to make an AR1 income process for example. \n", + "\n", + "\n", + "* The input $\\texttt{pLvlGrid}$ is created by the method $\\texttt{updatepLvlGrid}$ which updates the grid of persistent income levels for infinite horizon models (cycles=0) and lifecycle models (cycles=1). This method draws on the initial distribution of persistent income, the $\\texttt{pLvlNextFuncs}$, $\\texttt{pLvlInitMean}$, $\\texttt{pLvlInitStd}$ and the attribute $\\texttt{pLvlPctiles}$ (percentiles of the distribution of persistent income). It then uses a simulation approach to generate the $\\texttt{pLvlGrid}$ at each period of the cycle.\n", + "\n", + "\n", + "* The input $\\texttt{aXtraGrid}$ is created by $\\texttt{updateAssetsGrid}$ which updates the agent's end-of-period assets grid by constructing a multi-exponentially spaced grid of aXtra values, based on $\\texttt{aNrmInitMean}$ and $\\texttt{aNrmInitStd}$. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Consumer with Explicit Permanent Income\n", + "\n", + "Let's make an example of our generic model above with an \"explicit permanent income\" consumer who experiences idiosyncratic shocks to permanent and transitory, and faces permanent income growth.\n", + "\n", + "The agent's problem can be written in Bellman form as:\n", + "\n", + "\\begin{eqnarray*}\n", + "v_t(M_t,p_t) &=& \\max_{c_t} U(c_t) + \\beta (1-\\mathsf{D}_{t+1}) \\mathbb{E} [v_{t+1}(M_{t+1}, p_{t+1}) ], \\\\\n", + "a_t &=& M_t - c_t, \\\\\n", + "a_t &\\geq& \\underline{a}, \\\\\n", + "M_{t+1} &=& R/(\\Gamma_{t+1} \\psi_{t+1}) a_t + \\theta_{t+1}, \\\\\n", + "p_{t+1} &=& G_{t+1}(p_t)\\psi_{t+1}, \\\\\n", + "\\psi \\sim F_{\\psi}, \\mathbb{E} [F_{\\psi t}] = 1 &\\qquad& \\theta_t \\sim F_{\\theta}, \\mathbb{E} [F_{\\psi}] = 1, \\\\\n", + "U(c) &=& \\frac{c^{1-\\rho}}{1-\\rho}.\n", + "\\end{eqnarray*}\n", + "\n", + "\n", + "This agent type is identical to an $\\texttt{IndShockConsumerType}$ but for explicitly tracking $\\texttt{pLvl}$ as a state variable during solution as shown in the mathematical representation of GenIncProcess model. \n", + "\n", + "To construct $\\texttt{IndShockExplicitPermIncConsumerType}$ as an instance of $\\texttt{GenIncProcessConsumerType}$, we need to pass additional parameters to the constructor as shown in the table below.\n", + "\n", + "### Additional parameters to solve ExplicitPermInc model\n", + "\n", + "| Param | Description | Code | Value | Constructed |\n", + "| :---: | --- | --- | --- | :---: |\n", + "|(none)|percentiles of the distribution of persistent income|$\\texttt{pLvlPctiles}$|||\n", + "| $G$ |Expected persistent income next period | $\\texttt{pLvlNextFunc}$ | - | $\\surd$ |\n", + "|$\\Gamma$|Permanent income growth factor|$\\texttt{PermGroFac}$|[1.0]| |\n", + "\n", + "\n", + "### Constructed inputs to solve ExplicitPermInc\n", + "\n", + "* In this \"explicit permanent income\" model, we overwrite the method $\\texttt{updatepLvlNextFunc}$ to create $\\texttt{pLvlNextFunc}$ as a sequence of linear functions, indicating constant expected permanent income growth across permanent income levels. This method uses the attribute $\\texttt{PermGroFac}$, and installs a special retirement function when it exists.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# This cell defines a dictionary to make an instance of \"explicit permanent income\" consumer.\n", + "GenIncDictionary = { \n", + " \"CRRA\": 2.0, # Coefficient of relative risk aversion\n", + " \"Rfree\": 1.03, # Interest factor on assets\n", + " \"DiscFac\": 0.96, # Intertemporal discount factor\n", + " \"LivPrb\" : [0.98], # Survival probability\n", + " \"AgentCount\" : 10000, # Number of agents of this type (only matters for simulation)\n", + " \"aNrmInitMean\" : 0.0, # Mean of log initial assets (only matters for simulation)\n", + " \"aNrmInitStd\" : 1.0, # Standard deviation of log initial assets (only for simulation)\n", + " \"pLvlInitMean\" : 0.0, # Mean of log initial permanent income (only matters for simulation)\n", + " \"pLvlInitStd\" : 0.0, # Standard deviation of log initial permanent income (only matters for simulation)\n", + " \"PermGroFacAgg\" : 1.0, # Aggregate permanent income growth factor (only matters for simulation)\n", + " \"T_age\" : None, # Age after which simulated agents are automatically killed\n", + " \"T_cycle\" : 1, # Number of periods in the cycle for this agent type\n", + "# Parameters for constructing the \"assets above minimum\" grid\n", + " \"aXtraMin\" : 0.001, # Minimum end-of-period \"assets above minimum\" value\n", + " \"aXtraMax\" : 30, # Maximum end-of-period \"assets above minimum\" value \n", + " \"aXtraExtra\" : [0.005,0.01], # Some other value of \"assets above minimum\" to add to the grid\n", + " \"aXtraNestFac\" : 3, # Exponential nesting factor when constructing \"assets above minimum\" grid\n", + " \"aXtraCount\" : 48, # Number of points in the grid of \"assets above minimum\"\n", + "# Parameters describing the income process\n", + " \"PermShkCount\" : 7, # Number of points in discrete approximation to permanent income shocks\n", + " \"TranShkCount\" : 7, # Number of points in discrete approximation to transitory income shocks\n", + " \"PermShkStd\" : [0.1], # Standard deviation of log permanent income shocks\n", + " \"TranShkStd\" : [0.1], # Standard deviation of log transitory income shocks\n", + " \"UnempPrb\" : 0.05, # Probability of unemployment while working\n", + " \"UnempPrbRet\" : 0.005, # Probability of \"unemployment\" while retired\n", + " \"IncUnemp\" : 0.3, # Unemployment benefits replacement rate\n", + " \"IncUnempRet\" : 0.0, # \"Unemployment\" benefits when retired\n", + " \"tax_rate\" : 0.0, # Flat income tax rate\n", + " \"T_retire\" : 0, # Period of retirement (0 --> no retirement)\n", + " \"BoroCnstArt\" : 0.0, # Artificial borrowing constraint; imposed minimum level of end-of period assets\n", + " \"CubicBool\" : False, # Use cubic spline interpolation when True, linear interpolation when False\n", + " \"vFuncBool\" : True, # Whether to calculate the value function during solution \n", + "# More parameters specific to \"Explicit Permanent income\" shock model\n", + " \"cycles\": 0,\n", + " \"pLvlPctiles\" : np.concatenate(([0.001, 0.005, 0.01, 0.03], np.linspace(0.05, 0.95, num=19),[0.97, 0.99, 0.995, 0.999])),\n", + " \"PermGroFac\" : [1.0], # Permanent income growth factor - long run permanent income growth doesn't work yet \n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's now create an instance of the type of consumer we are interested in and solve this agent's problem with an infinite horizon (cycles=0)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Here, the lowest percentile is 0.1\n", + "and the highest percentile is 99.9.\n", + "\n" + ] + } + ], + "source": [ + "# Make and solve an example \"explicit permanent income\" consumer with idiosyncratic shocks\n", + "ExplicitExample = IndShockExplicitPermIncConsumerType(**GenIncDictionary)\n", + " \n", + "print('Here, the lowest percentile is ' + str(GenIncDictionary['pLvlPctiles'][0]*100))\n", + "print('and the highest percentile is ' + str(GenIncDictionary['pLvlPctiles'][-1]*100) + '.\\n')\n", + " \n", + "ExplicitExample.solve()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the cell below, we generate a plot of the consumption function for explicit permanent income consumer at different income levels." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "code_folding": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption function by pLvl for explicit permanent income consumer:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption function at various permanent income levels.\n", + "print('Consumption function by pLvl for explicit permanent income consumer:')\n", + "pLvlGrid = ExplicitExample.pLvlGrid[0]\n", + "mLvlGrid = np.linspace(0,20,300)\n", + "for p in pLvlGrid:\n", + " M_temp = mLvlGrid + ExplicitExample.solution[0].mLvlMin(p)\n", + " C = ExplicitExample.solution[0].cFunc(M_temp,p*np.ones_like(M_temp))\n", + " plt.plot(M_temp,C)\n", + "plt.xlim(0.,20.)\n", + "plt.xlabel('Market resource level mLvl')\n", + "plt.ylabel('Consumption level cLvl')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Permanent income normalized\n", + "\n", + "An alternative model is to normalize it by dividing all variables by permanent income $p_t$ and solve the model again." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "The given parameter values violate the Individual Growth Impatience Condition; the GIFInd is: 1.0037 \n", + "\n" + ] + } + ], + "source": [ + "# Make and solve an example of normalized model\n", + "NormalizedExample = IndShockConsumerType(**GenIncDictionary)\n", + "NormalizedExample.solve()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Normalized consumption function by pLvl for explicit permanent income consumer:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption function for normalized problem (without explicit permanent income):\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Compare the normalized problem with and without explicit permanent income and plot the consumption functions\n", + "print('Normalized consumption function by pLvl for explicit permanent income consumer:')\n", + "pLvlGrid = ExplicitExample.pLvlGrid[0]\n", + "mNrmGrid = np.linspace(0,20,300)\n", + "for p in pLvlGrid:\n", + " M_temp = mNrmGrid*p + ExplicitExample.solution[0].mLvlMin(p)\n", + " C = ExplicitExample.solution[0].cFunc(M_temp,p*np.ones_like(M_temp))\n", + " plt.plot(M_temp/p,C/p)\n", + "\n", + "plt.xlim(0.,20.)\n", + "plt.xlabel('Normalized market resources mNrm')\n", + "plt.ylabel('Normalized consumption cNrm')\n", + "plt.show()\n", + "\n", + "print('Consumption function for normalized problem (without explicit permanent income):')\n", + "mNrmMin = NormalizedExample.solution[0].mNrmMin\n", + "plotFuncs(NormalizedExample.solution[0].cFunc,mNrmMin,mNrmMin+20.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The figures above show that the normalized consumption function for the \"explicit permanent income\" consumer is almost identical for every permanent income level (and the same as the normalized problem's $\\texttt{cFunc}$), but is less accurate due to extrapolation outside the bounds of $\\texttt{pLvlGrid}$. \n", + "\n", + "The \"explicit permanent income\" solution deviates from the solution to the normalized problem because of errors from extrapolating beyond the bounds of the $\\texttt{pLvlGrid}$. The error is largest for $\\texttt{pLvl}$ values near the upper and lower bounds, and propagates toward the center of the distribution.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the value function at various permanent income levels\n", + "if ExplicitExample.vFuncBool:\n", + " pGrid = np.linspace(0.1,3.0,24)\n", + " M = np.linspace(0.001,5,300)\n", + " for p in pGrid:\n", + " M_temp = M+ExplicitExample.solution[0].mLvlMin(p)\n", + " C = ExplicitExample.solution[0].vFunc(M_temp,p*np.ones_like(M_temp))\n", + " plt.plot(M_temp,C)\n", + " plt.ylim([-200,0])\n", + " plt.xlabel('Market resource level mLvl')\n", + " plt.ylabel('Value v')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Simulate many periods to get to the stationary distribution\n", + "ExplicitExample.T_sim = 500\n", + "ExplicitExample.track_vars = ['mLvlNow','cLvlNow','pLvlNow']\n", + "ExplicitExample.initializeSim()\n", + "ExplicitExample.simulate()\n", + "plt.plot(np.mean(ExplicitExample.mLvlNow_hist,axis=1))\n", + "plt.xlabel('Simulated time period')\n", + "plt.ylabel('Average market resources mLvl')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Persistent income shock consumer\n", + "\n", + "\n", + "Class to solve consumption-saving models with idiosyncratic shocks to income in which shocks are persistent and transitory. This model extends $\\texttt{ConsGenIndShockModel}$ by allowing (log) persistent income to follow an AR(1) process.\n", + "\n", + "The agent's problem can be written in Bellman form as:\n", + "\n", + "\\begin{eqnarray*}\n", + "v_t(M_t,p_t) &=& \\max_{c_t} U(c_t) + \\beta (1-\\mathsf{D}_{t+1}) \\mathbb{E} [v_{t+1}(M_{t+1}, p_{t+1}) ], \\\\\n", + "a_t &=& M_t - c_t, \\\\\n", + "a_t &\\geq& \\underline{a}, \\\\\n", + "M_{t+1} &=& R a_t + \\theta_{t+1}, \\\\\n", + "log(p_{t+1}) &=& \\varphi log(p_t)+(1-\\varphi log(\\overline{p}_{t+1} ) +log(\\Gamma_{t+1})+log(\\psi_{t+1}), \\\\\n", + "\\\\\n", + "\\psi_t \\sim F_{\\psi t} &\\qquad& \\theta_t \\sim F_{\\theta t}, \\mathbb{E} [F_{\\psi t}] = 1 \\\\\n", + "\\end{eqnarray*}\n", + "\n", + "### Additional parameters to solve PersistentShock model\n", + "\n", + "| Param | Description | Code | Value | Constructed |\n", + "| :---: | --- | --- | --- | :---: |\n", + "|$\\varphi$|Serial correlation coefficient for permanent income|$\\texttt{PrstIncCorr}$|0.98||\n", + "||||||\n", + "\n", + "### Constructed inputs to solve PersistentShock\n", + "\n", + "* For this model, we overwrite the method $\\texttt{updatepLvlNextFunc}$ to create the input $\\texttt{pLvlNextFunc}$ as a sequence of AR1-style functions. The method uses now the attributes $\\texttt{PermGroFac}$ and $\\texttt{PrstIncCorr}$. If cycles=0, the product of $\\texttt{PermGroFac}$ across all periods must be 1.0, otherwise this method is invalid.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "# Make a dictionary for the \"persistent idiosyncratic shocks\" model\n", + "PrstIncCorr = 0.98 # Serial correlation coefficient for persistent income\n", + "\n", + "persistent_shocks = copy(GenIncDictionary)\n", + "persistent_shocks['PrstIncCorr'] = PrstIncCorr\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The $\\texttt{PersistentShockConsumerType}$ class solves the problem of a consumer facing idiosyncratic shocks to his persistent and transitory income, and for which the (log) persistent income follows an AR1 process rather than random walk." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Make and solve an example of \"persistent idisyncratic shocks\" consumer\n", + "PersistentExample = PersistentShockConsumerType(**persistent_shocks)\n", + "PersistentExample.solve()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption function by persistent income level pLvl for a consumer with AR1 coefficient of 0.98:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption function at various levels of persistent income pLvl\n", + "print('Consumption function by persistent income level pLvl for a consumer with AR1 coefficient of ' + str(PersistentExample.PrstIncCorr) + ':')\n", + "pLvlGrid = PersistentExample.pLvlGrid[0]\n", + "mLvlGrid = np.linspace(0,20,300)\n", + "for p in pLvlGrid:\n", + " M_temp = mLvlGrid + PersistentExample.solution[0].mLvlMin(p)\n", + " C = PersistentExample.solution[0].cFunc(M_temp,p*np.ones_like(M_temp))\n", + " plt.plot(M_temp,C)\n", + "plt.xlim(0.,20.)\n", + "plt.xlabel('Market resource level mLvl')\n", + "plt.ylabel('Consumption level cLvl')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the value function at various persistent income levels\n", + "if PersistentExample.vFuncBool:\n", + " pGrid = PersistentExample.pLvlGrid[0]\n", + " M = np.linspace(0.001,5,300)\n", + " for p in pGrid:\n", + " M_temp = M+PersistentExample.solution[0].mLvlMin(p)\n", + " C = PersistentExample.solution[0].vFunc(M_temp,p*np.ones_like(M_temp))\n", + " plt.plot(M_temp,C)\n", + " plt.ylim([-200,0])\n", + " plt.xlabel('Market resource level mLvl')\n", + " plt.ylabel('Value v')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Simulate some data\n", + "PersistentExample.T_sim = 500\n", + "PersistentExample.track_vars = ['mLvlNow','cLvlNow','pLvlNow']\n", + "PersistentExample.initializeSim()\n", + "PersistentExample.simulate()\n", + "plt.plot(np.mean(PersistentExample.mLvlNow_hist,axis=1))\n", + "plt.xlabel('Simulated time period')\n", + "plt.ylabel('Average market resources mLvl')\n", + "plt.show()" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "collapsed", + "formats": "ipynb,py", + "notebook_metadata_filter": "all" + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 3cdfe79cd9c6b7970019691c7d7903dcffcec487 Mon Sep 17 00:00:00 2001 From: sb Date: Wed, 25 Mar 2020 11:06:12 -0400 Subject: [PATCH 18/19] fixing syntax error from merge --- HARK/ConsumptionSaving/ConsPortfolioModel.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsPortfolioModel.py b/HARK/ConsumptionSaving/ConsPortfolioModel.py index 192d8ead5..59ddc338a 100644 --- a/HARK/ConsumptionSaving/ConsPortfolioModel.py +++ b/HARK/ConsumptionSaving/ConsPortfolioModel.py @@ -315,7 +315,7 @@ def updateShareLimit(self): None ''' if 'RiskyDstn' in self.time_vary: - self.ShareLimit = [] + self.ShareLimit = [] for t in range(self.T_cycle): RiskyDstn = self.RiskyDstn[t] temp_f = lambda s : -((1.-self.CRRA)**-1)*np.dot((self.Rfree + s*(RiskyDstn[1]-self.Rfree))**(1.-self.CRRA), RiskyDstn[0]) @@ -926,4 +926,4 @@ def solveConsPortfolio(solution_next,ShockDstn,IncomeDstn,RiskyDstn, init_portfolio['BoroCnstArt'] = 0.0 # Artificial borrowing constraint must be turned on init_portfolio['CRRA'] = 5.0 # Results are more interesting with higher risk aversion init_portfolio['DiscFac'] = 0.90 # And also lower patience - \ No newline at end of file + From bd9f6529cb3d2acef7a216159246740cc56de683 Mon Sep 17 00:00:00 2001 From: sb Date: Wed, 8 Apr 2020 10:53:46 -0400 Subject: [PATCH 19/19] repair ConsRepAgentModel --- HARK/ConsumptionSaving/ConsRepAgentModel.py | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/HARK/ConsumptionSaving/ConsRepAgentModel.py b/HARK/ConsumptionSaving/ConsRepAgentModel.py index ec0b3d116..821cc3fe6 100644 --- a/HARK/ConsumptionSaving/ConsRepAgentModel.py +++ b/HARK/ConsumptionSaving/ConsRepAgentModel.py @@ -260,7 +260,10 @@ def __init__(self,**kwds): ------- None ''' - RepAgentConsumerType.__init__(self,**kwds) + params = init_markov_rep_agent.copy() + params.update(kwds) + + RepAgentConsumerType.__init__(self,**params) self.solveOnePeriod = solveConsRepAgentMarkov def preSolve(self): @@ -332,3 +335,16 @@ def getControls(self): t = self.t_cycle[0] i = self.MrkvNow[0] self.cNrmNow = self.solution[t].cFunc[i](self.mNrmNow) + +# Define the default dictionary for a representative agent type +init_rep_agent = init_idiosyncratic_shocks.copy() +init_rep_agent["DeprFac"] = 0.05 +init_rep_agent["CapShare"] = 0.36 +init_rep_agent["UnempPrb"] = 0.0 +init_rep_agent["LivPrb"] = [1.0] + +# Define the default dictionary for a markov representative agent type +init_markov_rep_agent = init_rep_agent.copy() +init_markov_rep_agent["PermGroFac"] = [[0.97, 1.03]] +init_markov_rep_agent["MrkvArray"] = np.array([[0.99, 0.01], [0.01, 0.99]]) +init_markov_rep_agent["MrkvNow"] = 0