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 btwnfigs(anim, day, ep, t0, t1, someplt1, label1, lims1, someplt2, label2, lims2, someplt3, label3, lims3, r, x, y, scxMin, scxMax, scyMin, scyMax):
print "btwnfigs %(ep)d %(1)d %(2)d" % {"ep" : ep, "1" : t0, "2" : t1}
fig = _plt.figure(figsize=(13, 10))
fig.add_subplot(2, 2, 1)
_plt.scatter(r[::10, x], r[::10, y], s=5, color="grey")
_plt.scatter(r[t0:t1:2, x], r[t0:t1:2, y], s=9, color="black")
_plt.plot(r[t0, x], r[t0, y], ms=40, color="blue", marker=".")
_plt.plot(r[t1, x], r[t1, y], ms=40, color="red", marker=".")
_plt.xlim(scxMin, scxMax)
_plt.ylim(scyMin, scyMax)
fig.add_subplot(2, 2, 2)
_plt.plot(range(t0, t1), someplt1[t0:t1], color="black", lw=4)
_plt.xlim(t0, t1)
_plt.xticks(_N.arange(t0, t1, (t1-t0)/5))
_plt.ylabel(label1)
_plt.ylim(lims1[0], lims1[1])
_plt.grid()
fig.add_subplot(2, 2, 3)
_plt.plot(range(t0, t1), someplt2[t0:t1], color="black", lw=4)
_plt.xlim(t0, t1)
_plt.ylim(lims2[0], lims2[1])
_plt.ylabel(label2)
_plt.xticks(_N.arange(t0, t1, (t1-t0)/5))
_plt.grid()
fig.add_subplot(2, 2, 4)
_plt.plot(range(t0, t1), someplt3[t0:t1], color="black", lw=4)
_plt.xlim(t0, t1)
_plt.ylim(lims3[0], lims3[1])
_plt.ylabel(label3)
_plt.xticks(_N.arange(t0, t1, (t1-t0)/5))
_plt.grid()
fig.subplots_adjust(left=0.1, bottom=0.1, top=0.95, right=0.99)
sday = ("0%d" % day) if (day < 10) else ("%d" % day)
#print _edd.datFN("btwn_%(dy)d%(ep)d_%(1)d_%(2)d" % {"dy" : day, "ep" : (ep+1), "1" : t0, "2" : t1}, create=True)
#_edd.datFN("lindist.dat", dir="linearize/%(an)s%(dy)s0%(ep)d" % {"dy" : sday, "ep" : (ep+1), "an" : anim2}, create=True)
_plt.savefig(_edd.datFN("btwn_%(dy)d%(ep)d_%(1)d_%(2)d" % {"dy" : day, "ep" : (ep+1), "1" : t0, "2" : t1}, dir="linearize/%(an)s%(dy)s0%(ep)d" % {"dy" : sday, "ep" : (ep+1), "an" : anim2}, create=True))
#_plt.savefig("btwn_%(an)s%(dy)d%(ep)d_%(1)d_%(2)d" % {"dy" : day, "ep" : (ep+1), "1" : t0, "2" : t1, "an" : anim})
_plt.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))
for epc in range(4, 5):
ep=epc+1;
_pts=mLp["linpos"][0,ex][0,ep]
if (_pts.shape[1] > 0): # might be empty epoch
pts = _pts["statematrix"][0][0]["time"][0,0].T[0]
a = mLp["linpos"][0,ex][0,ep]["statematrix"][0,0]["segmentIndex"]
r = mRp["rawpos"][0,ex][0,ep]["data"][0,0]
fillin_unobsvd(r)
scxMin, scxMax, scyMin, scyMax = get_boundaries(r)
sday = ("0%d" % day) if (day < 10) else ("%d" % day)
fn = _edd.datFN("cp_lr.dat", dir="linearize/%(an)s%(dy)s0%(ep)d" % {"dy" : sday, "ep" : (ep+1), "an" : anim2})
cp_lr = _N.loadtxt(fn, dtype=_N.int)
fn = _edd.datFN("cp_inout.dat", dir="linearize/%(an)s%(dy)s0%(ep)d" % {"dy" : sday, "ep" : (ep+1), "an" : anim2})
cp_inout = _N.loadtxt(fn, dtype=_N.int)
lr, inout = thaw_LR_inout(27901, cp_lr, cp_inout)
fn = _edd.datFN("lindist.dat", dir="linearize/%(an)s%(dy)s0%(ep)d" % {"dy" : sday, "ep" : (ep+1), "an" : anim2})
lindist = _N.loadtxt(fn)
N = len(lindist)
lin_lr_inout = _N.empty(N)
build_lin_lr_inout(N, lin_lr_inout, lindist, lr, inout, gkRWD)
t0 = 0
winsz = 1000
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
"sds": sds_to_use,
"rmc": sRMC
}
else:
outdirN = "%(d)s/decGT%(ts)s_%(lf)d/%(Nx)d_smpsPsd=%(spsd).1f_sds2use=%(sds).1f%(rmc)s" % {
"d": outdir,
"ts": tetstr,
"lf": lagfit,
"Nx": Nx,
"spsd": smpsPerSD,
"sds": sds_to_use,
"rmc": sRMC
}
#if not os.access(outdir, os.F_OK):
_edd.recurseMkdir(outdirN)
#os.mkdir(outdir)
#if not os.access(outdirN, os.F_OK):
# os.mkdir(outdirN)
shutil.copyfile("GoF.py", "%s/GoF.py" % outdirN)
#0, 4, 6, 9, 14
dd = os.getenv("__EnDeDataDir__")
_dat = _N.loadtxt("%(dd)s/%(dfn)s.dat" % {
"dd": dd,
"dfn": datfn
}) # DATA/anim_mdec_dyep_tet.dat
dat = _dat[:, 0:2 + K]
intvs = _N.array(_N.loadtxt("%(dd)s/%(iv)s.dat" % {
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 done():
"""
come here after 6 landmarks chosen
"""
global r, seg_ts, segs, Nsgs, inout, a_inout, lindist, lin_lr, lin_inout, lin_lr_inout, lr, raw_lindist
global scxMin, scxMax, scyMin, scyMax
global an, day, ep
hdir = _N.empty(2)
vdir = _N.empty(2)
linp = _N.empty(2)
"""
L5 L0 L3
|| || ||
|| || ||
5 1 3
|| || ||
|| || ||
L4===4===L1===2===L2
"""
scxMin, scxMax, scyMin, scyMax = get_boundaries(r)
segs_from_landmarks(segs, landmarks, length)
e = inout_dir(segs, Nsgs)
a_s, b_s, c_s = slopes_of_segs(segs)
_plt.plot([segs[0, 0, 0], segs[0, 1, 0]], [segs[0, 0, 1], segs[0, 1, 1]],
lw=3,
color="black")
_plt.plot([segs[1, 0, 0], segs[1, 1, 0]], [segs[1, 0, 1], segs[1, 1, 1]],
lw=3,
color="black")
_plt.plot([segs[2, 0, 0], segs[2, 1, 0]], [segs[2, 0, 1], segs[2, 1, 1]],
lw=3,
color="black")
_plt.plot([segs[3, 0, 0], segs[3, 1, 0]], [segs[3, 0, 1], segs[3, 1, 1]],
lw=3,
color="black")
_plt.plot([segs[4, 0, 0], segs[4, 1, 0]], [segs[4, 0, 1], segs[4, 1, 1]],
lw=3,
color="black")
segsr = segs.reshape((10, 2))
clrs = ["blue", "orange", "red", "green", "yellow", "black", "brown"]
fillin_unobsvd(r)
N = r.shape[0]
seg_ts = _N.empty(N, dtype=_N.int)
lindist = _N.empty(N)
lin_lr = _N.empty(N)
lin_inout = _N.empty(N)
lin_lr_inout = _N.empty(N)
lr = _N.ones(N, dtype=_N.int) * -3
inout = _N.empty(N, dtype=_N.int)
a_inout = _N.empty(N)
gk = gauKer(30)
gk /= _N.sum(gk)
fx = _N.convolve(0.5 * (r[:, 1] + r[:, 3]), gk, mode="same")
fy = _N.convolve(0.5 * (r[:, 2] + r[:, 4]), gk, mode="same")
xp = fx
yp = fy
xpyp = _N.empty((N, 2))
xpyp[:, 0] = xp
xpyp[:, 1] = yp
_xpyp = _N.repeat(xpyp, Nsgs * 2, axis=0)
rxpyp = _xpyp.reshape((N, Nsgs * 2, 2))
dv = segsr - rxpyp
dists = _N.sum(dv * dv, axis=2) # closest point on maze from field points
rdists = dists.reshape((N, Nsgs, 2))
print rdists.shape
online = _N.empty(Nsgs, dtype=bool)
mins = _N.empty(Nsgs)
for n in xrange(N):
x0 = xpyp[n, 0]
y0 = xpyp[n, 1]
# xcs, ycs: pt on all line segs closest to x0, y0 (may b byond endpts)
xcs = (b_s *
(b_s * x0 - a_s * y0) - a_s * c_s) / (a_s * a_s + b_s * b_s)
ycs = (-a_s *
(b_s * x0 - a_s * y0) - b_s * c_s) / (a_s * a_s + b_s * b_s)
find_clsest(n, x0, y0, segs, rdists, seg_ts, Nsgs, online, offset, xcs,
ycs, mins, linp)
# fig = _plt.figure()
# _plt.plot(seg_ts)
# clean_seg_ts(seg_ts)
# _plt.plot(seg_ts)
raw_lindist = _N.zeros(N)
lindist_x0y0(N, xpyp, segs, rdists, seg_ts, Nsgs, online, offset, a_s, b_s,
c_s, mins, linp, raw_lindist)
smooth_lindist(raw_lindist, lindist)
# fig = _plt.figure(figsize=(10, 4))
# _plt.plot(lindist)
# gk = gauKer(8) # don't want to make this too large. if we just pass through the choice point, we can miss it.
# gk /= _N.sum(gk)
# flindist = _N.convolve(lindist, gk, mode="same")
# lindist = flindist
# rm_lindist_jumps(N, lindist, seg_ts)
fig = _plt.figure(figsize=(10, 4))
_plt.plot(lindist)
spd_thr = 0.35
a_inout_x0y0(N, a_inout, inout, r, seg_ts, spd_thr, e)
#_plt.plot([x0, x0], [y0, y0], ms=10, marker=".", color=clr)
make_lin_inout(N, lindist, inout, lin_inout)
make_lin_lr(N, lr, lindist, seg_ts, r)
build_lin_lr_inout(N, lin_lr_inout, lindist, lr, inout, gkRWD)
# inout
cp_lr, cp_inout = cpify_LR_inout(lr, inout)
sday = ("0%d" % day) if (day < 10) else ("%d" % day)
fn = _edd.datFN("lindist.dat",
dir="linearize/%(an)s%(dy)s0%(ep)d" % {
"dy": sday,
"ep": (ep + 1),
"an": anim2
},
create=True)
_N.savetxt(fn, lindist, fmt="%.3f")
fn = _edd.datFN("cp_lr.dat",
dir="linearize/%(an)s%(dy)s0%(ep)d" % {
"dy": sday,
"ep": (ep + 1),
"an": anim2
})
_U.savetxtWCom(
fn,
cp_lr,
fmt="%d %d",
com=
("# N=%d. 1st column time, 2nd column - inout value from this time until time in next row"
% N))
fn = _edd.datFN("cp_inout.dat",
dir="linearize/%(an)s%(dy)s0%(ep)d" % {
"dy": sday,
"ep": (ep + 1),
"an": anim2
})
_U.savetxtWCom(
fn,
cp_inout,
fmt="%d %d",
com=
("# N=%d. 1st column time, 2nd column - inout value from this time until time in next row"
% N))
fn = _edd.datFN("lin_lr_inout.dat",
dir="linearize/%(an)s%(dy)s0%(ep)d" % {
"dy": sday,
"ep": (ep + 1),
"an": anim2
})
_N.savetxt(fn, lin_lr_inout, fmt="%.3f")
"""
"""
t0 = 0
winsz = 1000
t1 = 0
iw = -1
while t1 < N:
iw += 1
t0 = iw * winsz
t1 = (iw + 1) * winsz if (iw + 1) * winsz < N else N - 1
#btwnfigs(anim2, day, ep, t0, t1, inout, [-1.1, 1.1], seg_ts+1, [0.9, 5.1], r, 1, 2, scxMin, scxMax, scyMin, scyMax)
btwnfigs(anim2, day, ep, t0, t1, inout, "INOUT", [-1.1, 1.1], lr, "LR",
[-1.1, 1.1], lin_lr_inout, "lin_lr_inout", [-6.1, 6.1], r, 1,
2, scxMin, scxMax, scyMin, scyMax)
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()
