def function_to_minimize(chi_params_scalars, chi_params_init, params, iterative_params, weights_SS, rho_vec, lambdas, tau_bq, e):
'''
Inputs:
chi_params_scalars = guesses for multipliers for chi parameters ((S+J)x1 array)
chi_params_init = chi parameters that will be multiplied ((S+J)x1 array)
params = list of parameters (list)
weights_SS = steady state population weights (Sx1 array)
rho_vec = mortality rates (Sx1 array)
lambdas = ability weights (Jx1 array)
tau_bq = bequest tax rates (Jx1 array)
e = ability levels (Jx1 array)
Output:
The sum of absolute percent deviations between the actual and simulated wealth moments
'''
J, S, T, beta, sigma, alpha, Z, delta, ltilde, nu, g_y, g_n_ss, tau_payroll, retire, mean_income_data, \
a_tax_income, b_tax_income, c_tax_income, d_tax_income, h_wealth, p_wealth, m_wealth, b_ellipse, upsilon = params
chi_params_init *= chi_params_scalars
# print 'Print Chi_b: ', chi_params_init[:J]
# print 'Scaling vals:', chi_params_scalars[:J]
solutions_dict = pickle.load(open("OUTPUT/Saved_moments/SS_init_solutions.pkl", "rb"))
solutions = solutions_dict['solutions']
b_guess = solutions[:S*J]
n_guess = solutions[S*J:2*S*J]
wguess, rguess, factorguess, T_Hguess = solutions[2*S*J:]
solutions = SS_solver(b_guess.reshape(S, J), n_guess.reshape(S, J), wguess, rguess, T_Hguess, factorguess, chi_params_init[J:], chi_params_init[:J], params, iterative_params, tau_bq, rho, lambdas, weights_SS, e)
b_new = solutions[:S*J]
n_new = solutions[S*J:2*S*J]
w_new, r_new, factor_new, T_H_new = solutions[2*S*J:]
# Wealth Calibration Euler
error5 = list(utils.check_wealth_calibration(b_new.reshape(S, J)[:-1, :], factor_new, params))
# labor calibration euler
lab_data_dict = pickle.load(open("OUTPUT/Saved_moments/labor_data_moments.pkl", "rb"))
labor_sim = (n_new.reshape(S, J)*lambdas.reshape(1, J)).sum(axis=1)
if DATASET == 'SMALL':
lab_dist_data = lab_data_dict['labor_dist_data'][:S]
else:
lab_dist_data = lab_data_dict['labor_dist_data']
error6 = list(utils.perc_dif_func(labor_sim, lab_dist_data))
# combine eulers
output = np.array(error5 + error6)
# Constraints
eul_error = np.ones(J)
for j in xrange(J):
eul_error[j] = np.abs(Euler_equation_solver(np.append(b_new.reshape(S, J)[:, j], n_new.reshape(S, J)[:, j]), r_new, w_new, T_H_new, factor_new, j, params, chi_params_init[:J], chi_params_init[J:], tau_bq, rho, lambdas, weights_SS, e)).max()
fsolve_no_converg = eul_error.max()
if np.isnan(fsolve_no_converg):
fsolve_no_converg = 1e6
if fsolve_no_converg > 1e-4:
# If the fsovle didn't converge (was NaN or above the tolerance), then tell the minimizer that this is a bad place to be
# and don't save the solutions as initial guesses (since they might be gibberish)
output += 1e14
else:
var_names = ['solutions']
dictionary = {}
for key in var_names:
dictionary[key] = locals()[key]
pickle.dump(dictionary, open("OUTPUT/Saved_moments/SS_init_solutions.pkl", "wb"))
if (chi_params_init <= 0.0).any():
# In case the minimizer doesn't respect the bounds given
output += 1e14
# Use generalized method of moments to fit the chi's
weighting_mat = np.eye(2*J + S)
scaling_val = 100.0
value = np.dot(scaling_val * np.dot(output.reshape(1, 2*J+S), weighting_mat), scaling_val * output.reshape(2*J+S, 1))
print 'Value of criterion function: ', value.sum()
return value.sum()
def function_to_minimize(chi_params_scalars, chi_params_init, income_tax_parameters, ss_parameters,
iterative_params, weights_SS, rho_vec, lambdas, tau_bq, e, output_dir):
'''
Inputs:
chi_params_scalars = guesses for multipliers for chi parameters
((S+J)x1 array)
chi_params_init = chi parameters that will be multiplied
((S+J)x1 array)
params = list of parameters (list)
weights_SS = steady state population weights (Sx1 array)
rho_vec = mortality rates (Sx1 array)
lambdas = ability weights (Jx1 array)
tau_bq = bequest tax rates (Jx1 array)
e = ability levels (Jx1 array)
Output:
The sum of absolute percent deviations between the actual and
simulated wealth moments
'''
J, S, T, BW, beta, sigma, alpha, Z, delta, ltilde, nu, g_y,\
g_n_ss, tau_payroll, retire, mean_income_data,\
h_wealth, p_wealth, m_wealth, b_ellipse, upsilon = ss_parameters
analytical_mtrs, etr_params, mtrx_params, mtry_params = income_tax_parameters
chi_params_init *= chi_params_scalars
# print 'Print Chi_b: ', chi_params_init[:J]
# print 'Scaling vals:', chi_params_scalars[:J]
ss_init_path = os.path.join(output_dir,
"Saved_moments/SS_init_solutions.pkl")
solutions_dict = pickle.load(open(ss_init_path, "rb"))
solutions = solutions_dict['solutions']
b_guess = solutions[:(S * J)]
n_guess = solutions[S * J:2 * S * J]
wguess, rguess, factorguess, T_Hguess = solutions[(2 * S * J):]
guesses = [wguess, rguess, T_Hguess, factorguess]
args_ = (b_guess.reshape(S, J), n_guess.reshape(S, J), chi_params_init[J:], chi_params_init[:J],
income_tax_parameters, ss_parameters, iterative_params, tau_bq, rho, lambdas, omega_SS, e)
[solutions, infodict, ier, message] = opt.fsolve(SS_fsolve, guesses, args=args_, xtol=mindist_SS, full_output=True)
[wguess, rguess, T_Hguess, factorguess] = solutions
fsolve_flag = True
solutions = SS_solver(b_guess.reshape(S, J), n_guess.reshape(S, J), wguess, rguess, T_Hguess, factorguess, chi_params_init[
J:], chi_params_init[:J], income_tax_parameters, ss_parameters, iterative_params, tau_bq, rho, lambdas, omega_SS, e, fsolve_flag)
b_new = solutions[:(S * J)]
n_new = solutions[(S * J):(2 * S * J)]
w_new, r_new, factor_new, T_H_new = solutions[(2 * S * J):]
# Wealth Calibration Euler
error5 = list(utils.check_wealth_calibration(b_new.reshape(S, J)[:-1, :],
factor_new, ss_parameters, output_dir))
# labor calibration euler
labor_path = os.path.join(
output_dir, "Saved_moments/labor_data_moments.pkl")
lab_data_dict = pickle.load(open(labor_path, "rb"))
labor_sim = (n_new.reshape(S, J) * lambdas.reshape(1, J)).sum(axis=1)
if DATASET == 'SMALL':
lab_dist_data = lab_data_dict['labor_dist_data'][:S]
else:
lab_dist_data = lab_data_dict['labor_dist_data']
error6 = list(utils.perc_dif_func(labor_sim, lab_dist_data))
# combine eulers
output = np.array(error5 + error6)
# Constraints
eul_error = np.ones(J)
for j in xrange(J):
eul_error[j] = np.abs(Euler_equation_solver(np.append(b_new.reshape(S, J)[:, j], n_new.reshape(S, J)[:, j]), r_new, w_new,
T_H_new, factor_new, j, income_tax_parameters, ss_parameters, chi_params_init[:J], chi_params_init[J:], tau_bq, rho, lambdas, weights_SS, e)).max()
fsolve_no_converg = eul_error.max()
if np.isnan(fsolve_no_converg):
fsolve_no_converg = 1e6
if fsolve_no_converg > 1e-4:
# If the fsovle didn't converge (was NaN or above the tolerance), then tell the minimizer that this is a bad place to be
# and don't save the solutions as initial guesses (since they might be
# gibberish)
output += 1e14
else:
var_names = ['solutions']
dictionary = {}
for key in var_names:
dictionary[key] = locals()[key]
ss_init_path = os.path.join(
output_dir, "Saved_moments/SS_init_solutions.pkl")
pickle.dump(dictionary, open(ss_init_path, "wb"))
if (chi_params_init <= 0.0).any():
# In case the minimizer doesn't respect the bounds given
output += 1e14
# Use generalized method of moments to fit the chi's
weighting_mat = np.eye(2 * J + S)
scaling_val = 100.0
value = np.dot(scaling_val * np.dot(output.reshape(1, 2 * J + S),
weighting_mat), scaling_val * output.reshape(2 * J + S, 1))
print 'Value of criterion function: ', value.sum()
# pickle output in case not converge
global Nfeval, value_all, chi_params_all
value_all[Nfeval] = value.sum()
chi_params_all[:,Nfeval] = chi_params_init
dict_GMM = dict([('values', value_all), ('chi_params', chi_params_all)])
ss_init_path = os.path.join(output_dir, "Saved_moments/SS_init_all.pkl")
pickle.dump(dict_GMM, open(ss_init_path, "wb"))
Nfeval += 1
return value.sum()
def function_to_minimize(chi_params_scalars, chi_params_init,
income_tax_parameters, ss_parameters,
iterative_params, weights_SS, rho_vec, lambdas,
tau_bq, e, output_dir):
'''
Inputs:
chi_params_scalars = guesses for multipliers for chi parameters
((S+J)x1 array)
chi_params_init = chi parameters that will be multiplied
((S+J)x1 array)
params = list of parameters (list)
weights_SS = steady state population weights (Sx1 array)
rho_vec = mortality rates (Sx1 array)
lambdas = ability weights (Jx1 array)
tau_bq = bequest tax rates (Jx1 array)
e = ability levels (Jx1 array)
Output:
The sum of absolute percent deviations between the actual and
simulated wealth moments
'''
J, S, T, BW, beta, sigma, alpha, Z, delta, ltilde, nu, g_y,\
g_n_ss, tau_payroll, retire, mean_income_data,\
h_wealth, p_wealth, m_wealth, b_ellipse, upsilon = ss_parameters
analytical_mtrs, etr_params, mtrx_params, mtry_params = income_tax_parameters
chi_params_init *= chi_params_scalars
# print 'Print Chi_b: ', chi_params_init[:J]
# print 'Scaling vals:', chi_params_scalars[:J]
ss_init_path = os.path.join(output_dir,
"Saved_moments/SS_init_solutions.pkl")
solutions_dict = pickle.load(open(ss_init_path, "rb"))
solutions = solutions_dict['solutions']
b_guess = solutions[:(S * J)]
n_guess = solutions[S * J:2 * S * J]
wguess, rguess, factorguess, T_Hguess = solutions[(2 * S * J):]
guesses = [wguess, rguess, T_Hguess, factorguess]
args_ = (b_guess.reshape(S, J), n_guess.reshape(S, J), chi_params_init[J:],
chi_params_init[:J], income_tax_parameters, ss_parameters,
iterative_params, tau_bq, rho, lambdas, omega_SS, e)
[solutions, infodict, ier, message] = opt.fsolve(SS_fsolve,
guesses,
args=args_,
xtol=mindist_SS,
full_output=True)
[wguess, rguess, T_Hguess, factorguess] = solutions
fsolve_flag = True
solutions = SS_solver(b_guess.reshape(S, J), n_guess.reshape(S, J), wguess,
rguess, T_Hguess, factorguess, chi_params_init[J:],
chi_params_init[:J], income_tax_parameters,
ss_parameters, iterative_params, tau_bq, rho,
lambdas, omega_SS, e, fsolve_flag)
b_new = solutions[:(S * J)]
n_new = solutions[(S * J):(2 * S * J)]
w_new, r_new, factor_new, T_H_new = solutions[(2 * S * J):]
# Wealth Calibration Euler
error5 = list(
utils.check_wealth_calibration(
b_new.reshape(S, J)[:-1, :], factor_new, ss_parameters,
output_dir))
# labor calibration euler
labor_path = os.path.join(output_dir,
"Saved_moments/labor_data_moments.pkl")
lab_data_dict = pickle.load(open(labor_path, "rb"))
labor_sim = (n_new.reshape(S, J) * lambdas.reshape(1, J)).sum(axis=1)
if DATASET == 'SMALL':
lab_dist_data = lab_data_dict['labor_dist_data'][:S]
else:
lab_dist_data = lab_data_dict['labor_dist_data']
error6 = list(utils.perc_dif_func(labor_sim, lab_dist_data))
# combine eulers
output = np.array(error5 + error6)
# Constraints
eul_error = np.ones(J)
for j in xrange(J):
eul_error[j] = np.abs(
Euler_equation_solver(
np.append(
b_new.reshape(S, J)[:, j],
n_new.reshape(S, J)[:, j]), r_new, w_new, T_H_new,
factor_new, j, income_tax_parameters, ss_parameters,
chi_params_init[:J], chi_params_init[J:], tau_bq, rho, lambdas,
weights_SS, e)).max()
fsolve_no_converg = eul_error.max()
if np.isnan(fsolve_no_converg):
fsolve_no_converg = 1e6
if fsolve_no_converg > 1e-4:
# If the fsovle didn't converge (was NaN or above the tolerance), then tell the minimizer that this is a bad place to be
# and don't save the solutions as initial guesses (since they might be
# gibberish)
output += 1e14
else:
var_names = ['solutions']
dictionary = {}
for key in var_names:
dictionary[key] = locals()[key]
ss_init_path = os.path.join(output_dir,
"Saved_moments/SS_init_solutions.pkl")
pickle.dump(dictionary, open(ss_init_path, "wb"))
if (chi_params_init <= 0.0).any():
# In case the minimizer doesn't respect the bounds given
output += 1e14
# Use generalized method of moments to fit the chi's
weighting_mat = np.eye(2 * J + S)
scaling_val = 100.0
value = np.dot(
scaling_val * np.dot(output.reshape(1, 2 * J + S), weighting_mat),
scaling_val * output.reshape(2 * J + S, 1))
print 'Value of criterion function: ', value.sum()
# pickle output in case not converge
global Nfeval, value_all, chi_params_all
value_all[Nfeval] = value.sum()
chi_params_all[:, Nfeval] = chi_params_init
dict_GMM = dict([('values', value_all), ('chi_params', chi_params_all)])
ss_init_path = os.path.join(output_dir, "Saved_moments/SS_init_all.pkl")
pickle.dump(dict_GMM, open(ss_init_path, "wb"))
Nfeval += 1
return value.sum()
