def estimate(method, vb_iter, vb_tol, modelName, seed, drawsType, nDraws, deleteDraws, paramFixMu_inits, paramFixSi_inits, paramRndMu_inits, paramRndSi_inits, zetaMu_inits, zetaSi_inits, cK, dK_inits, rK, omega, psi_inits, nu, mu0Fix, Sigma0FixInv, mu0Rnd, Sigma0RndInv, indID, obsID, chosen, xFix, xRnd): np.random.seed(seed) ### #Prepare data ### nFix = xFix.shape[1] nRnd = xRnd.shape[1] full = method[1] in ['delta', 'mji'] xList = [xFix, xRnd] (xList, nInd, nObs, nRow, chosenIdx, nonChosenIdx, rowsPerInd, rowsPerObs, map_obs_to_ind, map_avail_to_obs) = prepareData(xList, indID, obsID, chosen, full) xFix, xRnd = xList[0], xList[1] nRow = map_avail_to_obs.shape[0] obsPerInd = np.ones((nObs, ), dtype='int64') @ map_obs_to_ind map_ind_to_avail = (map_avail_to_obs @ map_obs_to_ind).T map_avail = map_avail_to_obs @ map_avail_to_obs.T slObsInd = map_obs_to_ind @ np.arange(nInd) cumRowsPerObs = np.cumsum(rowsPerObs) slObsRow = [ slice(l, u) for l, u in zip(np.concatenate((np.array([0]), cumRowsPerObs[:-1])), cumRowsPerObs) ] chFixIdx = None chFixIdxDiag = None if nFix: chFixIdx = np.triu_indices(nFix) chFixIdx = chFixIdx[1], chFixIdx[0] chFixIdxDiagAux = np.ones((nFix, nFix), dtype='int64') chFixIdxDiagAux[chFixIdx] = np.arange((nFix * (nFix + 1) / 2)) chFixIdxDiag = np.diag(chFixIdxDiagAux) chRndIdx = None chRndIdxDiag = None if nRnd: chRndIdx = np.triu_indices(nRnd) chRndIdx = chRndIdx[1], chRndIdx[0] chRndIdxDiagAux = np.ones((nRnd, nRnd), dtype='int64') chRndIdxDiagAux[chRndIdx] = np.arange((nRnd * (nRnd + 1) / 2)) chRndIdxDiag = np.diag(chRndIdxDiagAux) slIndObs = None slIndRow = None cumObsPerInd = np.cumsum(obsPerInd) slIndObs = [ slice(l, u) for l, u in zip(np.concatenate((np.array([0]), cumObsPerInd[:-1])), cumObsPerInd) ] cumRowsPerInd = np.cumsum(rowsPerInd) slIndRow = [ slice(l, u) for l, u in zip(np.concatenate((np.array([0]), cumRowsPerInd[:-1])), cumRowsPerInd) ] ### #Generate draws ### drawsFix = None drawsRnd = None if method[1] == "qmc": if nFix: _, drawsFix = makeNormalDraws(nDraws, nFix, drawsType) if nRnd: drawsRnd, _ = makeNormalDraws(nDraws, nRnd, drawsType, nInd) ### #Coordinate Ascent ### if method[0] == "qn" and (method[1] in ["qmc", "delta"]) and nRnd == 0: vb_iter = 1 paramFixMu = np.zeros((0, )) paramFixCh = np.zeros((0, 0)) paramFixSi = np.zeros((0, 0)) if nFix: paramFixMu = paramFixMu_inits.copy() paramFixCh = np.linalg.cholesky(paramFixSi_inits).copy() paramFixSi = paramFixSi_inits.copy() paramRndMu = None paramRndCh = None paramRndSi = None zetaMu = np.zeros((0, )) zetaSi = None dK = np.zeros((0, )) psi = np.zeros((0, 0)) psiInv = None if nRnd: paramRndMu = paramRndMu_inits.copy() paramRndCh = np.linalg.cholesky(paramRndSi_inits).copy() paramRndSi = paramRndSi_inits.copy() zetaMu = zetaMu_inits.copy() zetaSi = zetaSi_inits.copy() dK = dK_inits.copy() psi = psi_inits.copy() psiInv = np.linalg.inv(psi).copy() mjiAux = None if method[1] == "mji": numer = np.ones((nRow, )) denom = map_avail @ numer mjiAux = np.array(numer / denom).reshape((nRow, 1)) tic = time.time() (paramFixMu, paramFixCh, paramFixSi, paramRndMu, paramRndCh, paramRndSi, zetaMu, zetaSi, psi, dK, mjiAux, iters, parChange) = coordinateAscent( method, vb_iter, vb_tol, paramFixMu, paramFixCh, paramFixSi, paramRndMu, paramRndCh, paramRndSi, mjiAux, xFix, nFix, chFixIdx, chFixIdxDiag, xRnd, nRnd, chRndIdx, chRndIdxDiag, drawsFix, drawsRnd, nDraws, nInd, nObs, nRow, obsPerInd, rowsPerInd, rowsPerObs, map_obs_to_ind, map_avail_to_obs, map_ind_to_avail, map_avail, slIndObs, slIndRow, slObsInd, slObsRow, mu0Fix, Sigma0FixInv, mu0Rnd, Sigma0RndInv, zetaMu, zetaSi, psi, psiInv, omega, nu, cK, dK, rK) toc = time.time() - tic print(' ') print('Computation time [s]: ' + str(toc)) ### #Delete draws ### if deleteDraws: drawsFix = None drawsRnd = None ### #Save results ### results = { 'modelName': modelName, 'seed': seed, 'estimation_time': toc, 'iters': iters, 'termTol': parChange, 'drawsType': drawsType, 'nDraws': nDraws, 'drawsFix': drawsFix, 'drawsRnd': drawsRnd, 'paramFixMu': paramFixMu, 'paramFixCh': paramFixCh, 'paramFixSi': paramFixSi, 'paramRndMu': paramRndMu, 'paramRndCh': paramRndCh, 'paramRndSi': paramRndSi, 'zetaMu': zetaMu, 'zetaSi': zetaSi, 'psi': psi, 'omega': omega, 'dK': dK, 'mjiAux': mjiAux } return results
def estimate(drawsType, nDraws, nTakes, seed, modelName, deleteDraws, simCondInd, nSim, paramFix_inits, paramRndUc_mu_inits, paramRndUc_sd_inits, paramRndCo_mu_inits, paramRndCo_ch_inits, indID, obsID, altID, chosen, xFix, xRndUc, xRndCo, xFix_trans, xRndUc_trans, xRndCo_trans): np.random.seed(seed) ### #Prepare data ### nFix = xFix.shape[1] nRndUc = xRndUc.shape[1] nRndCo = xRndCo.shape[1] nRnd = nRndUc + nRndCo if nRnd > 0: nDrawsMem, mod = divmod(nDraws, nTakes) assert mod == 0, "nDraws is not multiple of nTakes!" else: nDraws, nDrawsMem, nTakes = 1, 1, 1 xFix_transBool = np.sum(xFix_trans) > 0 xRndUc_transBool = np.sum(xRndUc_trans) > 0 xRndCo_transBool = np.sum(xRndCo_trans) > 0 xList = [xFix, xRndUc, xRndCo] (xList, nInd, nObs, nRow, chosenIdx, nonChosenIdx, rowsPerInd, rowsPerObs, map_obs_to_ind, map_avail_to_obs) = prepareData(xList, indID, obsID, chosen) xFix, xRndUc, xRndCo = xList[0], xList[1], xList[2] sim_xFix, sim_xRndUc, sim_xRndCo = np.tile(xFix, (nDrawsMem, 1)), np.tile( xRndUc, (nDrawsMem, 1)), np.tile(xRndCo, (nDrawsMem, 1)) sim_rowsPerInd = np.tile(rowsPerInd, (nDrawsMem, )) sim_map_obs_to_ind = scipy.sparse.kron(scipy.sparse.eye(nDrawsMem), map_obs_to_ind) sim_map_avail_to_obs = scipy.sparse.kron(scipy.sparse.eye(nDrawsMem), map_avail_to_obs) sim_map_draws_to_ind = scipy.sparse.hstack( [scipy.sparse.eye(nInd) for i in np.arange(nDrawsMem)]) sim_map_ind_to_avail = (sim_map_avail_to_obs @ sim_map_obs_to_ind).T chIdx = None if nRndCo: chIdx = np.triu_indices(nRndCo) chIdx = chIdx[1], chIdx[0] ### #Generate draws ### drawsUc = None drawsCo = None if nRndUc: _, drawsUc = makeNormalDraws(nDraws, nRndUc, drawsType, nInd) if nRndCo: _, drawsCo = makeNormalDraws(nDraws, nRndCo, drawsType, nInd) ### #Optimise ### paramRndCo_chVec_inits = np.ndarray.flatten(paramRndCo_ch_inits[chIdx]) inits = np.concatenate( (paramFix_inits, paramRndUc_mu_inits, paramRndUc_sd_inits, paramRndCo_mu_inits, paramRndCo_chVec_inits), axis=0) tic = time.time() resOpt = sp.optimize.minimize( fun=objectiveMxl, x0=inits, args=(sim_xFix, xFix_transBool, xFix_trans, nFix, sim_xRndUc, xRndUc_transBool, xRndUc_trans, nRndUc, sim_xRndCo, xRndCo_transBool, xRndCo_trans, nRndCo, chIdx, drawsUc, drawsCo, nDraws, nDrawsMem, nTakes, nInd, sim_rowsPerInd, sim_map_obs_to_ind, sim_map_avail_to_obs, sim_map_ind_to_avail, sim_map_draws_to_ind), method='BFGS', jac=True, options={'disp': True}) toc = time.time() - tic print(' ') print('Computation time [s]: ' + str(toc)) ### #Process output ### logLik = -resOpt['fun'] est = resOpt['x'] iHess = resOpt['hess_inv'] se = np.sqrt(np.diag(iHess)) zVal = est / se pVal = 2 * scipy.stats.norm.cdf(-np.absolute(zVal)) u = 0 if nFix > 0: l = u u += nFix lu = slice(l, u) print(' ') print('Fixed parameters:') paramFix_est, paramFix_se, paramFix_zVal, paramFix_pVal, pd_paramFix = processOutput( est, se, zVal, pVal, lu) else: paramFix_est, paramFix_se, paramFix_zVal, paramFix_pVal, pd_paramFix = None, None, None, None, None if nRndUc > 0: l = u u += nRndUc lu = slice(l, u) print(' ') print('Uncorrelated random parameters (means):') paramRndUc_mu_est, paramRndUc_mu_se, paramRndUc_mu_zVal, paramRndUc_mu_pVal, pd_paramRndUc_mu = processOutput( est, se, zVal, pVal, lu) l = u u += nRndUc lu = slice(l, u) print(' ') print('Uncorrelated random parameters (standard deviations):') paramRndUc_sd_est, paramRndUc_sd_se, paramRndUc_sd_zVal, paramRndUc_sd_pVal, pd_paramRndUc_sd = processOutput( est, se, zVal, pVal, lu) else: paramRndUc_mu_est, paramRndUc_mu_se, paramRndUc_mu_zVal, paramRndUc_mu_pVal, pd_paramRndUc_mu = None, None, None, None, None paramRndUc_sd_est, paramRndUc_sd_se, paramRndUc_sd_zVal, paramRndUc_sd_pVal, pd_paramRndUc_sd = None, None, None, None, None if nRndCo > 0: l = u u += nRndCo lu = slice(l, u) print(' ') print('Correlated random parameters (means):') paramRndCo_mu_est, paramRndCo_mu_se, paramRndCo_mu_zVal, paramRndCo_mu_pVal, pd_paramRndCo_mu = processOutput( est, se, zVal, pVal, lu) l = u u = est.shape[0] lu = slice(l, u) print(' ') print('Correlated random parameters (Cholesky):') paramRndCo_ch_est_vec, paramRndCo_ch_se_vec, paramRndCo_ch_zVal_vec, paramRndCo_ch_pVal_vec, pd_paramRndCo_ch = processOutput( est, se, zVal, pVal, lu) print(' ') print('Correlated random parameters (Cholesky, est.):') paramRndCo_ch_est = np.zeros((nRndCo, nRndCo)) paramRndCo_ch_est[chIdx] = paramRndCo_ch_est_vec print(pd.DataFrame(paramRndCo_ch_est)) print(' ') print('Correlated random parameters (Cholesky, std. err.):') paramRndCo_ch_se = np.zeros((nRndCo, nRndCo)) paramRndCo_ch_se[chIdx] = paramRndCo_ch_se_vec print(pd.DataFrame(paramRndCo_ch_se)) print(' ') print('Correlated random parameters (Cholesky, p-val.):') paramRndCo_ch_pVal = np.zeros((nRndCo, nRndCo)) paramRndCo_ch_pVal[chIdx] = paramRndCo_ch_pVal_vec print(pd.DataFrame(paramRndCo_ch_pVal)) else: paramRndCo_mu_est, paramRndCo_mu_se, paramRndCo_mu_zVal, paramRndCo_mu_pVal, pd_paramRndCo_mu = None, None, None, None, None paramRndCo_ch_est, paramRndCo_ch_se, paramRndCo_ch_pVal, pd_paramRndCo_ch = None, None, None, None print(' ') print('Log-likelihood: ' + str(logLik)) print(' ') if nRnd: print('QMC method: ' + drawsType) print('Number of simulation draws: ' + str(nDraws)) ### #Conditional expectation of individual-specific parameters ### if simCondInd and nRnd > 0: paramRndUc_ind, paramRndCo_ind = condExpInd( paramFix_est, paramRndUc_mu_est, paramRndUc_sd_est, paramRndCo_mu_est, paramRndCo_ch_est, xFix, xFix_transBool, xFix_trans, nFix, xRndUc, xRndUc_transBool, xRndUc_trans, nRndUc, xRndCo, xRndCo_transBool, xRndCo_trans, nRndCo, nInd, rowsPerInd, map_obs_to_ind, map_avail_to_obs, nSim) else: paramRndUc_ind, paramRndCo_ind = None, None ### #Delete draws ### if deleteDraws: drawsUc = None drawsCo = None ### #Save results ### results = { 'modelName': modelName, 'seed': seed, 'estimation_time': toc, 'drawsType': drawsType, 'nDraws': nDraws, 'nSim': nSim, 'drawsUc': drawsUc, 'drawsCo': drawsCo, 'logLik': logLik, 'est': est, 'iHess': iHess, 'paramFix_est': paramFix_est, 'paramFix_se': paramFix_se, 'paramFix_zVal': paramFix_zVal, 'paramFix_pVal': paramFix_pVal, 'pd_paramFix': pd_paramFix, 'paramRndUc_mu_est': paramRndUc_mu_est, 'paramRndUc_mu_se': paramRndUc_mu_se, 'paramRndUc_mu_zVal': paramRndUc_mu_zVal, 'paramRndUc_mu_pVal': paramRndUc_mu_pVal, 'pd_paramRndUc_mu': pd_paramRndUc_mu, 'paramRndUc_sd_est': paramRndUc_sd_est, 'paramRndUc_sd_se': paramRndUc_sd_se, 'paramRndUc_sd_zVal': paramRndUc_sd_zVal, 'paramRndUc_sd_pVal': paramRndUc_sd_pVal, 'pd_paramRndUc_sd': pd_paramRndUc_sd, 'paramRndCo_mu_est': paramRndCo_mu_est, 'paramRndCo_mu_se': paramRndCo_mu_se, 'paramRndCo_mu_zVal': paramRndCo_mu_zVal, 'paramRndCo_mu_pVal': paramRndCo_mu_pVal, 'pd_paramRndCo_mu': pd_paramRndCo_mu, 'paramRndCo_ch_est': paramRndCo_ch_est, 'paramRndCo_ch_se': paramRndCo_ch_se, 'paramRndCo_ch_pVal': paramRndCo_ch_pVal, 'pd_paramRndCo_ch': pd_paramRndCo_ch, 'paramRndUc_ind': paramRndUc_ind, 'paramRndCo_ind': paramRndCo_ind, 'resOpt': resOpt } return results
def estimate(mcmc_nChain, mcmc_iterBurn, mcmc_iterSample, mcmc_thin, mcmc_iterMem, mcmc_disp, seed, simLogLik, simLogLikDrawsType, simDraws, rho, modelName, deleteDraws, A, nu, diagCov, zeta_inits, OmegaB_inits, OmegaW_inits, indID, obsID, altID, chosen, xRnd, xRnd_trans): ### #Prepare data ### nRnd = xRnd.shape[1] xRnd_transBool = np.sum(xRnd_trans) > 0 xList = [xRnd] (xList, nInd, nObs, nRow, chosenIdx, nonChosenIdx, rowsPerInd, rowsPerObs, map_obs_to_ind, map_avail_to_obs) = prepareData(xList, indID, obsID, chosen) xRnd = xList[0] obsPerInd = np.ones((nObs, ), dtype='int64') @ map_obs_to_ind assert np.unique(obsPerInd).shape[0] == 1, \ "Number of choice tasks must be the same for all decision makers!" ### #Posterior sampling ### mcmc_iter = mcmc_iterBurn + mcmc_iterSample mcmc_iterSampleThin = floor(mcmc_iterSample / mcmc_thin) mcmc_iterMemThin = floor(mcmc_iterMem / mcmc_thin) A = A * np.ones((nRnd, )) invASq = A**(-2) zeta = zeta_inits OmegaB = OmegaB_inits OmegaW = OmegaW_inits tic = time.time() Parallel(n_jobs=mcmc_nChain)(delayed(mcmcChain)( c, seed, mcmc_iter, mcmc_iterBurn, mcmc_iterSampleThin, mcmc_iterMemThin, mcmc_thin, mcmc_disp, rho, modelName, zeta, OmegaB, OmegaW, invASq, nu, diagCov, xRnd, xRnd_transBool, xRnd_trans, nRnd, nInd, nObs, obsPerInd, rowsPerObs, map_obs_to_ind, map_avail_to_obs) for c in range(mcmc_nChain)) toc = time.time() - tic print(' ') print('Computation time [s]: ' + str(toc)) ### #Posterior analysis ### postMean_zeta, pdTabPostAna_zeta = postAna('zeta', nRnd, 1, mcmc_nChain, mcmc_iterSampleThin, modelName) print(' ') print('Random parameters (means):') print(pdTabPostAna_zeta) postMean_sdB, pdTabPostAna_sdB = postAna('sdB', nRnd, 1, mcmc_nChain, mcmc_iterSampleThin, modelName) print(' ') print('Random parameters (standard deviations; between):') print(pdTabPostAna_sdB) postMean_OmegaB, pdTabPostAna_OmegaB = postAna('OmegaB', nRnd, nRnd, mcmc_nChain, mcmc_iterSampleThin, modelName) print(' ') print('Random parameters (covariance matrix; between):') print(pdTabPostAna_OmegaB) postMean_CorrB, pdTabPostAna_CorrB = postAna('CorrB', nRnd, nRnd, mcmc_nChain, mcmc_iterSampleThin, modelName) print(' ') print('Random parameters (correlation matrix; between):') print(pdTabPostAna_CorrB) postMean_sdW, pdTabPostAna_sdW = postAna('sdW', nRnd, 1, mcmc_nChain, mcmc_iterSampleThin, modelName) print(' ') print('Random parameters (standard deviations; within):') print(pdTabPostAna_sdW) postMean_OmegaW, pdTabPostAna_OmegaW = postAna('OmegaW', nRnd, nRnd, mcmc_nChain, mcmc_iterSampleThin, modelName) print(' ') print('Random parameters (covariance matrix; within):') print(pdTabPostAna_OmegaW) postMean_CorrW, pdTabPostAna_CorrW = postAna('CorrW', nRnd, nRnd, mcmc_nChain, mcmc_iterSampleThin, modelName) print(' ') print('Random parameters (correlation matrix; within):') print(pdTabPostAna_CorrW) postMean_paramRndB, pdTabPostAna_paramRndB = postAna( 'paramRndB', nInd, nRnd, mcmc_nChain, mcmc_iterSampleThin, modelName) ### #Simulate log-likelihood at posterior means ### if simLogLik: print(' ') np.random.seed(seed) postMean_chOmegaB = np.linalg.cholesky(postMean_OmegaB) postMean_chOmegaW = np.linalg.cholesky(postMean_OmegaW) _, drawsB = makeNormalDraws(simDraws, nRnd, simLogLikDrawsType, nInd) drawsB = np.array(drawsB).reshape((simDraws, nInd, nRnd)) _, drawsW = makeNormalDraws(simDraws, nRnd, simLogLikDrawsType, nObs) drawsW = np.array(drawsW).reshape((simDraws, nObs, nRnd)) pIndSim = 0 for i in np.arange(simDraws): paramRndB = postMean_zeta + ( postMean_chOmegaB @ drawsB[i, :, :].T).T paramRndB_perObs = np.repeat(paramRndB, obsPerInd, axis=0) pObsSim = 0 for j in np.arange(simDraws): paramRndW = paramRndB_perObs + ( postMean_chOmegaW @ drawsW[j, :, :].T).T pChosen, _ = probMxl(paramRndW, xRnd, xRnd_transBool, xRnd_trans, rowsPerObs, map_avail_to_obs) pObsSim += pChosen pObsSim /= simDraws pIndSim += np.exp(np.log(pObsSim) @ map_obs_to_ind) if ((i + 1) % 50) == 0: print('Log-likelihood simulation (inter-ind. draws): ' + str(i + 1)) sys.stdout.flush() pIndSim /= simDraws logLik = np.sum(np.log(pIndSim)) print(' ') print('Log-likelihood (simulated at posterior means): ' + str(logLik)) else: logLik = None ### #Delete draws ### if deleteDraws: for c in range(mcmc_nChain): os.remove(modelName + '_draws_chain' + str(c + 1) + '.hdf5') ### #Save results ### results = { 'modelName': modelName, 'seed': seed, 'estimation_time': toc, 'logLik': logLik, 'postMean_paramRndB': postMean_paramRndB, 'pdTabPostAna_paramRndB': pdTabPostAna_paramRndB, 'postMean_zeta': postMean_zeta, 'pdTabPostAna_zeta': pdTabPostAna_zeta, 'postMean_sdB': postMean_sdB, 'pdTabPostAna_sdB': pdTabPostAna_sdB, 'postMean_OmegaB': postMean_OmegaB, 'pdTabPostAna_OmegaB': pdTabPostAna_OmegaB, 'postMean_CorrB': postMean_CorrB, 'pdTabPostAna_CorrB': pdTabPostAna_CorrB, 'postMean_sdW': postMean_sdW, 'pdTabPostAna_sdW': pdTabPostAna_sdW, 'postMean_OmegaW': postMean_OmegaW, 'pdTabPostAna_OmegaW': pdTabPostAna_OmegaW, 'postMean_CorrW': postMean_CorrW, 'pdTabPostAna_CorrW': pdTabPostAna_CorrW, } return results
def estimate( svb, vb, vb_iter, vb_tol, modelName, seed, local_iter, local_tol, svb_eta, svb_kappa, K, N_K, T_K, drawsType, nDrawsB, nDrawsW_m, paramRndMuB_inits, paramRndSiB_inits, paramRndMuW_inits, paramRndSiW_inits, zetaMu_inits, zetaSi_inits, cK, rK, omegaB, psiB_inits, dK_B_inits, omegaW, psiW_inits, dK_W_inits, mu0Rnd, Sigma0RndInv, nu, A, indID, obsID, chosen, xRnd, intra): assert svb or vb, "Method not supported!" np.random.seed(seed) if intra: local_iter = 1 ### #Prepare data ### (xRnd, nInd, nObs, obsPerInd, nAlt, nRnd, chosenIdx, nonChosenIdx) = prepareData_vb(xRnd, indID, obsID, chosen) chRndIdx = np.triu_indices(nRnd); chRndIdx = chRndIdx[1], chRndIdx[0]; chRndIdxDiagAux = np.ones((nRnd, nRnd), dtype = 'int64') chRndIdxDiagAux[chRndIdx] = np.arange((nRnd * (nRnd + 1) / 2)) chRndIdxDiag = np.diag(chRndIdxDiagAux) tic = time.time() ### #SVB/VB ### #Initialise zetaMu = zetaMu_inits.copy() zetaSi = zetaSi_inits.copy() psiB = psiB_inits.copy() psiBInv = np.linalg.inv(psiB) dK_B = dK_B_inits.copy() psiW = psiW_inits.copy() psiWInv = np.linalg.inv(psiW) dK_W = dK_W_inits.copy() if svb: ### #Generate draws ### if not intra: nDrawsW_m = 1 nDrawsW = nDrawsB * nDrawsW_m drawsB = makeNormalDraws(nDrawsB, nRnd, drawsType, N_K)[0] if intra: drawsW = makeNormalDraws(nDrawsW, nRnd, drawsType, N_K * T_K)[0] drawsW = drawsW.reshape((N_K, T_K, nDrawsW, nRnd)) else: drawsW = np.zeros((N_K, T_K, nDrawsW, nRnd)) ### #Coordinate Ascent ### (zetaMu, zetaSi, psiB, dK_B, psiW, dK_W, iters, parChange) = coordinateAscent_svb( vb_iter, vb_tol, svb_eta, svb_kappa, local_iter, local_tol, zetaMu, zetaSi, psiB, psiBInv, omegaB, dK_B, psiW, psiWInv, omegaW, dK_W, nu, cK, rK, mu0Rnd, Sigma0RndInv, xRnd, nRnd, chRndIdx, chRndIdxDiag, intra, nInd, obsPerInd, nAlt, K[0], N_K, T_K, drawsB, nDrawsB, drawsW, nDrawsW, nDrawsW_m) if vb: ### #Generate draws ### if not intra: nDrawsW_m = 1 nDrawsW = nDrawsB * nDrawsW_m drawsB = makeNormalDraws(nDrawsB, nRnd, drawsType, nInd)[0] if intra: drawsW = makeNormalDraws(nDrawsW, nRnd, drawsType, nObs)[0] drawsW = drawsW.reshape((nInd, obsPerInd, nDrawsW, nRnd)) else: drawsW = np.zeros((nInd, obsPerInd, nDrawsW, nRnd)) ### #Coordinate Ascent ### paramRndMuB = paramRndMuB_inits.copy() paramRndSiB = paramRndSiB_inits.copy() paramRndChB = np.linalg.cholesky(paramRndSiB) paramRndMuW = paramRndMuW_inits.copy().reshape((nInd, obsPerInd, nRnd)) paramRndSiW = paramRndSiW_inits.copy().reshape((nInd, obsPerInd, nRnd, nRnd)) paramRndChW = np.linalg.cholesky(paramRndSiW) (paramRndMuW, paramRndSiW, paramRndMuB, paramRndSiB, zetaMu, zetaSi, psiB, dK_B, psiW, dK_W, iters, parChange) = coordinateAscent_vb( vb_iter, vb_tol, local_iter, local_tol, paramRndMuB, paramRndChB, paramRndSiB, paramRndMuW, paramRndChW, paramRndSiW, zetaMu, zetaSi, psiB, psiBInv, omegaB, dK_B, psiW, psiWInv, omegaW, dK_W, nu, cK, rK, mu0Rnd, Sigma0RndInv, xRnd, nRnd, chRndIdx, chRndIdxDiag, intra, nInd, obsPerInd, nAlt, K[1], int(nInd / K[1]), drawsB, nDrawsB, drawsW, nDrawsW, nDrawsW_m) ### #Estimation time ### toc = time.time() - tic print(' ') print('Computation time [s]: ' + str(toc)) ### #Save results ### results = {'modelName': modelName, 'estimation_time': toc, 'iters': iters, 'termTol': parChange, 'paramRndMuB': paramRndMuB, 'paramRndSiB': paramRndSiB, 'paramRndMuW': paramRndMuW, 'paramRndSiW': paramRndSiW, 'zetaMu': zetaMu, 'zetaSi': zetaSi, 'psiB': psiB, 'dK_B': dK_B, 'omegaB': omegaB, 'psiW': psiW, 'dK_W': dK_W, 'omegaW': omegaW, } return results
def estimate(drawsType, nDrawsB, nTakesB, nDrawsW, nTakesW, K, seed, modelName, deleteDraws, paramFix_inits, paramRndUc_mu_inits, paramRndUc_sd_inits, paramRndCo_mu_inits, paramRndCo_ch_inits, paramRnd2Uc_mu_inits, paramRnd2Uc_sdB_inits, paramRnd2Uc_sdW_inits, paramRnd2Co_mu_inits, paramRnd2Co_chB_inits, paramRnd2Co_chW_inits, indID, obsID, altID, chosen, xFix, xRndUc, xRndCo, xRnd2Uc, xRnd2Co, xFix_trans, xRndUc_trans, xRndCo_trans, xRnd2Uc_trans, xRnd2Co_trans): np.random.seed(seed) ### #Prepare data ### nFix = xFix.shape[1] nRndUc = xRndUc.shape[1] nRndCo = xRndCo.shape[1] nRnd = nRndUc + nRndCo nRnd2Uc = xRnd2Uc.shape[1] nRnd2Co = xRnd2Co.shape[1] nRnd2 = nRnd2Uc + nRnd2Co if nRnd == 0 and nRnd2 == 0: nDrawsB = 1 nDrawsBMem = 1 nTakesB = 1 nDrawsW = 1 nDrawsWMem = 1 nTakesW = 1 if nRnd > 0 and nRnd2 == 0: K = 1 nDrawsBMem, mod = divmod(nDrawsB, nTakesB) assert mod == 0, "nDrawsB is not multiple of nTakesB!" nDrawsW, nDrawsWMem, nTakesW = 1, 1, 1 if nRnd2 > 0: #If there are random parameters with intra-individual heterogeneity, #nDrawsBMem is necessarily one nDrawsBMem = 1 nTakesB = int(nDrawsB / K) nDrawsWMem, mod = divmod(nDrawsW, nTakesW) assert mod == 0, "nDrawsW is not multiple of nTakesW!" nDrawsMem = nDrawsBMem * nDrawsWMem xFix_transBool = np.sum(xFix_trans) > 0 xRndUc_transBool = np.sum(xRndUc_trans) > 0 xRndCo_transBool = np.sum(xRndCo_trans) > 0 xRnd2Uc_transBool = np.sum(xRnd2Uc_trans) > 0 xRnd2Co_transBool = np.sum(xRnd2Co_trans) > 0 xList = [xFix, xRndUc, xRndCo, xRnd2Uc, xRnd2Co] (xList, nInd, nObs, nRow, chosenIdx, nonChosenIdx, rowsPerInd, rowsPerObs, map_obs_to_ind, map_avail_to_obs) = prepareData(xList, indID, obsID, chosen) xFix, xRndUc, xRndCo, xRnd2Uc, xRnd2Co = xList[0], xList[1], xList[ 2], xList[3], xList[4] sim_xFix = np.tile(xFix, (nDrawsMem, 1)) sim_xRndUc = np.tile(xRndUc, (nDrawsMem, 1)) sim_xRndCo = np.tile(xRndCo, (nDrawsMem, 1)) sim_xRnd2Uc = np.tile(xRnd2Uc, (nDrawsMem, 1)) sim_xRnd2Co = np.tile(xRnd2Co, (nDrawsMem, 1)) #Good obsPerInd = np.array(map_obs_to_ind.sum(axis=0)).reshape((-1, )) simB_obsPerInd = np.tile(obsPerInd, (nDrawsBMem, )) simB_rowsPerInd = np.tile(rowsPerInd, (nDrawsBMem, )) simW_rowsPerObs = np.tile(rowsPerObs, (nDrawsWMem, )) #Good simB_map_obs_to_ind = scipy.sparse.kron(scipy.sparse.eye(nDrawsBMem), map_obs_to_ind) simW_map_avail_to_obs = scipy.sparse.kron(scipy.sparse.eye(nDrawsMem), map_avail_to_obs) simB_map_draws_to_ind = scipy.sparse.hstack( [scipy.sparse.eye(nInd) for i in np.arange(nDrawsBMem)]) map_obs_to_obs = scipy.sparse.eye(nObs) map_aux = scipy.sparse.csr_matrix(np.ones((nDrawsWMem, 1)), dtype='int64') simW_map_drawsW_to_obs = scipy.sparse.kron(map_aux, map_obs_to_obs) simW_map_drawsB_to_obs = scipy.sparse.kron(np.eye(nDrawsBMem), simW_map_drawsW_to_obs).T chIdx = None if nRndCo: chIdx = np.triu_indices(nRndCo) chIdx = chIdx[1], chIdx[0] ch2Idx = None if nRnd2Co: ch2Idx = np.triu_indices(nRnd2Co) ch2Idx = ch2Idx[1], ch2Idx[0] ### #Generate draws ### drawsUc = np.zeros((K, 1, 1, 1)) drawsCo = np.zeros((K, 1, 1, 1)) drawsUcB = np.zeros((K, 1, 1, 1)) drawsUcW = np.zeros((K, 1, 1, 1)) drawsCoB = np.zeros((K, 1, 1, 1)) drawsCoW = np.zeros((K, 1, 1, 1)) if nRndUc: _, drawsUc = makeNormalDraws(nDrawsB, nRndUc, drawsType, nInd) drawsUc = drawsUc.reshape( (K, nTakesB, int(nInd * nDrawsB / K / nTakesB), nRndCo)) if nRndCo: _, drawsCo = makeNormalDraws(nDrawsB, nRndCo, drawsType, nInd) drawsCo = drawsCo.reshape( (K, nTakesB, int(nInd * nDrawsB / K / nTakesB), nRndCo)) if nRnd2Uc: _, drawsUcB = makeNormalDraws(nDrawsB, nRnd2Uc, drawsType, nInd) _, drawsUcW = makeNormalDraws(nDrawsW, nRnd2Uc, drawsType, nObs) drawsUcB = drawsUcB.reshape( (K, nTakesB, int(nInd * nDrawsB / K / nTakesB), nRnd2Uc)) drawsUcW = drawsUcW.reshape( (nTakesW, int(nObs * nDrawsW / nTakesW), nRnd2Uc)) if nRnd2Co: _, drawsCoB = makeNormalDraws(nDrawsB, nRnd2Co, drawsType, nInd) _, drawsCoW = makeNormalDraws(nDrawsW, nRnd2Co, drawsType, nObs) drawsCoB = drawsCoB.reshape( (K, nTakesB, int(nInd * nDrawsB / K / nTakesB), nRnd2Co)) drawsCoW = drawsCoW.reshape( (nTakesW, int(nObs * nDrawsW / nTakesW), nRnd2Co)) ### #Optimise ### paramRndCo_chVec_inits = np.ndarray.flatten(paramRndCo_ch_inits[chIdx]) paramRnd2Co_chBVec_inits = np.ndarray.flatten( paramRnd2Co_chB_inits[ch2Idx]) paramRnd2Co_chWVec_inits = np.ndarray.flatten( paramRnd2Co_chW_inits[ch2Idx]) inits = np.concatenate( (paramFix_inits, paramRndUc_mu_inits, paramRndUc_sd_inits, paramRndCo_mu_inits, paramRndCo_chVec_inits, paramRnd2Uc_mu_inits, paramRnd2Uc_sdB_inits, paramRnd2Uc_sdW_inits, paramRnd2Co_mu_inits, paramRnd2Co_chBVec_inits, paramRnd2Co_chWVec_inits), axis=0) tic = time.time() algo = 'L-BFGS-B' resOpt = sp.optimize.minimize( fun=objectiveMxl, x0=inits, args=(False, K, sim_xFix, xFix_transBool, xFix_trans, nFix, sim_xRndUc, xRndUc_transBool, xRndUc_trans, nRndUc, sim_xRndCo, xRndCo_transBool, xRndCo_trans, nRndCo, chIdx, sim_xRnd2Uc, xRnd2Uc_transBool, xRnd2Uc_trans, nRnd2Uc, sim_xRnd2Co, xRnd2Co_transBool, xRnd2Co_trans, nRnd2Co, ch2Idx, drawsUc, drawsCo, nDrawsMem, drawsUcB, drawsCoB, nDrawsB, nDrawsBMem, nTakesB, drawsUcW, drawsCoW, nDrawsW, nDrawsWMem, nTakesW, nInd, nObs, simB_rowsPerInd, simB_obsPerInd, simW_rowsPerObs, simB_map_obs_to_ind, simB_map_draws_to_ind, simW_map_avail_to_obs, simW_map_drawsB_to_obs), method=algo, jac=True, options={'disp': True}) toc = time.time() - tic print(' ') print('Computation time [s]: ' + str(toc)) ### #Process output ### logLik = -resOpt['fun'] est = resOpt['x'] if algo == 'BFGS': iHess = resOpt['hess_inv'] if algo == 'L-BFGS-B': ll, gr, bhhh = objectiveMxl( est, True, K, sim_xFix, xFix_transBool, xFix_trans, nFix, sim_xRndUc, xRndUc_transBool, xRndUc_trans, nRndUc, sim_xRndCo, xRndCo_transBool, xRndCo_trans, nRndCo, chIdx, sim_xRnd2Uc, xRnd2Uc_transBool, xRnd2Uc_trans, nRnd2Uc, sim_xRnd2Co, xRnd2Co_transBool, xRnd2Co_trans, nRnd2Co, ch2Idx, drawsUc, drawsCo, nDrawsMem, drawsUcB, drawsCoB, nDrawsB, nDrawsBMem, nTakesB, drawsUcW, drawsCoW, nDrawsW, nDrawsWMem, nTakesW, nInd, nObs, simB_rowsPerInd, simB_obsPerInd, simW_rowsPerObs, simB_map_obs_to_ind, simB_map_draws_to_ind, simW_map_avail_to_obs, simW_map_drawsB_to_obs) iHess = np.linalg.inv(bhhh) se = np.sqrt(np.diag(iHess)) zVal = est / se pVal = 2 * scipy.stats.norm.cdf(-np.absolute(zVal)) u = 0 if nFix > 0: l = u u += nFix lu = slice(l, u) print(' ') print('Fixed parameters:') paramFix_est, paramFix_se, paramFix_zVal, paramFix_pVal, pd_paramFix = processOutput( est, se, zVal, pVal, lu) else: paramFix_est, paramFix_se, paramFix_zVal, paramFix_pVal, pd_paramFix = None, None, None, None, None if nRndUc > 0: l = u u += nRndUc lu = slice(l, u) print(' ') print('Uncorrelated random parameters (means):') paramRndUc_mu_est, paramRndUc_mu_se, paramRndUc_mu_zVal, paramRndUc_mu_pVal, pd_paramRndUc_mu = processOutput( est, se, zVal, pVal, lu) l = u u += nRndUc lu = slice(l, u) print(' ') print('Uncorrelated random parameters (standard deviations):') paramRndUc_sd_est, paramRndUc_sd_se, paramRndUc_sd_zVal, paramRndUc_sd_pVal, pd_paramRndUc_sd = processOutput( est, se, zVal, pVal, lu) else: paramRndUc_mu_est, paramRndUc_mu_se, paramRndUc_mu_zVal, paramRndUc_mu_pVal, pd_paramRndUc_mu = None, None, None, None, None paramRndUc_sd_est, paramRndUc_sd_se, paramRndUc_sd_zVal, paramRndUc_sd_pVal, pd_paramRndUc_sd = None, None, None, None, None if nRndCo > 0: l = u u += nRndCo lu = slice(l, u) print(' ') print('Correlated random parameters (means):') paramRndCo_mu_est, paramRndCo_mu_se, paramRndCo_mu_zVal, paramRndCo_mu_pVal, pd_paramRndCo_mu = processOutput( est, se, zVal, pVal, lu) l = u u += int((nRndCo * (nRndCo + 1)) / 2) lu = slice(l, u) print(' ') print('Correlated random parameters (Cholesky):') paramRndCo_ch_est_vec, paramRndCo_ch_se_vec, paramRndCo_ch_zVal_vec, paramRndCo_ch_pVal_vec, pd_paramRndCo_ch = processOutput( est, se, zVal, pVal, lu) print(' ') print('Correlated random parameters (Cholesky, est.):') paramRndCo_ch_est = np.zeros((nRndCo, nRndCo)) paramRndCo_ch_est[chIdx] = paramRndCo_ch_est_vec print(pd.DataFrame(paramRndCo_ch_est)) print(' ') print('Correlated random parameters (Cholesky, std. err.):') paramRndCo_ch_se = np.zeros((nRndCo, nRndCo)) paramRndCo_ch_se[chIdx] = paramRndCo_ch_se_vec print(pd.DataFrame(paramRndCo_ch_se)) print(' ') print('Correlated random parameters (Cholesky, p-val.):') paramRndCo_ch_pVal = np.zeros((nRndCo, nRndCo)) paramRndCo_ch_pVal[chIdx] = paramRndCo_ch_pVal_vec print(pd.DataFrame(paramRndCo_ch_pVal)) else: paramRndCo_mu_est, paramRndCo_mu_se, paramRndCo_mu_zVal, paramRndCo_mu_pVal, pd_paramRndCo_mu = None, None, None, None, None paramRndCo_ch_est, paramRndCo_ch_se, paramRndCo_ch_pVal, pd_paramRndCo_ch = None, None, None, None if nRnd2Uc > 0: l = u u += nRnd2Uc lu = slice(l, u) print(' ') print('Uncorrelated random parameters - intra (means):') paramRnd2Uc_mu_est, paramRnd2Uc_mu_se, paramRnd2Uc_mu_zVal, paramRnd2Uc_mu_pVal, pd_paramRnd2Uc_mu = processOutput( est, se, zVal, pVal, lu) l = u u += nRnd2Uc lu = slice(l, u) print(' ') print( 'Uncorrelated random parameters - intra-between (standard deviations):' ) paramRnd2Uc_sdB_est, paramRnd2Uc_sdB_se, paramRnd2Uc_sdB_zVal, paramRnd2Uc_sdB_pVal, pd_paramRnd2Uc_sdB = processOutput( est, se, zVal, pVal, lu) l = u u += nRnd2Uc lu = slice(l, u) print(' ') print( 'Uncorrelated random parameters - intra-within (standard deviations):' ) paramRnd2Uc_sdW_est, paramRnd2Uc_sdW_se, paramRnd2Uc_sdW_zVal, paramRnd2Uc_sdW_pVal, pd_paramRnd2Uc_sdW = processOutput( est, se, zVal, pVal, lu) else: paramRnd2Uc_mu_est, paramRnd2Uc_mu_se, paramRnd2Uc_mu_zVal, paramRnd2Uc_mu_pVal, pd_paramRnd2Uc_mu = None, None, None, None, None paramRnd2Uc_sdB_est, paramRnd2Uc_sdB_se, paramRnd2Uc_sdB_zVal, paramRnd2Uc_sdB_pVal, pd_paramRnd2Uc_sdB = None, None, None, None, None paramRnd2Uc_sdW_est, paramRnd2Uc_sdW_se, paramRnd2Uc_sdW_zVal, paramRnd2Uc_sdW_pVal, pd_paramRnd2Uc_sdW = None, None, None, None, None if nRnd2Co > 0: l = u u += nRnd2Co lu = slice(l, u) print(' ') print('Correlated random parameters - intra (means):') paramRnd2Co_mu_est, paramRnd2Co_mu_se, paramRnd2Co_mu_zVal, paramRnd2Co_mu_pVal, pd_paramRnd2Co_mu = processOutput( est, se, zVal, pVal, lu) l = u u += int((nRnd2Co * (nRnd2Co + 1)) / 2) lu = slice(l, u) print(' ') print('Correlated random parameters - intra-between (Cholesky):') paramRnd2Co_chB_est_vec, paramRnd2Co_chB_se_vec, paramRnd2Co_chB_zVal_vec, paramRnd2Co_chB_pVal_vec, pd_paramRnd2Co_chB = processOutput( est, se, zVal, pVal, lu) print(' ') print('Correlated random parameters - intra-between (Cholesky, est.):') paramRnd2Co_chB_est = np.zeros((nRnd2Co, nRnd2Co)) paramRnd2Co_chB_est[ch2Idx] = paramRnd2Co_chB_est_vec print(pd.DataFrame(paramRnd2Co_chB_est)) print(' ') print( 'Correlated random parameters - intra-between (Cholesky, std. err.):' ) paramRnd2Co_chB_se = np.zeros((nRnd2Co, nRnd2Co)) paramRnd2Co_chB_se[ch2Idx] = paramRnd2Co_chB_se_vec print(pd.DataFrame(paramRnd2Co_chB_se)) print(' ') print( 'Correlated random parameters - intra-between (Cholesky, p-val.):') paramRnd2Co_chB_pVal = np.zeros((nRnd2Co, nRnd2Co)) paramRnd2Co_chB_pVal[ch2Idx] = paramRnd2Co_chB_pVal_vec print(pd.DataFrame(paramRnd2Co_chB_pVal)) l = u u += int((nRnd2Co * (nRnd2Co + 1)) / 2) lu = slice(l, u) print(' ') print('Correlated random parameters - intra-within (Cholesky):') paramRnd2Co_chW_est_vec, paramRnd2Co_chW_se_vec, paramRnd2Co_chW_zVal_vec, paramRnd2Co_chW_pVal_vec, pd_paramRnd2Co_chW = processOutput( est, se, zVal, pVal, lu) print(' ') print('Correlated random parameters - intra-within (Cholesky, est.):') paramRnd2Co_chW_est = np.zeros((nRnd2Co, nRnd2Co)) paramRnd2Co_chW_est[ch2Idx] = paramRnd2Co_chW_est_vec print(pd.DataFrame(paramRnd2Co_chW_est)) print(' ') print( 'Correlated random parameters - intra-within (Cholesky, std. err.):' ) paramRnd2Co_chW_se = np.zeros((nRnd2Co, nRnd2Co)) paramRnd2Co_chW_se[ch2Idx] = paramRnd2Co_chW_se_vec print(pd.DataFrame(paramRnd2Co_chW_se)) print(' ') print( 'Correlated random parameters - intra-within (Cholesky, p-val.):') paramRnd2Co_chW_pVal = np.zeros((nRnd2Co, nRnd2Co)) paramRnd2Co_chW_pVal[ch2Idx] = paramRnd2Co_chW_pVal_vec print(pd.DataFrame(paramRnd2Co_chW_pVal)) else: paramRnd2Co_mu_est, paramRnd2Co_mu_se, paramRnd2Co_mu_zVal, paramRnd2Co_mu_pVal, pd_paramRnd2Co_mu = None, None, None, None, None paramRnd2Co_chB_est, paramRnd2Co_chB_se, paramRnd2Co_chB_pVal, pd_paramRnd2Co_chB = None, None, None, None paramRnd2Co_chW_est, paramRnd2Co_chW_se, paramRnd2Co_chW_pVal, pd_paramRnd2Co_chW = None, None, None, None print(' ') print('Log-likelihood: ' + str(logLik)) print(' ') if nRnd: print('QMC method: ' + drawsType) print('Number of simulation draws: ' + str(nDrawsB) + ' (inter); ' + str(nDrawsW) + ' (intra)') ### #Delete draws ### if deleteDraws: drawsUc = None drawsCo = None drawsUcB = None drawsCoB = None drawsUcW = None drawsCoW = None ### #Save results ### results = { 'modelName': modelName, 'seed': seed, 'estimation_time': toc, 'drawsType': drawsType, 'nDraws_inter': nDrawsB, 'nDraws_intra': nDrawsW, 'drawsUc': drawsUc, 'drawsCo': drawsCo, 'logLik': logLik, 'est': est, 'iHess': iHess, 'paramFix_est': paramFix_est, 'paramFix_se': paramFix_se, 'paramFix_zVal': paramFix_zVal, 'paramFix_pVal': paramFix_pVal, 'pd_paramFix': pd_paramFix, 'paramRndUc_mu_est': paramRndUc_mu_est, 'paramRndUc_mu_se': paramRndUc_mu_se, 'paramRndUc_mu_zVal': paramRndUc_mu_zVal, 'paramRndUc_mu_pVal': paramRndUc_mu_pVal, 'pd_paramRndUc_mu': pd_paramRndUc_mu, 'paramRndUc_sd_est': paramRndUc_sd_est, 'paramRndUc_sd_se': paramRndUc_sd_se, 'paramRndUc_sd_zVal': paramRndUc_sd_zVal, 'paramRndUc_sd_pVal': paramRndUc_sd_pVal, 'pd_paramRndUc_sd': pd_paramRndUc_sd, 'paramRndCo_mu_est': paramRndCo_mu_est, 'paramRndCo_mu_se': paramRndCo_mu_se, 'paramRndCo_mu_zVal': paramRndCo_mu_zVal, 'paramRndCo_mu_pVal': paramRndCo_mu_pVal, 'pd_paramRndCo_mu': pd_paramRndCo_mu, 'paramRndCo_ch_est': paramRndCo_ch_est, 'paramRndCo_ch_se': paramRndCo_ch_se, 'paramRndCo_ch_pVal': paramRndCo_ch_pVal, 'pd_paramRndCo_ch': pd_paramRndCo_ch, 'paramRnd2Uc_mu_est': paramRnd2Uc_mu_est, 'paramRnd2Uc_mu_se': paramRnd2Uc_mu_se, 'paramRnd2Uc_mu_zVal': paramRnd2Uc_mu_zVal, 'paramRnd2Uc_mu_pVal': paramRnd2Uc_mu_pVal, 'pd_paramRnd2Uc_mu': pd_paramRnd2Uc_mu, 'paramRnd2Uc_sdB_est': paramRnd2Uc_sdB_est, 'paramRnd2Uc_sdB_se': paramRnd2Uc_sdB_se, 'paramRnd2Uc_sdB_zVal': paramRnd2Uc_sdB_zVal, 'paramRnd2Uc_sdB_pVal': paramRnd2Uc_sdB_pVal, 'pd_paramRnd2Uc_sdB': pd_paramRnd2Uc_sdB, 'paramRnd2Uc_sdW_est': paramRnd2Uc_sdW_est, 'paramRnd2Uc_sdW_se': paramRnd2Uc_sdW_se, 'paramRnd2Uc_sdW_zVal': paramRnd2Uc_sdW_zVal, 'paramRnd2Uc_sdW_pVal': paramRnd2Uc_sdW_pVal, 'pd_paramRnd2Uc_sdW': pd_paramRnd2Uc_sdW, 'paramRnd2Co_mu_est': paramRnd2Co_mu_est, 'paramRnd2Co_mu_se': paramRnd2Co_mu_se, 'paramRnd2Co_mu_zVal': paramRnd2Co_mu_zVal, 'paramRnd2Co_mu_pVal': paramRnd2Co_mu_pVal, 'pd_paramRnd2Co_mu': pd_paramRnd2Co_mu, 'paramRnd2Co_chB_est': paramRnd2Co_chB_est, 'paramRnd2Co_chB_se': paramRnd2Co_chB_se, 'paramRnd2Co_chB_pVal': paramRnd2Co_chB_pVal, 'pd_paramRnd2Co_chB': pd_paramRnd2Co_chB, 'paramRnd2Co_chW_est': paramRnd2Co_chW_est, 'paramRnd2Co_chW_se': paramRnd2Co_chW_se, 'paramRnd2Co_chW_pVal': paramRnd2Co_chW_pVal, 'pd_paramRnd2Co_chW': pd_paramRnd2Co_chW, 'resOpt': resOpt } return results