Skip to content

Releases: brainpy/BrainPy

Version 2.6.0

24 Mar 02:30
@chaoming0625 chaoming0625
V2.6.0
3e5dcbf
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Learn about vigilant mode.
Compare
Choose a tag to compare
Version 2.6.0 Latest
Latest

New Features

This release provides several new features, including:

  • MLIR registered operator customization interface in brainpy.math.XLACustomOp.
  • Operator customization with CuPy JIT interface.
  • Bug fixes.

What's Changed

New Contributors

Full Changelog: V2.5.0...V2.6.0

Contributors

chaoming0625, CloudyDory, and Routhleck
Assets 2
Loading

Version 2.5.0

01 Feb 07:18
@chaoming0625 chaoming0625
V2.5.0
6b6a62f
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Learn about vigilant mode.
Compare
Choose a tag to compare
Version 2.5.0

This release contains many new features and fixes. It is the first release with a mature solution for Brain Dynamics Operator Customization on both CPU and GPU platforms.

New Features

  1. Add synapse projection with Delta synapse models through brainpy.dyn.HalfProjDelta and brainpy.dyn.FullProjDelta.
  2. Add brainpy.math.exprel, and change the code in the corresponding HH neuron models to improve numerical computation accuracy. These changes can significantly improve the numerical integration accuracy of HH-like models under x32 computation.
  3. Add brainpy.reset_level() decorator so that the state resetting order can be customized by users.
  4. Add brainpy.math.ein_rearrange, brainpy.math.ein_reduce, and brainpy.math.ein_repeat functions
  5. Add brainpy.math.scan transformation.
  6. Rebase all customized operators using Taichi JIT compiler. On the CPU platform, the speed performance can be boosted ten to hundred times. On the GPU platforms, the flexibility can be greatly improved.
  7. Many bug fixes.
  8. A new version of brainpylib>=0.2.4 has been released, supporting operator customization through the Taichi compiler. The supported backends include Linux, Windows, MacOS Intel, and MacOS M1 platforms. Tutorials please see https://brainpy.readthedocs.io/en/latest/tutorial_advanced/operator_custom_with_taichi.html

What's Changed

New Contributors

Full Changelog: V2.4.6...V2.5.0

Contributors

chaoming0625, charlielam0615, and 3 other contributors
Assets 2
Loading

Version 2.4.6

11 Nov 02:43
@chaoming0625 chaoming0625
V2.4.6
92cdc40
This commit was created on GitHub.com and signed with GitHub’s verified signature. The key has expired.
GPG key ID: 4AEE18F83AFDEB23
Expired
Learn about vigilant mode.
Compare
Choose a tag to compare
Version 2.4.6

This release contains more than 130 commit updates, and has provided several new features.

New Features

1. surrogate gradient functions are more transparent.

New instances can be used to compute the surrogate gradients. For example:

import brainpy.math as bm
fun = bm.surrogate.Sigmoid()

# forward function
spk = fun(membrane_potential)

# backward function
dV = fun.surrogate_grad(1., membrane_potential)

# surrogate forward function
surro_spk = fun.surrogate_fun(membrane_potential)

2. Add brainpy.math.eval_shape for evaluating the all dynamical variables used in the target function.

This function is similar to jax.eval_shape which has no FLOPs, while it can extract all variables used in the target function. For example:

net = ...  # any dynamical system
inputs = ...  # inputs to the dynamical system
variables, outputs= bm.eval_shape(net, inputs)  
# "variables" are all variables used in the target "net"

In future, this function will be used everywhere to transform all jax transformations into brainpy's oo transformations.

3. Generalize tools and interfaces for state managements.

For a single object:

  • The .reset_state() defines the state resetting of all local variables in this node.
  • The .load_state() defines the state loading from external disks (typically, a dict is passed into this .load_state() function).
  • The .save_state() defines the state saving to external disks (typically, the .save_state() function generates a dict containing all variable values).

Here is an example to define a full class of brainpy.DynamicalSystem.

import brainpy as bp

