for j in range(PrefShockExample.PrefShkDstn[0][1].size): PrefShk = PrefShockExample.PrefShkDstn[0][1][j] c = PrefShockExample.solution[0].cFunc(m, PrefShk * np.ones_like(m)) plt.plot(m, c) plt.show() print('Consumption function (and MPC) when shock=1:') c = PrefShockExample.solution[0].cFunc(m, np.ones_like(m)) k = PrefShockExample.solution[0].cFunc.derivativeX(m, np.ones_like(m)) plt.plot(m, c) plt.plot(m, k) plt.show() if PrefShockExample.vFuncBool: print('Value function (unconditional on shock):') plotFuncs(PrefShockExample.solution[0].vFunc, PrefShockExample.solution[0].mNrmMin + 0.5, 5) # Test the simulator for the pref shock class if do_simulation: PrefShockExample.T_sim = 120 PrefShockExample.track_vars = ['cNrmNow'] PrefShockExample.makeShockHistory() # This is optional PrefShockExample.initializeSim() PrefShockExample.simulate() ########################################################################### # Make and solve a "kinky preferece" consumer, whose model combines KinkedR and PrefShock KinkyPrefExample = KinkyPrefConsumerType(**Params.init_kinky_pref) KinkyPrefExample.cycles = 0 # Infinite horizon
ratio_min = 1. # minimum number to multiply income parameter by targetChangeInC = -6.32 # Source: FRED num_points = 10 #number of parameter values to plot in graphs ## First change the variance of the permanent income shock perm_ratio_max = ??? # Put whatever value in you want! maximum number to multiply std of perm income shock by perm_min = BaselineType.PermShkStd[0] * ratio_min perm_max = BaselineType.PermShkStd[0] * perm_ratio_max plt.ylabel('% Change in Consumption') plt.xlabel('Std. Dev. of Perm. Income Shock (Baseline = ' + str(round(BaselineType.PermShkStd[0],2)) + ')') plt.title('Change in Cons. Following Increase in Perm. Income Uncertainty') plt.ylim(-20.,5.) plt.hlines(targetChangeInC,perm_min,perm_max) plotFuncs([cChangeAfterPrmShkChange],perm_min,perm_max,N=num_points) ### Now change the variance of the temporary income shock #temp_ratio_max = ??? # Put whatever value in you want! maximum number to multiply std dev of temp income shock by # # #temp_min = BaselineType.TranShkStd[0] * ratio_min #temp_max = BaselineType.TranShkStd[0] * temp_ratio_max # #plt.ylabel('% Change in Consumption') #plt.xlabel('Std. Dev. of Temp. Income Shock (Baseline = ' + str(round(BaselineType.TranShkStd[0],2)) + ')') #plt.title('Change in Cons. Following Increase in Temp. Income Uncertainty') #plt.ylim(-20.,5.) #plt.hlines(targetChangeInC,temp_min,temp_max) #plotFuncs([cChangeAfterTranShkChange],temp_min,temp_max,N=num_points)
for j in range(PrefShockExample.PrefShkDstn[0][1].size): PrefShk = PrefShockExample.PrefShkDstn[0][1][j] c = PrefShockExample.solution[0].cFunc(m,PrefShk*np.ones_like(m)) plt.plot(m,c) plt.show() print('Consumption function (and MPC) when shock=1:') c = PrefShockExample.solution[0].cFunc(m,np.ones_like(m)) k = PrefShockExample.solution[0].cFunc.derivativeX(m,np.ones_like(m)) plt.plot(m,c) plt.plot(m,k) plt.show() if PrefShockExample.vFuncBool: print('Value function (unconditional on shock):') plotFuncs(PrefShockExample.solution[0].vFunc,PrefShockExample.solution[0].mNrmMin+0.5,5) # Test the simulator for the pref shock class if do_simulation: PrefShockExample.sim_periods = 120 PrefShockExample.makeIncShkHist() PrefShockExample.makePrefShkHist() PrefShockExample.initializeSim() PrefShockExample.simConsHistory() ########################################################################### # Make and solve a "kinky preferece" consumer, whose model combines KinkedR and PrefShock KinkyPrefExample = KinkyPrefConsumerType(**Params.init_kinky_pref) KinkyPrefExample.cycles = 0 # Infinite horizon
start_time = clock() LifecycleExample.solve() end_time = clock() print('Solving a lifecycle consumer took ' + mystr(end_time - start_time) + ' seconds.') LifecycleExample.unpackcFunc() LifecycleExample.timeFwd() # Plot the consumption functions during working life print('Consumption functions while working:') mMin = min([ LifecycleExample.solution[t].mNrmMin for t in range(LifecycleExample.T_cycle) ]) plotFuncs(LifecycleExample.cFunc[:LifecycleExample.T_retire], mMin, 5) # Plot the consumption functions during retirement print('Consumption functions while retired:') plotFuncs(LifecycleExample.cFunc[LifecycleExample.T_retire:], 0, 5) LifecycleExample.timeRev() ############################################################################### # Make and solve a "cyclical" consumer type who lives the same four quarters repeatedly. # The consumer has income that greatly fluctuates throughout the year. CyclicalExample = IndShockConsumerType(**Params.init_cyclical) CyclicalExample.cycles = 0 start_time = clock() CyclicalExample.solve()
# Have the consumers inherit relevant objects from the economy AggShockExample.getEconomyData(EconomyExample) # Solve the microeconomic model for the aggregate shocks example type (and display results) t_start = clock() AggShockExample.solve() t_end = clock() print('Solving an aggregate shocks consumer took ' + mystr(t_end-t_start) + ' seconds.') print('Consumption function at each capital-to-labor ratio gridpoint:') m_grid = np.linspace(0,10,200) AggShockExample.unpackcFunc() for k in AggShockExample.kGrid.tolist(): c_at_this_k = AggShockExample.cFunc[0](m_grid,k*np.ones_like(m_grid)) plt.plot(m_grid,c_at_this_k) plt.show() # Solve the "macroeconomic" model by searching for a "fixed point dynamic rule" t_start = clock() EconomyExample.solve() t_end = clock() print('Solving the "macroeconomic" aggregate shocks model took ' + str(t_end - t_start) + ' seconds.') print('Next capital-to-labor ratio as function of current ratio:') plotFuncs(EconomyExample.kNextFunc,0,2*EconomyExample.kSS) print('Consumption function at each capital-to-labor ratio gridpoint (in general equilibrium):') AggShockExample.unpackcFunc() m_grid = np.linspace(0,10,200) for k in AggShockExample.kGrid.tolist(): c_at_this_k = AggShockExample.cFunc[0](m_grid,k*np.ones_like(m_grid)) plt.plot(m_grid,c_at_this_k) plt.show()
t_end = clock() print('Solving an aggregate shocks consumer took ' + mystr(t_end - t_start) + ' seconds.') print('Consumption function at each capital-to-labor ratio gridpoint:') m_grid = np.linspace(0, 10, 200) AggShockExample.unpackcFunc() for k in AggShockExample.kGrid.tolist(): c_at_this_k = AggShockExample.cFunc[0](m_grid, k * np.ones_like(m_grid)) plt.plot(m_grid, c_at_this_k) plt.show() # Solve the "macroeconomic" model by searching for a "fixed point dynamic rule" t_start = clock() EconomyExample.solve() t_end = clock() print('Solving the "macroeconomic" aggregate shocks model took ' + str(t_end - t_start) + ' seconds.') print('Next capital-to-labor ratio as function of current ratio:') plotFuncs(EconomyExample.kNextFunc, 0, 2 * EconomyExample.kSS) print( 'Consumption function at each capital-to-labor ratio gridpoint (in general equilibrium):' ) AggShockExample.unpackcFunc() m_grid = np.linspace(0, 10, 200) for k in AggShockExample.kGrid.tolist(): c_at_this_k = AggShockExample.cFunc[0](m_grid, k * np.ones_like(m_grid)) plt.plot(m_grid, c_at_this_k) plt.show()
## Now, plot the functions we want # Import a useful plotting function from HARKutilities from HARKutilities import plotFuncs import pylab as plt # We need this module to change the y-axis on the graphs # Declare the upper limit for the graph x_max = 10. # Note that plotFuncs takes four arguments: (1) a list of the arguments to plot, # (2) the lower bound for the plots, (3) the upper bound for the plots, and (4) keywords to pass # to the legend for the plot. # Plot the consumption functions to compare them print('Consumption functions:') plotFuncs([BaselineExample.solution[0].cFunc,XtraCreditExample.solution[0].cFunc], BaselineExample.solution[0].mNrmMin,x_max, legend_kwds = {'loc': 'upper left', 'labels': ["Baseline","XtraCredit"]}) # Plot the MPCs to compare them print('MPC out of Credit v MPC out of Income') plt.ylim([0.,1.2]) plotFuncs([FirstDiffMPC_Credit,FirstDiffMPC_Income], BaselineExample.solution[0].mNrmMin,x_max, legend_kwds = {'labels': ["MPC out of Credit","MPC out of Income"]})
StickySOEconomy.makeAggShkHist() for n in range(Params.TypeCount): StickySOEconsumers[n].getEconomyData(StickySOEconomy) # Solve the small open economy and display some output t_start = clock() StickySOEconomy.solveAgents() t_end = clock() print('Solving the small open economy took ' + str(t_end - t_start) + ' seconds.') print( 'Consumption function for one type in the small open economy:') cFunc = lambda m: StickySOEconsumers[0].solution[0].cFunc( m, np.ones_like(m)) plotFuncs(cFunc, 0.0, 20.0) # Simulate the frictionless small open economy t_start = clock() for agent in StickySOEconomy.agents: agent(UpdatePrb=1.0) StickySOEconomy.makeHistory() t_end = clock() print('Simulating the frictionless small open economy took ' + mystr(t_end - t_start) + ' seconds.') # Make results for the frictionless representative agent economy desc = 'Results for the frictionless small open economy (update probability 1.0)' name = 'SOEsimpleFrictionless' makeStickyEdataFile(StickySOEconomy, ignore_periods,
sys.path.insert(0,'../') from HARKutilities import plotFunc, plotFuncs import DiscreteChoice as Model import numpy as np x_grid = np.linspace(0,10,200) sigma = 0.2 vFuncA = lambda x : x**0.5 vFuncB = lambda x : (2.0*(x-1.0))**0.5 vFuncC = lambda x : (3.0*(x-2.0))**0.5 vPfuncA = lambda x : 0.5*x**(-0.5) vPfuncB = lambda x : (2.0*(x-1.0))**(-0.5) vPfuncC = lambda x : 1.5*(3.0*(x-2.0))**(-0.5) vFunc = [vFuncA, vFuncB, vFuncC] vPfunc = [vPfuncA, vPfuncB, vPfuncC] transFunc = lambda Z : Z transFuncP = lambda Z : np.ones(Z.shape) #transFunc = lambda x : x**2 #transFuncP = lambda x : 2*x solution_tp1 = Model.DiscreteChoiceSolution(vFunc,vPfunc) solution_tp1.bonus = 'break on through' solution_t = Model.discreteChoiceContinuousStateSolver(solution_tp1,x_grid,sigma,transFunc,transFuncP) plotFuncs([solution_t.vFunc,vFuncA,vFuncB,vFuncC],0,10) plotFuncs([solution_t.vPfunc,vPfuncA,vPfuncB,vPfuncC],0,10)
a_max = 20, a_size = 48, calc_vFunc = True, cubic_splines = False, constrained = True, income_distrib = [None,TestType.income_distrib], p_zero_income = [None,TestType.p_zero_income], solveAPeriod = [discreteChoiceContinuousStateSolver, occupationalChoiceSolver], tolerance = 0.0001, cycles = 0) TestType.updateAssetsGrid() TestType.updateSolutionTerminal() transformations = makeCRRAtransformations(TestType.rho,do_Q=True,do_T=True,do_Z=True) TestType(transformations = transformations) #TestType(transformations = None) TestType.time_inv += ['transformations','state_grid'] TestType.time_vary += ['sigma_epsilon','solveAPeriod'] # Solve the income insurance problem t_start = clock() TestType.solve() t_end = clock() print('Took ' + str(t_end-t_start) + ' seconds to solve occupational choice problem.') plotFuncs(TestType.solution[1].vFunc,0.1,3) Q = transformations.Qfunc f = lambda x : Q(TestType.solution[1].vFunc[2](x)) - Q(TestType.solution[1].vFunc[0](x)) g = lambda x : Q(TestType.solution[1].vFunc[1](x)) - Q(TestType.solution[1].vFunc[0](x)) plotFuncs([f, g],0.1,50)
# single-threading (looping), due to overhead. BasicType = Model.IndShockConsumerType(**Params.init_idiosyncratic_shocks) BasicType.cycles = 0 BasicType(aXtraMax = 100, aXtraCount = 64) BasicType(vFuncBool = False, CubicBool = True) BasicType.updateAssetsGrid() BasicType.timeFwd() # Solve the basic type and plot the results, to make sure things are working start_time = clock() BasicType.solve() end_time = clock() print('Solving the basic consumer took ' + mystr(end_time-start_time) + ' seconds.') BasicType.unpackcFunc() print('Consumption function:') plotFuncs(BasicType.cFunc[0],0,5) # plot consumption print('Marginal consumption function:') plotFuncsDer(BasicType.cFunc[0],0,5) # plot MPC if BasicType.vFuncBool: print('Value function:') plotFuncs(BasicType.solution[0].vFunc,0.2,5) # Make many copies of the basic type, each with a different risk aversion BasicType.vFuncBool = False # just in case it was set to True above my_agent_list = [] CRRA_list = np.linspace(1,8,type_count) # All the values that CRRA will take on for i in range(type_count): this_agent = deepcopy(BasicType) # Make a new copy of the basic type this_agent.assignParameters(CRRA = CRRA_list[i]) # Give it a unique CRRA value my_agent_list.append(this_agent) # Addd it to the list of agent types
Params.init_consumer_objects['beta'] = 0.96 TestType = RetiringConsumerType(**Params.init_consumer_objects) TestType(survival_prob = 0.9, beta = 0.96, Gamma = 1.00, rho = 2.0, sigma_epsilon = [0.0001,None], state_grid = setupGridsExpMult(0.001, 50, 64, 3), a_max = 20, a_size = 48, calc_vFunc = True, cubic_splines = False, constrained = True, income_distrib = [None,TestType.income_distrib], p_zero_income = [None,TestType.p_zero_income], labor_supply = 0.5, alpha = 1.0, tolerance = 0.0001, cycles=0) TestType.updateAssetsGrid() transformations = makeCRRAtransformations(TestType.rho,do_Q=True,do_T=True,do_Z=True) TestType(transformations = transformations) t_start = time() TestType.solve() t_end = time() print('Took ' + str(t_end-t_start) + ' seconds to solve retirement choice problem.') plotFuncs(TestType.solution[1].vFunc,20,100) plotFunc(TestType.solution[0].vFunc,20,100)
import scipy.stats as stats import FashionVictimParams as Params from copy import copy from time import clock from HARKcore import Market mystr = lambda number: "{:.4f}".format(number) import matplotlib.pyplot as plt from copy import deepcopy do_many_types = True # Make a test case and solve the micro model TestType = FashionVictimType(**Params.default_params) print('Utility function:') plotFuncs(TestType.conformUtilityFunc, 0, 1) t_start = clock() TestType.solve() t_end = clock() print('Solving a fashion victim micro model took ' + mystr(t_end - t_start) + ' seconds.') ''' print('Jock value function:') plotFuncs(TestType.VfuncJock,0,1) print('Punk value function:') plotFuncs(TestType.VfuncPunk,0,1) print('Jock switch probability:') plotFuncs(TestType.switchFuncJock,0,1) print('Punk switch probability:') plotFuncs(TestType.switchFuncPunk,0,1)
for i in range(type_count): this_agent = deepcopy(BasicType) # Make a new copy of the basic type this_agent.assignParameters(CRRA = CRRA_list[i]) # Give it a unique CRRA value my_agent_list.append(this_agent) # Addd it to the list of agent types # Make a list of commands to be run in parallel; these should be methods of ConsumerType do_this_stuff = ['updateSolutionTerminal()','solve()','unpack_cFunc()'] # Solve the model for each type by looping over the types (not multithreading) start_time = clock() multiThreadCommandsFake(my_agent_list, do_this_stuff) # Fake multithreading, just loops end_time = clock() print('Solving ' + str(type_count) + ' types without multithreading took ' + mystr(end_time-start_time) + ' seconds.') # Plot the consumption functions for all types on one figure plotFuncs([this_type.cFunc[0] for this_type in my_agent_list],0,5) # Delete the solution for each type to make sure we're not just faking it for i in range(type_count): my_agent_list[i].solution = None my_agent_list[i].cFunc = None my_agent_list[i].time_vary.remove('solution') my_agent_list[i].time_vary.remove('cFunc') # And here's HARK's initial attempt at multithreading: start_time = clock() multiThreadCommands(my_agent_list, do_this_stuff) # Actual multithreading end_time = clock() print('Solving ' + str(type_count) + ' types with multithreading took ' + mystr(end_time-start_time) + ' seconds.') # Plot the consumption functions for all types on one figure to see if it worked
if do_RA: if run_models: # Make a representative agent consumer, then solve and simulate the model StickyRAmarkovConsumer = StickyEmarkovRepAgent(**Params.init_RA_mrkv_consumer) StickyRAmarkovConsumer.IncomeDstn[0] = Params.StateCount*[StickyRAmarkovConsumer.IncomeDstn[0]] StickyRAmarkovConsumer.track_vars = ['cLvlNow','yNrmTrue','aLvlNow','pLvlTrue','TranShkNow','MrkvNow'] # Solve the representative agent Markov economy t_start = clock() StickyRAmarkovConsumer.solve() t_end = clock() print('Solving the representative agent Markov economy took ' + mystr(t_end-t_start) + ' seconds.') print('Consumption functions for the Markov representative agent:') plotFuncs(StickyRAmarkovConsumer.solution[0].cFunc,0,50) # Simulate the sticky representative agent Markov economy t_start = clock() StickyRAmarkovConsumer(UpdatePrb = Params.UpdatePrb) StickyRAmarkovConsumer.initializeSim() StickyRAmarkovConsumer.simulate() t_end = clock() print('Simulating the sticky representative agent Markov economy took ' + mystr(t_end-t_start) + ' seconds.') # Make results for the sticky representative agent economy desc = 'Results for the sticky representative agent Markov economy' name = 'RAmarkovSticky' makeStickyEdataFile(StickyRAmarkovConsumer,ignore_periods,description=desc,filename=name,save_data=save_data,calc_micro_stats=calc_micro_stats) DeltaLogC_stdev = np.genfromtxt(results_dir + 'RAmarkovStickyResults.csv', delimiter=',')[3] # For use in frictionless spec
# single-threading (looping), due to overhead. BasicType = Model.IndShockConsumerType(**Params.init_idiosyncratic_shocks) BasicType.cycles = 0 BasicType(aXtraMax = 100, aXtraCount = 64) BasicType(vFuncBool = False, cubicBool = True) BasicType.updateAssetsGrid() BasicType.timeFwd() # Solve the basic type and plot the results, to make sure things are working start_time = clock() BasicType.solve() end_time = clock() print('Solving the basic consumer took ' + mystr(end_time-start_time) + ' seconds.') BasicType.unpackcFunc() print('Consumption function:') plotFuncs(BasicType.cFunc[0],0,5) # plot consumption print('Marginal consumption function:') plotFuncsDer(BasicType.cFunc[0],0,5) # plot MPC if BasicType.vFuncBool: print('Value function:') plotFuncs(BasicType.solution[0].vFunc,0.2,5) # Make many copies of the basic type, each with a different risk aversion BasicType.vFuncBool = False # just in case it was set to True above my_agent_list = [] CRRA_list = np.linspace(1,8,type_count) # All the values that CRRA will take on for i in range(type_count): this_agent = deepcopy(BasicType) # Make a new copy of the basic type this_agent.assignParameters(CRRA = CRRA_list[i]) # Give it a unique CRRA value my_agent_list.append(this_agent) # Addd it to the list of agent types
# Make a quick example dictionary RA_params = deepcopy(Params.init_idiosyncratic_shocks) RA_params['DeprFac'] = 0.05 RA_params['CapShare'] = 0.36 RA_params['UnempPrb'] = 0.0 RA_params['LivPrb'] = [1.0] # Make and solve a rep agent model RAexample = RepAgentConsumerType(**RA_params) t_start = clock() RAexample.solve() t_end = clock() print('Solving a representative agent problem took ' + str(t_end - t_start) + ' seconds.') plotFuncs(RAexample.solution[0].cFunc, 0, 20) # Simulate the representative agent model RAexample.T_sim = 2000 RAexample.track_vars = ['cNrmNow', 'mNrmNow', 'Rfree', 'wRte'] RAexample.initializeSim() t_start = clock() RAexample.simulate() t_end = clock() print('Simulating a representative agent for ' + str(RAexample.T_sim) + ' periods took ' + str(t_end - t_start) + ' seconds.') # Make and solve a Markov representative agent RA_markov_params = deepcopy(RA_params) RA_markov_params['PermGroFac'] = [[0.97, 1.03]] RA_markov_params['MrkvArray'] = np.array([[0.99, 0.01], [0.01, 0.99]])
'AgentCount' : 10000, # Number of agents to simulate 'T_sim' : 120, # Number of periods to simulate 'T_cycle' : 1} # Number of periods in the cycle # Make and solve a tractable consumer type ExampleType = TractableConsumerType(**base_primitives) t_start = clock() ExampleType.solve() t_end = clock() print('Solving a tractable consumption-savings model took ' + str(t_end-t_start) + ' seconds.') # Plot the consumption function and whatnot m_upper = 1.5*ExampleType.mTarg conFunc_PF = lambda m: ExampleType.h*ExampleType.PFMPC + ExampleType.PFMPC*m #plotFuncs([ExampleType.solution[0].cFunc,ExampleType.mSSfunc,ExampleType.cSSfunc],0,m_upper) plotFuncs([ExampleType.solution[0].cFunc,ExampleType.solution[0].cFunc_U],0,m_upper) if do_simulation: ExampleType(**simulation_values) # Set attributes needed for simulation ExampleType.track_vars = ['mLvlNow'] ExampleType.makeShockHistory() ExampleType.initializeSim() ExampleType.simulate() # Now solve the same model using backward induction rather than the analytic method of TBS. # The TBS model is equivalent to a Markov model with two states, one of them absorbing (permanent unemployment). MrkvArray = np.array([[1.0-base_primitives['UnempPrb'],base_primitives['UnempPrb']],[0.0,1.0]]) # Define the two state, absorbing unemployment Markov array init_consumer_objects = {"CRRA":base_primitives['CRRA'], "Rfree":np.array(2*[base_primitives['Rfree']]), # Interest factor (same in both states) "PermGroFac":[np.array(2*[base_primitives['PermGroFac']/(1.0-base_primitives['UnempPrb'])])], # Unemployment-compensated permanent growth factor
unemployed_income_dist = [np.ones(1),np.ones(1),np.zeros(1)] # Definitely don't SerialUnemploymentExample.IncomeDstn = [[employed_income_dist,unemployed_income_dist,employed_income_dist, unemployed_income_dist]] # Interest factor and permanent growth rates are constant arrays SerialUnemploymentExample.Rfree = np.array(4*[SerialUnemploymentExample.Rfree]) SerialUnemploymentExample.PermGroFac = [np.array(4*SerialUnemploymentExample.PermGroFac)] # Solve the serial unemployment consumer's problem and display solution SerialUnemploymentExample.timeFwd() start_time = clock() SerialUnemploymentExample.solve() end_time = clock() print('Solving a Markov consumer took ' + mystr(end_time-start_time) + ' seconds.') print('Consumption functions for each discrete state:') plotFuncs(SerialUnemploymentExample.solution[0].cFunc,0,50) if SerialUnemploymentExample.vFuncBool: print('Value functions for each discrete state:') plotFuncs(SerialUnemploymentExample.solution[0].vFunc,5,50) # Simulate some data; results stored in cHist, mHist, bHist, aHist, MPChist, and pHist if do_simulation: SerialUnemploymentExample.sim_periods = 120 SerialUnemploymentExample.Mrkv_init = np.zeros(SerialUnemploymentExample.Nagents,dtype=int) SerialUnemploymentExample.makeMrkvHist() SerialUnemploymentExample.makeIncShkHist() SerialUnemploymentExample.initializeSim() SerialUnemploymentExample.simConsHistory() ###############################################################################
my_agent_list.append(this_agent) # Addd it to the list of agent types # Make a list of commands to be run in parallel; these should be methods of ConsumerType do_this_stuff = ['updateSolutionTerminal()', 'solve()', 'unpack_cFunc()'] # Solve the model for each type by looping over the types (not multithreading) start_time = clock() multiThreadCommandsFake(my_agent_list, do_this_stuff) # Fake multithreading, just loops end_time = clock() print('Solving ' + str(type_count) + ' types without multithreading took ' + mystr(end_time - start_time) + ' seconds.') # Plot the consumption functions for all types on one figure plotFuncs([this_type.cFunc[0] for this_type in my_agent_list], 0, 5) # Delete the solution for each type to make sure we're not just faking it for i in range(type_count): my_agent_list[i].solution = None my_agent_list[i].cFunc = None my_agent_list[i].time_vary.remove('solution') my_agent_list[i].time_vary.remove('cFunc') # And here's HARK's initial attempt at multithreading: start_time = clock() multiThreadCommands(my_agent_list, do_this_stuff) # Actual multithreading end_time = clock() print('Solving ' + str(type_count) + ' types with multithreading took ' + mystr(end_time - start_time) + ' seconds.')
import pylab as plt # We need this module to change the y-axis on the graphs # Declare the upper limit for the graph x_max = 10.0 # Note that plotFuncs takes four arguments: (1) a list of the arguments to plot, # (2) the lower bound for the plots, (3) the upper bound for the plots, and (4) keywords to pass # to the legend for the plot. # Plot the consumption functions to compare them print("Consumption functions:") plotFuncs( [BaselineExample.solution[0].cFunc, XtraCreditExample.solution[0].cFunc], BaselineExample.solution[0].mNrmMin, x_max, legend_kwds={"loc": "upper left", "labels": ["Baseline", "XtraCredit"]}, ) # Plot the MPCs to compare them print("MPC out of Credit v MPC out of Income") plt.ylim([0.0, 1.2]) plotFuncs( [FirstDiffMPC_Credit, FirstDiffMPC_Income], BaselineExample.solution[0].mNrmMin, x_max, legend_kwds={"labels": ["MPC out of Credit", "MPC out of Income"]}, )
############################################################################### ############################################################################### if __name__ == '__main__': from time import clock from HARKcore import Market mystr = lambda number : "{:.4f}".format(number) import matplotlib.pyplot as plt from copy import deepcopy do_many_types = True # Make a test case and solve the micro model TestType = FashionVictimType(**Params.default_params) print('Utility function:') plotFuncs(TestType.conformUtilityFunc,0,1) t_start = clock() TestType.solve() t_end = clock() print('Solving a fashion victim micro model took ' + mystr(t_end-t_start) + ' seconds.') print('Jock value function:') plotFuncs(TestType.VfuncJock,0,1) print('Punk value function:') plotFuncs(TestType.VfuncPunk,0,1) print('Jock switch probability:') plotFuncs(TestType.switchFuncJock,0,1) print('Punk switch probability:') plotFuncs(TestType.switchFuncPunk,0,1)
# Make a small open economy and the consumers who live in it StickySOEconsumers = StickyEconsumerSOEType(**init_SOE_consumer) StickySOEconomy = SmallOpenEconomy(**init_SOE_market) StickySOEconomy.agents = [StickySOEconsumers] StickySOEconomy.makeAggShkHist() StickySOEconsumers.getEconomyData(StickySOEconomy) StickySOEconsumers.track_vars = ['aLvlNow','mNrmNow','cNrmNow','pLvlNow','pLvlErrNow'] # Solve the model and display some output StickySOEconomy.solveAgents() StickySOEconomy.makeHistory() # Plot some of the results cFunc = lambda m : StickySOEconsumers.solution[0].cFunc(m,np.ones_like(m)) plotFuncs(cFunc,0.0,20.0) plt.plot(np.mean(StickySOEconsumers.aLvlNow_hist,axis=1)) plt.show() plt.plot(np.mean(StickySOEconsumers.mNrmNow_hist*StickySOEconsumers.pLvlNow_hist,axis=1)) plt.show() plt.plot(np.mean(StickySOEconsumers.cNrmNow_hist*StickySOEconsumers.pLvlNow_hist,axis=1)) plt.show() plt.plot(np.mean(StickySOEconsumers.pLvlNow_hist,axis=1)) plt.plot(np.mean(StickySOEconsumers.pLvlErrNow_hist,axis=1)) plt.show() print('Average aggregate assets = ' + str(np.mean(StickySOEconsumers.aLvlNow_hist[ignore_periods:,:])))
# Define the model primitives base_primitives = {"mho": 0.015, "beta": 0.9, "R": 1.1, "G": 1.05, "rho": 0.95} # Make and solve a tractable consumer type ExampleType = Model.TractableConsumerType(**base_primitives) t_start = clock() ExampleType.solve() t_end = clock() print("Solving a tractable consumption-savings model took " + str(t_end - t_start) + " seconds.") # Plot the consumption function and whatnot m_upper = 1.5 * ExampleType.m_targ conFunc_PF = lambda m: ExampleType.h * ExampleType.kappa_PF + ExampleType.kappa_PF * m # plotFuncs([ExampleType.solution[0].cFunc,ExampleType.mSSfunc,ExampleType.cSSfunc],0,m_upper) plotFuncs([ExampleType.solution[0].cFunc, ExampleType.solution[0].cFunc_U], 0, m_upper) # Now solve the same model using backward induction init_consumer_objects = { "rho": base_primitives["rho"], "R": base_primitives["R"], "Gamma": [base_primitives["G"] / (1.0 - base_primitives["mho"])], "constraint": False, "psi_sigma": [0.0], "psi_N": 1, "xi_sigma": [0.0], "xi_N": 1, "T_total": 1, "p_unemploy": 0.0, "p_unemploy_retire": 0.0, "T_retire": 0,