コード例 #1
0
ファイル: learn.py プロジェクト: dunovank/bsac
def di_lca(Id=3.5, Ii=3, dt=.005, si=2.5, tau=.05, ntrials=10, tmax=3.0, w=-.2, k=.93, rmax=70, b=35, g=15):
    """
    tau:       time constant (cf NMDA receptors)
    k:         leak (0<k<1) | rec. excitation (1<k<~2)
    w:         strength of cross-inhibition

    rmax:      max rate of cells
    b:         input needed for 1/2-max firing
    g:         determines steepness of sigmoidal f-I curve
    """

    timepoints = np.arange(0, tmax, dt)
    rd = np.zeros(len(timepoints))
    ri = np.zeros(len(timepoints))
    rd[0] = .01
    ri[0] = 3

    Ed = si * np.sqrt(dt / tau) * rs(len(rd))
    Ei = si * np.sqrt(dt / tau) * rs(len(ri))

    NInput = lambda x, r: rmax / (1 + np.exp(-(x - b) / g)) - r

    for i in timepoints:
        rd[i] = rd[i-1] + dt/tau * NInput(Id + k*rd[i-1] - w*ri[i-1], rd[i-1]) + Ed[i]
        ri[i] = ri[i-1] + dt/tau * NInput(Ii + k*ri[i-1] - w*rd[i-1], ri[i-1]) + Ei[i]

    return rd, ri
コード例 #2
0
def LCA_Model(I1=10,
              I2=8,
              I0=2,
              k=5,
              B=5,
              si=1.,
              Z=1,
              dt=.01,
              tau=.1,
              tmax=1.5):

    timepoints = np.arange(0, tmax, dt)
    ntime = timepoints.size

    y1 = np.zeros(ntime)
    y2 = np.zeros(ntime)
    dx = np.sqrt(si * dt / tau)

    E1 = si * np.sqrt(dt / tau) * rs(ntime)
    E2 = si * np.sqrt(dt / tau) * rs(ntime)

    onset = 100
    for i in range(onset, ntime):
        y1[i] = y1[i - 1] + (I1 + -k * y1[i - 1] +
                             -B * y2[i - 1]) * dt / tau + E1[i]
        y2[i] = y2[i - 1] + (I2 + -k * y2[i - 1] +
                             -B * y1[i - 1]) * dt / tau + E2[i]
        y_t = np.array([y1[i], y2[i]])

        if np.any(y_t >= Z):
            rt = i
            act = np.argmax(y_t)
            return y1[:i], y2[:i], rt, act
    return y1[:i], y2[:i], np.nan, np.nan
コード例 #3
0
ファイル: multirace.py プロジェクト: dunovank/radd_kd
def simulate_dpm(p, pc_map={'vd':['vd_early', 'vd_late', 'vd_uniform'], 'vi': ['vi_early', 'vi_late', 'vi_uniform']}, dt=.001, si=.1, tb=.65, ssd=None, sso=0, single_process=False, return_di=False):

    nlevels = len(pc_map.values()[0])
    dx=si*np.sqrt(dt)
    p = vectorize_params(p, pc_map=pc_map, nresp=nlevels)
    Tg = np.ceil((tb-p['tr'])/dt).astype(int)
    xtb = temporal_dynamics(p, np.cumsum([dt]*Tg.max()))

    if single_process:
        Pg = 0.5*(1 + (p['vd']-p['vi'])*dx/si)
        DVg = xtb[0] * np.cumsum(np.where((rs((nlevels, Tg.max())).T < Pg), dx, -dx).T, axis=1)
    else:
        Pd = 0.5*(1 + p['vd']*dx/si)
        Pi = 0.5*(1 + p['vi']*dx/si)
        direct = np.where((rs((nlevels, Tg.max())).T < Pd),dx,-dx).T
        indirect = np.where((rs((nlevels, Tg.max())).T < Pi),dx,-dx).T
        DVg = xtb[0] * np.cumsum(direct-indirect, axis=1)

    if ssd is not None:
        if 'sso' in list(p):
            sso = p['sso']
        Ps = 0.5 * (1 + p['ssv'] * dx / si)
        Ts = np.ceil((tb - (ssd + sso)) / dt).astype(int)
        ss_on = np.where(Ts<Tg, Tg-Ts, 0)
        ssBase = DVg[np.arange(nlevels), ss_on[:, None]][:, :, None]
        # add ssBaseline to SS traces (nlevels, nSSD, ntrials_perssd, ntimepoints)
        DVs = ssBase + np.cumsum(np.where(rs((nlevels, 1, Ts.max())) < Ps, dx, -dx), axis=2)
        return [DVg, DVs]
    return DVg
