def runner(self):
'''
Method to run the model
'''
# baseline compute
self.base_ss_outputs = SS.run_SS(self.spec1)
if self.spec1.time_path:
self.base_tpi_output = TPI.run_TPI(self.spec1)
# reform compute
# a bit more complicated because will need stuff from baseline
self.reform_ss_outputs = SS.run_SS(self.spec2)
if self.spec2.time_path:
self.reform_tpi_output = TPI.run_TPI(self.spec2)
def test_constant_demographics_TPI():
'''
This tests solves the model under the assumption of constant
demographics, a balanced budget, and tax functions that do not vary
over time.
In this case, given how initial guesss for the time
path are made, the time path should be solved for on the first
iteration and the values all along the time path should equal their
steady-state values.
'''
output_base = "./OUTPUT"
baseline_dir = "./OUTPUT"
user_params = {
'constant_demographics': True,
'budget_balance': True,
'zero_taxes': True,
'maxiter': 2
}
# 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
spec = Specifications(run_micro=False,
output_base=output_base,
baseline_dir=baseline_dir,
test=False,
time_path=True,
baseline=True,
reform={},
guid='')
spec.update_specifications(user_params)
print('path for tax functions: ', spec.output_base)
spec.get_tax_function_parameters(None, False)
# Run SS
ss_outputs = SS.run_SS(spec, None)
# save SS results
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(spec, open(param_dir, "wb"))
tpi_output = TPI.run_TPI(spec, None)
print(
'Max diff btwn SS and TP bsplus1 = ',
np.absolute(tpi_output['bmat_splus1'][:spec.T, :, :] -
ss_outputs['bssmat_splus1']).max())
print('Max diff btwn SS and TP Y = ',
np.absolute(tpi_output['Y'][:spec.T] - ss_outputs['Yss']).max())
assert (np.allclose(tpi_output['bmat_splus1'][:spec.T, :, :],
ss_outputs['bssmat_splus1']))
def test_run_TPI(baseline, param_updates, filename, tmp_path, dask_client):
'''
Test TPI.run_TPI function. Provide inputs to function and
ensure that output returned matches what it has been before.
'''
baseline_dir = os.path.join(CUR_PATH, 'baseline')
if baseline:
output_base = baseline_dir
else:
output_base = os.path.join(CUR_PATH, 'reform')
p = Specifications(baseline=baseline,
baseline_dir=baseline_dir,
output_base=output_base,
test=True,
client=dask_client,
num_workers=NUM_WORKERS)
p.update_specifications(param_updates)
p.maxiter = 2 # this test runs through just two iterations
p.get_tax_function_parameters(None,
run_micro=False,
tax_func_path=os.path.join(
CUR_PATH, '..', 'data', 'tax_functions',
'TxFuncEst_baseline_CPS.pkl'))
# Need to run SS first to get results
SS.ENFORCE_SOLUTION_CHECKS = False
ss_outputs = SS.run_SS(p, None)
if p.baseline:
utils.mkdirs(os.path.join(p.baseline_dir, "SS"))
ss_dir = os.path.join(p.baseline_dir, "SS", "SS_vars.pkl")
with open(ss_dir, "wb") as f:
pickle.dump(ss_outputs, f)
else:
utils.mkdirs(os.path.join(p.output_base, "SS"))
ss_dir = os.path.join(p.output_base, "SS", "SS_vars.pkl")
with open(ss_dir, "wb") as f:
pickle.dump(ss_outputs, f)
TPI.ENFORCE_SOLUTION_CHECKS = False
test_dict = TPI.run_TPI(p, None)
expected_dict = utils.safe_read_pickle(filename)
for k, v in expected_dict.items():
try:
assert (np.allclose(test_dict[k][:p.T],
v[:p.T],
rtol=1e-04,
atol=1e-04))
except ValueError:
assert (np.allclose(test_dict[k][:p.T, :, :],
v[:p.T, :, :],
rtol=1e-04,
atol=1e-04))
def test_constant_demographics_TPI(dask_client):
'''
This tests solves the model under the assumption of constant
demographics, a balanced budget, and tax functions that do not vary
over time.
In this case, given how initial guesss for the time
path are made, the time path should be solved for on the first
iteration and the values all along the time path should equal their
steady-state values.
'''
# Create output directory structure
spec = Specifications(run_micro=False,
output_base=OUTPUT_DIR,
baseline_dir=OUTPUT_DIR,
test=False,
time_path=True,
baseline=True,
iit_reform={},
guid='',
client=dask_client,
num_workers=NUM_WORKERS)
og_spec = {
'constant_demographics': True,
'budget_balance': True,
'zero_taxes': True,
'maxiter': 2,
'r_gov_shift': 0.0,
'zeta_D': [0.0, 0.0],
'zeta_K': [0.0, 0.0],
'debt_ratio_ss': 1.0,
'initial_foreign_debt_ratio': 0.0,
'start_year': 2019,
'cit_rate': [0.0],
'PIA_rate_bkt_1': 0.0,
'PIA_rate_bkt_2': 0.0,
'PIA_rate_bkt_3': 0.0,
'eta':
(spec.omega_SS.reshape(spec.S, 1) * spec.lambdas.reshape(1, spec.J))
}
spec.update_specifications(og_spec)
spec.get_tax_function_parameters(None, False, tax_func_path=TAX_FUNC_PATH)
# Run SS
ss_outputs = SS.run_SS(spec, None)
# save SS results
utils.mkdirs(os.path.join(OUTPUT_DIR, "SS"))
ss_dir = os.path.join(OUTPUT_DIR, "SS", "SS_vars.pkl")
with open(ss_dir, "wb") as f:
pickle.dump(ss_outputs, f)
# Run TPI
tpi_output = TPI.run_TPI(spec, None)
assert (np.allclose(tpi_output['bmat_splus1'][:spec.T, :, :],
ss_outputs['bssmat_splus1']))
def test_constant_demographics_TPI():
'''
This tests solves the model under the assumption of constant
demographics, a balanced budget, and tax functions that do not vary
over time.
In this case, given how initial guesss for the time
path are made, the time path should be solved for on the first
iteration and the values all along the time path should equal their
steady-state values.
'''
output_base = "./OUTPUT"
baseline_dir = "./OUTPUT"
user_params = {'constant_demographics': True,
'budget_balance': True,
'zero_taxes': True,
'maxiter': 2}
# 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
spec = Specifications(run_micro=False, output_base=output_base,
baseline_dir=baseline_dir, test=False,
time_path=True, baseline=True, reform={},
guid='')
spec.update_specifications(user_params)
print('path for tax functions: ', spec.output_base)
spec.get_tax_function_parameters(None, False)
# Run SS
ss_outputs = SS.run_SS(spec, None)
# save SS results
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(spec, open(param_dir, "wb"))
tpi_output = TPI.run_TPI(spec, None)
print('Max diff btwn SS and TP bsplus1 = ',
np.absolute(tpi_output['bmat_splus1'][:spec.T, :, :] -
ss_outputs['bssmat_splus1']).max())
print('Max diff btwn SS and TP Y = ',
np.absolute(tpi_output['Y'][:spec.T] -
ss_outputs['Yss']).max())
assert(np.allclose(tpi_output['bmat_splus1'][:spec.T, :, :],
ss_outputs['bssmat_splus1']))
def test_constant_demographics_TPI():
'''
This tests solves the model under the assumption of constant
demographics, a balanced budget, and tax functions that do not vary
over time.
In this case, given how initial guesss for the time
path are made, the time path should be solved for on the first
iteration and the values all along the time path should equal their
steady-state values.
'''
output_base = os.path.join(CUR_PATH, 'OUTPUT')
baseline_dir = output_base
# 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:
pass
spec = Specifications(run_micro=False,
output_base=output_base,
baseline_dir=baseline_dir,
test=False,
time_path=True,
baseline=True,
iit_reform={},
guid='')
og_spec = {
'constant_demographics': True,
'budget_balance': True,
'zero_taxes': True,
'maxiter': 2,
'eta':
(spec.omega_SS.reshape(spec.S, 1) * spec.lambdas.reshape(1, spec.J))
}
spec.update_specifications(og_spec)
spec.get_tax_function_parameters(None, False)
# Run SS
ss_outputs = SS.run_SS(spec, None)
# save SS results
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"))
# Run TPI
tpi_output = TPI.run_TPI(spec, None)
assert (np.allclose(tpi_output['bmat_splus1'][:spec.T, :, :],
ss_outputs['bssmat_splus1']))
def test_constant_demographics_TPI_small_open():
'''
This tests solves the model under the assumption of constant
demographics, a balanced budget, and tax functions that do not vary
over time, as well as with a small open economy assumption.
'''
# Create output directory structure
spec = Specifications(run_micro=False,
output_base=OUTPUT_DIR,
baseline_dir=OUTPUT_DIR,
test=False,
time_path=True,
baseline=True,
iit_reform={},
guid='')
og_spec = {
'constant_demographics': True,
'budget_balance': True,
'zero_taxes': True,
'maxiter': 2,
'r_gov_shift': 0.0,
'zeta_D': [0.0, 0.0],
'zeta_K': [1.0],
'debt_ratio_ss': 1.0,
'initial_foreign_debt_ratio': 0.0,
'start_year': 2019,
'cit_rate': [0.0],
'PIA_rate_bkt_1': 0.0,
'PIA_rate_bkt_2': 0.0,
'PIA_rate_bkt_3': 0.0,
'eta':
(spec.omega_SS.reshape(spec.S, 1) * spec.lambdas.reshape(1, spec.J))
}
spec.update_specifications(og_spec)
spec.get_tax_function_parameters(None, False, tax_func_path=TAX_FUNC_PATH)
# Run SS
ss_outputs = SS.run_SS(spec, None)
# save SS results
utils.mkdirs(os.path.join(OUTPUT_DIR, "SS"))
ss_dir = os.path.join(OUTPUT_DIR, "SS", "SS_vars.pkl")
with open(ss_dir, "wb") as f:
pickle.dump(ss_outputs, f)
# Run TPI
tpi_output = TPI.run_TPI(spec, None)
assert (np.allclose(tpi_output['bmat_splus1'][:spec.T, :, :],
ss_outputs['bssmat_splus1']))
def test_run_TPI():
# Test TPI.run_TPI function. Provide inputs to function and
# ensure that output returned matches what it has been before.
input_tuple = utils.safe_read_pickle(
os.path.join(CUR_PATH, 'test_io_data/run_TPI_inputs.pkl'))
(income_tax_params, tpi_params, iterative_params, small_open_params,
initial_values, SS_values, fiscal_params, biz_tax_params,
output_dir, baseline_spending) = input_tuple
tpi_params = tpi_params + [True]
initial_values = initial_values + (0.0,)
income_tax_params = ('DEP',) + income_tax_params
test_dict = TPI.run_TPI(
income_tax_params, tpi_params, iterative_params,
small_open_params, initial_values, SS_values, fiscal_params,
biz_tax_params, output_dir, baseline_spending)
expected_dict = utils.safe_read_pickle(
os.path.join(CUR_PATH, 'test_io_data/run_TPI_outputs.pkl'))
for k, v in expected_dict.items():
assert(np.allclose(test_dict[k], v))
def test_run_TPI():
# Test TPI.run_TPI function. Provide inputs to function and
# ensure that output returned matches what it has been before.
input_tuple = utils.safe_read_pickle(
os.path.join(CUR_PATH, 'test_io_data/run_TPI_inputs.pkl'))
(income_tax_params, tpi_params, iterative_params, small_open_params,
initial_values, SS_values, fiscal_params, biz_tax_params,
output_dir, baseline_spending) = input_tuple
tpi_params = tpi_params + [True]
initial_values = initial_values + (0.0,)
p = Specifications()
(J, S, T, BW, p.beta, p.sigma, p.alpha, p.gamma, p.epsilon,
Z, p.delta, p.ltilde, p.nu, p.g_y, p.g_n, tau_b, delta_tau,
tau_payroll, tau_bq, p.rho, p.omega, N_tilde, lambdas,
p.imm_rates, p.e, retire, p.mean_income_data, factor, h_wealth,
p_wealth, m_wealth, p.b_ellipse, p.upsilon, p.chi_b, p.chi_n,
theta, p.baseline) = tpi_params
new_param_values = {
'J': J,
'S': S,
'T': T
}
# update parameters instance with new values for test
p.update_specifications(new_param_values, raise_errors=False)
(J, S, T, BW, p.beta, p.sigma, p.alpha, p.gamma, p.epsilon,
Z, p.delta, p.ltilde, p.nu, p.g_y, p.g_n, tau_b, delta_tau,
tau_payroll, tau_bq, p.rho, p.omega, N_tilde, lambdas,
p.imm_rates, p.e, retire, p.mean_income_data, factor, h_wealth,
p_wealth, m_wealth, p.b_ellipse, p.upsilon, p.chi_b, p.chi_n,
theta, p.baseline) = tpi_params
p.Z = np.ones(p.T + p.S) * Z
p.tau_bq = np.ones(p.T + p.S) * 0.0
p.tau_payroll = np.ones(p.T + p.S) * tau_payroll
p.tau_b = np.ones(p.T + p.S) * tau_b
p.delta_tau = np.ones(p.T + p.S) * delta_tau
p.h_wealth = np.ones(p.T + p.S) * h_wealth
p.p_wealth = np.ones(p.T + p.S) * p_wealth
p.m_wealth = np.ones(p.T + p.S) * m_wealth
p.retire = (np.ones(p.T + p.S) * retire).astype(int)
p.small_open, ss_firm_r, ss_hh_r = small_open_params
p.ss_firm_r = np.ones(p.T + p.S) * ss_firm_r
p.ss_hh_r = np.ones(p.T + p.S) * ss_hh_r
p.maxiter, p.mindist_SS, p.mindist_TPI = iterative_params
(p.budget_balance, alpha_T, alpha_G, p.tG1, p.tG2, p.rho_G,
p.debt_ratio_ss) = fiscal_params
p.alpha_T = np.concatenate((alpha_T, np.ones(40) * alpha_T[-1]))
p.alpha_G = np.concatenate((alpha_G, np.ones(40) * alpha_G[-1]))
(tau_b, delta_tau) = biz_tax_params
p.tau_b = np.ones(p.T + p.S) * tau_b
p.delta_tau = np.ones(p.T + p.S) * delta_tau
p.analytical_mtrs, etr_params, mtrx_params, mtry_params =\
income_tax_params
p.etr_params = np.transpose(etr_params, (1, 0, 2))[:p.T, :, :]
p.mtrx_params = np.transpose(mtrx_params, (1, 0, 2))[:p.T, :, :]
p.mtry_params = np.transpose(mtry_params, (1, 0, 2))[:p.T, :, :]
p.lambdas = lambdas.reshape(p.J, 1)
p.output = output_dir
p.baseline_spending = baseline_spending
p.num_workers = 1
(K0, b_sinit, b_splus1init, factor, initial_b, initial_n,
p.omega_S_preTP, initial_debt, D0) = initial_values
# Need to run SS first to get results
ss_outputs = SS.run_SS(p, None)
if p.baseline:
utils.mkdirs(os.path.join(p.baseline_dir, "SS"))
ss_dir = os.path.join(p.baseline_dir, "SS/SS_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
else:
utils.mkdirs(os.path.join(p.output_base, "SS"))
ss_dir = os.path.join(p.output_base, "SS/SS_vars.pkl")
pickle.dump(ss_outputs, open(ss_dir, "wb"))
test_dict = TPI.run_TPI(p, None)
expected_dict = utils.safe_read_pickle(
os.path.join(CUR_PATH, 'test_io_data/run_TPI_outputs.pkl'))
# delete values key-value pairs that are not in both dicts
del test_dict['etr_path'], test_dict['mtrx_path'], test_dict['mtry_path']
del test_dict['bmat_s']
test_dict['b_mat'] = test_dict.pop('bmat_splus1')
test_dict['REVENUE'] = test_dict.pop('total_revenue')
test_dict['IITpayroll_revenue'] = (test_dict['REVENUE'][:160] -
test_dict['business_revenue'])
del test_dict['T_P'], test_dict['T_BQ'], test_dict['T_W']
del test_dict['resource_constraint_error'], test_dict['T_C']
del test_dict['r_gov'], test_dict['r_hh']
for k, v in expected_dict.items():
try:
assert(np.allclose(test_dict[k], v, rtol=1e-04, atol=1e-04))
except ValueError:
assert(np.allclose(test_dict[k], v[:p.T, :, :], rtol=1e-04,
atol=1e-04))
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 run_model(meta_param_dict, adjustment):
'''
Initializes classes from OG-USA that compute the model under
different policies. Then calls function get output objects.
'''
print('Meta_param_dict = ', meta_param_dict)
print('adjustment dict = ', adjustment)
meta_params = MetaParams()
meta_params.adjust(meta_param_dict)
if meta_params.data_source == "PUF":
data = retrieve_puf(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)
# set name of cached baseline file in case use below
cached_pickle = 'TxFuncEst_baseline_PUF.pkl'
else:
data = "cps"
# set name of cached baseline file in case use below
cached_pickle = 'TxFuncEst_baseline_CPS.pkl'
# Get TC params adjustments
iit_mods = convert_policy_adjustment(
adjustment["Tax-Calculator Parameters"])
# Create output directory structure
base_dir = os.path.join(CUR_DIR, BASELINE_DIR)
reform_dir = os.path.join(CUR_DIR, REFORM_DIR)
dirs = [base_dir, reform_dir]
for _dir in dirs:
utils.mkdirs(_dir)
# Dask parmeters
client = Client()
num_workers = 5
# TODO: Swap to these parameters when able to specify tax function
# and model workers separately
# num_workers_txf = 5
# num_workers_mod = 6
# whether to estimate tax functions from microdata
run_micro = True
time_path = meta_param_dict['time_path'][0]['value']
# filter out OG-USA params that will not change between baseline and
# reform runs (these are the non-policy parameters)
filtered_ogusa_params = {}
constant_param_set = {
'frisch', 'beta_annual', 'sigma', 'g_y_annual', 'gamma', 'epsilon',
'Z', 'delta_annual', 'small_open', 'world_int_rate',
'initial_foreign_debt_ratio', 'zeta_D', 'zeta_K', 'tG1', 'tG2',
'rho_G', 'debt_ratio_ss', 'budget_balance'
}
filtered_ogusa_params = OrderedDict()
for k, v in adjustment['OG-USA Parameters'].items():
if k in constant_param_set:
filtered_ogusa_params[k] = v
# Solve baseline model
start_year = meta_param_dict['year'][0]['value']
if start_year == 2020:
OGPATH = inspect.getfile(SS)
OGDIR = os.path.dirname(OGPATH)
tax_func_path = None #os.path.join(OGDIR, 'data', 'tax_functions',
# cached_pickle)
run_micro_baseline = False
else:
tax_func_path = None
run_micro_baseline = True
base_spec = {
**{
'start_year': start_year,
'tax_func_type': 'DEP',
'age_specific': False
},
**filtered_ogusa_params
}
base_params = Specifications(run_micro=False,
output_base=base_dir,
baseline_dir=base_dir,
test=False,
time_path=False,
baseline=True,
iit_reform={},
guid='',
data=data,
client=client,
num_workers=num_workers)
base_params.update_specifications(base_spec)
base_params.get_tax_function_parameters(client,
run_micro_baseline,
tax_func_path=tax_func_path)
base_ss = SS.run_SS(base_params, client=client)
utils.mkdirs(os.path.join(base_dir, "SS"))
base_ss_dir = os.path.join(base_dir, "SS", "SS_vars.pkl")
with open(base_ss_dir, "wb") as f:
pickle.dump(base_ss, f)
if time_path:
base_tpi = TPI.run_TPI(base_params, client=client)
tpi_dir = os.path.join(base_dir, "TPI", "TPI_vars.pkl")
with open(tpi_dir, "wb") as f:
pickle.dump(base_tpi, f)
else:
base_tpi = None
# Solve reform model
reform_spec = base_spec
reform_spec.update(adjustment["OG-USA Parameters"])
reform_params = Specifications(run_micro=False,
output_base=reform_dir,
baseline_dir=base_dir,
test=False,
time_path=time_path,
baseline=False,
iit_reform=iit_mods,
guid='',
data=data,
client=client,
num_workers=num_workers)
reform_params.update_specifications(reform_spec)
reform_params.get_tax_function_parameters(client, run_micro)
reform_ss = SS.run_SS(reform_params, client=client)
utils.mkdirs(os.path.join(reform_dir, "SS"))
reform_ss_dir = os.path.join(reform_dir, "SS", "SS_vars.pkl")
with open(reform_ss_dir, "wb") as f:
pickle.dump(reform_ss, f)
if time_path:
reform_tpi = TPI.run_TPI(reform_params, client=client)
else:
reform_tpi = None
comp_dict = comp_output(base_params, base_ss, reform_params, reform_ss,
time_path, base_tpi, reform_tpi)
# Shut down client and make sure all of its references are
# cleaned up.
client.close()
del client
return comp_dict
def runner(output_base, baseline_dir, test=False, time_path=True,
baseline=True, reform={}, user_params={}, guid='',
run_micro=True, data=None, client=None, num_workers=1):
tick = time.time()
# 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:
pass
print('In runner, baseline is ', baseline)
# Get parameter class
# Note - set run_micro false when initially load class
# Update later with call to spec.get_tax_function_parameters()
spec = Specifications(run_micro=False, output_base=output_base,
baseline_dir=baseline_dir, test=test,
time_path=time_path, baseline=baseline,
reform=reform, guid=guid, data=data,
client=client, num_workers=num_workers)
spec.update_specifications(user_params)
print('path for tax functions: ', spec.output_base)
spec.get_tax_function_parameters(client, run_micro)
'''
------------------------------------------------------------------------
Run SS
------------------------------------------------------------------------
'''
ss_outputs = SS.run_SS(spec, client=client)
'''
------------------------------------------------------------------------
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"))
# Save pickle with parameter values for the run
param_dir = os.path.join(baseline_dir, "model_params.pkl")
pickle.dump(spec, 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(spec, open(param_dir, "wb"))
if time_path:
'''
------------------------------------------------------------------------
Run the TPI simulation
------------------------------------------------------------------------
'''
tpi_output = TPI.run_TPI(spec, client=client)
'''
------------------------------------------------------------------------
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))
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,
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,
test=False,
time_path=True,
baseline=True,
iit_reform={},
og_spec={},
guid='',
run_micro=True,
data=None,
client=None,
num_workers=1):
'''
This function runs the OG-USA model, solving for the steady-state
and (optionally) the time path equilibrium.
Args:
output_base (str): path to save output to
baseline_dir (str): path where baseline model results are saved
test (bool): whether to run model in test mode (which has
a smaller state space and higher tolerances for solution)
time_path (bool): whether to solve for the time path equlibrium
baseline (bool): whether the model run is the baseline run
iit_reform (dict): Tax-Calculator policy dictionary
og_spec (dict): dictionary with updates to default
parameters in OG-USA
guid (str): id for OG-USA run
run_micro (bool): whether to estimate tax functions from micro
data or load saved parameters from pickle file
data (str or Pandas DataFrame): path to or data to use in
Tax-Calculator
client (Dask client object): client
num_workers (int): number of workers to use for parallelization
with Dask
Returns:
None
'''
tick = time.time()
# 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:
pass
print('In runner, baseline is ', baseline)
# Get parameter class
# Note - set run_micro false when initially load class
# Update later with call to spec.get_tax_function_parameters()
spec = Specifications(run_micro=False,
output_base=output_base,
baseline_dir=baseline_dir,
test=test,
time_path=time_path,
baseline=baseline,
iit_reform=iit_reform,
guid=guid,
data=data,
client=client,
num_workers=num_workers)
spec.update_specifications(og_spec)
print('path for tax functions: ', spec.output_base)
spec.get_tax_function_parameters(client, run_micro)
'''
------------------------------------------------------------------------
Run SS
------------------------------------------------------------------------
'''
ss_outputs = SS.run_SS(spec, client=client)
'''
------------------------------------------------------------------------
Pickle SS results
------------------------------------------------------------------------
'''
if baseline:
utils.mkdirs(os.path.join(baseline_dir, "SS"))
ss_dir = os.path.join(baseline_dir, "SS", "SS_vars.pkl")
with open(ss_dir, "wb") as f:
pickle.dump(ss_outputs, f)
print('JUST SAVED SS output to ', ss_dir)
# Save pickle with parameter values for the run
param_dir = os.path.join(baseline_dir, "model_params.pkl")
with open(param_dir, "wb") as f:
cloudpickle.dump((spec), f)
else:
utils.mkdirs(os.path.join(output_base, "SS"))
ss_dir = os.path.join(output_base, "SS", "SS_vars.pkl")
with open(ss_dir, "wb") as f:
pickle.dump(ss_outputs, f)
# Save pickle with parameter values for the run
param_dir = os.path.join(output_base, "model_params.pkl")
with open(param_dir, "wb") as f:
cloudpickle.dump((spec), f)
if time_path:
'''
------------------------------------------------------------------------
Run the TPI simulation
------------------------------------------------------------------------
'''
tpi_output = TPI.run_TPI(spec, client=client)
'''
------------------------------------------------------------------------
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")
with open(tpi_vars, "wb") as f:
pickle.dump(tpi_output, f)
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={},
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 test_run_TPI():
# Test TPI.run_TPI function. Provide inputs to function and
# ensure that output returned matches what it has been before.
input_tuple = utils.safe_read_pickle(
os.path.join(CUR_PATH, 'test_io_data', 'run_TPI_inputs.pkl'))
(income_tax_params, tpi_params, iterative_params, small_open_params,
initial_values, SS_values, fiscal_params, biz_tax_params,
output_dir, baseline_spending) = input_tuple
tpi_params = tpi_params + [True]
initial_values = initial_values + (0.0,)
p = Specifications()
(J, S, T, BW, p.beta, p.sigma, p.alpha, p.gamma, p.epsilon,
Z, p.delta, p.ltilde, p.nu, p.g_y, p.g_n, tau_b, delta_tau,
tau_payroll, tau_bq, p.rho, p.omega, N_tilde, lambdas,
p.imm_rates, p.e, retire, p.mean_income_data, factor, h_wealth,
p_wealth, m_wealth, p.b_ellipse, p.upsilon, p.chi_b, p.chi_n,
theta, p.baseline) = tpi_params
new_param_values = {
'J': J,
'S': S,
'T': T,
'eta': (np.ones((S, J)) / (S * J))
}
# update parameters instance with new values for test
p.update_specifications(new_param_values, raise_errors=False)
(J, S, T, BW, p.beta, p.sigma, p.alpha, p.gamma, p.epsilon,
Z, p.delta, p.ltilde, p.nu, p.g_y, p.g_n, tau_b, delta_tau,
tau_payroll, tau_bq, p.rho, p.omega, N_tilde, lambdas,
p.imm_rates, p.e, retire, p.mean_income_data, factor, h_wealth,
p_wealth, m_wealth, p.b_ellipse, p.upsilon, p.chi_b, p.chi_n,
theta, p.baseline) = tpi_params
p.eta = p.omega.reshape(T + S, S, 1) * lambdas.reshape(1, J)
p.Z = np.ones(p.T + p.S) * Z
p.tau_bq = np.ones(p.T + p.S) * 0.0
p.tau_payroll = np.ones(p.T + p.S) * tau_payroll
p.tau_b = np.ones(p.T + p.S) * tau_b
p.delta_tau = np.ones(p.T + p.S) * delta_tau
p.h_wealth = np.ones(p.T + p.S) * h_wealth
p.p_wealth = np.ones(p.T + p.S) * p_wealth
p.m_wealth = np.ones(p.T + p.S) * m_wealth
p.retire = (np.ones(p.T + p.S) * retire).astype(int)
p.small_open, ss_firm_r, ss_hh_r = small_open_params
p.ss_firm_r = np.ones(p.T + p.S) * ss_firm_r
p.ss_hh_r = np.ones(p.T + p.S) * ss_hh_r
p.maxiter, p.mindist_SS, p.mindist_TPI = iterative_params
(p.budget_balance, alpha_T, alpha_G, p.tG1, p.tG2, p.rho_G,
p.debt_ratio_ss) = fiscal_params
p.alpha_T = np.concatenate((alpha_T, np.ones(40) * alpha_T[-1]))
p.alpha_G = np.concatenate((alpha_G, np.ones(40) * alpha_G[-1]))
(tau_b, delta_tau) = biz_tax_params
p.tau_b = np.ones(p.T + p.S) * tau_b
p.delta_tau = np.ones(p.T + p.S) * delta_tau
p.analytical_mtrs, etr_params, mtrx_params, mtry_params =\
income_tax_params
p.etr_params = np.transpose(etr_params, (1, 0, 2))[:p.T, :, :]
p.mtrx_params = np.transpose(mtrx_params, (1, 0, 2))[:p.T, :, :]
p.mtry_params = np.transpose(mtry_params, (1, 0, 2))[:p.T, :, :]
p.lambdas = lambdas.reshape(p.J, 1)
p.output = output_dir
p.baseline_spending = baseline_spending
p.frac_tax_payroll = 0.5 * np.ones(p.T + p.S)
p.num_workers = 1
(K0, b_sinit, b_splus1init, factor, initial_b, initial_n,
p.omega_S_preTP, initial_debt, D0) = initial_values
# Need to run SS first to get results
ss_outputs = SS.run_SS(p, None)
if p.baseline:
utils.mkdirs(os.path.join(p.baseline_dir, "SS"))
ss_dir = os.path.join(p.baseline_dir, "SS/SS_vars.pkl")
with open(ss_dir, "wb") as f:
pickle.dump(ss_outputs, f)
else:
utils.mkdirs(os.path.join(p.output_base, "SS"))
ss_dir = os.path.join(p.output_base, "SS/SS_vars.pkl")
with open(ss_dir, "wb") as f:
pickle.dump(ss_outputs, f)
test_dict = TPI.run_TPI(p, None)
expected_dict = utils.safe_read_pickle(
os.path.join(CUR_PATH, 'test_io_data', 'run_TPI_outputs.pkl'))
# delete values key-value pairs that are not in both dicts
del expected_dict['I_total']
del test_dict['etr_path'], test_dict['mtrx_path'], test_dict['mtry_path']
del test_dict['bmat_s']
test_dict['b_mat'] = test_dict.pop('bmat_splus1')
test_dict['REVENUE'] = test_dict.pop('total_revenue')
test_dict['T_H'] = test_dict.pop('TR')
test_dict['IITpayroll_revenue'] = (test_dict['REVENUE'][:160] -
test_dict['business_revenue'])
del test_dict['T_P'], test_dict['T_BQ'], test_dict['T_W']
del test_dict['y_before_tax_mat'], test_dict['K_f'], test_dict['K_d']
del test_dict['D_d'], test_dict['D_f']
del test_dict['new_borrowing_f'], test_dict['debt_service_f']
del test_dict['iit_revenue'], test_dict['payroll_tax_revenue']
del test_dict['resource_constraint_error'], test_dict['T_C']
del test_dict['r_gov'], test_dict['r_hh'], test_dict['tr_path']
for k, v in expected_dict.items():
try:
assert(np.allclose(test_dict[k], v, rtol=1e-04, atol=1e-04))
except ValueError:
assert(np.allclose(test_dict[k], v[:p.T, :, :], rtol=1e-04,
atol=1e-04))
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,
test=False,
time_path=True,
baseline=True,
reform={},
user_params={},
guid='',
run_micro=True,
data=None,
client=None,
num_workers=1):
tick = time.time()
# 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:
pass
print('In runner, baseline is ', baseline)
# Get parameter class
# Note - set run_micro false when initially load class
# Update later with call to spec.get_tax_function_parameters()
spec = Specifications(run_micro=False,
output_base=output_base,
baseline_dir=baseline_dir,
test=test,
time_path=time_path,
baseline=baseline,
reform=reform,
guid=guid,
data=data,
client=client,
num_workers=num_workers)
spec.update_specifications(user_params)
print('path for tax functions: ', spec.output_base)
spec.get_tax_function_parameters(client, run_micro)
'''
------------------------------------------------------------------------
Run SS
------------------------------------------------------------------------
'''
ss_outputs = SS.run_SS(spec, client=client)
'''
------------------------------------------------------------------------
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"))
# Save pickle with parameter values for the run
param_dir = os.path.join(baseline_dir, "model_params.pkl")
pickle.dump(spec, 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(spec, open(param_dir, "wb"))
if time_path:
'''
------------------------------------------------------------------------
Run the TPI simulation
------------------------------------------------------------------------
'''
tpi_output = TPI.run_TPI(spec, client=client)
'''
------------------------------------------------------------------------
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))
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=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,
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))