class YouDynSys(bp.DynamicalSystem):
   def __init__(self, ):  # define parameters
      self.par1 = ....
      self.num = ...

  def reset_state(self, batch_or_mode=None):  # define variables
     self.a = bp.init.variable_(bm.zeros, (self.num,), batch_or_mode)

  def load_state(self, state_dict):  # load states from an external dict
     self.a.value = bm.as_jax(state_dict['a'])

  def save_state(self):  # save states as an external dict
     return {'a': self.a.value}

For a complex network model, brainpy provide unified state managment interface for initializing, saving, and loading states.

  • The brainpy.reset_state() defines the state resetting of all variables in this node and its children nodes.
  • The brainpy.load_state() defines the state loading from external disks of all variables in the node and its children.
  • The brainpy.save_state() defines the state saving to external disks of all variables in the node and its children.
  • The brainpy.clear_input() defines the clearing of all input variables in the node and its children.

4. Unified brain simulation and brain-inspired computing interface through automatic membrane scaling.

The same model used in brain simulation can be easily transformed into the one used for brain-inspired computing for training. For example,

class EINet(bp.DynSysGroup):
  def __init__(self):
    super().__init__()
    self.N = bp.dyn.LifRefLTC(4000, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5.,
                              V_initializer=bp.init.Normal(-55., 2.))
    self.delay = bp.VarDelay(self.N.spike, entries={'I': None})
    self.E = bp.dyn.ProjAlignPost1(
      comm=bp.dnn.EventCSRLinear(bp.conn.FixedProb(0.02, pre=3200, post=4000), weight=bp.init.Normal(0.6, 0.01)),
      syn=bp.dyn.Expon(size=4000, tau=5.),
      out=bp.dyn.COBA(E=0.),
      post=self.N
    )
    self.I = bp.dyn.ProjAlignPost1(
      comm=bp.dnn.EventCSRLinear(bp.conn.FixedProb(0.02, pre=800, post=4000), weight=bp.init.Normal(6.7, 0.01)),
      syn=bp.dyn.Expon(size=4000, tau=10.),
      out=bp.dyn.COBA(E=-80.),
      post=self.N
    )

  def update(self, input):
    spk = self.delay.at('I')
    self.E(spk[:3200])
    self.I(spk[3200:])
    self.delay(self.N(input))
    return self.N.spike.value


# used for brain simulation
with bm.environment(mode=bm.nonbatching_mode):
  net = EINet()


# used for brain-inspired computing
# define the `membrane_scaling` parameter
with bm.environment(mode=bm.TrainingMode(128), membrane_scaling=bm.Scaling.transform([-60., -50.])):
  net = EINet()

5. New apis for operator customization on CPU and GPU devices through brainpy.math.XLACustomOp.

Starting from this release, brainpy introduces Taichi for operator customization. Now, users can write CPU and GPU operators through numba and taichi syntax on CPU device, and taichi syntax on GPu device. Particularly, to define an operator, user can use:

import numba as nb
import taichi as ti
import numpy as np
import jax
import brainpy.math as bm


@nb.njit
def numba_cpu_fun(a, b, out_a, out_b):
  out_a[:] = a
  out_b[:] = b


@ti.kernel
def taichi_gpu_fun(a, b, out_a, out_b):
  for i in range(a.size):
    out_a[i] = a[i]
  for i in range(b.size):
    out_b[i] = b[i]


prim = bm.XLACustomOp(cpu_kernel=numba_cpu_fun, gpu_kernel=taichi_gpu_fun)
a2, b2 = prim(np.random.random(1000), np.random.random(1000),
              outs=[jax.ShapeDtypeStruct(1000, dtype=np.float32),
                    jax.ShapeDtypeStruct(1000, dtype=np.float32)])

6. Generalized STDP models which are compatible with diverse synapse models.

See https://github.com/brainpy/BrainPy/blob/master/brainpy/_src/dyn/projections/tests/test_STDP.py

What's Changed

New Contributors

Full Changelog: V2.4.5...V2.4.6

Contributors

chaoming0625, HoshinoKoji, and 2 other contributors
Assets 2
Loading

Version 2.4.5

18 Sep 07:21
@chaoming0625 chaoming0625
V2.4.5
11e75e5
Compare
Choose a tag to compare
Version 2.4.5

