Merge pull request #124 from PKU-NIP-Lab/changes

fix DOGDecay bugs; add more features

Author: chaoming0625

brainpy/analysis/lowdim/tests/test_phase_plane.py

@@ -18,7 +18,7 @@ def int_x(x, t, Iext):
     analyzer = bp.analysis.PhasePlane1D(model=int_x,
                                         target_vars={'x': [-2, 2]},
                                         pars_update={'Iext': 0.},
-                                        resolutions=0.001)
+                                        resolutions=0.01)
 
     plt.ion()
     analyzer.plot_vector_field()
@@ -60,7 +60,7 @@ def int_s2(s2, t, s1):
     analyzer = bp.analysis.PhasePlane2D(
       model=[int_s1, int_s2],
       target_vars={'s1': [0, 1], 's2': [0, 1]},
-      resolutions=0.0005
+      resolutions=0.001
     )
     plt.ion()
     analyzer.plot_vector_field()

brainpy/base/base.py

@@ -69,6 +69,10 @@ def vars(self, method='absolute', level=-1, include_self=True):
     ----------
     method : str
       The method to access the variables.
+    level: int
+      The hierarchy level to find variables.
+    include_self: bool
+      Whether include the variables in the self.
 
     Returns
     -------
@@ -95,6 +99,10 @@ def train_vars(self, method='absolute', level=-1, include_self=True):
     ----------
     method : str
       The method to access the variables. Support 'absolute' and 'relative'.
+    level: int
+      The hierarchy level to find TrainVar instances.
+    include_self: bool
+      Whether include the TrainVar instances in the self.
 
     Returns
     -------
