ngclearn 1.0b0__py3-none-any.whl

ngclearn/__init__.py

@@ -0,0 +1,23 @@
+import sys
+import subprocess
+import pkg_resources
+from pkg_resources import get_distribution
+#from pathlib import Path
+#from sys import argv
+
+__version__ = get_distribution('ngclearn').version
+
+#required = {'ngcsimlib', 'jax', 'jaxlib'} ## list of core ngclearn dependencies
+required = {'ngcsimlib', 'jax', 'jaxlib'}
+installed = {pkg.key for pkg in pkg_resources.working_set}
+missing = required - installed
+
+for key in required:
+    if key in missing:
+        raise ImportError(str(key) + ", a core dependency of ngclearn, is not " \
+                          "currently installed!")
+
+
+## Needed to preload is called before anything in ngclearn
+import ngcsimlib
+from ngcsimlib.controller import Controller

ngclearn/commands/__init__.py

@@ -0,0 +1 @@
+from ngcsimlib.commands import *

ngclearn/components/__init__.py

@@ -0,0 +1,19 @@
+## point to rate-coded cell componet types
+from .neurons.graded.rateCell import RateCell
+from .neurons.graded.gaussianErrorCell import GaussianErrorCell
+from .neurons.graded.laplacianErrorCell import LaplacianErrorCell
+## point to standard spiking cell component types
+from .neurons.spiking.sLIFCell import SLIFCell
+from .neurons.spiking.LIFCell import LIFCell
+from .neurons.spiking.quadLIFCell import QuadLIFCell
+from .neurons.spiking.izhikevichCell import IzhikevichCell
+## point to transformer/operater component types
+from .other.varTrace import VarTrace
+from .other.expKernel import ExpKernel
+## point to input encoder component types
+from .input_encoders.bernoulliCell import BernoulliCell
+from .input_encoders.poissonCell import PoissonCell
+## point to synapse component types
+from .synapses.hebbian.hebbianSynapse import HebbianSynapse
+from .synapses.hebbian.traceSTDPSynapse import TraceSTDPSynapse
+from .synapses.hebbian.expSTDPSynapse import ExpSTDPSynapse

ngclearn/components/baseComponentTemplate.py

@@ -0,0 +1,47 @@
+from ngcsimlib.component import Component
+from jax import random
+import time
+
+
+class COMPONENT_TEMPLATE(Component):
+  ## Class Methods for Compartment Names
+  @classmethod
+  def DEFAULTCompartmentName(cls):
+    return 'DEFAULT'
+
+  ## Bind Properties to Compartments for ease of use
+  @property
+  def DEFAULTCompartment(self):
+    return self.compartments.get(self.DEFAULTCompartmentName(), None)
+
+  @DEFAULTCompartment.setter
+  def DEFAULTCompartment(self, x):
+    if x is not None:
+      if True:
+        raise RuntimeError("")
+    self.compartments[self.DEFAULTCompartmentName()] = x
+
+
+  # Define Functions
+  def __init__(self, name, key=None, useVerboseDict=False, **kwargs):
+    super().__init__(name, useVerboseDict, **kwargs)
+
+    ##Random Number Set up
+    self.key = key
+    if self.key is None:
+      self.key = random.PRNGKey(time.time_ns())
+
+    ##Reset to initialize stuff
+    self.reset()
+
+  def verify_connections(self):
+    pass
+
+  def advance_state(self, **kwargs):
+    pass
+
+  def reset(self, **kwargs):
+    pass
+
+  def save(self, directory, **kwargs):
+      pass

ngclearn/components/input_encoders/__init__.py

@@ -0,0 +1,2 @@
+from .bernoulliCell import BernoulliCell
+from .poissonCell import PoissonCell

ngclearn/components/input_encoders/bernoulliCell.py

