diff --git a/ACKNOWLEDGMENTS.md b/ACKNOWLEDGMENTS.md index caf968c4a..fa3fa42e2 100644 --- a/ACKNOWLEDGMENTS.md +++ b/ACKNOWLEDGMENTS.md @@ -8,6 +8,8 @@ This project has received funding from Science and Technology Innovation 2030 (C - Brain Science and Brain-inspired Intelligence Project (No. 2021ZD0200204). + Additionally, BrainPy gratefully acknowledges the support and funding received from: +- 新一代人工智能开源开放平台 OpenI - Beijing Academy of Artificial Intelligence. diff --git a/brainpy/_src/math/surrogate/_one_input.py b/brainpy/_src/math/surrogate/_one_input.py index 23f151ee0..c967622ee 100644 --- a/brainpy/_src/math/surrogate/_one_input.py +++ b/brainpy/_src/math/surrogate/_one_input.py @@ -1,17 +1,14 @@ # -*- coding: utf-8 -*- - - +import functools from typing import Union import jax import jax.numpy as jnp import jax.scipy as sci -from .base import Surrogate - from brainpy._src.math.interoperability import as_jax from brainpy._src.math.ndarray import Array -from ._utils import vjp_custom +from .base import Surrogate __all__ = [ 'sigmoid', @@ -35,7 +32,36 @@ ] -class Sigmoid(Surrogate): +class _OneInpSurrogate(Surrogate): + def __init__(self, forward_use_surrogate=False): + self.forward_use_surrogate = forward_use_surrogate + self._true_call_ = jax.custom_gradient(self.call) + + def __call__(self, x: Union[jax.Array, Array]): + return self._true_call_(as_jax(x)) + + def call(self, x): + """Call the function for surrogate gradient propagation.""" + y = self.surrogate_fun(x) if self.forward_use_surrogate else self.true_fun(x) + return y, functools.partial(self.surrogate_grad, x=x) + + def true_fun(self, x): + """The original true function.""" + return jnp.asarray(x >= 0, dtype=x.dtype) + + def surrogate_fun(self, x): + """The surrogate function.""" + raise NotImplementedError + + def surrogate_grad(self, dz, x): + """The gradient for the surrogate function.""" + raise NotImplementedError + + def __repr__(self): + return f'{self.__class__.__name__}(forward_use_surrogate={self.forward_use_surrogate})' + + +class Sigmoid(_OneInpSurrogate): """Spike function with the sigmoid-shaped surrogate gradient. See Also @@ -43,22 +69,27 @@ class Sigmoid(Surrogate): sigmoid """ - def __init__(self, alpha=4., origin=False): + + def __init__(self, alpha=4., forward_use_surrogate=False): + super().__init__(forward_use_surrogate) self.alpha = alpha - self.origin = origin - def __call__(self, x: Union[jax.Array, Array]): - return sigmoid(x, alpha=self.alpha, origin=self.origin) + def surrogate_fun(self, x): + return sci.special.expit(x) + + def surrogate_grad(self, dz, x): + sgax = sci.special.expit(x * self.alpha) + dx = as_jax(dz) * (1. - sgax) * sgax * self.alpha + return dx def __repr__(self): return f'{self.__class__.__name__}(alpha={self.alpha})' -@vjp_custom(['x'], dict(alpha=4., origin=False), dict(origin=[True, False])) def sigmoid( x: Union[jax.Array, Array], - alpha: float = None, - origin: bool = None, + alpha: float = 4., + origin: bool = False, ): r"""Spike function with the sigmoid-shaped surrogate gradient. @@ -111,20 +142,10 @@ def sigmoid( out: jax.Array The spiking state. """ - if origin: - z = sci.special.expit(x) - else: - z = jnp.asarray(x >= 0, dtype=x.dtype) - - def grad(dz): - sgax = sci.special.expit(x * alpha) - dx = as_jax(dz) * (1. - sgax) * sgax * alpha - return dx, None - - return z, grad + return Sigmoid(alpha=alpha, forward_use_surrogate=origin)(x) -class PiecewiseQuadratic(Surrogate): +class PiecewiseQuadratic(_OneInpSurrogate): """Judge spiking state with a piecewise quadratic function. See Also @@ -132,22 +153,31 @@ class PiecewiseQuadratic(Surrogate): piecewise_quadratic """ - def __init__(self, alpha=1., origin=False): + + def __init__(self, alpha=1., forward_use_surrogate=False): + super().__init__(forward_use_surrogate) self.alpha = alpha - self.origin = origin - def __call__(self, x: Union[jax.Array, Array]): - return piecewise_quadratic(x, alpha=self.alpha, origin=self.origin) + def surrogate_fun(self, x): + z = jnp.where(x < -1 / self.alpha, + 0., + jnp.where(x > 1 / self.alpha, + 1., + (-self.alpha * jnp.abs(x) / 2 + 1) * self.alpha * x + 0.5)) + return z + + def surrogate_grad(self, dz, x): + dx = jnp.where(jnp.abs(x) > 1 / self.alpha, 0., dz * (-(self.alpha * x) ** 2 + self.alpha)) + return dx def __repr__(self): return f'{self.__class__.__name__}(alpha={self.alpha})' -@vjp_custom(['x'], dict(alpha=1., origin=False), dict(origin=[True, False])) def piecewise_quadratic( x: Union[jax.Array, Array], - alpha: float, - origin: bool + alpha: float = 1., + origin: bool = False ): r"""Judge spiking state with a piecewise quadratic function [1]_ [2]_ [3]_ [4]_ [5]_. @@ -217,45 +247,36 @@ def piecewise_quadratic( .. [4] Neftci E O, Mostafa H, Zenke F. Surrogate gradient learning in spiking neural networks: Bringing the power of gradient-based optimization to spiking neural networks[J]. IEEE Signal Processing Magazine, 2019, 36(6): 51-63. .. [5] Panda P, Aketi S A, Roy K. Toward scalable, efficient, and accurate deep spiking neural networks with backward residual connections, stochastic softmax, and hybridization[J]. Frontiers in Neuroscience, 2020, 14. """ - if origin: - z = jnp.where(x < -1 / alpha, - 0., - jnp.where(x > 1 / alpha, - 1., - (-alpha * jnp.abs(x) / 2 + 1) * alpha * x + 0.5)) - else: - z = jnp.asarray(x >= 0, dtype=x.dtype) - - def grad(dz): - dx = jnp.where(jnp.abs(x) > 1 / alpha, 0., dz * (-(alpha * x) ** 2 + alpha)) - return dx, None + return PiecewiseQuadratic(alpha=alpha, forward_use_surrogate=origin)(x) - return z, grad - -class PiecewiseExp(Surrogate): +class PiecewiseExp(_OneInpSurrogate): """Judge spiking state with a piecewise exponential function. See Also -------- piecewise_exp """ - def __init__(self, alpha=1., origin=False): + + def __init__(self, alpha=1., forward_use_surrogate=False): + super().__init__(forward_use_surrogate) self.alpha = alpha - self.origin = origin - def __call__(self, x: Union[jax.Array, Array]): - return piecewise_exp(x, alpha=self.alpha, origin=self.origin) + def surrogate_grad(self, dz, x): + dx = (self.alpha / 2) * jnp.exp(-self.alpha * jnp.abs(x)) + return dx * as_jax(dz) + + def surrogate_fun(self, x): + return jnp.where(x < 0, jnp.exp(self.alpha * x) / 2, 1 - jnp.exp(-self.alpha * x) / 2) def __repr__(self): return f'{self.__class__.__name__}(alpha={self.alpha})' -@vjp_custom(['x'], dict(alpha=1., origin=False), dict(origin=[True, False])) def piecewise_exp( x: Union[jax.Array, Array], - alpha: float, - origin: bool + alpha: float = 1., + origin: bool = False ): r"""Judge spiking state with a piecewise exponential function [1]_. @@ -315,41 +336,36 @@ def piecewise_exp( ---------- .. [1] Neftci E O, Mostafa H, Zenke F. Surrogate gradient learning in spiking neural networks: Bringing the power of gradient-based optimization to spiking neural networks[J]. IEEE Signal Processing Magazine, 2019, 36(6): 51-63. """ - if origin: - z = jnp.where(x < 0, jnp.exp(alpha * x) / 2, 1 - jnp.exp(-alpha * x) / 2) - else: - z = jnp.asarray(x >= 0, dtype=x.dtype) - - def grad(dz): - dx = (alpha / 2) * jnp.exp(-alpha * jnp.abs(x)) - return dx * as_jax(dz), None - - return z, grad + return PiecewiseExp(alpha=alpha, forward_use_surrogate=origin)(x) -class SoftSign(Surrogate): +class SoftSign(_OneInpSurrogate): """Judge spiking state with a soft sign function. See Also -------- soft_sign """ - def __init__(self, alpha=1., origin=False): + + def __init__(self, alpha=1., forward_use_surrogate=False): + super().__init__(forward_use_surrogate=forward_use_surrogate) self.alpha = alpha - self.origin = origin - def __call__(self, x: Union[jax.Array, Array]): - return soft_sign(x, alpha=self.alpha, origin=self.origin) + def surrogate_grad(self, dz, x): + dx = self.alpha * 0.5 / (1 + jnp.abs(self.alpha * x)) ** 2 + return dx * as_jax(dz) + + def surrogate_fun(self, x): + return x / (2 / self.alpha + 2 * jnp.abs(x)) + 0.5 def __repr__(self): return f'{self.__class__.__name__}(alpha={self.alpha})' -@vjp_custom(['x'], dict(alpha=1., origin=False), dict(origin=[True, False])) def soft_sign( x: Union[jax.Array, Array], - alpha: float, - origin: bool + alpha: float = 1., + origin: bool = False ): r"""Judge spiking state with a soft sign function. @@ -404,41 +420,36 @@ def soft_sign( The spiking state. """ - if origin: - z = x / (2 / alpha + 2 * jnp.abs(x)) + 0.5 - else: - z = jnp.asarray(x >= 0, dtype=x.dtype) - - def grad(dz): - dx = alpha * 0.5 / (1 + jnp.abs(alpha * x)) ** 2 - return dx * as_jax(dz), None - - return z, grad + return SoftSign(alpha=alpha, forward_use_surrogate=origin)(x) -class Arctan(Surrogate): +class Arctan(_OneInpSurrogate): """Judge spiking state with an arctan function. See Also -------- arctan """ - def __init__(self, alpha=1., origin=False): + + def __init__(self, alpha=1., forward_use_surrogate=False): + super().__init__(forward_use_surrogate=forward_use_surrogate) self.alpha = alpha - self.origin = origin - def __call__(self, x: Union[jax.Array, Array]): - return arctan(x, alpha=self.alpha, origin=self.origin) + def surrogate_grad(self, dz, x): + dx = self.alpha * 0.5 / (1 + (jnp.pi / 2 * self.alpha * x) ** 2) + return dx * as_jax(dz) + + def surrogate_fun(self, x): + return jnp.arctan2(jnp.pi / 2 * self.alpha * x) / jnp.pi + 0.5 def __repr__(self): return f'{self.__class__.__name__}(alpha={self.alpha})' -@vjp_custom(['x'], dict(alpha=1., origin=False), dict(origin=[True, False])) def arctan( x: Union[jax.Array, Array], - alpha: float, - origin: bool + alpha: float = 1., + origin: bool = False ): r"""Judge spiking state with an arctan function. @@ -492,41 +503,36 @@ def arctan( The spiking state. """ - if origin: - z = jnp.arctan2(jnp.pi / 2 * alpha * x) / jnp.pi + 0.5 - else: - z = jnp.asarray(x >= 0, dtype=x.dtype) - - def grad(dz): - dx = alpha * 0.5 / (1 + (jnp.pi / 2 * alpha * x) ** 2) - return dx * as_jax(dz), None + return Arctan(alpha=alpha, forward_use_surrogate=origin)(x) - return z, grad - -class NonzeroSignLog(Surrogate): +class NonzeroSignLog(_OneInpSurrogate): """Judge spiking state with a nonzero sign log function. See Also -------- nonzero_sign_log """ - def __init__(self, alpha=1., origin=False): + + def __init__(self, alpha=1., forward_use_surrogate=False): + super().__init__(forward_use_surrogate=forward_use_surrogate) self.alpha = alpha - self.origin = origin - def __call__(self, x: Union[jax.Array, Array]): - return nonzero_sign_log(x, alpha=self.alpha, origin=self.origin) + def surrogate_grad(self, dz, x): + dx = as_jax(dz) / (1 / self.alpha + jnp.abs(x)) + return dx + + def surrogate_fun(self, x): + return jnp.where(x < 0, -1., 1.) * jnp.log(jnp.abs(self.alpha * x) + 1) def __repr__(self): return f'{self.__class__.__name__}(alpha={self.alpha})' -@vjp_custom(['x'], dict(alpha=1., origin=False), statics={'origin': [True, False]}) def nonzero_sign_log( x: Union[jax.Array, Array], - alpha: float, - origin: bool + alpha: float = 1., + origin: bool = False ): r"""Judge spiking state with a nonzero sign log function. @@ -593,41 +599,36 @@ def nonzero_sign_log( The spiking state. """ - if origin: - z = jnp.where(x < 0, -1., 1.) * jnp.log(jnp.abs(alpha * x) + 1) - else: - z = jnp.asarray(x >= 0, dtype=x.dtype) + return NonzeroSignLog(alpha=alpha, forward_use_surrogate=origin)(x) - def grad(dz): - dx = as_jax(dz) / (1 / alpha + jnp.abs(x)) - return dx, None - return z, grad - - -class ERF(Surrogate): +class ERF(_OneInpSurrogate): """Judge spiking state with an erf function. See Also -------- erf """ - def __init__(self, alpha=1., origin=False): + + def __init__(self, alpha=1., forward_use_surrogate=False): + super().__init__(forward_use_surrogate=forward_use_surrogate) self.alpha = alpha - self.origin = origin - def __call__(self, x: Union[jax.Array, Array]): - return erf(x, alpha=self.alpha, origin=self.origin) + def surrogate_grad(self, dz, x): + dx = (self.alpha / jnp.sqrt(jnp.pi)) * jnp.exp(-jnp.power(self.alpha, 2) * x * x) + return dx * as_jax(dz) + + def surrogate_fun(self, x): + return sci.special.erf(-self.alpha * x) * 0.5 def __repr__(self): return f'{self.__class__.__name__}(alpha={self.alpha})' -@vjp_custom(['x'], dict(alpha=1., origin=False), statics={'origin': [True, False]}) def erf( x: Union[jax.Array, Array], - alpha: float, - origin: bool + alpha: float = 1., + origin: bool = False ): r"""Judge spiking state with an erf function [1]_ [2]_ [3]_. @@ -691,43 +692,43 @@ def erf( .. [3] Yin B, Corradi F, Bohté S M. Effective and efficient computation with multiple-timescale spiking recurrent neural networks[C]//International Conference on Neuromorphic Systems 2020. 2020: 1-8. """ - if origin: - z = sci.special.erf(-alpha * x) * 0.5 - else: - z = jnp.asarray(x >= 0, dtype=x.dtype) - - def grad(dz): - dx = (alpha / jnp.sqrt(jnp.pi)) * jnp.exp(-jnp.power(alpha, 2) * x * x) - return dx * as_jax(dz), None + return ERF(alpha=alpha, forward_use_surrogate=origin)(x) - return z, grad - -class PiecewiseLeakyRelu(Surrogate): +class PiecewiseLeakyRelu(_OneInpSurrogate): """Judge spiking state with a piecewise leaky relu function. See Also -------- piecewise_leaky_relu """ - def __init__(self, c=0.01, w=1., origin=False): + + def __init__(self, c=0.01, w=1., forward_use_surrogate=False): + super().__init__(forward_use_surrogate=forward_use_surrogate) self.c = c self.w = w - self.origin = origin - def __call__(self, x: Union[jax.Array, Array]): - return piecewise_leaky_relu(x, c=self.c, w=self.w, origin=self.origin) + def surrogate_fun(self, x): + z = jnp.where(x < -self.w, + self.c * x + self.c * self.w, + jnp.where(x > self.w, + self.c * x - self.c * self.w + 1, + 0.5 * x / self.w + 0.5)) + return z + + def surrogate_grad(self, dz, x): + dx = jnp.where(jnp.abs(x) > self.w, self.c, 1 / self.w) + return dx * as_jax(dz) def __repr__(self): return f'{self.__class__.__name__}(c={self.c}, w={self.w})' -@vjp_custom(['x'], dict(c=0.01, w=1., origin=False), statics={'origin': [True, False]}) def piecewise_leaky_relu( x: Union[jax.Array, Array], - c: float, - w: float, - origin: bool + c: float = 0.01, + w: float = 1., + origin: bool = False ): r"""Judge spiking state with a piecewise leaky relu function [1]_ [2]_ [3]_ [4]_ [5]_ [6]_ [7]_ [8]_. @@ -804,47 +805,48 @@ def piecewise_leaky_relu( .. [8] Kaiser J, Mostafa H, Neftci E. Synaptic plasticity dynamics for deep continuous local learning (DECOLLE)[J]. Frontiers in Neuroscience, 2020, 14: 424. """ - if origin: - z = jnp.where(x < -w, - c * x + c * w, - jnp.where(x > w, - c * x - c * w + 1, - 0.5 * x / w + 0.5)) - else: - z = jnp.asarray(x >= 0, dtype=x.dtype) - - def grad(dz): - dx = jnp.where(jnp.abs(x) > w, c, 1 / w) - return dx * as_jax(dz), None, None - - return z, grad + return PiecewiseLeakyRelu(c=c, w=w)(x) -class SquarewaveFourierSeries(Surrogate): +class SquarewaveFourierSeries(_OneInpSurrogate): """Judge spiking state with a squarewave fourier series. See Also -------- squarewave_fourier_series """ - def __init__(self, n=2, t_period=8., origin=False): + + def __init__(self, n=2, t_period=8., forward_use_surrogate=False): + super().__init__(forward_use_surrogate=forward_use_surrogate) self.n = n self.t_period = t_period - self.origin = origin - def __call__(self, x: Union[jax.Array, Array]): - return squarewave_fourier_series(x, self.n, self.t_period, self.origin) + def surrogate_grad(self, dz, x): + w = jnp.pi * 2. / self.t_period + dx = jnp.cos(w * x) + for i in range(2, self.n): + dx += jnp.cos((2 * i - 1.) * w * x) + dx *= 4. / self.t_period + return dx * as_jax(dz) + + def surrogate_fun(self, x): + w = jnp.pi * 2. / self.t_period + ret = jnp.sin(w * x) + for i in range(2, self.n): + c = (2 * i - 1.) + ret += jnp.sin(c * w * x) / c + z = 0.5 + 2. / jnp.pi * ret + return z def __repr__(self): return f'{self.__class__.__name__}(n={self.n}, t_period={self.t_period})' -@vjp_custom(['x'], dict(n=2, t_period=8., origin=False), statics={'origin': [True, False]}) def squarewave_fourier_series( x: Union[jax.Array, Array], - n: int, - t_period: float, - origin: bool + n: int = 2, + t_period: float = 8., + origin: bool = False ): r"""Judge spiking state with a squarewave fourier series. @@ -898,55 +900,45 @@ def squarewave_fourier_series( The spiking state. """ - w = jnp.pi * 2. / t_period - if origin: - ret = jnp.sin(w * x) - for i in range(2, n): - c = (2 * i - 1.) - ret += jnp.sin(c * w * x) / c - z = 0.5 + 2. / jnp.pi * ret - else: - z = jnp.asarray(x >= 0, dtype=x.dtype) - def grad(dz): - dx = jnp.cos(w * x) - for i in range(2, n): - dx += jnp.cos((2 * i - 1.) * w * x) - dx *= 4. / t_period - return dx * as_jax(dz), None, None + return SquarewaveFourierSeries(n=n, t_period=t_period, forward_use_surrogate=origin)(x) - return z, grad - -class S2NN(Surrogate): +class S2NN(_OneInpSurrogate): """Judge spiking state with the S2NN surrogate spiking function. See Also -------- s2nn """ - def __init__(self, alpha=4., beta=1., epsilon=1e-8, origin=False): + + def __init__(self, alpha=4., beta=1., epsilon=1e-8, forward_use_surrogate=False): + super().__init__(forward_use_surrogate=forward_use_surrogate) self.alpha = alpha self.beta = beta self.epsilon = epsilon - self.origin = origin - def __call__(self, x: Union[jax.Array, Array], ): - return s2nn(x, self.alpha, self.beta, self.epsilon, self.origin) + def surrogate_fun(self, x): + z = jnp.where(x < 0., + sci.special.expit(x * self.alpha), + self.beta * jnp.log(jnp.abs((x + 1.)) + self.epsilon) + 0.5) + return z + + def surrogate_grad(self, dz, x): + sg = sci.special.expit(self.alpha * x) + dx = jnp.where(x < 0., self.alpha * sg * (1. - sg), self.beta / (x + 1.)) + return dx * as_jax(dz) def __repr__(self): return f'{self.__class__.__name__}(alpha={self.alpha}, beta={self.beta}, epsilon={self.epsilon})' -@vjp_custom(['x'], - defaults=dict(alpha=4., beta=1., epsilon=1e-8, origin=False), - statics={'origin': [True, False]}) def s2nn( x: Union[jax.Array, Array], - alpha: float, - beta: float, - epsilon: float, - origin: bool + alpha: float = 4., + beta: float = 1., + epsilon: float = 1e-8, + origin: bool = False ): r"""Judge spiking state with the S2NN surrogate spiking function [1]_. @@ -1015,46 +1007,39 @@ def s2nn( .. [1] Suetake, Kazuma et al. “S2NN: Time Step Reduction of Spiking Surrogate Gradients for Training Energy Efficient Single-Step Neural Networks.” ArXiv abs/2201.10879 (2022): n. pag. """ - if origin: - z = jnp.where(x < 0., - sci.special.expit(x * alpha), - beta * jnp.log(jnp.abs((x + 1.)) + epsilon) + 0.5) - else: - z = jnp.asarray(x >= 0, dtype=x.dtype) - - def grad(dz): - sg = sci.special.expit(alpha * x) - dx = jnp.where(x < 0., alpha * sg * (1. - sg), beta / (x + 1.)) - return dx * as_jax(dz), None, None, None + return S2NN(alpha=alpha, beta=beta, epsilon=epsilon, forward_use_surrogate=origin)(x) - return z, grad - -class QPseudoSpike(Surrogate): +class QPseudoSpike(_OneInpSurrogate): """Judge spiking state with the q-PseudoSpike surrogate function. See Also -------- q_pseudo_spike """ - def __init__(self, alpha=2., origin=False): + + def __init__(self, alpha=2., forward_use_surrogate=False): + super().__init__(forward_use_surrogate=forward_use_surrogate) self.alpha = alpha - self.origin = origin - def __call__(self, x: Union[jax.Array, Array]): - return q_pseudo_spike(x, self.alpha, self.origin) + def surrogate_grad(self, dz, x): + dx = jnp.power(1 + 2 / (self.alpha + 1) * jnp.abs(x), -self.alpha) + return dx * as_jax(dz) + + def surrogate_fun(self, x): + z = jnp.where(x < 0., + 0.5 * jnp.power(1 - 2 / (self.alpha - 1) * jnp.abs(x), 1 - self.alpha), + 1. - 0.5 * jnp.power(1 + 2 / (self.alpha - 1) * jnp.abs(x), 1 - self.alpha)) + return z def __repr__(self): return f'{self.__class__.__name__}(alpha={self.alpha})' -@vjp_custom(['x'], - dict(alpha=2., origin=False), - statics={'origin': [True, False]}) def q_pseudo_spike( x: Union[jax.Array, Array], - alpha: float, - origin: bool + alpha: float = 2., + origin: bool = False ): r"""Judge spiking state with the q-PseudoSpike surrogate function [1]_. @@ -1115,47 +1100,38 @@ def q_pseudo_spike( ---------- .. [1] Herranz-Celotti, Luca and Jean Rouat. “Surrogate Gradients Design.” ArXiv abs/2202.00282 (2022): n. pag. """ - if origin: - z = jnp.where(x < 0., - 0.5 * jnp.power(1 - 2 / (alpha - 1) * jnp.abs(x), 1 - alpha), - 1. - 0.5 * jnp.power(1 + 2 / (alpha - 1) * jnp.abs(x), 1 - alpha)) - else: - z = jnp.asarray(x >= 0, dtype=x.dtype) - - def grad(dz): - dx = jnp.power(1 + 2 / (alpha + 1) * jnp.abs(x), -alpha) - return dx * as_jax(dz), None + return QPseudoSpike(alpha=alpha, forward_use_surrogate=origin)(x) - return z, grad - -class LeakyRelu(Surrogate): +class LeakyRelu(_OneInpSurrogate): """Judge spiking state with the Leaky ReLU function. See Also -------- leaky_relu """ - def __init__(self, alpha=0.1, beta=1., origin=False): + + def __init__(self, alpha=0.1, beta=1., forward_use_surrogate=False): + super().__init__(forward_use_surrogate=forward_use_surrogate) self.alpha = alpha self.beta = beta - self.origin = origin - def __call__(self, x: Union[jax.Array, Array]): - return leaky_relu(x, self.alpha, self.beta, self.origin) + def surrogate_fun(self, x): + return jnp.where(x < 0., self.alpha * x, self.beta * x) + + def surrogate_grad(self, dz, x): + dx = jnp.where(x < 0., self.alpha, self.beta) + return dx * as_jax(dz) def __repr__(self): return f'{self.__class__.__name__}(alpha={self.alpha}, beta={self.beta})' -@vjp_custom(['x'], - dict(alpha=0.1, beta=1., origin=False), - statics={'origin': [True, False]}) def leaky_relu( x: Union[jax.Array, Array], - alpha: float, - beta: float, - origin: bool + alpha: float = 0.1, + beta: float = 1., + origin: bool = False ): r"""Judge spiking state with the Leaky ReLU function. @@ -1217,43 +1193,45 @@ def leaky_relu( out: jax.Array The spiking state. """ - if origin: - z = jnp.where(x < 0., alpha * x, beta * x) - else: - z = jnp.asarray(x >= 0, dtype=x.dtype) - - def grad(dz): - dx = jnp.where(x < 0., alpha, beta) - return dx * as_jax(dz), None, None - - return z, grad + return LeakyRelu(alpha=alpha, beta=beta, forward_use_surrogate=origin)(x) -class LogTailedRelu(Surrogate): +class LogTailedRelu(_OneInpSurrogate): """Judge spiking state with the Log-tailed ReLU function. See Also -------- log_tailed_relu """ - def __init__(self, alpha=0., origin=False): + + def __init__(self, alpha=0., forward_use_surrogate=False): + super().__init__(forward_use_surrogate=forward_use_surrogate) self.alpha = alpha - self.origin = origin - def __call__(self, x: Union[jax.Array, Array]): - return log_tailed_relu(x, self.alpha, self.origin) + def surrogate_fun(self, x): + z = jnp.where(x > 1, + jnp.log(x), + jnp.where(x > 0, + x, + self.alpha * x)) + return z + + def surrogate_grad(self, dz, x): + dx = jnp.where(x > 1, + 1 / x, + jnp.where(x > 0, + 1., + self.alpha)) + return dx * as_jax(dz) def __repr__(self): return f'{self.__class__.__name__}(alpha={self.alpha})' -@vjp_custom(['x'], - dict(alpha=0., origin=False), - statics={'origin': [True, False]}) def log_tailed_relu( x: Union[jax.Array, Array], - alpha: float, - origin: bool + alpha: float = 0., + origin: bool = False ): r"""Judge spiking state with the Log-tailed ReLU function [1]_. @@ -1319,49 +1297,34 @@ def log_tailed_relu( ---------- .. [1] Cai, Zhaowei et al. “Deep Learning with Low Precision by Half-Wave Gaussian Quantization.” 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR) (2017): 5406-5414. """ - if origin: - z = jnp.where(x > 1, - jnp.log(x), - jnp.where(x > 0, - x, - alpha * x)) - else: - z = jnp.asarray(x >= 0, dtype=x.dtype) - - def grad(dz): - dx = jnp.where(x > 1, - 1 / x, - jnp.where(x > 0, - 1., - alpha)) - return dx * as_jax(dz), None - - return z, grad + return LogTailedRelu(alpha=alpha, forward_use_surrogate=origin)(x) -class ReluGrad(Surrogate): +class ReluGrad(_OneInpSurrogate): """Judge spiking state with the ReLU gradient function. See Also -------- relu_grad """ + def __init__(self, alpha=0.3, width=1.): + super().__init__() self.alpha = alpha self.width = width - def __call__(self, x: Union[jax.Array, Array]): - return relu_grad(x, self.alpha, self.width) + def surrogate_grad(self, dz, x): + dx = jnp.maximum(self.alpha * self.width - jnp.abs(x) * self.alpha, 0) + return dx * as_jax(dz) def __repr__(self): return f'{self.__class__.__name__}(alpha={self.alpha}, width={self.width})' -@vjp_custom(['x'], dict(alpha=0.3, width=1.)) def relu_grad( x: Union[jax.Array, Array], - alpha: float, - width: float, + alpha: float = 0.3, + width: float = 1., ): r"""Spike function with the ReLU gradient function [1]_. @@ -1413,38 +1376,34 @@ def relu_grad( ---------- .. [1] Neftci, E. O., Mostafa, H. & Zenke, F. Surrogate gradient learning in spiking neural networks. IEEE Signal Process. Mag. 36, 61–63 (2019). """ - z = jnp.asarray(x >= 0, dtype=x.dtype) - - def grad(dz): - dx = jnp.maximum(alpha * width - jnp.abs(x) * alpha, 0) - return dx * as_jax(dz), None, None - - return z, grad + return ReluGrad(alpha=alpha, width=width)(x) -class GaussianGrad(Surrogate): +class GaussianGrad(_OneInpSurrogate): """Judge spiking state with the Gaussian gradient function. See Also -------- gaussian_grad """ + def __init__(self, sigma=0.5, alpha=0.5): + super().__init__() self.sigma = sigma self.alpha = alpha - def __call__(self, x: Union[jax.Array, Array]): - return gaussian_grad(x, self.sigma, self.alpha) + def surrogate_grad(self, dz, x): + dx = jnp.exp(-(x ** 2) / 2 * jnp.power(self.sigma, 2)) / (jnp.sqrt(2 * jnp.pi) * self.sigma) + return self.alpha * dx * as_jax(dz) def __repr__(self): return f'{self.__class__.__name__}(alpha={self.alpha}, sigma={self.sigma})' -@vjp_custom(['x'], dict(sigma=0.5, alpha=0.5)) def gaussian_grad( x: Union[jax.Array, Array], - sigma: float, - alpha: float, + sigma: float = 0.5, + alpha: float = 0.5, ): r"""Spike function with the Gaussian gradient function [1]_. @@ -1495,42 +1454,43 @@ def gaussian_grad( ---------- .. [1] Yin, B., Corradi, F. & Bohté, S.M. Accurate and efficient time-domain classification with adaptive spiking recurrent neural networks. Nat Mach Intell 3, 905–913 (2021). """ - z = jnp.asarray(x >= 0, dtype=x.dtype) - - def grad(dz): - dx = jnp.exp(-(x ** 2) / 2 * jnp.power(sigma, 2)) / (jnp.sqrt(2 * jnp.pi) * sigma) - return alpha * dx * as_jax(dz), None, None - - return z, grad + return GaussianGrad(sigma=sigma, alpha=alpha)(x) -class MultiGaussianGrad(Surrogate): +class MultiGaussianGrad(_OneInpSurrogate): """Judge spiking state with the multi-Gaussian gradient function. See Also -------- multi_gaussian_grad """ + def __init__(self, h=0.15, s=6.0, sigma=0.5, scale=0.5): + super().__init__() self.h = h self.s = s self.sigma = sigma self.scale = scale - def __call__(self, x: Union[jax.Array, Array]): - return multi_gaussian_grad(x, self.h, self.s, self.sigma, self.scale) + def surrogate_grad(self, dz, x): + g1 = jnp.exp(-x ** 2 / (2 * jnp.power(self.sigma, 2))) / (jnp.sqrt(2 * jnp.pi) * self.sigma) + g2 = jnp.exp(-(x - self.sigma) ** 2 / (2 * jnp.power(self.s * self.sigma, 2)) + ) / (jnp.sqrt(2 * jnp.pi) * self.s * self.sigma) + g3 = jnp.exp(-(x + self.sigma) ** 2 / (2 * jnp.power(self.s * self.sigma, 2)) + ) / (jnp.sqrt(2 * jnp.pi) * self.s * self.sigma) + dx = g1 * (1. + self.h) - g2 * self.h - g3 * self.h + return self.scale * dx * as_jax(dz) def __repr__(self): return f'{self.__class__.__name__}(h={self.h}, s={self.s}, sigma={self.sigma}, scale={self.scale})' -@vjp_custom(['x'], dict(h=0.15, s=6.0, sigma=0.5, scale=0.5)) def multi_gaussian_grad( x: Union[jax.Array, Array], - h: float, - s: float, - sigma: float, - scale: float, + h: float = 0.15, + s: float = 6.0, + sigma: float = 0.5, + scale: float = 0.5, ): r"""Spike function with the multi-Gaussian gradient function [1]_. @@ -1588,39 +1548,32 @@ def multi_gaussian_grad( ---------- .. [1] Yin, B., Corradi, F. & Bohté, S.M. Accurate and efficient time-domain classification with adaptive spiking recurrent neural networks. Nat Mach Intell 3, 905–913 (2021). """ - z = jnp.asarray(x >= 0, dtype=x.dtype) - - def grad(dz): - g1 = jnp.exp(-x ** 2 / (2 * jnp.power(sigma, 2))) / (jnp.sqrt(2 * jnp.pi) * sigma) - g2 = jnp.exp(-(x - sigma) ** 2 / (2 * jnp.power(s * sigma, 2))) / (jnp.sqrt(2 * jnp.pi) * s * sigma) - g3 = jnp.exp(-(x + sigma) ** 2 / (2 * jnp.power(s * sigma, 2))) / (jnp.sqrt(2 * jnp.pi) * s * sigma) - dx = g1 * (1. + h) - g2 * h - g3 * h - return scale * dx * as_jax(dz), None, None, None, None - - return z, grad + return MultiGaussianGrad(h=h, s=s, sigma=sigma, scale=scale)(x) -class InvSquareGrad(Surrogate): +class InvSquareGrad(_OneInpSurrogate): """Judge spiking state with the inverse-square surrogate gradient function. See Also -------- inv_square_grad """ + def __init__(self, alpha=100.): + super().__init__() self.alpha = alpha - def __call__(self, x: Union[jax.Array, Array]): - return inv_square_grad(x, self.alpha) + def surrogate_grad(self, dz, x): + dx = as_jax(dz) / (self.alpha * jnp.abs(x) + 1.0) ** 2 + return dx def __repr__(self): return f'{self.__class__.__name__}(alpha={self.alpha})' -@vjp_custom(['x'], dict(alpha=100.)) def inv_square_grad( x: Union[jax.Array, Array], - alpha: float + alpha: float = 100. ): r"""Spike function with the inverse-square surrogate gradient. @@ -1665,36 +1618,32 @@ def inv_square_grad( out: jax.Array The spiking state. """ - z = jnp.asarray(x >= 0, dtype=x.dtype) - - def grad(dz): - dx = as_jax(dz) / (alpha * jnp.abs(x) + 1.0) ** 2 - return dx, None - - return z, grad + return InvSquareGrad(alpha=alpha)(x) -class SlayerGrad(Surrogate): +class SlayerGrad(_OneInpSurrogate): """Judge spiking state with the slayer surrogate gradient function. See Also -------- slayer_grad """ + def __init__(self, alpha=1.): + super().__init__() self.alpha = alpha - def __call__(self, x: Union[jax.Array, Array]): - return slayer_grad(x, self.alpha) + def surrogate_grad(self, dz, x): + dx = as_jax(dz) * jnp.exp(-self.alpha * jnp.abs(x)) + return dx def __repr__(self): return f'{self.__class__.__name__}(alpha={self.alpha})' -@vjp_custom(['x'], dict(alpha=1.)) def slayer_grad( x: Union[jax.Array, Array], - alpha: float + alpha: float = 1. ): r"""Spike function with the slayer surrogate gradient function. @@ -1744,10 +1693,4 @@ def slayer_grad( ---------- .. [1] Shrestha, S. B. & Orchard, G. Slayer: spike layer error reassignment in time. In Advances in Neural Information Processing Systems Vol. 31, 1412–1421 (NeurIPS, 2018). """ - z = jnp.asarray(x >= 0, dtype=x.dtype) - - def grad(dz): - dx = as_jax(dz) * jnp.exp(-alpha * jnp.abs(x)) - return dx, None - - return z, grad + return SlayerGrad(alpha=alpha)(x) diff --git a/brainpy/_src/mixin.py b/brainpy/_src/mixin.py index 23cd703bf..37d3ca3b7 100644 --- a/brainpy/_src/mixin.py +++ b/brainpy/_src/mixin.py @@ -560,7 +560,7 @@ class SupportOnline(MixIn): online_fit_by: Optional # methods for online fitting - def online_init(self): + def online_init(self, *args, **kwargs): raise NotImplementedError def online_fit(self, target: ArrayType, fit_record: Dict[str, ArrayType]): @@ -575,6 +575,9 @@ class SupportOffline(MixIn): offline_fit_by: Optional # methods for offline fitting + def offline_init(self, *args, **kwargs): + pass + def offline_fit(self, target: ArrayType, fit_record: Dict[str, ArrayType]): raise NotImplementedError diff --git a/brainpy/_src/train/back_propagation.py b/brainpy/_src/train/back_propagation.py index 6f65783fe..f0b56f15a 100644 --- a/brainpy/_src/train/back_propagation.py +++ b/brainpy/_src/train/back_propagation.py @@ -9,10 +9,10 @@ from jax.tree_util import tree_map from tqdm import tqdm -from brainpy import tools import brainpy.losses as losses import brainpy.math as bm from brainpy import optim +from brainpy import tools from brainpy._src.context import share from brainpy._src.dynsys import DynamicalSystem from brainpy._src.running import constants as c diff --git a/brainpy/_src/train/base.py b/brainpy/_src/train/base.py index 97e20a384..2ab2ea3cd 100644 --- a/brainpy/_src/train/base.py +++ b/brainpy/_src/train/base.py @@ -1,13 +1,13 @@ # -*- coding: utf-8 -*- -from typing import Dict, Sequence, Any, Union, Optional +from typing import Dict, Sequence, Any, Optional import brainpy.math as bm from brainpy._src.dynsys import DynamicalSystem from brainpy._src.runners import DSRunner from brainpy._src.running import constants as c from brainpy.errors import NoLongerSupportError -from brainpy.types import ArrayType, Output +from brainpy.types import Output __all__ = [ 'DSTrainer', diff --git a/brainpy/_src/train/offline.py b/brainpy/_src/train/offline.py index ab1521a36..2bfa419d6 100644 --- a/brainpy/_src/train/offline.py +++ b/brainpy/_src/train/offline.py @@ -10,9 +10,9 @@ from brainpy import tools from brainpy._src.context import share from brainpy._src.dynsys import DynamicalSystem +from brainpy._src.mixin import SupportOffline from brainpy._src.runners import _call_fun_with_share from brainpy.algorithms.offline import get, RidgeRegression, OfflineAlgorithm -from brainpy.errors import NoImplementationError from brainpy.types import ArrayType, Output from ._utils import format_ys from .base import DSTrainer @@ -239,16 +239,15 @@ def _step_func_monitor(self): def _check_interface(self): for node in self.train_nodes: - if not hasattr(node, 'offline_fit'): - raise NoImplementationError( + if not isinstance(node, SupportOffline): + raise TypeError( f''' The node - + {node} - - is set to be computing mode of {bm.training_mode} with {self.__class__.__name__}. - However, it does not implement the required training - interface "offline_fit()" function. + + is set to be computing mode of {bm.training_mode} with {self.__class__.__name__}. + However, {self.__class__.__name__} only support training nodes that are instances of {SupportOffline}. ''' ) diff --git a/brainpy/_src/train/online.py b/brainpy/_src/train/online.py index e028f9c62..daeea476b 100644 --- a/brainpy/_src/train/online.py +++ b/brainpy/_src/train/online.py @@ -10,9 +10,9 @@ from brainpy import math as bm, tools from brainpy._src.context import share from brainpy._src.dynsys import DynamicalSystem +from brainpy._src.mixin import SupportOnline from brainpy._src.runners import _call_fun_with_share from brainpy.algorithms.online import get, OnlineAlgorithm, RLS -from brainpy.errors import NoImplementationError from brainpy.types import ArrayType, Output from ._utils import format_ys from .base import DSTrainer @@ -256,19 +256,12 @@ def _step_func_fit(self, i, xs: Sequence, ys: Dict, shared_args=None): def _check_interface(self): for node in self.train_nodes: - if not hasattr(node, 'online_fit'): - raise NoImplementationError( + if not isinstance(node, SupportOnline): + raise TypeError( f'The node \n\n{node}\n\n' - f'is set to be trainable with {self.__class__.__name__} method. ' - f'However, it does not implement the required training ' - f'interface "online_fit()" function. ' - ) - if not hasattr(node, 'online_init'): - raise NoImplementationError( - f'The node \n\n{node}\n\n' - f'is set to be trainable with {self.__class__.__name__} method. ' - f'However, it does not implement the required training ' - f'interface "online_init()" function. ' + f'is set to be trainable with {self.__class__.__name__} method. \n' + f'{self.__class__.__name__} only support training nodes that are instances ' + f'of {SupportOnline}. ' ) def _step_func_monitor(self): diff --git a/docs/tutorial_simulation/index.rst b/docs/tutorial_simulation/index.rst index 26ba6e508..ffe75e2bb 100644 --- a/docs/tutorial_simulation/index.rst +++ b/docs/tutorial_simulation/index.rst @@ -4,5 +4,6 @@ Model Simulation .. toctree:: :maxdepth: 1 - simulation_dsrunner - parallel_computing + simulation_dsrunner.ipynb + parallel_for_parameter_exploration.ipynb + monitor_per_multiple_steps.ipynb diff --git a/docs/tutorial_simulation/monitor_per_multiple_steps.ipynb b/docs/tutorial_simulation/monitor_per_multiple_steps.ipynb new file mode 100644 index 000000000..566e02d40 --- /dev/null +++ b/docs/tutorial_simulation/monitor_per_multiple_steps.ipynb @@ -0,0 +1,285 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Monitor every multiple steps" + ], + "metadata": { + "collapsed": false + }, + "id": "1e2c9e0b751c9bf0" + }, + { + "cell_type": "markdown", + "source": [ + "Sometimes it is not necessary to record the system's behavior at a very high temporal precision. When the simulation time is long, monitoring the variables at high temporal precision can lead to out of memory error. It is very helpful to record the values once every few steps to decrease the memory requirement. \n", + "\n", + "In this tutorial, we will highlight how to record/monitor variable every multiple simulation time steps. " + ], + "metadata": { + "collapsed": false + }, + "id": "b16daa893d751c15" + }, + { + "cell_type": "code", + "execution_count": 2, + "outputs": [], + "source": [ + "import brainpy as bp\n", + "import brainpy.math as bm\n", + "import numpy as np" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-10-09T06:03:52.638868Z", + "start_time": "2023-10-09T06:03:52.627082500Z" + } + }, + "id": "f7c8ecc962d28987" + }, + { + "cell_type": "markdown", + "source": [ + "First of all, define your dynamical system that you want. Here we use the EI balanced network model. " + ], + "metadata": { + "collapsed": false + }, + "id": "d63ae11e921086b5" + }, + { + "cell_type": "code", + "execution_count": 3, + "outputs": [], + "source": [ + "class EINet(bp.DynSysGroup):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.N = bp.dyn.LifRef(4000, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5.,\n", + " V_initializer=bp.init.Normal(-55., 2.))\n", + " self.delay = bp.VarDelay(self.N.spike, entries={'I': None})\n", + " self.E = bp.dyn.ProjAlignPostMg1(comm=bp.dnn.EventJitFPHomoLinear(3200, 4000, prob=0.02, weight=0.6),\n", + " syn=bp.dyn.Expon.desc(size=4000, tau=5.),\n", + " out=bp.dyn.COBA.desc(E=0.),\n", + " post=self.N)\n", + " self.I = bp.dyn.ProjAlignPostMg1(comm=bp.dnn.EventJitFPHomoLinear(800, 4000, prob=0.02, weight=6.7),\n", + " syn=bp.dyn.Expon.desc(size=4000, tau=10.),\n", + " out=bp.dyn.COBA.desc(E=-80.),\n", + " post=self.N)\n", + "\n", + " def update(self, input):\n", + " spk = self.delay.at('I')\n", + " self.E(spk[:3200])\n", + " self.I(spk[3200:])\n", + " self.delay(self.N(input))\n", + " return self.N.spike.value\n", + " \n", + " def run(self, ids, inputs): # the most import function!!!\n", + " for i, inp in zip(ids, inputs):\n", + " bp.share.save(i=i, t=bm.get_dt() * i)\n", + " self.update(inp)\n", + " return self.N.spike.value" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-10-09T06:03:52.642762100Z", + "start_time": "2023-10-09T06:03:52.633059900Z" + } + }, + "id": "5d47f5793d83aa79" + }, + { + "cell_type": "markdown", + "source": [ + "In this example, we monitor the spikes of the neuron group every 1 ms (10 time steps). " + ], + "metadata": { + "collapsed": false + }, + "id": "4af7ae96791f4dd0" + }, + { + "cell_type": "code", + "execution_count": 4, + "outputs": [], + "source": [ + "n_step_per_monitor = 10" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-10-09T06:03:52.653365500Z", + "start_time": "2023-10-09T06:03:52.637774500Z" + } + }, + "id": "fe86375df801c02c" + }, + { + "cell_type": "markdown", + "source": [ + "Then the key is to reshape the running indices and inputs as the shape of ``[n_time, ..., n_step_per_time]``. " + ], + "metadata": { + "collapsed": false + }, + "id": "cd8cf8c045d5c05c" + }, + { + "cell_type": "code", + "execution_count": 5, + "outputs": [], + "source": [ + "indices = np.arange(10000).reshape(-1, n_step_per_monitor)\n", + "inputs = np.ones(indices.shape) * 20." + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-10-09T06:03:52.653365500Z", + "start_time": "2023-10-09T06:03:52.638868Z" + } + }, + "id": "532ef05c0800e28e" + }, + { + "cell_type": "markdown", + "source": [ + "Next, we write a run function, in which the model run multiple steps we want. \n", + "\n", + "\n", + "```python\n", + "\n", + "class EINet(bp.DynSysGroup):\n", + " ...\n", + "\n", + " def run(self, ids, inputs): \n", + " for i, inp in zip(ids, inputs): # run the model multiple steps in the run function\n", + " bp.share.save(i=i, t=bm.get_dt() * i)\n", + " self.update(inp)\n", + " return self.N.spike.value\n", + "\n", + "```" + ], + "metadata": { + "collapsed": false + }, + "id": "677f17a7652f8e11" + }, + { + "cell_type": "markdown", + "source": [ + "Finally, let's run the model with ``brainpy.math.for_loop``." + ], + "metadata": { + "collapsed": false + }, + "id": "fce584fad7a4928a" + }, + { + "cell_type": "code", + "execution_count": 6, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" + ] + }, + { + "data": { + "text/plain": " 0%| | 0/1000 [00:00", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bp.visualize.raster_plot(indices[:, 0], spks, show=True)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-10-09T06:04:08.838065800Z", + "start_time": "2023-10-09T06:04:08.296683Z" + } + }, + "id": "585029a001c65faa" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorial_simulation/parallel_computing.ipynb b/docs/tutorial_simulation/parallel_for_parameter_exploration.ipynb similarity index 100% rename from docs/tutorial_simulation/parallel_computing.ipynb rename to docs/tutorial_simulation/parallel_for_parameter_exploration.ipynb