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()
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()
