PySINDy Documentation

PySINDy is a Python package designed for the discovery of governing dynamical systems models from data using the Sparse Identification of Nonlinear Dynamics (SINDy) approach.

Given state measurements $\mathbf{x}(t)$, PySINDy seeks to find a function $\mathbf{f}$ such that $\frac{d}{dt}\mathbf{x}(t) = \mathbf{f}(\mathbf{x}(t))$. It treats model discovery as a sparse regression problem, selecting relevant terms for the model from a library of candidate functions. This results in parsimonious, interpretable, and generalizable models that avoid overfitting.

Key characteristics:

• Scikit-learn compatible: The core SINDy model class is implemented as a scikit-learn estimator, allowing it to be used in standard machine learning pipelines (e.g., for parameter tuning or model selection).
• Extensible: Users can customize the differentiation methods, feature libraries, and sparse regression algorithms.

PySINDy is a Python package for Sparse Identification of Nonlinear Dynamics (SINDy), a method for discovering the governing equations of a dynamical system directly from data.

The Core Concept

SINDy assumes that the dynamical evolution of a state variable $\mathbf{q}(t)$ follows an Ordinary Differential Equation (ODE) of the form: $$\frac{d}{dt} \mathbf{q} = \mathbf{f}(\mathbf{q})$$

The method approximates the function $\mathbf{f}(\mathbf{q})$ as a sparse combination of terms from a library of candidate basis functions $\boldsymbol{\theta}(\mathbf{q})$: $$\mathbf{f}(\mathbf{q}) \approx \sum_{k=1}^{p}\theta_k(\mathbf{q})\boldsymbol\xi_k, \quad \text{or} \quad \frac{d}{dt}\mathbf{q} \approx \mathbf{\Theta}(\mathbf{q})\mathbf{\Xi}$$

Where:

• $\mathbf{\Theta}(\mathbf{q})$ is the library of candidate terms.
• $\mathbf{\Xi}$ contains the sparse coefficients to be identified.

The Workflow

1. Data Collection: Collect state measurements $\mathbf{Q}$ sampled at time steps $t_1, ..., t_m$.
2. Derivative Computation: Compute a matrix of time derivatives $\mathbf{Q}_t$ from the data $\mathbf{Q}$. PySINDy supports various methods including finite differences, Savitzky-Golay, spectral, spline, and total variational derivatives.
3. Sparse Regression: Solve the optimization problem to find coefficients $\mathbf{\Xi}$ that minimize the error while promoting sparsity (using regularizers like $l_0$ or $l_1$ and algorithms like SR3): $$\text{argmin}_{\boldsymbol\Xi}|\mathbf Q_t - \boldsymbol\Theta(\mathbf{Q}) \boldsymbol\Xi|^2 + R(\boldsymbol\Xi)$$

SINDy (Sparse Identification of Nonlinear Dynamical systems) is a method used to discover the governing equations of a dynamical system from measurement data. It assumes that the time evolution of a system $\dot{x}(t) = f(x(t))$ can be represented as a sparse linear combination of basis functions.

In PySINDy, the approximation problem $\dot{X} \approx \Theta(X)\Xi$ is decomposed into three main functional areas:

1. Numerical Differentiation: Computing the time derivatives $\dot{X}$ from the state measurements $X$.
2. Feature Library: Constructing the library matrix $\Theta(X)$, which contains the chosen set of basis functions (e.g., polynomials, trigonometric functions) applied to the data.
3. Sparse Regression: Using optimizers to solve for the sparse coefficient matrix $\Xi$ that best fits the data.

The main SINDy class encapsulates these three components to automate the discovery process.

The SINDy method assumes dynamics can be represented as a sparse linear combination of library functions.

Library Selection Strategies:

• Polynomials: A good starting point for smooth functions (Taylor series approximation).
• Custom/Specific Bases: Use Chebyshev polynomials if you expect the dynamics to be better represented by them.
• Incremental Expansion: Start with a small library (e.g., linear terms) and gradually add higher-order terms (quadratic, cubic) to avoid ill-conditioning.

Available Library Classes:

• CustomLibrary: Use this when you have a set of functions to apply to each measurement variable or combinations of variables.
• IdentityLibrary: The most customizable. It expects all features to be pre-computed and present in X before calling SINDy.fit. It simply applies an identity map.
• BaseFeatureLibrary: Inherit from this class to implement your own custom library class.

PySINDy is built around the abstract base class _BaseSINDy, which represents the problem of fitting a dynamical system $X' = \Xi^T \Theta(X)$.

The primary concrete implementation is the SINDy class, which follows a traditional approach by composing three main components:

1. Differentiation Method (BaseDifferentiation): Computes the derivative $X'$. These are often callable objects and may accept axis and order arguments.
2. Feature Library (BaseFeatureLibrary): Specifies the candidate basis functions $\Theta(X)$. The fit() method determines the number and string format of features. You can inspect features using get_feature_names() or n_features_out_.
3. Optimizer (BaseOptimizer): Implements sparse regression to solve for $\Xi$. Optimizers share a history_ of coefficient values and a coef_ array of final coefficients.

Once a SINDy object is created, it follows a scikit-learn style workflow:

• fit(X, t): Fit the model to measurement data.
• predict(X): Predict derivatives given new measurements.
• simulate(x0, t): Evolve novel initial conditions forward in time.
• score(X, t): Evaluate the model performance.