NeMoS (Neural ModelS) is a statistical modeling framework optimized for systems neuroscience and powered by JAX. It streamlines the process of defining and selecting models, through a collection of easytouse methods for feature design.
The core of NeMoS includes GPUaccelerated, welltested implementations of standard statistical models, currently focusing on the Generalized Linear Model (GLM).
We provide a Poisson GLM for analyzing spike counts, and a Gamma GLM for calcium or voltage imaging traces.
The package is under active development and more methods will be added in the future.
For those looking to get a better grasp of the Generalized Linear Model, we recommend checking out the Neuromatch Academy's lesson here and Jonathan Pillow's tutorial from Cosyne 2018 here.
Overview
At his core, NeMoS consists of two primary modules: the basis
and the glm
module.
The basis
module focuses on designing model features (inputs) for the GLM. It includes a suite of composable feature
constructors that accept timeseries data as inputs. These inputs can be any observed variables, such as presented
stimuli, head direction, position, or spike counts.
The basis objects can perform two types of transformations on the inputs:

Nonlinear Mapping: This process transforms the input data through a nonlinear function, allowing it to capture complex, nonlinear relationships between inputs and neuronal firing rates. Importantly, this transformation preserves the properties that makes GLM easy to fit and guarantee a single optimal solution (e.g. convexity).

Convolution: This applies a convolution of the input data with a bank of filters, designed to capture linear temporal effects. This transformation is particularly useful when analyzing data with inherent time dependencies or when the temporal dynamics of the input are significant.
Both transformations produce a vector of features X
that changes over time, with a shape
of (n_time_points, n_features)
.
On the other hand, the glm
module maps the feature to spike counts. It is used to learn the GLM weights,
evaluating the model performance, and explore its behavior on new input.
Examples
Here's a brief demonstration of how the basis
and glm
modules work together within NeMoS.
Poisson GLM for features analysis
In this example, we'll construct a timeseries of features using the basis objects, applying a nonlinear mapping (default behavior):
Feature Representation
import nemos as nmo
# Instantiate the basis
basis_1 = nmo.basis.MSplineBasis(n_basis_funcs=5)
basis_2 = nmo.basis.CyclicBSplineBasis(n_basis_funcs=6)
basis_3 = nmo.basis.MSplineBasis(n_basis_funcs=7)
basis = basis_1 * basis_2 + basis_3
# Generate the design matrix starting from some raw
# input time series, i.e. LFP phase, position, etc.
X = basis.compute_features(input_1, input_2, input_3)
GLM
# Fit the model mapping X to the spike count
# timeseries y
glm = nmo.glm.GLM().fit(X, y)
# Inspect the learned coefficients
print(glm.coef_, glm.intercept_)
# compute the rate
firing_rate = glm.predict(X)
# compute loglikelihood
ll = glm.score(X, y)
Poisson GLM for neural population
This second example demonstrates feature construction by convolving the simultaneously recorded population spike counts with a bank of filters, utilizing the basis in conv
mode.
The figure above show the GLM scheme for a single neuron, however in NeMoS you can fit jointly the whole population with the PopulationGLM
object.
Feature Representation
import nemos as nmo
# assume that the population spike counts timeseries is stored
# in a 2D array spike_counts of shape (n_samples, n_neurons).
# generate 5 basis functions of 100 timebins,
# and convolve the counts with the basis.
X = nmo.basis.RaisedCosineBasisLog(5, mode="conv", window_size=100
).compute_features(spike_counts)
Population GLM
# fit a GLM to the first neuron counts timeseries
glm = nmo.glm.PopulationGLM().fit(X, spike_counts)
# compute the rate
firing_rate = glm.predict(X)
# compute loglikelihood
ll = glm.score(X, spike_counts)
For a deeper dive, see our Quickstart guide and consider using pynapple for data exploration and preprocessing. When initializing the GLM object, you may optionally specify an observation model and a regularizer.
Multiepoch convolution
If your data is formatted as a pynapple
timeseries, the convolution performed by the basis objects will be
executed epochbyepoch, avoiding the risk of introducing artifacts from gaps in your timeseries.
Installation
Run the following pip
command in your virtual environment.
For macOS/Linux users:
pip install nemos
For Windows users:
python m pip install nemos
For more details, including specifics for GPU users and developers, refer to NeMoS docs.
Disclaimer
Please note that this package is currently under development. While you can download and test the functionalities that are already present, please be aware that syntax and functionality may change before our preliminary release.
Getting help and getting in touch
We communicate via several channels on Github:
 To report a bug, open an issue.
 To ask usage questions, discuss broad issues, or show off what you’ve made with NeMoS, go to Discussions.
 To send suggestions for extensions or enhancements, please post in the ideas section of discussions first. We’ll discuss it there and, if we decide to pursue it, open an issue to track progress.
 To contribute to the project, see the contributing guide.
In all cases, we request that you respect our code of conduct.