update advanced tutorials

Author: chaoming0625

brainpy/algorithms/offline.py

@@ -149,16 +149,16 @@ def cond_fun(a):
                             i < self.max_iter).value
 
     def body_fun(a):
-      i, par_old, par_new = a
+      i, _, par_new = a
       # Gradient of regularization loss w.r.t w
-      y_pred = inputs.dot(par_old)
+      y_pred = inputs.dot(par_new)
       grad_w = bm.dot(inputs.T, -(targets - y_pred)) + self.regularizer.grad(par_new)
       # Update the weights
       par_new2 = par_new - self.learning_rate * grad_w
       return i + 1, par_new, par_new2
 
     # Tune parameters for n iterations
-    r = while_loop(cond_fun, body_fun, (0, w, w + 1e-8))
+    r = while_loop(cond_fun, body_fun, (0, w - 1e-8, w))
     return r[-1]
 
   def predict(self, W, X):

brainpy/math/operators/op_register.py

@@ -94,9 +94,9 @@ def __call__(self, *args, **kwargs):
 
 
 def register_op(
-    op_name: str,
+    name: str,
+    eval_shape: Union[Callable, ShapedArray, Sequence[ShapedArray]],
     cpu_func: Callable,
-    out_shapes: Union[Callable, ShapedArray, Sequence[ShapedArray]],
     gpu_func: Callable = None,
     apply_cpu_func_to_gpu: bool = False
 ):
@@ -105,13 +105,13 @@ def register_op(
 
   Parameters
   ----------
-  op_name: str
+  name: str
     Name of the operators.
   cpu_func: Callble
     A callable numba-jitted function or pure function (can be lambda function) running on CPU.
   gpu_func: Callable, default = None
     A callable cuda-jitted kernel running on GPU.
-  out_shapes: Callable, ShapedArray, Sequence[ShapedArray], default = None
+  eval_shape: Callable, ShapedArray, Sequence[ShapedArray], default = None
     Outputs shapes of target function. `out_shapes` can be a `ShapedArray` or
     a sequence of `ShapedArray`. If it is a function, it takes as input the argument
     shapes and dtypes and should return correct output shapes of `ShapedArray`.
@@ -123,10 +123,10 @@ def register_op(
   A jitable JAX function.
   """
   _check_brainpylib(register_op.__name__)
-  f = brainpylib.register_op(op_name,
+  f = brainpylib.register_op(name,
                              cpu_func=cpu_func,
                              gpu_func=gpu_func,
-                             out_shapes=out_shapes,
+                             out_shapes=eval_shape,
                              apply_cpu_func_to_gpu=apply_cpu_func_to_gpu)
 
   def fixed_op(*inputs):

brainpy/math/operators/tests/test_op_register.py

@@ -23,7 +23,7 @@ def event_sum_op(outs, ins):
         outs[index] += v
 
 
-event_sum = bm.register_op(op_name='event_sum', cpu_func=event_sum_op, out_shapes=abs_eval)
+event_sum = bm.register_op(name='event_sum', cpu_func=event_sum_op, eval_shape=abs_eval)
 event_sum = bm.jit(event_sum)
 
 

docs/index.rst

@@ -77,11 +77,10 @@ The code of BrainPy is open-sourced at GitHub:
    :caption: Advanced Tutorials
 
    tutorial_advanced/variables
-   tutorial_advanced/base
+   tutorial_advanced/base_and_collector
    tutorial_advanced/compilation
    tutorial_advanced/differentiation
-   tutorial_advanced/control_flows
-   tutorial_advanced/low-level_operator_customization
+   tutorial_advanced/operator_customization
    tutorial_advanced/interoperation
 
 

docs/tutorial_advanced/base.ipynb renamed to docs/tutorial_advanced/base_and_collector.ipynb

@@ -9,7 +9,7 @@
     }
    },
    "source": [
-    "# Base Class"
+    "# Fundamental Base and Collector Objects"
    ]
   },
   {

docs/tutorial_advanced/differentiation.ipynb

@@ -9,7 +9,7 @@
     }
    },
    "source": [
-    "# Autograd for Class Variables"
+    "# Automatic Differentiation for Class Variables"
    ]
   },
   {