@@ -0,0 +1,123 @@
+from ngcsimlib.component import Component
+from jax import numpy as jnp, random, jit
+from functools import partial
+import time
+
+@jit
+def update_times(t, s, tols):
+    """
+    Updates time-of-last-spike (tols) variable.
+
+    Args:
+        t: current time (a scalar/int value)
+
+        s: binary spike vector
+
+        tols: current time-of-last-spike variable
+
+    Returns:
+        updated tols variable
+    """
+    _tols = (1. - s) * tols + (s * t)
+    return _tols
+
+@jit
+def sample_bernoulli(dkey, data):
+    """
+    Samples a Bernoulli spike train on-the-fly
+
+    Args:
+        data: sensory data (vector/matrix)
+
+        dt: integration time constant
+
+    Returns:
+        binary spikes
+    """
+    s_t = random.bernoulli(dkey, p=data).astype(jnp.float32)
+    return s_t
+
+class BernoulliCell(Component):
+    """
+    A Bernoulli cell that produces Bernoulli-distributed spikes on-the-fly.
+
+    Args:
+        name: the string name of this cell
+
+        n_units: number of cellular entities (neural population size)
+
+        key: PRNG key to control determinism of any underlying synapses
+            associated with this cell
+
+        useVerboseDict: triggers slower, verbose dictionary mode (Default: False)
+    """
+
+    ## Class Methods for Compartment Names
+    @classmethod
+    def inputCompartmentName(cls):
+        return 'in'
+
+    @classmethod
+    def outputCompartmentName(cls):
+        return 'out'
+
+    @classmethod
+    def timeOfLastSpikeCompartmentName(cls):
+        return 'tols'
+
+    ## Bind Properties to Compartments for ease of use
+    @property
+    def inputCompartment(self):
+        return self.compartments.get(self.inputCompartmentName(), None)
+
+    @inputCompartment.setter
+    def inputCompartment(self, inp):
+        self.compartments[self.inputCompartmentName()] = inp
+
+    @property
+    def outputCompartment(self):
+        return self.compartments.get(self.outputCompartmentName(), None)
+
+    @outputCompartment.setter
+    def outputCompartment(self, out):
+        self.compartments[self.outputCompartmentName()] = out
+
+    @property
+    def timeOfLastSpike(self):
+        return self.compartments.get(self.timeOfLastSpikeCompartmentName(), None)
+
+    @timeOfLastSpike.setter
+    def timeOfLastSpike(self, t):
+        self.compartments[self.timeOfLastSpikeCompartmentName()] = t
+
+    # Define Functions
+    def __init__(self, name, n_units, key=None, useVerboseDict=False, **kwargs):
+        super().__init__(name, useVerboseDict, **kwargs)
+
+        ##Random Number Set up
+        self.key = key
+        if self.key is None:
+            self.key = random.PRNGKey(time.time_ns())
+
+        ##Layer Size Setup
+        self.batch_size = 1
+        self.n_units = n_units
+        self.reset()
+
+    def verify_connections(self):
+        pass
+
+    def advance_state(self, t, dt, **kwargs):
+        self.key, *subkeys = random.split(self.key, 2)
+
+        self.outputCompartment = sample_bernoulli(subkeys[0], data=self.inputCompartment)
+        #self.timeOfLastSpike = (1 - self.outputCompartment) * self.timeOfLastSpike + (self.outputCompartment * t)
+        self.timeOfLastSpike = update_times(t, self.outputCompartment, self.timeOfLastSpike)
+
+    def reset(self, **kwargs):
+        self.inputCompartment = None
+        self.outputCompartment = jnp.zeros((self.batch_size, self.n_units)) #None
+        self.timeOfLastSpike = jnp.zeros((self.batch_size, self.n_units))
+
+    def save(self, **kwargs):
+        pass

ngclearn/components/input_encoders/poissonCell.py