@@ -109,7 +117,7 @@ def _find_nodes(self, method='absolute', level=-1, include_self=True, _lid=0, _p
     if _paths is None:
       _paths = set()
     gather = Collector()
-    if (level > 0) and (_lid >= level):
+    if (level > -1) and (_lid >= level):
       return gather
     if method == 'absolute':
       nodes = []
@@ -127,7 +135,7 @@ def _find_nodes(self, method='absolute', level=-1, include_self=True, _lid=0, _p
           gather[node.name] = node
           nodes.append(node)
       for v in nodes:
-        gather.update(v._find_nodes(method=method, level=-1, _lid=_lid + 1, _paths=_paths,
+        gather.update(v._find_nodes(method=method, level=level, _lid=_lid + 1, _paths=_paths,
                                     include_self=include_self))
       if include_self: gather[self.name] = self
 
@@ -163,8 +171,10 @@ def nodes(self, method='absolute', level=-1, include_self=True):
     ----------
     method : str
       The method to access the nodes.
-    _paths : set, Optional
-      The data structure to solve the circular reference.
+    level: int
+      The hierarchy level to find nodes.
+    include_self: bool
+      Whether include the self.
 
     Returns
     -------

brainpy/base/naming.py

@@ -1,11 +1,10 @@
 # -*- coding: utf-8 -*-
 
-from brainpy import errors
-
 import logging
 
-logger = logging.getLogger('brainpy.base.naming')
+from brainpy import errors
 
+logger = logging.getLogger('brainpy.base.naming')
 
 __all__ = [
   'check_name_uniqueness',
@@ -25,11 +24,13 @@ def check_name_uniqueness(name, obj):
                               f'Please choose another name.')
   if name in _name2id:
     if _name2id[name] != id(obj):
-      raise errors.UniqueNameError(f'In BrainPy, each object should have a unique name. '
-                                   f'However, we detect that {obj} has a used name "{name}". \n\n'
-                                   f'If you try t0 run multiple trials, you may need '
-                                   f'"brainpy.base.clear_name_cache()" '
-                                   f'to clear all used names. ')
+      raise errors.UniqueNameError(
+        f'In BrainPy, each object should have a unique name. '
+        f'However, we detect that {obj} has a used name "{name}". \n'
+        f'If you try to run multiple trials, you may need \n\n'
+        f'>>> brainpy.base.clear_name_cache() \n\n'
+        f'to clear all cached names. '
+      )
   else:
     _name2id[name] = id(obj)
 

brainpy/base/tests/test_base.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+
+import unittest
+
+import brainpy as bp
+import brainpy.math as bm
+
+
+class TestCollectionFunction(unittest.TestCase):
+  def test_f_nodes(self):
+    class C(bp.dyn.DynamicalSystem):
+      def __init__(self):
+        super(C, self).__init__()
+
+    class B(bp.dyn.DynamicalSystem):
+      def __init__(self):
+        super(B, self).__init__()
+
+        self.child1 = C()
+        self.child2 = C()
+
+    class A(bp.dyn.DynamicalSystem):
+      def __init__(self):
+        super(A, self).__init__()
+
+        self.child1 = B()
+        self.child2 = B()
+
+    net = bp.dyn.Network(a1=A(), a2=A())
+    print(net.nodes(level=2))
+    self.assertTrue(len(net.nodes(level=0)) == 0)
+    self.assertTrue(len(net.nodes(level=0, include_self=False)) == 0)
+    self.assertTrue(len(net.nodes(level=1)) == (1 + 2))
+    self.assertTrue(len(net.nodes(level=1, include_self=False)) == 2)
+    self.assertTrue(len(net.nodes(level=2)) == (1 + 2 + 4))
+    self.assertTrue(len(net.nodes(level=2, include_self=False)) == (2 + 4))
+    self.assertTrue(len(net.nodes(level=3)) == (1 + 2 + 4 + 8))
+    self.assertTrue(len(net.nodes(level=3, include_self=False)) == (2 + 4 + 8))
+
+  def test_f_vars(self):
+    class C(bp.dyn.DynamicalSystem):
+      def __init__(self):
+        super(C, self).__init__()
+
+        self.var1 = bm.Variable(bm.zeros(1))
+        self.var2 = bm.Variable(bm.zeros(1))
+
+    class B(bp.dyn.DynamicalSystem):
+      def __init__(self):
+        super(B, self).__init__()
+
+        self.child1 = C()
+        self.child2 = C()
+
+        self.var1 = bm.Variable(bm.zeros(1))
+        self.var2 = bm.Variable(bm.zeros(1))
+
+    class A(bp.dyn.DynamicalSystem):
+      def __init__(self):
+        super(A, self).__init__()
+
+        self.child1 = B()
+        self.child2 = B()
+
+        self.var1 = bm.Variable(bm.zeros(1))
+        self.var2 = bm.Variable(bm.zeros(1))
+
+    net = bp.dyn.Network(a1=A(), a2=A())
+    print(net.vars(level=2))
+    self.assertTrue(len(net.vars(level=0)) == 0)
+    self.assertTrue(len(net.vars(level=0, include_self=False)) == 0)
+    self.assertTrue(len(net.vars(level=1)) == 2*2)
+    self.assertTrue(len(net.vars(level=1, include_self=False)) == 2*2)
+    self.assertTrue(len(net.vars(level=2)) == (2 + 4) * 2)
+    self.assertTrue(len(net.vars(level=2, include_self=False)) == (2 + 4) * 2)
+    self.assertTrue(len(net.vars(level=3)) == (2 + 4 + 8) * 2)
+    self.assertTrue(len(net.vars(level=3, include_self=False)) == (2 + 4 + 8) * 2)
+
+
+
+
+

brainpy/base/tests/test_collector.py

@@ -28,7 +28,7 @@ def __init__(self, pre, post, conn, delay=0., g_max=0.1, E=-75.,
     # variables
     self.t_last_pre_spike = bp.math.ones(self.size) * -1e7
     self.s = bp.math.zeros(self.size)
-    self.g = self.register_constant_delay('g', size=self.size, delay=delay)
+    self.g = bp.dyn.ConstantDelay(size=self.size, delay=delay)
 
   @bp.odeint
   def int_s(self, s, t, TT):
@@ -227,7 +227,7 @@ def __init__(self, pre, post, conn, delay=0., g_max=0.1, E=-75.,
     # variables
     self.t_last_pre_spike = bp.math.Variable(bp.math.ones(self.size) * -1e7)
     self.s = bp.math.Variable(bp.math.zeros(self.size))
-    self.g = self.register_constant_delay('g', size=self.size, delay=delay)
+    self.g = bp.dyn.ConstantDelay(size=self.size, delay=delay)
 
   @bp.odeint
   def int_s(self, s, t, TT):

brainpy/dyn/base.py

@@ -71,82 +71,6 @@ def ints(self, method='absolute'):
           gather[f'{node_path}.{k}' if node_path else k] = v
     return gather
 
-  def child_ds(self, method='absolute', include_self=False):
-    """Return the children instance of dynamical systems.
-
-    This is a shortcut function to get all children dynamical system
-    in this object. For example:
-
-    >>> import brainpy as bp
-    >>>
-    >>> class Net(bp.DynamicalSystem):
-    >>>   def __init__(self, **kwargs):
-    >>>     super(Net, self).__init__(**kwargs)
-    >>>     self.A = bp.NeuGroup(10)
-    >>>     self.B = bp.NeuGroup(20)
-    >>>
-    >>>   def update(self, _t, _dt):
-    >>>     for node in self.child_ds().values():
-    >>>        node.update(_t, _dt)
-    >>>
-    >>> net = Net()
-    >>> net.child_ds()
-    {'NeuGroup0': <brainpy.simulation.brainobjects.neuron.NeuGroup object at 0x000001ABD4FF02B0>,
-    'NeuGroup1': <brainpy.simulation.brainobjects.neuron.NeuGroup object at 0x000001ABD74E5670>}
-
-    Parameters
-    ----------
-    method : str
-      The method to access the children nodes.
-    include_self : bool
-      Whether include the self dynamical system.
-
-    Returns
-    -------
-    collector: Collector
-      A Collector includes all children systems.
-    """
-    nodes = self.nodes(method=method).subset(DynamicalSystem).unique()
-    if not include_self:
-      if method == 'absolute':
-        nodes.pop(self.name)
-      elif method == 'relative':
-        nodes.pop('')
-      else:
-        raise ValueError(f'Unknown access method: {method}')
-    return nodes
-
-  def register_constant_delay(self, key, size, delay, dtype=None):
-    """Register a constant delay, whose update method will be appended into
-    the ``self.steps`` in this host class.
-
-    Parameters
-    ----------
-    key : str
-      The delay name.
-    size : int, list of int, tuple of int
-      The delay data size.
-    delay : int, float, ndarray
-      The delay time, with the unit same with `brainpy.math.get_dt()`.
-    dtype : optional
-      The data type.
-
-    Returns
-    -------
-    delay : ConstantDelay
-        An instance of ConstantDelay.
-    """
-    if not hasattr(self, 'steps'):
-      raise ModelBuildError('Please initialize the super class first before '
-                            'registering constant_delay. \n\n'
-                            'super(YourClassName, self).__init__(**kwargs)')
-    if not key.isidentifier(): raise ValueError(f'{key} is not a valid identifier.')
-    cdelay = ConstantDelay(size=size,
-                           delay=delay,
-                           name=f'{self.name}_delay_{key}',
-                           dtype=dtype)
-    return cdelay
-
   def __call__(self, *args, **kwargs):
     """The shortcut to call ``update`` methods."""
     return self.update(*args, **kwargs)
@@ -202,7 +126,8 @@ def update(self, _t, _dt):
     In this update function, the update functions in children systems are
     iteratively called.
     """
-    for node in self.child_ds().values():
+    nodes = self.nodes(level=1, include_self=False).subset(DynamicalSystem).unique()
+    for node in nodes.values():
       node.update(_t, _dt)
 
   def __getattr__(self, item):