def next_paramRnd(
paramFix, paramRnd, zeta, Omega,
lPInd,
xFix, xFix_transBool, xFix_trans, nFix,
xRnd, xRnd_transBool, xRnd_trans, nRnd,
nInd, rowsPerInd, map_obs_to_ind, map_avail_to_obs,
rho):
lPhi = mvnlpdf(paramRnd, zeta, Omega)
paramRnd_star = paramRnd + np.sqrt(rho) * (np.linalg.cholesky(Omega) @ np.random.randn(nRnd, nInd)).T
lPInd_star = probMxl(
paramFix, paramRnd_star,
xFix, xFix_transBool, xFix_trans, nFix,
xRnd, xRnd_transBool, xRnd_trans, nRnd,
nInd, rowsPerInd, map_obs_to_ind, map_avail_to_obs)
lPhi_star = mvnlpdf(paramRnd_star, zeta, Omega)
r = np.exp(lPInd_star + lPhi_star - lPInd - lPhi)
idxAccept = np.random.rand(nInd,) <= r
paramRnd[idxAccept, :] = np.array(paramRnd_star[idxAccept, :])
lPInd[idxAccept] = np.array(lPInd_star[idxAccept])
acceptRate = np.mean(idxAccept)
rho = rho - 0.001 * (acceptRate < 0.3) + 0.001 * (acceptRate > 0.3)
return paramRnd, lPInd, rho
def next_paramFix(paramFix, paramRnd, lPInd, xFix, xFix_transBool, xFix_trans,
nFix, xRnd, xRnd_transBool, xRnd_trans, nRnd, nInd,
rowsPerInd, map_obs_to_ind, map_avail_to_obs, rhoF):
paramFix_star = paramFix + np.sqrt(rhoF) * np.random.randn(nFix, )
lPInd_star = probMxl(paramFix_star, paramRnd, xFix, xFix_transBool,
xFix_trans, nFix, xRnd, xRnd_transBool, xRnd_trans,
nRnd, nInd, rowsPerInd, map_obs_to_ind,
map_avail_to_obs)
r = np.exp(np.sum(lPInd_star - lPInd, axis=0))
if np.random.rand() <= r:
paramFix = np.array(paramFix_star)
lPInd = np.array(lPInd_star)
return paramFix, lPInd
def mcmcChain(
chainID, 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):
np.random.seed(seed + chainID)
###
#Precomputations
###
if nRnd > 0:
paramRnd = zeta + (np.linalg.cholesky(Omega) @ np.random.randn(nRnd, nInd)).T
iwDiagA = np.random.gamma(1 / 2, 1 / invASq)
else:
paramRnd = np.zeros((0,0))
iwDiagA = np.zeros((0,0))
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)
###
#Storage
###
fileName = modelName + '_draws_chain' + str(chainID + 1) + '.hdf5'
if os.path.exists(fileName):
os.remove(fileName)
file = h5py.File(fileName, "a")
if nFix > 0:
paramFix_store = file.create_dataset('paramFix_store', (mcmc_iterSampleThin, nFix))
paramFix_store_tmp = np.zeros((mcmc_iterMemThin, nFix))
if nRnd > 0:
paramRnd_store = file.create_dataset('paramRnd_store', (mcmc_iterSampleThin, nInd, nRnd))
zeta_store = file.create_dataset('zeta_store', (mcmc_iterSampleThin, nRnd))
Omega_store = file.create_dataset('Omega_store', (mcmc_iterSampleThin, nRnd, nRnd))
Corr_store = file.create_dataset('Corr_store', (mcmc_iterSampleThin, nRnd, nRnd))
sd_store = file.create_dataset('sd_store', (mcmc_iterSampleThin, nRnd))
paramRnd_store_tmp = np.zeros((mcmc_iterMemThin, nInd, nRnd))
zeta_store_tmp = np.zeros((mcmc_iterMemThin, nRnd))
Omega_store_tmp = np.zeros((mcmc_iterMemThin, nRnd, nRnd))
Corr_store_tmp = np.zeros((mcmc_iterMemThin, nRnd, nRnd))
sd_store_tmp = np.zeros((mcmc_iterMemThin, nRnd))
###
#Sample
###
j = -1
ll = 0
sampleState = 'burn in'
for i in np.arange(mcmc_iter):
if nFix > 0:
paramFix, lPInd = next_paramFix(
paramFix, paramRnd,
lPInd,
xFix, xFix_transBool, xFix_trans, nFix,
xRnd, xRnd_transBool, xRnd_trans, nRnd,
nInd, rowsPerInd, map_obs_to_ind, map_avail_to_obs,
rhoF)
if nRnd > 0:
zeta = next_zeta(paramRnd, Omega, nRnd, nInd)
Omega = next_Omega(paramRnd, zeta, nu, iwDiagA, diagCov, nRnd, nInd)
iwDiagA = next_iwDiagA(Omega, nu, invASq, nRnd)
paramRnd, lPInd, rho = next_paramRnd(
paramFix, paramRnd, zeta, Omega,
lPInd,
xFix, xFix_transBool, xFix_trans, nFix,
xRnd, xRnd_transBool, xRnd_trans, nRnd,
nInd, rowsPerInd, map_obs_to_ind, map_avail_to_obs,
rho)
if ((i + 1) % mcmc_disp) == 0:
if (i + 1) > mcmc_iterBurn:
sampleState = 'sampling'
print('Chain ' + str(chainID + 1) + '; iteration: ' + str(i + 1) + ' (' + sampleState + ')')
sys.stdout.flush()
if (i + 1) > mcmc_iterBurn:
if ((i + 1) % mcmc_thin) == 0:
j+=1
if nFix > 0:
paramFix_store_tmp[j,:] = paramFix
if nRnd > 0:
paramRnd_store_tmp[j,:,:] = paramRnd
zeta_store_tmp[j,:] = zeta
Omega_store_tmp[j,:,:] = Omega
Corr_store_tmp[j,:,:], sd_store_tmp[j,:,] = corrcov(Omega)
if (j + 1) == mcmc_iterMemThin:
l = ll; ll += mcmc_iterMemThin; sl = slice(l, ll)
print('Storing chain ' + str(chainID + 1))
sys.stdout.flush()
if nFix > 0:
paramFix_store[sl,:] = paramFix_store_tmp
if nRnd > 0:
paramRnd_store[sl,:,:] = paramRnd_store_tmp
zeta_store[sl,:] = zeta_store_tmp
Omega_store[sl,:,:] = Omega_store_tmp
Corr_store[sl,:,:] = Corr_store_tmp
sd_store[sl,:,] = sd_store_tmp
j = -1
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