コード例 #4
0
ファイル: models.py プロジェクト: CoAxLab/radd
 def __update_rand_vectors__(self):
     """ update rvector (random_floats) for Go and Stop traces
     """
     nl, ntot, nTime = self.nlevels, self.ntot, self.ntime
     self.xtime = csum([self.dt] * nTime)
     self.rvector = rs((nl, ntot, nTime))
     if self.include_ss:
         ssd, nssd, nss, nss_per, ssd_ix = self.ssd_info
         self.rvector_ss = rs((nl, nssd, nss_per, nTime))
コード例 #5
0
ファイル: models.py プロジェクト: dunovank/radd_kd
 def __update_rand_vectors__(self):
     """ update rvector (random_floats) for Go and Stop traces
     """
     nl, ntot, ntime = self.nlevels, self.ntot, self.ntime
     self.rvector = rs((nl, ntot, ntime))
     if self.include_ss:
         ssd, nssd, nss, nss_per, ssd_ix = self.ssd_info
         self.rvector_ss=self.rvector[:, :nss, :].reshape(nl, nssd, nss_per, ntime)
コード例 #6
0
def attractor_network(I1=6,
                      I2=3,
                      I0=2,
                      k=.85,
                      B=.28,
                      si=.3,
                      rmax=50,
                      b=30,
                      g=9,
                      Z=20,
                      dt=.001,
                      tau=.05,
                      tmax=1.5):

    timepoints = np.arange(0, tmax, dt)
    ntime = timepoints.size

    r1 = np.zeros(ntime)
    r2 = np.zeros(ntime)
    dv = np.zeros(ntime)

    NInput = lambda x, r: rmax / (1 + np.exp(-(x - b) / g)) - r
    dspace = lambda r1, r2: (r1 - r2) / np.sqrt(2)

    E1 = si * np.sqrt(dt / tau) * rs(ntime)
    E2 = si * np.sqrt(dt / tau) * rs(ntime)

    onset = 100
    r1[:onset], r2[:onset] = [
        v[0][:onset] + I0 + v[1][:onset] for v in [[r1, E1], [r2, E2]]
    ]

    subZ = True
    for i in range(onset, ntime):
        r1[i] = r1[i - 1] + dt / tau * (NInput(
            I1 + I0 + k * r1[i - 1] + -B * r2[i - 1], r1[i - 1])) + E1[i]
        r2[i] = r2[i - 1] + dt / tau * (NInput(
            I2 + I0 + k * r2[i - 1] + -B * r1[i - 1], r2[i - 1])) + E2[i]
        dv[i] = (r1[i] - r2[i]) / np.sqrt(2)
        if np.abs(dv[i]) >= Z:
            rt = i + 1
            return r1[:i + 1], r2[:i + 1], dv[:i + 1], rt
    rt = i + 1
    return r1[:i], r2[:i], dv[:i], rt
