def predictB(
nIter, nTakes, nSim, seed,
zetaMu, zetaSi, psiB, omegaB, psiW, omegaW,
indID, obsID, altID, chosen,
xRnd):
np.random.seed(seed)
###
#Prepare data
###
nRnd = xRnd.shape[1]
xList = [xRnd]
(xList,
nInd, nObs, nRow,
chosenIdx, nonChosenIdx,
rowsPerInd, rowsPerObs,
_, map_avail_to_obs) = prepareData(xList, indID, obsID, chosen)
xRnd = xList[0]
sim_xRnd = np.tile(xRnd, (nSim, 1))
sim_rowsPerObs = np.tile(rowsPerObs, (nSim,))
sim_map_avail_to_obs = scipy.sparse.kron(scipy.sparse.eye(nSim), map_avail_to_obs)
###
#Prediction
###
pPred = np.zeros((nRow + nObs,))
vFix = 0
zetaCh = np.linalg.cholesky(zetaSi)
for i in np.arange(nIter):
zeta_tmp = zetaMu + zetaCh @ np.random.randn(nRnd,)
chB_tmp = np.linalg.cholesky(invwishart.rvs(omegaB, psiB).reshape((nRnd, nRnd)))
chW_tmp = np.linalg.cholesky(invwishart.rvs(omegaW, psiW).reshape((nRnd, nRnd)))
pPred_iter = np.zeros((nRow + nObs,))
for j in np.arange(nSim * nTakes):
betaRndInd = zeta_tmp.reshape((1,nRnd)) + (chB_tmp @ np.random.randn(nRnd, nInd)).T
betaRndInd_perRow = np.tile(np.repeat(betaRndInd, rowsPerInd, axis = 0), (nSim, 1))
for k in np.arange(nTakes):
betaRndObs = (chW_tmp @ np.random.randn(nRnd, nObs * nSim)).T
betaRnd = betaRndInd_perRow + np.repeat(betaRndObs, sim_rowsPerObs, axis = 0)
vRnd = np.sum(sim_xRnd * betaRnd, axis = 1)
pPred_take = pPredMxl(vFix, vRnd, sim_map_avail_to_obs, nSim, chosenIdx, nonChosenIdx)
pPred_iter += pPred_take
pPred += pPred_iter / (nSim * nTakes**2)
pPred /= nIter
return pPred
def predictionMsle(nIter, nTakes, nSim, seed, param, iHess, indID, obsID,
altID, chosen, xFix, xRnd):
np.random.seed(seed)
###
#Prepare data
###
nFix = xFix.shape[1]
nRnd = xRnd.shape[1]
xList = [xFix, xRnd]
(xList, nInd, nObs, nRow, chosenIdx, nonChosenIdx, rowsPerInd, rowsPerObs,
_, map_avail_to_obs) = prepareData(xList, indID, obsID, chosen)
xFix, xRnd = xList[0], xList[1]
sim_xRnd = np.tile(xRnd, (nSim, 1))
sim_rowsPerInd = np.tile(rowsPerInd, (nSim, ))
sim_map_avail_to_obs = scipy.sparse.kron(scipy.sparse.eye(nSim),
map_avail_to_obs)
chIdx = np.triu_indices(nRnd)
chIdx = chIdx[1], chIdx[0]
###
#Prediction
###
pPred = np.zeros((nRow + nObs, ))
vFix = 0
chIHess = np.linalg.cholesky(iHess)
nParam = param.shape[0]
for i in np.arange(nIter):
paramSim = param + chIHess @ np.random.randn(nParam, )
if nFix:
paramFixSim = np.array(paramSim[:nFix])
vFix = np.tile(xFix @ paramFixSim, (nSim, ))
paramRnd_muSim = np.array(paramSim[nFix:(nFix + nRnd)])
paramRnd_chSim = np.zeros((nRnd, nRnd))
paramRnd_chSim[chIdx] = np.array(paramSim[(nFix + nRnd):])
pPred_iter = np.zeros((nRow + nObs, ))
for t in np.arange(nTakes):
paramRndSim = paramRnd_muSim + (
paramRnd_chSim @ np.random.randn(nRnd, nInd * nSim)).T
paramRndSimPerRow = np.repeat(paramRndSim, sim_rowsPerInd, axis=0)
vRnd = np.sum(sim_xRnd * paramRndSimPerRow, axis=1)
pPred_take = pPredMxl(vFix, vRnd, sim_map_avail_to_obs, nSim,
chosenIdx, nonChosenIdx)
pPred_iter += pPred_take
pPred += (pPred_iter / nTakes)
pPred /= nIter
return pPred
def ppdW(
mcmc_nChain, mcmc_iterSample, mcmc_thin, mcmc_disp,
seed,
modelName, deleteDraws,
indID, obsID, altID, chosen,
xFix, xFix_trans,
xRnd, xRnd_trans,
xRnd2, xRnd2_trans):
###
#Prepare data
###
nFix = xFix.shape[1]
nRnd = xRnd.shape[1]
nRnd2 = xRnd2.shape[1]
xFix_transBool = np.sum(xFix_trans) > 0
xRnd_transBool = np.sum(xRnd_trans) > 0
xRnd2_transBool = np.sum(xRnd_trans) > 0
xList = [xFix, xRnd, xRnd2]
(xList,
nInd, nObs, nRow,
chosenIdx, nonChosenIdx,
rowsPerInd, rowsPerObs,
_, map_avail_to_obs) = prepareData(xList, indID, obsID, chosen)
xFix, xRnd, xRnd2 = xList[0], xList[1], xList[2]
###
#Predictive simulation
###
mcmc_iterSampleThin = floor(mcmc_iterSample / mcmc_thin)
pPred = np.zeros((mcmc_nChain, mcmc_iterSampleThin, nObs + nRow))
for c in np.arange(mcmc_nChain):
pPred[c,:,:] = mcmcChainPredW(
c, seed,
mcmc_iterSampleThin, mcmc_disp,
modelName,
xFix, xFix_transBool, xFix_trans, nFix,
xRnd, xRnd_transBool, xRnd_trans, nRnd,
xRnd2, xRnd2_transBool, xRnd2_trans, nRnd2,
nInd, nObs, nRow,
rowsPerInd, map_avail_to_obs, chosenIdx, nonChosenIdx)
pPred_chosen = pPred[:,:,chosenIdx]
###
#Delete draws
###
if deleteDraws:
for c in range(mcmc_nChain):
os.remove(modelName + '_draws_chain' + str(c + 1) + '.hdf5')
return pPred, pPred_chosen
def predict(nIter, nTakes, nSim, seed, paramFixMu, paramFixCh, zetaMu, zetaSi,
psi, omega, indID, obsID, altID, chosen, xFix, xRnd):
np.random.seed(seed)
###
#Prepare data
###
nFix = xFix.shape[1]
nRnd = xRnd.shape[1]
xList = [xFix, xRnd]
(xList, nInd, nObs, nRow, chosenIdx, nonChosenIdx, rowsPerInd, rowsPerObs,
_, map_avail_to_obs) = prepareData(xList, indID, obsID, chosen)
xFix, xRnd = xList[0], xList[1]
sim_xRnd = np.tile(xRnd, (nSim, 1))
sim_rowsPerInd = np.tile(rowsPerInd, (nSim, ))
sim_map_avail_to_obs = scipy.sparse.kron(scipy.sparse.eye(nSim),
map_avail_to_obs)
chIdx = np.triu_indices(nRnd)
chIdx = chIdx[1], chIdx[0]
###
#Prediction
###
pPred = np.zeros((nRow + nObs, ))
vFix = 0
zetaCh = np.linalg.cholesky(zetaSi)
for i in np.arange(nIter):
if nFix:
paramFix = paramFixMu + paramFixCh @ np.random.randn(nFix, )
vFix = np.tile(xFix @ paramFix, (nSim, ))
zeta = zetaMu + zetaCh @ np.random.randn(nRnd, )
ch = np.linalg.cholesky(
invwishart.rvs(omega, psi).reshape((nRnd, nRnd)))
pPred_iter = np.zeros((nRow + nObs, ))
for t in np.arange(nTakes):
paramRnd = zeta + (ch @ np.random.randn(nRnd, nInd * nSim)).T
paramRndPerRow = np.repeat(paramRnd, sim_rowsPerInd, axis=0)
vRnd = np.sum(sim_xRnd * paramRndPerRow, axis=1)
pPred_take = pPredMxl(vFix, vRnd, sim_map_avail_to_obs, nSim,
chosenIdx, nonChosenIdx)
pPred_iter += pPred_take
pPred += (pPred_iter / nTakes)
pPred /= nIter
return pPred
def predictW(
nIter, nTakes, nSim, seed,
paramRndMuB, paramRndSiB, psiW, omegaW,
indID, obsID, altID, chosen,
xRnd):
np.random.seed(seed)
###
#Prepare data
###
nRnd = xRnd.shape[1]
xList = [xRnd]
(xList,
nInd, nObs, nRow,
chosenIdx, nonChosenIdx,
rowsPerInd, rowsPerObs,
_, map_avail_to_obs) = prepareData(xList, indID, obsID, chosen)
xRnd = xList[0]
sim_xRnd = np.tile(xRnd, (nSim, 1))
sim_rowsPerObs = np.tile(rowsPerObs, (nSim,))
sim_map_avail_to_obs = scipy.sparse.kron(scipy.sparse.eye(nSim), map_avail_to_obs)
###
#Prediction
###
pPred = np.zeros((nRow + nObs,))
vFix = 0
paramRndChB = np.linalg.cholesky(paramRndSiB)
for i in np.arange(nIter):
paramRndB_tmp = np.tile(paramRndMuB + \
(paramRndChB @ np.random.randn(nInd, nRnd, 1)).reshape((nInd, nRnd,)),
(nSim,1))
chW_tmp = np.linalg.cholesky(invwishart.rvs(omegaW, psiW).reshape((nRnd, nRnd)))
pPred_iter = np.zeros((nRow + nObs,))
for t in np.arange(nTakes):
paramRnd = paramRndB_tmp + (chW_tmp @ np.random.randn(nRnd, nObs * nSim)).T
paramRndPerRow = np.repeat(paramRnd, sim_rowsPerObs, axis = 0)
vRnd = np.sum(sim_xRnd * paramRndPerRow, axis = 1)
pPred_take = pPredMxl(vFix, vRnd, sim_map_avail_to_obs, nSim, chosenIdx, nonChosenIdx)
pPred_iter += pPred_take
pPred += pPred_iter / nTakes
pPred /= nIter
return pPred
def predict(
mcmc_nChain, mcmc_iterSample, mcmc_thin, mcmc_disp, nTakes, nSim,
seed,
modelName, deleteDraws,
indID, obsID, altID, chosen,
xFix, xRnd):
###
#Prepare data
###
nFix = xFix.shape[1]
nRnd = xRnd.shape[1]
xList = [xFix, xRnd]
(xList,
nInd, nObs, nRow,
chosenIdx, nonChosenIdx,
rowsPerInd, rowsPerObs,
_, map_avail_to_obs) = prepareData(xList, indID, obsID, chosen)
xFix, xRnd = xList[0], xList[1]
sim_xRnd = np.tile(xRnd, (nSim, 1))
sim_rowsPerInd = np.tile(rowsPerInd, (nSim,))
sim_map_avail_to_obs = scipy.sparse.kron(scipy.sparse.eye(nSim), map_avail_to_obs)
###
#Predictive simulation
###
mcmc_iterSampleThin = floor(mcmc_iterSample / mcmc_thin)
pPred = np.zeros((nObs + nRow,))
for c in np.arange(mcmc_nChain):
predPred_chain = mcmcChainPred(
c, seed,
mcmc_iterSampleThin, mcmc_disp, nTakes, nSim,
modelName,
xFix, nFix,
sim_xRnd, nRnd,
nInd, nObs, nRow,
sim_rowsPerInd, sim_map_avail_to_obs, chosenIdx, nonChosenIdx)
pPred += predPred_chain
pPred /= mcmc_nChain
###
#Delete draws
###
if deleteDraws:
for c in range(mcmc_nChain):
os.remove(modelName + '_draws_chain' + str(c + 1) + '.hdf5')
return pPred
def predictB(mcmc_nChain, mcmc_iterSample, mcmc_thin, mcmc_thinPred, mcmc_disp,
nTakes, nSim, seed, modelName, deleteDraws, indID, obsID, chosen,
xFix, xRnd):
###
#Prepare data
###
nFix = xFix.shape[1]
nRnd = xRnd.shape[1]
if nFix > 0 and nRnd == 0:
nTakes = 1
nSim = 1
xList = [xFix, xRnd]
(xList, nInd, nObs, nRow, chosenIdx, nonChosenIdx, rowsPerInd, rowsPerObs,
_, map_avail_to_obs) = prepareData(xList, indID, obsID, chosen)
xFix, xRnd = xList[0], xList[1]
sim_xRnd = np.tile(xRnd, (nSim, 1))
sim_rowsPerInd = np.tile(rowsPerInd, (nSim, ))
sim_map_avail_to_obs = scipy.sparse.kron(scipy.sparse.eye(nSim),
map_avail_to_obs)
###
#Predictive simulation
###
mcmc_iterSampleThin = floor(mcmc_iterSample / mcmc_thin)
mcmc_iterSampleThinPred = floor(mcmc_iterSampleThin / mcmc_thinPred)
pPred = Parallel(n_jobs=mcmc_nChain)(delayed(mcmcChainPredB)(
c, seed, mcmc_iterSampleThin, mcmc_iterSampleThinPred, mcmc_disp,
nTakes, nSim, modelName, xFix, nFix, sim_xRnd, nRnd, nInd, nObs, nRow,
sim_rowsPerInd, sim_map_avail_to_obs, chosenIdx, nonChosenIdx)
for c in range(mcmc_nChain))
pPred = np.array(pPred).mean(axis=0)
###
#Delete draws
###
if deleteDraws:
for c in range(mcmc_nChain):
os.remove(modelName + '_draws_chain' + str(c + 1) + '.hdf5')
return pPred
def predictW(mcmc_nChain, mcmc_iterSample, mcmc_thin, mcmc_thinPred, mcmc_disp,
nTakes, nSim, seed, modelName, deleteDraws, indID, obsID, altID,
chosen, xRnd):
###
#Prepare data
###
nRnd = xRnd.shape[1]
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
sim_xRnd = np.tile(xRnd, (nSim, 1))
sim_rowsPerObs = np.tile(rowsPerObs, (nSim, ))
sim_map_avail_to_obs = scipy.sparse.kron(scipy.sparse.eye(nSim),
map_avail_to_obs)
###
#Predictive simulation
###
mcmc_iterSampleThin = floor(mcmc_iterSample / mcmc_thin)
mcmc_iterSampleThinPred = floor(mcmc_iterSampleThin / mcmc_thinPred)
pPred = Parallel(n_jobs=mcmc_nChain)(delayed(mcmcChainPredW)(
c, seed, mcmc_iterSampleThin, mcmc_iterSampleThinPred, mcmc_disp,
nTakes, nSim, modelName, sim_xRnd, nRnd, nInd, nObs, nRow, obsPerInd,
sim_rowsPerObs, sim_map_avail_to_obs, chosenIdx, nonChosenIdx)
for c in range(mcmc_nChain))
pPred = np.array(pPred).mean(axis=0)
###
#Delete draws
###
if deleteDraws:
for c in range(mcmc_nChain):
os.remove(modelName + '_draws_chain' + str(c + 1) + '.hdf5')
return pPred
def predictW(mcmc_nChain, mcmc_iterSample, mcmc_thin, mcmc_thinPred, mcmc_disp,
seed, modelName, deleteDraws, indID, obsID, chosen, xFix, xRnd):
###
#Prepare data
###
nFix = xFix.shape[1]
nRnd = xRnd.shape[1]
xList = [xFix, xRnd]
(xList, nInd, nObs, nRow, chosenIdx, nonChosenIdx, rowsPerInd, rowsPerObs,
_, map_avail_to_obs) = prepareData(xList, indID, obsID, chosen)
xFix, xRnd = xList[0], xList[1]
###
#Predictive simulation
###
mcmc_iterSampleThin = floor(mcmc_iterSample / mcmc_thin)
mcmc_iterSampleThinPred = floor(mcmc_iterSampleThin / mcmc_thinPred)
pPred = 0
for c in np.arange(mcmc_nChain):
pPred_chain = mcmcChainPredW(c, seed, mcmc_iterSampleThin,
mcmc_iterSampleThinPred, mcmc_disp,
modelName, xFix, nFix, xRnd, nRnd, nInd,
nObs, nRow, rowsPerInd, map_avail_to_obs,
chosenIdx, nonChosenIdx)
pPred += pPred_chain
pPred /= mcmc_nChain
###
#Delete draws
###
if deleteDraws:
for c in range(mcmc_nChain):
os.remove(modelName + '_draws_chain' + str(c + 1) + '.hdf5')
return pPred
def estimate(
mcmc_nChain, mcmc_iterBurn, mcmc_iterSample, mcmc_thin, mcmc_iterMem, mcmc_disp,
seed, simDraws,
rhoF, rho,
modelName, deleteDraws,
A, nu, diagCov,
paramFix_inits, zeta_inits, Omega_inits,
indID, obsID, altID, chosen,
xFix, xRnd,
xFix_trans, xRnd_trans):
###
#Prepare data
###
nFix = xFix.shape[1]
nRnd = xRnd.shape[1]
xFix_transBool = np.sum(xFix_trans) > 0
xRnd_transBool = np.sum(xRnd_trans) > 0
xList = [xFix, xRnd]
(xList,
nInd, nObs, nRow,
chosenIdx, nonChosenIdx,
rowsPerInd, rowsPerObs,
map_obs_to_ind, map_avail_to_obs) = prepareData(xList, indID, obsID, chosen)
xFix, xRnd = xList[0], xList[1]
###
#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)
paramFix = paramFix_inits
zeta = zeta_inits
Omega = Omega_inits
tic = time.time()
for c in range(mcmc_nChain):
mcmcChain(c, seed,
mcmc_iter, mcmc_iterBurn, mcmc_iterSampleThin, mcmc_iterMemThin, mcmc_thin, mcmc_disp,
rhoF, rho,
modelName,
paramFix, zeta, Omega, invASq, nu, diagCov,
xFix, xFix_transBool, xFix_trans, nFix,
xRnd, xRnd_transBool, xRnd_trans, nRnd,
nInd, rowsPerInd, map_obs_to_ind, map_avail_to_obs)
"""
Parallel(n_jobs = mcmc_nChain)(delayed(mcmcChain)(
c, seed,
mcmc_iter, mcmc_iterBurn, mcmc_iterSampleThin, mcmc_iterMemThin, mcmc_thin, mcmc_disp,
rhoF, rho,
modelName,
paramFix, zeta, Omega, invASq, nu, diagCov,
xFix, xFix_transBool, xFix_trans, nFix,
xRnd, xRnd_transBool, xRnd_trans, nRnd,
nInd, rowsPerInd, 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
###
if nFix > 0:
postMean_paramFix, pdTabPostAna_paramFix = postAna('paramFix', nFix, 1, mcmc_nChain, mcmc_iterSampleThin, modelName)
print(' ')
print('Fixed parameters:')
print(pdTabPostAna_paramFix)
else:
postMean_paramFix = None; pdTabPostAna_paramFix = None;
if nRnd > 0:
postMean_zeta, pdTabPostAna_zeta = postAna('zeta', nRnd, 1, mcmc_nChain, mcmc_iterSampleThin, modelName)
print(' ')
print('Random parameters (means):')
print(pdTabPostAna_zeta)
postMean_sd, pdTabPostAna_sd = postAna('sd', nRnd, 1, mcmc_nChain, mcmc_iterSampleThin, modelName)
print(' ')
print('Random parameters (standard deviations):')
print(pdTabPostAna_sd)
postMean_Omega, pdTabPostAna_Omega = postAna('Omega', nRnd, nRnd, mcmc_nChain, mcmc_iterSampleThin, modelName)
print(' ')
print('Random parameters (covariance matrix):')
print(pdTabPostAna_Omega)
postMean_Corr, pdTabPostAna_Corr = postAna('Corr', nRnd, nRnd, mcmc_nChain, mcmc_iterSampleThin, modelName)
print(' ')
print('Random parameters (correlation matrix):')
print(pdTabPostAna_Corr)
postMean_paramRnd, pdTabPostAna_paramRnd = postAna('paramRnd', nInd, nRnd, mcmc_nChain, mcmc_iterSampleThin, modelName)
else:
postMean_zeta = None; pdTabPostAna_zeta = None;
postMean_sd = None; pdTabPostAna_sd = None;
postMean_Omega = None; pdTabPostAna_Omega = None;
postMean_Corr = None; pdTabPostAna_Corr = None;
postMean_paramRnd = None; pdTabPostAna_paramRnd = None;
###
#Simulate log-likelihood at posterior means
###
if nFix > 0 and nRnd == 0:
simDraws_star = 1
else:
simDraws_star = simDraws
pSim = np.zeros((simDraws_star, nInd))
paramFix = 0; paramRnd = 0;
if nFix > 0: paramFix = postMean_paramFix
if nRnd > 0: postMean_chOmega = np.linalg.cholesky(postMean_Omega)
for i in np.arange(simDraws_star):
if nRnd > 0:
paramRnd = postMean_zeta + (postMean_chOmega @ np.random.randn(nRnd, nInd)).T
lPInd = probMxl(
paramFix, paramRnd,
xFix, xFix_transBool, xFix_trans, nFix,
xRnd, xRnd_transBool, xRnd_trans, nRnd,
nInd, rowsPerInd, map_obs_to_ind, map_avail_to_obs)
pSim[i, :] = np.exp(lPInd)
logLik = np.sum(np.log(np.mean(pSim, axis = 0)))
print(' ')
print('Log-likelihood (simulated at posterior means): ' + str(logLik))
###
#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_paramFix': postMean_paramFix, 'pdTabPostAna_paramFix': pdTabPostAna_paramFix,
'postMean_zeta': postMean_zeta, 'pdTabPostAna_zeta': pdTabPostAna_zeta,
'postMean_sd': postMean_sd, 'pdTabPostAna_sd': pdTabPostAna_sd,
'postMean_Omega': postMean_Omega, 'pdTabPostAna_Omega': pdTabPostAna_Omega,
'postMean_Corr': postMean_Corr, 'pdTabPostAna_Corr': pdTabPostAna_Corr,
'postMean_paramRnd': postMean_paramRnd, 'pdTabPostAna_paramRnd': pdTabPostAna_paramRnd
}
return results
def test(results, seed, simDraws, indID, obsID, altID, chosen, xFix, xRnd,
xFix_trans, xRnd_trans):
###
#Prepare data
###
nFix = xFix.shape[1]
nRnd = xRnd.shape[1]
xFix_transBool = np.sum(xFix_trans) > 0
xRnd_transBool = np.sum(xRnd_trans) > 0
xList = [xFix, xRnd]
(xList, nInd, nObs, nRow, chosenIdx, nonChosenIdx, rowsPerInd, rowsPerObs,
map_obs_to_ind, map_avail_to_obs) = prepareData(xList, indID, obsID,
chosen)
xFix, xRnd = xList[0], xList[1]
###
#Simulate log-likelihood at posterior means
###
if nFix > 0 and nRnd == 0:
simDraws_star = 1
else:
simDraws_star = simDraws
pSim = np.zeros((simDraws_star, nInd))
paramFix = 0
paramRnd = 0
if nFix > 0: paramFix = results['postMean_paramFix']
if nRnd > 0:
postMean_chOmega = np.linalg.cholesky(results['postMean_Omega'])
for i in np.arange(simDraws_star):
if nRnd > 0:
paramRnd = results['postMean_zeta'] + (
postMean_chOmega @ np.random.randn(xRnd.shape[1], nInd)).T
lPInd = probMxl(paramFix, paramRnd, xFix, xFix_transBool, xFix_trans,
nFix, xRnd, xRnd_transBool, xRnd_trans, nRnd, nInd,
rowsPerInd, map_obs_to_ind, map_avail_to_obs)
pSim[i, :] = np.exp(lPInd)
logLik = np.sum(np.log(np.mean(pSim, axis=0)))
print(' ')
print('Log-likelihood (simulated at posterior means): ' + str(logLik))
pSimCond = np.zeros(nInd)
if nRnd > 0:
paramRnd = results['postMean_paramRnd']
lPInd = probMxl(paramFix, paramRnd, xFix, xFix_transBool, xFix_trans, nFix,
xRnd, xRnd_transBool, xRnd_trans, nRnd, nInd, rowsPerInd,
map_obs_to_ind, map_avail_to_obs)
pSimCond = np.exp(lPInd)
CondLogLik = np.sum(np.log(pSimCond))
results = {
'unconditionalLogLik': logLik,
'conditionalLogLik': CondLogLik,
'unconditionalChosenProb': np.mean(pSim),
'conditionalChosenProb': np.mean(pSimCond)
}
return results
def estimate(mcmc_nChain, mcmc_iterBurn, mcmc_iterSample, mcmc_thin,
mcmc_iterMem, mcmc_disp, seed, simDraws, rhoF, rho, modelName,
deleteDraws, method, mu0, Si0, A, nu, diagCov, alpha, K, g0_mu0,
g0_Si0, g0_nu, g0_A, g0_s, diagCov2, paramFix_inits, zeta_inits,
Omega_inits, indID, obsID, altID, chosen, xFix, xRnd, xRnd2,
xFix_trans, xRnd_trans, xRnd2_trans):
###
#Prepare data
###
nFix = xFix.shape[1]
nRnd = xRnd.shape[1]
nRnd2 = xRnd2.shape[1]
xFix_transBool = np.sum(xFix_trans) > 0
xRnd_transBool = np.sum(xRnd_trans) > 0
xRnd2_transBool = np.sum(xRnd_trans) > 0
xList = [xFix, xRnd, xRnd2]
(xList, nInd, nObs, nRow, chosenIdx, nonChosenIdx, rowsPerInd, rowsPerObs,
map_obs_to_ind, map_avail_to_obs) = prepareData(xList, indID, obsID,
chosen)
xFix, xRnd, xRnd2 = xList[0], xList[1], xList[2]
###
#Posterior sampling
###
mcmc_iter = mcmc_iterBurn + mcmc_iterSample
mcmc_iterSampleThin = floor(mcmc_iterSample / mcmc_thin)
mcmc_iterMemThin = floor(mcmc_iterMem / mcmc_thin)
Si0Inv = np.linalg.inv(Si0)
invASq = np.ones((nRnd, )) * A**(-2)
g0_Si0Inv = np.linalg.inv(g0_Si0)
g0_invASq = np.ones((nRnd2, )) * g0_A**(-2)
paramFix = paramFix_inits
zeta = zeta_inits
Omega = Omega_inits
tic = time.time()
for c in range(mcmc_nChain):
mcmcChain(c, seed, mcmc_iter, mcmc_iterBurn, mcmc_iterSampleThin,
mcmc_iterMemThin, mcmc_thin, mcmc_disp, rhoF, rho, modelName,
method, paramFix, zeta, Omega, mu0, Si0Inv, invASq, nu,
diagCov, alpha, K, g0_mu0, g0_Si0, g0_Si0Inv, g0_nu,
g0_invASq, g0_s, diagCov2, xFix, xFix_transBool, xFix_trans,
nFix, xRnd, xRnd_transBool, xRnd_trans, nRnd, xRnd2,
xRnd2_transBool, xRnd2_trans, nRnd2, nInd, rowsPerInd,
map_obs_to_ind, map_avail_to_obs)
"""
Parallel(n_jobs = mcmc_nChain)(delayed(mcmcChain)(
c, seed,
mcmc_iter, mcmc_iterBurn, mcmc_iterSampleThin, mcmc_iterMemThin, mcmc_thin, mcmc_disp,
rhoF, rho,
modelName,
method,
paramFix, zeta, Omega, mu0, Si0Inv, invASq, nu, diagCov,
alpha, K, g0_mu0, g0_Si0, g0_Si0Inv, g0_nu, g0_invASq, g0_s, diagCov2,
xFix, xFix_transBool, xFix_trans, nFix,
xRnd, xRnd_transBool, xRnd_trans, nRnd,
xRnd2, xRnd2_transBool, xRnd2_trans, nRnd2,
nInd, rowsPerInd, 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
###
post_paramFix = None
post_paramRnd = None
post_paramRnd2 = None
post_pi = None
if nFix: post_paramFix = extractPost('paramFix', (nFix,1), mcmc_nChain, mcmc_iterSampleThin, modelName)
if nRnd: post_paramRnd = extractPost('paramRnd', (nInd, nRnd), mcmc_nChain, mcmc_iterSampleThin, modelName)
if nRnd2:
post_paramRnd2 = extractPost('paramRnd2', (nInd, nRnd2), mcmc_nChain, mcmc_iterSampleThin, modelName)
post_pi = extractPost('pi', (K, 1), mcmc_nChain, mcmc_iterSampleThin, modelName)
"""
###
#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}
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
altID_valB = np.array(altID_tot[idx])
chosen_valB = np.array(chosen_tot[idx])
xRnd_valB = np.array(xRnd_tot[idx, :])
idx = indObsID_tot > T #Within validation
indID_valW = np.array(indID_tot[idx])
obsID_valW = np.array(obsID_tot[idx])
altID_valW = np.array(altID_tot[idx])
chosen_valW = np.array(chosen_tot[idx])
xRnd_valW = np.array(xRnd_tot[idx, :])
#Calculate choice probabilities for the training sample
xList = [xRnd]
(xList, _, _, _, chosenIdx, nonChosenIdx, rowsPerInd, _, _,
map_avail_to_obs) = prepareData(xList, indID, obsID, chosen)
xRnd_valDiff = xList[0]
vFix = 0
betaRndInd_val = np.array(betaRndInd[:N, :])
betaRndInd_perRow_val = np.repeat(betaRndInd_val, rowsPerInd, axis=0)
vRnd = np.sum(xRnd_valDiff * betaRndInd_perRow_val, axis=1)
pPredT_true = pPredMxl(vFix, vRnd, map_avail_to_obs, 1, chosenIdx,
nonChosenIdx)
#Simulate predictive choice distributions for the between validation sample
xList = [xRnd_valB]
(xList, _, _, _, chosenIdx, nonChosenIdx, rowsPerInd, _, _,
map_avail_to_obs) = prepareData(xList, indID_valB, obsID_valB,
chosen_valB)
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(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, 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
