Ctrl+K

FullProjAlignPost

FullProjAlignPost#

class brainpy.dyn.FullProjAlignPost(pre, delay, comm, syn, out, post, out_label=None, name=None, mode=None)[source]#

Full-chain synaptic projection with the align-post reduction.

The full-chain means that the model needs to provide all information needed for a projection, including pre -> delay -> comm -> syn -> out -> post.

The align-post means that the synaptic variables have the same dimension as the post-synaptic neuron group.

All align-post projection models prefer to use the event-driven computation mode. This means that the comm model should be the event-driven model.

Moreover, it’s worth noting that FullProjAlignPost has a different updating order with all align-pre projection models. The updating order of align-post projections is spikes -> comm -> syn -> out. While, the updating order of all align-pre projection models is usually spikes -> syn -> comm -> out.

To simulate and define an E/I balanced network model:

class EINet(bp.DynSysGroup):
  def __init__(self):
    super().__init__()
    ne, ni = 3200, 800
    self.E = bp.dyn.LifRef(ne, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5.,
                           V_initializer=bp.init.Normal(-55., 2.))
    self.I = bp.dyn.LifRef(ni, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5.,
                           V_initializer=bp.init.Normal(-55., 2.))
    self.E2E = bp.dyn.FullProjAlignPost(pre=self.E,
                                     delay=0.1,
                                     comm=bp.dnn.EventJitFPHomoLinear(ne, ne, prob=0.02, weight=0.6),
                                     syn=bp.dyn.Expon(size=ne, tau=5.),
                                     out=bp.dyn.COBA(E=0.),
                                     post=self.E)
    self.E2I = bp.dyn.FullProjAlignPost(pre=self.E,
                                     delay=0.1,
                                     comm=bp.dnn.EventJitFPHomoLinear(ne, ni, prob=0.02, weight=0.6),
                                     syn=bp.dyn.Expon(size=ni, tau=5.),
                                     out=bp.dyn.COBA(E=0.),
                                     post=self.I)
    self.I2E = bp.dyn.FullProjAlignPost(pre=self.I,
                                     delay=0.1,
                                     comm=bp.dnn.EventJitFPHomoLinear(ni, ne, prob=0.02, weight=6.7),
                                     syn=bp.dyn.Expon(size=ne, tau=10.),
                                     out=bp.dyn.COBA(E=-80.),
                                     post=self.E)
    self.I2I = bp.dyn.FullProjAlignPost(pre=self.I,
                                     delay=0.1,
                                     comm=bp.dnn.EventJitFPHomoLinear(ni, ni, prob=0.02, weight=6.7),
                                     syn=bp.dyn.Expon(size=ni, tau=10.),
                                     out=bp.dyn.COBA(E=-80.),
                                     post=self.I)

  def update(self, inp):
    self.E2E()
    self.E2I()
    self.I2E()
    self.I2I()
    self.E(inp)
    self.I(inp)
    return self.E.spike

model = EINet()
indices = bm.arange(1000)
spks = bm.for_loop(lambda i: model.step_run(i, 20.), indices)
bp.visualize.raster_plot(indices, spks, show=True)
Parameters:
update()[source]#

The function to specify the updating rule.

Contents