New Features

  • A new version of brainpylib==0.1.10 has been released. In this release, we have fixed some bugs of brainpy dedicated GPU operators. Users can freely use them in any application.
  • Correspondingly, dedicated operators in brainpy.math have been refined.
  • .tracing_variable() has been created to support tracing Variables during computations and compilations. Example usage please see #472
  • Add a new random API for creating multiple random keys: brainpy.math.random.split_keys().
  • Fix bugs, including
    • brainpy.dnn.AllToAll module
    • RandomState.
    • brainpy.math.cond and brainpy.math.while_loop when variables are used in both branches

What's Changed

New Contributors

Full Changelog: V2.4.4...V2.4.5

Contributors

chaoming0625, dependabot, and 3 other contributors
Assets 2
Loading

Version 2.4.4

26 Aug 05:22
@chaoming0625 chaoming0625
V2.4.4
57ce2bc
Compare
Choose a tag to compare
Version 2.4.4

This release has fixed several bugs and updated the sustainable documentation.

What's Changed

New Contributors

Full Changelog: V2.4.3...V2.4.4

Contributors

chaoming0625, ztqakita, and 3 other contributors
Assets 2
Loading

Version 2.4.3

23 Jul 02:33
@chaoming0625 chaoming0625
V2.4.3
53ed70b
This commit was created on GitHub.com and signed with GitHub’s verified signature. The key has expired.
GPG key ID: 4AEE18F83AFDEB23
Expired
Learn about vigilant mode.
Compare
Choose a tag to compare
Version 2.4.3

This release has standardized the modeling of DNN and SNN models by two intercorrelated packages: brainpy.dnn and brainpy.dyn.

Overall, the modeling of brain dynamics in this release has the following advantages:

  • the automatic merging of the duplicate synapses, keeping the minimal device memory
  • easy model and data parallelization across multiple devices
  • easy integration with artificial neural networks
  • a new abstraction that decouples dynamics from communication
  • the unified DynamicalSystem interface

New Features

  1. Support to define ion channel models which rely on multiple ions. For example,
class HH(bp.dyn.CondNeuGroup):
   def __init__(self, size):
      super().__init__(size)
      self.k = bp.dyn.PotassiumFixed(size)
      self.ca = bp.dyn.CalciumFirstOrder(size)

      self.kca = bp.dyn.mix_ions(self.k, self.ca)  # Ion that mixing Potassium and Calcium
      self.kca.add_elem(ahp=bp.dyn.IAHP_De1994v2(size))  # channel that relies on both Potassium and Calcium
  1. New style .update() function in brainpy.DynamicalSystem which resolves all compatible issues. Starting from this version, all update() no longer needs to receive a global shared argument such as tdi.
class YourDynSys(bp.DynamicalSystem):
  def update(self, x):
    t = bp.share['t']
    dt = bp.share['dt']
    i = bp.share['i']
    ...

  1. Optimize the connection-building process when using brainpy.conn.ScaleFreeBA, brainpy.conn.ScaleFreeBADual, brainpy.conn.PowerLaw

  2. New dual exponential model brainpy.dyn.DualExponV2 can be aligned with post dimension.

  3. More synaptic projection abstractions, including

    • brainpy.dyn.VanillaProj
    • brainpy.dyn.ProjAlignPostMg1
    • brainpy.dyn.ProjAlignPostMg2
    • brainpy.dyn.ProjAlignPost1
    • brainpy.dyn.ProjAlignPost2
    • brainpy.dyn.ProjAlignPreMg1
    • brainpy.dyn.ProjAlignPreMg2

  4. Fix compatible issues, fix unexpected bugs, and improve the model tests.

What's Changed

New Contributors

Full Changelog: V2.4.2...V2.4.3

Contributors

chaoming0625, Routhleck, and yygf123
Assets 2
Loading

Version 2.4.2

27 Jun 09:00
@ztqakita ztqakita
V2.4.2
9c43971
This commit was created on GitHub.com and signed with GitHub’s verified signature. The key has expired.
GPG key ID: 4AEE18F83AFDEB23
Expired
Learn about vigilant mode.
Compare
Choose a tag to compare
Version 2.4.2

We are very excited to release this new version of BrainPy V2.4.2. In this new update, we cover several exciting features:

New Features

  • Reorganize the model to decouple dynamics and communication.
  • Add brainpy.dyn for dynamics models and brainpy.dnn for the ANN layer and connection structures.
  • Supplement many docs for dedicated operators and common bugs of BrainPy.
  • Fix many bugs.

