def test_create_steady_state_parameters(): # Test that SS parameters creates same objects with same inputs. input_dict = utils.safe_read_pickle( os.path.join(CUR_PATH, 'test_io_data/create_params_inputs.pkl')) input_dict['tax_func_type'] = 'DEP' test_tuple = SS.create_steady_state_parameters(**input_dict) expected_tuple = utils.safe_read_pickle( os.path.join(CUR_PATH, 'test_io_data/create_params_outputs.pkl')) (income_tax_params, ss_params, iterative_params, chi_params, small_open_params) = expected_tuple income_tax_params = ('DEP', ) + income_tax_params expected_tuple = (income_tax_params, ss_params, iterative_params, chi_params, small_open_params) for i, v in enumerate(expected_tuple): for i2, v2 in enumerate(v): try: assert (all(test_tuple[i][i2] == v2)) except ValueError: assert ((test_tuple[i][i2] == v2).all()) except TypeError: assert (test_tuple[i][i2] == v2)
def runner_SS(output_base, baseline_dir, baseline=False, analytical_mtrs=False, age_specific=False, reform={}, user_params={}, guid='', run_micro=True): 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 # 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_params, iterative_params, chi_params= SS.create_steady_state_parameters(**sim_params) ''' **** CALL CALIBRATION here if boolean flagged **** ''' calibrate_model = False if calibrate_model: chi_params = calibrate.chi_estimate(income_tax_params, ss_params, iterative_params, chi_params, baseline_dir=baseline_dir) ss_outputs = SS.run_SS(income_tax_params, ss_params, 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"))
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))
'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: sim_params[key] = globals()[key] #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(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
'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: sim_params[key] = globals()[key] #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
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"
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=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_SS(output_base, baseline_dir, baseline=False, analytical_mtrs=True, age_specific=False, reform={}, user_params={}, guid='', run_micro=True): 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" 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 ''' **** CALL CALIBRATION here if boolean flagged **** ''' calibrate_model = False # if calibrate_model: # chi_b, chi_n = calibrate.(income_tax_params, ss_params, iterative_params, chi_params, baseline, # calibrate_model, output_dir=output_base, baseline_dir=baseline_dir) # 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_params, iterative_params, chi_params = SS.create_steady_state_parameters( **sim_params) ss_outputs = SS.run_SS(income_tax_params, ss_params, 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"))
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_SS(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 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) globals().update(run_params) from ogusa import SS, TPI # Generate Wealth data moments wealth.get_wealth_data(lambdas, J, flag_graphs, output_dir=output_base) # Generate labor data moments labor.labor_data_moments(flag_graphs, output_dir=output_base) get_baseline = True calibrate_model = True # 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 ------------------------------------------------------------------------ ''' 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'] = output_base 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, baseline, calibrate_model, output_dir=output_base, baseline_dir=baseline_dir)
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_SS( output_base, baseline_dir, baseline=False, analytical_mtrs=False, age_specific=False, reform={}, user_params={}, guid="", run_micro=True, ): 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 """ **** CALL CALIBRATION here if boolean flagged **** """ calibrate_model = False # if calibrate_model: # chi_b, chi_n = calibrate.(income_tax_params, ss_params, iterative_params, chi_params, baseline, # calibrate_model, output_dir=output_base, baseline_dir=baseline_dir) # 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_params, iterative_params, chi_params = SS.create_steady_state_parameters(**sim_params) ss_outputs = SS.run_SS( income_tax_params, ss_params, 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"))
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_SS(output_base, baseline_dir, baseline=False, analytical_mtrs=True, age_specific=False, reform=0, fix_transfers=False, user_params={}, guid='', calibrate_model=False, run_micro=True): 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, SS_alt # 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' ] 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 ''' ------------------------------------------------------------------------ If using income tax reform, need to determine parameters that yield same SS revenue as the wealth tax reform. ------------------------------------------------------------------------ ''' if reform == 1: 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[ 'T_Hss'] + reform3_ss_solutions['Gss'] # 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, fix_transfers=fix_transfers, baseline_dir=baseline_dir) 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= .452 # initial guess 0.452 works for sigma = 2, frisch 1.5 # new_d_inc = d_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-8) # print '\tOld income tax:', d_guess # print '\tNew income tax:', new_d_inc def samesign(a, b): return a * b > 0 def bisect_method(func, params, low, high): 'Find root of continuous function where f(low) and f(high) have opposite signs' #assert not samesign(func(params,low), func(params,high)) for i in range(54): midpoint = (low + high) / 2.0 if samesign(func(params, low), func(params, midpoint)): low = midpoint else: high = midpoint return midpoint def solve_model(params, d): income_tax_params, 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 mtrx_params[:, 3] = d mtry_params[:, 3] = d 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, fix_transfers=fix_transfers, baseline_dir=baseline_dir) ss_dir = os.path.join("./OUTPUT_INCOME_REFORM/sigma2.0", "SS/SS_vars.pkl") pickle.dump(ss_outputs, open(ss_dir, "wb")) receipts_new = ss_outputs['T_Hss'] + ss_outputs['Gss'] new_error = receipts_to_match - receipts_new print 'Error in taxes:', error print 'New income tax:', d return new_error # print 'Computing new income tax to match wealth tax' # d_guess= 0.5025 # initial guess # # 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, fix_transfers=fix_transfers, # baseline_dir=baseline_dir) # ss_dir = os.path.join("./OUTPUT_INCOME_REFORM/sigma2.0", "SS/SS_vars.pkl") # pickle.dump(ss_outputs, open(ss_dir, "wb")) # receipts_new = ss_outputs['T_Hss'] + ss_outputs['Gss'] # error = receipts_to_match - receipts_new # new_error = error # print "ERROR: ", error # max_loop_iter = 1 # output_list = np.zeros((max_loop_iter,3)) # loop_iter = 0 # bisect = 0 # d_guess_old = d_guess # # while np.abs(new_error) > 1e-8 and loop_iter < max_loop_iter: # while loop_iter < max_loop_iter: # # if new_error > 0 and new_error > 0 and bisect == 0: # # d_guess_old = d_guess # # d_guess+=0.001 # # elif new_error < 0 and new_error < 0 and bisect == 0: # # d_guess_old = d_guess # # d_guess-=0.001 # # d_guess = max(0.0,d_guess) # constrain so not negative # # else: # # bisect = 1 # # print 'Entering bisection method' # # params = income_tax_params, ss_params, iterative_params,\ # # chi_params, baseline ,baseline_dir # # high = max(d_guess,d_guess_old) # # low = min(d_guess,d_guess_old) # # d_guess = bisect_method(solve_model, params, low, high) # # loop_iter = max_loop_iter # d_guess_old = d_guess # d_guess+=0.0005 # # error = new_error # 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 # print 'now here$$$' # ss_outputs = SS.run_SS(income_tax_params, ss_params, iterative_params, # chi_params, baseline, fix_transfers=fix_transfers, # baseline_dir=baseline_dir) # ss_dir = os.path.join("./OUTPUT_INCOME_REFORM/sigma2.0", "SS/SS_vars.pkl") # pickle.dump(ss_outputs, open(ss_dir, "wb")) # receipts_new = ss_outputs['T_Hss'] + ss_outputs['Gss'] # new_error = (receipts_to_match - receipts_new) # print "ERROR: ", new_error # output_list[loop_iter,0]=new_error # output_list[loop_iter,1]=d_guess # output_list[loop_iter,2]=ss_outputs['Yss']-ss_outputs['Iss']-ss_outputs['Css']-ss_outputs['Gss'] # np.savetxt('inc_tax_out.csv',output_list, delimiter=",") # pickle.dump(output_list, open("output_list.pkl", "wb")) # print 'Error in taxes:', error # print 'Old income tax:', d_guess_old # print 'New income tax:', d_guess # print 'iteration: ', loop_iter # loop_iter += 1 analytical_mtrs, etr_params, mtrx_params, mtry_params = income_tax_params new_d_inc = 0.5025 # this is 0.453 if fix_transfers=False, 0.503 if True etr_params[:, 3] = new_d_inc mtrx_params[:, 3] = new_d_inc mtry_params[:, 3] = new_d_inc sim_params['etr_params'] = np.tile( np.reshape(etr_params, (run_params['S'], 1, etr_params.shape[1])), (1, run_params['BW'], 1)) sim_params['mtrx_params'] = np.tile( np.reshape(mtrx_params, (run_params['S'], 1, mtrx_params.shape[1])), (1, run_params['BW'], 1)) sim_params['mtry_params'] = np.tile( np.reshape(mtry_params, (run_params['S'], 1, mtry_params.shape[1])), (1, run_params['BW'], 1)) ''' ------------------------------------------------------------------------ Run SS ------------------------------------------------------------------------ ''' income_tax_params, ss_params, iterative_params, chi_params = SS.create_steady_state_parameters( **sim_params) analytical_mtrs, etr_params, mtrx_params, mtry_params = income_tax_params ''' **** CALL CALIBRATION here if boolean flagged **** ''' if calibrate_model: chi_params = calibrate.chi_estimate(income_tax_params, ss_params, iterative_params, chi_params, baseline_dir=baseline_dir) # ss_outputs = SS_alt.run_SS(income_tax_params, ss_params, iterative_params, # chi_params, baseline, baseline_dir=baseline_dir) print 'Fix transfers = ', fix_transfers ss_outputs = SS.run_SS(income_tax_params, ss_params, iterative_params, chi_params, baseline, fix_transfers=fix_transfers, baseline_dir=baseline_dir) model_moments = ogusa.calibrate.calc_moments(ss_outputs, sim_params['omega_SS'], sim_params['lambdas'], sim_params['S'], sim_params['J']) scf, data = ogusa.wealth.get_wealth_data() wealth_moments = ogusa.wealth.compute_wealth_moments( scf, sim_params['lambdas'], sim_params['J']) print 'model moments: ', model_moments[:sim_params['J'] + 2] print 'data moments: ', wealth_moments ''' ------------------------------------------------------------------------ Pickle SS results and parameters ------------------------------------------------------------------------ ''' 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"))
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, 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)
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))