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 mcmcChainPredW(chainID, 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):
np.random.seed(seed + chainID)
###
#Retrieve draws
###
fileName = modelName + '_draws_chain' + str(chainID + 1) + '.hdf5'
file = h5py.File(fileName, "r")
paramRndB_store = np.array(file['paramRndB_store'][:, :nInd, :])
OmegaW_store = np.array(file['OmegaW_store'])
###
#Simulate
###
pPred = np.zeros((nRow + nObs, ))
vFix = 0
sampleIdx = np.sort(
np.random.choice(np.arange(mcmc_iterSampleThin),
size=mcmc_iterSampleThinPred,
replace=False))
ii = -1
for i in sampleIdx:
ii += 1
paramRndB_tmp = np.tile(
np.repeat(paramRndB_store[i, :, :], obsPerInd, axis=0), (nSim, 1))
chW_tmp = np.linalg.cholesky(OmegaW_store[i, :, :])
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
if ((ii + 1) % mcmc_disp) == 0:
print('Chain ' + str(chainID + 1) + '; iteration: ' + str(ii + 1) +
' (predictive simulation)')
sys.stdout.flush()
pPred /= mcmc_iterSampleThinPred
return pPred
def mcmcChainPred(
chainID, 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):
np.random.seed(seed + chainID)
###
#Retrieve draws
###
fileName = modelName + '_draws_chain' + str(chainID + 1) + '.hdf5'
file = h5py.File(fileName, "r")
paramFix_store = None
if nFix: paramFix_store = np.array(file['paramFix_store'])
zeta_store = np.array(file['zeta_store'])
Omega_store = np.array(file['Omega_store'])
###
#Simulate
###
pPred = np.zeros((nRow + nObs,))
vFix = 0
for i in np.arange(mcmc_iterSampleThin):
if nFix:
paramFix = paramFix_store[i,:]
vFix = np.tile(xFix @ paramFix, (nSim,));
zeta_tmp = zeta_store[i,:]
ch_tmp = np.linalg.cholesky(Omega_store[i,:,:])
pPred_iter = np.zeros((nRow + nObs,))
for t in np.arange(nTakes):
paramRnd = zeta_tmp + (ch_tmp @ 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)
if ((i + 1) % mcmc_disp) == 0:
print('Chain ' + str(chainID + 1) + '; iteration: ' + str(i + 1) + ' (predictive simulation)')
sys.stdout.flush()
pPred /= mcmc_iterSampleThin
return pPred
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 mcmcChainPredW(chainID, seed, mcmc_iterSampleThin, mcmc_iterSampleThinPred,
mcmc_disp, modelName, xFix, nFix, xRnd, nRnd, nInd, nObs,
nRow, rowsPerInd, map_avail_to_obs, chosenIdx,
nonChosenIdx):
np.random.seed(seed + chainID)
###
#Retrieve draws
###
fileName = modelName + '_draws_chain' + str(chainID + 1) + '.hdf5'
file = h5py.File(fileName, "r")
paramFix_store = None
paramRnd_store = None
if nFix: paramFix_store = np.array(file['paramFix_store'])
if nRnd: paramRnd_store = np.array(file['paramRnd_store'][:, :nInd, :])
###
#Simulate
###
pPred = np.zeros((nRow + nObs, ))
vFix = 0
vRnd = 0
sampleIdx = np.sort(
np.random.choice(np.arange(mcmc_iterSampleThin),
size=mcmc_iterSampleThinPred,
replace=False))
ii = -1
for i in sampleIdx:
ii += 1
if nFix:
paramFix = np.array(paramFix_store[i, :])
vFix = xFix @ paramFix
if nRnd:
paramRnd = paramRnd_store[i, :, :]
paramRndPerRow = np.repeat(paramRnd, rowsPerInd, axis=0)
vRnd = np.sum(xRnd * paramRndPerRow, axis=1)
pPred += pPredMxl(vFix, vRnd, map_avail_to_obs, 1, chosenIdx,
nonChosenIdx)
if ((ii + 1) % mcmc_disp) == 0:
print('Chain ' + str(chainID + 1) + '; iteration: ' + str(ii + 1) +
' (predictive simulation)')
sys.stdout.flush()
pPred /= mcmc_iterSampleThinPred
return pPred
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)
xRnd_valDiff = xList[0]
xRnd_valDiff = np.tile(xRnd_valDiff, (D, 1))
sim_map_avail_to_obs = scipy.sparse.kron(scipy.sparse.eye(D),
map_avail_to_obs)
sim_rowsPerInd = np.tile(rowsPerInd, D)
rowsPerObs = np.squeeze(np.asarray(np.sum(map_avail_to_obs, axis=0)))
sim_rowsPerObs = np.tile(rowsPerObs, D)
vFix = 0
for i in np.arange(simDraws_B):
betaRndInd = betaRndMu_true + (
betaRndChB_true @ np.random.randn(nRnd, N_val)).T
betaRndInd_perRow = np.tile(np.repeat(betaRndInd, rowsPerInd, axis=0),
(D_B, 1))
for j in np.arange(nTakes_B):
betaRndObs = (
betaRndChW_true @ np.random.randn(nRnd, NT_val * D_W)).T
betaRnd = betaRndInd_perRow + np.repeat(
betaRndObs, sim_rowsPerObs, axis=0)
vRnd = np.sum(xRnd_valDiff * betaRnd, axis=1)
pPred_true_take = pPredMxl(vFix, vRnd, sim_map_avail_to_obs, D_W,
chosenIdx, nonChosenIdx)
pPred_true += pPred_true_take
pPred_true /= (D_B * nTakes_B**2)
pPredB_true = np.array(pPred_true)
#Simulate predictive choice distributions for the within validation sample
D_W = 1000
nTakes_W = 10
simDraws_W = D_W * nTakes_W
xList = [xRnd_valW]
(xList, _, _, _, chosenIdx, nonChosenIdx, rowsPerInd, _, _,
map_avail_to_obs) = prepareData(xList, indID_valW, obsID_valW,
chosen_valW)
