CFE_scale = scalar > 0, scale parameter for CFE disutility of labor
cfe_params = (2,) vector, values for (Frisch, CFE_scale)
b_ellip = scalar > 0, fitted value of b for elliptical disutility
of labor
upsilon = scalar > 1, fitted value of upsilon for elliptical
disutility of labor
------------------------------------------------------------------------
'''
ellip_graph = False
b_ellip_init = 1.0
upsilon_init = 2.0
ellip_init = np.array([b_ellip_init, upsilon_init])
Frisch_elast = 0.9
CFE_scale = 1.0
cfe_params = np.array([Frisch_elast, CFE_scale])
b_ellip, upsilon = elp.fit_ellip_CFE(ellip_init, cfe_params, l_tilde,
ellip_graph)
'''
------------------------------------------------------------------------
Solve for the steady-state solution
------------------------------------------------------------------------
cur_path = string, current file path of this script
ss_output_fldr = string, cur_path extension of SS output folder path
ss_output_dir = string, full path name of SS output folder
ss_outputfile = string, path name of file for SS output objects
ss_paramsfile = string, path name of file for SS parameter objects
ss_args = length 15 tuple, arguments to pass in to ss.get_SS()
rss_init = scalar > -delta, initial guess for r_ss
c1_init = scalar > 0, initial guess for c1
init_vals = length 2 tuple, initial guesses (r, c1) to be passed
in to ss.get_SS
S = int(80) beta_annual = 0.96 beta = beta_annual**(80 / S) sigma = 2.5 l_tilde = 1.0 chi_n_vec = 1.0 * np.ones(S) # chi_n_vec = np.hstack((np.linspace(1.2, 1.0, 10), # np.linspace(1.0, 1.0, 40), # np.linspace(1.0, 3.0, 30))) # b = 0.501 # upsilon = 1.553 ellip_init = np.array([0.2, 1.0]) Frisch = 0.8 scale_param = 1.0 cfe_params = np.array([Frisch, scale_param]) b, upsilon = elp.fit_ellip_CFE(ellip_init, cfe_params, l_tilde, True) lambdas = np.array([0.3, 0.3, 0.2, 0.1, 0.1]) J = lambdas.shape[0] age_wgts = np.ones(S) * (1 / S) age_wgts_80 = np.ones(80) * (1 / 80) emat = abil.get_e_interp(S, age_wgts, age_wgts_80, lambdas, True) # Firm parameters A = 1.0 alpha = 0.35 delta_annual = 0.05 delta = 1 - ((1 - delta_annual)**(80 / S)) # SS parameters SS_graph = True
# Household parameters
S = int(80)
beta_annual = 0.96
beta = beta_annual**(80 / S)
sigma = 2.5
l_tilde = 1.0
chi_n_vec = 1.0 * np.ones(S)
b_ellip_init = 1.0
upsilon_init = 2.0
ellip_init = np.array([b_ellip_init, upsilon_init])
Frisch_elast = 2.2
CFE_scale = 1.0
cfe_params = np.array([Frisch_elast, CFE_scale])
b_ellip, upsilon = elp.fit_ellip_CFE(ellip_init, cfe_params, l_tilde, False)
'''
------------------------------------------------------------------------
Estimate tax function parameters
------------------------------------------------------------------------
'''
num_tx_params = 12
# micro_data = pickle.load(open('taxdata42.pkl', 'rb'))
# baseline = True
# analytical_mtrs = False
# age_specific = True
# start_year = 2017
# txf_dict = txf.tax_func_estimate(start_year, baseline, analytical_mtrs,
# age_specific)
txf_dict = pickle.load(open('tax_dict.pkl', 'rb'))
def __init__(self):
'''
Instantiate the parameters class with the input name
paramclass_name
'''
'''
Period parameters
----------------------------------------------------------------
E = integer >= 1, number of periods an individual is
economically inactive (youth)
S = integer >= 3, number of periods an individual lives
yrs_in_per = scalar > 0, number of years in model period
T1 = integer > S, number of periods until demographics
hit steady state
T2 = integer > T1, number of periods until economy is in
steady state
----------------------------------------------------------------
'''
self.E = int(20)
self.S = int(80)
self.yrs_in_per = 80 / self.S
self.T1 = int(round(2.0 * self.S))
self.T2 = int(round(3.0 * self.S))
'''
Household parameters
----------------------------------------------------------------
beta_an = scalar in (0,1), discount factor for one year
beta = scalar in (0,1), discount factor for each model
period
sigma = scalar > 0, coefficient of relative risk aversion
l_tilde = scalar > 0, per-period time endowment for every
agent
chi_n_vec = (S,) vector, values for chi_{n,s}
chi_b = scalar >= 0, scalar parameter on utility of dying
with positive savings (warm glow bequest motive)
b_ellip_init = scalar > 0, initial guess for b
upsilon_init = scalar > 1, initial guess for upsilon
ellip_init = (2,) vector, initial guesses for b and upsilon
Frisch_elast = scalar > 0, Frisch elasticity of labor supply for
CFE disutility of labor
CFE_scale = scalar > 0, scale parameter for CFE disutility of
labor
cfe_params = (2,) vector, values for (Frisch, CFE_scale)
b_ellip = scalar > 0, fitted value of b for elliptical
disutility of labor
upsilon = scalar > 1, fitted value of upsilon for
elliptical disutility of labor
b_s0_vec = (S,) vector, initial wealth for each aged
individual in the first model period
----------------------------------------------------------------
'''
self.beta_an = 0.96
self.beta = self.beta_an**self.yrs_in_per
self.sigma = 2.2
self.l_tilde = 1.0
self.chi_n_vec = 1.0 * np.ones(self.S)
self.chi_b = 1.0
b_ellip_init = 1.0
upsilon_init = 2.0
ellip_init = np.array([b_ellip_init, upsilon_init])
self.Frisch_elast = 0.9
self.CFE_scale = 1.0
cfe_params = np.array([self.Frisch_elast, self.CFE_scale])
b_ellip, upsilon = elp.fit_ellip_CFE(ellip_init, cfe_params,
self.l_tilde)
self.b_ellip = b_ellip
self.upsilon = upsilon
self.b_s0_vec = 0.1 * np.ones(self.S)
'''
Demographic parameters
----------------------------------------------------------------
min_yr = integer > 0, minimum year represented in the
data
max_yr = integer > min_yr, maximum number of years
represented in the data
curr_year = integer >= 2020, current year represented by t=0
omega_m1 = (S,) vector, stationarized economically active
population distribution in period t=-1 right
before current period
omega_tp = (S, T2+1) matrix, transition path of the
stationarized population distribution by age for
economically active ages
omega_ss = (S,) vector, steady-state stationarized
population distribution by age for economically
active ages
g_n_path = (T2,) vector, time path of the population growth
rate
g_n_tp = (T2 + S,) vector, time path of the population
growth rate
g_n_ss = scalar, steady-state population growth rate
surv_rates = (S,) vector, constant per-period survival rate
of particular age cohort of cohort
imm_rates_mat = (T2, S) matrix, time path of immigration rates
by age
rho_m1 = (S,) vector, mortality rates by age in the
period t=-1 before the initial period
rho_st = (S, T2+S) matrix, time path of mortality rates
by age
rho_ss = (S,) vector, constant per-period mortality rate
of particular age cohort
i_st = (S, T2+1) matrix, time path of immigration rates
by age
i_ss = (S,) vector, steady-state immigration rates by
age for economically active ages
----------------------------------------------------------------
'''
self.min_yr = 1
self.max_yr = self.E + self.S
self.curr_year = 2020
(omega_tp, g_n_ss, omega_ss, surv_rates, rho_ss, g_n_path,
imm_rates_mat, omega_m1) = \
demog.get_pop_objs(self.E, self.S, self.T1, self.min_yr,
self.max_yr, self.curr_year,
GraphDiag=False)
self.rho_ss = rho_ss
self.i_ss = imm_rates_mat.T[:, self.T1]
self.omega_ss = omega_ss
self.omega_tp = \
np.append(omega_tp.T, omega_ss.reshape((self.S, 1)), axis=1)
self.rho_m1 = rho_ss
self.omega_m1 = omega_m1
self.g_n_ss = g_n_ss
self.g_n_tp = \
np.append(g_n_path.reshape((1, self.T1 + self.S)),
g_n_ss * np.ones((1, self.T2 - self.T1)),
axis=1).flatten()
self.rho_st = np.tile(self.rho_ss.reshape((self.S, 1)),
(1, self.T2 + self.S))
self.i_st = np.append(imm_rates_mat.T,
self.i_ss.reshape((self.S, 1)),
axis=1)
'''
Industry parameters
----------------------------------------------------------------
A = scalar > 0, total factor productivity
alpha = scalar in (0,1), capital share of income
delta_an = scalar in [0,1], annual capital depreciation rate
delta = scalar in [0,1], model period capital depreciation
rate
g_y_an = scalar, annual net growth rate of labor productivity
g_y = scalar, net growth rate of labor productivity in each
model period
----------------------------------------------------------------
'''
self.A = 1.0
self.alpha = 0.35
self.delta_an = 0.05
self.delta = 1 - ((1 - self.delta_an)**self.yrs_in_per)
g_y_an = 0.03
self.g_y = ((1 + g_y_an)**self.yrs_in_per) - 1
'''
Set steady-state solution method parameters
----------------------------------------------------------------
SS_solve = boolean, =True if want to solve for steady-state
solution, otherwise retrieve solutions from pickle
SS_OutTol = scalar > 0, tolerance for outer loop iterative
solution convergence criterion
SS_EulTol = scalar > 0, tolerance level for steady-state
inner-loop Euler equation root finder
SS_graphs = boolean, =True if want graphs of steady-state
objects
SS_EulDif = boolean, =True if use simple differences in Euler
errors. Otherwise, use percent deviation form.
----------------------------------------------------------------
'''
self.SS_solve = True
self.SS_OutTol = 1e-13
self.SS_EulTol = 1e-13
self.SS_graphs = True
self.SS_EulDif = True
'''
Set transition path solution method parameters
----------------------------------------------------------------
TP_solve = boolean, =True if want to solve TP equilibrium
TP_OutTol = scalar > 0, tolerance level for outer-loop
bisection method in TPI
TP_EulTol = scalar > 0, tolerance level for inner-loop root
finder in each iteration of TPI
TP_graphs = boolean, =True if want graphs of TPI objects
TP_EulDif = boolean, =True if want difference version of Euler
errors beta*(1+r)*u'(c2) - u'(c1), =False if want
ratio version [beta*(1+r)*u'(c2)]/[u'(c1)] - 1
xi_TP = scalar in (0,1], TPI path updating parameter
maxiter_TP = integer >= 1, Maximum number of iterations for TPI
----------------------------------------------------------------
'''
self.TP_solve = True
self.TP_OutTol = 1e-7
self.TP_EulTol = 1e-10
self.TP_graphs = True
self.TP_EulDif = True
self.xi_TP = 0.2
self.maxiter_TP = 1000
def get_chi_n_vec(self, params):
'''
--------------------------------------------------------------------
This function calibrates chi_n_vec(s) in line with eq. (7.8) based
on actual data for hours worked, consumption by age and wage for Italy.
--------------------------------------------------------------------
INPUTS:
WDATA = scalar, data on annual gross wage in thousands of euros
params = length 7 tuple, (sigma, l_tilde, ellip_graph, b_ellip_init,
upsilon_init, Frisch_elast, CFE_scale)
OTHER FUNCTIONS AND FILES CALLED BY THIS FUNCTION:
get_cdata()
get_ndata()
elp.fit_ellip_CFE()
OBJECTS CREATED WITHIN FUNCTION:
cdata = (S,) vector, average annual consumption expenditure by
individual in thousands EUR, smoothed using polynomial function
ndata = (S,) vector, elementwise average (i.e. out of 4 years'
values) of 80 elements of n_year
ellip_init = (2,) vector, initial guesses for b and upsilon
cfe_params = (2,) vector, parameters for CFE disutility of labor
parameters: Frisch elasticity and scale parameter
b_ellip = scalar > 0, scale parameter in elliptical disutility
of labor function
upsilon = scalar > 1, shape parameter in elliptical disutility
of labor function
chi_n_vec = (S,) vector, values for chi^n_s
FILES CREATED BY THIS FUNCTION: None
RETURNS: chi_n_vec
---------------------------------------------------------------------
'''
cdata = self.get_cdata()
ndata = self.get_ndata()
"""
S = 10
if S == 10:
cdata = np.array([3.98753917, 10.43735981, 14.30110456, 15.73431751,
15.14497752, 13.19349825, 10.79272809, 9.1079502,
8.41754415, 7.36851578])
ndata = np.array([0.24494488, 0.40675908, 0.41317181, 0.4082234,
0.3838976, 0.24507573, 0.10400452, 0.04430578,
0.040039, 0.03372474])
elif S == 80:
cdata = self.get_cdata()
ndata = self.get_ndata()
"""
sigma, l_tilde, ellip_graph, b_ellip_init, upsilon_init, Frisch_elast, CFE_scale = params
ellip_init = np.array([b_ellip_init, upsilon_init])
cfe_params = np.array([Frisch_elast, CFE_scale])
b_ellip, upsilon = elp.fit_ellip_CFE(ellip_init, cfe_params, l_tilde,
ellip_graph)
chi_n_vec = (self.WDATA * cdata**(-sigma)) / (
(b_ellip / l_tilde) * (ndata / l_tilde)**(upsilon - 1) *
(1 - (ndata / l_tilde)**upsilon)**((1 - upsilon) / upsilon))
"""
if S == 80:
vector_name ="chi_n_vec"
chi_n_vec_graph = np.zeros(self.S+self.missing_ages)
chi_n_vec_graph[self.missing_ages:] = chi_n_vec
utils.create_graph_calib(chi_n_vec_graph, vector_name)
"""
vector_name = 'chi_n_vec_hat'
utils.create_graph_calib(chi_n_vec, vector_name)
return chi_n_vec