@@ -0,0 +1,132 @@
+from ngcsimlib.component import Component
+from jax import numpy as jnp, random, jit
+from functools import partial
+import time
+
+@jit
+def update_times(t, s, tols):
+    """
+    Updates time-of-last-spike (tols) variable.
+
+    Args:
+        t: current time (a scalar/int value)
+
+        s: binary spike vector
+
+        tols: current time-of-last-spike variable
+
+    Returns:
+        updated tols variable
+    """
+    _tols = (1. - s) * tols + (s * t)
+    return _tols
+
+@partial(jit, static_argnums=[3])
+def sample_poisson(dkey, data, dt, fmax=63.75):
+    """
+    Samples a Poisson spike train on-the-fly.
+
+    Args:
+        data: sensory data (vector/matrix)
+
+        dt: integration time constant
+
+        fmax: maximum frequency (Hz)
+
+    Returns:
+        binary spikes
+    """
+    pspike = data * (dt/1000.) * fmax
+    eps = random.uniform(dkey, data.shape, minval=0., maxval=1., dtype=jnp.float32)
+    s_t = (eps < pspike).astype(jnp.float32)
+    return s_t
+
+class PoissonCell(Component):
+    """
+    A Poisson cell that produces approximately Poisson-distributed spikes on-the-fly.
+
+    Args:
+        name: the string name of this cell
+
+        n_units: number of cellular entities (neural population size)
+
+        max_freq: maximum frequency (in Hertz) of this Poisson spike train (must be > 0.)
+
+        key: PRNG key to control determinism of any underlying synapses
+            associated with this cell
+
+        useVerboseDict: triggers slower, verbose dictionary mode (Default: False)
+    """
+
+    ## Class Methods for Compartment Names
+    @classmethod
+    def inputCompartmentName(cls):
+        return 'in'
+
+    @classmethod
+    def outputCompartmentName(cls):
+        return 'out'
+
+    @classmethod
+    def timeOfLastSpikeCompartmentName(cls):
+        return 'tols'
+
+    ## Bind Properties to Compartments for ease of use
+    @property
+    def inputCompartment(self):
+        return self.compartments.get(self.inputCompartmentName(), None)
+
+    @inputCompartment.setter
+    def inputCompartment(self, inp):
+        self.compartments[self.inputCompartmentName()] = inp
+
+    @property
+    def outputCompartment(self):
+        return self.compartments.get(self.outputCompartmentName(), None)
+
+    @outputCompartment.setter
+    def outputCompartment(self, out):
+        self.compartments[self.outputCompartmentName()] = out
+
+    @property
+    def timeOfLastSpike(self):
+        return self.compartments.get(self.timeOfLastSpikeCompartmentName(), None)
+
+    @timeOfLastSpike.setter
+    def timeOfLastSpike(self, t):
+        self.compartments[self.timeOfLastSpikeCompartmentName()] = t
+
+    # Define Functions
+    def __init__(self, name, n_units, max_freq=63.75, key=None,
+                 useVerboseDict=False, **kwargs):
+        super().__init__(name, useVerboseDict, **kwargs)
+
+        ##Random Number Set up
+        self.key = key
+        if self.key is None:
+            self.key = random.PRNGKey(time.time_ns())
+
+        ## Poisson parameters
+        self.max_freq = max_freq ## maximum frequency (in Hertz/Hz)
+
+        ##Layer Size Setup
+        self.batch_size = 1
+        self.n_units = n_units
+        self.reset()
+
+    def verify_connections(self):
+        pass
+
+    def advance_state(self, t, dt, **kwargs):
+        self.key, *subkeys = random.split(self.key, 2)
+        self.outputCompartment = sample_poisson(subkeys[0], data=self.inputCompartment, dt=dt, fmax=self.max_freq)
+        #self.timeOfLastSpike = (1 - self.outputCompartment) * self.timeOfLastSpike + (self.outputCompartment * t)
+        self.timeOfLastSpike = update_times(t, self.outputCompartment, self.timeOfLastSpike)
+
+    def reset(self, **kwargs):
+        self.inputCompartment = None
+        self.outputCompartment = jnp.zeros((self.batch_size, self.n_units)) #None
+        self.timeOfLastSpike = jnp.zeros((self.batch_size, self.n_units))
+
+    def save(self, **kwargs):
+        pass

ngclearn/components/neurons/__init__.py

@@ -0,0 +1,9 @@
+## point to rate-coded cell componet types
+from .graded.rateCell import RateCell
+from .graded.gaussianErrorCell import GaussianErrorCell
+from .graded.laplacianErrorCell import LaplacianErrorCell
+## point to standard spiking cell component types
+from .spiking.sLIFCell import SLIFCell
+from .spiking.LIFCell import LIFCell
+from .spiking.quadLIFCell import QuadLIFCell
+from .spiking.izhikevichCell import IzhikevichCell

ngclearn/components/neurons/graded/__init__.py

@@ -0,0 +1,4 @@
+## point to rate-coded cell componet types
+from .rateCell import RateCell
+from .gaussianErrorCell import GaussianErrorCell
+from .laplacianErrorCell import LaplacianErrorCell

ngclearn/components/neurons/graded/gaussianErrorCell.py

