def probMxl(paramFix, paramRnd, paramRnd2, 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): """ vFix = 0; vRnd = 0; vRnd2 = 0; if nFix > 0: if xFix_transBool: paramFix = transFix(paramFix, xFix_trans) vFix = xFix @ paramFix if nRnd > 0: if xRnd_transBool: paramRnd = transRnd(paramRnd, xRnd_trans) paramRndPerRow = np.repeat(paramRnd, rowsPerInd, axis = 0) vRnd = np.sum(xRnd * paramRndPerRow, axis = 1) if nRnd2 > 0: if xRnd2_transBool: paramRnd2 = transRnd(paramRnd2, xRnd_trans) paramRnd2PerRow = np.repeat(paramRnd2, rowsPerInd, axis = 0) vRnd2 = np.sum(xRnd2 * paramRnd2PerRow, axis = 1) v = vFix + vRnd + vRnd2 """ if xRnd_transBool: paramRnd = transRnd(paramRnd, xRnd_trans) paramRndPerRow = np.repeat(paramRnd, rowsPerInd, axis=0) if xRnd2_transBool: paramRnd2 = transRnd(paramRnd2, xRnd2_trans) paramRnd2PerRow = np.repeat(paramRnd2, rowsPerInd, axis=0) v = xRnd[:,0] * paramRndPerRow[:,0] \ + paramRndPerRow[:,1] * (xRnd[:,1] + np.sum(xRnd2 * paramRnd2PerRow, axis = 1)) ev = np.exp(v) ev[ev > 1e+200] = 1e+200 ev[ev < 1e-300] = 1e-300 nev = map_avail_to_obs.T @ ev + 1 pChosen = 1 / nev lPChosen = np.log(pChosen) lPInd = map_obs_to_ind.T @ lPChosen return lPInd
def mcmcChainPredW( chainID, 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): 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 paramRnd2_store = None if nFix: paramFix_store = np.array(file['paramFix_store']) if nRnd: paramRnd_store = np.array(file['paramRnd_store'][:,:nInd,:]) if nRnd2: paramRnd2_store = np.array(file['paramRnd2_store'][:,:nInd,:]) ### #Simulate ### pPred = np.zeros((mcmc_iterSampleThin, nRow + nObs)) vFix = 0; vRnd = 0; vRnd2 = 0; for i in np.arange(mcmc_iterSampleThin): if nFix: paramFix = np.array(paramFix_store[i,:]) if xFix_transBool: paramFix = transFix(paramFix, xFix_trans) #vFix = xFix @ paramFix if nRnd: paramRnd = paramRnd_store[i,:,:] if xRnd_transBool: paramRnd = transRnd(paramRnd, xRnd_trans) paramRndPerRow = np.repeat(paramRnd, rowsPerInd, axis = 0) #vRnd = np.sum(xRnd * paramRndPerRow, axis = 1) if nRnd2: paramRnd2 = paramRnd2_store[i,:,:] if xRnd2_transBool: paramRnd2 = transRnd(paramRnd2, xRnd2_trans) paramRnd2PerRow = np.repeat(paramRnd2, rowsPerInd, axis = 0) #vRnd2 = np.sum(xRnd2 * paramRnd2PerRow, axis = 1) #v = vFix + vRnd + vRnd2 v = xRnd[:,0] * paramRndPerRow[:,0] \ + paramRndPerRow[:,1] * (xRnd[:,1] + np.sum(xRnd[:,2:] * paramRndPerRow[:,2:], axis = 1)) pPred[i,:] = pPredMxl(v, map_avail_to_obs, 1, chosenIdx, nonChosenIdx) if ((i + 1) % mcmc_disp) == 0: print('Chain ' + str(chainID + 1) + '; iteration: ' + str(i + 1) + ' (predictive simulation)') sys.stdout.flush() return pPred
def 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): if nRndUc: paramRndUc_draws = np.zeros((nSim, nInd, nRndUc)) if nRndCo: paramRndCo_draws = np.zeros((nSim, nInd, nRndCo)) pInd_draws = np.zeros((nSim, nInd)) vFix = 0 vRndUc = 0 vRndCo = 0 if nFix > 0: vFix = xFix @ paramFix_est for i in np.arange(nSim): if nRndUc > 0: paramRndUc = paramRndUc_mu_est + paramRndUc_sd_est * np.random.randn( nInd, nRndUc) paramRndUc_draws[i, :, :] = paramRndUc if xRndUc_transBool: paramRndUc = np.array(transRnd(paramRndUc, xRndUc_trans)) paramRndUcPerRow = np.repeat(paramRndUc, rowsPerInd, axis=0) vRndUc = np.sum(xRndUc * paramRndUcPerRow, axis=1) if nRndCo > 0: paramRndCo = paramRndCo_mu_est + ( paramRndCo_ch_est @ np.random.randn(nRndCo, nInd)).T paramRndCo_draws[i, :, :] = paramRndCo if xRndCo_transBool: paramRndCo = np.array(transRnd(paramRndCo, xRndCo_trans)) paramRndCoPerRow = np.repeat(paramRndCo, rowsPerInd, axis=0) vRndCo = np.sum(xRndCo * paramRndCoPerRow, axis=1) v = vFix + vRndUc + vRndCo pInd_draws[i, :] = probMxl(v, map_obs_to_ind, map_avail_to_obs) denom = np.mean(pInd_draws, axis=0) pInd_draws = np.array(pInd_draws).reshape((nSim, nInd, 1)) paramRndUc_ind = None paramRndCo_ind = None if nRndUc > 0: numer = np.mean(paramRndUc_draws * pInd_draws, axis=0) paramRndUc_ind = numer / denom.reshape((nInd, 1)) if nRndCo > 0: numer = np.mean(paramRndCo_draws * pInd_draws, axis=0) paramRndCo_ind = numer / denom.reshape((nInd, 1)) return paramRndUc_ind, paramRndCo_ind
def 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): vFix = 0 vRnd = 0 if nFix > 0: if xFix_transBool: paramFix = transFix(paramFix, xFix_trans) vFix = xFix @ paramFix vFix = xFix[:,0] * paramFix[0] \ + np.exp(paramFix[1]) * (xFix[:,1] + xFix[:,2:] @ paramFix[2:]) if nRnd > 0: if xRnd_transBool: paramRnd = transRnd(paramRnd, xRnd_trans) paramRndPerRow = np.repeat(paramRnd, rowsPerInd, axis=0) #vRnd = paramRndPerRow[:,0] * (xRnd[:,0] + np.sum(xRnd[:,1:] * paramRndPerRow[:,1:], axis = 1)) vRnd = xRnd[:,0] * paramRndPerRow[:,0] \ + paramRndPerRow[:,1] * (xRnd[:,1] + np.sum(xRnd[:,2:] * paramRndPerRow[:,2:], axis = 1)) v = vFix + vRnd ev = np.exp(v) ev[ev > 1e+200] = 1e+200 ev[ev < 1e-300] = 1e-300 nev = map_avail_to_obs.T @ ev + 1 pChosen = 1 / nev lPChosen = np.log(pChosen) lPInd = map_obs_to_ind.T @ lPChosen return lPInd
def probMxl(paramRndW, xRnd, xRnd_transBool, xRnd_trans, rowsPerObs, map_avail_to_obs): if xRnd_transBool: paramRndW = transRnd(paramRndW, xRnd_trans) paramRndWPerRow = np.repeat(paramRndW, rowsPerObs, axis=0) v = np.sum(xRnd * paramRndWPerRow, axis=1) ev = np.exp(v) ev[ev > 1e+200] = 1e+200 ev[ev < 1e-300] = 1e-300 nev = map_avail_to_obs.T @ ev + 1 pChosen = 1 / nev lPChosen = np.log(pChosen) return pChosen, lPChosen
def mcmcChainPredB(chainID, seed, mcmc_iterSampleThin, mcmc_disp, nTakes, nSim, modelName, xFix, xFix_transBool, xFix_trans, nFix, sim_xRnd, xRnd_transBool, xRnd_trans, nRnd, sim_xRnd2, xRnd2_transBool, xRnd2_trans, nRnd2, 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 zeta_store = None Omega_store = None zeta2_store = None Omega2_store = None pi_store = None nComp = None if nFix: paramFix_store = np.array(file['paramFix_store']) if nRnd: zeta_store = np.array(file['zeta_store']) Omega_store = np.array(file['Omega_store']) if nRnd2: zeta2_store = np.array(file['zeta2_store']) Omega2_store = np.array(file['Omega2_store']) pi_store = np.array(file['pi_store']) nComp = pi_store.shape[1] ### #Simulate ### pPred = np.zeros((mcmc_iterSampleThin, nRow + nObs)) vFix = 0 vRnd = 0 vRnd2 = 0 for i in np.arange(mcmc_iterSampleThin): if nFix: paramFix = paramFix_store[i, :] if xFix_transBool: paramFix = transFix(paramFix, xFix_trans) vFix = np.tile(xFix @ paramFix, (nSim, )) if nRnd: zeta_tmp = zeta_store[i, :] ch_tmp = np.linalg.cholesky(Omega_store[i, :, :]) if nRnd2: zeta2_tmp = zeta2_store[i, :, :] Omega2_tmp = Omega2_store[i, :, :, :] pi_tmp = pi_store[i, :] pPred_take = 0 for t in np.arange(nTakes): if nRnd: paramRnd = zeta_tmp + ( ch_tmp @ np.random.randn(nRnd, nInd * nSim)).T if xRnd_transBool: paramRnd = transRnd(paramRnd, xRnd_trans) paramRndPerRow = np.repeat(paramRnd, sim_rowsPerInd, axis=0) #vRnd = np.sum(sim_xRnd * paramRndPerRow, axis = 1) if nRnd2: q = np.random.choice(np.arange(nComp), size=nInd * nSim, replace=True, p=pi_tmp) paramRnd2 = monrnd(zeta2_tmp, Omega2_tmp, q) if xRnd2_transBool: paramRnd2 = transRnd(paramRnd2, xRnd2_trans) paramRnd2PerRow = np.repeat(paramRnd2, sim_rowsPerInd, axis=0) #vRnd2 = np.sum(sim_xRnd2 * paramRnd2PerRow, axis = 1) #v = vFix + vRnd + vRnd2 v = sim_xRnd[:,0] * paramRndPerRow[:,0] \ + paramRndPerRow[:,1] * (sim_xRnd[:,1] + np.sum(sim_xRnd2 * paramRnd2PerRow, axis = 1)) pPred_take += pPredMxl(v, sim_map_avail_to_obs, nSim, chosenIdx, nonChosenIdx) pPred[i, :] = pPred_take / nTakes if ((i + 1) % mcmc_disp) == 0: print('Chain ' + str(chainID + 1) + '; iteration: ' + str(i + 1) + ' (predictive simulation)') sys.stdout.flush() return pPred
def probGrMxl(param, sim_xFix, xFix_transBool, xFix_trans, nFix, sim_xRndUc, xRndUc_transBool, xRndUc_trans, nRndUc, sim_xRndCo, xRndCo_transBool, xRndCo_trans, nRndCo, chIdx, drawsUcTake, drawsCoTake, nDrawsMem, nInd, sim_rowsPerInd, sim_map_obs_to_ind, sim_map_avail_to_obs, sim_map_ind_to_avail, sim_map_draws_to_ind): ### #Utility ### vFix = 0 vRndUc = 0 vRndCo = 0 u = 0 if nFix > 0: l = u u += nFix paramFix = np.array(param[l:u]) if xFix_transBool: paramFix = np.array(transFix(paramFix, xFix_trans)) vFix = sim_xFix @ paramFix if nRndUc > 0: l = u u += nRndUc paramRndUc_mu = np.array(param[l:u]) l = u u += nRndUc paramRndUc_sd = np.array(param[l:u]) paramRndUc = paramRndUc_mu + paramRndUc_sd * drawsUcTake if xRndUc_transBool: paramRndUc = np.array(transRnd(paramRndUc, xRndUc_trans)) paramRndUcPerRow = np.repeat(paramRndUc, sim_rowsPerInd, axis=0) vRndUc = np.sum(sim_xRndUc * paramRndUcPerRow, axis=1) if nRndCo > 0: l = u u += nRndCo paramRndCo_mu = np.array(param[l:u]) l = u paramRndCo_ch = np.zeros((nRndCo, nRndCo)) paramRndCo_ch[chIdx] = np.array(param[l:]) paramRndCo = paramRndCo_mu + (paramRndCo_ch @ drawsCoTake.T).T if xRndCo_transBool: paramRndCo = np.array(transRnd(paramRndCo, xRndCo_trans)) paramRndCoPerRow = np.repeat(paramRndCo, sim_rowsPerInd, axis=0) vRndCo = np.sum(sim_xRndCo * paramRndCoPerRow, axis=1) v = vFix + vRndUc + vRndCo ### #Probability ### ev = np.exp(v) ev[ev > 1e+200] = 1e+200 ev[ev < 1e-200] = 1e-200 nev = sim_map_avail_to_obs.T @ ev + 1 nnev = sim_map_avail_to_obs * nev pChosen = 1 / nev pChosen[pChosen < 1e-200] = 1e-200 pNonChosen = ev / nnev pNonChosen[pNonChosen < 1e-200] = 1e-200 lPChosen = np.log(pChosen) lPInd = sim_map_obs_to_ind.T @ lPChosen pIndVec = np.exp(lPInd) pInd = pIndVec.reshape((nDrawsMem, nInd)).sum(axis=0) ### #Gradient ### def calcGradient(der): frac = -pNonChosen.reshape((-1, 1)) * der summation = sim_map_ind_to_avail @ frac prod = pIndVec.reshape((-1, 1)) * summation sgr = sim_map_draws_to_ind @ prod return sgr sgrFix = np.empty((nInd, 0)) sgrRndUc_mu = np.empty((nInd, 0)) sgrRndUc_sd = np.empty((nInd, 0)) sgrRndCo_mu = np.empty((nInd, 0)) sgrRndCo_ch = np.empty((nInd, 0)) if nFix > 0: derFix = sim_xFix if xFix_transBool: derFix = np.array(transDerFix(derFix, paramFix, xFix_trans)) sgrFix = calcGradient(derFix) if nRndUc > 0: derRndUc_mu, derRndUc_sd = derRnd(nInd, nDrawsMem, nRndUc, xRndUc_transBool, paramRndUc, xRndUc_trans, chIdx, drawsUcTake, sim_rowsPerInd, True) derRndUc_mu *= sim_xRndUc derRndUc_sd *= sim_xRndUc sgrRndUc_mu = calcGradient(derRndUc_mu) sgrRndUc_sd = calcGradient(derRndUc_sd) if nRndCo > 0: derRndCo_mu, derRndCo_ch = derRnd(nInd, nDrawsMem, nRndCo, xRndCo_transBool, paramRndCo, xRndCo_trans, chIdx, drawsCoTake, sim_rowsPerInd, False) derRndCo_mu *= sim_xRndCo derRndCo_ch *= sim_xRndCo[:, chIdx[0]] sgrRndCo_mu = calcGradient(derRndCo_mu) sgrRndCo_ch = calcGradient(derRndCo_ch) sgr = np.concatenate( (sgrFix, sgrRndUc_mu, sgrRndUc_sd, sgrRndCo_mu, sgrRndCo_ch), axis=1) return pInd, sgr
def probGrMxl(param, 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, drawsUcTake, drawsCoTake, nDrawsMem, drawsUcBTake, drawsCoBTake, nDrawsBMem, drawsUcWTake, drawsCoWTake, nDrawsWMem, nInd, nObs, simB_rowsPerInd, simB_obsPerInd, simW_rowsPerObs, simW_map_avail_to_obs, simW_map_drawsB_to_obs): ### #Utility ### vFix = 0 vRndUc = 0 vRndCo = 0 vRnd2Uc = 0 vRnd2Co = 0 u = 0 if nFix > 0: l = u u += nFix paramFix = np.array(param[l:u]) if xFix_transBool: paramFix = np.array(transFix(paramFix, xFix_trans)) vFix = sim_xFix @ paramFix #Good if nRndUc > 0: l = u u += nRndUc paramRndUc_mu = np.array(param[l:u]) l = u u += nRndUc paramRndUc_sd = np.array(param[l:u]) paramRndUc = paramRndUc_mu + paramRndUc_sd * drawsUcTake if xRndUc_transBool: paramRndUc = np.array(transRnd(paramRndUc, xRndUc_trans)) paramRndUcPerRow = np.tile( np.repeat(paramRndUc, simB_rowsPerInd, axis=0), (nDrawsWMem, 1)) #Good vRndUc = np.sum(sim_xRndUc * paramRndUcPerRow, axis=1) if nRndCo > 0: l = u u += nRndCo paramRndCo_mu = np.array(param[l:u]) l = u u += int((nRndCo * (nRndCo + 1)) / 2) paramRndCo_ch = np.zeros((nRndCo, nRndCo)) paramRndCo_ch[chIdx] = np.array(param[l:u]) paramRndCo = paramRndCo_mu + (paramRndCo_ch @ drawsCoTake.T).T if xRndCo_transBool: paramRndCo = np.array(transRnd(paramRndCo, xRndCo_trans)) paramRndCoPerRow = np.tile( np.repeat(paramRndCo, simB_rowsPerInd, axis=0), (nDrawsWMem, 1)) #Good vRndCo = np.sum(sim_xRndCo * paramRndCoPerRow, axis=1) if nRnd2Uc > 0: l = u u += nRnd2Uc paramRnd2Uc_mu = np.array(param[l:u]) l = u u += nRnd2Uc paramRnd2Uc_sdB = np.array(param[l:u]) l = u u += nRnd2Uc paramRnd2Uc_sdW = np.array(param[l:u]) paramRnd2Uc_ind = paramRnd2Uc_mu + paramRnd2Uc_sdB * drawsUcBTake #Good paramRnd2Uc_obs = paramRnd2Uc_sdW * drawsUcWTake #Good paramRnd2Uc = np.tile( np.repeat(paramRnd2Uc_ind, simB_obsPerInd, axis=0), (nDrawsWMem, 1)) + paramRnd2Uc_obs #Good if xRnd2Uc_transBool: paramRnd2Uc = np.array(transRnd(paramRnd2Uc, xRnd2Uc_trans)) paramRnd2UcPerRow = np.repeat(paramRnd2Uc, simW_rowsPerObs, axis=0) #Good vRnd2Uc = np.sum(sim_xRnd2Uc * paramRnd2UcPerRow, axis=1) if nRnd2Co > 0: l = u u += nRnd2Co paramRnd2Co_mu = np.array(param[l:u]) l = u u += int((nRnd2Co * (nRnd2Co + 1)) / 2) paramRnd2Co_chB = np.zeros((nRnd2Co, nRnd2Co)) paramRnd2Co_chB[ch2Idx] = np.array(param[l:u]) l = u u += int((nRnd2Co * (nRnd2Co + 1)) / 2) paramRnd2Co_chW = np.zeros((nRnd2Co, nRnd2Co)) paramRnd2Co_chW[ch2Idx] = np.array(param[l:u]) paramRnd2Co_ind = paramRnd2Co_mu + ( paramRnd2Co_chB @ drawsCoBTake.T).T #Good paramRnd2Co_obs = (paramRnd2Co_chW @ drawsCoWTake.T).T #Good paramRnd2Co = np.tile( np.repeat(paramRnd2Co_ind, simB_obsPerInd, axis=0), (nDrawsWMem, 1)) + paramRnd2Co_obs #Good if xRnd2Co_transBool: paramRnd2Co = np.array(transRnd(paramRnd2Co, xRnd2Co_trans)) paramRnd2CoPerRow = np.repeat(paramRnd2Co, simW_rowsPerObs, axis=0) #Good vRnd2Co = np.sum(sim_xRnd2Co * paramRnd2CoPerRow, axis=1) v = vFix + vRndUc + vRndCo + vRnd2Uc + vRnd2Co ### #Probability ### ev = np.exp(v) ev[ev > 1e+200] = 1e+200 ev[ev < 1e-200] = 1e-200 nev = simW_map_avail_to_obs.T @ ev + 1 nnev = simW_map_avail_to_obs @ nev sim_pChosen = 1 / nev sim_pChosen[sim_pChosen < 1e-200] = 1e-200 sim_pNonChosen = ev / nnev sim_pNonChosen[sim_pNonChosen < 1e-200] = 1e-200 pChosen = sim_pChosen.reshape( (nDrawsWMem, nDrawsBMem, nObs)).sum(axis=0).reshape((-1, 1)) ### #Gradient ### def calcGradient(der): t1 = -sim_pNonChosen.reshape((-1, 1)) * der t2 = simW_map_avail_to_obs.T @ t1 numer = sim_pChosen.reshape((-1, 1)) * t2 sgr = simW_map_drawsB_to_obs @ numer return sgr sgrFix = np.empty((nObs * nDrawsBMem, 0)) sgrRndUc_mu = np.empty((nObs * nDrawsBMem, 0)) sgrRndUc_sd = np.empty((nObs * nDrawsBMem, 0)) sgrRndCo_mu = np.empty((nObs * nDrawsBMem, 0)) sgrRndCo_ch = np.empty((nObs * nDrawsBMem, 0)) sgrRnd2Uc_mu = np.empty((nObs * nDrawsBMem, 0)) sgrRnd2Uc_sdB = np.empty((nObs * nDrawsBMem, 0)) sgrRnd2Uc_sdW = np.empty((nObs * nDrawsBMem, 0)) sgrRnd2Co_mu = np.empty((nObs * nDrawsBMem, 0)) sgrRnd2Co_chB = np.empty((nObs * nDrawsBMem, 0)) sgrRnd2Co_chW = np.empty((nObs * nDrawsBMem, 0)) if nFix > 0: derFix = sim_xFix if xFix_transBool: derFix = np.array(transDerFix(derFix, paramFix, xFix_trans)) sgrFix = calcGradient(derFix) if nRndUc > 0: derRndUc_mu, derRndUc_sd = derRnd(nInd, nDrawsBMem, nRndUc, xRndUc_transBool, paramRndUc, xRndUc_trans, chIdx, drawsUcTake, simB_rowsPerInd, True) derRndUc_mu = np.tile(derRndUc_mu, (nDrawsWMem, 1)) derRndUc_sd = np.tile(derRndUc_sd, (nDrawsWMem, 1)) derRndUc_mu *= sim_xRndUc derRndUc_sd *= sim_xRndUc sgrRndUc_mu = calcGradient(derRndUc_mu) sgrRndUc_sd = calcGradient(derRndUc_sd) if nRndCo > 0: derRndCo_mu, derRndCo_ch = derRnd(nInd, nDrawsBMem, nRndCo, xRndCo_transBool, paramRndCo, xRndCo_trans, chIdx, drawsCoTake, simB_rowsPerInd, False) derRndCo_mu = np.tile(derRndCo_mu, (nDrawsWMem, 1)) derRndCo_ch = np.tile(derRndCo_ch, (nDrawsWMem, 1)) derRndCo_mu *= sim_xRndCo derRndCo_ch *= sim_xRndCo[:, chIdx[0]] sgrRndCo_mu = calcGradient(derRndCo_mu) sgrRndCo_ch = calcGradient(derRndCo_ch) if nRnd2Uc > 0: derRnd2Uc_mu, derRnd2Uc_sdB = derRnd(nInd, nDrawsBMem, nRnd2Uc, xRnd2Uc_transBool, paramRnd2Uc_ind, xRnd2Uc_trans, ch2Idx, drawsUcBTake, simB_rowsPerInd, True) derRnd2Uc_mu = np.tile(derRnd2Uc_mu, (nDrawsWMem, 1)) derRnd2Uc_sdB = np.tile(derRnd2Uc_sdB, (nDrawsWMem, 1)) derRnd2Uc_sdW = derRnd_ch(nObs, nDrawsMem, nRnd2Uc, xRnd2Uc_transBool, paramRnd2Uc_obs, xRnd2Uc_trans, ch2Idx, drawsUcBTake, simW_rowsPerObs, True) derRnd2Uc_mu *= sim_xRnd2Uc derRnd2Uc_sdB *= sim_xRnd2Uc derRnd2Uc_sdW *= sim_xRnd2Uc sgrRnd2Uc_mu = calcGradient(derRnd2Uc_mu) sgrRnd2Uc_sdB = calcGradient(derRnd2Uc_sdB) sgrRnd2Uc_sdW = calcGradient(derRnd2Uc_sdW) if nRnd2Co > 0: derRnd2Co_mu, derRnd2Co_chB = derRnd(nInd, nDrawsBMem, nRnd2Co, xRnd2Co_transBool, paramRnd2Co_ind, xRnd2Co_trans, ch2Idx, drawsCoBTake, simB_rowsPerInd, False) derRnd2Co_mu = np.tile(derRnd2Co_mu, (nDrawsWMem, 1)) derRnd2Co_chB = np.tile(derRnd2Co_chB, (nDrawsWMem, 1)) derRnd2Co_chW = derRnd_ch(nObs, nDrawsMem, nRnd2Co, xRnd2Co_transBool, paramRnd2Co_obs, xRnd2Co_trans, ch2Idx, drawsCoWTake, simW_rowsPerObs, False) derRnd2Co_mu *= sim_xRnd2Co derRnd2Co_chB *= sim_xRnd2Co[:, ch2Idx[0]] derRnd2Co_chW *= sim_xRnd2Co[:, ch2Idx[0]] sgrRnd2Co_mu = calcGradient(derRnd2Co_mu) sgrRnd2Co_chB = calcGradient(derRnd2Co_chB) sgrRnd2Co_chW = calcGradient(derRnd2Co_chW) sgr = np.concatenate( (sgrFix, sgrRndUc_mu, sgrRndUc_sd, sgrRndCo_mu, sgrRndCo_ch, sgrRnd2Uc_mu, sgrRnd2Uc_sdB, sgrRnd2Uc_sdW, sgrRnd2Co_mu, sgrRnd2Co_chB, sgrRnd2Co_chW), axis=1) return pChosen, sgr