コード例 #7
0
ファイル: lca.py プロジェクト: dunovank/bsac
def decision_network(Id=3.5, Ii=3.5, Io=3., wdi=.22, wid=.22, k=.85, si=2.3, dt=.001, tau=.05, tmax=1.5, rmax=70, b=35, g=15, ntrials=10, y=1, Z=20, IoMax=4.5):

    timepoints = np.arange(0, tmax, dt)
    ntp = len(timepoints)

    rd = np.zeros(ntp)
    ri = np.zeros(ntp)
    dv = np.zeros(ntp)

    NInput = lambda x, r: rmax / (1 + np.exp(-(x - b) / g)) - r
    dspace = lambda rd, ri: (rd - ri) / np.sqrt(2)

    Ed = si * np.sqrt(dt / tau) * rs(ntp)
    Ei = si * np.sqrt(dt / tau) * rs(ntp)
    x = 200
    rd[:x], ri[:x] = [v[0][:x] + Io + v[1][:x] for v in [[rd, Ed], [ri, Ei]]]

    subZ = True
    IIi, IId = [deepcopy(ii) for ii in [Id, Ii]]
    for i in xrange(x, ntp):

        rd[i] = rd[i - 1] + dt / tau * \
            (NInput(Id + y * Io + k * rd[i - 1] + -
                    wid * ri[i - 1], rd[i - 1])) + Ed[i]
        ri[i] = ri[i - 1] + dt / tau * \
            (NInput(Ii + y * Io + k * ri[i - 1] + -
                    wdi * rd[i - 1], ri[i - 1])) + Ei[i]

        if dv[i - 1] < Z and subZ:
            dv[i] = dspace(rd[i - 1], ri[i - 1])
        elif subZ:
            Id, Ii, Io = -Id * Io, -Ii * Io, Io
            wdi, wid = 0, 0
            NInput = lambda x, r: Io / (1 + np.exp(-(x - b) / g)) - r - IoMax
            subZ = False
        elif not subZ and rd[i] < (IoMax + 1):
            x = len(rd[i:])
            rd0 = hs(rd[:200].tolist() * 3)
            ri0 = hs(ri[:200].tolist() * 3)
            rd, ri = hs([rd[:i], rd0]), hs([ri[:i], ri0])
            break

    return rd, ri, dv[:dv[dv < Z].argmax()]
コード例 #8
0
ファイル: learn.py プロジェクト: dunovank/bsac
def di_decision(p):

    #p = vectorize_params(p, pc_map=pc_map, ncond=nc)

    Pd = 0.5 * (1 + p['vd'] * dx / si)
    Pi = 0.5 * (1 + p['vi'] * dx / si)

    Tex = np.ceil((tb - p['tr']) / dt).astype(int)
    #state = np.where(rs(ntot)>.5, 'l', 'r')
    #state=np.sort(state)

    Pd, Pi, Tex = update_execution(p)
    direct = np.where((rs((nc, Tex.max())).T < Pd), dx, -dx).T
    indirect = np.where((rs((nc, Tex.max())).T < Pi), dx, -dx).T
    execution = np.cumsum(direct - indirect, axis=1)

    choice = np.nan
    while np.isnan(choice):
        choice, p = analyze_execution(execution, p)

    return int(choice)
コード例 #9
0
ファイル: multirace.py プロジェクト: CoAxLab/radd
def simulate_multirace(p, pcmap={'vd': ['vd_a', 'vd_b', 'vd_c', 'vd_d'], 'vi': ['vi_a', 'vi_b', 'vi_c', 'vi_d']}, dt=.001, si=.01, tb=.9, single_process=0, return_di=False):

    nresp = len(pcmap.values()[0])
    dx = si * np.sqrt(dt)
    p = vectorize_params(p, pcmap=pcmap, nresp=nresp)

    Tex = np.ceil((tb-p['tr'])/dt).astype(int)
    xtb = temporal_dynamics(p, np.cumsum([dt]*Tex.max()))

    if single_process:
        Pe = 0.5*(1 + (p['vd']-p['vi'])*dx/si)
        execution = xtb * np.cumsum(np.where((rs((nresp, Tex.max())).T < Pe), dx, -dx).T, axis=1)
    else:
        Pd = 0.5 * (1 + p['vd'] * dx / si)
        Pi = 0.5 * (1 + p['vi'] * dx / si)
        direct = xtb * np.where((rs((nresp, Tex.max())).T < Pd),dx,-dx).T
        indirect = np.where((rs((nresp, Tex.max())).T < Pi),dx,-dx).T
        execution = np.cumsum(direct-indirect, axis=1)
        if return_di:
            return np.cumsum(direct, axis=1), np.cumsum(indirect, axis=1), execution
    return execution