@@ -0,0 +1,174 @@
+from ngcsimlib.component import Component
+from jax import numpy as jnp, random, jit
+from functools import partial
+import time, sys
+
+#@partial(jit, static_argnums=[3])
+def run_cell(dt, targ, mu, eType="gaussian"):
+    """
+    Moves cell dynamics one step forward.
+
+    Args:
+        dt: integration time constant
+
+        targ: target pattern value
+
+        mu: prediction value
+
+    Returns:
+        derivative w.r.t. mean "dmu", derivative w.r.t. target dtarg
+    """
+    return run_gaussian_cell(dt, targ, mu)
+
+@jit
+def run_gaussian_cell(dt, targ, mu):
+    """
+    Moves Gaussian cell dynamics one step forward. Specifically, this
+    routine emulates the error unit behavior of the local cost functional:
+
+    | L(targ, mu) = (1/2) * ||targ - mu||^2_2
+    | or log likelihood of the multivariate Gaussian with identity covariance
+
+    Args:
+        dt: integration time constant
+
+        targ: target pattern value
+
+        mu: prediction value
+
+    Returns:
+        derivative w.r.t. mean "dmu", derivative w.r.t. target dtarg
+    """
+    dmu = (targ - mu) # e (error unit)
+    dtarg = -dmu # reverse of e
+    return dmu, dtarg
+
+class GaussianErrorCell(Component): ## Rate-coded/real-valued error unit/cell
+    """
+    A simple (non-spiking) Gaussian error cell - this is a fixed-point solution
+    of a mismatch signal.
+
+    Args:
+        name: the string name of this cell
+
+        n_units: number of cellular entities (neural population size)
+
+        tau_m: (Unused -- currently cell is a fixed-point model)
+
+        leakRate: (Unused -- currently cell is a fixed-point model)
+
+        key: PRNG Key to control determinism of any underlying synapses
+            associated with this cell
+
+        useVerboseDict: triggers slower, verbose dictionary mode (Default: False)
+    """
+
+    ## Class Methods for Compartment Names
+    @classmethod
+    def inputCompartmentName(cls):
+        return 'j' ## electrical current
+
+    @classmethod
+    def outputCompartmentName(cls):
+        return 'e' ## rate-coded output
+
+    @classmethod
+    def meanName(cls):
+        return 'mu'
+
+    @classmethod
+    def derivMeanName(cls):
+        return 'dmu'
+
+    @classmethod
+    def targetName(cls):
+        return 'target'
+
+    @classmethod
+    def derivTargetName(cls):
+        return 'dtarget'
+
+    @classmethod
+    def modulatorName(cls):
+        return 'modulator'
+
+    ## Bind Properties to Compartments for ease of use
+    @property
+    def mean(self):
+        return self.compartments.get(self.meanName(), None)
+
+    @mean.setter
+    def mean(self, inp):
+        self.compartments[self.meanName()] = inp
+
+    @property
+    def derivMean(self):
+        return self.compartments.get(self.derivMeanName(), None)
+
+    @derivMean.setter
+    def derivMean(self, inp):
+        self.compartments[self.derivMeanName()] = inp
+
+    @property
+    def target(self):
+        return self.compartments.get(self.targetName(), None)
+
+    @target.setter
+    def target(self, inp):
+        self.compartments[self.targetName()] = inp
+
+    @property
+    def derivTarget(self):
+        return self.compartments.get(self.derivTargetName(), None)
+
+    @derivTarget.setter
+    def derivTarget(self, inp):
+        self.compartments[self.derivTargetName()] = inp
+
+    @property
+    def modulator(self):
+        return self.compartments.get(self.modulatorName(), None)
+
+    @modulator.setter
+    def modulator(self, inp):
+        self.compartments[self.modulatorName()] = inp
+
+    # Define Functions
+    def __init__(self, name, n_units, tau_m=0., leakRate=0., key=None,
+                 useVerboseDict=False, **kwargs):
+        super().__init__(name, useVerboseDict, **kwargs)
+
+        ##Random Number Set up
+        self.key = key
+        if self.key is None:
+            self.key = random.PRNGKey(time.time_ns())
+
+        ##Layer Size Setup
+        self.n_units = n_units
+        self.batch_size = 1
+
+        ## Set up bundle for multiple inputs of current
+        self.reset()
+
+    def verify_connections(self):
+        #self.metadata.check_incoming_connections(self.inputCompartmentName(), min_connections=1)
+        self.metadata.check_incoming_connections(self.meanName(), min_connections=1)
+        self.metadata.check_incoming_connections(self.targetName(), min_connections=1)
+
+    def advance_state(self, t, dt, **kwargs):
+        ## currently only Gaussian error cells supported
+        self.derivMean, self.derivTarget = run_cell(dt, self.target, self.mean)
+        if self.modulator is not None:
+            self.derivMean = self.derivMean * self.modulator
+            self.derivTarget = self.derivTarget * self.modulator
+            self.modulator = None ## use and consume modulator
+
+    def reset(self, **kwargs):
+        self.derivMean = jnp.zeros((self.batch_size, self.n_units))
+        self.derivTarget = jnp.zeros((self.batch_size, self.n_units))
+        self.target = jnp.zeros((self.batch_size, self.n_units)) #None
+        self.mean = jnp.zeros((self.batch_size, self.n_units)) #None
+        self.modulator = None
+
+    def save(self, **kwargs):
+        pass