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 create(setname): copyfile( "%s.py" % setname, "%(s)s/%(s)s.py" % { "s": setname, "to": setFN("%s.py" % setname, dir=setname, create=True) }) global dt, lambda2, rpsth, isis, us, TR, etme, f0VAR nColumns = 3 alldat = _N.empty((N, TR * nColumns)) for tr in xrange(TR): if f0VAR is None: f0VAR = _N.zeros(TR) sig = 0.1 x, y = createDataAR(100000, Bf, sig, sig) stdf = _N.std( x) # choice of 4 std devs to keep phase monotonically increasing x, y = createDataAR(100000, Ba, sig, sig) stda = _N.std( x) # choice of 4 std devs to keep phase monotonically increasing x, y = createDataAR(100000, Bf_1, sig, sig) stdf_1 = _N.std( x) # choice of 4 std devs to keep phase monotonically increasing x, y = createDataAR(100000, Ba_1, sig, sig) stda_1 = _N.std( x) # choice of 4 std devs to keep phase monotonically increasing x = createFlucOsc( f0, _N.array([f0VAR[tr]]), N, dt, 1, Bf=Bf, Ba=Ba, amp=amp, amp_nz=amp_nz, stdf=stdf, stda=stda, sig=sig, smoothKer=5, dSA=dSA, dSF=dSF ) # sig is arbitrary, but we need to keep it same as when stdf, stda measured x_1 = createFlucOsc( f0_1, _N.array([f0VAR_1[tr]]), N, dt, 1, Bf=Bf_1, Ba=Ba_1, amp=amp_1, amp_nz=amp_nz_1, stdf=stdf_1, stda=stda_1, sig=sig, smoothKer=5, dSA=dSA_1, dSF=dSF_1 ) # sig is arbitrary, but we need to keep it same as when stdf, stda measured y = x[0, :] + x_1[0, :] + obsNz * _N.random.randn(N) alldat[:, tr * nColumns] = x alldat[:, tr * nColumns + 1] = x_1 alldat[:, tr * nColumns + 2] = y fmtstr = "%.3f %.3f %.3f" * TR _N.savetxt(resFN("gauobs.dat", dir=setname), alldat, fmt=fmtstr) return alldat
def initGibbs(self): ################################ INITGIBBS oo = self 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 oo.aS = _N.linalg.solve( _N.dot(oo.B, oo.B.T), _N.dot(oo.B, _N.ones(oo.t1 - oo.t0) * _N.mean(oo.u))) # #generate initial values of parameters oo._d = _kfardat.KFARGauObsDat(oo.TR, oo.N, oo.k) oo._d.copyData(oo.y) sPR = "cmpref" if oo.use_prior == _cd.__FREQ_REF__: sPR = "frqref" elif oo.use_prior == _cd.__ONOF_REF__: sPR = "onfref" sAO = "sf" if (oo.ARord == _cd.__SF__) else "nf" ts = "[%(1)d-%(2)d]" % {"1": oo.t0, "2": oo.t1} baseFN = "rs=%(rs)d" % {"pr": sPR, "rs": oo.restarts} setdir = "%(sd)s/AR%(k)d_%(ts)s_%(pr)s_%(ao)s" % { "sd": oo.setname, "k": oo.k, "ts": ts, "pr": sPR, "ao": sAO } # baseFN_inter baseFN_comps baseFN_comps ############### oo.Bsmpx = _N.zeros((oo.TR, oo.NMC + oo.burn, (oo.N + 1) + 2)) oo.smp_u = _N.zeros((oo.TR, oo.burn + oo.NMC)) oo.smp_q2 = _N.zeros((oo.TR, oo.burn + oo.NMC)) oo.smp_x00 = _N.empty((oo.TR, oo.burn + oo.NMC - 1, oo.k)) # store samples of oo.allalfas = _N.empty((oo.burn + oo.NMC, oo.k), dtype=_N.complex) oo.uts = _N.empty((oo.TR, oo.burn + oo.NMC, oo.R, oo.N + 2)) oo.wts = _N.empty((oo.TR, oo.burn + oo.NMC, oo.C, oo.N + 3)) oo.ranks = _N.empty((oo.burn + oo.NMC, oo.C), dtype=_N.int) oo.pgs = _N.empty((oo.TR, oo.burn + oo.NMC, oo.N + 1)) oo.fs = _N.empty((oo.burn + oo.NMC, oo.C)) oo.amps = _N.empty((oo.burn + oo.NMC, oo.C)) if oo.bpsth: oo.smp_aS = _N.zeros((oo.burn + oo.NMC, oo.dfPSTH)) radians = buildLims(oo.Cn, oo.freq_lims, nzLimL=1.) oo.AR2lims = 2 * _N.cos(radians) if (oo.rs < 0): oo.smpx = _N.zeros( (oo.TR, (oo.N + 1) + 2, oo.k)) # start at 0 + u oo.ws = _N.empty((oo.TR, oo._d.N + 1), dtype=_N.float) oo.F_alfa_rep = initF(oo.R, oo.Cs, oo.Cn, ifs=oo.ifs).tolist() # init F_alfa_rep print "begin---" print ampAngRep(oo.F_alfa_rep) print "begin^^^" q20 = 1e-3 oo.q2 = _N.ones(oo.TR) * q20 oo.F0 = (-1 * _Npp.polyfromroots(oo.F_alfa_rep)[::-1].real)[1:] ######## Limit the amplitude to something reasonable xE, nul = createDataAR(oo.N, oo.F0, 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) if oo.model == "Bernoulli": oo.initBernoulli() #smpx[0, 2:, 0] = x[0] ########## DEBUG #### initialize ws if starting for first time if oo.TR == 1: oo.ws = oo.ws.reshape(1, oo._d.N + 1) for m in xrange(oo._d.TR): lw.rpg_devroye(oo.rn, oo.smpx[m, 2:, 0] + oo.u[m], num=(oo.N + 1), out=oo.ws[m, :]) oo.smp_u[:, 0] = oo.u oo.smp_q2[:, 0] = oo.q2 if oo.bpsth: oo.u_a = _N.ones(oo.dfPSTH) * _N.mean(oo.u)
def create(setname): global lowQs, lowQpc copyfile( "%s.py" % setname, "%(s)s/%(s)s.py" % { "s": setname, "to": setFN("%s.py" % setname, dir=setname, create=True) }) ARcoeff = _N.empty((nRhythms, 2)) for n in xrange(nRhythms): ARcoeff[n] = (-1 * _Npp.polyfromroots(alfa[n])[::-1][1:]).real V = _N.empty(N) dV = _N.empty(N) dN = _N.zeros(N) xprbsdN = _N.empty((N, 3 * TR)) isis = [] lowQs = [] spksPT = _N.empty(TR) for tr in xrange(TR): V[0] = 0.2 * _N.random.randn() eps = bcksig * _N.random.randn(N) # time series err = nzs[0, 1] if _N.random.rand() < lowQpc: err = nzs[0, 0] lowQs.append(tr) sTs = [] x, y = createDataAR(N, ARcoeff[0], err, obsnz, trim=trim) dN[:] = 0 for n in xrange(N - 1): dV[n] = -V[n] / tau + eps[n] + Is[tr] + x[n] + psth[n] V[n + 1] = V[n] + dV[n] * dt if V[n + 1] > thr: V[n + 1] = rst dN[n] = 1 sTs.append(n) spksPT[tr] = len(sTs) xprbsdN[:, tr * 3] = x xprbsdN[:, tr * 3 + 1] = V xprbsdN[:, tr * 3 + 2] = dN isis.extend(_U.toISI([sTs])[0]) fmt = "% .2e %.3f %d " * TR _N.savetxt(resFN("xprbsdN.dat", dir=setname, create=True), xprbsdN, fmt=fmt) plotWFandSpks( N - 1, dN, [x], sTitle="AR2 freq %(f).1fHz num spks %(d).0f spk Hz %(spkf).1fHz" % { "f": (500 * ths[0] / _N.pi), "d": _N.sum(dN), "spkf": (_N.sum(dN) / (N * 0.001)) }, sFilename=resFN("generative", dir=setname)) #plotWFandSpks(N-1, dN, [x], sTitle="AR2 freq %(f).1fHz num spks %(d).0f spk Hz %(spkf).1fHz" % {"f" : (500*ths[0]), "d" : _N.sum(dN), "spkf" : (_N.sum(dN) / (N*0.001))}, sFilename=resFN("generative", dir=setname)) fig = _plt.figure(figsize=(8, 4)) _plt.hist(isis, bins=range(100), color="black") _plt.grid() _plt.savefig(resFN("ISIhist", dir=setname)) _plt.close() cv = _N.std(spksPT)**2 / _N.mean(spksPT) fig = _plt.figure(figsize=(13, 4)) _plt.plot(spksPT, marker=".", color="black", ms=8) _plt.ylim(0, max(spksPT) * 1.1) _plt.grid() _plt.suptitle("avg. Hz %(hz).1f cv=%(cv).2f" % { "hz": (_N.mean(spksPT) / (N * 0.001)), "cv": cv }) _plt.savefig(resFN("spksPT", dir=setname)) _plt.close() """
def create(setname): # _plt.ioff() copyfile( "%s.py" % setname, "%(s)s/%(s)s.py" % { "s": setname, "to": setFN("%s.py" % setname, dir=setname, create=True) }) global dt, lambda2, rpsth, isis, us, csTR, etme, bGenOscUsingAR, f0VAR, f0, Bf, Ba, amp, amp_nz, dSA, dSF, psth if bGenOscUsingAR: ARcoeff = _N.empty((nRhythms, 2)) for n in xrange(nRhythms): ARcoeff[n] = (-1 * _Npp.polyfromroots(alfa[n])[::-1][1:]).real stNzs = _N.empty((TR, nRhythms)) for tr in xrange(TR): if _N.random.rand() < lowQpc: lowQs.append(tr) stNzs[tr] = nzs[:, 0] else: stNzs[tr] = nzs[:, 1] # high elif bGenOscUsingSines: if f0VAR is None: f0VAR = _N.zeros(TR) sig = 0.1 x, y = createDataAR(100000, Bf, sig, sig) stdf = _N.std( x) # choice of 4 std devs to keep phase monotonically increasing x, y = createDataAR(100000, Ba, sig, sig) stda = _N.std( x) # choice of 4 std devs to keep phase monotonically increasing # x, prbs, spks 3 columns nColumns = 3 alldat = _N.empty((N, TR * nColumns)) probNOsc = _N.empty((N, TR)) spksPT = _N.empty(TR) lowQs = [] isis = [] rpsth = [] if csTR is None: csTR = _N.ones(TR) if etme is None: etme = _N.ones((TR, N)) if us is None: us = _N.zeros(TR) elif (type(us) is float) or (type(us) is int): us = _N.zeros(TR) * us for tr in xrange(TR): if bGenOscUsingAR: #x, dN, prbs, fs, prbsNOsc = createDataPPl2(TR, N, dt, ARcoeff, psth + us[tr], stNzs[tr], lambda2=lambda2, p=1, nRhythms=nRhythms, cs=csTR[tr], etme=etme[tr]) # psth is None. Turn it off for now x, dN, prbs, fs, prbsNOsc = createDataPPl2(TR, N, dt, ARcoeff, us[tr], stNzs[tr], lambda2=lambda2, p=1, nRhythms=nRhythms, cs=csTR[tr], etme=etme[tr], offset=psth) else: xosc = createFlucOsc( f0, _N.array([f0VAR[tr]]), N, dt, 1, Bf=Bf, Ba=Ba, amp=amp, amp_nz=amp_nz, stdf=stdf, stda=stda, sig=sig, smoothKer=5, dSA=dSA, dSF=dSF ) * etme[ tr] # sig is arbitrary, but we need to keep it same as when stdf, stda measured #x, dN, prbs, fs, prbsNOsc = createDataPPl2(TR, N, dt, None, psth + us[tr], None, lambda2=lambda2, p=1, nRhythms=1, cs=csTR[tr], etme=etme[tr], x=xosc[0]) x, dN, prbs, fs, prbsNOsc = createDataPPl2(TR, N, dt, None, us[tr], None, lambda2=lambda2, p=1, nRhythms=1, cs=csTR[tr], etme=etme[tr], x=xosc, offset=psth) spksPT[tr] = _N.sum(dN) rpsth.extend(_N.where(dN == 1)[0]) alldat[:, nColumns * tr] = _N.sum(x, axis=0).T * etme[tr] * csTR[tr] alldat[:, nColumns * tr + 1] = prbs alldat[:, nColumns * tr + 2] = dN probNOsc[:, tr] = prbsNOsc isis.extend(_U.toISI([_N.where(dN == 1)[0].tolist()])[0]) savesetMT(TR, alldat, model, setname) savesetMTnosc(TR, probNOsc, setname) arfs = "" xlst = [] if bGenOscUsingAR: for nr in xrange(nRhythms): arfs += "%.1fHz " % (500 * ths[nr] / _N.pi) xlst.append(x[nr]) else: xlst.append(x[0]) sTitle = "AR2 freq %(fs)s spk Hz %(spkf).1fHz TR=%(tr)d N=%(N)d" % { "spkf": (_N.sum(spksPT) / (N * TR * 0.001)), "tr": TR, "N": N, "fs": arfs } plotWFandSpks(N - 1, dN, xlst, sTitle=sTitle, sFilename=resFN("generative", dir=setname)) fig = _plt.figure(figsize=(8, 4)) _plt.hist(isis, bins=range(100), color="black") _plt.grid() _plt.savefig(resFN("ISIhist", dir=setname)) _plt.close() fig = _plt.figure(figsize=(13, 4)) _plt.plot(spksPT, marker=".", color="black", ms=8) _plt.ylim(0, max(spksPT) * 1.1) _plt.grid() _plt.suptitle("avg. Hz %.1f" % (_N.mean(spksPT) / (N * 0.001))) _plt.savefig(resFN("spksPT", dir=setname)) _plt.close() if (lambda2 is None) and (absrefr > 0): lambda2 = _N.array([0.0001] * absrefr) if lambda2 is not None: _N.savetxt(resFN("lambda2.dat", dir=setname), lambda2, fmt="%.7f") # if we want to double bin size #lambda2db = 0.5*(lambda2[1::2] + lambda2[::2]) #_N.savetxt(resFN("lambda2db.dat", dir=setname), lambda2db, fmt="%.7f") #_plt.ion() if lowQpc > 0: _N.savetxt(resFN("lowQtrials", dir=setname), lowQs, fmt="%d")
def create(setname): global lowQs, lowQpc, f0VAR, oscCS, etme, xmultLo, updn, buff, thsVAR, a, B, Is, psthThisTrial, nPSTHs, psthTypsPc copyfile("%s.py" % setname, "%(s)s/%(s)s.py" % {"s" : setname, "to" : setFN("%s.py" % setname, dir=setname, create=True)}) if etme is None: etme = _N.ones((TR, N)) if updn is None: updn = _N.zeros((TR, N+buff)) if bGenOscUsingAR: alfa = _N.empty((TR, nRhythms, 2), dtype=_N.complex) if thsVAR is None: thsVAR = _N.zeros((TR, nRhythms)) for tr in xrange(TR): for nr in xrange(nRhythms): th = ths[nr] + thsVAR[tr, nr] alfa[tr, nr, 0] = rs[nr]*(_N.cos(th) + 1j*_N.sin(th)) alfa[tr, nr, 1] = rs[nr]*(_N.cos(th) - 1j*_N.sin(th)) ARcoeff = _N.empty((TR, nRhythms, 2)) for tr in xrange(TR): for n in xrange(nRhythms): ARcoeff[tr, n] = (-1*_Npp.polyfromroots(alfa[tr, n])[::-1][1:]).real elif bGenOscUsingSines: if f0VAR is None: f0VAR = _N.zeros(TR) sig = 0.1 x, y = createDataAR(100000, Bf, sig, sig) stdf = _N.std(x) # choice of 4 std devs to keep phase monotonically increasing x, y = createDataAR(100000, Ba, sig, sig) stda = _N.std(x) # choice of 4 std devs to keep phase monotonically increasing if oscCS is None: # coupling strength of osc. given oscCS = _N.ones(TR) V = _N.empty(N+buff) dV = _N.empty(N+buff) dN = _N.zeros(N+buff) xprbsdN= _N.empty((N, 3*TR)) isis = [] bGivenLowQs = True bGivenPSTHbyTrial = True if lowQs is None: lowQs = [] bGivenLowQs = False if (psthTypsPc is None) or (nPSTHs == 1): bGivenPSTHbyTrial = False psthThisTrial = _N.zeros(TR, dtype=_N.int) nknts = a.shape[0] else: crat = _N.zeros(len(psthTypsPc)+1) for ityp in xrange(len(psthTypsPc)): crat[ityp+1] = crat[ityp] + psthTypsPc[ityp] nknts = a.shape[1] psthThisTrial = _N.empty(TR, dtype=_N.int) for tr in xrange(TR): rnd = _N.random.rand() typ = _N.where((rnd > crat[0:-1]) & (rnd < crat[1:]))[0][0] psthThisTrial[tr] = typ spksPT= _N.empty(TR) currentsPSTH = _N.empty((N+buff, TR)) currentsOsc = _N.empty((N+buff, TR)) currentsUpDn = _N.empty((N+buff, TR)) # slow up-downs for tr in xrange(TR): V[0] = 0.1*_N.random.randn() eps = bcksig*_N.random.randn(N+buff) # time series sTs = [] if bGenOscUsingAR: err = nzs[0, 1] if not bGivenLowQs: # randomly gen. trials which are lowQs if _N.random.rand() < lowQpc: err = nzs[0, 0] lowQs.append(tr) else: try: lowQs.index(tr) err = nzs[0, 0] except ValueError: pass maxPwr = 0 for i in xrange(cand): x, y= createDataAR(N, ARcoeff[tr, 0], err, obsnz, trim=trim) x *= etme[tr] pwr = _N.sum(x**2) if pwr > maxPwr: xBest = x maxPwr = pwr elif bGenOscUsingSines: xmult = 1 if not bGivenLowQs: # randomly gen. trials which are lowQs if _N.random.rand() < lowQpc: xmult = xmultLo lowQs.append(tr) else: try: lowQs.index(tr) xmult = xmultLo except ValueError: pass x = xmult*createFlucOsc(f0, _N.array([f0VAR[tr]]), N, dt, 1, Bf=Bf, Ba=Ba, amp=amp, amp_nz=amp_nz, stdf=stdf, stda=stda, sig=sig, smoothKer=5, dSA=dSA, dSF=dSF) * etme[tr] # sig is arbitrary, but we need to keep it same as when stdf, stda measured _xBest = x[0] dN[:] = 0 _psth = _N.empty((nPSTHs, N)) psth = _N.empty((nPSTHs, N+buff)) for np in xrange(nPSTHs): if nPSTHs == 1: _psth[np] = _N.dot(B, a + aNz*_N.random.randn(nknts)) else: _N.dot(B, a[np] + aNz*_N.random.randn(nknts)) _psth[np] = _N.dot(B, a[np] + aNz*_N.random.randn(nknts)) psth[np] = _N.empty(N+buff) psth[np, 0:buff] = _psth[np, 0] psth[np, buff:] = _psth[np] xBest = _N.empty(N+buff) xBest[0:buff] = 0#_xBest[0:buff][::-1] xBest[buff:] = _xBest #etmeBUF = _N.ones((TR, N+buff)) #etmeBUF[:, buff:] = etme for n in xrange(N-1+buff): currentsPSTH[n, tr] = psth[psthThisTrial[tr], n] currentsOsc[n, tr] = xBest[n] currentsUpDn[n, tr] = updn[tr, n] dV[n] = -V[n] / tau + eps[n] + currentsPSTH[n, tr] + Is[tr] + oscCS[tr]*currentsOsc[n, tr] V[n+1] = V[n] + dV[n]*dt if V[n+1] + updn[tr, n] > thr: V[n + 1] = rst dN[n] = 1 if n > buff: sTs.append(n-buff) spksPT[tr] = len(sTs) xprbsdN[:, tr*3] = xBest[buff:] xprbsdN[:, tr*3 + 1] = V[buff:] xprbsdN[:, tr*3 + 2] = dN[buff:] isis.extend(_U.toISI([sTs])[0]) fmt = "%.3f " * TR _N.savetxt(resFN("currentsPSTH.dat", dir=setname, create=True), currentsPSTH[buff:], fmt=fmt) fmt = "%.3f " _N.savetxt(resFN("currentsIs.dat", dir=setname, create=True), Is, fmt=fmt) fmt = "%.3f " * TR _N.savetxt(resFN("currentsUpDn.dat", dir=setname, create=True), currentsUpDn[buff:], fmt=fmt) fmt = "%.3f " * TR _N.savetxt(resFN("currentsOsc.dat", dir=setname, create=True), currentsOsc[buff:], fmt=fmt) if bGivenLowQs: fmt = "%d" _N.savetxt(resFN("lowQs.dat", dir=setname, create=True), lowQs, fmt=fmt) if bGivenPSTHbyTrial: fmt = "%d" _N.savetxt(resFN("psthTyps.dat", dir=setname, create=True), psthThisTrial, fmt=fmt) fmt = "% .2e %.3f %d " * TR _N.savetxt(resFN("xprbsdN.dat", dir=setname, create=True), xprbsdN, fmt=fmt) if bGenOscUsingAR: plotWFandSpks(N-1, dN[buff:], [xBest[buff:]], sTitle="AR2 freq %(f).1fHz num spks %(d).0f spk Hz %(spkf).1fHz" % {"f" : (500*ths[0]/_N.pi), "d" : _N.sum(dN[buff:]), "spkf" : (_N.sum(dN[buff:]) / (N*0.001))}, sFilename=resFN("generative", dir=setname)) else: plotWFandSpks(N-1, dN[buff:], [xBest[buff:]], sTitle="", sFilename=resFN("generative", dir=setname)) fig = _plt.figure(figsize=(8, 4)) _plt.hist(isis, bins=range(100), color="black") _plt.grid() _plt.savefig(resFN("ISIhist", dir=setname)) _plt.close() cv = _N.std(spksPT)**2/_N.mean(spksPT) fig = _plt.figure(figsize=(13, 4)) _plt.plot(spksPT, marker=".", color="black", ms=8) _plt.ylim(0, max(spksPT)*1.1) _plt.grid() _plt.suptitle("avg. Hz %(hz).1f cv=%(cv).2f" % {"hz" : (_N.mean(spksPT) / (N*0.001)), "cv" : cv}) _plt.savefig(resFN("spksPT", dir=setname)) _plt.close() cv = _N.std(isis) / _N.mean(isis) #fig = _plt.figure(figsize=(7, 3.5)) fig, ax = _plt.subplots(figsize=(7, 8)) _plt.subplot(2, 1, 1) _plt.hist(isis, bins=range(0, 50), color="black") _plt.grid() _plt.subplot(2, 1, 2) _plt.hist(isis, bins=range(0, ISItmscl), color="black") _plt.yscale("log") _plt.grid() _plt.suptitle("ISI cv %.2f" % cv) _plt.savefig(resFN("ISIhist", dir=setname)) _plt.close()