What's Changed

New Contributors

Full Changelog: V2.4.1...V2.4.2

Contributors

chaoming0625, shangyangli, and 3 other contributors
Assets 2
Loading

Version 2.4.1

24 May 10:03
@chaoming0625 chaoming0625
V2.4.1
fc6d657
This commit was created on GitHub.com and signed with GitHub’s verified signature. The key has expired.
GPG key ID: 4AEE18F83AFDEB23
Expired
Learn about vigilant mode.
Compare
Choose a tag to compare
Version 2.4.1

New Features

  1. [math] Support the error report when modifying a brainpy.math.Array during compilation
  2. [math] add brainpy.math.event, brainpy.math.sparse and brainpy.math.jitconn module, needs brainpylib >= 0.1.9
  3. [interoperation] add apis and docs for brainpy.layers.FromFlax and brainpy.layer.ToFlaxRNNCell
  4. [fix] Bug fixes:
    • fix WilsonCowan bug
    • fix brainpy.connect.FixedProb bug
    • fix analysis jit bug

What's Changed

New Contributors

Full Changelog: V2.4.0...V2.4.1

Contributors

chaoming0625, grysgreat, and Routhleck
Assets 2
Loading

Version 2.4.0

15 Apr 13:46
@chaoming0625 chaoming0625
V2.4.0
dd238fc
This commit was created on GitHub.com and signed with GitHub’s verified signature. The key has expired.
GPG key ID: 4AEE18F83AFDEB23
Expired
Learn about vigilant mode.
Compare
Choose a tag to compare
Version 2.4.0

This branch of releases (brainpy==2.4.x) are going to support the large-scale modeling for brain dynamics.

As the start, this release provides support for automatic object-oriented (OO) transformations.

What's New

  1. Automatic OO transformations on longer need to take dyn_vars or child_objs information.
    These transformations are capable of automatically inferring the underlying dynamical variables.
    Specifically, they include:

    • brainpy.math.grad and other autograd functionalities
    • brainpy.math.jit
    • brainpy.math.for_loop
    • brainpy.math.while_loop
    • brainpy.math.ifelse
    • brainpy.math.cond

  2. Update documentation

  3. Fix several bugs

What's Changed

  • reorganize operators in brainpy.math by @chaoming0625 in #357
  • Automatic transformations any function/object using brainpy.math.Variable by @chaoming0625 in #358
  • New OO transforms support jax.disable_jit mode by @chaoming0625 in #359
  • [oo transform] Enable new style of jit transformation to support static_argnums and static_argnames by @chaoming0625 in #360
  • [documentation] update documentation to brainpy>=2.4.0 by @chaoming0625 in #361

Full Changelog: V2.3.8...V2.4.0

Contributors

chaoming0625
Assets 2
Loading

Version 2.3.8

08 Apr 07:32
@chaoming0625 chaoming0625
V2.3.8
c0c7910
This commit was created on GitHub.com and signed with GitHub’s verified signature. The key has expired.
GPG key ID: 4AEE18F83AFDEB23
Expired
Learn about vigilant mode.
Compare
Choose a tag to compare
Version 2.3.8

This release continues to add support for improving the usability of BrainPy.

New Features

  1. New data structures for object-oriented transformations.
    • NodeList and NodeDict for a list/tuple/dict of BrainPyObject instances.
    • ListVar and DictVar for a list/tuple/dict of brainpy data.
  2. Clip transformation for brainpy initializers.
  3. All brainpylib operators are accessible in brainpy.math module. Especially there are some dedicated operators for scaling up the million-level neuron networks. For an example, see example in Simulating 1-million-neuron networks with 1GB GPU memory
  4. Enable monitoring GPU models on CPU when setting DSRunner(..., memory_efficient=True). This setting can usually reduce so much memory usage.
  5. brainpylib wheels on the Linux platform support the GPU operators. Users can install GPU version of brainpylib (require brainpylib>=0.1.7) directly by pip install brainpylib. @ztqakita

What's Changed

Full Changelog: V2.3.7...V2.3.8

Contributors

chaoming0625 and ztqakita
Assets 2
Loading