def save(self): oo = self print _edd.resFN("alltetmarks.pkl", dir="%(a)s0%(d)d0%(e)d" % {"a" : oo.anim, "d" : oo.day, "e" : oo.ep}) dmp = open(_edd.resFN("alltetmarks.pkl", dir="%(a)s0%(d)d0%(e)d" % {"a" : oo.anim, "d" : oo.day, "e" : oo.ep}, create=True), "wb") _pkl.dump(oo, dmp, -1) dmp.close()
def justOneTet(fn, stet): with open(fn, "rb") as f: lm = _pkl.load(f) f.close() ind = lm.tetlist.index(stet) lm.tetlist = [stet] mks = _N.array(lm.marks[:, ind]) mks = mks.reshape(mks.shape[0], 1) lm.marks = mks dmp = open(_edd.resFN("tetmarks_%s.pkl" % stet, dir="bond0402", create=True), "wb") _pkl.dump(lm, dmp, -1) dmp.close()
def cmpGTtoFIT(basefn, datfn, itvfn, M, epc, xticks=None, yticks=None): dmp = open(_ed.resFN("posteriors.dump", dir=basefn), "rb") gt = _N.loadtxt(_ed.datFN("%s_prms.dat" % datfn)) _intvs = _N.loadtxt(_ed.datFN("%s.dat" % itvfn)) intvs = _N.array(gt.shape[0] * _intvs, dtype=_N.int) pckl = pickle.load(dmp) dmp.close() N = 300 x = _N.linspace(0, 3, N) smpls = pckl["cp%d" % epc] mds = pckl["md"] l0s = smpls[0] # GIBBS ITER x M fs = smpls[1] q2s = smpls[2] frm = 200 Nsmp = l0s.shape[0] - frm SMPS = 1000 rfsmps= _N.empty((SMPS, N, M)) # samples rs = _N.random.rand(SMPS, 3, M) for m in xrange(M): for ss in xrange(SMPS): i_l0 = int((Nsmp-frm)*rs[ss, 0, m]) # one of the iters i_f = int((Nsmp-frm)*rs[ss, 1, m]) i_q2 = int((Nsmp-frm)*rs[ss, 2, m]) l0 = l0s[frm+i_l0, m] f = fs[frm+i_f, m] q2 = q2s[frm+i_q2, m] rfsmps[ss, :, m] = (l0 / _N.sqrt(2*_N.pi*q2)) * _N.exp(-0.5*(x - f)*(x-f)/q2) #_plt.plot(x, rfsmps[ss], color="black") Arfsmps = _N.sum(rfsmps, axis=2) srtd = _N.sort(Arfsmps, axis=0) fig = _plt.figure(figsize=(5, 4)) ax = fig.add_subplot(1, 1, 1) #_plt.fill_between(x, srtd[50, :], srtd[950, :], alpha=0.3) _plt.fill_between(x, srtd[50, :], srtd[950, :], color="#CCCCFF") fr_s = _N.zeros(N) fr_e = _N.zeros(N) Mgt = gt.shape[1]/3 print Mgt for m in xrange(Mgt): l0_s = gt[intvs[epc], 2+3*m] l0_e = gt[intvs[epc+1]-1, 2+3*m] f_s = gt[intvs[epc], 3*m] f_e = gt[intvs[epc+1]-1, 3*m] q2_s = gt[intvs[epc], 1+3*m] q2_e = gt[intvs[epc+1]-1, 1+3*m] fr_s += (l0_s / _N.sqrt(2*_N.pi*q2_s)) * _N.exp(-0.5*(x - f_s)*(x-f_s)/q2_s) fr_e += (l0_e / _N.sqrt(2*_N.pi*q2_e)) * _N.exp(-0.5*(x - f_e)*(x-f_e)/q2_e) _plt.plot(x, 0.5*(fr_s+fr_e), lw=3, color="black") fr_m = _N.zeros(N) for m in xrange(M): l0_m = mds[epc, 3*m] f_m = mds[epc, 1+3*m] q2_m = mds[epc, 2+3*m] fr_m += (l0_m / _N.sqrt(2*_N.pi*q2_m)) * _N.exp(-0.5*(x - f_m)*(x-f_m)/q2_m) _plt.plot(x, fr_m, lw=3, color="blue") mF.setTicksAndLims(xlabel="position", ylabel="Hz", xticks=xticks, yticks=yticks, tickFS=22, labelFS=24) mF.arbitaryAxes(ax, axesVis=[True, True, False, False]) fig.subplots_adjust(left=0.2, bottom=0.2, right=0.95, top=0.95) _plt.savefig(_ed.resFN("cmpGT2FIT%d.eps" % epc, dir=basefn))
def create(self, setname, pos=None, thresh=-1000000): # time series to model ratio of the states oo = self k = oo.k N = oo.N # length of observation M = oo.M # # of cells oo.uP = _N.empty((M, N)) # oo.stdP = _N.empty((M, N)) # oo.um = _N.empty((M, N, k)) # oo.Cov = _N.empty((M, k, k)) oo.neurIDs= _N.zeros((N, M), dtype=_N.int) #oo.neurIDsf= _N.empty((N, M)) oo.dt = 0.001 if oo.stdPMags is None: oo.stdPMags = _N.ones(M)*0.1 oo.alp = _N.empty((M, N)) mr = _N.random.rand(N) if oo.bWtrack: oo.pos = _U.generateMvt(N, vAmp=oo.vAmp, constV=oo.constV, pLR=oo.pLR, nLf=oo.nLf, nRh=oo.nRh) else: oo._pos = _N.empty(N) oo.pos = _N.empty(N) oo._pos[0] = 0.3*_N.random.randn() for n in xrange(N-1): oo._pos[n+1] = 0.9995*oo._pos[n] + 0.04*_N.random.randn() oo.pos[:] = oo._pos[:]#_N.convolve(oo._pos, gk, mode="same") oo.mvpos = oo.pos Ns = N/50 _ts = _N.linspace(0, N, Ns, endpoint=False) ts = _N.linspace(0, N, N, endpoint=False) # First generate # step update is 50ms. #gk = gauKer(2) #gk /= _N.sum(gk) #oo.pos[:] = _N.interp(ts, _ts, oo._pos) Ns = N/1000 _ts = _N.linspace(0, N, Ns, endpoint=False) oo._uP = _N.empty((M, Ns)) # oo._um = _N.empty((M, Ns, oo.k)) # oo._stdP = _N.empty((M, Ns)) # oo._alp = _N.empty((M, Ns)) # ######### Initial conditions if oo.uP0 is not None: # M x Npf matrix oo._uP[:, 0] = 0 else: oo._uP[:, 0] = _N.random.randn(M) if oo.alp0 is not None: # M x Npf matrix oo._alp[:, 0] = oo.alp0 else: oo._alp[:, 0] = _N.random.randn(M) if oo.um0 is not None: # M x k matrix oo._um[:, 0, :] = 0 else: oo._um[:, 0] = _N.random.randn(oo.k)*oo.md ###### BUILD latent place field centers and mark centers for m in xrange(M): for ik in xrange(k): oo.Cov[m, ik, ik] = oo.min_var + (oo.max_var - oo.min_var)*_N.random.rand() for ik1 in xrange(k): for ik2 in xrange(ik1 + 1, k): # set up cov. matrices oo.Cov[m, ik1, ik2] = 0.4*(0.6+0.4*_N.abs(_N.random.rand()))*_N.sqrt(oo.Cov[m, ik1, ik1]*oo.Cov[m, ik2, ik2]) oo.Cov[m, ik2, ik1] = oo.Cov[m, ik1, ik2] oo._stdP[:, 0] = 0.1*_N.random.randn() for n in xrange(Ns-1): # slow changes for m in xrange(M): for ik in xrange(k): oo._um[m, n+1, ik] = oo.Fm*oo._um[m, n, ik] + oo.sivm*_N.random.randn() oo._uP[m, n+1] = oo.Fu*oo._uP[m, n] + oo.sivu*_N.random.randn() oo._stdP[m, n+1] = oo.Fstd*oo._stdP[m, n] + oo.sivs*_N.random.randn() oo._alp[m, n+1] = oo.Falp*oo._alp[m, n] + oo.siva*_N.random.randn() oo._uP[:, :] += oo.uP0.reshape((M, 1)) oo._um[:, :, :] += oo.um0.reshape((M, 1, k)) for m in xrange(M): for ik in xrange(k): oo.um[m, :, ik] = _N.interp(ts, _ts, oo._um[m, :, ik]) oo.uP[m] = _N.interp(ts, _ts, oo._uP[m]) oo.stdP[m] = _N.interp(ts, _ts, _N.abs(oo._stdP[m])) + oo.stdPMags[m] oo.alp[m] = _N.log(_N.interp(ts, _ts, _N.abs(oo._alp[m]))) ###### now create spikes oo.marksH = _N.empty((oo.N, 1), dtype=list) oo.marksNH = _N.empty((oo.N, 1), dtype=list) nspks = 0 cut = 0 for m in xrange(M):# For each cluster if m < oo.Mh_strt: marks = oo.marksNH else: marks = oo.marksH mkid = oo.markIDs[m] # for the mark fr = _N.zeros(oo.N) wdP = 2*oo.stdP[m]**2 fr[:] += _N.exp(oo.alp[m] - (oo.pos - oo.uP[m])**2 / wdP) rands = _N.random.rand(oo.N) thrX = _N.where(rands < fr*oo.dt)[0] #oo.neurIDsf[:, m] = fr oo.neurIDs[thrX, m] = 1 for n in xrange(len(thrX)): # iterate over time tm = thrX[n] mk = mvn(oo.um[mkid, tm], oo.Cov[mkid], size=1)[0] if (_N.sum(mk < thresh) == oo.k): oo.neurIDs[thrX[n], m] = 0 cut += 1 else: if marks[tm, 0] is None: # separate hash, non-hash marks[tm, 0] = [mk] else: marks[tm, 0].append(mk) nspks += 1 #kde = _kde.kde(setname) #oo.marks = None #kde.est(oo.pos, oo.marks, oo.k, oo.xA, oo.mA, oo.Nx, oo.Nm, oo.Bx, oo.Bm, oo.bx, t0=t0, t1=t1, filename="kde.dump") print "tot spikes created %(n)d cut %(c)d" % {"n" : nspks, "c" : cut} dmp = open(_edd.resFN("marks.pkl", dir=setname, create=True), "wb") pickle.dump(oo, dmp, -1) dmp.close()
scyMax = _N.max(r[nzinds, 2]) + scyAmp * 0.05 seg_ts = a[0, 0].T[0] seg1 = _N.where(seg_ts == 1) seg2 = _N.where(seg_ts == 2) seg3 = _N.where(seg_ts == 3) seg4 = _N.where(seg_ts == 4) seg5 = _N.where(seg_ts == 5) time = mLp["linpos"][0, ex][0, ep]["statematrix"][0][0]["time"][0, 0].T[0] lindist = mLp["linpos"][0, ex][0, ep]["statematrix"][0][0]["lindist"][0, 0].T[0] ### quick show zrrp = _N.where((r[:, 1] > 0) & (r[:, 2] > 0) & (r[:, 3] > 0) & (r[:, 4] > 0))[0] _plt.scatter(r[zrrp, 1], r[zrrp, 2], color="black") _plt.savefig(_edd.resFN("rawpos.png", dir="%(a)s%(sd)s0%(e)d" % {"a": anim2, "sd": sdy, "e": ep + 1}, create=True)) _plt.close() _plt.plot(lindist, color="black") _plt.savefig(_edd.resFN("lindist.png", dir="%(a)s%(sd)s0%(e)d" % {"a": anim2, "sd": sdy, "e": ep + 1})) _plt.close() # _plt.plot(time[seg1[0]], lindist[seg1[0]], ls="", marker=".") # _plt.plot(time[seg4[0]], lindist[seg4[0]], ls="", marker=".") # _plt.plot(time[seg5[0]], lindist[seg5[0]], ls="", marker=".") # _plt.plot(time[seg2[0]], -1*lindist[seg2[0]], ls="", marker=".") # _plt.plot(time[seg3[0]], -1*lindist[seg3[0]], ls="", marker=".") # 1 3 5 we're there long enough
def est(self, ispks, xtr, mdim, markstr, xA, mA, Ntr, Nx, Nm, Bx, cBm, bx, t0=None, t1=None, filename="kde.dump"): oo = self oo.xA = xA; oo.mA = mA oo.Nx = Nx; oo.Nm = Nm oo.Bx = Bx; oo.cBm = cBm oo.bx = bx oo.Ntr= Ntr print "t0 %(0)d t1 %(1)d" % {"0" : t0, "1" : t1} if (t0 is not None) and (t1 is not None): oo.Ntr = t1-t0 else: t0 = 0 t1 = oo.Ntr isqrt2pi = 1/_N.sqrt(2*_N.pi) nard = [oo.Nx] for d in xrange(mdim): nard.append(oo.Nm) oo.kde = _N.zeros(nard) oo.kde = oo.kde.reshape(oo.Nx, Nm**mdim) print "kde.shape" print oo.kde.shape iBx = 1./Bx xR = _N.linspace(-xA, xA, Nx).reshape(Nx, 1) mR = _N.linspace(0, mA, Nm) mkpts = Nm**mdim # # grid pts on which to compute KDE args = [] for d in xrange(mdim): args.append(mR) mk_grid = _N.array(_N.meshgrid(*args, indexing="ij")) mk_grid = mk_grid.reshape(mdim, mkpts).T mk_grid = mk_grid.reshape(1, mdim*mkpts) #isnone = _N.equal(markstr, None) print ispks iB2 = 1/(cBm*cBm) for ui in ispks: # iterate over time, training mklst = markstr[ui] for mk in mklst[1:]: # sum over spikes # output this onto a Nx x Nm for each spike. # Here oo.kde is a vector # Explicit sum over marks # Either I need a #print mk mk_tile = _N.tile(mk, mkpts) mk_tile = mk_tile.reshape(1, mkpts*mdim) #print mk_grid.shape #print mk_tile.shape #print (xR - xtr[ui]).shape mprt = _N.multiply(mk_grid - mk_tile, mk_grid - mk_tile) mprt = mprt.reshape(mkpts, mdim) mprt = _N.sum(mprt, axis=1) mprt = mprt.reshape(1, mkpts) #print mprt.shape # components of mark consecutive. we want to sum every 3 # xprt = (xR - xtr[ui])**2 #print xprt.shape #print (mprt + xprt).shape oo.kde += _N.exp(-0.5*((xR - xtr[ui])*iBx)**2 - 0.5 * mprt*iB2) # oo.kde *= (isqrt2pi * isqrt2pi)*(1./oo.N)*(1./Bx)*(1./Bm) # x(t) - x_j # lambda(x, m) # K is a function of x(t) # denom is also a function of x(t) """ denom = _N.zeros(oo.Nx) for n in xrange(oo.N): denom += _N.exp(-0.5*((xR - oo.xtr[n])*(xR - oo.xtr[n]))/bx) """ ### func of x times func of m. lives on a grid #xR = xR.reshape(Nx, 1) xtr = xtr.reshape(1, Ntr) denom = _N.sum(_N.exp(-0.5*((xR - xtr)/bx)**2), axis=1) denom *= isqrt2pi*(1./bx) denom = denom.reshape(Nx, 1) print oo.kde.shape oo.kde /= denom dmp = open(_edd.resFN(filename, dir=oo.setname, create=True), "wb") pickle.dump(oo, dmp) dmp.close()
def create(self, setname, pos=None): # time series to model ratio of the states oo = self k = oo.k N = oo.N # length of observation M = oo.M Npf = oo.Npf # number of place fields per neuron oo.uP = _N.empty((M, Npf, N)) # oo.stdP = _N.empty((M, Npf, N)) # oo.um = _N.empty((M, N, k)) # oo.Cov = _N.empty((M, k, k)) oo.neurIDs = _N.zeros((N, M), dtype=_N.int) # oo.neurIDsf= _N.empty((N, M)) oo.dt = 0.001 if oo.stdPMags is None: oo.stdPMags = _N.ones(M * Npf) * 0.1 oo.alp = _N.empty((M, Npf, N)) mr = _N.random.rand(N) if oo.bWtrack: oo.pos = _U.generateMvt(N, vAmp=oo.vAmp, constV=oo.constV) else: oo._pos = _N.empty(N) oo.pos = _N.empty(N) oo._pos[0] = 0.3 * _N.random.randn() for n in xrange(N - 1): oo._pos[n + 1] = 0.9995 * oo._pos[n] + 0.04 * _N.random.randn() oo.pos[:] = oo._pos[:] # _N.convolve(oo._pos, gk, mode="same") oo.mvpos = oo.pos Ns = N / 50 _ts = _N.linspace(0, N, Ns, endpoint=False) ts = _N.linspace(0, N, N, endpoint=False) # First generate # step update is 50ms. # gk = gauKer(2) # gk /= _N.sum(gk) # oo.pos[:] = _N.interp(ts, _ts, oo._pos) Ns = N / 1000 _ts = _N.linspace(0, N, Ns, endpoint=False) oo._uP = _N.empty((M, Npf, Ns)) # oo._um = _N.empty((M, Ns, oo.k)) # oo._stdP = _N.empty((M, Npf, Ns)) # oo._alp = _N.empty((M, Npf, Ns)) # oo._pfdst = _N.empty((M, Npf - 1, Ns)) # distance between place flds ######### Initial conditions if oo.uP0 is not None: # M x Npf matrix oo._uP[:, :, 0] = 0 else: oo._uP[:, :, 0] = _N.random.randn(M, Npf) if oo.alp0 is not None: # M x Npf matrix oo._alp[:, :, 0] = oo.alp0 else: oo._alp[:, :, 0] = _N.random.randn(M, Npf) if oo.um0 is not None: # M x k matrix oo._um[:, 0, :] = 0 else: oo._um[:, 0] = _N.random.randn(oo.k) * oo.md ###### BUILD latent place field centers and mark centers for m in xrange(M): for ik in xrange(k): oo.Cov[m, ik, ik] = oo.min_var + (oo.max_var - oo.min_var) * _N.random.rand() for ik1 in xrange(k): for ik2 in xrange(ik1 + 1, k): # set up cov. matrices oo.Cov[m, ik1, ik2] = 0.04 * (0.1 + _N.abs(_N.random.randn())) oo.Cov[m, ik2, ik1] = oo.Cov[m, ik1, ik2] ## place field set up for np in xrange(1, Npf): mlt = 1 if _N.random.rand() < 0.5 else -1 oo._uP[m, np] = oo._uP[m, np - 1] - mlt * (1 + 0.3 * _N.random.rand()) oo._stdP[:, :, 0] = 0.1 * _N.random.randn() for n in xrange(Ns - 1): # slow changes for m in xrange(M): for ik in xrange(k): oo._um[m, n + 1, ik] = oo.Fm * oo._um[m, n, ik] + oo.sivm * _N.random.randn() for mpf in xrange(Npf): oo._uP[m, mpf, n + 1] = oo.Fu * oo._uP[m, mpf, n] + oo.sivu * _N.random.randn() oo._stdP[m, mpf, n + 1] = oo.Fstd * oo._stdP[m, mpf, n] + oo.sivs * _N.random.randn() oo._alp[m, mpf, n + 1] = oo.Falp * oo._alp[m, mpf, n] + oo.siva * _N.random.randn() oo._uP[:, :, :] += oo.uP0.reshape((M, Npf, 1)) # oo._um[:, :, :] += oo.um0.reshape((M, 1, 1)) oo._um[:, :, :] += oo.um0.reshape((M, 1, k)) for m in xrange(M): for ik in xrange(k): oo.um[m, :, ik] = _N.interp(ts, _ts, oo._um[m, :, ik]) for mpf in xrange(Npf): oo.uP[m, mpf] = _N.interp(ts, _ts, oo._uP[m, mpf]) oo.stdP[m, mpf] = _N.interp(ts, _ts, _N.abs(oo._stdP[m, mpf])) + oo.stdPMags[m, mpf] oo.alp[m, mpf] = _N.log(_N.interp(ts, _ts, _N.abs(oo._alp[m, mpf]))) ###### now create spikes oo.marks = _N.empty((oo.N, 1), dtype=list) nspks = 0 for m in xrange(M): # For each cluster fr = _N.zeros(oo.N) for mpf in xrange(Npf): wdP = 2 * oo.stdP[m, mpf] ** 2 fr[:] += _N.exp(oo.alp[m, mpf] - (oo.pos - oo.uP[m, mpf]) ** 2 / wdP) rands = _N.random.rand(oo.N) thrX = _N.where(rands < fr * oo.dt)[0] # oo.neurIDsf[:, m] = fr oo.neurIDs[thrX, m] = 1 for n in xrange(len(thrX)): # iterate over time tm = thrX[n] mk = mvn(oo.um[m, tm], oo.Cov[m], size=1)[0] if oo.marks[tm, 0] is None: oo.marks[tm, 0] = [mk] else: oo.marks[tm, 0].append(mk) nspks += 1 # kde = _kde.kde(setname) # oo.marks = None # kde.est(oo.pos, oo.marks, oo.k, oo.xA, oo.mA, oo.Nx, oo.Nm, oo.Bx, oo.Bm, oo.bx, t0=t0, t1=t1, filename="kde.dump") print "total spikes created %d" % nspks dmp = open(_edd.resFN("marks.pkl", dir=setname, create=True), "wb") pickle.dump(oo, dmp, -1) dmp.close()
def create(self, setname, xc=None): t1 = _tm.time() isqrt2pi = 1/_N.sqrt(2*_N.pi) oo = self oo.setname = setname oo.x = _N.empty(oo.N) oo.xtr = _N.empty(oo.Ntr) ### training data oo.xtr[0]= _N.random.randn()*0.3 rd = oo.sd*_N.random.randn(oo.Ntr) for n in xrange(1, oo.Ntr): oo.xtr[n] = oo.a*oo.xtr[n-1] + rd[n] ### behavioral data if xc is None: oo.x[0]= _N.random.randn()*0.3 rd = oo.sd*_N.random.randn(oo.N) for n in xrange(1, oo.N): oo.x[n] = oo.a*oo.x[n-1] + rd[n] else: oo.x[:] = xc qdx = _N.empty((oo.Nc, oo.Nx)) # 4 mark vectors # ([m11, m12, m13], [m21, m22, m23], [m31, m32, m33], [m41, m42, m43]) # B is I . B^2, B scalara M- cnard = [oo.Nc, oo.Nx] nard = [oo.Nx] for d in xrange(oo.mdim): nard.append(oo.Nm) cnard.append(oo.Nm**oo.mdim) qdm = _N.empty((oo.Nc, oo.Nm**oo.mdim)) oo.lmd = _N.zeros(nard) # nard=(Nx, Nm, Nm, Nm...) lmdC = _N.zeros(cnard) # nard=(Nx, Nm, Nm, Nm...). lmd for each cell xR = _N.linspace(-oo.xA, oo.xA, oo.Nx) mR = _N.linspace(0, oo.mA, oo.Nm) oo.zrspksx = [] mkpts = oo.Nm**oo.mdim args = [] for d in xrange(oo.mdim): args.append(mR) # # pts of mesh x mark dim is size of axyz axyz = _N.array(_N.meshgrid(*args, indexing="ij")) axyz = axyz.reshape(oo.mdim, mkpts).T oo.lmd = oo.lmd.reshape((oo.Nx, mkpts)) qdm = _N.empty((oo.Nc, mkpts)) for nc in xrange(oo.Nc): # cell identity wdx = 2*oo.wx[nc]**2 qdx[nc] = (xR - oo.ux[nc])**2 / wdx for n in xrange(mkpts): # sample domain of the marks qdm[nc, n] = _N.dot(axyz[n]-oo.um[nc], _N.dot(oo.iCMm[nc], axyz[n]-oo.um[nc])) t2 = _tm.time() m = _N.empty(oo.mdim) for nc in xrange(oo.Nc): for ix in xrange(oo.Nx): #qdm[nc, ...] lmdC[nc, ix] = _N.exp(oo.alp[nc] - qdx[nc, ix] - qdm[nc]) _N.sum(lmdC, axis=0, out=oo.lmd) # sum over Nc neurons oo.lmd = oo.lmd.reshape(nard) t3 = _tm.time() ### now create spikes marks = _N.empty(oo.N, dtype=list) markstr = _N.empty(oo.Ntr, dtype=list) for nc in xrange(oo.Nc): wdx = 2*oo.wx[nc]**2 fr = _N.exp(oo.alp[nc] - (oo.x - oo.ux[nc])**2 / wdx) frtr = _N.exp(oo.alp[nc] - (oo.xtr - oo.ux[nc])**2 / wdx) rands = _N.random.rand(oo.N) randstr = _N.random.rand(oo.Ntr) thrX = _N.where(rands < fr*oo.dt)[0] thrXtr = _N.where(randstr < frtr*oo.dt)[0] mk = _N.random.multivariate_normal(oo.um[nc], oo.CMm[nc], size=len(thrX)) mktr = _N.random.multivariate_normal(oo.um[nc], oo.CMm[nc], size=len(thrXtr)) for n in xrange(len(thrX)): # iterate over time tm = thrX[n] if marks[tm] is None: marks[tm] = [tm, mk[n]] else: marks[tm].append(mk[n]) for n in xrange(len(thrXtr)): # iterate over time tm = thrXtr[n] if markstr[tm] is None: markstr[tm] = [tm, mktr[n]] else: markstr[tm].append(mktr[n]) oo.marks = [] oo.markstr = [] for n in xrange(oo.N): if marks[n] is not None: oo.marks.append(marks[n]) for n in xrange(oo.Ntr): if markstr[n] is not None: # spike here oo.markstr.append(markstr[n]) else: oo.zrspksx.append(oo.xtr[n]) # oo.kde1 = _kde.kde(setname) # oo.kde1.est(oo.xtr, oo.mdim, markstr, oo.xA, oo.mA, oo.Ntr, oo.Nx, oo.Nm, oo.Bx, oo.cBm, oo.bx, t0=0, t1=10000, filename="kde1.dump") # oo.kde2 = _kde.kde(setname) # oo.kde2.est(oo.xtr, oo.mdim, markstr, oo.xA, oo.mA, oo.Ntr, oo.Nx, oo.Nm, oo.Bx, oo.cBm, oo.bx, t0=5000, t1=10000, filename="kde2.dump") dmp = open(_edd.resFN("marks.dump", dir=oo.setname, create=True), "wb") pickle.dump(oo, dmp) dmp.close()