def runner(output_base, baseline_dir, baseline=False,
analytical_mtrs=False, age_specific=False, reform={}, user_params={},
guid='', run_micro=True):
#from ogusa import parameters, wealth, labor, demographics, income
from ogusa import parameters, demographics, income, utils
from ogusa import txfunc
tick = time.time()
#Create output directory structure
saved_moments_dir = os.path.join(output_base, "Saved_moments")
ss_dir = os.path.join(output_base, "SS")
tpi_dir = os.path.join(output_base, "TPI")
dirs = [saved_moments_dir, ss_dir, tpi_dir]
for _dir in dirs:
try:
print "making dir: ", _dir
os.makedirs(_dir)
except OSError as oe:
pass
if run_micro:
txfunc.get_tax_func_estimate(baseline=baseline, analytical_mtrs=analytical_mtrs, age_specific=age_specific,
start_year=user_params['start_year'], reform=reform, guid=guid)
print ("in runner, baseline is ", baseline)
run_params = ogusa.parameters.get_parameters(baseline=baseline, guid=guid)
run_params['analytical_mtrs'] = analytical_mtrs
# Modify ogusa parameters based on user input
if 'frisch' in user_params:
print "updating fricsh and associated"
b_ellipse, upsilon = ogusa.elliptical_u_est.estimation(user_params['frisch'],
run_params['ltilde'])
run_params['b_ellipse'] = b_ellipse
run_params['upsilon'] = upsilon
run_params.update(user_params)
# Modify ogusa parameters based on user input
if 'g_y_annual' in user_params:
print "updating g_y_annual and associated"
ending_age = run_params['ending_age']
starting_age = run_params['starting_age']
S = run_params['S']
g_y = (1 + user_params['g_y_annual'])**(float(ending_age - starting_age) / S) - 1
run_params['g_y'] = g_y
run_params.update(user_params)
from ogusa import SS, TPI
calibrate_model = False
# List of parameter names that will not be changing (unless we decide to
# change them for a tax experiment)
param_names = ['S', 'J', 'T', 'BW', 'lambdas', 'starting_age', 'ending_age',
'beta', 'sigma', 'alpha', 'nu', 'Z', 'delta', 'E',
'ltilde', 'g_y', 'maxiter', 'mindist_SS', 'mindist_TPI',
'analytical_mtrs', 'b_ellipse', 'k_ellipse', 'upsilon',
'chi_b_guess', 'chi_n_guess','etr_params','mtrx_params',
'mtry_params','tau_payroll', 'tau_bq',
'retire', 'mean_income_data', 'g_n_vector',
'h_wealth', 'p_wealth', 'm_wealth',
'omega', 'g_n_ss', 'omega_SS', 'surv_rate', 'imm_rates','e', 'rho', 'omega_S_preTP']
'''
------------------------------------------------------------------------
Run SS
------------------------------------------------------------------------
'''
sim_params = {}
for key in param_names:
sim_params[key] = run_params[key]
sim_params['output_dir'] = output_base
sim_params['run_params'] = run_params
income_tax_params, ss_parameters, iterative_params, chi_params = SS.create_steady_state_parameters(**sim_params)
ss_outputs = SS.run_SS(income_tax_params, ss_parameters, iterative_params, chi_params, baseline,
baseline_dir=baseline_dir)
'''
------------------------------------------------------------------------
Pickle SS results
------------------------------------------------------------------------
'''
if baseline:
utils.mkdirs(os.path.join(baseline_dir, "SS"))
ss_dir = os.path.join(baseline_dir, "SS/SS_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
else:
utils.mkdirs(os.path.join(output_base, "SS"))
ss_dir = os.path.join(output_base, "SS/SS_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
'''
------------------------------------------------------------------------
Run the TPI simulation
------------------------------------------------------------------------
'''
sim_params['baseline'] = baseline
sim_params['input_dir'] = output_base
sim_params['baseline_dir'] = baseline_dir
income_tax_params, tpi_params, iterative_params, initial_values, SS_values = TPI.create_tpi_params(**sim_params)
tpi_output, macro_output = TPI.run_TPI(income_tax_params,
tpi_params, iterative_params, initial_values, SS_values, output_dir=output_base)
'''
------------------------------------------------------------------------
Pickle TPI results
------------------------------------------------------------------------
'''
tpi_dir = os.path.join(output_base, "TPI")
utils.mkdirs(tpi_dir)
tpi_vars = os.path.join(tpi_dir, "TPI_vars.pkl")
pickle.dump(tpi_output, open(tpi_vars, "wb"))
tpi_dir = os.path.join(output_base, "TPI")
utils.mkdirs(tpi_dir)
tpi_vars = os.path.join(tpi_dir, "TPI_macro_vars.pkl")
pickle.dump(macro_output, open(tpi_vars, "wb"))
print "Time path iteration complete. It"
print "took {0} seconds to get that part done.".format(time.time() - tick)
def runner(output_base,
input_dir,
baseline=False,
analytical_mtrs=True,
reform={},
user_params={},
guid='',
run_micro=True):
from ogusa import parameters, wealth, labor, demographics, income
from ogusa import txfunc
tick = time.time()
#Create output directory structure
saved_moments_dir = os.path.join(output_base, "Saved_moments")
ssinit_dir = os.path.join(output_base, "SSinit")
tpiinit_dir = os.path.join(output_base, "TPIinit")
dirs = [saved_moments_dir, ssinit_dir, tpiinit_dir]
for _dir in dirs:
try:
print "making dir: ", _dir
os.makedirs(_dir)
except OSError as oe:
pass
if run_micro:
txfunc.get_tax_func_estimate(baseline=baseline,
analytical_mtrs=analytical_mtrs,
reform=reform,
guid=guid)
print("in runner, baseline is ", baseline)
run_params = ogusa.parameters.get_parameters(baseline=baseline, guid=guid)
run_params['analytical_mtrs'] = analytical_mtrs
# Modify ogusa parameters based on user input
if 'frisch' in user_params:
print "updating fricsh and associated"
b_ellipse, upsilon = ogusa.elliptical_u_est.estimation(
user_params['frisch'], run_params['ltilde'])
run_params['b_ellipse'] = b_ellipse
run_params['upsilon'] = upsilon
run_params.update(user_params)
# Modify ogusa parameters based on user input
if 'g_y_annual' in user_params:
print "updating g_y_annual and associated"
g_y = (1 + user_params['g_y_annual'])**(
float(ending_age - starting_age) / S) - 1
run_params['g_y'] = g_y
run_params.update(user_params)
globals().update(run_params)
from ogusa import SS, TPI
# Generate Wealth data moments
wealth.get_wealth_data(lambdas, J, flag_graphs, output_dir=input_dir)
# Generate labor data moments
labor.labor_data_moments(flag_graphs, output_dir=input_dir)
get_baseline = True
calibrate_model = False
# List of parameter names that will not be changing (unless we decide to
# change them for a tax experiment)
param_names = [
'S', 'J', 'T', 'BW', 'lambdas', 'starting_age', 'ending_age', 'beta',
'sigma', 'alpha', 'nu', 'Z', 'delta', 'E', 'ltilde', 'g_y', 'maxiter',
'mindist_SS', 'mindist_TPI', 'analytical_mtrs', 'b_ellipse',
'k_ellipse', 'upsilon', 'chi_b_guess', 'chi_n_guess', 'etr_params',
'mtrx_params', 'mtry_params', 'tau_payroll', 'tau_bq',
'calibrate_model', 'retire', 'mean_income_data', 'g_n_vector',
'h_wealth', 'p_wealth', 'm_wealth', 'get_baseline', 'omega', 'g_n_ss',
'omega_SS', 'surv_rate', 'e', 'rho'
]
'''
------------------------------------------------------------------------
Run SS with minimization to fit chi_b and chi_n
------------------------------------------------------------------------
'''
# This is the simulation before getting the replacement rate values
sim_params = {}
glbs = globals()
lcls = locals()
for key in param_names:
if key in glbs:
sim_params[key] = glbs[key]
else:
sim_params[key] = lcls[key]
sim_params['output_dir'] = input_dir
sim_params['run_params'] = run_params
income_tax_params, wealth_tax_params, ellipse_params, ss_parameters, iterative_params = SS.create_steady_state_parameters(
**sim_params)
ss_outputs = SS.run_steady_state(income_tax_params,
ss_parameters,
iterative_params,
get_baseline,
calibrate_model,
output_dir=input_dir)
'''
------------------------------------------------------------------------
Run the baseline TPI simulation
------------------------------------------------------------------------
'''
ss_outputs['get_baseline'] = get_baseline
sim_params['input_dir'] = input_dir
income_tax_params, wealth_tax_params, ellipse_params, parameters, N_tilde, omega_stationary, K0, b_sinit, \
b_splus1init, L0, Y0, w0, r0, BQ0, T_H_0, tax0, c0, initial_b, initial_n = TPI.create_tpi_params(**sim_params)
ss_outputs['income_tax_params'] = income_tax_params
ss_outputs['wealth_tax_params'] = wealth_tax_params
ss_outputs['ellipse_params'] = ellipse_params
ss_outputs['parameters'] = parameters
ss_outputs['N_tilde'] = N_tilde
ss_outputs['omega_stationary'] = omega_stationary
ss_outputs['K0'] = K0
ss_outputs['b_sinit'] = b_sinit
ss_outputs['b_splus1init'] = b_splus1init
ss_outputs['L0'] = L0
ss_outputs['Y0'] = Y0
ss_outputs['r0'] = r0
ss_outputs['BQ0'] = BQ0
ss_outputs['T_H_0'] = T_H_0
ss_outputs['tax0'] = tax0
ss_outputs['c0'] = c0
ss_outputs['initial_b'] = initial_b
ss_outputs['initial_n'] = initial_n
ss_outputs['tau_bq'] = tau_bq
ss_outputs['g_n_vector'] = g_n_vector
ss_outputs['output_dir'] = input_dir
with open("ss_outputs.pkl", 'wb') as fp:
pickle.dump(ss_outputs, fp)
w_path, r_path, T_H_path, BQ_path, Y_path = TPI.run_time_path_iteration(
**ss_outputs)
print "getting to here...."
TPI.TP_solutions(w_path, r_path, T_H_path, BQ_path, **ss_outputs)
print "took {0} seconds to get that part done.".format(time.time() - tick)
#call(['python', 'SS.py'])
income_tax_params, wealth_tax_params, ellipse_params, ss_parameters, iterative_params = SS.create_steady_state_parameters(**sim_params)
ss_outputs = SS.run_steady_state(income_tax_params, ss_parameters, iterative_params, get_baseline, calibrate_model)
'''
------------------------------------------------------------------------
Run the baseline TPI simulation
------------------------------------------------------------------------
'''
ss_outputs['get_baseline'] = get_baseline
income_tax_params, wealth_tax_params, ellipse_params, parameters, N_tilde, omega_stationary, K0, b_sinit, \
b_splus1init, L0, Y0, w0, r0, BQ0, T_H_0, tax0, c0, initial_b, initial_n = TPI.create_tpi_params(**sim_params)
ss_outputs['income_tax_params'] = income_tax_params
ss_outputs['wealth_tax_params'] = wealth_tax_params
ss_outputs['ellipse_params'] = ellipse_params
ss_outputs['parameters'] = parameters
ss_outputs['N_tilde'] = N_tilde
ss_outputs['omega_stationary'] = omega_stationary
ss_outputs['K0'] = K0
ss_outputs['b_sinit'] = b_sinit
ss_outputs['b_splus1init'] = b_splus1init
ss_outputs['L0'] = L0
ss_outputs['Y0'] = Y0
ss_outputs['r0'] = r0
ss_outputs['BQ0'] = BQ0
ss_outputs['T_H_0'] = T_H_0
ss_outputs['tax0'] = tax0
def runner(output_base,
baseline_dir,
test=False,
time_path=True,
baseline=False,
analytical_mtrs=False,
age_specific=False,
reform={},
user_params={},
guid='',
run_micro=True,
small_open=False,
budget_balance=False,
baseline_spending=False):
#from ogusa import parameters, wealth, labor, demographics, income
from ogusa import parameters, demographics, income, utils
from ogusa import txfunc
tick = time.time()
# Make sure options are internally consistent
if baseline == True and baseline_spending == True:
print(
'Inconsistent options. Setting <baseline_spending> to False, leaving <baseline> True.'
)
baseline_spending = False
if budget_balance == True and baseline_spending == True:
print(
'Inconsistent options. Setting <baseline_spending> to False, leaving <budget_balance> True.'
)
baseline_spending = False
#Create output directory structure
saved_moments_dir = os.path.join(output_base, "Saved_moments")
ss_dir = os.path.join(output_base, "SS")
tpi_dir = os.path.join(output_base, "TPI")
dirs = [saved_moments_dir, ss_dir, tpi_dir]
for _dir in dirs:
try:
print("making dir: ", _dir)
os.makedirs(_dir)
except OSError as oe:
pass
if run_micro:
txfunc.get_tax_func_estimate(baseline=baseline,
analytical_mtrs=analytical_mtrs,
age_specific=age_specific,
start_year=user_params['start_year'],
reform=reform,
guid=guid)
print('In runner, baseline is ', baseline)
run_params = ogusa.parameters.get_parameters(test=test,
baseline=baseline,
guid=guid)
run_params['analytical_mtrs'] = analytical_mtrs
run_params['small_open'] = small_open
run_params['budget_balance'] = budget_balance
# Modify ogusa parameters based on user input
if 'frisch' in user_params:
print("updating frisch and associated")
b_ellipse, upsilon = ogusa.elliptical_u_est.estimation(
user_params['frisch'], run_params['ltilde'])
run_params['b_ellipse'] = b_ellipse
run_params['upsilon'] = upsilon
run_params.update(user_params)
if 'debt_ratio_ss' in user_params:
run_params['debt_ratio_ss'] = user_params['debt_ratio_ss']
# Modify ogusa parameters based on user input
if 'g_y_annual' in user_params:
print("updating g_y_annual and associated")
ending_age = run_params['ending_age']
starting_age = run_params['starting_age']
S = run_params['S']
g_y = (1 + user_params['g_y_annual'])**(
float(ending_age - starting_age) / S) - 1
run_params['g_y'] = g_y
run_params.update(user_params)
# Modify transfer & spending ratios based on user input.
if 'T_shifts' in user_params:
if baseline_spending == False:
print('updating ALPHA_T with T_shifts in first',
user_params['T_shifts'].size, 'periods.')
T_shifts = np.concatenate((user_params['T_shifts'],
np.zeros(run_params['ALPHA_T'].size -
user_params['T_shifts'].size)),
axis=0)
run_params['ALPHA_T'] = run_params['ALPHA_T'] + T_shifts
if 'G_shifts' in user_params:
if baseline_spending == False:
print('updating ALPHA_G with G_shifts in first',
user_params['G_shifts'].size, 'periods.')
G_shifts = np.concatenate((user_params['G_shifts'],
np.zeros(run_params['ALPHA_G'].size -
user_params['G_shifts'].size)),
axis=0)
run_params['ALPHA_G'] = run_params['ALPHA_G'] + G_shifts
from ogusa import SS, TPI
calibrate_model = False
# List of parameter names that will not be changing (unless we decide to
# change them for a tax experiment)
param_names = [
'S', 'J', 'T', 'BW', 'lambdas', 'starting_age', 'ending_age', 'beta',
'sigma', 'alpha', 'gamma', 'epsilon', 'nu', 'Z', 'delta', 'E',
'ltilde', 'g_y', 'maxiter', 'mindist_SS', 'mindist_TPI',
'analytical_mtrs', 'b_ellipse', 'k_ellipse', 'upsilon', 'small_open',
'budget_balance', 'ss_firm_r', 'ss_hh_r', 'tpi_firm_r', 'tpi_hh_r',
'tG1', 'tG2', 'alpha_T', 'alpha_G', 'ALPHA_T', 'ALPHA_G', 'rho_G',
'debt_ratio_ss', 'tau_b', 'delta_tau', 'chi_b_guess', 'chi_n_guess',
'etr_params', 'mtrx_params', 'mtry_params', 'tau_payroll', 'tau_bq',
'retire', 'mean_income_data', 'g_n_vector', 'h_wealth', 'p_wealth',
'm_wealth', 'omega', 'g_n_ss', 'omega_SS', 'surv_rate', 'imm_rates',
'e', 'rho', 'initial_debt', 'omega_S_preTP'
]
'''
------------------------------------------------------------------------
Run SS
------------------------------------------------------------------------
'''
sim_params = {}
for key in param_names:
sim_params[key] = run_params[key]
sim_params['output_dir'] = output_base
sim_params['run_params'] = run_params
income_tax_params, ss_parameters, iterative_params, chi_params, small_open_params = SS.create_steady_state_parameters(
**sim_params)
ss_outputs = SS.run_SS(income_tax_params,
ss_parameters,
iterative_params,
chi_params,
small_open_params,
baseline,
baseline_spending,
baseline_dir=baseline_dir)
'''
------------------------------------------------------------------------
Pickle SS results
------------------------------------------------------------------------
'''
if baseline:
utils.mkdirs(os.path.join(baseline_dir, "SS"))
ss_dir = os.path.join(baseline_dir, "SS/SS_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
else:
utils.mkdirs(os.path.join(output_base, "SS"))
ss_dir = os.path.join(output_base, "SS/SS_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
if time_path:
'''
------------------------------------------------------------------------
Run the TPI simulation
------------------------------------------------------------------------
'''
sim_params['baseline'] = baseline
sim_params['baseline_spending'] = baseline_spending
sim_params['input_dir'] = output_base
sim_params['baseline_dir'] = baseline_dir
income_tax_params, tpi_params, iterative_params, small_open_params, initial_values, SS_values, fiscal_params, biz_tax_params = TPI.create_tpi_params(
**sim_params)
tpi_output, macro_output = TPI.run_TPI(
income_tax_params,
tpi_params,
iterative_params,
small_open_params,
initial_values,
SS_values,
fiscal_params,
biz_tax_params,
output_dir=output_base,
baseline_spending=baseline_spending)
'''
------------------------------------------------------------------------
Pickle TPI results
------------------------------------------------------------------------
'''
tpi_dir = os.path.join(output_base, "TPI")
utils.mkdirs(tpi_dir)
tpi_vars = os.path.join(tpi_dir, "TPI_vars.pkl")
pickle.dump(tpi_output, open(tpi_vars, "wb"))
tpi_dir = os.path.join(output_base, "TPI")
utils.mkdirs(tpi_dir)
tpi_vars = os.path.join(tpi_dir, "TPI_macro_vars.pkl")
pickle.dump(macro_output, open(tpi_vars, "wb"))
print("Time path iteration complete.")
print("It took {0} seconds to get that part done.".format(time.time() -
tick))
def test_sstpi():
import tempfile
import pickle
import numpy as np
import numpy as np
import cPickle as pickle
import os
import ogusa
ogusa.parameters.DATASET = "REAL"
from ogusa.utils import comp_array
from ogusa.utils import comp_scalar
from ogusa.utils import dict_compare
from ogusa.utils import pickle_file_compare
import ogusa.SS
import ogusa.TPI
from ogusa import parameters, wealth, labor, demographics, income, SS, TPI
globals().update(ogusa.parameters.get_parameters())
# Generate Wealth data moments
output_dir = TEST_OUTPUT
input_dir = "./OUTPUT"
wealth.get_wealth_data(lambdas, J, flag_graphs, output_dir)
# Generate labor data moments
labor.labor_data_moments(flag_graphs, output_dir=output_dir)
get_baseline = True
calibrate_model = False
# List of parameter names that will not be changing (unless we decide to
# change them for a tax experiment)
param_names = [
"S",
"J",
"T",
"lambdas",
"starting_age",
"ending_age",
"beta",
"sigma",
"alpha",
"nu",
"Z",
"delta",
"E",
"ltilde",
"g_y",
"maxiter",
"mindist_SS",
"mindist_TPI",
"b_ellipse",
"k_ellipse",
"upsilon",
"a_tax_income",
"chi_b_guess",
"chi_n_guess",
"b_tax_income",
"c_tax_income",
"d_tax_income",
"tau_payroll",
"tau_bq",
"calibrate_model",
"retire",
"mean_income_data",
"g_n_vector",
"h_wealth",
"p_wealth",
"m_wealth",
"get_baseline",
"omega",
"g_n_ss",
"omega_SS",
"surv_rate",
"e",
"rho",
]
"""
------------------------------------------------------------------------
Run SS with minimization to fit chi_b and chi_n
------------------------------------------------------------------------
"""
# This is the simulation before getting the replacement rate values
sim_params = {}
for key in param_names:
try:
sim_params[key] = locals()[key]
except KeyError:
sim_params[key] = globals()[key]
sim_params["output_dir"] = output_dir
sim_params["input_dir"] = input_dir
income_tax_params, wealth_tax_params, ellipse_params, ss_parameters, iterative_params = SS.create_steady_state_parameters(
**sim_params
)
ss_outputs = SS.run_steady_state(
ss_parameters, iterative_params, get_baseline, calibrate_model, output_dir=output_dir
)
"""
------------------------------------------------------------------------
Run the baseline TPI simulation
------------------------------------------------------------------------
"""
ss_outputs["get_baseline"] = get_baseline
income_tax_params, wealth_tax_params, ellipse_params, parameters, N_tilde, omega_stationary, K0, b_sinit, b_splus1init, L0, Y0, w0, r0, BQ0, T_H_0, tax0, c0, initial_b, initial_n = TPI.create_tpi_params(
**sim_params
)
ss_outputs["output_dir"] = output_dir
ss_outputs["income_tax_params"] = income_tax_params
ss_outputs["wealth_tax_params"] = wealth_tax_params
ss_outputs["ellipse_params"] = ellipse_params
ss_outputs["parameters"] = parameters
ss_outputs["N_tilde"] = N_tilde
ss_outputs["omega_stationary"] = omega_stationary
ss_outputs["K0"] = K0
ss_outputs["b_sinit"] = b_sinit
ss_outputs["b_splus1init"] = b_splus1init
ss_outputs["L0"] = L0
ss_outputs["Y0"] = Y0
ss_outputs["r0"] = r0
ss_outputs["BQ0"] = BQ0
ss_outputs["T_H_0"] = T_H_0
ss_outputs["tax0"] = tax0
ss_outputs["c0"] = c0
ss_outputs["initial_b"] = initial_b
ss_outputs["initial_n"] = initial_n
ss_outputs["tau_bq"] = tau_bq
ss_outputs["g_n_vector"] = g_n_vector
TPI.run_time_path_iteration(**ss_outputs)
# Platform specific exceptions:
if sys.platform == "darwin":
exceptions = {"tax_path": 0.08, "c_path": 0.02, "b_mat": 0.0017, "solutions": 0.005}
else:
exceptions = {}
# compare results to test data
for old, new in zip(oldfiles, newfiles):
print "trying a pair"
print old, new
assert pickle_file_compare(old, new, exceptions=exceptions, relative=True)
print "next pair"
#pickle.dump(dictionary, open("OUTPUT/Saved_moments/params_given.pkl", "w"))
#call(['python', 'SS.py'])
income_tax_params, wealth_tax_params, ellipse_params, ss_parameters, iterative_params = SS.create_steady_state_parameters(
**sim_params)
ss_outputs = SS.run_steady_state(ss_parameters, iterative_params, get_baseline,
calibrate_model)
'''
------------------------------------------------------------------------
Run the baseline TPI simulation
------------------------------------------------------------------------
'''
ss_outputs['get_baseline'] = get_baseline
income_tax_params, wealth_tax_params, ellipse_params, parameters, N_tilde, omega_stationary, K0, b_sinit, \
b_splus1init, L0, Y0, w0, r0, BQ0, T_H_0, tax0, c0, initial_b, initial_n = TPI.create_tpi_params(**sim_params)
ss_outputs['income_tax_params'] = income_tax_params
ss_outputs['wealth_tax_params'] = wealth_tax_params
ss_outputs['ellipse_params'] = ellipse_params
ss_outputs['parameters'] = parameters
ss_outputs['N_tilde'] = N_tilde
ss_outputs['omega_stationary'] = omega_stationary
ss_outputs['K0'] = K0
ss_outputs['b_sinit'] = b_sinit
ss_outputs['b_splus1init'] = b_splus1init
ss_outputs['L0'] = L0
ss_outputs['Y0'] = Y0
ss_outputs['r0'] = r0
ss_outputs['BQ0'] = BQ0
ss_outputs['T_H_0'] = T_H_0
ss_outputs['tax0'] = tax0
def test_sstpi():
import tempfile
import pickle
import numpy as np
import numpy as np
import pickle as pickle
import os
import ogusa
ogusa.parameters.DATASET = 'REAL'
from ogusa.utils import comp_array
from ogusa.utils import comp_scalar
from ogusa.utils import dict_compare
from ogusa.utils import pickle_file_compare
import ogusa.SS
import ogusa.TPI
from ogusa import parameters, wealth, labor, demographics, income, SS, TPI
globals().update(ogusa.parameters.get_parameters())
# Generate Wealth data moments
output_dir = TEST_OUTPUT
input_dir = "./OUTPUT"
wealth.get_wealth_data(lambdas, J, flag_graphs, output_dir)
# Generate labor data moments
labor.labor_data_moments(flag_graphs, output_dir=output_dir)
get_baseline = True
calibrate_model = False
# List of parameter names that will not be changing (unless we decide to
# change them for a tax experiment)
param_names = [
'S', 'J', 'T', 'lambdas', 'starting_age', 'ending_age', 'beta',
'sigma', 'alpha', 'nu', 'Z', 'delta', 'E', 'ltilde', 'g_y', 'maxiter',
'mindist_SS', 'mindist_TPI', 'b_ellipse', 'k_ellipse', 'upsilon',
'a_tax_income', 'chi_b_guess', 'chi_n_guess', 'b_tax_income',
'c_tax_income', 'd_tax_income', 'tau_payroll', 'tau_bq',
'calibrate_model', 'retire', 'mean_income_data', 'g_n_vector',
'h_wealth', 'p_wealth', 'm_wealth', 'get_baseline', 'omega', 'g_n_ss',
'omega_SS', 'surv_rate', 'e', 'rho'
]
'''
------------------------------------------------------------------------
Run SS with minimization to fit chi_b and chi_n
------------------------------------------------------------------------
'''
# This is the simulation before getting the replacement rate values
sim_params = {}
for key in param_names:
try:
sim_params[key] = locals()[key]
except KeyError:
sim_params[key] = globals()[key]
sim_params['output_dir'] = output_dir
sim_params['input_dir'] = input_dir
income_tax_params, wealth_tax_params, ellipse_params, ss_parameters, \
iterative_params = SS.create_steady_state_parameters(**sim_params)
ss_outputs = SS.run_steady_state(ss_parameters,
iterative_params,
get_baseline,
calibrate_model,
output_dir=output_dir)
'''
------------------------------------------------------------------------
Run the baseline TPI simulation
------------------------------------------------------------------------
'''
ss_outputs['get_baseline'] = get_baseline
income_tax_params, wealth_tax_params, ellipse_params, parameters, N_tilde, omega_stationary, K0, b_sinit, \
b_splus1init, L0, Y0, w0, r0, BQ0, T_H_0, tax0, c0, initial_b, initial_n = TPI.create_tpi_params(
**sim_params)
ss_outputs['output_dir'] = output_dir
ss_outputs['income_tax_params'] = income_tax_params
ss_outputs['wealth_tax_params'] = wealth_tax_params
ss_outputs['ellipse_params'] = ellipse_params
ss_outputs['parameters'] = parameters
ss_outputs['N_tilde'] = N_tilde
ss_outputs['omega_stationary'] = omega_stationary
ss_outputs['K0'] = K0
ss_outputs['b_sinit'] = b_sinit
ss_outputs['b_splus1init'] = b_splus1init
ss_outputs['L0'] = L0
ss_outputs['Y0'] = Y0
ss_outputs['r0'] = r0
ss_outputs['BQ0'] = BQ0
ss_outputs['T_H_0'] = T_H_0
ss_outputs['tax0'] = tax0
ss_outputs['c0'] = c0
ss_outputs['initial_b'] = initial_b
ss_outputs['initial_n'] = initial_n
ss_outputs['tau_bq'] = tau_bq
ss_outputs['g_n_vector'] = g_n_vector
TPI.run_time_path_iteration(**ss_outputs)
# Platform specific exceptions:
if sys.platform == "darwin":
exceptions = {
'tax_path': 0.08,
'c_path': 0.02,
'b_mat': 0.0017,
'solutions': 0.005
}
else:
exceptions = {}
# compare results to test data
for old, new in zip(oldfiles, newfiles):
print("trying a pair")
print(old, new)
assert pickle_file_compare(old,
new,
exceptions=exceptions,
relative=True)
print("next pair")
def runner(output_base, baseline_dir, baseline=False, analytical_mtrs=True, age_specific=False, reform={}, user_params={}, guid='', run_micro=True):
#from ogusa import parameters, wealth, labor, demographics, income
from ogusa import parameters, wealth, labor, demog, income, utils
from ogusa import txfunc
tick = time.time()
#Create output directory structure
saved_moments_dir = os.path.join(output_base, "Saved_moments")
ssinit_dir = os.path.join(output_base, "SSinit")
tpiinit_dir = os.path.join(output_base, "TPIinit")
dirs = [saved_moments_dir, ssinit_dir, tpiinit_dir]
for _dir in dirs:
try:
print "making dir: ", _dir
os.makedirs(_dir)
except OSError as oe:
pass
if run_micro:
txfunc.get_tax_func_estimate(baseline=baseline, analytical_mtrs=analytical_mtrs, age_specific=age_specific,
start_year=user_params['start_year'], reform=reform, guid=guid)
print ("in runner, baseline is ", baseline)
run_params = ogusa.parameters.get_parameters(baseline=baseline, guid=guid)
run_params['analytical_mtrs'] = analytical_mtrs
# Modify ogusa parameters based on user input
if 'frisch' in user_params:
print "updating fricsh and associated"
b_ellipse, upsilon = ogusa.elliptical_u_est.estimation(user_params['frisch'],
run_params['ltilde'])
run_params['b_ellipse'] = b_ellipse
run_params['upsilon'] = upsilon
run_params.update(user_params)
# Modify ogusa parameters based on user input
if 'g_y_annual' in user_params:
print "updating g_y_annual and associated"
g_y = (1 + user_params['g_y_annual'])**(float(ending_age - starting_age) / S) - 1
run_params['g_y'] = g_y
run_params.update(user_params)
from ogusa import SS, TPI
# Generate Wealth data moments
wealth.get_wealth_data(run_params['lambdas'], run_params['J'], run_params['flag_graphs'], output_dir=output_base)
# Generate labor data moments
labor.labor_data_moments(run_params['flag_graphs'], output_dir=output_base)
calibrate_model = False
# List of parameter names that will not be changing (unless we decide to
# change them for a tax experiment)
param_names = ['S', 'J', 'T', 'BW', 'lambdas', 'starting_age', 'ending_age',
'beta', 'sigma', 'alpha', 'nu', 'Z', 'delta', 'E',
'ltilde', 'g_y', 'maxiter', 'mindist_SS', 'mindist_TPI',
'analytical_mtrs', 'b_ellipse', 'k_ellipse', 'upsilon',
'chi_b_guess', 'chi_n_guess','etr_params','mtrx_params',
'mtry_params','tau_payroll', 'tau_bq',
'retire', 'mean_income_data', 'g_n_vector',
'h_wealth', 'p_wealth', 'm_wealth',
'omega', 'g_n_ss', 'omega_SS', 'surv_rate', 'e', 'rho']
'''
------------------------------------------------------------------------
Run SS
------------------------------------------------------------------------
'''
sim_params = {}
for key in param_names:
sim_params[key] = run_params[key]
sim_params['output_dir'] = output_base
sim_params['run_params'] = run_params
income_tax_params, ss_parameters, iterative_params, chi_params = SS.create_steady_state_parameters(**sim_params)
ss_outputs = SS.run_SS(income_tax_params, ss_parameters, iterative_params, chi_params, baseline,
baseline_dir=baseline_dir)
'''
------------------------------------------------------------------------
Pickle SS results
------------------------------------------------------------------------
'''
if baseline:
utils.mkdirs(os.path.join(baseline_dir, "SS"))
ss_dir = os.path.join(baseline_dir, "SS/ss_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
else:
utils.mkdirs(os.path.join(output_dir, "SS"))
ss_dir = os.path.join(output_dir, "SS/ss_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
'''
------------------------------------------------------------------------
Run the baseline TPI simulation
------------------------------------------------------------------------
'''
sim_params['input_dir'] = output_base
sim_params['baseline_dir'] = baseline_dir
income_tax_params, tpi_params, iterative_params, initial_values, SS_values = TPI.create_tpi_params(**sim_params)
# ss_outputs['income_tax_params'] = income_tax_params
# ss_outputs['wealth_tax_params'] = wealth_tax_params
# ss_outputs['ellipse_params'] = ellipse_params
# ss_outputs['parameters'] = parameters
# ss_outputs['N_tilde'] = N_tilde
# ss_outputs['omega_stationary'] = omega_stationary
# ss_outputs['K0'] = K0
# ss_outputs['b_sinit'] = b_sinit
# ss_outputs['b_splus1init'] = b_splus1init
# ss_outputs['L0'] = L0
# ss_outputs['Y0'] = Y0
# ss_outputs['r0'] = r0
# ss_outputs['BQ0'] = BQ0
# ss_outputs['T_H_0'] = T_H_0
# ss_outputs['factor_ss'] = factor
# ss_outputs['tax0'] = tax0
# ss_outputs['c0'] = c0
# ss_outputs['initial_b'] = initial_b
# ss_outputs['initial_n'] = initial_n
# ss_outputs['tau_bq'] = tau_bq
# ss_outputs['g_n_vector'] = g_n_vector
# ss_outputs['output_dir'] = output_base
# with open("ss_outputs.pkl", 'wb') as fp:
# pickle.dump(ss_outputs, fp)
w_path, r_path, T_H_path, BQ_path, Y_path = TPI.run_TPI(income_tax_params,
tpi_params, iterative_params, initial_values, SS_values, output_dir=output_base)
print "getting to here...."
TPI.TP_solutions(w_path, r_path, T_H_path, BQ_path, **ss_outputs)
print "took {0} seconds to get that part done.".format(time.time() - tick)
def runner(output_base, input_dir, baseline=False, analytical_mtrs=True, age_specific=False, reform={}, user_params={}, guid='', run_micro=True):
from ogusa import parameters, wealth, labor, demographics, income
from ogusa import txfunc
tick = time.time()
#Create output directory structure
saved_moments_dir = os.path.join(output_base, "Saved_moments")
ssinit_dir = os.path.join(output_base, "SSinit")
tpiinit_dir = os.path.join(output_base, "TPIinit")
dirs = [saved_moments_dir, ssinit_dir, tpiinit_dir]
for _dir in dirs:
try:
print "making dir: ", _dir
os.makedirs(_dir)
except OSError as oe:
pass
if run_micro:
txfunc.get_tax_func_estimate(baseline=baseline, analytical_mtrs=analytical_mtrs, age_specific=age_specific, reform=reform, guid=guid)
print ("in runner, baseline is ", baseline)
run_params = ogusa.parameters.get_parameters(baseline=baseline, guid=guid)
run_params['analytical_mtrs'] = analytical_mtrs
# Modify ogusa parameters based on user input
if 'frisch' in user_params:
print "updating fricsh and associated"
b_ellipse, upsilon = ogusa.elliptical_u_est.estimation(user_params['frisch'],
run_params['ltilde'])
run_params['b_ellipse'] = b_ellipse
run_params['upsilon'] = upsilon
run_params.update(user_params)
# Modify ogusa parameters based on user input
if 'g_y_annual' in user_params:
print "updating g_y_annual and associated"
g_y = (1 + user_params['g_y_annual'])**(float(ending_age - starting_age) / S) - 1
run_params['g_y'] = g_y
run_params.update(user_params)
globals().update(run_params)
from ogusa import SS, TPI
# Generate Wealth data moments
wealth.get_wealth_data(lambdas, J, flag_graphs, output_dir=input_dir)
# Generate labor data moments
labor.labor_data_moments(flag_graphs, output_dir=input_dir)
get_baseline = True
calibrate_model = False
# List of parameter names that will not be changing (unless we decide to
# change them for a tax experiment)
param_names = ['S', 'J', 'T', 'BW', 'lambdas', 'starting_age', 'ending_age',
'beta', 'sigma', 'alpha', 'nu', 'Z', 'delta', 'E',
'ltilde', 'g_y', 'maxiter', 'mindist_SS', 'mindist_TPI',
'analytical_mtrs', 'b_ellipse', 'k_ellipse', 'upsilon',
'chi_b_guess', 'chi_n_guess','etr_params','mtrx_params',
'mtry_params','tau_payroll', 'tau_bq', 'calibrate_model',
'retire', 'mean_income_data', 'g_n_vector',
'h_wealth', 'p_wealth', 'm_wealth', 'get_baseline',
'omega', 'g_n_ss', 'omega_SS', 'surv_rate', 'e', 'rho']
'''
------------------------------------------------------------------------
Run SS with minimization to fit chi_b and chi_n
------------------------------------------------------------------------
'''
# This is the simulation before getting the replacement rate values
sim_params = {}
glbs = globals()
lcls = locals()
for key in param_names:
if key in glbs:
sim_params[key] = glbs[key]
else:
sim_params[key] = lcls[key]
sim_params['output_dir'] = input_dir
sim_params['run_params'] = run_params
income_tax_params, wealth_tax_params, ellipse_params, ss_parameters, iterative_params = SS.create_steady_state_parameters(**sim_params)
ss_outputs = SS.run_steady_state(income_tax_params, ss_parameters, iterative_params, get_baseline, calibrate_model, output_dir=input_dir)
'''
------------------------------------------------------------------------
Run the baseline TPI simulation
------------------------------------------------------------------------
'''
ss_outputs['get_baseline'] = get_baseline
sim_params['input_dir'] = input_dir
income_tax_params, wealth_tax_params, ellipse_params, parameters, N_tilde, omega_stationary, K0, b_sinit, \
b_splus1init, L0, Y0, w0, r0, BQ0, T_H_0, tax0, c0, initial_b, initial_n = TPI.create_tpi_params(**sim_params)
ss_outputs['income_tax_params'] = income_tax_params
ss_outputs['wealth_tax_params'] = wealth_tax_params
ss_outputs['ellipse_params'] = ellipse_params
ss_outputs['parameters'] = parameters
ss_outputs['N_tilde'] = N_tilde
ss_outputs['omega_stationary'] = omega_stationary
ss_outputs['K0'] = K0
ss_outputs['b_sinit'] = b_sinit
ss_outputs['b_splus1init'] = b_splus1init
ss_outputs['L0'] = L0
ss_outputs['Y0'] = Y0
ss_outputs['r0'] = r0
ss_outputs['BQ0'] = BQ0
ss_outputs['T_H_0'] = T_H_0
ss_outputs['tax0'] = tax0
ss_outputs['c0'] = c0
ss_outputs['initial_b'] = initial_b
ss_outputs['initial_n'] = initial_n
ss_outputs['tau_bq'] = tau_bq
ss_outputs['g_n_vector'] = g_n_vector
ss_outputs['output_dir'] = input_dir
with open("ss_outputs.pkl", 'wb') as fp:
pickle.dump(ss_outputs, fp)
w_path, r_path, T_H_path, BQ_path, Y_path = TPI.run_time_path_iteration(**ss_outputs)
print "getting to here...."
TPI.TP_solutions(w_path, r_path, T_H_path, BQ_path, **ss_outputs)
print "took {0} seconds to get that part done.".format(time.time() - tick)
def runner(output_base,
baseline_dir,
baseline=False,
analytical_mtrs=True,
age_specific=False,
reform={},
user_params={},
guid='',
run_micro=True):
#from ogusa import parameters, wealth, labor, demographics, income
from ogusa import parameters, demog, income, utils
from ogusa import txfunc
tick = time.time()
#Create output directory structure
saved_moments_dir = os.path.join(output_base, "Saved_moments")
ss_dir = os.path.join(output_base, "SS")
tpi_dir = os.path.join(output_base, "TPI")
dirs = [saved_moments_dir, ss_dir, tpi_dir]
for _dir in dirs:
try:
print "making dir: ", _dir
os.makedirs(_dir)
except OSError as oe:
pass
if run_micro:
txfunc.get_tax_func_estimate(baseline=baseline,
analytical_mtrs=analytical_mtrs,
age_specific=age_specific,
start_year=user_params['start_year'],
reform=reform,
guid=guid)
print("in runner, baseline is ", baseline)
run_params = ogusa.parameters.get_parameters(baseline=baseline, guid=guid)
run_params['analytical_mtrs'] = analytical_mtrs
# Modify ogusa parameters based on user input
if 'frisch' in user_params:
print "updating fricsh and associated"
b_ellipse, upsilon = ogusa.elliptical_u_est.estimation(
user_params['frisch'], run_params['ltilde'])
run_params['b_ellipse'] = b_ellipse
run_params['upsilon'] = upsilon
run_params.update(user_params)
# Modify ogusa parameters based on user input
if 'g_y_annual' in user_params:
print "updating g_y_annual and associated"
g_y = (1 + user_params['g_y_annual'])**(
float(ending_age - starting_age) / S) - 1
run_params['g_y'] = g_y
run_params.update(user_params)
from ogusa import SS, TPI
calibrate_model = False
# List of parameter names that will not be changing (unless we decide to
# change them for a tax experiment)
param_names = [
'S', 'J', 'T', 'BW', 'lambdas', 'starting_age', 'ending_age', 'beta',
'sigma', 'alpha', 'nu', 'Z', 'delta', 'E', 'ltilde', 'g_y', 'maxiter',
'mindist_SS', 'mindist_TPI', 'analytical_mtrs', 'b_ellipse',
'k_ellipse', 'upsilon', 'chi_b_guess', 'chi_n_guess', 'etr_params',
'mtrx_params', 'mtry_params', 'tau_payroll', 'tau_bq', 'retire',
'mean_income_data', 'g_n_vector', 'h_wealth', 'p_wealth', 'm_wealth',
'omega', 'g_n_ss', 'omega_SS', 'surv_rate', 'e', 'rho'
]
'''
------------------------------------------------------------------------
Run SS
------------------------------------------------------------------------
'''
sim_params = {}
for key in param_names:
sim_params[key] = run_params[key]
sim_params['output_dir'] = output_base
sim_params['run_params'] = run_params
income_tax_params, ss_parameters, iterative_params, chi_params = SS.create_steady_state_parameters(
**sim_params)
ss_outputs = SS.run_SS(income_tax_params,
ss_parameters,
iterative_params,
chi_params,
baseline,
baseline_dir=baseline_dir)
'''
------------------------------------------------------------------------
Pickle SS results
------------------------------------------------------------------------
'''
if baseline:
utils.mkdirs(os.path.join(baseline_dir, "SS"))
ss_dir = os.path.join(baseline_dir, "SS/SS_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
else:
utils.mkdirs(os.path.join(output_base, "SS"))
ss_dir = os.path.join(output_base, "SS/SS_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
'''
------------------------------------------------------------------------
Run the TPI simulation
------------------------------------------------------------------------
'''
sim_params['input_dir'] = output_base
sim_params['baseline_dir'] = baseline_dir
income_tax_params, tpi_params, iterative_params, initial_values, SS_values = TPI.create_tpi_params(
**sim_params)
tpi_output, macro_output = TPI.run_TPI(income_tax_params,
tpi_params,
iterative_params,
initial_values,
SS_values,
output_dir=output_base)
'''
------------------------------------------------------------------------
Pickle TPI results
------------------------------------------------------------------------
'''
tpi_dir = os.path.join(output_base, "TPI")
utils.mkdirs(tpi_dir)
tpi_vars = os.path.join(tpi_dir, "TPI_vars.pkl")
pickle.dump(tpi_output, open(tpi_vars, "wb"))
tpi_dir = os.path.join(output_base, "TPI")
utils.mkdirs(tpi_dir)
tpi_vars = os.path.join(tpi_dir, "TPI_macro_vars.pkl")
pickle.dump(macro_output, open(tpi_vars, "wb"))
print "Time path iteration complete. It"
print "took {0} seconds to get that part done.".format(time.time() - tick)
def runner(output_base,
baseline_dir,
baseline=False,
analytical_mtrs=True,
age_specific=False,
reform={},
user_params={},
guid='',
run_micro=True):
#from ogusa import parameters, wealth, labor, demographics, income
from ogusa import parameters, wealth, labor, demog, income, utils
from ogusa import txfunc
tick = time.time()
#Create output directory structure
saved_moments_dir = os.path.join(output_base, "Saved_moments")
ssinit_dir = os.path.join(output_base, "SSinit")
tpiinit_dir = os.path.join(output_base, "TPIinit")
dirs = [saved_moments_dir, ssinit_dir, tpiinit_dir]
for _dir in dirs:
try:
print "making dir: ", _dir
os.makedirs(_dir)
except OSError as oe:
pass
if run_micro:
txfunc.get_tax_func_estimate(baseline=baseline,
analytical_mtrs=analytical_mtrs,
age_specific=age_specific,
start_year=user_params['start_year'],
reform=reform,
guid=guid)
print("in runner, baseline is ", baseline)
run_params = ogusa.parameters.get_parameters(baseline=baseline, guid=guid)
run_params['analytical_mtrs'] = analytical_mtrs
# Modify ogusa parameters based on user input
if 'frisch' in user_params:
print "updating fricsh and associated"
b_ellipse, upsilon = ogusa.elliptical_u_est.estimation(
user_params['frisch'], run_params['ltilde'])
run_params['b_ellipse'] = b_ellipse
run_params['upsilon'] = upsilon
run_params.update(user_params)
# Modify ogusa parameters based on user input
if 'g_y_annual' in user_params:
print "updating g_y_annual and associated"
g_y = (1 + user_params['g_y_annual'])**(
float(ending_age - starting_age) / S) - 1
run_params['g_y'] = g_y
run_params.update(user_params)
from ogusa import SS, TPI
# Generate Wealth data moments
wealth.get_wealth_data(run_params['lambdas'],
run_params['J'],
run_params['flag_graphs'],
output_dir=output_base)
# Generate labor data moments
labor.labor_data_moments(run_params['flag_graphs'], output_dir=output_base)
calibrate_model = False
# List of parameter names that will not be changing (unless we decide to
# change them for a tax experiment)
param_names = [
'S', 'J', 'T', 'BW', 'lambdas', 'starting_age', 'ending_age', 'beta',
'sigma', 'alpha', 'nu', 'Z', 'delta', 'E', 'ltilde', 'g_y', 'maxiter',
'mindist_SS', 'mindist_TPI', 'analytical_mtrs', 'b_ellipse',
'k_ellipse', 'upsilon', 'chi_b_guess', 'chi_n_guess', 'etr_params',
'mtrx_params', 'mtry_params', 'tau_payroll', 'tau_bq', 'retire',
'mean_income_data', 'g_n_vector', 'h_wealth', 'p_wealth', 'm_wealth',
'omega', 'g_n_ss', 'omega_SS', 'surv_rate', 'e', 'rho'
]
'''
------------------------------------------------------------------------
Run SS
------------------------------------------------------------------------
'''
sim_params = {}
for key in param_names:
sim_params[key] = run_params[key]
sim_params['output_dir'] = output_base
sim_params['run_params'] = run_params
income_tax_params, ss_parameters, iterative_params, chi_params = SS.create_steady_state_parameters(
**sim_params)
ss_outputs = SS.run_SS(income_tax_params,
ss_parameters,
iterative_params,
chi_params,
baseline,
baseline_dir=baseline_dir)
'''
------------------------------------------------------------------------
Pickle SS results
------------------------------------------------------------------------
'''
if baseline:
utils.mkdirs(os.path.join(baseline_dir, "SS"))
ss_dir = os.path.join(baseline_dir, "SS/ss_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
else:
utils.mkdirs(os.path.join(output_dir, "SS"))
ss_dir = os.path.join(output_dir, "SS/ss_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
'''
------------------------------------------------------------------------
Run the baseline TPI simulation
------------------------------------------------------------------------
'''
sim_params['input_dir'] = output_base
sim_params['baseline_dir'] = baseline_dir
income_tax_params, tpi_params, iterative_params, initial_values, SS_values = TPI.create_tpi_params(
**sim_params)
# ss_outputs['income_tax_params'] = income_tax_params
# ss_outputs['wealth_tax_params'] = wealth_tax_params
# ss_outputs['ellipse_params'] = ellipse_params
# ss_outputs['parameters'] = parameters
# ss_outputs['N_tilde'] = N_tilde
# ss_outputs['omega_stationary'] = omega_stationary
# ss_outputs['K0'] = K0
# ss_outputs['b_sinit'] = b_sinit
# ss_outputs['b_splus1init'] = b_splus1init
# ss_outputs['L0'] = L0
# ss_outputs['Y0'] = Y0
# ss_outputs['r0'] = r0
# ss_outputs['BQ0'] = BQ0
# ss_outputs['T_H_0'] = T_H_0
# ss_outputs['factor_ss'] = factor
# ss_outputs['tax0'] = tax0
# ss_outputs['c0'] = c0
# ss_outputs['initial_b'] = initial_b
# ss_outputs['initial_n'] = initial_n
# ss_outputs['tau_bq'] = tau_bq
# ss_outputs['g_n_vector'] = g_n_vector
# ss_outputs['output_dir'] = output_base
# with open("ss_outputs.pkl", 'wb') as fp:
# pickle.dump(ss_outputs, fp)
w_path, r_path, T_H_path, BQ_path, Y_path = TPI.run_TPI(
income_tax_params,
tpi_params,
iterative_params,
initial_values,
SS_values,
output_dir=output_base)
print "getting to here...."
TPI.TP_solutions(w_path, r_path, T_H_path, BQ_path, **ss_outputs)
print "took {0} seconds to get that part done.".format(time.time() - tick)
def runner(
output_base,
baseline_dir,
baseline=False,
analytical_mtrs=False,
age_specific=False,
reform={},
user_params={},
guid="",
run_micro=True,
):
# from ogusa import parameters, wealth, labor, demographics, income
from ogusa import parameters, demographics, income, utils
from ogusa import txfunc
tick = time.time()
# Create output directory structure
saved_moments_dir = os.path.join(output_base, "Saved_moments")
ss_dir = os.path.join(output_base, "SS")
tpi_dir = os.path.join(output_base, "TPI")
dirs = [saved_moments_dir, ss_dir, tpi_dir]
for _dir in dirs:
try:
print "making dir: ", _dir
os.makedirs(_dir)
except OSError as oe:
pass
if run_micro:
txfunc.get_tax_func_estimate(
baseline=baseline,
analytical_mtrs=analytical_mtrs,
age_specific=age_specific,
start_year=user_params["start_year"],
reform=reform,
guid=guid,
)
print ("in runner, baseline is ", baseline)
run_params = ogusa.parameters.get_parameters(baseline=baseline, guid=guid)
run_params["analytical_mtrs"] = analytical_mtrs
# Modify ogusa parameters based on user input
if "frisch" in user_params:
print "updating fricsh and associated"
b_ellipse, upsilon = ogusa.elliptical_u_est.estimation(user_params["frisch"], run_params["ltilde"])
run_params["b_ellipse"] = b_ellipse
run_params["upsilon"] = upsilon
run_params.update(user_params)
# Modify ogusa parameters based on user input
if "g_y_annual" in user_params:
print "updating g_y_annual and associated"
ending_age = run_params["ending_age"]
starting_age = run_params["starting_age"]
S = run_params["S"]
g_y = (1 + user_params["g_y_annual"]) ** (float(ending_age - starting_age) / S) - 1
run_params["g_y"] = g_y
run_params.update(user_params)
from ogusa import SS, TPI
calibrate_model = False
# List of parameter names that will not be changing (unless we decide to
# change them for a tax experiment)
param_names = [
"S",
"J",
"T",
"BW",
"lambdas",
"starting_age",
"ending_age",
"beta",
"sigma",
"alpha",
"nu",
"Z",
"delta",
"E",
"ltilde",
"g_y",
"maxiter",
"mindist_SS",
"mindist_TPI",
"analytical_mtrs",
"b_ellipse",
"k_ellipse",
"upsilon",
"chi_b_guess",
"chi_n_guess",
"etr_params",
"mtrx_params",
"mtry_params",
"tau_payroll",
"tau_bq",
"retire",
"mean_income_data",
"g_n_vector",
"h_wealth",
"p_wealth",
"m_wealth",
"omega",
"g_n_ss",
"omega_SS",
"surv_rate",
"imm_rates",
"e",
"rho",
"omega_S_preTP",
]
"""
------------------------------------------------------------------------
Run SS
------------------------------------------------------------------------
"""
sim_params = {}
for key in param_names:
sim_params[key] = run_params[key]
sim_params["output_dir"] = output_base
sim_params["run_params"] = run_params
income_tax_params, ss_parameters, iterative_params, chi_params = SS.create_steady_state_parameters(**sim_params)
ss_outputs = SS.run_SS(
income_tax_params, ss_parameters, iterative_params, chi_params, baseline, baseline_dir=baseline_dir
)
"""
------------------------------------------------------------------------
Pickle SS results
------------------------------------------------------------------------
"""
if baseline:
utils.mkdirs(os.path.join(baseline_dir, "SS"))
ss_dir = os.path.join(baseline_dir, "SS/SS_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
else:
utils.mkdirs(os.path.join(output_base, "SS"))
ss_dir = os.path.join(output_base, "SS/SS_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
"""
------------------------------------------------------------------------
Run the TPI simulation
------------------------------------------------------------------------
"""
sim_params["baseline"] = baseline
sim_params["input_dir"] = output_base
sim_params["baseline_dir"] = baseline_dir
income_tax_params, tpi_params, iterative_params, initial_values, SS_values = TPI.create_tpi_params(**sim_params)
tpi_output, macro_output = TPI.run_TPI(
income_tax_params, tpi_params, iterative_params, initial_values, SS_values, output_dir=output_base
)
"""
------------------------------------------------------------------------
Pickle TPI results
------------------------------------------------------------------------
"""
tpi_dir = os.path.join(output_base, "TPI")
utils.mkdirs(tpi_dir)
tpi_vars = os.path.join(tpi_dir, "TPI_vars.pkl")
pickle.dump(tpi_output, open(tpi_vars, "wb"))
tpi_dir = os.path.join(output_base, "TPI")
utils.mkdirs(tpi_dir)
tpi_vars = os.path.join(tpi_dir, "TPI_macro_vars.pkl")
pickle.dump(macro_output, open(tpi_vars, "wb"))
print "Time path iteration complete. It"
print "took {0} seconds to get that part done.".format(time.time() - tick)
def runner(output_base, baseline_dir, test=False, time_path=True, baseline=False,
analytical_mtrs=False, age_specific=False, reform={}, user_params={},
guid='', run_micro=True, small_open=False, budget_balance=False, baseline_spending=False):
#from ogusa import parameters, wealth, labor, demographics, income
from ogusa import parameters, demographics, income, utils
from ogusa import txfunc
tick = time.time()
# Make sure options are internally consistent
if baseline==True and baseline_spending==True:
print 'Inconsistent options. Setting <baseline_spending> to False, leaving <baseline> True.'
baseline_spending = False
if budget_balance==True and baseline_spending==True:
print 'Inconsistent options. Setting <baseline_spending> to False, leaving <budget_balance> True.'
baseline_spending = False
#Create output directory structure
saved_moments_dir = os.path.join(output_base, "Saved_moments")
ss_dir = os.path.join(output_base, "SS")
tpi_dir = os.path.join(output_base, "TPI")
dirs = [saved_moments_dir, ss_dir, tpi_dir]
for _dir in dirs:
try:
print "making dir: ", _dir
os.makedirs(_dir)
except OSError as oe:
pass
if run_micro:
txfunc.get_tax_func_estimate(baseline=baseline, analytical_mtrs=analytical_mtrs, age_specific=age_specific,
start_year=user_params['start_year'], reform=reform, guid=guid)
print 'In runner, baseline is ', baseline
run_params = ogusa.parameters.get_parameters(test=test, baseline=baseline, guid=guid)
run_params['analytical_mtrs'] = analytical_mtrs
run_params['small_open'] = small_open
run_params['budget_balance'] = budget_balance
# Modify ogusa parameters based on user input
if 'frisch' in user_params:
print "updating frisch and associated"
b_ellipse, upsilon = ogusa.elliptical_u_est.estimation(user_params['frisch'],
run_params['ltilde'])
run_params['b_ellipse'] = b_ellipse
run_params['upsilon'] = upsilon
run_params.update(user_params)
if 'debt_ratio_ss' in user_params:
run_params['debt_ratio_ss']=user_params['debt_ratio_ss']
# Modify ogusa parameters based on user input
if 'g_y_annual' in user_params:
print "updating g_y_annual and associated"
ending_age = run_params['ending_age']
starting_age = run_params['starting_age']
S = run_params['S']
g_y = (1 + user_params['g_y_annual'])**(float(ending_age - starting_age) / S) - 1
run_params['g_y'] = g_y
run_params.update(user_params)
# Modify transfer & spending ratios based on user input.
if 'T_shifts' in user_params:
if baseline_spending==False:
print 'updating ALPHA_T with T_shifts in first', user_params['T_shifts'].size, 'periods.'
T_shifts = np.concatenate((user_params['T_shifts'], np.zeros(run_params['ALPHA_T'].size - user_params['T_shifts'].size)), axis=0)
run_params['ALPHA_T'] = run_params['ALPHA_T'] + T_shifts
if 'G_shifts' in user_params:
if baseline_spending==False:
print 'updating ALPHA_G with G_shifts in first', user_params['G_shifts'].size, 'periods.'
G_shifts = np.concatenate((user_params['G_shifts'], np.zeros(run_params['ALPHA_G'].size - user_params['G_shifts'].size)), axis=0)
run_params['ALPHA_G'] = run_params['ALPHA_G'] + G_shifts
from ogusa import SS, TPI
calibrate_model = False
# List of parameter names that will not be changing (unless we decide to
# change them for a tax experiment)
param_names = ['S', 'J', 'T', 'BW', 'lambdas', 'starting_age', 'ending_age',
'beta', 'sigma', 'alpha', 'gamma', 'epsilon', 'nu', 'Z', 'delta', 'E',
'ltilde', 'g_y', 'maxiter', 'mindist_SS', 'mindist_TPI',
'analytical_mtrs', 'b_ellipse', 'k_ellipse', 'upsilon',
'small_open', 'budget_balance', 'ss_firm_r', 'ss_hh_r', 'tpi_firm_r', 'tpi_hh_r',
'tG1', 'tG2', 'alpha_T', 'alpha_G', 'ALPHA_T', 'ALPHA_G', 'rho_G', 'debt_ratio_ss',
'tau_b', 'delta_tau',
'chi_b_guess', 'chi_n_guess','etr_params','mtrx_params',
'mtry_params','tau_payroll', 'tau_bq',
'retire', 'mean_income_data', 'g_n_vector',
'h_wealth', 'p_wealth', 'm_wealth',
'omega', 'g_n_ss', 'omega_SS', 'surv_rate', 'imm_rates','e', 'rho',
'initial_debt','omega_S_preTP']
'''
------------------------------------------------------------------------
Run SS
------------------------------------------------------------------------
'''
sim_params = {}
for key in param_names:
sim_params[key] = run_params[key]
sim_params['output_dir'] = output_base
sim_params['run_params'] = run_params
income_tax_params, ss_parameters, iterative_params, chi_params, small_open_params = SS.create_steady_state_parameters(**sim_params)
ss_outputs = SS.run_SS(income_tax_params, ss_parameters, iterative_params, chi_params, small_open_params, baseline, baseline_spending,
baseline_dir=baseline_dir)
'''
------------------------------------------------------------------------
Pickle SS results
------------------------------------------------------------------------
'''
if baseline:
utils.mkdirs(os.path.join(baseline_dir, "SS"))
ss_dir = os.path.join(baseline_dir, "SS/SS_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
else:
utils.mkdirs(os.path.join(output_base, "SS"))
ss_dir = os.path.join(output_base, "SS/SS_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
if time_path:
'''
------------------------------------------------------------------------
Run the TPI simulation
------------------------------------------------------------------------
'''
sim_params['baseline'] = baseline
sim_params['baseline_spending'] = baseline_spending
sim_params['input_dir'] = output_base
sim_params['baseline_dir'] = baseline_dir
income_tax_params, tpi_params, iterative_params, small_open_params, initial_values, SS_values, fiscal_params, biz_tax_params = TPI.create_tpi_params(**sim_params)
tpi_output, macro_output = TPI.run_TPI(income_tax_params, tpi_params, iterative_params, small_open_params, initial_values,
SS_values, fiscal_params, biz_tax_params, output_dir=output_base, baseline_spending=baseline_spending)
'''
------------------------------------------------------------------------
Pickle TPI results
------------------------------------------------------------------------
'''
tpi_dir = os.path.join(output_base, "TPI")
utils.mkdirs(tpi_dir)
tpi_vars = os.path.join(tpi_dir, "TPI_vars.pkl")
pickle.dump(tpi_output, open(tpi_vars, "wb"))
tpi_dir = os.path.join(output_base, "TPI")
utils.mkdirs(tpi_dir)
tpi_vars = os.path.join(tpi_dir, "TPI_macro_vars.pkl")
pickle.dump(macro_output, open(tpi_vars, "wb"))
print "Time path iteration complete."
print "It took {0} seconds to get that part done.".format(time.time() - tick)
def runner(output_base,
baseline_dir,
baseline=False,
analytical_mtrs=True,
age_specific=False,
reform=0,
fix_transfers=False,
user_params={},
guid='',
run_micro=True,
calibrate_model=False):
from ogusa import parameters, demographics, income, utils
tick = time.time()
#Create output directory structure
saved_moments_dir = os.path.join(output_base, "Saved_moments")
ss_dir = os.path.join(output_base, "SS")
tpi_dir = os.path.join(output_base, "TPI")
dirs = [saved_moments_dir, ss_dir, tpi_dir]
for _dir in dirs:
try:
print "making dir: ", _dir
os.makedirs(_dir)
except OSError as oe:
pass
print("in runner, baseline is ", baseline)
run_params = ogusa.parameters.get_parameters(baseline=baseline,
reform=reform,
guid=guid,
user_modifiable=True)
run_params['analytical_mtrs'] = analytical_mtrs
# Modify ogusa parameters based on user input
if 'frisch' in user_params:
print "updating fricsh and associated"
b_ellipse, upsilon = ogusa.elliptical_u_est.estimation(
user_params['frisch'], run_params['ltilde'])
run_params['b_ellipse'] = b_ellipse
run_params['upsilon'] = upsilon
run_params.update(user_params)
# Modify ogusa parameters based on user input
if 'sigma' in user_params:
print "updating sigma"
run_params['sigma'] = user_params['sigma']
run_params.update(user_params)
from ogusa import SS, TPI
calibrate_model = False
# List of parameter names that will not be changing (unless we decide to
# change them for a tax experiment)
param_names = [
'S', 'J', 'T', 'BW', 'lambdas', 'starting_age', 'ending_age', 'beta',
'sigma', 'alpha', 'nu', 'Z', 'delta', 'E', 'ltilde', 'g_y', 'maxiter',
'mindist_SS', 'mindist_TPI', 'analytical_mtrs', 'b_ellipse',
'k_ellipse', 'upsilon', 'chi_b_guess', 'chi_n_guess', 'etr_params',
'mtrx_params', 'mtry_params', 'tau_payroll', 'tau_bq', 'retire',
'mean_income_data', 'g_n_vector', 'h_wealth', 'p_wealth', 'm_wealth',
'omega', 'g_n_ss', 'omega_SS', 'surv_rate', 'imm_rates', 'e', 'rho',
'omega_S_preTP'
]
'''
------------------------------------------------------------------------
If using income tax reform, need to determine parameters that yield
same SS revenue as the wealth tax reform.
------------------------------------------------------------------------
'''
if reform == 1:
sim_params = {}
for key in param_names:
sim_params[key] = run_params[key]
sim_params['output_dir'] = output_base
sim_params['run_params'] = run_params
income_tax_params, ss_params, iterative_params, chi_params = SS.create_steady_state_parameters(
**sim_params)
# find SS revenue from wealth tax reform
reform3_ss_dir = os.path.join(
"./OUTPUT_WEALTH_REFORM" + '/sigma' + str(run_params['sigma']),
"SS/SS_vars.pkl")
reform3_ss_solutions = pickle.load(open(reform3_ss_dir, "rb"))
receipts_to_match = reform3_ss_solutions['net_tax_receipts']
# create function to match SS revenue
# def matcher(d_guess, params):
# income_tax_params, receipts_to_match, ss_params, iterative_params,\
# chi_params, baseline, baseline_dir = params
# analytical_mtrs, etr_params, mtrx_params, mtry_params = income_tax_params
# etr_params[:,3] = d_guess
# mtrx_params[:,3] = d_guess
# mtry_params[:,3] = d_guess
# income_tax_params = analytical_mtrs, etr_params, mtrx_params, mtry_params
# ss_outputs = SS.run_SS(income_tax_params, ss_params, iterative_params,
# chi_params, baseline ,baseline_dir=baseline_dir, output_base=output_base)
#
# receipts_new = ss_outputs['T_Hss'] + ss_outputs['Gss']
# error = abs(receipts_to_match - receipts_new)
# if d_guess <= 0:
# error = 1e14
# print 'Error in taxes:', error
# return error
# print 'Computing new income tax to match wealth tax'
d_guess = 0.413 # initial guess
# import scipy.optimize as opt
# params = [income_tax_params, receipts_to_match, ss_params, iterative_params,
# chi_params, baseline, baseline_dir]
# new_d_inc = opt.fsolve(matcher, d_guess, args=params, xtol=1e-6)
new_d_inc = 0.413 # this value comes out given default parameter values (if fix_transfers=True this is 0.503 if False then 0.453)
print '\tOld income tax:', d_guess
print '\tNew income tax:', new_d_inc
analytical_mtrs, etr_params, mtrx_params, mtry_params = income_tax_params
etr_params[:, 3] = new_d_inc
mtrx_params[:, 3] = new_d_inc
mtry_params[:, 3] = new_d_inc
run_params['etr_params'] = np.tile(
np.reshape(etr_params, (run_params['S'], 1, etr_params.shape[1])),
(1, run_params['BW'], 1))
run_params['mtrx_params'] = np.tile(
np.reshape(mtrx_params,
(run_params['S'], 1, mtrx_params.shape[1])),
(1, run_params['BW'], 1))
run_params['mtry_params'] = np.tile(
np.reshape(mtry_params,
(run_params['S'], 1, mtry_params.shape[1])),
(1, run_params['BW'], 1))
'''
------------------------------------------------------------------------
Run SS
------------------------------------------------------------------------
'''
sim_params = {}
for key in param_names:
sim_params[key] = run_params[key]
sim_params['output_dir'] = output_base
sim_params['run_params'] = run_params
income_tax_params, ss_parameters, iterative_params, chi_params = SS.create_steady_state_parameters(
**sim_params)
analytical_mtrs, etr_params, mtrx_params, mtry_params = income_tax_params
print('ETR param shape = ', etr_params.shape)
ss_outputs = SS.run_SS(income_tax_params,
ss_parameters,
iterative_params,
chi_params,
baseline,
fix_transfers=fix_transfers,
baseline_dir=baseline_dir)
'''
------------------------------------------------------------------------
Pickle SS results and parameters of run
------------------------------------------------------------------------
'''
if baseline:
utils.mkdirs(os.path.join(baseline_dir, "SS"))
ss_dir = os.path.join(baseline_dir, "SS/SS_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
param_dir = os.path.join(baseline_dir, "run_parameters.pkl")
pickle.dump(sim_params, open(param_dir, "wb"))
else:
utils.mkdirs(os.path.join(output_base, "SS"))
ss_dir = os.path.join(output_base, "SS/SS_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
param_dir = os.path.join(output_base, "run_parameters.pkl")
pickle.dump(sim_params, open(param_dir, "wb"))
'''
------------------------------------------------------------------------
Run the TPI simulation
------------------------------------------------------------------------
'''
sim_params['baseline'] = baseline
sim_params['input_dir'] = output_base
sim_params['baseline_dir'] = baseline_dir
income_tax_params, tpi_params, iterative_params, initial_values, SS_values = TPI.create_tpi_params(
**sim_params)
tpi_output, macro_output = TPI.run_TPI(income_tax_params,
tpi_params,
iterative_params,
initial_values,
SS_values,
fix_transfers=fix_transfers,
output_dir=output_base)
'''
------------------------------------------------------------------------
Pickle TPI results
------------------------------------------------------------------------
'''
tpi_dir = os.path.join(output_base, "TPI")
utils.mkdirs(tpi_dir)
tpi_vars = os.path.join(tpi_dir, "TPI_vars.pkl")
pickle.dump(tpi_output, open(tpi_vars, "wb"))
tpi_dir = os.path.join(output_base, "TPI")
utils.mkdirs(tpi_dir)
tpi_vars = os.path.join(tpi_dir, "TPI_macro_vars.pkl")
pickle.dump(macro_output, open(tpi_vars, "wb"))
print "Time path iteration complete. It"
print "took {0} seconds to get that part done.".format(time.time() - tick)
def runner(output_base,
baseline_dir,
test=False,
time_path=True,
baseline=False,
constant_rates=True,
tax_func_type='DEP',
analytical_mtrs=False,
age_specific=False,
reform={},
user_params={},
guid='',
run_micro=True,
small_open=False,
budget_balance=False,
baseline_spending=False,
data=None,
client=None,
num_workers=1):
from ogusa import parameters, demographics, income, utils
tick = time.time()
start_year = user_params.get('start_year', DEFAULT_START_YEAR)
if start_year > TC_LAST_YEAR:
raise RuntimeError("Start year is beyond data extrapolation.")
# Make sure options are internally consistent
if baseline and baseline_spending:
print("Inconsistent options. Setting <baseline_spending> to False, "
"leaving <baseline> True.'")
baseline_spending = False
if budget_balance and baseline_spending:
print("Inconsistent options. Setting <baseline_spending> to False, "
"leaving <budget_balance> True.")
baseline_spending = False
# Create output directory structure
ss_dir = os.path.join(output_base, "SS")
tpi_dir = os.path.join(output_base, "TPI")
dirs = [ss_dir, tpi_dir]
for _dir in dirs:
try:
print("making dir: ", _dir)
os.makedirs(_dir)
except OSError as oe:
pass
print('In runner, baseline is ', baseline)
if small_open and (not isinstance(small_open, dict)):
raise ValueError(
'small_open must be False/None or a dict with keys: {}'.format(
SMALL_OPEN_KEYS))
small_open = small_open or {}
run_params = ogusa.parameters.get_parameters(
output_base,
reform=reform,
test=test,
baseline=baseline,
guid=guid,
run_micro=run_micro,
constant_rates=constant_rates,
analytical_mtrs=analytical_mtrs,
tax_func_type=tax_func_type,
age_specific=age_specific,
start_year=start_year,
data=data,
client=client,
num_workers=num_workers,
**small_open)
run_params['analytical_mtrs'] = analytical_mtrs
run_params['small_open'] = bool(small_open)
run_params['budget_balance'] = budget_balance
run_params['world_int_rate'] = small_open.get('world_int_rate',
DEFAULT_WORLD_INT_RATE)
# Modify ogusa parameters based on user input
if 'frisch' in user_params:
print("updating frisch and associated")
b_ellipse, upsilon = ogusa.elliptical_u_est.estimation(
user_params['frisch'], run_params['ltilde'])
run_params['b_ellipse'] = b_ellipse
run_params['upsilon'] = upsilon
run_params.update(user_params)
if 'debt_ratio_ss' in user_params:
run_params['debt_ratio_ss'] = user_params['debt_ratio_ss']
if 'tau_b' in user_params:
run_params['tau_b'] = user_params['tau_b']
# Modify ogusa parameters based on user input
if 'g_y_annual' in user_params:
print("updating g_y_annual and associated")
ending_age = run_params['ending_age']
starting_age = run_params['starting_age']
S = run_params['S']
g_y = ((1 + user_params['g_y_annual'])
**(float(ending_age - starting_age) / S) - 1)
run_params['g_y'] = g_y
run_params.update(user_params)
# Modify transfer & spending ratios based on user input.
if 'T_shifts' in user_params:
if not baseline_spending:
print('updating ALPHA_T with T_shifts in first',
user_params['T_shifts'].size, 'periods.')
T_shifts = np.concatenate((user_params['T_shifts'],
np.zeros(run_params['ALPHA_T'].size -
user_params['T_shifts'].size)),
axis=0)
run_params['ALPHA_T'] = run_params['ALPHA_T'] + T_shifts
if 'G_shifts' in user_params:
if not baseline_spending:
print('updating ALPHA_G with G_shifts in first',
user_params['G_shifts'].size, 'periods.')
G_shifts = np.concatenate((user_params['G_shifts'],
np.zeros(run_params['ALPHA_G'].size -
user_params['G_shifts'].size)),
axis=0)
run_params['ALPHA_G'] = run_params['ALPHA_G'] + G_shifts
from ogusa import SS, TPI
calibrate_model = False
# List of parameter names that will not be changing (unless we decide to
# change them for a tax experiment)
param_names = [
'S', 'J', 'T', 'BW', 'lambdas', 'starting_age', 'ending_age', 'beta',
'sigma', 'alpha', 'gamma', 'epsilon', 'nu', 'Z', 'delta', 'E',
'ltilde', 'g_y', 'maxiter', 'mindist_SS', 'mindist_TPI',
'analytical_mtrs', 'b_ellipse', 'k_ellipse', 'upsilon', 'small_open',
'budget_balance', 'ss_firm_r', 'ss_hh_r', 'tpi_firm_r', 'tpi_hh_r',
'tG1', 'tG2', 'alpha_T', 'alpha_G', 'ALPHA_T', 'ALPHA_G', 'rho_G',
'debt_ratio_ss', 'tau_b', 'delta_tau', 'chi_b_guess', 'chi_n_guess',
'etr_params', 'mtrx_params', 'mtry_params', 'tau_payroll', 'tau_bq',
'retire', 'mean_income_data', 'g_n_vector', 'h_wealth', 'p_wealth',
'm_wealth', 'omega', 'g_n_ss', 'omega_SS', 'surv_rate', 'imm_rates',
'e', 'rho', 'initial_debt', 'omega_S_preTP'
]
'''
------------------------------------------------------------------------
Run SS
------------------------------------------------------------------------
'''
sim_params = {}
for key in param_names:
sim_params[key] = run_params[key]
sim_params['output_dir'] = output_base
sim_params['run_params'] = run_params
sim_params['tax_func_type'] = tax_func_type
(income_tax_params, ss_parameters, iterative_params, chi_params,
small_open_params) = SS.create_steady_state_parameters(**sim_params)
ss_outputs = SS.run_SS(income_tax_params,
ss_parameters,
iterative_params,
chi_params,
small_open_params,
baseline,
baseline_spending,
baseline_dir=baseline_dir,
client=client,
num_workers=num_workers)
'''
------------------------------------------------------------------------
Pickle SS results
------------------------------------------------------------------------
'''
model_params = {}
for key in param_names:
model_params[key] = sim_params[key]
if baseline:
utils.mkdirs(os.path.join(baseline_dir, "SS"))
ss_dir = os.path.join(baseline_dir, "SS/SS_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
# Save pickle with parameter values for the run
param_dir = os.path.join(baseline_dir, "model_params.pkl")
pickle.dump(model_params, open(param_dir, "wb"))
else:
utils.mkdirs(os.path.join(output_base, "SS"))
ss_dir = os.path.join(output_base, "SS/SS_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
# Save pickle with parameter values for the run
param_dir = os.path.join(output_base, "model_params.pkl")
pickle.dump(model_params, open(param_dir, "wb"))
if time_path:
'''
------------------------------------------------------------------------
Run the TPI simulation
------------------------------------------------------------------------
'''
sim_params['baseline'] = baseline
sim_params['baseline_spending'] = baseline_spending
sim_params['input_dir'] = output_base
sim_params['baseline_dir'] = baseline_dir
(income_tax_params, tpi_params,
iterative_params, small_open_params, initial_values, SS_values,
fiscal_params, biz_tax_params) =\
TPI.create_tpi_params(**sim_params)
tpi_output = TPI.run_TPI(income_tax_params,
tpi_params,
iterative_params,
small_open_params,
initial_values,
SS_values,
fiscal_params,
biz_tax_params,
output_dir=output_base,
baseline_spending=baseline_spending,
client=client,
num_workers=num_workers)
'''
------------------------------------------------------------------------
Pickle TPI results
------------------------------------------------------------------------
'''
tpi_dir = os.path.join(output_base, "TPI")
utils.mkdirs(tpi_dir)
tpi_vars = os.path.join(tpi_dir, "TPI_vars.pkl")
pickle.dump(tpi_output, open(tpi_vars, "wb"))
print("Time path iteration complete.")
print("It took {0} seconds to get that part done.".format(time.time() -
tick))
