def getPhases(_mdn, offset=0):
"""
what is the inferred phase when ground truth phase is 0
"""
TR = _mdn.shape[0]
ph = _N.array(_mdn)
gk = gauKer(2)
gk /= _N.sum(gk)
mdn = _mdn
itr = 0
for tr in xrange(TR):
itr += 1
cv = _N.convolve(mdn[tr] - _N.mean(mdn[tr]), gk, mode="same")
ht_mdn = _ssig.hilbert(cv)
ph[tr] = (_N.arctan2(ht_mdn.imag, ht_mdn.real) + _N.pi) / (2 * _N.pi)
if offset != 0:
ph[tr] += offset
inds = _N.where(ph[tr] >= 1)[0]
ph[tr, inds] -= 1
return ph
def kernel_NGS(dat, SHUF=0, kerwin=3):
_td = _rt.return_hnd_dat(dat)
Tgame= _td.shape[0]
cprobs = _N.zeros((3, 3, Tgame-1))
stay_win, dn_win, up_win, stay_tie, dn_tie, up_tie, stay_los, dn_los, up_los, win_cond, tie_cond, los_cond = _rt.get_ME_WTL(_td, 0, Tgame)
gk = gauKer(kerwin)
gk /= _N.sum(gk)
all_cnd_tr = _N.zeros((3, 3, Tgame-1))
ker_all_cnd_tr = _N.ones((3, 3, Tgame-1))*-100
all_cnd_tr[0, 0, stay_win] = 1
all_cnd_tr[0, 1, dn_win] = 1
all_cnd_tr[0, 2, up_win] = 1
all_cnd_tr[1, 0, stay_tie] = 1
all_cnd_tr[1, 1, dn_tie] = 1
all_cnd_tr[1, 2, up_tie] = 1
all_cnd_tr[2, 0, stay_los] = 1
all_cnd_tr[2, 1, dn_los] = 1
all_cnd_tr[2, 2, up_los] = 1
for iw in range(3):
if iw == 0:
cond = _N.sort(win_cond)
elif iw == 1:
cond = _N.sort(tie_cond)
elif iw == 2:
cond = _N.sort(los_cond)
for it in range(3):
print(all_cnd_tr[iw, it, cond])
ker_all_cnd_tr[iw, it, cond] = _N.convolve(all_cnd_tr[iw, it, cond], gk, mode="same")
for n in range(1, Tgame-1):
if ker_all_cnd_tr[iw, it, n] == -100:
ker_all_cnd_tr[iw, it, n] = ker_all_cnd_tr[iw, it, n-1]
n = 0
while ker_all_cnd_tr[iw, it, n] == -100:
n += 1
ker_all_cnd_tr[iw, it, 0:n] = ker_all_cnd_tr[iw, it, n]
for iw in range(3):
for_cond = _N.sum(ker_all_cnd_tr[iw], axis=0)
for it in range(3):
print(ker_all_cnd_tr[iw, it].shape)
ker_all_cnd_tr[iw, it] /= for_cond
return ker_all_cnd_tr
def initBernoulli(model, k, F0, TR, N, y, fSigMax, smpx, Bsmpx): ############
if model == "bernoulli":
w = 5
wf = gauKer(w)
gk = _N.empty((TR, N + 1))
fgk = _N.empty((TR, N + 1))
for m in xrange(TR):
gk[m] = _N.convolve(y[m], wf, mode="same")
gk[m] = gk[m] - _N.mean(gk[m])
gk[m] /= 5 * _N.std(gk[m])
fgk[m] = bpFilt(15, 100, 1, 135, 500, gk[m]) # we want
fgk[m, :] /= 2 * _N.std(fgk[m, :])
smpx[m, 2:, 0] = fgk[m, :]
for n in xrange(2 + k - 1, N + 1 + 2): # CREATE square smpx
smpx[m, n, 1:] = smpx[m, n - k + 1:n, 0][::-1]
for n in xrange(2 + k - 2, -1, -1): # CREATE square smpx
smpx[m, n, 0:k - 1] = smpx[m, n + 1, 1:k]
smpx[m, n, k - 1] = _N.dot(F0, smpx[m, n:n + k,
k - 2]) # no noise
Bsmpx[m, 0, :] = smpx[m, :, 0]
def getGLMphases(TR, t0, t1, est, X, spkHist, dat, gkW=20, useRefr=True):
params = _N.array(est.params)
stT = spkHist.LHbin * (spkHist.nLHBins + 1
) # first stT spikes used for initial history
ocifs = _N.empty(
(spkHist.endTR - spkHist.startTR, spkHist.t1 - spkHist.t0 - stT))
dt = 0.001
##
sur = "refr"
if not useRefr:
params[spkHist.endTR:spkHist.endTR +
spkHist.LHbin] = params[spkHist.endTR + spkHist.LHbin]
sur = "NOrefr"
for tr in xrange(spkHist.endTR - spkHist.startTR):
ocifs[tr] = _N.exp(_N.dot(X[tr], params)) / dt
gk = _flt.gauKer(gkW)
gk /= _N.sum(gk)
cglmAll = _N.zeros((TR, t1 - t0))
for tr in xrange(spkHist.startTR, TR): # spkHist.statTR usually 0
_gt = dat[stT:, tr * 3]
gt = _N.convolve(_gt, gk, mode="same")
gt /= _N.std(gt)
glm = (ocifs[tr] - _N.mean(ocifs[tr])) / _N.std(ocifs[tr])
cglm = _N.convolve(glm, gk, mode="same")
cglm /= _N.std(cglm)
cglmAll[tr, stT:] = cglm
return stT, cglmAll
def createModEnvelopes(TR,
N,
t0,
t1,
jitterTiming,
jitterLength,
gkW=0,
weak=0.1):
"""
Generate a wave packet. Amplitude envelope is trapezoidal
"""
out = _N.empty((TR, N))
if gkW > 0:
gk = gauKer(gkW)
AM = _N.empty(N)
for tr in xrange(TR):
w = int(((t1 - t0) + jitterLength * _N.random.randn()) / 2.)
m = int(0.5 * (t1 + t0) + jitterTiming * _N.random.randn())
if m - w > 0:
AM[m - w:m + w] = 1
AM[0:m - w] = weak
else:
AM[0:m + w] = 1
AM[m + w:] = weak
if gkW > 0:
out[tr] = _N.convolve(AM, gk, mode="same")
else:
out[tr] = AM
out[tr] /= _N.max(out[tr])
return out
def createOscPacket(f0,
f0VAR,
N,
dt0,
TR,
tM0,
tS0,
tJ=0,
Bf=[0.99],
amp=1,
stdf=None,
stda=None,
sig=0.1,
smoothKer=0):
"""
Generate a wave packet. Amplitude envelope is trapezoidal
"""
out = _N.empty((TR, N))
if stdf == None:
x, y = createDataAR(100000, Bf, sig, sig)
stdf = _N.std(
x) # choice of 4 std devs to keep phase monotonically increasing
trm = 100
dts = _N.empty(N - 1)
t = _N.empty(N)
t[0] = 0
gkC = gauKer(int(tS0 * 0.2)) # slight envelope
if smoothKer > 0:
gk = gauKer(smoothKer)
AM = _N.empty(N)
for tr in xrange(TR):
ph0 = _N.random.rand() * 2 * _N.pi
tM = tM0 + int(tJ * _N.random.randn())
tS = tS0 + int(tJ * _N.random.randn())
bGood = False
while not bGood:
f, dum = createDataAR(N + trm, Bf, sig, sig, trim=trm)
fn = 1 + (f / (3 * stdf)
) # going above 4 stdf very rare. |xn| is almost < 1
if _N.min(fn) > 0:
bGood = True
for i in xrange(1, N):
dt = dt0 * fn[i]
t[i] = t[i - 1] + dt
dts[i - 1] = dt
y = _N.sin(2 * _N.pi * (f0 + f0VAR[tr]) * t + ph0)
t0 = tM - tS if (tM - tS > 0) else 0
t1 = tM + tS if (tM + tS < N) else N
AM[0:t0] = 0.15 + 0.03 * _N.random.randn(t0)
AM[t0:t1] = 1 + 0.2 * _N.random.randn(t1 - t0)
AM[t1:] = 0.15 + 0.03 * _N.random.randn(N - t1)
AMC = _N.convolve(AM, gkC, mode="same")
if smoothKer > 0:
out[tr] = _N.convolve(y * AMC * amp, gk, mode="same")
else:
out[tr] = y * AMC * amp
return out
def _histPhase0_phaseInfrdAll(TR,
N,
x,
_mdn,
t0=None,
t1=None,
bRealDat=False,
trials=None,
fltPrms=None,
maxY=None,
yticks=None,
fn=None,
normed=False,
surrogates=1,
shftPhase=0,
color=None):
"""
what is the inferred phase when ground truth phase is 0
"""
pInfrdAt0 = []
if (fltPrms is not None) and (not bRealDat):
_fx = _N.empty((TR, N))
for tr in xrange(TR):
if len(fltPrms) == 2:
_fx[tr] = lpFilt(fltPrms[0], fltPrms[1], 500, x[tr])
elif len(fltPrms) == 4:
# 20, 40, 10, 55 #(fpL, fpH, fsL, fsH, nyqf, y):
_fx[tr] = bpFilt(fltPrms[0], fltPrms[1], fltPrms[2],
fltPrms[3], 500, x[tr])
else:
_fx = x
gk = gauKer(1)
gk /= _N.sum(gk)
if trials is None:
trials = _N.arange(TR)
TR = TR
else:
TR = len(trials)
trials = _N.array(trials)
#trials, TR = range(mARp.TR), mARp.TR if (trials is None) else trials, len(trials)
nPh0s = _N.zeros(TR)
t1 = t1 - t0 # mdn already size t1-t0
t0 = 0
mdn = _mdn
fx = _fx
if _mdn.shape[0] != t1 - t0:
mdn = _mdn[:, t0:t1]
if _fx.shape[0] != t1 - t0:
fx = _fx[:, t0:t1]
itr = 0
phs = [] # phase 0 of inferred is at what phase of GT or LFP?
cSpkPhs = []
sSpkPhs = []
for tr in trials:
itr += 1
cv = _N.convolve(mdn[tr, t0:t1] - _N.mean(mdn[tr, t0:t1]),
gk,
mode="same")
ht_mdn = _ssig.hilbert(cv)
ht_fx = _ssig.hilbert(fx[tr, t0:t1] - _N.mean(fx[tr, t0:t1]))
ph_mdn = (_N.arctan2(ht_mdn.imag, ht_mdn.real) + _N.pi) / (2 * _N.pi)
ph_mdn = _N.mod(ph_mdn + shftPhase, 1)
ph_fx = (_N.arctan2(ht_fx.imag, ht_fx.real) + _N.pi) / (2 * _N.pi)
ph_fx = _N.mod(ph_fx + shftPhase, 1)
# phase = 0 is somewhere in middle
inds = _N.where((ph_mdn[0:t1 - t0 - 1] < 1)
& (ph_mdn[0:t1 - t0 - 1] > 0.5)
& (ph_mdn[1:t1 - t0] < 0.25))[0]
cSpkPhs.append(_N.cos(2 * _N.pi * ph_fx[inds + t0]))
sSpkPhs.append(_N.sin(2 * _N.pi * ph_fx[inds + t0]))
phs.append(ph_fx[inds + t0])
#for i in xrange(t0-t0, t1-t0-1):
# if (ph_mdn[i] < 1) and (ph_mdn[i] > 0.5) and (ph_mdn[i+1] < -0.5):
# pInfrdAt0.append(ph_fx[i]/2.)
return figCircularDistribution(phs,
cSpkPhs,
sSpkPhs,
trials,
surrogates=surrogates,
normed=normed,
fn=fn,
maxY=maxY,
yticks=yticks,
color=color,
xlabel=xlabel)
segN_mm[1] = _N.array([_N.min(lindist[seg2]), _N.max(lindist[seg2])])
seg3 = _N.where(tFilled == 3)[0]
segN_mm[2] = _N.array([_N.min(lindist[seg3]), _N.max(lindist[seg3])])
seg4 = _N.where(tFilled == 4)[0]
segN_mm[3] = _N.array([_N.min(lindist[seg4]), _N.max(lindist[seg4])])
seg5 = _N.where(tFilled == 5)[0]
segN_mm[4] = _N.array([_N.min(lindist[seg5]), _N.max(lindist[seg5])])
trans = _N.array([-1] + (_N.where(_N.diff(tFilled) != 0)[0]).tolist()) + 1
# 1, 2, 3, 4, 5
# (seg)0, (seg)1 10, 11 20, 21 30, 31 40, 41 50, 51
# 10 outbound 11 inbound
gk = _flt.gauKer(20)
gk /= _N.sum(gk)
# first, break it into inbound, outbound.
flindist = _N.convolve(lindist, gk, mode="same")
for isg in xrange(len(trans) - 1):
tSeg0 = trans[isg] # time when we moved into this segment
tSeg1 = trans[isg + 1] # time when we moved into this segment
iseg = tFilled[tSeg0] - 1 #
outb = tFilled[tSeg0] * 10
inb = outb + 1
av = _N.mean(segN_mm[iseg])
if flindist[tSeg0] < av and flindist[tSeg1] > av: # OUTBOUND
tsFilled[tSeg0:tSeg1] = outb
elif flindist[tSeg0] > av and flindist[tSeg1] < av: # INBOUND
tsFilled[tSeg0:tSeg1] = inb
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()
#frg = "38-50"
#frg = "30-45"
#frg = "10-18"
#frg = "25-30"
lags_sec=30
slideby_sec = slideby/300
lags = int(lags_sec / slideby_sec)+1 # (slideby/300)*lags
xticksD = [-20, -10, 0, 10, 20]
time_lags = _N.linspace(-(slideby/300)*lags, lags*(slideby/300), 2*lags+1)
xticksD = [-20, -10, 0, 10, 20]
iexpt = -1
#time_lags = _N.linspace(-(slideby/300)*lags, lags*(slideby/300), 2*lags+1)
gk = gauKer(2)
pf_x = _N.arange(-15, 16)
all_x= _N.arange(-141, 142)
ch_w_CM, rm_chs, list_ch_names, ch_types = datconf.getConfig(datconf._RPS)
arr_ch_names = _N.array(list_ch_names)
for key in key_dats:
iexpt += 1
f12 = frg.split("-")
f1 = f12[0]
f2 = f12[1]
allWFs = []
vs = "%(a)d%(g)d" % {"a" : armv_ver, "g" : gcoh_ver}
def setParams(self):
oo = self
# #generate initial values of parameters
oo._d = _kfardat.KFARGauObsDat(oo.TR, oo.N, 1)
oo._d.copyData(oo.y)
# baseFN_inter baseFN_comps baseFN_comps
oo.smpx = _N.zeros((oo.TR, oo.N + 1)) # start at 0 + u
oo.ws = _N.empty((oo.TR, oo._d.N+1), dtype=_N.float)
if oo.q20 is None:
oo.q20 = 0.00077
oo.q2 = _N.ones(oo.TR)*oo.q20
oo.F0 = _N.array([0.9])
######## Limit the amplitude to something reasonable
xE, nul = createDataAR(oo.N, oo.F0, oo.q20, 0.1)
mlt = _N.std(xE) / 0.5 # we want amplitude around 0.5
oo.q2 /= mlt*mlt
xE, nul = createDataAR(oo.N, oo.F0, oo.q2[0], 0.1)
w = 5
wf = gauKer(w)
gk = _N.empty((oo.TR, oo.N+1))
fgk= _N.empty((oo.TR, oo.N+1))
for m in xrange(oo.TR):
gk[m] = _N.convolve(oo.y[m], wf, mode="same")
gk[m] = gk[m] - _N.mean(gk[m])
gk[m] /= 5*_N.std(gk[m])
fgk[m] = bpFilt(15, 100, 1, 135, 500, gk[m]) # we want
fgk[m, :] /= 2*_N.std(fgk[m, :])
if oo.noAR:
oo.smpx[m, 0] = 0
else:
oo.smpx[m] = fgk[m]
oo.s_lrn = _N.empty((oo.TR, oo.N+1))
oo.sprb = _N.empty((oo.TR, oo.N+1))
oo.lrn_scr1 = _N.empty(oo.N+1)
oo.lrn_iscr1 = _N.empty(oo.N+1)
oo.lrn_scr2 = _N.empty(oo.N+1)
oo.lrn_scr3 = _N.empty(oo.N+1)
oo.lrn_scld = _N.empty(oo.N+1)
if oo.bpsth:
oo.B = patsy.bs(_N.linspace(0, (oo.t1 - oo.t0)*oo.dt, (oo.t1-oo.t0)), df=oo.dfPSTH, knots=oo.kntsPSTH, include_intercept=True) # spline basis
if oo.dfPSTH is None:
oo.dfPSTH = oo.B.shape[1]
oo.B = oo.B.T # My convention for beta
if oo.aS is None:
oo.aS = _N.linalg.solve(_N.dot(oo.B, oo.B.T), _N.dot(oo.B, _N.ones(oo.t1 - oo.t0)*0.01)) # small amplitude psth at first
oo.u_a = _N.zeros(oo.dfPSTH)
else:
oo.B = patsy.bs(_N.linspace(0, (oo.t1 - oo.t0)*oo.dt, (oo.t1-oo.t0)), df=4, include_intercept=True) # spline basis
oo.B = oo.B.T # My convention for beta
oo.aS = _N.zeros(4)
#oo.u_a = _N.ones(oo.dfPSTH)*_N.mean(oo.us)
oo.u_a = _N.zeros(oo.dfPSTH)
def 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):
# finish epoch doesn't deal with noise cluster
tt2 = _tm.time()
gkMAP = gauKer(2)
frm = int(0.7*ITERS) # have to test for stationarity
if nSpks > 0:
# ITERS x nSpks x M
occ = _N.mean(_N.mean(gz[frm:ITERS-1], axis=0), axis=0)
oo.smp_sp_hyps = smp_sp_hyps
oo.smp_sp_prms = smp_sp_prms
oo.smp_mk_hyps = smp_mk_hyps
oo.smp_mk_prms = smp_mk_prms
l_trlsNearMAP = []
MAPvalues2(epc, smp_sp_prms, oo.sp_prmPstMd, frm, ITERS, M, 3, occ, gkMAP, l_trlsNearMAP)
l0[0:M] = oo.sp_prmPstMd[epc, oo.ky_p_l0::3]
f[0:M] = oo.sp_prmPstMd[epc, oo.ky_p_f::3]
q2[0:M] = oo.sp_prmPstMd[epc, oo.ky_p_q2::3]
MAPvalues2(epc, smp_sp_hyps, oo.sp_hypPstMd, frm, ITERS, M, 6, occ, gkMAP, None)
_f_u[:] = oo.sp_hypPstMd[epc, oo.ky_h_f_u::6]
_f_q2[:] = oo.sp_hypPstMd[epc, oo.ky_h_f_q2::6]
_q2_a[:] = oo.sp_hypPstMd[epc, oo.ky_h_q2_a::6]
_q2_B[:] = oo.sp_hypPstMd[epc, oo.ky_h_q2_B::6]
_l0_a[:] = oo.sp_hypPstMd[epc, oo.ky_h_l0_a::6]
_l0_B[:] = oo.sp_hypPstMd[epc, oo.ky_h_l0_B::6]
#pcklme["cp%d" % epc] = _N.array(smp_sp_prms)
#trlsNearMAP = _N.array(list(set(trlsNearMAP_D)))+frm # use these trials to pick out posterior params for MARK part
#oo.mk_prmPstMd = [ epochs, M, K
# epochs, M, K, K ]
#oo.mk_hypPstMd = [ epochs, M, K
# epochs, M, K, K
# epochs, M, 1
# epochs, M, K, K
#smp_mk_prms = [ K, ITERS, M
# K, K, ITERS, M
#smp_mk_hyps = [ K, ITERS, M
# K, K, ITERS, M
# 1, ITERS, M
# K, K, ITERS, M
## params and hyper parms for mark
for m in xrange(M):
MAPtrls = l_trlsNearMAP[m]
if len(MAPtrls) == 0: # none of them. causes nan in mean
MAPtrls = _N.arange(frm, ITERS, 10)
#print MAPtrls
u[m] = _N.median(smp_mk_prms[0][:, frm:, m], axis=1)
Sg[m] = _N.mean(smp_mk_prms[1][:, :, frm:, m], axis=2)
oo.mk_prmPstMd[oo.ky_p_u][epc, m] = u[m]
oo.mk_prmPstMd[oo.ky_p_Sg][epc, m]= Sg[m]
_u_u[m] = _N.mean(smp_mk_hyps[oo.ky_h_u_u][:, frm:, m], axis=1)
_u_Sg[m] = _N.mean(smp_mk_hyps[oo.ky_h_u_Sg][:, :, frm:, m], axis=2)
_Sg_nu[m] = _N.mean(smp_mk_hyps[oo.ky_h_Sg_nu][0, frm:, m], axis=0)
_Sg_PSI[m] = _N.mean(smp_mk_hyps[oo.ky_h_Sg_PSI][:, :, frm:, m], axis=2)
oo.mk_hypPstMd[oo.ky_h_u_u][epc, m] = _u_u[m]
oo.mk_hypPstMd[oo.ky_h_u_Sg][epc, m] = _u_Sg[m]
oo.mk_hypPstMd[oo.ky_h_Sg_nu][epc, m] = _Sg_nu[m]
oo.mk_hypPstMd[oo.ky_h_Sg_PSI][epc, m]= _Sg_PSI[m]
#print _u_Sg[m]
u[0:M] = oo.mk_prmPstMd[oo.ky_p_u][epc]
Sg[0:M] = oo.mk_prmPstMd[oo.ky_p_Sg][epc]
### hack here. If we don't reset the prior for
### what happens when a cluster is unused?
### l0 -> 0, and at the same time, the variance increases.
### the prior then gets pushed to large values, but
### then it becomes difficult to bring it back to small
### values once that cluster becomes used again. So
### we would like unused clusters to have l0->0, but keep the
### variance small. That's why we will reset a cluster
sq25 = 5*_N.sqrt(q2)
if M > 1:
occ = _N.mean(_N.sum(gz[frm:], axis=1), axis=0) # avg. # of marks assigned to this cluster
socc = _N.sort(occ)
minAss = (0.5*(socc[-2]+socc[-1])*0.01) # if we're 100 times smaller than the average of the top 2, let's consider it empty
if oo.resetClus and (M > 1):
for m in xrange(M):
# Sg and q2 are treated differently. Even if no spikes are
# observed, q2 is updated, while Sg is not.
# This is because NO spikes in physical space AND trajectory
# information contains information about the place field.
# However, in mark space, not observing any marks tells you
# nothing about the mark distribution. That is why f, q2
# are updated when there are no spikes, but u and Sg are not.
if q2[m] < 0:
print "????????????????"
print q2
print "q2[%(m)d] = %(q2).3f" % {"m" : m, "q2" : q2[m]}
print smp_sp_prms[0, :, m]
print smp_sp_prms[1, :, m]
print smp_sp_prms[2, :, m]
print smp_sp_hyps[4, :, m]
print smp_sp_hyps[5, :, m]
if ((occ[m] < minAss) and (l0[m] / _N.sqrt(twpi*q2[m]) < 1)) or \
(f[m] < oo.xLo-sq25[m]) or \
(f[m] > oo.xHi+sq25[m]):
print "resetting cluster %(m)d %(l0).3f %(f).3f" % {"m" : m, "l0" : (l0[m] / _N.sqrt(twpi*q2[m])), "f" : f[m]}
_q2_a[m] = 1e-4
_q2_B[m] = 1e-3
_f_q2[m] = 4
_u_Sg[m] = _N.identity(K)*9
_l0_a[m] = 1e-4
freeClstr[m] = True
else:
freeClstr[m] = False
rsmp_sp_prms = smp_sp_prms.swapaxes(1, 0).reshape(ITERS, 3*M, order="F")
_N.savetxt(resFN("posParams_%d.dat" % epc, dir=oo.outdir), rsmp_sp_prms, fmt=("%.4f %.4f %.4f " * M)) # the params for the non-noise
landmarks = _N.empty((6, 2)) Nsgs = 5 segs = _N.empty((Nsgs, 2, 2)) length = _N.empty(Nsgs) offset = _N.array([0, 1, 2, 1, 2]) minINOUT = 100 # regular lindist # 0 to 3 # lin_inout # inbound outbound 0 to 6 # lin_lr # -3 to 3 # lin_lr_inout # -3 to 3 ii = 0 gkRWD = gauKer(5) gkRWD /= _N.sum(gkRWD) anim1 = None anim2 = None day = None ep = None r = None seg_ts = None inout = None # inbound - outbound a_inout = None # inbound - outbound lr = None fspd = None
def createFlucOsc(f0,
f0VAR,
N,
dt0,
TR,
Bf=[0.99],
Ba=[0.99],
amp=1,
amp_nz=0,
stdf=None,
stda=None,
sig=0.1,
smoothKer=0,
dSF=5,
dSA=5):
"""
AR as a generative model creates oscillations where amplitude is
sometimes small - to the point of calling it an oscillation is not quite
dSA, dSF modulations created like (AR / (dSX x stddev)).
"""
out = _N.empty((TR, N))
if stdf == None:
x, y = createDataAR(100000, Bf, sig, sig)
stdf = _N.std(
x) # choice of 4 std devs to keep phase monotonically increasing
if stda == None:
x, y = createDataAR(100000, Ba, sig, sig)
stda = _N.std(
x) # choice of 4 std devs to keep phase monotonically increasing
trm = 500
dts = _N.empty(N - 1)
t = _N.empty(N)
t[0] = 0
if smoothKer > 0:
gk = gauKer(smoothKer)
for tr in xrange(TR):
ph0 = _N.random.rand() * 2 * _N.pi
bGood = False
while not bGood:
f, dum = createDataAR(N + trm, Bf, sig, sig, trim=trm)
fn = 1 + (f / (dSF * stdf)
) # going above 4 stdf very rare. |xn| is almost < 1
bGood = True
lt0s = _N.where(fn < 0)
print "fn < 0 at %d places" % len(lt0s[0])
#if _N.min(fn) > 0:
# bGood = True
for i in xrange(1, N):
dt = dt0 * fn[i]
t[i] = t[i - 1] + dt
dts[i - 1] = dt
y = _N.sin(2 * _N.pi * (f0 + f0VAR[tr]) * t + ph0)
bGood = False
while not bGood:
a, dum = createDataAR(N + trm, Ba, sig, sig, trim=trm)
an = a / (dSA * stda) # in limit of large N, std(xn) = 1
AM = 1 + an # if we get fluctuations 2 stds bigger,
bGood = True
lt0s = _N.where(AM < 0)
print "AM < 0 at %d places" % len(lt0s[0])
#if _N.min(AM) > 0:
# bGood = True
if smoothKer > 0:
out[tr] = _N.convolve(y * AM * (amp + _N.random.randn() * amp_nz),
gk,
mode="same")
else:
out[tr] = y * AM * amp
return out
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 suggestPSTHKnots(dt, TR, N, bindat, bnsz=10, psth_knts=10, psth_run=False):
"""
bnsz binsize used to calculate approximate PSTH
"""
rszd = False
if N % bnsz != 0:
rszd = True
pcs = _N.ceil(N / bnsz)
bnsz = int(_N.floor(N / pcs))
spkts = _U.fromBinDat(bindat, SpkTs=True)
# apsth needs to be same size as N. ie N%bnsz needs to be 0
h, bs = _N.histogram(spkts, bins=_N.linspace(0, N, (N // bnsz) + 1))
fs = (h / (TR * bnsz * dt))
_apsth = _N.repeat(fs, bnsz) # piecewise boxy approximate PSTH
if rszd:
apsth = _N.zeros(N)
apsth[0:(N // bnsz) * bnsz] = _apsth
apsth[(N // bnsz) * bnsz:] = apsth[(N // bnsz) * bnsz - 1]
else:
apsth = _apsth
apsth *= dt
gk = gauKer(5)
gk /= _N.sum(gk)
f_apsth = _N.convolve(apsth, gk, mode="same")
dpsth_pctl = _N.cumsum(_N.abs(_N.diff(f_apsth)))
dpsth_pctl /= dpsth_pctl[-1]
dpsth_pctl[0] = 0
ITERS = 40
x = _N.linspace(0., N - 1, N, endpoint=False) # in units of ms.
r2s = _N.empty(ITERS)
best_r2s = _N.zeros(5)
for iknts in range(5, 6):
allKnts = _N.empty((ITERS, iknts))
allCoeffs = []
tAvg = 1. / iknts
tsMin = tAvg * 0.5
tsMax = tAvg * 1.5
for it in range(ITERS):
knt_inds = _N.zeros(iknts + 1)
bGood = False
while not bGood:
try:
#pieces = tsMin + _N.random.rand(iknts+1)*(tsMax-tsMin)
rnd_pctls = _N.sort(_N.random.rand(iknts + 1))
#pieces = tsMin + _N.random.rand(iknts+1)*(tsMax-tsMin)
for i in range(iknts + 1):
iHere = _N.where((rnd_pctls[i] >= dpsth_pctl[0:-1])
& (rnd_pctls[i] < dpsth_pctl[1:]))[0]
knt_inds[i] = iHere[0]
# knts = _N.empty(iknts+1)
# knts[0] = pieces[0]
# for i in range(1, iknts+1):
# knts[i] = knts[i-1] + pieces[i]
# knts /= knts[-1]
# knts[0:-1] *= N
#knts = _N.sort((0.1 + 0.85*_N.random.rand(iknts))*N)
B = patsy.bs(x,
knots=(knt_inds[0:-1]),
include_intercept=True)
iBTB = _N.linalg.inv(_N.dot(B.T, B))
bGood = True
except _N.linalg.linalg.LinAlgError:
print("Linalg Error or Value Error in suggestPSTHKnots")
except ValueError:
print("Linalg Error or Value Error in suggestPSTHKnots")
#a = _N.dot(iBTB, _N.dot(B.T, _N.log(apsth)))
a = _N.dot(iBTB, _N.dot(B.T, apsth))
#ft = _N.exp(_N.dot(B, a))
ft = _N.dot(B, a)
r2s[it] = _N.dot(ft - apsth, ft - apsth)
allKnts[it, :] = knt_inds[0:-1]
allCoeffs.append(a)
mnIt = _N.where(r2s == r2s.min())[0][0]
best_r2s[iknts - 10] = r2s[mnIt]
knts = allKnts[mnIt]
cfs = allCoeffs[mnIt]
B = patsy.bs(x, knots=knts, include_intercept=True)
if psth_run:
fig = _plt.figure()
_plt.plot(_N.dot(B, cfs))
_plt.plot(apsth)
return knts, apsth, cfs
rpsm_key = rpsms.rpsm_eeg_as_key[dat]
armv_ver = 1
gcoh_ver = 3
manual_cluster = False
Fs = 300
win, slideby = _ppv.get_win_slideby(gcoh_ver)
t_offset = 0 # ms offset behv_sig_ts
stop_early = 0 #180
ev_n = 0
gk_std = 1
gk = gauKer(gk_std)
gk /= _N.sum(gk)
show_shuffled = False
rvrs = False
process_keyval_args(globals(), sys.argv[1:])
######################################################3
srvrs = "_revrsd" if rvrs else ""
sshf = "_sh" if show_shuffled else ""
rpsmdir = getResultFN(dat)
pikdir = getResultFN("%(dir)s/v%(av)d%(gv)d" % {
"dir": dat,
"av": armv_ver,
"gv": gcoh_ver
})
def compare(mARp, est, X, spkHist, oscMn, dat, gkW=20, useRefr=True):
dt = 0.001
gk = _flt.gauKer(gkW)
gk /= _N.sum(gk)
TR = oscMn.shape[0]
# params, stT
params = _N.array(est.params)
stT = spkHist.LHbin * (spkHist.nLHBins + 1
) # first stT spikes used for initial history
ocifs = _N.empty(
(spkHist.endTR - spkHist.startTR, spkHist.t1 - spkHist.t0 - stT))
##
sur = "refr"
if not useRefr:
params[spkHist.endTR:spkHist.endTR +
spkHist.LHbin] = params[spkHist.endTR + spkHist.LHbin]
sur = "NOrefr"
for tr in xrange(spkHist.endTR - spkHist.startTR):
ocifs[tr] = _N.exp(_N.dot(X[tr], params)) / dt
cglmAll = _N.zeros((TR, mARp.N + 1))
infrdAll = _N.zeros((TR, mARp.N + 1))
xt = _N.arange(stT, mARp.N + 1)
for tr in xrange(spkHist.startTR, TR):
_gt = dat[stT:, tr * 3]
gt = _N.convolve(_gt, gk, mode="same")
gt /= _N.std(gt)
glm = (ocifs[tr] - _N.mean(ocifs[tr])) / _N.std(ocifs[tr])
cglm = _N.convolve(glm, gk, mode="same")
cglm /= _N.std(cglm)
infrd = oscMn[tr, stT:] / _N.std(oscMn[tr, stT:])
infrd /= _N.std(infrd)
pc1, pv1 = _ss.pearsonr(glm, gt)
pc1c, pv1c = _ss.pearsonr(cglm, gt)
pc2, pv2 = _ss.pearsonr(infrd, gt)
cglmAll[tr, stT:] = cglm
infrdAll[tr, stT:] = infrd
fig = _plt.figure(figsize=(12, 4))
ax = fig.add_subplot(1, 1, 1)
_plt.plot(xt, infrd, color=myC.infrdM, lw=2)
_plt.plot(xt, cglm, color=myC.infrdM, lw=2., ls="--")
#_plt.plot(xt, glm, color=myC.infrdM, lw=2., ls="-.")
_plt.plot(xt, gt, color=myC.grndTruth, lw=4)
MINx = _N.min(infrd)
MAXx = _N.max(infrd)
AMP = MAXx - MINx
ht = 0.08 * AMP
ys1 = MINx - 0.5 * ht
ys2 = MINx - 3 * ht
for n in xrange(stT, mARp.N + 1):
if mARp.y[tr, n] == 1:
_plt.plot([n, n], [ys1, ys2], lw=2.5, color="black")
_plt.ylim(ys2 - 0.05 * AMP, MAXx + 0.05 * AMP)
_plt.xlim(stT, mARp.N + 1)
mF.arbitraryAxes(ax,
axesVis=[False, False, False, False],
xtpos="bottom",
ytpos="none")
mF.setLabelTicks(_plt,
yticks=[],
yticksDsp=None,
xlabel="time (ms)",
ylabel=None,
xtickFntSz=24,
xlabFntSz=26)
fig.subplots_adjust(left=0.05, right=0.95, bottom=0.2, top=0.85)
_plt.savefig("cmpGLMAR_%(ur)s_%(tr)d.eps" % {"tr": tr, "ur": sur})
_plt.close()
corrs[tr] = pc1, pc1c, pc2
mF.histPhase0_phaseInfrd(mARp,
cglmAll,
t0=stT,
t1=(mARp.N + 1),
bRealDat=False,
normed=True,
maxY=1.8,
fn="smthdGLMPhaseGLM%s" % sur)
mF.histPhase0_phaseInfrd(mARp,
infrdAll,
t0=stT,
t1=(mARp.N + 1),
bRealDat=False,
normed=True,
maxY=1.8,
fn="smthdGLMPhaseInfrd")
print _N.mean(corrs[:, 0])
print _N.mean(corrs[:, 1])
print _N.mean(corrs[:, 2])
fig = _plt.figure(figsize=(8, 3.5))
ax = fig.add_subplot(1, 2, 1)
_plt.hist(corrs[:, 1],
bins=_N.linspace(-0.5,
max(corrs[:, 2]) * 1.05, 30),
color=myC.hist1)
mF.bottomLeftAxes(ax)
ax = fig.add_subplot(1, 2, 2)
_plt.hist(corrs[:, 2],
bins=_N.linspace(-0.5,
max(corrs[:, 2]) * 1.05, 30),
color=myC.hist1)
mF.bottomLeftAxes(ax)
fig.subplots_adjust(left=0.05,
bottom=0.1,
right=0.95,
top=0.88,
wspace=0.2,
hspace=0.2)
_plt.savefig("cmpGLMAR_hist")
_plt.close()
print("............... %s" % datetm)
flip_human_AI = False
#fig = _plt.figure(figsize=(11, 11))
for cov in [_AIconst._WTL]: #, _AIconst._HUMRPS, _AIconst._AIRPS]:
scov = _AIconst.sCOV[cov]
sran = ""
SHUFFLES = 1
a_s = _N.zeros((len(datetms), SHUFFLES + 1))
acs = _N.zeros((len(datetms), SHUFFLES + 1, 61))
if gk_w > 0:
gk = gauKer(gk_w)
gk /= _N.sum(gk)
sFlip = "_flip" if flip_human_AI else ""
label = "%(wins)d%(gkw)d" % {"wins": wins, "gkw": gk_w}
out_dir = getResultFN("%(dfn)s" % {"dfn": datetm})
if not os.access(out_dir, os.F_OK):
os.mkdir(out_dir)
out_dir = getResultFN("%(dfn)s/%(lbl)s" % {
"dfn": datetm,
"lbl": label
})
if not os.access(out_dir, os.F_OK):
os.mkdir(out_dir)
def compareWF(mARp,
ests,
Xs,
spkHists,
oscMn,
dat,
gkW=20,
useRefr=True,
dspW=None):
"""
instead of subplots, plot 3 different things with 3 largely separated y-values
"""
glmsets = len(ests) # horrible hack
TR = oscMn.shape[0]
infrdAll = _N.zeros((TR, mARp.N + 1))
dt = 0.001
gk = _flt.gauKer(gkW)
gk /= _N.sum(gk)
paramss = []
ocifss = []
stTs = []
for gs in xrange(glmsets): # for the 2 glm conditions
params = _N.array(ests[gs].params)
X = Xs[gs]
spkHist = spkHists[gs]
stTs.append(spkHist.LHbin *
(spkHist.nLHBins +
1)) # first stT spikes used for initial history
ocifss.append(
_N.empty((spkHist.endTR - spkHist.startTR,
spkHist.t1 - spkHist.t0 - stTs[gs])))
for tr in xrange(spkHist.endTR - spkHist.startTR):
ocifss[gs][tr] = _N.exp(_N.dot(X[tr], params)) / dt
stT = min(stTs)
#cglmAll = _N.zeros((TR, mARp.N+1))
xt = _N.arange(stT, mARp.N + 1)
xts = [_N.arange(stTs[0], mARp.N + 1), _N.arange(stTs[1], mARp.N + 1)]
lss = [":", "-"]
lws = [3.8, 2]
cls = [myC.infrdM]
for tr in xrange(spkHist.startTR, TR):
_gt = dat[stT:, tr * 3]
gt = _N.convolve(_gt, gk, mode="same")
gt /= _N.std(gt)
infrd = oscMn[tr, stT:] / _N.std(oscMn[tr, stT:])
infrd /= _N.std(infrd)
infrdAll[tr, stT:] = infrd
fig = _plt.figure(figsize=(12, 8))
ax = fig.add_subplot(1, 1, 1)
_plt.plot(xt, gt, color=myC.grndTruth, lw=4)
#_plt.plot(xt, infrd, color="brown", lw=4)
up1 = _N.max(gt) - _N.min(gt)
## mirror
_plt.plot(xt, gt + up1 * 1.25, color=myC.grndTruth, lw=4)
_plt.plot(xt, infrd + up1 * 1.25, color=myC.infrdM, lw=2)
for gs in xrange(glmsets):
ocifs = ocifss[gs]
glm = (ocifs[tr] - _N.mean(ocifs[tr])) / _N.std(ocifs[tr])
cglm = _N.convolve(glm, gk, mode="same")
cglm /= _N.std(cglm)
_plt.plot(xts[gs], cglm, color=myC.infrdM, lw=lws[gs], ls=lss[gs])
MINx = _N.min(infrd)
#MAXx = _N.max(infrd)
MAXx = _N.max(gt) + up1 * 1.35
AMP = MAXx - MINx
ht = 0.08 * AMP
ys1 = MINx - 0.5 * ht
ys2 = MINx - 3 * ht
for n in xrange(stT, mARp.N + 1):
if mARp.y[tr, n] == 1:
_plt.plot([n, n], [ys1, ys2], lw=2.5, color="black")
_plt.ylim(ys2 - 0.05 * AMP, MAXx + 0.05 * AMP)
if dspW is None:
_plt.xlim(stT, mARp.N + 1)
else:
_plt.xlim(dspW[0], dspW[1])
mF.arbitraryAxes(ax,
axesVis=[False, False, False, False],
xtpos="bottom",
ytpos="none")
mF.setLabelTicks(_plt,
yticks=[],
yticksDsp=None,
xlabel="time (ms)",
ylabel=None,
xtickFntSz=24,
xlabFntSz=26)
fig.subplots_adjust(left=0.05, right=0.95, bottom=0.2, top=0.85)
_plt.savefig("cmpGLMAR_%(tr)d.eps" % {"tr": tr}, transparent=True)
_plt.close()
def histPhase0_phaseInfrd(mARp,
_mdn,
t0=None,
t1=None,
bRealDat=False,
trials=None,
filtParams=None,
maxY=None,
yticks=None,
fn=None,
normed=False):
# what is the inferred phase when ground truth phase is 0
pInfrdAt0 = []
#if (filtParams is not None) and (not bRealDat):
if not bRealDat:
_fx = _N.empty((mARp.TR, mARp.N + 1))
for tr in xrange(mARp.TR):
_fx[tr] = lpFilt(30, 40, 1000, mARp.x[tr])
else:
_fx = mARp.x
if bRealDat:
_fx = mARp.fx
gk = gauKer(1)
gk /= _N.sum(gk)
if trials is None:
trials = range(mARp.TR)
TR = mARp.TR
else:
TR = len(trials)
nPh0s = _N.zeros(TR)
#t1 = t1-t0 # mdn already size t1-t0
#t0 = 0
mdn = _mdn
fx = _fx
#if _mdn.shape[0] != t1 - t0:
# mdn = _mdn[:, t0:t1]
#if _fx.shape[0] != t1 - t0:
# fx = _fx[:, t0:t1]
itr = 0
for tr in trials:
itr += 1
cv = _N.convolve(mdn[tr, t0:t1] - _N.mean(mdn[tr, t0:t1]),
gk,
mode="same")
#cv = mdn[tr, t0:t1] - _N.mean(mdn[tr, t0:t1])
ht_mdn = _ssig.hilbert(cv)
#ht_fx = _ssig.hilbert(fx[tr, t0:t1] - _N.mean(fx[tr, t0:t1]))
ht_fx = _ssig.hilbert(fx[tr, t0:t1] - _N.mean(fx[tr, t0:t1]))
ph_mdn = _N.arctan2(ht_mdn.imag, ht_mdn.real) / _N.pi
ph_fx = ((_N.arctan2(ht_fx.imag, ht_fx.real) / _N.pi) + 1)
# phase = 0 is somewhere in middle
for i in xrange(t0 - t0, t1 - t0 - 1):
if (ph_mdn[i] < 1) and (ph_mdn[i] > 0.5) and (ph_mdn[i + 1] <
-0.5):
nPh0s[itr - 1] += 1
pInfrdAt0.append(ph_fx[i] / 2.)
pInfrdAt0.append((ph_fx[i] + 2) / 2.)
bgFnt = 22
smFnt = 20
fig, ax = _plt.subplots(figsize=(6, 4.2))
pInfrdAt0A = _N.array(pInfrdAt0[::2]) # 0 to 2
Npts = len(pInfrdAt0A)
R2 = (1. / (Npts * Npts)) * (_N.sum(_N.cos(2 * _N.pi * pInfrdAt0A))**2 +
_N.sum(_N.sin(2 * _N.pi * pInfrdAt0A))**2)
_plt.hist(pInfrdAt0,
bins=_N.linspace(0, 2, 41),
color=mC.hist1,
edgecolor=mC.hist1,
normed=normed)
print "maxY!!! %f" % maxY
if (maxY is not None):
_plt.ylim(0, maxY)
_plt.xlabel("phase", fontsize=bgFnt)
_plt.ylabel("frequency", fontsize=bgFnt)
_plt.xticks(fontsize=smFnt)
if yticks is not None:
_plt.yticks(yticks)
_plt.yticks(fontsize=smFnt)
if yticks is not None:
_plt.yticks(yticks)
if normed:
_plt.yticks([0.25, 0.5, 0.75, 1], ["0.25", "0.5", "0.75", "1"])
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.yaxis.set_ticks_position("left")
ax.xaxis.set_ticks_position("bottom")
for tic in ax.xaxis.get_major_ticks():
tic.tick1On = tic.tick2On = False
fig.subplots_adjust(left=0.17, bottom=0.17, right=0.95, top=0.9)
if fn is None:
fn = "fxPhase1_phaseInfrd,R=%.3f.eps" % _N.sqrt(R2)
else:
fn = "%(1)s,R=%(2).3f.eps" % {"1": fn, "2": _N.sqrt(R2)}
_plt.savefig(fn, transparent=True)
_plt.close()
return pInfrdAt0, _N.sqrt(R2), nPh0s
shfl_type=_SHFL_KEEP_CONT
slideby_sec = slideby/Fs
lags = int(lags_sec / slideby_sec)+1 # (slideby/300)*lags
xticksD = [-20, -10, 0, 10, 20]
time_lags = _N.linspace(-(slideby/300)*lags, lags*(slideby/300), 2*lags+1)
xticksD = [-20, -10, 0, 10, 20]
midp = lags
#### # of sections
#### # gk size for smoothing
#### # pk_win_sec
sections = 6
int_gkw = 6
gk = gauKer(int_gkw)
#gk = gauKer(2)
gk /= _N.sum(gk)
pk_win_sec = 2.5
prm_dir = "sec=%(sec)d_gkintw=%(gk)d_pkwin_sec=%(pws).1f" % {"sec" : sections, "gk" : int_gkw, "pws" : pk_win_sec}
print("lags %d" % lags)
iexpt = -1
#time_lags = _N.linspace(-(slideby/300)*lags, lags*(slideby/300), 2*lags+1)
#gk = gauKer(2)
#all_x= _N.arange(-141, 142)
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()
_ME_WTL = 0
_ME_RPS = 1
_SHFL_KEEP_CONT = 0
_SHFL_NO_KEEP_CONT = 1
shfl_type_str = _N.array(["keep_cont", "no_keep_cont"])
def depickle(s):
import pickle
with open(s, "rb") as f:
lm = pickle.load(f)
return lm
gk_fot = gauKer(1)
gk_fot = gk_fot / _N.sum(gk_fot)
def find_osc_timescale(ACfun, lags):
ACfun = _N.convolve(ACfun, gk_fot, mode="same") # smooth out AC function
dACfun = _N.diff(ACfun)
maxes = _N.where((dACfun[0:-1] > 0) & (dACfun[1:] <= 0))[0]
mins = _N.where((dACfun[0:-1] < 0) & (dACfun[1:] >= 0))[0]
mnMaxes = -1
mnMins = -1
mnInt = 0
nTerms = 0
if (len(maxes) >= 2):
mnMaxes = _N.diff(maxes)[0] # intervals
#mnMaxes = _N.mean(_N.diff(maxes)) # intervals
partIDs, incmp_dat = only_complete_data(partIDs, TO, label, SHF_NUM) strtTr = 0 TO -= strtTr #fig= _plt.figure(figsize=(14, 14)) SHUFFLES = 1 nMimics = _N.empty(len(partIDs), dtype=_N.int) t0 = -5 t1 = 10 trigger_temp = _N.empty(t1 - t0) cut = 1 all_avgs = _N.empty((len(partIDs), t1 - t0)) netwins = _N.empty(len(partIDs), dtype=_N.int) gk = gauKer(1) gk /= _N.sum(gk) #gk = None UD_diff = _N.empty((len(partIDs), 3)) corrs_all = _N.empty((3, 6)) corrs_sing = _N.empty((len(partIDs), 3, 6)) perform = _N.empty(len(partIDs)) pid = 0 ts = _N.arange(t0 - 2, t1 - 2) signal_5_95 = _N.empty((len(partIDs), t1 - t0)) hnd_dat_all = _N.zeros((len(partIDs), TO, 4), dtype=_N.int)
SHF_NUM = 0 partIDs, incmp_dat = only_complete_data(partIDs, TO, label, SHF_NUM) strtTr = 0 TO -= strtTr #fig= _plt.figure(figsize=(14, 14)) SHUFFLES = 50 t0 = -5 t1 = 10 cut = 1 all_avgs = _N.empty((len(partIDs), SHUFFLES + 1, t1 - t0)) netwins = _N.empty(len(partIDs), dtype=_N.int) gk = gauKer(1) gk /= _N.sum(gk) #gk = None corrs_all = _N.empty((3, 6)) corrs_sing = _N.empty((len(partIDs), 3, 6)) perform = _N.empty(len(partIDs)) pid = 0 ts = _N.arange(t0 - 2, t1 - 2) signal_5_95 = _N.empty((len(partIDs), 4, t1 - t0)) pc_sum = _N.empty(len(partIDs)) pc_sum01 = _N.empty(len(partIDs))
def setParams(self, psth_run=False, psth_knts=10):
oo = self
# #generate initial values of parameters
#oo._d = _kfardat.KFARGauObsDat(oo.TR, oo.N, oo.k)
#oo._d.copyData(oo.y)
oo.Ns = _N.ones(oo.TR, dtype=_N.int) * oo.N
oo.ks = _N.ones(oo.TR, dtype=_N.int) * oo.k
oo.F = _N.zeros((oo.k, oo.k))
_N.fill_diagonal(oo.F[1:, 0:oo.k - 1], 1)
oo.F[0] = _N.random.randn(oo.k) / _N.arange(1, oo.k + 1)**2
oo.F[0, 0] = 0.8
oo.Fs = _N.zeros((oo.TR, oo.k, oo.k))
for tr in range(oo.TR):
oo.Fs[tr] = oo.F
oo.Ik = _N.identity(oo.k)
oo.IkN = _N.tile(oo.Ik, (oo.N + 1, 1, 1))
# need TR
# pr_x[:, 0] empty, not used
#oo.p_x = _N.empty((oo.TR, oo.N+1, oo.k, 1))
oo.p_x = _N.empty((oo.TR, oo.N + 1, oo.k))
oo.p_x[:, 0, 0] = 0
oo.p_V = _N.empty((oo.TR, oo.N + 1, oo.k, oo.k))
oo.p_Vi = _N.empty((oo.TR, oo.N + 1, oo.k, oo.k))
#oo.f_x = _N.empty((oo.TR, oo.N+1, oo.k, 1))
oo.f_x = _N.empty((oo.TR, oo.N + 1, oo.k))
oo.f_V = _N.empty((oo.TR, oo.N + 1, oo.k, oo.k))
#oo.s_x = _N.empty((oo.TR, oo.N+1, oo.k, 1))
oo.s_x = _N.empty((oo.TR, oo.N + 1, oo.k))
oo.s_V = _N.empty((oo.TR, oo.N + 1, oo.k, oo.k))
_N.fill_diagonal(oo.F[1:, 0:oo.k - 1], 1)
oo.G = _N.zeros((oo.k, 1))
oo.G[0, 0] = 1
oo.Q = _N.empty(oo.TR)
# baseFN_inter baseFN_comps baseFN_comps
print("freq_lims")
print(oo.freq_lims)
radians = buildLims(0, oo.freq_lims, nzLimL=1., Fs=(1 / oo.dt))
oo.AR2lims = 2 * _N.cos(radians)
oo.smpx = _N.zeros((oo.TR, (oo.N + 1) + 2, oo.k)) # start at 0 + u
oo.ws = _N.empty((oo.TR, oo.N + 1), dtype=_N.float)
############# ADDED THIS FOR DEBUG
#oo.F_alfa_rep = _N.array([-0.4 +0.j, 0.96999828+0.00182841j, 0.96999828-0.00182841j, 0.51000064+0.02405102j, 0.51000064-0.02405102j, 0.64524011+0.04059507j, 0.64524011-0.04059507j]).tolist()
if oo.F_alfa_rep is None:
oo.F_alfa_rep = initF(oo.R, oo.Cs + oo.Cn,
0).tolist() # init F_alfa_rep
print("F_alfa_rep*********************")
print(oo.F_alfa_rep)
#print(ampAngRep(oo.F_alfa_rep))
if oo.q20 is None:
oo.q20 = 0.00077
oo.q2 = _N.ones(oo.TR) * oo.q20
oo.F0 = (-1 * _Npp.polyfromroots(oo.F_alfa_rep)[::-1].real)[1:]
oo.Fs = _N.zeros((oo.TR, oo.k, oo.k))
oo.F[0] = oo.F0
_N.fill_diagonal(oo.F[1:, 0:oo.k - 1], 1)
for tr in range(oo.TR):
oo.Fs[tr] = oo.F
######## Limit the amplitude to something reasonable
xE, nul = createDataAR(oo.N, oo.F0, oo.q20, 0.1)
mlt = _N.std(xE) / 0.5 # we want amplitude around 0.5
oo.q2 /= mlt * mlt
xE, nul = createDataAR(oo.N, oo.F0, oo.q2[0], 0.1)
w = 5
wf = gauKer(w)
gk = _N.empty((oo.TR, oo.N + 1))
fgk = _N.empty((oo.TR, oo.N + 1))
for m in range(oo.TR):
gk[m] = _N.convolve(oo.y[m], wf, mode="same")
gk[m] = gk[m] - _N.mean(gk[m])
gk[m] /= 5 * _N.std(gk[m])
fgk[m] = bpFilt(15, 100, 1, 135, 500, gk[m]) # we want
fgk[m, :] /= 3 * _N.std(fgk[m, :])
if oo.noAR:
oo.smpx[m, 2:, 0] = 0
else:
oo.smpx[m, 2:, 0] = fgk[m, :]
for n in range(2 + oo.k - 1, oo.N + 1 + 2): # CREATE square smpx
oo.smpx[m, n, 1:] = oo.smpx[m, n - oo.k + 1:n, 0][::-1]
for n in range(2 + oo.k - 2, -1, -1): # CREATE square smpx
oo.smpx[m, n, 0:oo.k - 1] = oo.smpx[m, n + 1, 1:oo.k]
oo.smpx[m, n, oo.k - 1] = _N.dot(oo.F0,
oo.smpx[m, n:n + oo.k,
oo.k - 2]) # no noise
if oo.bpsth:
psthKnts, apsth, aWeights = _spknts.suggestPSTHKnots(
oo.dt,
oo.TR,
oo.N + 1,
oo.y.T,
psth_knts=psth_knts,
psth_run=psth_run)
_N.savetxt("apsth.txt", apsth, fmt="%.4f")
_N.savetxt("psthKnts.txt", psthKnts, fmt="%.4f")
apprx_ps = _N.array(_N.abs(aWeights))
oo.u_a = -_N.log(1 / apprx_ps - 1)
# For oo.u_a, use the values we get from aWeights
oo.B = patsy.bs(_N.linspace(0, (oo.t1 - oo.t0) * oo.dt,
(oo.t1 - oo.t0)),
knots=(psthKnts * oo.dt),
include_intercept=True) # spline basis
oo.B = oo.B.T # My convention for beta
oo.aS = _N.array(oo.u_a)
# fig = _plt.figure(figsize=(4, 7))
# fig.add_subplot(2, 1, 1)
# _plt.plot(apsth)
# fig.add_subplot(2, 1, 2)
# _plt.plot(_N.dot(oo.B.T, aWeights))
else:
oo.B = patsy.bs(_N.linspace(0, (oo.t1 - oo.t0) * oo.dt,
(oo.t1 - oo.t0)),
df=4,
include_intercept=True) # spline basis
oo.B = oo.B.T # My convention for beta
oo.aS = _N.zeros(4)
