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