def binding(self, psi):
param0 = self.betas_struct(psi)
N = self.output_ins.__dict__['N']
p1_0 = self.output_ins.__dict__['p1_0']
p2_0 = self.output_ins.__dict__['p2_0']
years = self.output_ins.__dict__['years']
treatment = self.output_ins.__dict__['treatment']
typeSchool = self.output_ins.__dict__['typeSchool']
HOURS = self.output_ins.__dict__['HOURS']
p1 = self.output_ins.__dict__['p1']
p2 = self.output_ins.__dict__['p2']
catPort = self.output_ins.__dict__['catPort']
catPrueba = self.output_ins.__dict__['catPrueba']
TrameI = self.output_ins.__dict__['TrameI']
model = util.Utility(param0, N, p1_0, p2_0, years, treatment,
typeSchool, HOURS, p1, p2, catPort, catPrueba,
TrameI)
modelSD = sd.SimData(N, model)
betas = self.sim_moments(modelSD)
return betas
param0 = parameters.Parameters(alphas, betas, gammas, hw, porc, pro, pol,
AEP, priori)
model = util.Utility(param0, N, p1_0, p2_0, years, treatment, typeSchool,
HOURS, p1, p2, catPort, catPrueba, TrameI, priotity,
rural_rbd, locality)
# SIMULACIÓN SIMDATA
simce_sims = np.zeros((N, n_sim))
income_sims = np.zeros((N, n_sim))
baseline_sims = np.zeros((N, n_sim, 2))
for j in range(n_sim):
modelSD = sd.SimData(N, model)
opt = modelSD.choice()
simce_sims[:, j] = opt['Opt Simce']
income_sims[:, j] = opt['Opt Income'][1 - x]
baseline_sims[:, j, 0] = opt['Potential scores'][0]
baseline_sims[:, j, 1] = opt['Potential scores'][1]
simce.append(np.mean(simce_sims, axis=1))
income.append(np.mean(income_sims, axis=1))
baseline_p.append(np.mean(baseline_sims, axis=1))
print('')
print('ATT equals ', np.mean(simce[1] - simce[0]))
print('')
#For validation purposes
sigma2w_reg = 0.34
betastd = betas_opt[9]
T = (24-8)*20 #monthly waking hours
Lc = 8*20 #monthly cc hours
w_matrix = np.identity(10)
times = 50
times_boot = 1000
#------------ CALL CLASSES, ESTIMATION SIM & BOOTSTRAP ------------#
param0 = parameters.Parameters(betasw, betastd, betasn, sigma2n, sigma2w_reg, meanshocks, covshocks, T, Lc, alpha, gamma, times)
model = util.Utility(param0, N, data)
model_sim = simdata.SimData(N, model)
model_boot= bstr.bootstrap(N, data)
moments_boot = model_boot.boostr(times_boot)
model_est = est.estimate(N, data, param0, moments_boot, w_matrix)
results_estimate = model_est.simulation(model_sim)
#------------ EXCEL TABLE ------------#
workbook = xlsxwriter.Workbook('data/labor_choice.xlsx')
worksheet = workbook.add_worksheet()
worksheet.write('B2', 'parameter')
def samples(self, param1, emaxins, model):
"""
Returns a sample M of utility values
"""
#number of choices
J = 2 * 2 * 3
#updating sample with new betas and emax
simdata_ins = simdata.SimData(
self.N, param1, emaxins, self.x_w, self.x_m, self.x_k, self.x_wmk,
self.passign, self.nkids0, self.married0, self.agech0_a,
self.agech0_b, self.d_childa, self.d_childb, self.hours_p,
self.hours_f, self.wr, self.cs, self.ws, model)
#save here
util_list = []
income_matrix = np.zeros((self.N, self.nperiods, self.M))
consumption_matrix = np.zeros((self.N, self.nperiods, self.M))
iscost_matrix = np.zeros((self.N, self.nperiods, self.M))
cscost_matrix = np.zeros((self.N, self.nperiods, self.M))
childcare_a_matrix = np.zeros((self.N, self.nperiods, self.M))
childcare_b_matrix = np.zeros((self.N, self.nperiods, self.M))
utils_periodt = np.zeros((self.N, J, self.nperiods, self.M))
utils_c_periodt = np.zeros((self.N, J, self.nperiods, self.M))
theta_matrix_a = np.zeros((self.N, self.nperiods, self.M))
theta_matrix_b = np.zeros((self.N, self.nperiods, self.M))
wage_matrix = np.zeros((self.N, self.nperiods, self.M))
spouse_income_matrix = np.zeros((self.N, self.nperiods, self.M))
spouse_employment_matrix = np.zeros((self.N, self.nperiods, self.M))
hours_matrix = np.zeros((self.N, self.nperiods, self.M))
ssrs_t2_matrix_a = np.zeros((self.N, self.M))
ssrs_t2_matrix_b = np.zeros((self.N, self.M))
ssrs_t5_matrix_a = np.zeros((self.N, self.M))
ssrs_t5_matrix_b = np.zeros((self.N, self.M))
#Computing samples (in parallel)
def sample_gen(j):
np.random.seed(j + 100)
return simdata_ins.fake_data(self.nperiods)
pool = ProcessPool(nodes=10)
dics = pool.map(sample_gen, range(self.M))
pool.close()
pool.join()
pool.clear()
# dics = []
# for j in range(self.M):
# np.random.seed(j+100)
# dics.append(simdata_ins.fake_data(self.nperiods))
#Saving results
for j in range(0, self.M):
income_matrix[:, :, j] = dics[j]['Income']
consumption_matrix[:, :, j] = dics[j]['Consumption']
iscost_matrix[:, :, j] = dics[j]['nh_matrix']
cscost_matrix[:, :, j] = dics[j]['cs_cost_matrix']
childcare_a_matrix[:, :, j] = dics[j]['Childcare_a']
childcare_b_matrix[:, :, j] = dics[j]['Childcare_b']
theta_matrix_a[:, :, j] = dics[j]['Theta'][0]
theta_matrix_b[:, :, j] = dics[j]['Theta'][1]
ssrs_t2_matrix_a[:, j] = dics[j]['SSRS_t2'][0]
ssrs_t2_matrix_b[:, j] = dics[j]['SSRS_t2'][1]
ssrs_t5_matrix_a[:, j] = dics[j]['SSRS_t5'][0]
ssrs_t5_matrix_b[:, j] = dics[j]['SSRS_t5'][1]
wage_matrix[:, :, j] = dics[j]['Wage']
spouse_income_matrix[:, :, j] = dics[j]['Spouse_income']
spouse_employment_matrix[:, :,
j] = dics[j]['Spouse_employment_matrix']
hours_matrix[:, :, j] = dics[j]['Hours']
for periodt in range(0, self.nperiods):
utils_periodt[:, :, periodt,
j] = dics[j]['Uti_values_dic'][periodt]
utils_c_periodt[:, :, periodt,
j] = dics[j]['Uti_values_c_dic'][periodt]
return {
'utils_periodt': utils_periodt,
'utils_c_periodt': utils_c_periodt,
'income_matrix': income_matrix,
'theta_matrix_a': theta_matrix_a,
'theta_matrix_b': theta_matrix_b,
'ssrs_t2_matrix_a': ssrs_t2_matrix_a,
'ssrs_t2_matrix_b': ssrs_t2_matrix_b,
'ssrs_t5_matrix_a': ssrs_t5_matrix_a,
'ssrs_t5_matrix_b': ssrs_t5_matrix_b,
'childcare_a_matrix': childcare_a_matrix,
'childcare_b_matrix': childcare_b_matrix,
'wage_matrix': wage_matrix,
'consumption_matrix': consumption_matrix,
'spouse_income_matrix': spouse_income_matrix,
'spouse_employment_matrix': spouse_employment_matrix,
'hours_matrix': hours_matrix,
'cscost_matrix': cscost_matrix,
'iscost_matrix': iscost_matrix
}
print ('')
print ('')
#########Simulating data###############
print ('')
print ('')
print ('Simulating fake data')
start_time = time.time()
print ('')
print ('')
sim_ins=simdata.SimData(N,param0,emax_dic,x_w,x_m,x_k,x_wmk,passign,nkids0,married0,
agech0,hours_p,hours_f,wr,cs,ws,model)
data_dic=sim_ins.fake_data(8)
time_sim=time.time() - start_time
print ('')
print ('')
print ('Done with procedure in:')
print("--- %s seconds ---" % (time_sim))
print ('')
print ('')
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')
def ll(self, beta):
"""
Takes structural parameters and computes the objective function for optimization
beta = [beta]
"""
#updating beta->parameters instance to compute likelihood.
self.param.alpha = beta[0] #disutility from work
self.param.gamma = beta[1] #resistance to treatment
self.param.meanshocks[0] = beta[2] #mean of resistance to treatment
self.param.meanshocks[1] = beta[
3] #mean of theta (causal effect of cc on child skills )
self.param.covshocks[1] = beta[4] #var of causal effect
self.param.covshocks[2] = beta[5] #correlation
self.param.betasw[0] = beta[6] #structural parameter of wage equation
self.param.betasw[1] = beta[7] #structural parameter of wage equation
self.param.sigma2w_reg = beta[8] #variance of res of wage equation
self.param.betastd = beta[9] #constant from test score equation
model = util.Utility(self.param, self.N, self.data)
model_sim = simdata.SimData(self.N, model)
est = self.simulation(model_sim)
labor_choice = est['Labor Choice']
cc_choice = est['CC Choice']
test_score = est['Test Score']
beta0_w = est['beta0_w']
beta1_w = est['beta1_w']
resid_var_w = est['resid_var_w']
beta1_td = est['beta1_td']
beta1_tz = est['beta1_tz']
beta1_dz = est['beta1_dz']
resid_var_td = est['resid_var_td']
#number of moments to match
num_par = labor_choice.size + cc_choice.size + test_score.size + beta0_w.size + beta1_w.size + resid_var_w.size + beta1_td.size + beta1_tz.size + beta1_dz.size + resid_var_td.size
#outer matrix
x_vector = np.zeros((num_par, 1))
#10 momentos
x_vector[0, 0] = labor_choice - self.moments_boot['Labor Choice']
x_vector[1, 0] = cc_choice - self.moments_boot['CC Choice']
x_vector[2, 0] = test_score - self.moments_boot['Test Score']
x_vector[3,
0] = beta0_w - self.moments_boot['beta0_w'] #beta0 from wage
x_vector[4,
0] = beta1_w - self.moments_boot['beta1_w'] #beta1 from wage
x_vector[5, 0] = resid_var_w - self.moments_boot[
'resid_var_w'] #resid var from wage
x_vector[6, 0] = beta1_td - self.moments_boot[
'beta1_td'] #beta1 from test vs d_cc (td)
x_vector[7, 0] = beta1_dz - self.moments_boot[
'beta1_dz'] #beta1 from d_cc vs commute (dz)
x_vector[8, 0] = beta1_tz - self.moments_boot[
'beta1_tz'] #beta1 from test vs commute (tz)
x_vector[9, 0] = resid_var_td - self.moments_boot[
'resid_var_td'] #resid var from t vs d
#The Q metric
q_w = np.dot(np.dot(np.transpose(x_vector), self.w_matrix), x_vector)
print('')
print('The objetive function value equals ', q_w)
print('')
return q_w
print('')
print('Done with procedure in:')
print("--- %s seconds ---" % (time_emax))
print('')
print('')
#########Simulating data###############
print('')
print('')
print('Simulating fake data')
start_time = time.time()
print('')
print('')
sim_ins = simdata.SimData(N, param, emax_dic, x_w, x_m, x_k, x_wmk, passign,
nkids0, married0, agech0_a, agech0_b, d_childa,
d_childb, hours_p, hours_f, wr, cs, ws, model)
data_dic = sim_ins.fake_data(8)
time_sim = time.time() - start_time
print('')
print('')
print('Done with procedure in:')
print("--- %s seconds ---" % (time_sim))
print('')
print('')
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')
def objfunction(self, beta):
"""Define objective function how a substraction of real and
simulate data """
self.param0.alphas[0][0] = beta[0]
self.param0.alphas[0][1] = beta[1]
#self.param0.alphas[0][2] = beta[2]
self.param0.alphas[0][3] = beta[2]
self.param0.alphas[0][4] = beta[3]
self.param0.alphas[0][5] = beta[4]
self.param0.alphas[1][0] = beta[5]
#self.param0.alphas[1][1] = beta[7]
self.param0.alphas[1][2] = beta[6]
self.param0.alphas[1][3] = beta[7]
self.param0.alphas[1][4] = beta[8]
self.param0.alphas[1][5] = beta[9]
self.param0.betas[0] = beta[10]
self.param0.betas[1] = beta[11]
self.param0.betas[2] = beta[12]
self.param0.betas[3] = beta[13]
self.param0.betas[4] = beta[14]
self.param0.gammas[0] = beta[15]
self.param0.gammas[1] = beta[16]
self.param0.gammas[2] = beta[17]
model = util.Utility(self.param0,self.N,self.p1_0,self.p2_0,self.years,self.treatment, \
self.typeSchool,self.HOURS,self.p1,self.p2,self.catPort,self.catPrueba,self.TrameI, \
self.priority,self.rural_rbd,self.locality)
modelSD = sd.SimData(self.N, model)
result = self.simulation(50, modelSD)
beta_mport = result['Mean Portfolio']
beta_vport = result['Var Port']
beta_msimce = result['Mean SIMCE']
beta_vsimce = result['Var SIMCE']
beta_mtest = result['Mean Test']
beta_vtest = result['Var Test']
beta_mporttest = result['Mean PortTest']
#beta_pinit = result['perc init']
beta_pinter = result['perc inter']
beta_padv = result['perc advanced']
beta_pexpert = result['perc expert']
beta_sport = result['Estimation SIMCE vs Portfolio']
beta_spru = result['Estimation SIMCE vs Prueba']
beta_expport = result['Estimation EXP vs Portfolio']
beta_exptest = result['Estimation EXP vs Prueba']
beta_sexp = result['Estimation SIMCE vs Experience']
beta_advexp_c = result['perc adv/exp control']
beta_testp = result['Estimation Test vs p']
beta_portp = result['Estimation Portfolio vs p']
#Number of moments to match
num_par = beta_mport.size + beta_vport.size + beta_msimce.size + beta_vsimce.size + beta_mtest.size + \
beta_vtest.size + beta_mporttest.size + beta_pinter.size + beta_padv.size + \
beta_pexpert.size + beta_sport.size + beta_spru.size + beta_expport.size + beta_exptest.size + \
beta_advexp_c.size + beta_testp.size + beta_portp.size + beta_sexp.size
#Outer matrix
x_vector = np.zeros((num_par, 1))
x_vector[0, 0] = beta_mport - self.moments_vector[0]
x_vector[1, 0] = beta_vport - self.moments_vector[1]
x_vector[2, 0] = beta_msimce - self.moments_vector[2]
x_vector[3, 0] = beta_vsimce - self.moments_vector[3]
x_vector[4, 0] = beta_mtest - self.moments_vector[4]
x_vector[5, 0] = beta_vtest - self.moments_vector[5]
x_vector[6, 0] = beta_mporttest - self.moments_vector[6]
x_vector[7, 0] = beta_pinter - self.moments_vector[7]
x_vector[8, 0] = beta_padv - self.moments_vector[8]
x_vector[9, 0] = beta_pexpert - self.moments_vector[9]
x_vector[10, 0] = beta_sport - self.moments_vector[10]
x_vector[11, 0] = beta_spru - self.moments_vector[11]
x_vector[12, 0] = beta_expport - self.moments_vector[12]
x_vector[13, 0] = beta_exptest - self.moments_vector[13]
x_vector[14, 0] = beta_sexp - self.moments_vector[14]
x_vector[15, 0] = beta_advexp_c - self.moments_vector[15]
x_vector[16, 0] = beta_testp - self.moments_vector[16]
x_vector[17, 0] = beta_portp - self.moments_vector[17]
#The Q metric
q_w = np.dot(np.dot(np.transpose(x_vector), self.w_matrix), x_vector)
print('')
print('The objetive function value equals ', q_w)
print('')
return q_w