コード例 #10
0
ファイル: learn.py プロジェクト: dunovank/bsac
def simulate_learning(p, pc_map={'vd': ['vd_e', 'vd_u', 'vd_l'], 'vi': ['vi_e', 'vi_u', 'vi_l']}, nc=3, lr=array([.4, .3]), nssd=5, dt=.001, si=.1, ntot=1000, tb=.3):

    dx = np.sqrt(si * dt)
    p = vectorize_params(p, pc_map=pc_map, ncond=nc)

    Pd, Pi, Tex = update_execution(p)
    t = np.cumsum([dt] * Tex.max())
    xtb = temporal_dynamics(p, t)

    #Ph, Th = update_brake(p)
    #ss_index = [np.where(Th<Tex[c],Tex[c]-Th,0) for c in range(nc)]

    rts, vd, vi = [], [], []
    for i in xrange(ntot):

        Pd, Pi, Tex = update_execution(p)
        direct = np.where((rs((nc, Tex.max())).T < Pd), dx, -dx).T
        indirect = np.where((rs((nc, Tex.max())).T < Pi), dx, -dx).T
        execution = np.cumsum(direct + indirect, axis=1)

        # if i<=int(.5*ntot):
        #      init_ss = array([[execution[c,ix] for ix in ss_index] for c in range(nc)])
        #      hyper = init_ss[:,:,:,None]+np.cumsum(np.where(rs(Th.max())<Ph, dx, -dx), axis=1)
        r = np.argmax((execution.T >= p['a']).T, axis=1) * dt
        rt = p['tr'] + (r * np.where(r == 0, np.nan, 1))
        resp = np.where(rt < tb, 1, 0)

        # find conditions where response was recorded
        for ci in np.where(~np.isnan(rt))[0]:
            p['vd'][ci] = p['vd'][ci] + p['vd'][ci] * (lr[0] * (rt[ci] - .500))
            p['vi'][ci] = p['vi'][ci] - p['vi'][ci] * (lr[1] * (rt[ci] - .500))

        vd.append(deepcopy(p['vd']))
        vi.append(deepcopy(p['vi']))
        rts.append(rt)

    vd = np.asarray(vd)
    vi = np.asarray(vi)
    rts = np.asarray(rts)
コード例 #11
0
def simulate_multirace(p, dt=.001, si=.1, tb=1.5, singleProcess=False):

    temporal_dynamics = lambda p, t: np.cosh(p['xb'] * t)

    nresp = p['vd'].size
    dx = si * np.sqrt(dt)

    nTime = np.ceil((tb - p['tr']) / dt).astype(int)
    xtb = temporal_dynamics(p, np.cumsum([dt] * nTime))

    if singleProcess:
        Pdelta = .5 * (1 + ((p['vd'] - p['vi']) * np.sqrt(dt)) / si)
        execution = xtb * np.cumsum(np.where((rs(
            (nresp, nTime)).T < Pdelta), dx, -dx).T,
                                    axis=1)
    else:
        Pd = .5 * (1 + (p['vd'] * np.sqrt(dt)) / si)
        Pi = .5 * (1 + (p['vi'] * np.sqrt(dt)) / si)
        direct = xtb * np.where((rs((nresp, nTime)).T < Pd), dx, -dx).T
        indirect = np.where((rs((nresp, nTime)).T < Pi), dx, -dx).T
        execution = np.cumsum(direct - indirect, axis=1)

    act_ix, rt, rt_ix = analyze_multiresponse(execution, p, dt=dt)
    return act_ix, rt, rt_ix
