def gibbs(self, ITERS, K, ep1=0, ep2=None, savePosterior=True, gtdiffusion=False, doSepHash=True, use_spc=True, nz_pth=0., smth_pth_ker=100, ignoresilence=False, use_omp=False, nThrds=2): """ gtdiffusion: use ground truth center of place field in calculating variance of center. Meaning of diffPerMin different """ print "gibbs %.5f" % _N.random.rand() oo = self oo.nThrds = nThrds twpi = 2*_N.pi pcklme = {} ep2 = oo.epochs if (ep2 == None) else ep2 oo.epochs = ep2-ep1 ###################################### GRID for calculating #### # points in sum. #### # points in uniform sampling of exp(x)p(x) (non-spike interals) #### # points in sampling of f for conditional posterior distribution #### # points in sampling of q2 for conditional posterior distribution #### NSexp, Nupx, fss, q2ss # numerical grid ux = _N.linspace(oo.xLo, oo.xHi, oo.Nupx, endpoint=False) # uniform x position # grid over uxr = ux.reshape((1, oo.Nupx)) uxrr= ux.reshape((1, 1, oo.Nupx)) #q2x = _N.exp(_N.linspace(_N.log(1e-7), _N.log(100), oo.q2ss)) # 5 orders of q2x = _N.exp(_N.linspace(_N.log(oo.q2x_L), _N.log(oo.q2x_H), oo.q2ss)) # 5 orders of d_q2x = _N.diff(q2x) q2x_m1 = _N.array(q2x[0:-1]) lq2x = _N.log(q2x) iq2x = 1./q2x q2xr = q2x.reshape((oo.q2ss, 1)) iq2xr = 1./q2xr q2xrr = q2x.reshape((1, oo.q2ss, 1)) iq2xrr = 1./q2xrr d_q2xr = d_q2x.reshape((oo.q2ss - 1, 1)) q2x_m1 = _N.array(q2x[0:-1]) q2x_m1r = q2x_m1.reshape((oo.q2ss-1, 1)) sqrt_2pi_q2x = _N.sqrt(twpi*q2x) l_sqrt_2pi_q2x = _N.log(sqrt_2pi_q2x) freeClstr = None if smth_pth_ker > 0: gk = gauKer(smth_pth_ker) # 0.1s smoothing of motion gk /= _N.sum(gk) xf = _N.convolve(oo.dat[:, 0], gk, mode="same") oo.dat[:, 0] = xf + nz_pth*_N.random.randn(len(oo.dat[:, 0])) else: oo.dat[:, 0] += nz_pth*_N.random.randn(len(oo.dat[:, 0])) x = oo.dat[:, 0] mks = oo.dat[:, 2:] if nz_pth > 0: _N.savetxt(resFN("nzyx.txt", dir=oo.outdir), x, fmt="%.4f") f_q2_rate = (oo.diffusePerMin**2)/60000. # unit of minutes ###################################### PRECOMPUTED tau_l0 = oo.t_hlf_l0/_N.log(2) tau_q2 = oo.t_hlf_q2/_N.log(2) for epc in xrange(ep1, ep2): print "^^^^^^^^^^^^^^^^^^^^^^^^ epoch %d" % epc t0 = oo.intvs[epc] t1 = oo.intvs[epc+1] if epc > 0: tm1= oo.intvs[epc-1] # 0 10 30 20 - 5 = 15 0.5*((10+30) - (10+0)) = 15 dt = 0.5*((t1+t0) - (t0+tm1)) dt = (t1-t0)*0.5 xt0t1 = _N.array(x[t0:t1]) posbins = _N.linspace(oo.xLo, oo.xHi, oo.Nupx+1) # _N.sum(px)*(xbns[1]-xbns[0]) = 1 px, xbns = _N.histogram(xt0t1, bins=posbins, normed=True) pxr = px.reshape((1, oo.Nupx)) pxrr = px.reshape((1, 1, oo.Nupx)) Asts = _N.where(oo.dat[t0:t1, 1] == 1)[0] # based at 0 if epc == ep1: ### initialize labS, labH, flatlabels, M, MF, hashthresh, nHSclusters = gAMxMu.initClusters(oo, K, x, mks, t0, t1, Asts, doSepHash=doSepHash, xLo=oo.xLo, xHi=oo.xHi, oneCluster=oo.oneCluster, nzclstr=oo.nzclstr) Mwowonz = M+1 if oo.nzclstr else M #nHSclusters.append(M - nHSclusters[0]-nHSclusters[1]) # last are free clusters that are not the noise cluster u_u_ = _N.empty((M, K)) u_Sg_ = _N.empty((M, K, K)) ####### containers for GIBBS samples iterations smp_sp_prms = _N.zeros((3, ITERS, M)) smp_mk_prms = [_N.zeros((K, ITERS, M)), _N.zeros((K, K, ITERS, M))] smp_sp_hyps = _N.zeros((6, ITERS, M)) smp_mk_hyps = [_N.zeros((K, ITERS, M)), _N.zeros((K, K, ITERS, M)), _N.zeros((1, ITERS, M)), _N.zeros((K, K, ITERS, M))] oo.smp_sp_prms = smp_sp_prms oo.smp_mk_prms = smp_mk_prms oo.smp_sp_hyps = smp_sp_hyps oo.smp_mk_hyps = smp_mk_hyps if oo.nzclstr: smp_nz_l0 = _N.zeros(ITERS) smp_nz_hyps = _N.zeros((2, ITERS)) # list of freeClstrs freeClstr = _N.empty(M, dtype=_N.bool) # Actual cluster freeClstr[:] = False l0, f, q2, u, Sg = gAMxMu.declare_params(M, K, nzclstr=oo.nzclstr) # nzclstr not inited # sized to include noise cluster if needed _l0_a, _l0_B, _f_u, _f_q2, _q2_a, _q2_B, _u_u, _u_Sg, _Sg_nu, \ _Sg_PSI = gAMxMu.declare_prior_hyp_params(M, MF, K, x, mks, Asts, t0) fr = f[0:M].reshape((M, 1)) gAMxMu.init_params_hyps(oo, M, MF, K, l0, f, q2, u, Sg, _l0_a, _l0_B, _f_u, _f_q2, _q2_a, _q2_B, _u_u, _u_Sg, _Sg_nu, \ _Sg_PSI, Asts, t0, x, mks, flatlabels, nHSclusters, nzclstr=oo.nzclstr) U = _N.empty(M) FQ2 = _N.empty(M) _fxs0 = _N.tile(_N.linspace(0, 1, oo.fss), M).reshape(M, oo.fss) f_exp_px = _N.empty((M, oo.fss)) q2_exp_px= _N.empty((M, oo.q2ss)) if oo.nzclstr: nz_l0_intgrd = _N.exp(-0.5*ux*ux / q2[Mwowonz-1]) _nz_l0_a = 0.001 _nz_l0_B = 0.1 ###### the hyperparameters for f, q2, u, Sg, l0 during Gibbs # f_u_, f_q2_, q2_a_, q2_B_, u_u_, u_Sg_, Sg_nu, Sg_PSI_, l0_a_, l0_B_ NSexp = t1-t0 # length of position data # # of no spike positions to sum xt0t1 = _N.array(x[t0:t1]) nSpks = len(Asts) gz = _N.zeros((ITERS, nSpks, Mwowonz), dtype=_N.bool) oo.gz=gz print "spikes %d" % nSpks dSilenceX1 = (NSexp/float(oo.Nupx))*(oo.xHi-oo.xLo) dSilenceX2 = NSexp*(xbns[1]-xbns[0]) # dx of histogram print "-------------------------- %(1).4f %(2).4f" % {"1" : dSilenceX1, "2" : dSilenceX2} dSilenceX = dSilenceX1 xAS = x[Asts + t0] # position @ spikes mAS = mks[Asts + t0] # position @ spikes xASr = xAS.reshape((1, nSpks)) mASr = mAS.reshape((1, nSpks, K)) econt = _N.empty((Mwowonz, nSpks)) rat = _N.zeros((Mwowonz+1, nSpks)) qdrMKS = _N.empty((Mwowonz, nSpks)) ################################ GIBBS ITERS ITERS ITERS clstsz = _N.zeros(M, dtype=_N.int) _iu_Sg = _N.array(_u_Sg) for m in xrange(M): _iu_Sg[m] = _N.linalg.inv(_u_Sg[m]) ttA = _tm.time() for iter in xrange(ITERS): tt1 = _tm.time() iSg = _N.linalg.inv(Sg) if (iter % 100) == 0: #print "-------iter %(i)d %(r).5f" % {"i" : iter, "r" : _N.random.rand()} print "-------iter %(i)d" % {"i" : iter} gAMxMu.stochasticAssignment(oo, epc, iter, M, Mwowonz, K, l0, f, q2, u, Sg, _f_u, _u_u, _f_q2, _u_Sg, Asts, t0, mASr, xASr, rat, econt, gz, qdrMKS, freeClstr, hashthresh, ((epc > 0) and (iter == 0)), nthrds=oo.nThrds) #gAMxMu.stochasticAssignment(oo, iter, M, Mwowonz, K, l0, f, q2, u, Sg, _f_u, _u_u, Asts, t0, mASr, xASr, rat, econt, gz, qdrMKS, freeClstr, hashthresh, iter==0, nthrds=oo.nThrds) ############### FOR EACH CLUSTER l_sts = [] for m in xrange(M): # get the minds minds = _N.where(gz[iter, :, m] == 1)[0] sts = Asts[minds] + t0 # sts is in absolute time clstsz[m] = len(sts) l_sts.append(sts) # for m in xrange(Mwowonz): # get the minds # minds = _N.where(gz[iter, :, m] == 1)[0] # print "cluster %(m)d len %(l)d " % {"m" : m, "l" : len(minds)} # print u[m] # print f[m] #tt2 = _tm.time() ############### ############### CONDITIONAL l0 ############### # _ss.gamma.rvs. uses k, theta k is 1/B (B is our thing) iiq2 = 1./q2[0:M] iiq2r= iiq2.reshape((M, 1)) iiq2rr= iiq2.reshape((M, 1, 1)) fr = f[0:M].reshape((M, 1)) l0_intgrd = _N.exp(-0.5*(fr - ux)*(fr-ux) * iiq2r) sLLkPr = _N.empty((M, oo.q2ss)) l0_exp_px = _N.sum(l0_intgrd*pxr, axis=1) * dSilenceX BL = (oo.dt/_N.sqrt(twpi*q2[0:M]))*l0_exp_px # dim M if (epc > 0) and oo.adapt: _md_nd= _l0_a / _l0_B _Dl0_a = _l0_a * _N.exp(-dt/tau_l0) _Dl0_B = _Dl0_a / _md_nd else: _Dl0_a = _l0_a _Dl0_B = _l0_B aL = clstsz l0_a_ = aL + _Dl0_a l0_B_ = BL + _Dl0_B try: # mean is (l0_a_ / l0_B_) l0[0:M] = _ss.gamma.rvs(l0_a_, scale=(1/l0_B_)) # check except ValueError: """ print l0_B_ print _Dl0_B print BL print l0_exp_px print 1/_N.sqrt(twpi*q2[0:M]) print pxr print l0_intgrd """ _N.savetxt("fxux", (fr - ux)*(fr-ux)) _N.savetxt("fr", fr) _N.savetxt("iiq2", iiq2) _N.savetxt("l0_intgrd", l0_intgrd) raise smp_sp_prms[oo.ky_p_l0, iter] = l0[0:M] smp_sp_hyps[oo.ky_h_l0_a, iter] = l0_a_ smp_sp_hyps[oo.ky_h_l0_B, iter] = l0_B_ mcs = _N.empty((M, K)) # cluster sample means #tt3 = _tm.time() ############### ############### u ############### for m in xrange(M): if clstsz[m] > 0: u_Sg_[m] = _N.linalg.inv(_iu_Sg[m] + clstsz[m]*iSg[m]) clstx = mks[l_sts[m]] mcs[m] = _N.mean(clstx, axis=0) #u_u_[m] = _N.dot(u_Sg_[m], _N.dot(_iu_Sg[m], _u_u[m]) + clstsz[m]*_N.dot(iSg[m], mcs[m])) u_u_[m] = _N.einsum("jk,k->j", u_Sg_[m], _N.dot(_iu_Sg[m], _u_u[m]) + clstsz[m]*_N.dot(iSg[m], mcs[m])) # print "mean of cluster %d" % m # print mcs[m] # print u_u_[m] # hyp ######## POSITION ## mean of posterior distribution of cluster means # sigma^2 and mu are the current Gibbs-sampled values ## mean of posterior distribution of cluster means # print "for cluster %(m)d with size %(sz)d" % {"m" : m, "sz" : clstsz[m]} # print mcs[m] # print u_u_[m] # print _u_u[m] else: u_Sg_[m] = _N.array(_u_Sg[m]) u_u_[m] = _N.array(_u_u[m]) ucmvnrms= _N.random.randn(M, K) C = _N.linalg.cholesky(u_Sg_) u[0:M] = _N.einsum("njk,nk->nj", C, ucmvnrms) + u_u_ smp_mk_prms[oo.ky_p_u][:, iter] = u[0:M].T # dim of u wrong smp_mk_hyps[oo.ky_h_u_u][:, iter] = u_u_.T smp_mk_hyps[oo.ky_h_u_Sg][:, :, iter] = u_Sg_.T #tt4 = _tm.time() ############### ############### Conditional f ############### if (epc > 0) and oo.adapt: q2pr = _f_q2 + f_q2_rate * dt else: q2pr = _f_q2 for m in xrange(M): sts = l_sts[m] if clstsz[m] > 0: fs = (1./clstsz[m])*_N.sum(xt0t1[sts-t0]) fq2 = q2[m]/clstsz[m] U[m] = (fs*q2pr[m] + _f_u[m]*fq2) / (q2pr[m] + fq2) FQ2[m] = (q2pr[m]*fq2) / (q2pr[m] + fq2) else: U[m] = _f_u[m] FQ2[m] = q2pr[m] FQ = _N.sqrt(FQ2) Ur = U.reshape((M, 1)) FQr = FQ.reshape((M, 1)) FQ2r = FQ2.reshape((M, 1)) if use_spc: fxs = _N.copy(_fxs0) fxs *= (FQr*120) fxs -= (FQr*60) fxs += Ur if use_omp: M_times_N_f_intgrls_raw(fxs, ux, iiq2, dSilenceX, px, f_exp_px, M, oo.fss, oo.Nupx, oo.nThrds) else: fxsr = fxs.reshape((M, oo.fss, 1)) fxrux = -0.5*(fxsr-uxrr)*(fxsr-uxrr) # f_intgrd is M x fss x Nupx f_intgrd = _N.exp(fxrux*iiq2rr) # integrand f_exp_px = _N.sum(f_intgrd*pxrr, axis=2) * dSilenceX # f_exp_px is M x fss l0r = l0[0:M].reshape((M, 1)) q2r = q2[0:M].reshape((M, 1)) # s is (M x fss) s = -(l0r*oo.dt/_N.sqrt(twpi*q2r)) * f_exp_px # a function of x #if (iter > ITERS - 40) and (iter % 5 == 0): # print f_exp_px # _plt.plot(fxs[0], _N.s) else: s = _N.zeros(M) # U, FQ2 is dim(M) # fxs is M x fss funcf = -0.5*((fxs-Ur)*(fxs-Ur))/FQ2r + s maxes = _N.max(funcf, axis=1) maxesr = maxes.reshape((M, 1)) funcf -= maxesr condPosF= _N.exp(funcf) # condPosF is M x fss ttB = _tm.time() # fxs M x fss # fxs M x fss # condPosF M x fss norm = 1./_N.sum(condPosF, axis=1) # sz M f_u_ = norm*_N.sum(fxs*condPosF, axis=1) # sz M f_u_r = f_u_.reshape((M, 1)) f_q2_ = norm*_N.sum(condPosF*(fxs-f_u_r)*(fxs-f_u_r), axis=1) f[0:M] = _N.sqrt(f_q2_)*_N.random.randn() + f_u_ smp_sp_prms[oo.ky_p_f, iter] = f[0:M] smp_sp_hyps[oo.ky_h_f_u, iter] = f_u_ smp_sp_hyps[oo.ky_h_f_q2, iter] = f_q2_ #tt5 = _tm.time() ############## ############## VARIANCE, COVARIANCE ############## for m in xrange(M): if clstsz[m] >= K: ## dof of posterior distribution of cluster covariance Sg_nu_ = _Sg_nu[m, 0] + clstsz[m] ## dof of posterior distribution of cluster covariance ur = u[m].reshape((1, K)) clstx = mks[l_sts[m]] Sg_PSI_ = _Sg_PSI[m] + _N.dot((clstx - ur).T, (clstx-ur)) else: Sg_nu_ = _Sg_nu[m, 0] ## dof of posterior distribution of cluster covariance ur = u[m].reshape((1, K)) Sg_PSI_ = _Sg_PSI[m] Sg[m] = s_u.sample_invwishart(Sg_PSI_, Sg_nu_) smp_mk_hyps[oo.ky_h_Sg_nu][0, iter, m] = Sg_nu_ smp_mk_hyps[oo.ky_h_Sg_PSI][:, :, iter, m] = Sg_PSI_ ## dof of posterior distribution of cluster covariance smp_mk_prms[oo.ky_p_Sg][:, :, iter] = Sg[0:M].T #tt6 = _tm.time() ############## ############## SAMPLE SPATIAL VARIANCE ############## if use_spc: # M x q2ss x Nupx # f M x 1 x 1 # iq2xrr 1 x q2ss x 1 # uxrr 1 x 1 x Nupx if use_omp: #ux variable held fixed M_times_N_q2_intgrls_raw(f, ux, iq2x, dSilenceX, px, q2_exp_px, M, oo.q2ss, oo.Nupx, oo.nThrds) else: frr = f.reshape((M, 1, 1)) q2_intgrd = _N.exp(-0.5*(frr - uxrr)*(frr-uxrr) * iq2xrr) q2_exp_px = _N.sum(q2_intgrd*pxrr, axis=2) * dSilenceX # function of q2 s = -((l0r*oo.dt)/sqrt_2pi_q2x)*q2_exp_px else: s = _N.zeros((oo.q2ss, M)) # B' / (a' - 1) = MODE #keep mode the same after discount # B' = MODE * (a' - 1) if (epc > 0) and oo.adapt: _md_nd= _q2_B / (_q2_a + 1) _Dq2_a = _q2_a * _N.exp(-dt/tau_q2) _Dq2_B = _Dq2_a / _md_nd else: _Dq2_a = _q2_a _Dq2_B = _q2_B SL_Bs = _N.empty(M) SL_as = _N.empty(M) for m in xrange(M): if clstsz[m] > 0: sts = l_sts[m] xI = (xt0t1[sts-t0]-f[m])*(xt0t1[sts-t0]-f[m])*0.5 SL_a = 0.5*clstsz[m] - 1 # spiking part of likelihood SL_B = _N.sum(xI) # spiking part of likelihood SL_Bs[m] = SL_B SL_as[m] = SL_a # spiking prior x prior #sLLkPr[m] = -(SL_a + 1)*lq2x - iq2x*SL_B sLLkPr[m] = -(_q2_a[m] + SL_a + 2)*lq2x - iq2x*(_q2_B[m] + SL_B) else: sLLkPr[m] = -(_q2_a[m] + 1)*lq2x - iq2x*_q2_B[m] q2_a_, q2_B_ = mltpl_ig_prmsUV(q2xr, sLLkPr.T, s.T, d_q2xr, q2x_m1r, clstsz, iter, mks, t0, xt0t1, gz, l_sts, SL_as, SL_Bs, _q2_a, _q2_B, oo.q2_min, oo.q2_max) q2[0:M] = _ss.invgamma.rvs(q2_a_ + 1, scale=q2_B_) # check tt7 = _tm.time() smp_sp_prms[oo.ky_p_q2, iter] = q2[0:M] smp_sp_hyps[oo.ky_h_q2_a, iter] = q2_a_ smp_sp_hyps[oo.ky_h_q2_B, iter] = q2_B_ # print "timing start" # print (tt2-tt1) # print (tt3-tt2) # print (tt4-tt3) # print (tt5-tt4) # print (tt6-tt5) #print (tt7-tt1) # print "timing end" # nz clstr. fixed width if oo.nzclstr: nz_l0_exp_px = _N.sum(nz_l0_intgrd*px) * dSilenceX BL = (oo.dt/_N.sqrt(twpi*q2[Mwowonz-1]))*nz_l0_exp_px minds = len(_N.where(gz[iter, :, Mwowonz-1] == 1)[0]) l0_a_ = minds + _nz_l0_a l0_B_ = BL + _nz_l0_B l0[Mwowonz-1] = _ss.gamma.rvs(l0_a_, scale=(1/l0_B_)) smp_nz_l0[iter] = l0[Mwowonz-1] smp_nz_hyps[0, iter] = l0_a_ smp_nz_hyps[1, iter] = l0_B_ ttB = _tm.time() print (ttB-ttA) gAMxMu.finish_epoch(oo, nSpks, epc, ITERS, gz, l0, f, q2, u, Sg, _f_u, _f_q2, _q2_a, _q2_B, _l0_a, _l0_B, _u_u, _u_Sg, _Sg_nu, _Sg_PSI, smp_sp_hyps, smp_sp_prms, smp_mk_hyps, smp_mk_prms, freeClstr, M, K) # MAP of nzclstr if oo.nzclstr: frm = int(0.7*ITERS) _nz_l0_a = _N.median(smp_nz_hyps[0, frm:]) _nz_l0_B = _N.median(smp_nz_hyps[1, frm:]) pcklme["smp_sp_hyps"] = smp_sp_hyps pcklme["smp_mk_hyps"] = smp_mk_hyps pcklme["smp_sp_prms"] = smp_sp_prms pcklme["smp_mk_prms"] = smp_mk_prms pcklme["sp_prmPstMd"] = oo.sp_prmPstMd pcklme["mk_prmPstMd"] = oo.mk_prmPstMd pcklme["intvs"] = oo.intvs pcklme["occ"] = gz pcklme["nz_pth"] = nz_pth pcklme["M"] = M pcklme["Mwowonz"] = Mwowonz if Mwowonz > M: # or oo.nzclstr == True pcklme["nz_fs"] = f[M] pcklme["nz_q2"] = q2[M] pcklme["nz_Sg"] = Sg[M] pcklme["nz_u"] = u[M] pcklme["smp_nz_l0"] = smp_nz_l0 pcklme["smp_nz_hyps"]= smp_nz_hyps dmp = open(resFN("posteriors_%d.dmp" % epc, dir=oo.outdir), "wb") pickle.dump(pcklme, dmp, -1) dmp.close()
def gibbs(self, ITERS, K, ep1=0, ep2=None, savePosterior=True, gtdiffusion=False, Mdbg=None, doSepHash=True, use_spc=True, nz_pth=0., ignoresilence=False, use_omp=False): """ gtdiffusion: use ground truth center of place field in calculating variance of center. Meaning of diffPerMin different """ print "gibbs" oo = self twpi = 2*_N.pi pcklme = {} ep2 = oo.epochs if (ep2 == None) else ep2 oo.epochs = ep2-ep1 ###################################### GRID for calculating #### # points in sum. #### # points in uniform sampling of exp(x)p(x) (non-spike interals) #### # points in sampling of f for conditional posterior distribution #### # points in sampling of q2 for conditional posterior distribution #### NSexp, Nupx, fss, q2ss # numerical grid ux = _N.linspace(oo.xLo, oo.xHi, oo.Nupx, endpoint=False) # uniform x position q2x = _N.exp(_N.linspace(_N.log(1e-7), _N.log(100), oo.q2ss)) # 5 orders of d_q2x = _N.diff(q2x) q2x_m1 = _N.array(q2x[0:-1]) lq2x = _N.log(q2x) iq2x = 1./q2x q2xr = q2x.reshape((oo.q2ss, 1)) iq2xr = 1./q2xr sqrt_2pi_q2x = _N.sqrt(twpi*q2x) l_sqrt_2pi_q2x = _N.log(sqrt_2pi_q2x) freeClstr = None gk = gauKer(100) # 0.1s smoothing of motion gk /= _N.sum(gk) xf = _N.convolve(oo.dat[:, 0], gk, mode="same") oo.dat[:, 0] = xf + nz_pth*_N.random.randn(len(oo.dat[:, 0])) x = oo.dat[:, 0] mks = oo.dat[:, 2:] f_q2_rate = (oo.diffusePerMin**2)/60000. # unit of minutes ###################################### PRECOMPUTED tau_l0 = oo.t_hlf_l0/_N.log(2) tau_q2 = oo.t_hlf_q2/_N.log(2) for epc in xrange(ep1, ep2): t0 = oo.intvs[epc] t1 = oo.intvs[epc+1] if epc > 0: tm1= oo.intvs[epc-1] # 0 10 30 20 - 5 = 15 0.5*((10+30) - (10+0)) = 15 dt = 0.5*((t1+t0) - (t0+tm1)) dt = (t1-t0)*0.5 xt0t1 = _N.array(x[t0:t1]) posbins = _N.linspace(oo.xLo, oo.xHi, oo.Nupx+1) # _N.sum(px)*(xbns[1]-xbns[0]) = 1 px, xbns = _N.histogram(xt0t1, bins=posbins, normed=True) Asts = _N.where(oo.dat[t0:t1, 1] == 1)[0] # based at 0 Ants = _N.where(oo.dat[t0:t1, 1] == 0)[0] if epc == ep1: ### initialize labS, labH, lab, flatlabels, M, MF, hashthresh, nHSclusters = gAMxMu.initClusters(oo, K, x, mks, t0, t1, Asts, doSepHash=doSepHash, xLo=oo.xLo, xHi=oo.xHi, oneCluster=oo.oneCluster) # nHSclusters is # of clusters in hash and signal signalClusters = _N.where(flatlabels < nHSclusters[0])[0] Mwowonz = M if not oo.nzclstr else M + 1 ####### containers for GIBBS samples iterations smp_sp_prms = _N.zeros((3, ITERS, M)) smp_mk_prms = [_N.zeros((K, ITERS, M)), _N.zeros((K, K, ITERS, M))] smp_sp_hyps = _N.zeros((6, ITERS, M)) smp_mk_hyps = [_N.zeros((K, ITERS, M)), _N.zeros((K, K, ITERS, M)), _N.zeros((1, ITERS, M)), _N.zeros((K, K, ITERS, M))] oo.smp_sp_prms = smp_sp_prms oo.smp_mk_prms = smp_mk_prms oo.smp_sp_hyps = smp_sp_hyps oo.smp_mk_hyps = smp_mk_hyps if oo.nzclstr: smp_nz_l0 = _N.zeros(ITERS) smp_nz_hyps = _N.zeros((2, ITERS)) # list of freeClstrs freeClstr = _N.empty(M, dtype=_N.bool) # Actual cluster freeClstr[:] = False l0, f, q2, u, Sg = gAMxMu.declare_params(M, K, nzclstr=oo.nzclstr) # nzclstr not INITED, sized to include noise cluster if needed _l0_a, _l0_B, _f_u, _f_q2, _q2_a, _q2_B, _u_u, _u_Sg, _Sg_nu, \ _Sg_PSI = gAMxMu.declare_prior_hyp_params(M, MF, K, x, mks, Asts, t0) # hyper params don't include noise cluster gAMxMu.init_params_hyps(oo, M, MF, K, l0, f, q2, u, Sg, Asts, t0, x, mks, flatlabels, nzclstr=oo.nzclstr, signalClusters=signalClusters) ###### the hyperparameters for f, q2, u, Sg, l0 during Gibbs # f_u_, f_q2_, q2_a_, q2_B_, u_u_, u_Sg_, Sg_nu, Sg_PSI_, l0_a_, l0_B_ if oo.nzclstr: nz_l0_intgrd = _N.exp(-0.5*ux*ux / q2[Mwowonz-1]) _nz_l0_a = 0.001 _nz_l0_B = 0.1 NSexp = t1-t0 # length of position data # # of no spike positions to sum xt0t1 = _N.array(x[t0:t1]) nSpks = len(Asts) gz = _N.zeros((ITERS, nSpks, Mwowonz), dtype=_N.bool) oo.gz=gz print "spikes %d" % nSpks #dSilenceX = (NSexp/float(oo.Nupx))*(oo.xHi-oo.xLo) dSilenceX = NSexp*(xbns[1]-xbns[0]) # dx of histogram xAS = x[Asts + t0] # position @ spikes mAS = mks[Asts + t0] # position @ spikes xASr = xAS.reshape((1, nSpks)) #mASr = mAS.reshape((nSpks, 1, K)) mASr = mAS.reshape((1, nSpks, K)) econt = _N.empty((Mwowonz, nSpks)) rat = _N.zeros((Mwowonz+1, nSpks)) qdrMKS = _N.empty((Mwowonz, nSpks)) ################################ GIBBS ITERS ITERS ITERS # linalgerror #_iSg_Mu = _N.einsum("mjk,mk->mj", _N.linalg.inv(_u_Sg), _u_u) clusSz = _N.zeros(M, dtype=_N.int) _iu_Sg = _N.array(_u_Sg) for m in xrange(M): _iu_Sg[m] = _N.linalg.inv(_u_Sg[m]) ttA = _tm.time() for iter in xrange(ITERS): iSg = _N.linalg.inv(Sg) if (iter % 5) == 0: print "iter %d" % iter gAMxMu.stochasticAssignment(oo, iter, M, Mwowonz, K, l0, f, q2, u, Sg, _f_u, _u_u, Asts, t0, mASr, xASr, rat, econt, gz, qdrMKS, freeClstr, hashthresh, ((epc > 0) and (iter == 0))) # ############### FOR EACH CLUSTER for m in xrange(M): minds = _N.where(gz[iter, :, m] == 1)[0] sts = Asts[minds] + t0 nSpksM = len(sts) clusSz[m] = nSpksM ############### CONDITIONAL l0 # _ss.gamma.rvs. uses k, theta k is 1/B (B is our thing) iiq2 = 1./q2[m] # xI = (xt0t1-f[m])*(xt0t1-f[m])*0.5*iiq2 # BL = (oo.dt/_N.sqrt(twpi*q2[m]))*_N.sum(_N.exp(-xI)) # l0_intgrd (M x Nupx) l0_intgrd = _N.exp(-0.5*(f[m] - ux)*(f[m]-ux) * iiq2) l0_exp_px = _N.sum(l0_intgrd*px) * dSilenceX BL = (oo.dt/_N.sqrt(twpi*q2[m]))*l0_exp_px # # keep mode same after discount # a' - 1 / B' = MODE # mode is a - 1 / B # B' = (a' - 1) / MODE # discount a #if (epc > 0) and oo.adapt and (_l0_a[m] > 1.1): if (epc > 0) and oo.adapt: _md_nd= _l0_a[m] / _l0_B[m] _Dl0_a = _l0_a[m] * _N.exp(-dt/tau_l0) _Dl0_B = _Dl0_a / _md_nd else: _Dl0_a = _l0_a[m] _Dl0_B = _l0_B[m] # a'/B' = a/B # B' = (B/a)a' aL = nSpksM l0_a_ = aL + _Dl0_a l0_B_ = BL + _Dl0_B # print "------------------" # print "liklhd BL %(B).3f f %(f).3f a %(a)d B/a %(ba).3f" % {"B" : BL, "f" : f[m], "ba" : (aL/ BL), "a" : aL} # print "prior BL %(B).3f f %(f).3f a %(a)d B/a %(ba).3f" % {"B" : l0_B_, "f" : f[m], "ba" : (l0_a_/ l0_B_), "a" : l0_a_} # print (len(xt0t1)*oo.dt) # print "******************" #print "%(1).5f %(2).5f" % {"1" : l0_a_, "2" : l0_B_} try: l0[m] = _ss.gamma.rvs(l0_a_, scale=(1/l0_B_)) # check except ValueError: print "fail" print "M: %d" % M print "_l0_a[m] %.3f" % _l0_a[m] print "_l0_B[m] %.3f" % _l0_B[m] print "l0_a_ %.3f" % l0_a_ print "l0_B_ %.3f" % l0_B_ print "aL %.3f" % aL print "BL %.3f" % BL print "_Dl0_a %.3f" % _Dl0_a print "_Dl0_B %.3f" % _Dl0_B raise ### l0 / _N.sqrt(twpi*q2) is f*dt used in createData2 smp_sp_prms[oo.ky_p_l0, iter, m] = l0[m] smp_sp_hyps[oo.ky_h_l0_a, iter, m] = l0_a_ smp_sp_hyps[oo.ky_h_l0_B, iter, m] = l0_B_ mcs = _N.empty((M, K)) # cluster sample means if nSpksM >= K: u_Sg_ = _N.linalg.inv(_iu_Sg[m] + nSpksM*iSg[m]) clstx = mks[sts] mcs[m] = _N.mean(clstx, axis=0) #u_u_ = _N.einsum("jk,k->j", u_Sg_, _N.dot(_N.linalg.inv(_u_Sg[m]), _u_u[m]) + nSpksM*_N.dot(iSg[m], mcs[m])) #u_u_ = _N.einsum("jk,k->j", u_Sg_, _N.dot(_iu_Sg[m], _u_u[m]) + nSpksM*_N.dot(iSg[m], mcs[m])) # hyp ######## POSITION ## mean of posterior distribution of cluster means # sigma^2 and mu are the current Gibbs-sampled values ## mean of posterior distribution of cluster means else: u_Sg_ = _N.array(_u_Sg[m]) u_u_ = _N.array(_u_u[m]) u[m] = _N.random.multivariate_normal(u_u_, u_Sg_) smp_mk_prms[oo.ky_p_u][:, iter, m] = u[m] smp_mk_hyps[oo.ky_h_u_u][:, iter, m] = u_u_ smp_mk_hyps[oo.ky_h_u_Sg][:, :, iter, m] = u_Sg_ """ ############################################ """ ############### CONDITIONAL f #q2pr = _f_q2[m] if (_f_q2[m] > q2rate) else q2rate if (epc > 0) and oo.adapt: q2pr = _f_q2[m] + f_q2_rate * dt else: q2pr = _f_q2[m] if nSpksM > 0: # spiking portion likelihood x prior fs = (1./nSpksM)*_N.sum(xt0t1[sts-t0]) fq2 = q2[m]/nSpksM U = (fs*q2pr + _f_u[m]*fq2) / (q2pr + fq2) FQ2 = (q2pr*fq2) / (q2pr + fq2) else: U = _f_u[m] FQ2 = q2pr FQ = _N.sqrt(FQ2) fx = _N.linspace(U - FQ*15, U + FQ*15, oo.fss) if use_spc: fxr = fx.reshape((oo.fss, 1)) fxrux = -0.5*(fxr-ux)*(fxr-ux) # f_intgrd = _N.exp((fxrux*iiq2)) # integrand f_exp_px = _N.sum(f_intgrd*px, axis=1) * dSilenceX s = -(l0[m]*oo.dt/_N.sqrt(twpi*q2[m])) * f_exp_px # a function of x else: s = 0 funcf = -0.5*((fx-U)*(fx-U))/FQ2 + s funcf -= _N.max(funcf) condPosF= _N.exp(funcf) norm = 1./_N.sum(condPosF) f_u_ = norm*_N.sum(fx*condPosF) f_q2_ = norm*_N.sum(condPosF*(fx-f_u_)*(fx-f_u_)) f[m] = _N.sqrt(f_q2_)*_N.random.randn() + f_u_ smp_sp_prms[oo.ky_p_f, iter, m] = f[m] smp_sp_hyps[oo.ky_h_f_u, iter, m] = f_u_ smp_sp_hyps[oo.ky_h_f_q2, iter, m] = f_q2_ #ttc1g = _tm.time() ############# VARIANCE, COVARIANCE if nSpksM >= K: ## dof of posterior distribution of cluster covariance Sg_nu_ = _Sg_nu[m, 0] + nSpksM ## dof of posterior distribution of cluster covariance ur = u[m].reshape((1, K)) Sg_PSI_ = _Sg_PSI[m] + _N.dot((clstx - ur).T, (clstx-ur)) Sg[m] = s_u.sample_invwishart(Sg_PSI_, Sg_nu_) else: Sg_nu_ = _Sg_nu[m, 0] ## dof of posterior distribution of cluster covariance ur = u[m].reshape((1, K)) Sg_PSI_ = _Sg_PSI[m] Sg[m] = s_u.sample_invwishart(Sg_PSI_, Sg_nu_) ############## SAMPLE COVARIANCES ## dof of posterior distribution of cluster covariance smp_mk_prms[oo.ky_p_Sg][:, :, iter, m] = Sg[m] smp_mk_hyps[oo.ky_h_Sg_nu][0, iter, m] = Sg_nu_ smp_mk_hyps[oo.ky_h_Sg_PSI][:, :, iter, m] = Sg_PSI_ # ############### CONDITIONAL q2 #xI = (xt0t1-f)*(xt0t1-f)*0.5*iq2xr if use_spc: q2_intgrd = _N.exp(-0.5*(f[m] - ux)*(f[m]-ux) * iq2xr) q2_exp_px = _N.sum(q2_intgrd*px, axis=1) * dSilenceX # function of q2 s = -((l0[m]*oo.dt)/sqrt_2pi_q2x)*q2_exp_px else: s = 0 # B' / (a' - 1) = MODE #keep mode the same after discount # B' = MODE * (a' - 1) if (epc > 0) and oo.adapt: _md_nd= _q2_B[m] / (_q2_a[m] + 1) _Dq2_a = _q2_a[m] * _N.exp(-dt/tau_q2) _Dq2_B = _Dq2_a / _md_nd else: _Dq2_a = _q2_a[m] _Dq2_B = _q2_B[m] if nSpksM > 0: ## (1/sqrt(sg2))^S ## (1/x)^(S/2) = (1/x)-(a+1) ## -S/2 = -a - 1 -a = -S/2 + 1 a = S/2-1 xI = (xt0t1[sts-t0]-f[m])*(xt0t1[sts-t0]-f[m])*0.5 SL_a = 0.5*nSpksM - 1 # spiking part of likelihood SL_B = _N.sum(xI) # spiking part of likelihood # spiking prior x prior sLLkPr = -(_q2_a[m] + SL_a + 2)*lq2x - iq2x*(_q2_B[m] + SL_B) else: sLLkPr = -(_q2_a[m] + 1)*lq2x - iq2x*_q2_B[m] sat = sLLkPr + s sat -= _N.max(sat) condPos = _N.exp(sat) q2_a_, q2_B_ = ig_prmsUV(q2x, sLLkPr, s, d_q2x, q2x_m1, ITER=1, nSpksM=nSpksM, clstr=m, l0=l0[m]) # sat = sLLkPr + s # sat -= _N.max(sat) # condPos = _N.exp(sat) # q2_a_, q2_B_ = ig_prmsUV(q2x, condPos, d_q2x, q2x_m1, ITER=1) q2[m] = _ss.invgamma.rvs(q2_a_ + 1, scale=q2_B_) # check #q2[m] = 1.1**2 #print ((1./nSpks)*_N.sum((xt0t1[sts]-f)*(xt0t1[sts]-f))) if q2[m] < 0: print "******** q2[%(m)d] = %(q2).3f" % {"m" : m, "q2" : q2[m]} smp_sp_prms[oo.ky_p_q2, iter, m] = q2[m] smp_sp_hyps[oo.ky_h_q2_a, iter, m] = q2_a_ smp_sp_hyps[oo.ky_h_q2_B, iter, m] = q2_B_ if q2[m] < 0: print "^^^^^^^^ q2[%(m)d] = %(q2).3f" % {"m" : m, "q2" : q2[m]} print q2[m] print smp_sp_prms[oo.ky_p_q2, 0:iter+1, m] iiq2 = 1./q2[m] #ttc1h = _tm.time() # nz clstr. fixed width if oo.nzclstr: nz_l0_exp_px = _N.sum(nz_l0_intgrd*px) * dSilenceX BL = (oo.dt/_N.sqrt(twpi*q2[Mwowonz-1]))*nz_l0_exp_px minds = len(_N.where(gz[iter, :, Mwowonz-1] == 1)[0]) l0_a_ = minds + _nz_l0_a l0_B_ = BL + _nz_l0_B l0[Mwowonz-1] = _ss.gamma.rvs(l0_a_, scale=(1/l0_B_)) smp_nz_l0[iter] = l0[Mwowonz-1] smp_nz_hyps[0, iter] = l0_a_ smp_nz_hyps[1, iter] = l0_B_ ttB = _tm.time() print (ttB-ttA) ### THIS LEVEL: Finished Gibbs iters for epoch gAMxMu.finish_epoch(oo, nSpks, epc, ITERS, gz, l0, f, q2, u, Sg, _f_u, _f_q2, _q2_a, _q2_B, _l0_a, _l0_B, _u_u, _u_Sg, _Sg_nu, _Sg_PSI, smp_sp_hyps, smp_sp_prms, smp_mk_hyps, smp_mk_prms, freeClstr, M, K) # MAP of nzclstr if oo.nzclstr: frm = int(0.7*ITERS) _nz_l0_a = _N.median(smp_nz_hyps[0, frm:]) _nz_l0_B = _N.median(smp_nz_hyps[1, frm:]) pcklme["smp_sp_hyps"] = smp_sp_hyps pcklme["smp_mk_hyps"] = smp_mk_hyps pcklme["smp_sp_prms"] = smp_sp_prms pcklme["smp_mk_prms"] = smp_mk_prms pcklme["sp_prmPstMd"] = oo.sp_prmPstMd pcklme["mk_prmPstMd"] = oo.mk_prmPstMd pcklme["intvs"] = oo.intvs pcklme["occ"] = gz pcklme["nz_pth"] = nz_pth pcklme["M"] = M pcklme["Mwowonz"] = Mwowonz if Mwowonz > M: # or oo.nzclstr == True pcklme["smp_nz_l0"] = smp_nz_l0 pcklme["smp_nz_hyps"]= smp_nz_hyps dmp = open(resFN("posteriors_%d.dmp" % epc, dir=oo.outdir), "wb") pickle.dump(pcklme, dmp, -1) dmp.close()