コード例 #12
0
ファイル: models.py プロジェクト: dunovank/radd_kd
    def simulate_rldpm(self, p, analyze=True):
        """ Simulate the dependent process model (DPM)
        with learning
        """
        p = self.vectorize_params(p)
        Pg, xtb, Ps, ss_on = self.__update_go_process__(p)
        nl, ntot, dx = self.nlevels, self.ntot, self.dx
        ssd, nssd, nss, nss_per, ssd_ix = self.ssd_info

        for trial in xrange(ntot):
            DVg = xtb[:, na] * csum(np.where(self.rvector[:, trial, :].T < Pg, dx, -dx).T, axis=2)
            # INITIALIZE DVs FROM DVg(t=SSD)
            if trial%2:
                DVg[:, ]
                ssBase = ssDVg[np.arange(nl)[:,na], ssd, :, ss_on][:,:,:,na]
                DVs = ssBase + csum(np.where(self.rvector_ss.T < Ps, dx, -dx).T, axis=3)
                #ssBase = DVg[np.arange(nl)[:,na], ssd_ix, :, ss_on][:,:,:,na]
                #DVs = init_ss[:,:,na] + csum(np.where(rs((nss, Ts.max()))<Ps, dx, -dx), axis=1)
                DVs = csum(np.where(rs((nl, Ts.max()))<Ps, dx, -dx), axis=1)
        if analyze:
            return self.analyze_fx(DVg, DVs, p)
        return [DVg, DVs]
コード例 #13
0
ファイル: learn.py プロジェクト: dunovank/bsac
def rew_func(rprob):
    if rs() < rprob:
        return 1
    else:
        return 0
コード例 #14
0
 def random(self, shape):
     if type(shape) not in (int, tuple):
         exit('Int or tuple expected for shape.')
     return rs(shape)
コード例 #15
0
ファイル: main.py プロジェクト: fblasutt/py_mar
if __name__ == '__main__':

    #Build  data moments and pickle them
    dat_moments(period=1, sampling_number=4, transform=2)  # refresh

    #Initialize the file with parameters

    lb, ub, x0, keys, translator = calibration_params(
    )  # bounds are set in a separate file

    ##### FIRST LET'S TRY TO RUN THE FUNCTION IN FEW POINTS

    print('Testing the workers...')
    from p_client import compute_for_values
    pts = [lb + rs(lb.shape) * (ub - lb) for _ in range(1)]
    pts = [('compute', translator(x)) for x in pts]
    outs = compute_for_values(pts, timeout=72000.0)
    print('Everything worked, output is {}'.format(outs))

    print('')
    print('')
    print('running tic tac...')
    print('')
    print('')

    #Tik Tak Optimization
    param = tiktak(N=2000, N_st=50, skip_local=False, skip_global=False)

    print('f is {} and x is {}'.format(param[0], param[1]))
コード例 #16
0
start = default_timer()
tic = default_timer()

time_abort = 7200.0  # time when the worker stops, in seconds

while True:
    toc = default_timer()
    if toc - start > time_abort: break

    if toc - tic > 5.0:
        gc.collect()  # runs garbage collection
        print('I am ok, running for {:.1f} min, memory used is {}'.format(
            (toc - start) / 60, get_mem()))
        tic = toc

    sleep(rs())  # sleep random number of seconds

    li_txt = [
        f for f in listdir('Job') if f.endswith('.pkl') and f.startswith('in')
    ]

    num_in = len(li_txt)

    if num_in == 0: continue

    getnum = lambda x: int(find_between(x, 'in', '.pkl'))

    try:
        rnum = ri(1 + (num_in // 2))
        fname = li_txt[rnum]
        num = getnum(fname)