From 3cac69c5ffaab91b9531043116eb6fad6862a090 Mon Sep 17 00:00:00 2001 From: Jake Stevens-Haas Date: Tue, 14 Jun 2022 08:49:42 -0700 Subject: [PATCH 01/12] TST: Add Notebook tests Tests are skipped by default. Run `pytest -m "slow"` in order to run slow tests. Also require upgrading to pytest ~=6.0.0 in order to read pyproject.toml configs. Change pyproject.toml black table to use extend-exclude, which also excludes anything gitignored --- pyproject.toml | 7 ++++--- requirements-dev.txt | 3 ++- test/test_notebooks.py | 33 +++++++++++++++++++++++++++++++++ 3 files changed, 39 insertions(+), 4 deletions(-) create mode 100644 test/test_notebooks.py diff --git a/pyproject.toml b/pyproject.toml index f7518e09..6f536562 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -7,7 +7,7 @@ write_to = "pysindy/version.py" [tool.black] line-length = 88 -exclude = ''' +extend-exclude = ''' /( \.git | \.mypy_cache @@ -20,5 +20,6 @@ exclude = ''' [tool.pytest.ini_options] filterwarnings = [ "ignore::RuntimeWarning", - "ignore::UserWarning" -] \ No newline at end of file + "ignore::UserWarning",] +addopts = '-m "not slow"' +markers = ["slow"] \ No newline at end of file diff --git a/requirements-dev.txt b/requirements-dev.txt index b8b3d402..9ef8781f 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -1,6 +1,7 @@ -e . -r requirements.txt -pytest +pytest~=6.0.0 +black pytest-cov pytest-lazy-fixture flake8-builtins-unleashed diff --git a/test/test_notebooks.py b/test/test_notebooks.py new file mode 100644 index 00000000..acc81d95 --- /dev/null +++ b/test/test_notebooks.py @@ -0,0 +1,33 @@ +import os +import sys +from pathlib import Path + +import nbformat +import pytest +from nbconvert.preprocessors import ExecutePreprocessor + +notebook_dir = Path(__file__).parent.parent / "examples" +notebooks = [nb.name for nb in notebook_dir.glob("*.ipynb")] + + +def _load_notebook(filename: Path) -> str: + with open(filename, "r") as fh: + notebook = nbformat.read(fh, as_version=4) + return notebook + + +def _create_kernel(): + from ipykernel import kernelapp as app + + kernel_name = sys.executable.replace("/", ".").replace("\\", ".").replace(":", ".") + app.launch_new_instance(argv=["install", "--user", "--name", kernel_name]) + return kernel_name + + +@pytest.mark.parametrize("filename", notebooks) +@pytest.mark.slow +def test_notebook(filename): + nb = _load_notebook(notebook_dir / filename) + os.chdir(notebook_dir) + ExecutePreprocessor(timeout=-1, kernel=_create_kernel).preprocess(nb) + os.chdir(Path(__file__).parent) From e0310ad17fe4947f700221626765e11dd45f79d3 Mon Sep 17 00:00:00 2001 From: Jake Stevens-Haas Date: Tue, 14 Jun 2022 14:01:50 -0700 Subject: [PATCH 02/12] TST: Comments and docstrings in test_notebooks --- test/test_notebooks.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/test/test_notebooks.py b/test/test_notebooks.py index acc81d95..04477ebf 100644 --- a/test/test_notebooks.py +++ b/test/test_notebooks.py @@ -4,21 +4,23 @@ import nbformat import pytest +from ipykernel import kernelapp as app from nbconvert.preprocessors import ExecutePreprocessor +# Find all example notebooks notebook_dir = Path(__file__).parent.parent / "examples" notebooks = [nb.name for nb in notebook_dir.glob("*.ipynb")] -def _load_notebook(filename: Path) -> str: +def _load_notebook(filename: Path) -> nbformat.NotebookNode: + """Load Jupyter Notebook as NotebookNode object.""" with open(filename, "r") as fh: notebook = nbformat.read(fh, as_version=4) return notebook -def _create_kernel(): - from ipykernel import kernelapp as app - +def _create_kernel() -> str: + """Create a IPython Kernel for the current executable.""" kernel_name = sys.executable.replace("/", ".").replace("\\", ".").replace(":", ".") app.launch_new_instance(argv=["install", "--user", "--name", kernel_name]) return kernel_name @@ -28,6 +30,8 @@ def _create_kernel(): @pytest.mark.slow def test_notebook(filename): nb = _load_notebook(notebook_dir / filename) + # Need to run in notebook directory to find data via relative path os.chdir(notebook_dir) + # Run the notebook ExecutePreprocessor(timeout=-1, kernel=_create_kernel).preprocess(nb) os.chdir(Path(__file__).parent) From 49f0f40563cd53e2afcccf05cf52b3543cee9483 Mon Sep 17 00:00:00 2001 From: Jake Stevens-Haas Date: Tue, 14 Jun 2022 14:02:48 -0700 Subject: [PATCH 03/12] CI: test all notebooks --- .github/workflows/main.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 518a8e69..48c820e2 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -36,7 +36,7 @@ jobs: pip install -r requirements-dev.txt - name: Test with pytest run: | - pytest test --cov=pysindy --cov-report=xml + pytest test --cov=pysindy --cov-report=xml -m "slow or not slow" - name: Upload coverage to Codecov uses: codecov/codecov-action@v1 with: From f01df76f7b405f213291ee967414f377c08ea482 Mon Sep 17 00:00:00 2001 From: Jake Stevens-Haas Date: Wed, 15 Jun 2022 11:04:40 -0700 Subject: [PATCH 04/12] CI: Add sympy install to workflow for nb 9 --- .github/workflows/main.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 48c820e2..903fc916 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -34,6 +34,7 @@ jobs: - name: Install dependencies run: | pip install -r requirements-dev.txt + pip install sympy # needed for notebook 9, but not required for pysindy - name: Test with pytest run: | pytest test --cov=pysindy --cov-report=xml -m "slow or not slow" From 6074eed0b9e5f4ebf825115a43d26f926e06b8eb Mon Sep 17 00:00:00 2001 From: Jake Stevens-Haas Date: Tue, 5 Jul 2022 15:33:01 -0700 Subject: [PATCH 05/12] CLN: Add some infrastructure for tests/develop notebooks Add jupytext dev requirements. Jupytext creates notebooks from scripts. Add publish_notebook.py script to regenerate and run notebook. Demonstrated on the shortest notebook we have. Added some flake8 config to handle the idiosyncracies of python files created from notebooks (long comments and imports not at top) --- examples/2_introduction_to_sindy.ipynb | 510 ----------------- .../2_introduction_to_sindy/example.ipynb | 516 ++++++++++++++++++ examples/2_introduction_to_sindy/example.py | 200 +++++++ .../2_introduction_to_sindy/example_data.py | 17 + examples/2_introduction_to_sindy/mock_data.py | 17 + examples/publish_notebook.py | 39 ++ requirements-dev.txt | 1 + setup.cfg | 3 + 8 files changed, 793 insertions(+), 510 deletions(-) delete mode 100644 examples/2_introduction_to_sindy.ipynb create mode 100644 examples/2_introduction_to_sindy/example.ipynb create mode 100644 examples/2_introduction_to_sindy/example.py create mode 100644 examples/2_introduction_to_sindy/example_data.py create mode 100644 examples/2_introduction_to_sindy/mock_data.py create mode 100644 examples/publish_notebook.py diff --git a/examples/2_introduction_to_sindy.ipynb b/examples/2_introduction_to_sindy.ipynb deleted file mode 100644 index 7d7a1136..00000000 --- a/examples/2_introduction_to_sindy.ipynb +++ /dev/null @@ -1,510 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "ExecuteTime": { - "end_time": "2020-04-09T18:27:44.551977Z", - "start_time": "2020-04-09T18:27:44.544309Z" - } - }, - "source": [ - "# An introduction to Sparse Identification of Nonlinear Dynamical systems (SINDy)\n", - "This notebook gives an overview of the Sparse Identification of Nonlinear Dynamical systems (SINDy) method and discusses the relationship between SINDy and PySINDy. It also includes a brief example showing how different objects in the SINDy method are represented in PySINDy." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/dynamicslab/pysindy/v1.7?filepath=examples/2_introduction_to_sindy.ipynb)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Main ideas\n", - "Suppose we have a set of measurements $x(t)\\in \\mathbb{R}^n$ from some physical system at different points in time $t$. SINDy seeks to represent the time evolution of $x(t)$ in terms of a nonlinear function $f$:\n", - "\n", - "$$ \\frac{d}{dt}x(t) = f(x(t)). $$\n", - "\n", - "This equation constitutes a *dynamical system* for the measurements $x(t)$. The vector $x(t)=[x_1(t), x_2(t), \\dots x_n(t)]^\\top$ gives the state of the physical system at time $t$. The function $f(x(t))$ constrains how the system evolves in time.\n", - "\n", - "The key idea behind SINDy is that the function $f$ is often **sparse** in the space of an appropriate set of basis functions. For example, the function\n", - "\n", - "$$ \n", - "\t\\frac{d}{dt}x = f(x)\n", - "\t= \\begin{bmatrix} f_1(x)\\\\f_2(x) \\end{bmatrix}\n", - "\t= \\begin{bmatrix}1 - x_1 + 3x_1x_2 \\\\ x_2^2 - 5x_1^3 \\end{bmatrix}\n", - "$$\n", - "\n", - "is sparse with respect to the set of polynomials of two variables in the sense that if we were to write an expansion of the component functions of $f$ in this basis (e.g. $f_{1}(x) = \\sum_{i=0}^\\infty\\sum_{j=0}^\\infty a_{i,j}x_1^ix_2^j$), only a small number of coefficients ($a_{i,j}$) would be nonzero.\n", - "\n", - "SINDy employs **sparse regression** to find a linear combination of basis functions that best capture the dynamic behavior of the physical system." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Approximation problem\n", - "To apply SINDy in practice one needs a set of measurement data collected at times $t_1, t_2, \\dots, t_n$, and the time derivatives of these measurements (either measured directly or numerically approximated). These data are aggregated into the matrices $X$ and $\\dot X$, respectively\n", - "\n", - "$$\n", - "\tX = \\begin{bmatrix}\n", - "\t\tx_1(t_1) & x_2(t_1) & \\dots & x_n(t_1) \\\\\n", - "\t\tx_1(t_2) & x_2(t_2) & \\dots & x_n(t_2) \\\\\n", - "\t\t\\vdots & \\vdots & & \\vdots \\\\ x_1(t_m) & x_2(t_m) & \\dots & x_n(t_m)\n", - "\t\\end{bmatrix},\n", - "\t\\qquad\n", - "\t\\dot{X} = \\begin{bmatrix} \\dot{x_1}(t_1) & \\dot{x_2}(t_1) & \\dots & \\dot{x_n}(t_1) \\\\\n", - "\t\t\\dot{x_1}(t_2) & \\dot{x_2}(t_2) & \\dots & \\dot{x_n}(t_2) \\\\\n", - "\t\t\\vdots & \\vdots & & \\vdots \\\\\n", - "\t\t\\dot{x_1}(t_m) & \\dot{x_2}(t_m) & \\dots & \\dot{x_n}(t_m)\n", - "\t\\end{bmatrix}.\n", - "$$\n", - "\n", - "Next, one forms a library matrix $\\Theta(X)$ whose columns consist of a chosen set of basis functions applied to the data\n", - "\n", - "$$\n", - "\t\\Theta(X) = \\begin{bmatrix}\n", - "\t\t\\mid & \\mid & & \\mid \\\\\n", - "\t\t\\theta_1(X) & \\theta_2(X) & \\dots & \\theta_\\ell(X) \\\\\n", - "\t\t\\mid & \\mid & & \\mid \n", - "\t\\end{bmatrix}.\n", - "$$\n", - "\n", - "For example, if $\\theta_1(x), \\theta_2(x), \\dots, \\theta_\\ell(x)$ are monomials ($\\theta_i(x) = x^{i-1}$), then \n", - "\n", - "$$\n", - "\t\\theta_3(X) = \\begin{bmatrix}\n", - "\t\t\\mid & \\mid & & \\mid & \\mid & & \\mid \\\\\n", - "\t\tx_1(t)^2 & x_1(t)x_2(t) & \\dots & x_2(t)^2 & x_2(t)x_3(t) & \\dots & x_n^2(t) \\\\\n", - "\t\t\\mid & \\mid & & \\mid & \\mid & & \\mid\n", - "\t\\end{bmatrix},\n", - "$$\n", - "\n", - "where vector products and powers are understood to be element-wise.\n", - "\n", - "We seek a set of sparse coefficient vectors (collected into a matrix)\n", - "\n", - "$$\n", - "\t\\Xi = \\begin{bmatrix}\n", - "\t\t\\mid & \\mid & & \\mid \\\\\n", - "\t\t\\xi_1 & \\xi_2 & \\dots & \\xi_n \\\\\n", - "\t\t\\mid & \\mid & & \\mid\n", - "\t\\end{bmatrix}.\n", - "$$\n", - "\n", - "The vector $\\xi_i$ provides the coefficients for a linear combination of basis functions $\\theta_1(x), \\theta_2(x), \\dots, \\theta_\\ell(x)$ representing the $i$th component function of $f$: $f_i(x)$. That is to say, $f_i(x) = \\Theta\\left(x^\\top\\right) \\xi_i$, where $\\Theta\\left(x^\\top\\right)$ is understood to be a row vector consisting of symbolic functions (whereas $\\Theta(X)$ is a matrix whose entries are numerical values).\n", - "\n", - "With each of the objects $X$, $\\dot X$, $\\Theta(X)$, and $\\Xi$ being defined, we are ready to write down the approximation problem underlying SINDy:\n", - "\n", - "$$ \\dot X \\approx \\Theta(X)\\Xi. $$" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Structure of PySINDy\n", - "The submodules of PySINDy are each aligned with one of the terms in the aforementioned approximation equation\n", - "\n", - "$$ \\dot X \\approx \\Theta(X)\\Xi. $$\n", - "\n", - " * `pysindy.differentiate` performs numerical differentiation to compute $\\dot X$ from $X$;\n", - " * `pysindy.feature_library` allows the user to specify a set of library functions and handles the formation of $\\Theta(X)$;\n", - " * `pysindy.optimizers` provides a set of sparse regression solvers for determining $\\Xi$.\n", - "\n", - "The `SINDy` object encapsulates one class object from each of these three submodules and uses them, along with a user-supplied data matrix, to find a governing dynamical system.\n", - "\n", - "Let's walk through an example showing how this works using a toy dataset." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Example\n", - "Suppose we have measurements of the position of a particle obeying the following dynamical system at different points in time:\n", - "\n", - "$$\n", - "\t\\frac{d}{dt} \\begin{bmatrix} x \\\\ y \\end{bmatrix}\n", - "\t= \\begin{bmatrix} -2x \\\\ y \\end{bmatrix}\n", - "\t= \\begin{bmatrix} -2 & 0 \\\\ 0 & 1 \\end{bmatrix}\n", - "\t\\begin{bmatrix} x \\\\ y \\end{bmatrix}\n", - "$$\n", - "\n", - "Note that this system of differential equations decouples into two differential equations whose solutions are simply $x(t) = x_0e^{-2t}$ and $y(t) = y_0e^t$, where $x_0 = x(0)$ and $y_0=y(0)$ are the initial conditions.\n", - "\n", - "Using the initial conditions $x_0 = 3$ and $y_0 = \\tfrac{1}{2}$, we construct the data matrix $X$." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-06T19:30:34.476137Z", - "start_time": "2020-05-06T19:30:33.805539Z" - } - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pysindy as ps" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-06T19:30:34.484161Z", - "start_time": "2020-05-06T19:30:34.479291Z" - } - }, - "outputs": [], - "source": [ - "t = np.linspace(0, 1, 100)\n", - "x = 3 * np.exp(-2 * t)\n", - "y = 0.5 * np.exp(t)\n", - "X = np.stack((x, y), axis=-1) # First column is x, second is y" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "ExecuteTime": { - "end_time": "2020-04-09T18:40:02.813464Z", - "start_time": "2020-04-09T18:40:02.804987Z" - } - }, - "source": [ - "We can select a differentiation method from the `differentiation` submodule." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-06T19:30:34.556434Z", - "start_time": "2020-05-06T19:30:34.486716Z" - } - }, - "outputs": [], - "source": [ - "differentiation_method = ps.FiniteDifference(order=2)\n", - "\n", - "# We could instead call ps.differentiation.FiniteDifference(order=2)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "While we could use this method to compute $\\dot X$ \"by hand,\" it is often more convenient to pass it into the `SINDy` object and let the computation of $\\dot X$ be handled automatically.\n", - "\n", - "The candidate library can be specified with an object from the `feature_library` submodule, which will also be passed into the `SINDy` object." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-06T19:30:34.627472Z", - "start_time": "2020-05-06T19:30:34.561177Z" - } - }, - "outputs": [], - "source": [ - "feature_library = ps.PolynomialLibrary(degree=3)\n", - "\n", - "# Note: We could instead call ps.feature_library.PolynomialLibrary(degree=3)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next we select which optimizer should be used." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-06T19:30:34.694085Z", - "start_time": "2020-05-06T19:30:34.632427Z" - } - }, - "outputs": [], - "source": [ - "optimizer = ps.STLSQ(threshold=0.2)\n", - "\n", - "# Note: We could instead call ps.optimizers.STLSQ(threshold=0.2)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, we bring these three components together in one `SINDy` object." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-06T19:30:34.781346Z", - "start_time": "2020-05-06T19:30:34.699244Z" - } - }, - "outputs": [], - "source": [ - "model = ps.SINDy(\n", - " differentiation_method=differentiation_method,\n", - " feature_library=feature_library,\n", - " optimizer=optimizer,\n", - " feature_names=[\"x\", \"y\"]\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Following the `scikit-learn` workflow, we first instantiate a `SINDy` class object with the desired properties, then fit it to the data in separate step." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-06T19:30:34.892681Z", - "start_time": "2020-05-06T19:30:34.789619Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "SINDy(differentiation_method=FiniteDifference(),\n", - " feature_library=PolynomialLibrary(degree=3), feature_names=['x', 'y'],\n", - " optimizer=STLSQ(threshold=0.2))" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.fit(X, t=t)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can inspect the governing equations discovered by the model and check whether they seem reasonable with the `print` function." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-06T19:30:34.951590Z", - "start_time": "2020-05-06T19:30:34.898283Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(x)' = -2.000 x\n", - "(y)' = 1.000 y\n" - ] - } - ], - "source": [ - "model.print()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Once the SINDy model has been fit we can use it to evolve new initial conditions forward in time with the `simulate` function." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-06T19:30:35.056598Z", - "start_time": "2020-05-06T19:30:34.955999Z" - } - }, - "outputs": [], - "source": [ - "x0 = 6\n", - "y0 = -0.1\n", - "\n", - "t_test = np.linspace(0, 1, 100)\n", - "x_test = x0 * np.exp(-2 * t_test)\n", - "y_test = y0 * np.exp(t_test)\n", - "\n", - "sim = model.simulate([x0, y0], t=t_test)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-06T19:30:35.724879Z", - "start_time": "2020-05-06T19:30:35.059810Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.figure()\n", - "plt.plot(x0, y0, \"ro\", label=\"Initial condition\", alpha=0.6, markersize=8)\n", - "plt.plot(x_test, y_test, \"b\", label=\"Exact solution\", alpha=0.4, linewidth=4)\n", - "plt.plot(sim[:, 0], sim[:, 1], \"k--\", label=\"SINDy model\", linewidth=3)\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that if the library we had chosen had been inappropriate for the problem at hand (i.e. if the dynamics could not be well-approximated as a sparse linear combination of library functions), then SINDy would have failed to produce a reasonable model. For example, if we solve the same problem, but using sines and cosines as our basis functions, SINDy is unable to find a sparse model for the dynamics:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-06T19:30:35.741380Z", - "start_time": "2020-05-06T19:30:35.728187Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(x)' = 0.772 sin(1 x) + 2.097 cos(1 x) + -2.298 sin(1 y) + -3.115 cos(1 y)\n", - "(y)' = 1.362 sin(1 y) + -0.222 cos(1 y)\n" - ] - } - ], - "source": [ - "# Populate the library with trigonometric functions\n", - "feature_library = ps.FourierLibrary()\n", - "\n", - "model = ps.SINDy(\n", - " differentiation_method=differentiation_method,\n", - " feature_library=feature_library,\n", - " optimizer=optimizer,\n", - " feature_names=[\"x\", \"y\"]\n", - ")\n", - "model.fit(X, t=t)\n", - "model.print()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.4" - }, - "toc": { - "base_numbering": 1, - "nav_menu": {}, - "number_sections": true, - "sideBar": true, - "skip_h1_title": false, - "title_cell": "Table of Contents", - "title_sidebar": "Contents", - "toc_cell": false, - "toc_position": {}, - "toc_section_display": true, - "toc_window_display": false - }, - "varInspector": { - "cols": { - "lenName": 16, - "lenType": 16, - "lenVar": 40 - }, - "kernels_config": { - "python": { - "delete_cmd_postfix": "", - "delete_cmd_prefix": "del ", - "library": "var_list.py", - "varRefreshCmd": "print(var_dic_list())" - }, - "r": { - "delete_cmd_postfix": ") ", - "delete_cmd_prefix": "rm(", - "library": "var_list.r", - "varRefreshCmd": "cat(var_dic_list()) " - } - }, - "types_to_exclude": [ - "module", - "function", - "builtin_function_or_method", - "instance", - "_Feature" - ], - "window_display": false - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/examples/2_introduction_to_sindy/example.ipynb b/examples/2_introduction_to_sindy/example.ipynb new file mode 100644 index 00000000..3118e703 --- /dev/null +++ b/examples/2_introduction_to_sindy/example.ipynb @@ -0,0 +1,516 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "689291af", + "metadata": { + "lines_to_next_cell": 0 + }, + "source": [ + "# An introduction to Sparse Identification of Nonlinear Dynamical systems (SINDy)\n", + "This notebook gives an overview of the Sparse Identification of Nonlinear Dynamical systems (SINDy) method and discusses the relationship between SINDy and PySINDy. It also includes a brief example showing how different objects in the SINDy method are represented in PySINDy." + ] + }, + { + "cell_type": "markdown", + "id": "6ea0d61d", + "metadata": { + "lines_to_next_cell": 0 + }, + "source": [ + "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/dynamicslab/pysindy/v1.7?filepath=examples/2_introduction_to_sindy.ipynb)" + ] + }, + { + "cell_type": "markdown", + "id": "45da8981", + "metadata": { + "lines_to_next_cell": 0 + }, + "source": [ + "## Main ideas\n", + "Suppose we have a set of measurements $x(t)\\in \\mathbb{R}^n$ from some physical system at different points in time $t$. SINDy seeks to represent the time evolution of $x(t)$ in terms of a nonlinear function $f$:\n", + "\n", + "$$ \\frac{d}{dt}x(t) = f(x(t)). $$\n", + "\n", + "This equation constitutes a *dynamical system* for the measurements $x(t)$. The vector $x(t)=[x_1(t), x_2(t), \\dots x_n(t)]^\\top$ gives the state of the physical system at time $t$. The function $f(x(t))$ constrains how the system evolves in time.\n", + "\n", + "The key idea behind SINDy is that the function $f$ is often **sparse** in the space of an appropriate set of basis functions. For example, the function\n", + "\n", + "$$\n", + "\t\\frac{d}{dt}x = f(x)\n", + "\t= \\begin{bmatrix} f_1(x)\\\\f_2(x) \\end{bmatrix}\n", + "\t= \\begin{bmatrix}1 - x_1 + 3x_1x_2 \\\\ x_2^2 - 5x_1^3 \\end{bmatrix}\n", + "$$\n", + "\n", + "is sparse with respect to the set of polynomials of two variables in the sense that if we were to write an expansion of the component functions of $f$ in this basis (e.g. $f_{1}(x) = \\sum_{i=0}^\\infty\\sum_{j=0}^\\infty a_{i,j}x_1^ix_2^j$), only a small number of coefficients ($a_{i,j}$) would be nonzero.\n", + "\n", + "SINDy employs **sparse regression** to find a linear combination of basis functions that best capture the dynamic behavior of the physical system." + ] + }, + { + "cell_type": "markdown", + "id": "73caa123", + "metadata": { + "lines_to_next_cell": 0 + }, + "source": [ + "## Approximation problem\n", + "To apply SINDy in practice one needs a set of measurement data collected at times $t_1, t_2, \\dots, t_n$, and the time derivatives of these measurements (either measured directly or numerically approximated). These data are aggregated into the matrices $X$ and $\\dot X$, respectively\n", + "\n", + "$$\n", + "\tX = \\begin{bmatrix}\n", + "\t\tx_1(t_1) & x_2(t_1) & \\dots & x_n(t_1) \\\\\n", + "\t\tx_1(t_2) & x_2(t_2) & \\dots & x_n(t_2) \\\\\n", + "\t\t\\vdots & \\vdots & & \\vdots \\\\ x_1(t_m) & x_2(t_m) & \\dots & x_n(t_m)\n", + "\t\\end{bmatrix},\n", + "\t\\qquad\n", + "\t\\dot{X} = \\begin{bmatrix} \\dot{x_1}(t_1) & \\dot{x_2}(t_1) & \\dots & \\dot{x_n}(t_1) \\\\\n", + "\t\t\\dot{x_1}(t_2) & \\dot{x_2}(t_2) & \\dots & \\dot{x_n}(t_2) \\\\\n", + "\t\t\\vdots & \\vdots & & \\vdots \\\\\n", + "\t\t\\dot{x_1}(t_m) & \\dot{x_2}(t_m) & \\dots & \\dot{x_n}(t_m)\n", + "\t\\end{bmatrix}.\n", + "$$\n", + "\n", + "Next, one forms a library matrix $\\Theta(X)$ whose columns consist of a chosen set of basis functions applied to the data\n", + "\n", + "$$\n", + "\t\\Theta(X) = \\begin{bmatrix}\n", + "\t\t\\mid & \\mid & & \\mid \\\\\n", + "\t\t\\theta_1(X) & \\theta_2(X) & \\dots & \\theta_\\ell(X) \\\\\n", + "\t\t\\mid & \\mid & & \\mid\n", + "\t\\end{bmatrix}.\n", + "$$\n", + "\n", + "For example, if $\\theta_1(x), \\theta_2(x), \\dots, \\theta_\\ell(x)$ are monomials ($\\theta_i(x) = x^{i-1}$), then\n", + "\n", + "$$\n", + "\t\\theta_3(X) = \\begin{bmatrix}\n", + "\t\t\\mid & \\mid & & \\mid & \\mid & & \\mid \\\\\n", + "\t\tx_1(t)^2 & x_1(t)x_2(t) & \\dots & x_2(t)^2 & x_2(t)x_3(t) & \\dots & x_n^2(t) \\\\\n", + "\t\t\\mid & \\mid & & \\mid & \\mid & & \\mid\n", + "\t\\end{bmatrix},\n", + "$$\n", + "\n", + "where vector products and powers are understood to be element-wise.\n", + "\n", + "We seek a set of sparse coefficient vectors (collected into a matrix)\n", + "\n", + "$$\n", + "\t\\Xi = \\begin{bmatrix}\n", + "\t\t\\mid & \\mid & & \\mid \\\\\n", + "\t\t\\xi_1 & \\xi_2 & \\dots & \\xi_n \\\\\n", + "\t\t\\mid & \\mid & & \\mid\n", + "\t\\end{bmatrix}.\n", + "$$\n", + "\n", + "The vector $\\xi_i$ provides the coefficients for a linear combination of basis functions $\\theta_1(x), \\theta_2(x), \\dots, \\theta_\\ell(x)$ representing the $i$th component function of $f$: $f_i(x)$. That is to say, $f_i(x) = \\Theta\\left(x^\\top\\right) \\xi_i$, where $\\Theta\\left(x^\\top\\right)$ is understood to be a row vector consisting of symbolic functions (whereas $\\Theta(X)$ is a matrix whose entries are numerical values).\n", + "\n", + "With each of the objects $X$, $\\dot X$, $\\Theta(X)$, and $\\Xi$ being defined, we are ready to write down the approximation problem underlying SINDy:\n", + "\n", + "$$ \\dot X \\approx \\Theta(X)\\Xi. $$" + ] + }, + { + "cell_type": "markdown", + "id": "2ce0bc10", + "metadata": { + "lines_to_next_cell": 0 + }, + "source": [ + "## Structure of PySINDy\n", + "The submodules of PySINDy are each aligned with one of the terms in the aforementioned approximation equation\n", + "\n", + "$$ \\dot X \\approx \\Theta(X)\\Xi. $$\n", + "\n", + " * `pysindy.differentiate` performs numerical differentiation to compute $\\dot X$ from $X$;\n", + " * `pysindy.feature_library` allows the user to specify a set of library functions and handles the formation of $\\Theta(X)$;\n", + " * `pysindy.optimizers` provides a set of sparse regression solvers for determining $\\Xi$.\n", + "\n", + "The `SINDy` object encapsulates one class object from each of these three submodules and uses them, along with a user-supplied data matrix, to find a governing dynamical system.\n", + "\n", + "Let's walk through an example showing how this works using a toy dataset." + ] + }, + { + "cell_type": "markdown", + "id": "a222e4ef", + "metadata": { + "lines_to_next_cell": 0 + }, + "source": [ + "## Example\n", + "Suppose we have measurements of the position of a particle obeying the following dynamical system at different points in time:\n", + "\n", + "$$\n", + "\t\\frac{d}{dt} \\begin{bmatrix} x \\\\ y \\end{bmatrix}\n", + "\t= \\begin{bmatrix} -2x \\\\ y \\end{bmatrix}\n", + "\t= \\begin{bmatrix} -2 & 0 \\\\ 0 & 1 \\end{bmatrix}\n", + "\t\\begin{bmatrix} x \\\\ y \\end{bmatrix}\n", + "$$\n", + "\n", + "Note that this system of differential equations decouples into two differential equations whose solutions are simply $x(t) = x_0e^{-2t}$ and $y(t) = y_0e^t$, where $x_0 = x(0)$ and $y_0=y(0)$ are the initial conditions.\n", + "\n", + "Using the initial conditions $x_0 = 3$ and $y_0 = \\tfrac{1}{2}$, we construct the data matrix $X$." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a0b15f0d", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-05T22:47:56.825709Z", + "iopub.status.busy": "2022-07-05T22:47:56.824993Z", + "iopub.status.idle": "2022-07-05T22:47:57.329078Z", + "shell.execute_reply": "2022-07-05T22:47:57.328316Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "from example_data import gen_data1\n", + "from example_data import gen_data2\n", + "\n", + "import pysindy as ps" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9734bd11", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-05T22:47:57.334079Z", + "iopub.status.busy": "2022-07-05T22:47:57.333778Z", + "iopub.status.idle": "2022-07-05T22:47:57.338020Z", + "shell.execute_reply": "2022-07-05T22:47:57.337404Z" + } + }, + "outputs": [], + "source": [ + "t, x, y = gen_data1()\n", + "X = np.stack((x, y), axis=-1) # First column is x, second is y" + ] + }, + { + "cell_type": "markdown", + "id": "cf7827bb", + "metadata": {}, + "source": [ + "We can select a differentiation method from the `differentiation` submodule." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5048cd1c", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-05T22:47:57.342438Z", + "iopub.status.busy": "2022-07-05T22:47:57.342104Z", + "iopub.status.idle": "2022-07-05T22:47:57.345542Z", + "shell.execute_reply": "2022-07-05T22:47:57.344825Z" + } + }, + "outputs": [], + "source": [ + "differentiation_method = ps.FiniteDifference(order=2)\n", + "\n", + "# We could instead call ps.differentiation.FiniteDifference(order=2)" + ] + }, + { + "cell_type": "markdown", + "id": "c97db345", + "metadata": {}, + "source": [ + "While we could use this method to compute $\\dot X$ \"by hand,\" it is often more convenient to pass it into the `SINDy` object and let the computation of $\\dot X$ be handled automatically.\n", + "\n", + "The candidate library can be specified with an object from the `feature_library` submodule, which will also be passed into the `SINDy` object." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7cbb50ce", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-05T22:47:57.349422Z", + "iopub.status.busy": "2022-07-05T22:47:57.349061Z", + "iopub.status.idle": "2022-07-05T22:47:57.353274Z", + "shell.execute_reply": "2022-07-05T22:47:57.352396Z" + } + }, + "outputs": [], + "source": [ + "feature_library = ps.PolynomialLibrary(degree=3)\n", + "\n", + "# Note: We could instead call ps.feature_library.PolynomialLibrary(degree=3)" + ] + }, + { + "cell_type": "markdown", + "id": "6f56a564", + "metadata": {}, + "source": [ + "Next we select which optimizer should be used." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "08fd5275", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-05T22:47:57.357021Z", + "iopub.status.busy": "2022-07-05T22:47:57.356725Z", + "iopub.status.idle": "2022-07-05T22:47:57.361165Z", + "shell.execute_reply": "2022-07-05T22:47:57.360123Z" + } + }, + "outputs": [], + "source": [ + "optimizer = ps.STLSQ(threshold=0.2)\n", + "\n", + "# Note: We could instead call ps.optimizers.STLSQ(threshold=0.2)" + ] + }, + { + "cell_type": "markdown", + "id": "18dc5685", + "metadata": {}, + "source": [ + "Finally, we bring these three components together in one `SINDy` object." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8333785d", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-05T22:47:57.365905Z", + "iopub.status.busy": "2022-07-05T22:47:57.365506Z", + "iopub.status.idle": "2022-07-05T22:47:57.370218Z", + "shell.execute_reply": "2022-07-05T22:47:57.369254Z" + } + }, + "outputs": [], + "source": [ + "model = ps.SINDy(\n", + " differentiation_method=differentiation_method,\n", + " feature_library=feature_library,\n", + " optimizer=optimizer,\n", + " feature_names=[\"x\", \"y\"],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "60273bde", + "metadata": {}, + "source": [ + "Following the `scikit-learn` workflow, we first instantiate a `SINDy` class object with the desired properties, then fit it to the data in separate step." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d7612a79", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-05T22:47:57.374074Z", + "iopub.status.busy": "2022-07-05T22:47:57.373698Z", + "iopub.status.idle": "2022-07-05T22:47:57.395553Z", + "shell.execute_reply": "2022-07-05T22:47:57.394915Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "SINDy(differentiation_method=FiniteDifference(),\n", + " feature_library=PolynomialLibrary(degree=3), feature_names=['x', 'y'],\n", + " optimizer=STLSQ(threshold=0.2))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.fit(X, t=t)" + ] + }, + { + "cell_type": "markdown", + "id": "47bab10d", + "metadata": {}, + "source": [ + "We can inspect the governing equations discovered by the model and check whether they seem reasonable with the `print` function." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "70d207fd", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-05T22:47:57.400206Z", + "iopub.status.busy": "2022-07-05T22:47:57.399847Z", + "iopub.status.idle": "2022-07-05T22:47:57.404757Z", + "shell.execute_reply": "2022-07-05T22:47:57.404056Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(x)' = -2.000 x\n", + "(y)' = 1.000 y\n" + ] + } + ], + "source": [ + "model.print()" + ] + }, + { + "cell_type": "markdown", + "id": "a465bf7f", + "metadata": {}, + "source": [ + "Once the SINDy model has been fit we can use it to evolve new initial conditions forward in time with the `simulate` function." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "bfb37ed3", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-05T22:47:57.408529Z", + "iopub.status.busy": "2022-07-05T22:47:57.408239Z", + "iopub.status.idle": "2022-07-05T22:47:57.487369Z", + "shell.execute_reply": "2022-07-05T22:47:57.486746Z" + } + }, + "outputs": [], + "source": [ + "x0, y0, t_test, x_test, y_test = gen_data2()\n", + "sim = model.simulate([x0, y0], t=t_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "337501c9", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-05T22:47:57.491513Z", + "iopub.status.busy": "2022-07-05T22:47:57.491177Z", + "iopub.status.idle": "2022-07-05T22:47:58.220218Z", + "shell.execute_reply": "2022-07-05T22:47:58.219457Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAEGCAYAAACpXNjrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAA8B0lEQVR4nO3deVwW1f7A8c8XBHdTxB0Rt3JBRUXTFCR3rdwyNc3UMrPFbLm3vNmiXTMry+q2/DJLzWtpWZi53HJNTVNAcddwQUVwAfcd5fz+eIZHQHB9Hobl+369nhdzzpyZ+Q7W82XOzJwjxhiUUkopV/KwOwCllFJ5jyYXpZRSLqfJRSmllMtpclFKKeVymlyUUkq5XAG7A8gJfH19TUBAgN1hKKVUrhIVFZVojCmT2TpNLkBAQACRkZF2h6GUUrmKiOzNap12iymllHI5TS5KKaVcTpOLUkopl9N7LllITk4mLi6O8+fP2x2KugWFChXCz88PLy8vu0NRKl/S5JKFuLg4ihcvTkBAACJidzjqJhhjSEpKIi4ujqpVq9odjlI5z4UL8NtvEB4Ohw5BuXLQvTt06AAFC7rkELZ1i4mIj4gsFJEY62epLNr9T0SOi8jcDPVVRWSNiOwUkZki4m3VF7TKO631AbcS3/nz5yldurQmllxIRChdurRedSqVmQsX4PXX4bPP4OJF8PPDXLjoKL/+umO9C9h5z2UEsNgYUxNYbJUz8z7QP5P6d4EJxpgawDHgcav+ceCYVT/BandLNLHkXvpvp9TVzp+HhO+XsfXPYyyQZkw5UItpMc2IPFcXqlSBDRscVzQuYGe3WFcgzFqeCiwDXsnYyBizWETC0taJ45ujNdA3zfajgC+s/Y6y6mcBn4qIGJ1bQCmVT1y4AMeOwdGjEBt7lE2btrB9+1b27dtKfNQiEs4e4ETyCYJ97+aJ2s9y7GIREAFfX0dXWZcutx2DnVcu5YwxCdbyQaDcTWxbGjhujLlkleOAStZyJWA/gLX+hNU+HREZIiKRIhJ55MiRW4n/igsXYM4cGDQIOnd2/Jwz57YvL4sVK3bdNoMHD2br1q0AjB07Nt26e+65xyXHcJWBAwcya9Ys4PbjVkrBpUtw5Ajs2AF//QXz58M772zmvvteoHXrdtxzT0Xuu680I0aEMmXKUJYs+YTtJ7ZyIvkEAPFnDwBw7EJRxw6LFIHDh10Sm1uvXERkEVA+k1Uj0xaMMUZEsvXKwhgzEZgIEBwcfOvHTu2/3LDBkfX9/ODMGUf/5cqV8O9/u+wGWWYmTZrkXB47diyvvvqqs7xq1Sq3Hfd25da4lbKDMXDyJCQlweHDyWzcuINNmzYRHx9Hhw7/TNf28OGDLF780XX36eXhhbenN8YYziR7k2IEj7NnoWxZl8Ts1uRijGmb1ToROSQiFYwxCSJSAbiZdJkElBSRAtbViR9wwFp3AKgMxIlIAeAOq717/PabI7FUqeK4rAQoVgyKFr3Sf3mbl5jLli1j1KhR+Pr6snnzZho3bsx///tfRISwsDDGjx/PrFmzOHfuHEFBQdStW5fp06dTrFgxTp8+zenTp+natSvHjh0jOTmZMWPG0LVr12se89tvv2X8+PGICPXr12fatGnExsby2GOPkZiYSJkyZZg8eTL+/v4MHDiQEiVKEBkZycGDB3nvvffo2bMnxhiGDRvGwoULqVy5Mt7e3s7930jcxhhefvllFixYgIjw2muv0bt372v+PpTK7S5edHRnJSYaYmIOER29gW3bNrJ37wYOHNjIwYPbuXw5GcD6DniaggWLOrevWLFuuv15eRWifPnaVKhQBz+/utTAi8AdO6hd0w/fwhco6R1FCe/zeJACiYnwzDMuOQ8777nMAQYA46yfv9zohtaVzlKgJzAjw/ap+11trV/i1vst4eGOK5aMX2wu7r9cv349W7ZsoWLFirRo0YI///yTli1bOtePGzeOTz/9lOjo6Ku2LVSoEOHh4ZQoUYLExESaNWtGly5dsvwy3rJlC2PGjGHVqlX4+vpy9OhRAIYNG8aAAQMYMGAA33zzDc899xyzZ88GICEhgZUrV7J9+3a6dOlCz549CQ8PZ8eOHWzdupVDhw5Rp04dHnvssXTHulbcP//8M9HR0WzYsIHExESaNGlCaGjoDf0+lMoNTp92fJ8nJV35HD16gc8+u5+4uA2cOnXtLntjDPHxW6hatamzrkSJ8vToMY5q1e4kMDCQunWr4evrSalSULw4eCSn9rasgiK+4FUEzpx1BNKggeNxZBewM7mMA34QkceBvUAvABEJBoYaYwZb5RVALaCYiMQBjxtjfsNx83+GiIwB1gNfW/v9GpgmIjuBo0Aft57FoUOOrrDMFCkC8fEuOUzTpk3xs44TFBREbGzsDX+ZGmN49dVXWb58OR4eHhw4cIBDhw5RvnxmPZawZMkSHnroIXx9fQHw8fEBYPXq1fz8888A9O/fn5dfftm5Tbdu3fDw8KBOnTocOnQIgOXLl/Pwww/j6elJxYoVad269U2d88qVK53blytXjlatWhEREUGJEiVu6/ehVHZLSYETJxzf33v3niIqKppNm6KJjY3m3nufo3LlBs62Xl4FSUjYds3E4uPjT6VK9ahUqR7ly5cmIAB8fByfUqWEJ554BY+s7qgXLOjork99zyU+3tEV9swzLn3PxbbkYoxJAtpkUh8JDE5TDsli+91A00zqzwMPuS7S6yhXznGPJbMb4y7svyyY5h/c09OTS5cuXaN1etOnT+fIkSNERUXh5eVFQECAy98BSRtfdjyYdzu/D6XcKSUltVsLYmKOEBW1ns2b1xMbu479+9dz+HBMuvb+/o3TJRcAP78GHD9+gIIFi1KpUn38/OoTENCAunXrExQUiL//Hc5kUuBWvsULFnT0qLigVyUr+ob+7ere3XHzvmjR9F1jxri0//JGeHl5kZycfNWQJydOnKBs2bJ4eXmxdOlS9u7NcpRsAFq3bk337t158cUXKV26NEePHsXHx4d77rmHGTNm0L9/f6ZPn05ISKZ53yk0NJQvv/ySAQMGcPjwYZYuXUrfvn2vapdV3CEhIc7tjx49yvLly3n//ffZvn37Df5GlHKv1ERy5Ijjf/cjRxzluXPfZvnyLzl2bP9197F/f3S6sggMGvQeZcp8TN261ShTxoPSpR0dIbmJJpfb1aGD46mw1KfFihRxXLG4uP/yRgwZMoT69evTqFEjpk+f7qzv168fDzzwAPXq1SM4OJhatWpdcz9169Zl5MiRtGrVCk9PTxo2bMiUKVP4z3/+w6BBg3j//fedN/SvpXv37ixZsoQ6derg7+9P8+bNbyru7t27s3r1aho0aICI8N5771G+fHlNLsoWxsDx444EEhOTREREFBs2RFC0qC+hoU+ma3vp0oUsE4uHhycVK9bFzy+IgIAggoNDqFsXSpd2fIWUKgWennUz3TY3EX230PEocsbJwrZt20bt2rVvbAdpx+k5fNjRFebicXrUzbupf0OlMjh92vG/8759Z/jrr3WsX7+WXbvWsndvJImJu53t/P0bM3Jk+u+P6Ohf+OKLbnh5FcLPrwGVKzekevWGNGjQiEaNAqlUqRC+vo4b7Ln5IUcRiTLGBGe2Tq9cXCEb+i+VUu6TnOy4Ijl82PGMzubNu5k9+x1iY9dy4MBmjEnJctsDBzaSnHwBL68rf0g2bHgvn3++gcaN61C+fAFnp0Z+oslFKZWvGON4cuvQIdi27RCrV/9FtWr3I+LpbHPhgrBy5aQs91GggDd+fg2oUiWYO+9sgr9/CpUqQZkyjq6twoVLAPWz4WxyLk0uSqk8LfWqJC7uEmvXbmTNmtX8/fcqdu9eTWLiHgDeeGMTlSoFOrcpXTqAYsV8OX06ERGhQoU6BAQ0pWbNpjRq1IQmTepRsaI3ZcrkvyuSG6XJRSmVp5w547gqiYk5zooVq1m//k927vyT2Ni1XLx4NtNt9uz5K11yEREeeeRz/PzK0KxZYwICilO2rOMeiboxmlyUUrna8eNw8CAkJDh+njrlqH///QfYuXPlNbf18ipElSrBFC58ByVLOp7FSf0MHvxQ1i8iquvS5KKUyjWMcQyREh9vWLNmG6tWrWDr1hX4+zekXbuX0rWtVu2eq5JLqVKVqV79HmrWbE7TpvfQrFkD/Pwc3Vv6YKdraXLJwTw9PalXr56z3KdPH0aMyGpOtZsTHR1NfHw8nTt3vu19pQ40eS0fffQRQ4YMoYjVQd25c2e+++47SpYsedvHV3lXSoojmRw4kMKqVZv4888/2LbtD2JilnP6dKKzXVLSnquSy513tmL79sXUqNGCevVa0KLFPdSr50e5clCyZO5+BDg30OSSgxUuXDjTAR1dITo6msjISJcklxvx0Ucf8cgjjziTy/z587PluCp3uXJlAlu2HOLXX79n69alxMSs4OzZY1luFxsbwcWL5/D2LoyHh+Oprfr1O/PSS50pXx4KFcrGk1CAJpfrmjjRvfsfMuTm2p84cYKmTZsyZ84c7rrrLh5++GFat27NE088wVNPPUVERATnzp2jZ8+ejB49GoCIiAiGDx/OmTNnKFiwIAsXLuSNN97g3LlzrFy5kn/961/07t3beYwtW7YwaNAgLl68SEpKCj/99BM1a9bkww8/5JtvvgEck309//zz6WJbtmwZ48ePZ+7cuQA8++yzBAcHc/LkSeLj47n33nvx9fVl6dKlBAQEEBkZia+vb6b7jY2NpVOnTrRs2ZJVq1ZRqVIlfvnlFwoXLnyLv2mVUx0/DnFxhvh4ISHhyhx7Bw4c5vvvX8hyu6JFS1OzZgh33RVCs2Yh3H23N35+jsRyS+NtKZfSf4IcLHWek1SpSeDTTz9l4MCBDB8+nGPHjvHEE08A8Pbbb+Pj48Ply5dp06YNGzdupFatWvTu3ZuZM2fSpEkTTp48SZEiRXjrrbeIjIzk008/veq4//d//8fw4cPp168fFy9e5PLly0RFRTF58mTWrFmDMYa7776bVq1a0bBhw+uex3PPPceHH37I0qVLnSMtp8pqv6VKlSImJobvv/+er776il69evHTTz/xyCOP3N4vVdnu7FmIi4N16/axZMliNmxYzI4dS3jlldWULl3F2a5ChbrOx4EBSpQoR82arahdO5SQkFY0bVoHPz8PfHzQG+85kCaXHCyrbrF27drx448/8swzz7BhwwZn/Q8//MDEiRO5dOkSCQkJbN261XpGvwJNmjQBoESJEtc9bvPmzXn77beJi4ujR48e1KxZk5UrV9K9e3eKFnVMStSjRw9WrFhxQ8nlWrLab5cuXahataozuTZu3JjY2NjbOpayx6VLjm6uHTtO8PvvS4mIWMi2bQuvGh14+/bFtGhxZb4fDw8POnV6lSJFChMSEkbTpndRqZJQqpTeL8kNNLnkQikpKWzbto0iRYpw7Ngx/Pz82LNnD+PHjyciIoJSpUoxcODAWx5Wv2/fvtx9993MmzePzp078+WXX97QdgUKFCAl5cowGbc7rH/GYfXPnTt3W/tT2ScpyXF1smzZehYv/oUtW34nNnYtKSmXs9xm164/adHiMby9oWJFx6dnzxc0meRSmlyu42bviWSHCRMmULt2bcaOHcugQYNYvXo1J0+epGjRotxxxx0cOnSIBQsWEBYWxl133UVCQgIRERE0adKEU6dOUbhwYYoXL86p1BcCMti9ezfVqlXjueeeY9++fWzcuJHQ0FAGDhzIiBEjMMYQHh7OtGnT0m1XpUoVtm7dyoULFzh37hyLFy92TuCVeryM3WIhISHX3a/K+S5cgAMHYN8+R1I5a72rGB4+iT/++DzTbby8ClGjRgh16rQhJKQNISEN8fd3jA6syST30+SSg2W859KxY0cGDRrEpEmTWLt2LcWLFyc0NJQxY8YwevRoGjZsSK1atahcuTItWrQAwNvbm5kzZzJs2DDOnTtH4cKFWbRoEffeey/jxo0jKCjoqhv6P/zwA9OmTcPLy4vy5cvz6quv4uPjw8CBA2na1DE/2+DBg6/qEqtcuTK9evUiMDCQqlWrpls/ZMgQOnbsSMWKFVm6dKmzvlGjRpnuV7vAcr6kJNi1K5lFi1axYsUCLl48T+/eH6VrU7duB2dyEREqV25EnTrtaN68HW3a3EO1aoUoWxY8PTM5gMrVdMh9XDDkvsqR9N/QtS5dclydbNhwmHnzFhAZOZetW3/n/PmTAHh5FWbChKN4eV157vf8+VPMnDmcxo3b0759WwIDfalYEby97ToL5Uo65L5S6pacPQuxsYZlyzaycOGvbNgwl9jYtZlOZZ2cfI6///6DunU74OXluGdSuXJxBg78hht4jkTlMZpclFLpHD0KsbGwdy8cOpTC6NF1OXgw69k/fXz8CQzsTLNmnejUqSV33gnly+vjwfmdLclFRHyAmUAAEAv0MsZc9fqtiPwPaAasNMbcn6Z+OhAMJANrgSeNMckiEgb8Auyxmv5sjHnLbSeiVB5gjGMU4S1bThITcxYPj/LOdR4eHpQpUyNdcvHw8KRatXsICrqftm3vIySkDv7+QrFidkSvciq7rlxGAIuNMeNEZIRVfiWTdu8DRYAnM9RPB1LfpvsOGAx8YZVXpE1ESqmrpaQ43j1Zv/4I4eGziYgIt94zGUzfvp+la9ugQRd27lxBYGBnmjS5n/vv70hgoA8VK+qNeJU1u5JLVyDMWp4KLCOT5GKMWWxdjWSsdw5MJSJrAT83xKhUnpKS4nhMeM2aA8yZE87atT8RE7M83RS+Gzb8Qp8+/8EjTZ/WAw/0Z9iwgdSo4YWPjx2Rq9zIruRSzhiTYC0fBMrdyk5ExAvoDwxPU91cRDYA8cA/jDFbsth2CDAEwN/f/1YOr1SOd/my4wmvNWviCA+fxdq1P7Jr16os2xcvXpYzZw5Tt255AgLA3x+KFNFRH9XNc9stNxFZJCKbM/l0TdvOOB47udXnoT8HlhtjVljldUAVY0wD4D/A7Kw2NMZMNMYEG2OCy5Qpc4uHd6+3336bunXrUr9+fYKCglizZg0AYWFhpD46HRAQwIMPPujcZtasWQwcOBCAKVOmUKZMGRo2bEjNmjXp0KEDq1Zl/cXibqNGjWL8+PG33UZdW+oVyh9/wLRpMGNGPL17+/P99y9clVhEhBo1WtKnz4dMn76HZcvW8dxz5enYEWrV0il81a1z25WLMaZtVutE5JCIVDDGJIhIBeDwze5fRN4EypDmfowx5mSa5fki8rmI+BpjEjPbR062evVq5s6dy7p16yhYsCCJiYlcvHgx07ZRUVFs3bqVOnXqXLUudaBLgKVLl9KjRw+WLl2q73/kMak35aOikti3zwNPz1LOdSVLVqRy5Ubs2xcFOG7I33XXvTRt+iBdunQjOLg8lSrp/RPlWnY9LDgHGGAtD8DxhNcNE5HBQAfgYZOmw1hEyos4Bo4QkaY4zi/JJRFns4SEBHx9fZ3ja/n6+lKxYsVM27700ku8/fbb193nvffey5AhQ5g4cSK7du2iUaNGznUxMTHpyqnCwsJ44YUXCA4Opnbt2kRERDgHs3zttdec7T788EMCAwMJDAzko48+cta//fbb3HnnnbRs2ZIdO3Y463ft2kXHjh1p3LgxISEhbN+e9aOuKmtHj8Iff5xh2LDvad/+frp0Kc/ChVePBde06cPUrt2WQYMmMnv2QRYuXMg33wylR4/y+PtrYlGuZ1dyGQe0E5EYoK1VRkSCRWRSaiMRWQH8CLQRkTgR6WCt+j8c92lWi0i0iLxh1fcENlv3XD4B+hgXDUEwatQoROSGPkMyGZBsyJAh6dqMGjXqmsdr3749+/fv58477+Tpp5/mjz/+yLJtr169WLduHTt37rzueTRq1Ijt27dTvXp17rjjDueoy5MnT2bQoEGZbuPt7U1kZCRDhw6la9eufPbZZ2zevJkpU6aQlJSUbtj8v/76i6+++or169cTFRXFjBkziI6OZv78+URERKT7ffznP/8hKiqK8ePH8/TTT183duVw9ixER1/m9dd/o1OnR+jQoRyffdaXTZvmkZJyiYiIGenaFyoEw4e/xKJFC5k06QkeeMCXSpX0PRTlXrbc0DfGJAFtMqmPxPFYcWo5JIvtM43bGPMpcPUEJblQsWLFiIqKYsWKFSxdupTevXszbtw45/2UtDw9PfnnP//JO++8Q6dOna6537S5dvDgwUyePJkPP/yQmTNnsnbt2ky36dKlCwD16tWjbt26VKhQAYBq1aqxf//+LIfNT0lJoXv37s7ZJ1P3c/r0aVatWsVDDz3kPMaF1BmiVKYuX3a82PjbbxuZPftb1q79jhMnEjJt6+VVmMuXT1GnTnGqV3e8Ka+JRGU3fUM/B/P09CQsLIywsDDq1avH1KlTM00uAP379+edd94hMDDwmvtcv369837Lgw8+yOjRo2ndujWNGzemdOnSmW6T2jXn4eGRbhh8Dw8PLl26dNPnlZKSQsmSJd02hXNecvgw/P03rFmzn48/7sL+/dGZtitfvhbNmvWjR4++hIRUo3Jl7epS9tK/Z27QqFGjMMbc0GdiJnMjT5w4MV2b63WL7dixg5iYK5MpRUdHU6VKlSzbe3l58cILLzBhwoQs2/zxxx9MnDjROXNloUKF6NChA0899VSWXWI3IiQkhNmzZ3P27FnOnDlDeHg4ISEhhIaGMnv2bM6dO8epU6f49ddfAceEZVWrVuXHH38EHFdTaSc9y+/On4eNG+HHH2H2bNi6FYoWrcipU+mfeylRohxt277Axx9HsWzZVmbOfI3+/asREKCJRdlPr1xyqNOnTzNs2DCOHz9OgQIFqFGjRqZJK63HH3+cMWPGpKubOXMmK1eu5OzZs1StWpWffvop3ZNi/fr1Izw8nPbt299yrFkNmw+Op9UaNGhA2bJlnbNhAkyfPp2nnnqKMWPGkJycTJ8+fWjQoMEtx5DbGeN4H2Xx4p3MnPkN1au3pF69zs71Hh6eNGv2KIsXf0RQUDfatXuUBx9sR61aBfRxYZUj6ZD75O8h98ePH8+JEyf497//bXcoLpcb/g3PnoUtWy4ybVo4v/8+kR07lgBQp057hg//LV3b5OREatYsQOPGJcmiB1OpbKVD7qtMde/enV27drFkyRK7Q8l34uNh0aJdfPfdl6xaNYVTp46kW79t20KSkvbi61sFf3+46y7w9/fVG/Mq19Dkko+Fh4fbHUK+cvEibN16ienT5zF//hds3frbVW1EPAgM7Ez79o/Trl1F6tTRt+RV7qTJ5RqMMYhO5p0r5aTu3mPHYMsW2Lr1Iq+9VocjR3Zd1aZUqcqEhg6mb9/HCA31o3z5THakVC6iySULhQoVIikpidKlS2uCyWWMMSQlJVGokH0DLhoD+/bBpk2OLjAHb6pWvduZXESEwMDOdOo0lL59O1GrlidpnvRWKlfT5JIFPz8/4uLiOHLkyPUbqxynUKFC+Pll/0wMycmwZcslpk79hcOHj9Cq1dB068PCnmXr1t8JCRlM375DaNOmKtY7qUrlKZpcsuDl5UXVqlXtDkPlEmfOwJo1J/nqq0ksXPgJSUl7KVSoBHff3Y9ChYo72wUGNmPhwjjq1y+o91JUnqbJRanbcPQoLFy4n2+++YTlyydy/rxzYG7Onz/JqlVTaN16GOXLQ2AgBAQIHh7a96XyPk0uSt2C+HiYM2cLU6e+x9q135GSkn4YnKJFS9Oq1VB69nyQsDDw9bUnTqXsoslFqRuUepP+hx8imDbtLTZtmntVm3Ll7qRTp5d4/PH+NGpUWLu+VL6lyUWp6zAGdu2C6GhHN1h0dNRViaVGjRC6d/8nAwbcx113eVBA/89S+Zz+L6BUFlJSICbGEB0tnDhxpf6eewYyb95bnDx5kAYNuvLww6/Qq1czqlQBfWpdKQdNLkplkJICf/+dwldf/cKPP77Fww9/TvXqzZ3rvbwKMXDgFOrW9eeBB2rpC49KZUKTi1IWYxxXKhMnzmHmzDeJi3NMAzBv3ls899wCZ7vq1aFnz/b4+NgVqVI5nyYXle8ZA7t3GyZNWsB3373Bvn1R6dbHxCzn+PED3H13JYKC4I477IlTqdxEk4vK1+LiYPLk5Uyd+iq7dv2Zbp23dxHuvfcZnnrqH7RuXZbixbPYiVLqKppcVL50+DB8//16Jk7811WjE3t5FSIs7GmeeeYVTSpK3SJbkouI+AAzgQAgFuhljDmWSbv/Ac2AlcaY+9PUTwFaAanP8Aw0xkSLY4TJj4HOwFmrfp37zkTlNidPwtq1sHs3fPnlK2zbttC5ztPTi5CQITzzzKu0b1+REiVsDFSpXM6uqYdGAIuNMTWBxVY5M+8D/bNY909jTJD1ibbqOgE1rc8Q4AvXhaxys/PnYdUq+OEHR2IB6N79HcAxh0rz5gOZMuVvwsM/pWdPTSxK3S67usW6AmHW8lRgGfBKxkbGmMUiEpax/jr7/dY4JvP4S0RKikgFY0zCbUWrcq2UFFi//iKffjqVJk0GUKCAt3NdlSqNeeihCbRu3Z6ePevoEC1KuZBdyaVcmi/8g0C5W9jH2yLyBtaVjzHmAlAJ2J+mTZxVd1VyEZEhOK5u8Pf3v4XDq5wuNtbw+edzmTr1JQ4fjuHs2bO0aTPcud7XFyZMeJ5KlWwMUqk8ym3JRUQWAZm9XjYybcEYY0TkZqcN/BeOpOQNTMRx1fPWzezAGDPR2pbg4OCcM22hum3Hj8OMGVv55JPn091TmTfvLZo1e5Ry5UrRtKnjfRV9o14p93BbcjHGtM1qnYgcSu2uEpEKwOGb3HfqlcgFEZkM/MMqHwAqp2nqZ9WpfCA5GZYvP8G4caNZsuQTUlIuO9cVLnwHDzwwkpYti9CoEXh62hioUvmAXTf05wADrOUBwC83s7GVkLCeDusGbE6z30fFoRlwQu+35A+7dhmGDfuWHj3uYtGiCc7EIuJBq1ZDmTkzhsmTX6RJk4KaWJTKBnbdcxkH/CAijwN7gV4AIhIMDDXGDLbKK4BaQDERiQMeN8b8BkwXkTKAANFA6lyy83E8hrwTx6PIg7LtjJQtTpyA777bwoQJTxMTszzdujvvbMWzz35Cv371dagWpbKZLcnFGJMEtMmkPhIYnKYcksX2rbOoN8AzLgpT5WCXL8OGDbBuHcyZ8990iaVkyUr06zeeF17oTfXqelNFKTvoG/oq1zl4EJYvd9y4B+jc+TXWrv2O48fjadfuBUaMeIOWLYvpnCpK2Uj/91O5xsWL8PvviezYYShevIyzvmDBogwaNI2qVX3o1y+QkiXti1Ep5WDXDX2lbsq+fYaXXppJ3751+O67p9OtK1QIhg4N5ZlnNLEolVPolYvK0S5ehHnzDvHWW0OJjp4NwLp1s1i37mcaNepBrVpw991QsKC9cSql0tPkonKs/fsN7747kylTnuXMmSRnfalSfvj4FOP++6FiRRsDVEplSZOLynEuXYLff0/ijTeeIirqx3TrQkOf5M033yM0tITesFcqB9P/PVWOcuQIfPDBAr744jFOnjzorPfx8efpp79h2LA2lC1rY4BKqRuiyUXlCMZAREQyI0a8yNKln6Zb17LlYEaP/oBWrUro2/VK5RKaXJTtzpyBJUsgPr4AiYl7nPUlSpTjySe/5sUX76N8ZkOgKqVyLH0UWdlq716YNQsSEkBEePTRrylevCxBQd3473838/bbmliUyo30ykXZIiUFFi48zu7dxfD0vPKfYYkS5Rg9OpLu3f0ICNChW5TKrfTKRWW7U6dg/Pi19OsXxK+/vplunZ8fPPlkZU0sSuVymlxUttq71/DUU5/w6qstSUray4IFY9m8+X94eDhehuzUCYoUsTtKpdTt0m4xlS2MgRUrTvOPfzxBRMQMZ33hwnfg7Z1Mly7oI8ZK5SGaXJTbXbgA3377N2++2Z2EhK3Oen//xowe/QMPP1xNh29RKo/R5KLc6tgxeOedeXz6aT/OnTvhrA8NfZLx4z+mSRPNKkrlRZpclNvs2WN46aWxzJ79Oo553MDLqxADB37BqFEDdVwwpfIwTS7KLaKj4eWX/8nChR8460qVqszIkbMZOrQRRYvaF5tSyv30aTHlUpcvw9KlsHYtNG8+gIIFiwGO+ewnT47k+ec1sSiVH9iSXETER0QWikiM9bNUFu3+JyLHRWRuhvoVIhJtfeJFZLZVHyYiJ9KseyMbTkdZzp+HefMgJsZRrlSpHo8/Pp2wsKf54YeFdO1aVscGUyqfsKtbbASw2BgzTkRGWOVXMmn3PlAEeDJtpTEmJHVZRH4CfkmzeoUx5n7Xh6yu5cQJmDXrOJcvl0xX37RpF0aO7KL3V5TKZ+zqFusKTLWWpwLdMmtkjFkMnMpqJyJSAmgNzHZteOpmHDoEzz//JcOHV+fAgU3O+jvugG7ddEIvpfIju5JLOWNMgrV8ECh3i/vphuMK6GSauuYiskFEFohI3dsJUl1fbKzhscdGMmXKUM6cOcp//tOZY8fiqFjRkVjuuMPuCJVSdnBbt5iILAIyG892ZNqCMcaIiLnFwzwMTEpTXgdUMcacFpHOOK5oamYR3xBgCIC/v/8tHj5/27z5Ek8+OYRVqyY764oXL0fNmgXo3Bk89HERpfIttyUXY0zbrNaJyCERqWCMSRCRCsDhm92/iPgCTYHuaY55Ms3yfBH5XER8jTGJmcQ3EZgIEBwcfKvJLd9avfosTz7Zm02brjxrERjYmc8+m0loaDEbI1NK5QR2/W05BxhgLQ8g/Q35G9UTmGuMOZ9aISLlRUSs5aY4zi/pNmNVGSxadIJHH+2YLrHcc88gvvvuF00sSinAvuQyDmgnIjFAW6uMiASLiLObS0RWAD8CbUQkTkQ6pNlHH+D7DPvtCWwWkQ3AJ0Afk/pquLptxsCcOUd47LF72blzhbO+U6cR/Pe/X1Ovnr6Tq5RyEP3udXSLRUZG2h1GjpaSAj/9FM/w4W1JSNjmrO/T5wM+/PBFKlSwMTillC1EJMoYE5zZOv1TU11XSopjjvtp0yY5E4uIB4899hXjxj2Gr6/NASqlchx9nkddU0oKLFoEu3dD586v0aLFY3h4FODZZ2cwfrwmFqVU5rRbDO0Wy0pqYomNTVt3mcTEdTz3XBNKlLAtNKVUDqDdYuqmOe6xJHL0aGmsB/AAKFnSk0ceaUIxfShMKXUN2i2mrpKSAjNm7Ofpp5vy/ffPkJKSAjjetn/gATSxKKWuS5OLSscYCA9P4IUXWpOYuIc//viCGTOGOROLDpevlLoR100uIjIsqyHxVd4zf34Szz3XnsOHdwLg6elF06aduf9+KFLE5uCUUrnGjVy5lAMiROQHEekoaTvgVZ6ybNkpnn22E/HxmwHw8PBk2LCZvPHGfXrFopS6KddNLsaY13AM/vg1MBCIEZGxIlLdzbGpbBQVdYGhQ7sRGxsBgIgwZMhURo/urvdYlFI37YbuuVhDqBy0PpeAUsAsEXnPjbGpbLJjx2WGDOnHjh1LnHUDBnzB2LH99HFjpdQtue6jyCIyHHgUSMQxvP0/jTHJIuIBxAAvuzdE5U779xuGDn2Odet+ctb16PE27777JKX0TptS6hbdyHsuPkAPY8zetJXGmBQR0emEc7GkJHjppfdZtuxzZ13bts/z0Uf/omxZGwNTSuV6N3LP5c2MiSXNum2Z1auc78wZWLAAAgJaULRoaQCaNOnD559/QOXK+syGUur26Hsu+VBysiOxnD0LNWq0YMSIv2jR4nE+/3wKNWvqfxJKqdunw7/kM8bA4sVw9OiVurJla/Dee5MIznSEIKWUunn6Z2o+8/vvx1i3LjZdXUAANG9uSzhKqTxKk0s+snnzJV54oRfjxjVl165VAJQpA61bg74aq5RyJU0u+cShQ/D88/9g27ZFnDp1hAkT2nD+fBwdOkAB7RxVSrmYJpd84MwZeP31KSxe/LGzrlOnEfTt66fjhSml3EKTSx53+TJ88UUkkycPddY1bNiDDz54XWeRVEq5jW3JRUR8RGShiMRYP696H1xEgkRktYhsEZGNItI7zbqqIrJGRHaKyEwR8bbqC1rlndb6gGw8rRxn/vwjjB3bg0uXLgBQsWIgEyZMpUYN/btCKeU+dn7DjAAWG2NqAoutckZngUeNMXWBjsBHIlLSWvcuMMEYUwM4Bjxu1T8OHLPqJ1jt8qVt2y7zyit9OXZsPwCFC9/Bv/8dTmiojkSplHIvO5NLV2CqtTwV6JaxgTHmb2NMjLUcDxwGyljD/rcGZmWyfdr9zgLa5MdpAo4ehVdeGc22bYucdc8+O51+/Wrok2FKKbezM7mUM8YkWMsHccwbkyURaQp4A7uA0sBxY8wla3UcUMlargTsB7DWn7DaZ9zfEBGJFJHII0eO3O655CjJyTB+/G/8+uu/nXX33/86r7xyHwUL2hiYUirfcOtDqCKyCCifyaqRaQvGGCMi5hr7qQBMAwZYA2bedmzGmInARIDg4OAsj50brVwJq1fPdZZr127Lu+++SemrUqxSSrmHW5OLMaZtVutE5JCIVDDGJFjJ43AW7UoA84CRxpi/rOokoKSIFLCuTvyAA9a6A0BlIE5ECgB3WO3zhb//hpgY6NPnE/z86vPbb+8ydux06tTxtDs0pVQ+Yme32BxggLU8APglYwPrCbBw4FtjTOr9ldTJy5YCPTPZPu1+ewJLrPZ53okTjqsWcMwkGRLyBB9/vJX779fx85VS2cvO5DIOaCciMUBbq4yIBIvIJKtNLyAUGCgi0dYnyFr3CvCiiOzEcU/la6v+a6C0Vf8imT+FluekpDgGpLx06UpdgQLQsaO3voGvlMp2kk/+qL+m4OBgExkZaXcYt2XJkpNMmDCBjh1fwcurEAChoVCrls2BKaXyLBGJMsZkOp66vkmXBxw8CK+9Npy5c0cxdmww+/dvoGpVTSxKKftocsnlkpPh3Xd/ZvXqKQDEx2/h6NFthIbaG5dSKn/T5JLLLVhwmEmTnnSWmzbty6uv9tH3WZRSttLkkovt3294882hnD6dCEDJkpV4663PqFTpOhsqpZSbaXLJpS5ehHHjZhAdHe6se/rpb2jTpqR9QSmllEWTSy41f/4hpk4d5iyHhj7J8OHt9bFjpVSOoMklF4qPhzFjnuPMGcfAAz4+/owa9T5l9V1JpVQOockll7l0CT78cA5RUT8464YO/YrQ0OI2RqWUUulpcsll1q2D33770llu3nwgw4a1x1OHDlNK5SCaXHKRo0dh40Z4+unZdO36Nj4+/owcOZ7ymY07rZRSNtLbv7mEMbBihWMMMU9PLzp3fpVu3V6iXTt9oUUplfPolUsusWMHHDqUvi4srCDe3vbEo5RS16LJJRe4cAHmzt1N2kFGq1SBgAD7YlJKqWvR5JIL/P77Ed58szEffdSOgwe3U6AAtGhhd1RKKZU1TS45XGIivPfeSM6ePc727Yv54ovuNGiQQrFidkemlFJZ0+SSw337bRR//jnJWe7ffzxBQfrPppTK2fRbKgfbudPw+efPOe+11Kt3H88+e5++06KUyvE0ueRQly7Bxx//wK5dqwDH48fDh0/A39/mwJRS6gZocsmhIiPP8/33rzjLbdo8x4MP1rQxIqWUunGaXHKgc+fggw8+JilpLwDFivny0kuvUbKkvXEppdSNsiW5iIiPiCwUkRjrZ6lM2gSJyGoR2SIiG0Wkd5p100Vkh4hsFpFvRMTLqg8TkRMiEm193sjO83KVJUsSmTt3rLPcrdsoWrUqaV9ASil1k+y6chkBLDbG1AQWW+WMzgKPGmPqAh2Bj0SkpLVuOlALqAcUBgan2W6FMSbI+rzlrhNwlxMnYMKEMZw/fxKAcuXu5IUXhui0xUqpXMWu5NIVmGotTwW6ZWxgjPnbGBNjLccDh4EyVnm+sQBrAb/sCDo7rF1rOHPmmLPct+84GjTwsjEipZS6eXYll3LGmARr+SBQ7lqNRaQp4A3sylDvBfQH/pemurmIbBCRBSJS9xr7HCIikSISeeTIkVs6CVdLTIQ9e4RBg6YycmQU7dq9xNNPd9NHj5VSuY7bRkUWkUVAZoPBj0xbMMYYETGZtEvdTwVgGjDAGJOSYfXnwHJjzAqrvA6oYow5LSKdgdlApo9YGWMmAhMBgoODszx+dlq79sqyv38jGjVqRPXq9sWjlFK3ym3JxRjTNqt1InJIRCoYYxKs5HE4i3YlgHnASGPMXxnWvYmjm+zJNMc8mWZ5voh8LiK+xpjE2zwdtzt4EOLi0tc1bQoi9sSjlFK3w65usTnAAGt5APBLxgYi4g2EA98aY2ZlWDcY6AA8nPZqRkTKizi+jq2uNA8gyS1n4GLz5+/n/PlTznKFCuCXZ+4kKaXyG7uSyzignYjEAG2tMiISLCKpA2n1AkKBgWkeLQ6y1v0fjvs0qzM8ctwT2CwiG4BPgD4m7Tj1OVR8PEyYMJSRI6uxcOGHXLx4jiZN7I5KKaVuneSC7163Cw4ONpGRkbYd//331/Dyy80AEBE+/3wzQ4fWsS0epZS6ESISZYwJzmydvqFvswMH4NtvRzvLwcF96NFDE4tSKnfT5GKzmTMj2bx5AeC4ann88dcpW9bmoJRS6jZpcrHRwYPw7bdjnOXGjXvRvXttGyNSSinX0ORio59/3sSGDVcelBs0aKRetSil8gRNLjZJTISpU8c5y0FB3ejevZ6NESmllOtocrHJggW7iYiY4Sw/8sirVKhgY0BKKeVCmlxscPIkfPPNB6S+/1m7dlseekhfbFFK5R2aXGwQFXWR9evDneWHHhqh0xcrpfIUt40tpjJ3/jzs3u3N6NHbWblyEjExf9CvX2u7w1JKKZfS5JLNtm6Fy5ehcOEStGv3It27v0iNGnZHpZRSrqXdYtno8mXYsiV9XWAgeOi/glIqj9GvtWy0cyecO3el7OUFtWrZF49SSrmLJpds9N13i5k8eQB790YBjsTi7W1zUEop5QaaXLJJQgKEh0/gr7++ZezYYBYtmkBgoN1RKaWUe2hyySa//baTTZvmAY4BKjt1eoDixW0OSiml3ESTSzY4cwamT//cWQ4M7EyHDvqImFIq79Lkkg3Wrz/LqlWTneUHHniWihVtDEgppdxMk4ubpaTAlCnfc/bscQDKlq3Bww+3tzcopZRyM00ubhYbC4sW/Z+zHBY2lLvu0l+7Uipv0285N5szJ5K9eyMBKFCgII8+OhAvL5uDUkopN7MluYiIj4gsFJEY62epTNoEichqEdkiIhtFpHeadVNEZI+IRFufIKteROQTEdlpbdMoG0/rKidPwk8/feksBwf3onnz0jZGpJRS2cOuK5cRwGJjTE1gsVXO6CzwqDGmLtAR+EhESqZZ/09jTJD1ibbqOgE1rc8Q4As3xX9DoqJOERHxvbPcpcuT+PjYGJBSSmUTu5JLV2CqtTwV6JaxgTHmb2NMjLUcDxwGytzAfr81Dn8BJUXElim4UlIgKuoQ/v6NAahQoTbdu99jRyhKKZXt7BoVuZwxJsFaPgiUu1ZjEWkKeAO70lS/LSJvYF35GGMuAJWA/WnaxFl1CWQgIkNwXN3g74bJVPbtgxIlavCPf/zBwYM7OHfuEDVqiMuPo5RSOZHbkouILALKZ7JqZNqCMcaIiLnGfioA04ABJnXqRvgXjqTkDUwEXgHeupn4jDETrW0JDg7O8vi3aseOK8vly99F7dp3UUAnOFBK5RNu+7ozxrTNap2IHBKRCsaYBCt5HM6iXQlgHjDS6uZK3XfqlcgFEZkM/MMqHwAqp9mFn1WXrc6edVy5pKWjHyul8hO77rnMAQZYywOAXzI2EBFvIBzHPZRZGdZVsH4Kjvs1m9Ps91HrqbFmwIk0iSjb/P13CikpVy6GfHygzPXuFimlVB5iV3IZB7QTkRigrVVGRIJFZJLVphcQCgzM+MgxMF1ENgGbAF9gjFU/H9gN7AS+Ap7OjpPJaObMBbz+ek3mzfs3SUl7ufNOO6JQSin7iDEuv92Q6wQHB5vIyEiX7CsxETp27EVU1I8AtG//T2bPfo/ChV2ye6WUyjFEJMoYE5zZOn1D38XWrTvOhg1znOUePQZoYlFK5TuaXFwoJQVmzpzFpUsXAPD3b0TbtnVtjkoppbKfJhcXio+HlSv/6yy3aNGfKlVsDEgppWyiycWFVq3az99//wGAiAc9e/bRd1uUUvmSJhcXuXQJZs2a4SzXqtWGu+/O7B1SpZTK+zS5uMi+ffDXX1cGqWzZsq/ONqmUyrc0ubjIH3/8zf796wHHvC09e3ZHdCgxpVQ+pcnFBZKT4ZdfZjrLgYGdCAq6w8aIlFLKXppcXGDvXihcuBSlSwcA0LJlb8qWtTcmpZSykz7L5AK7d8O99z5LWNgzxMZG0KGDvtuilMrfNLncpuRk2G/NICMiVK3alLqaW5RS+Zx2i92mffvg8uUr5eLFdQRkpZTS5HKb9uxJX65a1Z44lFIqJ9Fusdtw6RJMmjSBjRvn07BhDxo27EG1atecsVkppfIFTS634cABWLt2Jnv2rGHbtkUUK1aEMmUGXH9DpZTK47Rb7DZERsazZ88aADw8POnW7QF9cVIppdDkcsuMgV9/vTJvy513hlG/vo+NESmlVM6hyeUWHToEERGzneXGjbtSoYJ98SilVE6iyeUW7dlj8PGpTJEipQC4774ueOhvUymlAJuSi4j4iMhCEYmxfpbKpE2QiKwWkS0islFEeqdZt0JEoq1PvIjMturDROREmnVvuOsc9u4V+vf/ivHjDzNixF/cfbfOCqaUUqns+lt7BLDYGFMTWGyVMzoLPGqMqQt0BD4SkZIAxpgQY0yQMSYIWA38nGa7FanrjDFvuSN4Y6B+ffDzAy+vAlSvfjd+fu44klJK5U52PYrcFQizlqcCy4BX0jYwxvydZjleRA4DZYDjqfUiUgJoDQxya7QZiECdOo7PxYuQmAje3tkZgVJK5Wx2XbmUM8YkWMsHgWu+eSgiTQFvYFeGVd1wXAGdTFPXXEQ2iMgCEXH7KF/e3uikYEoplYHbrlxEZBGQ2Ty/I9MWjDFGRMw19lMBmAYMMMakZFj9MDApTXkdUMUYc1pEOgOzgZpZ7HcIMATA39//2iejlFLqpogxWX6vu++gIjuAMGNMgpU8lhlj7sqkXQkcXWZjjTGzMqzzBXYAlYwx57M4TiwQbIxJvFY8wcHBJjIy8pbORSml8isRiTLGBGe2zq5usTlA6jgpA4BfMjYQEW8gHPg2Y2Kx9ATmpk0sIlJexPGOvNWV5gEkuTh2pZRS12FXchkHtBORGKCtVUZEgkUktZurFxAKDEzzaHFQmn30Ab7PsN+ewGYR2QB8AvQxdlyaKaVUPmdLt1hOo91iSil183Jit5hSSqk8TK9cABE5AuzNhkP5Atd8uCAP0XPNe/LLeYKe642qYozJdO5dTS7ZSEQis7qEzGv0XPOe/HKeoOfqCtotppRSyuU0uSillHI5TS7Za6LdAWQjPde8J7+cJ+i53ja956KUUsrl9MpFKaWUy2lyUUop5XKaXLKBiHwjIodFZLPdsbibiFQWkaUistWaRXS43TG5g4gUEpG11vQOW0RktN0xuZuIeIrIehGZa3cs7iQisSKyyRpyKs8O3SEiJUVklohsF5FtItLcpfvXey7uJyKhwGkcg3AG2h2PO1mjXFcwxqwTkeJAFNDNGLPV5tBcyhogtag1vYMXsBIYboz5y+bQ3EZEXgSCgRLGmPvtjsddbnQ09dxORKbimLl3kjVQcBFjzHFX7V+vXLKBMWY5cNTuOLKDMSbBGLPOWj4FbAMq2RuV6xmH01bRy/rk2b/URMQPuI/08yepXEpE7sAxMPDXAMaYi65MLKDJRbmRiAQADYE1NofiFlY3UTRwGFhojMmT52n5CHgZyDhhX15kgN9FJMqaVDAvqgocASZbXZ2TRKSoKw+gyUW5hYgUA34Cns8wDXWeYYy5bIwJAvyApiKSJ7s8ReR+4LAxJsruWLJJS2NMI6AT8IzVrZ3XFAAaAV8YYxoCZ4ARrjyAJhflctY9iJ+A6caYn+2Ox92s7oSlQEebQ3GXFkAX617EDKC1iPzX3pDcxxhzwPp5GMeEhU3tjcgt4oC4NFfbs3AkG5fR5KJcyrrR/TWwzRjzod3xuIuIlBGRktZyYaAdsN3WoNzEGPMvY4yfMSYAxyR9S4wxj9gclluISFHrQRSsbqL2QJ57ytMYcxDYLyKp08u3AVz60E0BV+5MZU5EvgfCAF8RiQPeNMZ8bW9UbtMC6A9ssu5HALxqjJlvX0huUQGYKiKeOP5I+8EYk6cf0c0nygHh1mzpBYDvjDH/szcktxkGTLeeFNsNDHLlzvVRZKWUUi6n3WJKKaVcTpOLUkopl9PkopRSyuU0uSillHI5TS5KKaVcTpOLUkopl9PkopRSyuU0uSiVA4lIExHZaM0bU9SaMyZPjl2m8iZ9iVKpHEpExgCFgMI4xoF6x+aQlLphmlyUyqGsYTkigPPAPcaYyzaHpNQN024xpXKu0kAxoDiOKxilcg29clEqhxKROTiGuK+KY+roZ20OSakbpqMiK5UDicijQLIx5jtr5OVVItLaGLPE7tiUuhF65aKUUsrl9J6LUkopl9PkopRSyuU0uSillHI5TS5KKaVcTpOLUkopl9PkopRSyuU0uSillHK5/weD0b0A/D8Q1gAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.figure()\n", + "plt.plot(x0, y0, \"ro\", label=\"Initial condition\", alpha=0.6, markersize=8)\n", + "plt.plot(x_test, y_test, \"b\", label=\"Exact solution\", alpha=0.4, linewidth=4)\n", + "plt.plot(sim[:, 0], sim[:, 1], \"k--\", label=\"SINDy model\", linewidth=3)\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"y\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b29fd0b5", + "metadata": {}, + "source": [ + "Note that if the library we had chosen had been inappropriate for the problem at hand (i.e. if the dynamics could not be well-approximated as a sparse linear combination of library functions), then SINDy would have failed to produce a reasonable model. For example, if we solve the same problem, but using sines and cosines as our basis functions, SINDy is unable to find a sparse model for the dynamics:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "550097e1", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-05T22:47:58.225801Z", + "iopub.status.busy": "2022-07-05T22:47:58.225437Z", + "iopub.status.idle": "2022-07-05T22:47:58.235337Z", + "shell.execute_reply": "2022-07-05T22:47:58.234485Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(x)' = 0.772 sin(1 x) + 2.097 cos(1 x) + -2.298 sin(1 y) + -3.115 cos(1 y)\n", + "(y)' = 1.362 sin(1 y) + -0.222 cos(1 y)\n" + ] + } + ], + "source": [ + "# Populate the library with trigonometric functions\n", + "feature_library = ps.FourierLibrary()\n", + "\n", + "model = ps.SINDy(\n", + " differentiation_method=differentiation_method,\n", + " feature_library=feature_library,\n", + " optimizer=optimizer,\n", + " feature_names=[\"x\", \"y\"],\n", + ")\n", + "model.fit(X, t=t)\n", + "model.print()" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all", + "text_representation": { + "extension": ".py", + "format_name": "percent" + } + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/2_introduction_to_sindy/example.py b/examples/2_introduction_to_sindy/example.py new file mode 100644 index 00000000..adc32d7c --- /dev/null +++ b/examples/2_introduction_to_sindy/example.py @@ -0,0 +1,200 @@ +# %% [markdown] +# # An introduction to Sparse Identification of Nonlinear Dynamical systems (SINDy) +# This notebook gives an overview of the Sparse Identification of Nonlinear Dynamical systems (SINDy) method and discusses the relationship between SINDy and PySINDy. It also includes a brief example showing how different objects in the SINDy method are represented in PySINDy. +# %% [markdown] +# [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/dynamicslab/pysindy/v1.7?filepath=examples/2_introduction_to_sindy.ipynb) +# %% [markdown] +# ## Main ideas +# Suppose we have a set of measurements $x(t)\in \mathbb{R}^n$ from some physical system at different points in time $t$. SINDy seeks to represent the time evolution of $x(t)$ in terms of a nonlinear function $f$: +# +# $$ \frac{d}{dt}x(t) = f(x(t)). $$ +# +# This equation constitutes a *dynamical system* for the measurements $x(t)$. The vector $x(t)=[x_1(t), x_2(t), \dots x_n(t)]^\top$ gives the state of the physical system at time $t$. The function $f(x(t))$ constrains how the system evolves in time. +# +# The key idea behind SINDy is that the function $f$ is often **sparse** in the space of an appropriate set of basis functions. For example, the function +# +# $$ +# \frac{d}{dt}x = f(x) +# = \begin{bmatrix} f_1(x)\\f_2(x) \end{bmatrix} +# = \begin{bmatrix}1 - x_1 + 3x_1x_2 \\ x_2^2 - 5x_1^3 \end{bmatrix} +# $$ +# +# is sparse with respect to the set of polynomials of two variables in the sense that if we were to write an expansion of the component functions of $f$ in this basis (e.g. $f_{1}(x) = \sum_{i=0}^\infty\sum_{j=0}^\infty a_{i,j}x_1^ix_2^j$), only a small number of coefficients ($a_{i,j}$) would be nonzero. +# +# SINDy employs **sparse regression** to find a linear combination of basis functions that best capture the dynamic behavior of the physical system. +# %% [markdown] +# ## Approximation problem +# To apply SINDy in practice one needs a set of measurement data collected at times $t_1, t_2, \dots, t_n$, and the time derivatives of these measurements (either measured directly or numerically approximated). These data are aggregated into the matrices $X$ and $\dot X$, respectively +# +# $$ +# X = \begin{bmatrix} +# x_1(t_1) & x_2(t_1) & \dots & x_n(t_1) \\ +# x_1(t_2) & x_2(t_2) & \dots & x_n(t_2) \\ +# \vdots & \vdots & & \vdots \\ x_1(t_m) & x_2(t_m) & \dots & x_n(t_m) +# \end{bmatrix}, +# \qquad +# \dot{X} = \begin{bmatrix} \dot{x_1}(t_1) & \dot{x_2}(t_1) & \dots & \dot{x_n}(t_1) \\ +# \dot{x_1}(t_2) & \dot{x_2}(t_2) & \dots & \dot{x_n}(t_2) \\ +# \vdots & \vdots & & \vdots \\ +# \dot{x_1}(t_m) & \dot{x_2}(t_m) & \dots & \dot{x_n}(t_m) +# \end{bmatrix}. +# $$ +# +# Next, one forms a library matrix $\Theta(X)$ whose columns consist of a chosen set of basis functions applied to the data +# +# $$ +# \Theta(X) = \begin{bmatrix} +# \mid & \mid & & \mid \\ +# \theta_1(X) & \theta_2(X) & \dots & \theta_\ell(X) \\ +# \mid & \mid & & \mid +# \end{bmatrix}. +# $$ +# +# For example, if $\theta_1(x), \theta_2(x), \dots, \theta_\ell(x)$ are monomials ($\theta_i(x) = x^{i-1}$), then +# +# $$ +# \theta_3(X) = \begin{bmatrix} +# \mid & \mid & & \mid & \mid & & \mid \\ +# x_1(t)^2 & x_1(t)x_2(t) & \dots & x_2(t)^2 & x_2(t)x_3(t) & \dots & x_n^2(t) \\ +# \mid & \mid & & \mid & \mid & & \mid +# \end{bmatrix}, +# $$ +# +# where vector products and powers are understood to be element-wise. +# +# We seek a set of sparse coefficient vectors (collected into a matrix) +# +# $$ +# \Xi = \begin{bmatrix} +# \mid & \mid & & \mid \\ +# \xi_1 & \xi_2 & \dots & \xi_n \\ +# \mid & \mid & & \mid +# \end{bmatrix}. +# $$ +# +# The vector $\xi_i$ provides the coefficients for a linear combination of basis functions $\theta_1(x), \theta_2(x), \dots, \theta_\ell(x)$ representing the $i$th component function of $f$: $f_i(x)$. That is to say, $f_i(x) = \Theta\left(x^\top\right) \xi_i$, where $\Theta\left(x^\top\right)$ is understood to be a row vector consisting of symbolic functions (whereas $\Theta(X)$ is a matrix whose entries are numerical values). +# +# With each of the objects $X$, $\dot X$, $\Theta(X)$, and $\Xi$ being defined, we are ready to write down the approximation problem underlying SINDy: +# +# $$ \dot X \approx \Theta(X)\Xi. $$ +# %% [markdown] +# ## Structure of PySINDy +# The submodules of PySINDy are each aligned with one of the terms in the aforementioned approximation equation +# +# $$ \dot X \approx \Theta(X)\Xi. $$ +# +# * `pysindy.differentiate` performs numerical differentiation to compute $\dot X$ from $X$; +# * `pysindy.feature_library` allows the user to specify a set of library functions and handles the formation of $\Theta(X)$; +# * `pysindy.optimizers` provides a set of sparse regression solvers for determining $\Xi$. +# +# The `SINDy` object encapsulates one class object from each of these three submodules and uses them, along with a user-supplied data matrix, to find a governing dynamical system. +# +# Let's walk through an example showing how this works using a toy dataset. +# %% [markdown] +# ## Example +# Suppose we have measurements of the position of a particle obeying the following dynamical system at different points in time: +# +# $$ +# \frac{d}{dt} \begin{bmatrix} x \\ y \end{bmatrix} +# = \begin{bmatrix} -2x \\ y \end{bmatrix} +# = \begin{bmatrix} -2 & 0 \\ 0 & 1 \end{bmatrix} +# \begin{bmatrix} x \\ y \end{bmatrix} +# $$ +# +# Note that this system of differential equations decouples into two differential equations whose solutions are simply $x(t) = x_0e^{-2t}$ and $y(t) = y_0e^t$, where $x_0 = x(0)$ and $y_0=y(0)$ are the initial conditions. +# +# Using the initial conditions $x_0 = 3$ and $y_0 = \tfrac{1}{2}$, we construct the data matrix $X$. +# %% +import numpy as np +from example_data import gen_data1 +from example_data import gen_data2 + +import pysindy as ps + +# %% +t, x, y = gen_data1() +X = np.stack((x, y), axis=-1) # First column is x, second is y + +# %% [markdown] +# We can select a differentiation method from the `differentiation` submodule. + +# %% +differentiation_method = ps.FiniteDifference(order=2) + +# We could instead call ps.differentiation.FiniteDifference(order=2) + +# %% [markdown] +# While we could use this method to compute $\dot X$ "by hand," it is often more convenient to pass it into the `SINDy` object and let the computation of $\dot X$ be handled automatically. +# +# The candidate library can be specified with an object from the `feature_library` submodule, which will also be passed into the `SINDy` object. + +# %% +feature_library = ps.PolynomialLibrary(degree=3) + +# Note: We could instead call ps.feature_library.PolynomialLibrary(degree=3) + +# %% [markdown] +# Next we select which optimizer should be used. + +# %% +optimizer = ps.STLSQ(threshold=0.2) + +# Note: We could instead call ps.optimizers.STLSQ(threshold=0.2) + +# %% [markdown] +# Finally, we bring these three components together in one `SINDy` object. + +# %% +model = ps.SINDy( + differentiation_method=differentiation_method, + feature_library=feature_library, + optimizer=optimizer, + feature_names=["x", "y"], +) + +# %% [markdown] +# Following the `scikit-learn` workflow, we first instantiate a `SINDy` class object with the desired properties, then fit it to the data in separate step. + +# %% +model.fit(X, t=t) + +# %% [markdown] +# We can inspect the governing equations discovered by the model and check whether they seem reasonable with the `print` function. + +# %% +model.print() + +# %% [markdown] +# Once the SINDy model has been fit we can use it to evolve new initial conditions forward in time with the `simulate` function. + +# %% +x0, y0, t_test, x_test, y_test = gen_data2() +sim = model.simulate([x0, y0], t=t_test) + +# %% +import matplotlib.pyplot as plt + +plt.figure() +plt.plot(x0, y0, "ro", label="Initial condition", alpha=0.6, markersize=8) +plt.plot(x_test, y_test, "b", label="Exact solution", alpha=0.4, linewidth=4) +plt.plot(sim[:, 0], sim[:, 1], "k--", label="SINDy model", linewidth=3) +plt.xlabel("x") +plt.ylabel("y") +plt.legend() +plt.show() + +# %% [markdown] +# Note that if the library we had chosen had been inappropriate for the problem at hand (i.e. if the dynamics could not be well-approximated as a sparse linear combination of library functions), then SINDy would have failed to produce a reasonable model. For example, if we solve the same problem, but using sines and cosines as our basis functions, SINDy is unable to find a sparse model for the dynamics: + +# %% +# Populate the library with trigonometric functions +feature_library = ps.FourierLibrary() + +model = ps.SINDy( + differentiation_method=differentiation_method, + feature_library=feature_library, + optimizer=optimizer, + feature_names=["x", "y"], +) +model.fit(X, t=t) +model.print() diff --git a/examples/2_introduction_to_sindy/example_data.py b/examples/2_introduction_to_sindy/example_data.py new file mode 100644 index 00000000..136b895f --- /dev/null +++ b/examples/2_introduction_to_sindy/example_data.py @@ -0,0 +1,17 @@ +import numpy as np + + +def gen_data1(): + t = np.linspace(0, 1, 100) + x = 3 * np.exp(-2 * t) + y = 0.5 * np.exp(t) + return t, x, y + + +def gen_data2(): + x0 = 6 + y0 = -0.1 + t_test = np.linspace(0, 1, 100) + x_test = x0 * np.exp(-2 * t_test) + y_test = y0 * np.exp(t_test) + return x0, y0, t_test, x_test, y_test diff --git a/examples/2_introduction_to_sindy/mock_data.py b/examples/2_introduction_to_sindy/mock_data.py new file mode 100644 index 00000000..0c05698f --- /dev/null +++ b/examples/2_introduction_to_sindy/mock_data.py @@ -0,0 +1,17 @@ +import numpy as np + + +def gen_data1(): + t = np.linspace(0, 0.1, 10) + x = 3 * np.exp(-2 * t) + y = 0.5 * np.exp(t) + return t, x, y + + +def gen_data2(): + x0 = 6 + y0 = -0.1 + t_test = np.linspace(0, 0.1, 10) + x_test = x0 * np.exp(-2 * t_test) + y_test = y0 * np.exp(t_test) + return x0, y0, t_test, x_test, y_test diff --git a/examples/publish_notebook.py b/examples/publish_notebook.py new file mode 100644 index 00000000..726d4af2 --- /dev/null +++ b/examples/publish_notebook.py @@ -0,0 +1,39 @@ +import os +import sys +from argparse import ArgumentParser +from pathlib import Path + +import jupytext +import nbformat +from ipykernel import kernelapp as app +from nbconvert.preprocessors import ExecutePreprocessor + +notebook_dir = Path(__file__).parent + +argparser = ArgumentParser( + description="Create and run a .ipynb file from a script named 'example.py'." +) +argparser.add_argument("target", help="Directory containing example.py") + + +def _create_kernel() -> str: + """Create a IPython Kernel for the current executable.""" + kernel_name = sys.executable.replace("/", ".").replace("\\", ".").replace(":", ".") + app.launch_new_instance(argv=["install", "--user", "--name", kernel_name]) + return kernel_name + + +if __name__ == "__main__": + args = argparser.parse_args() + tgt_dir = Path(args.target) + tgt_file = tgt_dir.resolve() / "example.py" + # convert notebook-formatted python script to notebook + nb = jupytext.read(tgt_file) + cwd = Path.cwd() + os.chdir(tgt_dir) + # Run the notebook + ExecutePreprocessor(timeout=-1, kernel=_create_kernel).preprocess(nb) + os.chdir(cwd) + # Save the notebook + with open(str(tgt_dir / "example.ipynb"), "w", encoding="utf-8") as f: + nbformat.write(nb, f) diff --git a/requirements-dev.txt b/requirements-dev.txt index e7000018..b6f821e3 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -9,6 +9,7 @@ codecov setuptools_scm setuptools_scm_git_archive jupyter +jupytext notebook sphinx >= 2 sphinxcontrib-apidoc diff --git a/setup.cfg b/setup.cfg index 111fcd82..74135688 100644 --- a/setup.cfg +++ b/setup.cfg @@ -4,12 +4,15 @@ exclude = .venv, dist, build, + site-packages, + bin, __pycache__ ignore = W503 # Line break before binary operator - Conflicts black E203 # Whitespace before ':' - Conflicts black per-file-ignores = __init__.py:F401,F403 + examples/**:E402,E501 max-line-length = 88 import-order-style = smarkets statistics = True From 8e3c9d9b5fe3dfca259961b2a42b338536697a7e Mon Sep 17 00:00:00 2001 From: Jake Stevens-Haas Date: Tue, 5 Jul 2022 17:47:57 -0700 Subject: [PATCH 06/12] ENH: Add test functionality for notebook scripts via mock_data --- .../2_introduction_to_sindy/example.ipynb | 152 +++++++++--------- examples/2_introduction_to_sindy/example.py | 10 +- test/test_notebooks.py | 32 +++- 3 files changed, 114 insertions(+), 80 deletions(-) diff --git a/examples/2_introduction_to_sindy/example.ipynb b/examples/2_introduction_to_sindy/example.ipynb index 3118e703..f5520761 100644 --- a/examples/2_introduction_to_sindy/example.ipynb +++ b/examples/2_introduction_to_sindy/example.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "689291af", + "id": "97dfc2b6", "metadata": { "lines_to_next_cell": 0 }, @@ -13,7 +13,7 @@ }, { "cell_type": "markdown", - "id": "6ea0d61d", + "id": "827fcf3f", "metadata": { "lines_to_next_cell": 0 }, @@ -23,7 +23,7 @@ }, { "cell_type": "markdown", - "id": "45da8981", + "id": "a164fa66", "metadata": { "lines_to_next_cell": 0 }, @@ -50,7 +50,7 @@ }, { "cell_type": "markdown", - "id": "73caa123", + "id": "13685931", "metadata": { "lines_to_next_cell": 0 }, @@ -113,7 +113,7 @@ }, { "cell_type": "markdown", - "id": "2ce0bc10", + "id": "b015fa9b", "metadata": { "lines_to_next_cell": 0 }, @@ -134,7 +134,7 @@ }, { "cell_type": "markdown", - "id": "a222e4ef", + "id": "9c6295a4", "metadata": { "lines_to_next_cell": 0 }, @@ -157,34 +157,40 @@ { "cell_type": "code", "execution_count": 1, - "id": "a0b15f0d", + "id": "760c027c", "metadata": { "execution": { - "iopub.execute_input": "2022-07-05T22:47:56.825709Z", - "iopub.status.busy": "2022-07-05T22:47:56.824993Z", - "iopub.status.idle": "2022-07-05T22:47:57.329078Z", - "shell.execute_reply": "2022-07-05T22:47:57.328316Z" - } + "iopub.execute_input": "2022-07-06T00:43:54.334793Z", + "iopub.status.busy": "2022-07-06T00:43:54.334164Z", + "iopub.status.idle": "2022-07-06T00:43:54.843135Z", + "shell.execute_reply": "2022-07-06T00:43:54.842275Z" + }, + "lines_to_next_cell": 2 }, "outputs": [], "source": [ "import numpy as np\n", - "from example_data import gen_data1\n", - "from example_data import gen_data2\n", "\n", - "import pysindy as ps" + "import pysindy as ps\n", + "\n", + "if __name__ != \"testing\":\n", + " from example_data import gen_data1\n", + " from example_data import gen_data2\n", + "else:\n", + " from mock_data import gen_data1\n", + " from mock_data import gen_data2" ] }, { "cell_type": "code", "execution_count": 2, - "id": "9734bd11", + "id": "72256309", "metadata": { "execution": { - "iopub.execute_input": "2022-07-05T22:47:57.334079Z", - "iopub.status.busy": "2022-07-05T22:47:57.333778Z", - "iopub.status.idle": "2022-07-05T22:47:57.338020Z", - "shell.execute_reply": "2022-07-05T22:47:57.337404Z" + "iopub.execute_input": "2022-07-06T00:43:54.847201Z", + "iopub.status.busy": "2022-07-06T00:43:54.846876Z", + "iopub.status.idle": "2022-07-06T00:43:54.851460Z", + "shell.execute_reply": "2022-07-06T00:43:54.850804Z" } }, "outputs": [], @@ -195,7 +201,7 @@ }, { "cell_type": "markdown", - "id": "cf7827bb", + "id": "6906c2ef", "metadata": {}, "source": [ "We can select a differentiation method from the `differentiation` submodule." @@ -204,13 +210,13 @@ { "cell_type": "code", "execution_count": 3, - "id": "5048cd1c", + "id": "ee86b513", "metadata": { "execution": { - "iopub.execute_input": "2022-07-05T22:47:57.342438Z", - "iopub.status.busy": "2022-07-05T22:47:57.342104Z", - "iopub.status.idle": "2022-07-05T22:47:57.345542Z", - "shell.execute_reply": "2022-07-05T22:47:57.344825Z" + "iopub.execute_input": "2022-07-06T00:43:54.854815Z", + "iopub.status.busy": "2022-07-06T00:43:54.854544Z", + "iopub.status.idle": "2022-07-06T00:43:54.858256Z", + "shell.execute_reply": "2022-07-06T00:43:54.857631Z" } }, "outputs": [], @@ -222,7 +228,7 @@ }, { "cell_type": "markdown", - "id": "c97db345", + "id": "df8b6bd3", "metadata": {}, "source": [ "While we could use this method to compute $\\dot X$ \"by hand,\" it is often more convenient to pass it into the `SINDy` object and let the computation of $\\dot X$ be handled automatically.\n", @@ -233,13 +239,13 @@ { "cell_type": "code", "execution_count": 4, - "id": "7cbb50ce", + "id": "1b485201", "metadata": { "execution": { - "iopub.execute_input": "2022-07-05T22:47:57.349422Z", - "iopub.status.busy": "2022-07-05T22:47:57.349061Z", - "iopub.status.idle": "2022-07-05T22:47:57.353274Z", - "shell.execute_reply": "2022-07-05T22:47:57.352396Z" + "iopub.execute_input": "2022-07-06T00:43:54.861660Z", + "iopub.status.busy": "2022-07-06T00:43:54.861260Z", + "iopub.status.idle": "2022-07-06T00:43:54.865207Z", + "shell.execute_reply": "2022-07-06T00:43:54.864553Z" } }, "outputs": [], @@ -251,7 +257,7 @@ }, { "cell_type": "markdown", - "id": "6f56a564", + "id": "97263ee3", "metadata": {}, "source": [ "Next we select which optimizer should be used." @@ -260,13 +266,13 @@ { "cell_type": "code", "execution_count": 5, - "id": "08fd5275", + "id": "5617fad5", "metadata": { "execution": { - "iopub.execute_input": "2022-07-05T22:47:57.357021Z", - "iopub.status.busy": "2022-07-05T22:47:57.356725Z", - "iopub.status.idle": "2022-07-05T22:47:57.361165Z", - "shell.execute_reply": "2022-07-05T22:47:57.360123Z" + "iopub.execute_input": "2022-07-06T00:43:54.868326Z", + "iopub.status.busy": "2022-07-06T00:43:54.868094Z", + "iopub.status.idle": "2022-07-06T00:43:54.872182Z", + "shell.execute_reply": "2022-07-06T00:43:54.871132Z" } }, "outputs": [], @@ -278,7 +284,7 @@ }, { "cell_type": "markdown", - "id": "18dc5685", + "id": "949d0ec9", "metadata": {}, "source": [ "Finally, we bring these three components together in one `SINDy` object." @@ -287,13 +293,13 @@ { "cell_type": "code", "execution_count": 6, - "id": "8333785d", + "id": "0e1555fc", "metadata": { "execution": { - "iopub.execute_input": "2022-07-05T22:47:57.365905Z", - "iopub.status.busy": "2022-07-05T22:47:57.365506Z", - "iopub.status.idle": "2022-07-05T22:47:57.370218Z", - "shell.execute_reply": "2022-07-05T22:47:57.369254Z" + "iopub.execute_input": "2022-07-06T00:43:54.875960Z", + "iopub.status.busy": "2022-07-06T00:43:54.875691Z", + "iopub.status.idle": "2022-07-06T00:43:54.879557Z", + "shell.execute_reply": "2022-07-06T00:43:54.878948Z" } }, "outputs": [], @@ -308,7 +314,7 @@ }, { "cell_type": "markdown", - "id": "60273bde", + "id": "72948949", "metadata": {}, "source": [ "Following the `scikit-learn` workflow, we first instantiate a `SINDy` class object with the desired properties, then fit it to the data in separate step." @@ -317,13 +323,13 @@ { "cell_type": "code", "execution_count": 7, - "id": "d7612a79", + "id": "fb828425", "metadata": { "execution": { - "iopub.execute_input": "2022-07-05T22:47:57.374074Z", - "iopub.status.busy": "2022-07-05T22:47:57.373698Z", - "iopub.status.idle": "2022-07-05T22:47:57.395553Z", - "shell.execute_reply": "2022-07-05T22:47:57.394915Z" + "iopub.execute_input": "2022-07-06T00:43:54.882681Z", + "iopub.status.busy": "2022-07-06T00:43:54.882416Z", + "iopub.status.idle": "2022-07-06T00:43:54.902860Z", + "shell.execute_reply": "2022-07-06T00:43:54.901509Z" } }, "outputs": [ @@ -346,7 +352,7 @@ }, { "cell_type": "markdown", - "id": "47bab10d", + "id": "b319c4f7", "metadata": {}, "source": [ "We can inspect the governing equations discovered by the model and check whether they seem reasonable with the `print` function." @@ -355,13 +361,13 @@ { "cell_type": "code", "execution_count": 8, - "id": "70d207fd", + "id": "54b7321f", "metadata": { "execution": { - "iopub.execute_input": "2022-07-05T22:47:57.400206Z", - "iopub.status.busy": "2022-07-05T22:47:57.399847Z", - "iopub.status.idle": "2022-07-05T22:47:57.404757Z", - "shell.execute_reply": "2022-07-05T22:47:57.404056Z" + "iopub.execute_input": "2022-07-06T00:43:54.908324Z", + "iopub.status.busy": "2022-07-06T00:43:54.908016Z", + "iopub.status.idle": "2022-07-06T00:43:54.913613Z", + "shell.execute_reply": "2022-07-06T00:43:54.912952Z" } }, "outputs": [ @@ -380,7 +386,7 @@ }, { "cell_type": "markdown", - "id": "a465bf7f", + "id": "fc2df88d", "metadata": {}, "source": [ "Once the SINDy model has been fit we can use it to evolve new initial conditions forward in time with the `simulate` function." @@ -389,13 +395,13 @@ { "cell_type": "code", "execution_count": 9, - "id": "bfb37ed3", + "id": "08129225", "metadata": { "execution": { - "iopub.execute_input": "2022-07-05T22:47:57.408529Z", - "iopub.status.busy": "2022-07-05T22:47:57.408239Z", - "iopub.status.idle": "2022-07-05T22:47:57.487369Z", - "shell.execute_reply": "2022-07-05T22:47:57.486746Z" + "iopub.execute_input": "2022-07-06T00:43:54.916864Z", + "iopub.status.busy": "2022-07-06T00:43:54.916596Z", + "iopub.status.idle": "2022-07-06T00:43:54.998927Z", + "shell.execute_reply": "2022-07-06T00:43:54.998241Z" } }, "outputs": [], @@ -407,13 +413,13 @@ { "cell_type": "code", "execution_count": 10, - "id": "337501c9", + "id": "0a8e1bc6", "metadata": { "execution": { - "iopub.execute_input": "2022-07-05T22:47:57.491513Z", - "iopub.status.busy": "2022-07-05T22:47:57.491177Z", - "iopub.status.idle": "2022-07-05T22:47:58.220218Z", - "shell.execute_reply": "2022-07-05T22:47:58.219457Z" + "iopub.execute_input": "2022-07-06T00:43:55.002231Z", + "iopub.status.busy": "2022-07-06T00:43:55.001900Z", + "iopub.status.idle": "2022-07-06T00:43:55.718332Z", + "shell.execute_reply": "2022-07-06T00:43:55.717415Z" } }, "outputs": [ @@ -445,7 +451,7 @@ }, { "cell_type": "markdown", - "id": "b29fd0b5", + "id": "1d7adea2", "metadata": {}, "source": [ "Note that if the library we had chosen had been inappropriate for the problem at hand (i.e. if the dynamics could not be well-approximated as a sparse linear combination of library functions), then SINDy would have failed to produce a reasonable model. For example, if we solve the same problem, but using sines and cosines as our basis functions, SINDy is unable to find a sparse model for the dynamics:" @@ -454,13 +460,13 @@ { "cell_type": "code", "execution_count": 11, - "id": "550097e1", + "id": "a68446f0", "metadata": { "execution": { - "iopub.execute_input": "2022-07-05T22:47:58.225801Z", - "iopub.status.busy": "2022-07-05T22:47:58.225437Z", - "iopub.status.idle": "2022-07-05T22:47:58.235337Z", - "shell.execute_reply": "2022-07-05T22:47:58.234485Z" + "iopub.execute_input": "2022-07-06T00:43:55.722229Z", + "iopub.status.busy": "2022-07-06T00:43:55.721792Z", + "iopub.status.idle": "2022-07-06T00:43:55.732058Z", + "shell.execute_reply": "2022-07-06T00:43:55.731277Z" } }, "outputs": [ diff --git a/examples/2_introduction_to_sindy/example.py b/examples/2_introduction_to_sindy/example.py index adc32d7c..0aaac2e6 100644 --- a/examples/2_introduction_to_sindy/example.py +++ b/examples/2_introduction_to_sindy/example.py @@ -106,11 +106,17 @@ # Using the initial conditions $x_0 = 3$ and $y_0 = \tfrac{1}{2}$, we construct the data matrix $X$. # %% import numpy as np -from example_data import gen_data1 -from example_data import gen_data2 import pysindy as ps +if __name__ != "testing": + from example_data import gen_data1 + from example_data import gen_data2 +else: + from mock_data import gen_data1 + from mock_data import gen_data2 + + # %% t, x, y = gen_data1() X = np.stack((x, y), axis=-1) # First column is x, second is y diff --git a/test/test_notebooks.py b/test/test_notebooks.py index 04477ebf..2dad25fd 100644 --- a/test/test_notebooks.py +++ b/test/test_notebooks.py @@ -1,5 +1,7 @@ import os +import runpy import sys +from contextlib import contextmanager from pathlib import Path import nbformat @@ -10,6 +12,10 @@ # Find all example notebooks notebook_dir = Path(__file__).parent.parent / "examples" notebooks = [nb.name for nb in notebook_dir.glob("*.ipynb")] +notebook_scripts = [] +for x in notebook_dir.iterdir(): + if x.is_dir() and (x / "example.py").exists(): + notebook_scripts.append(x.name) def _load_notebook(filename: Path) -> nbformat.NotebookNode: @@ -26,12 +32,28 @@ def _create_kernel() -> str: return kernel_name +@contextmanager +def _cwd(directory): + """Modify working directory and sys.path temporarily""" + cwd = Path.cwd() + os.chdir(directory) + sys.path.insert(0, str(directory)) + yield + sys.path.pop(0) + os.chdir(cwd) + + +@pytest.mark.parametrize("directory", notebook_scripts) +def test_notebook_script(directory: Path): + # Run in native directory with modified sys.path for imports to work + with _cwd(notebook_dir / directory): + runpy.run_path(notebook_dir / directory / "example.py", run_name="testing") + + @pytest.mark.parametrize("filename", notebooks) @pytest.mark.slow def test_notebook(filename): nb = _load_notebook(notebook_dir / filename) - # Need to run in notebook directory to find data via relative path - os.chdir(notebook_dir) - # Run the notebook - ExecutePreprocessor(timeout=-1, kernel=_create_kernel).preprocess(nb) - os.chdir(Path(__file__).parent) + # Run in native directory to find data via relative path + with _cwd(notebook_dir): + ExecutePreprocessor(timeout=-1, kernel=_create_kernel).preprocess(nb) From b2fc2cda6d15ca8f3837e382449d6635bd490ea8 Mon Sep 17 00:00:00 2001 From: Jacob Stevens-Haas <37048747+Jacob-Stevens-Haas@users.noreply.github.com> Date: Tue, 5 Jul 2022 18:21:28 -0700 Subject: [PATCH 07/12] DOC: Add contributing guidance for notebook testing compatability --- README.rst | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/README.rst b/README.rst index 08e227ba..253d3680 100644 --- a/README.rst +++ b/README.rst @@ -157,6 +157,20 @@ Contributing examples ^^^^^^^^^^^^^^^^^^^^^ We love seeing examples of PySINDy being used to solve interesting problems! If you would like to contribute an example, reach out to us by creating an issue. +At a minimum, we need to be able to run the example notebooks in the normal mode as well as in a test mode that uses smaller data in order to run faster and simply verify that cells execute without error. In order to do that, your example should obey the following directory tree + +.. code-block:: + + .// + \ + |-example.py # save your notebook as a python script + |-example_data.py # has functions to create/load data + |-mock_data.py # has functions with same name as in example_data.py which create/load smaller datasets + |-example.ipynb # run python examples/publish_notebook/ to generate this. Needs packages in requirements-dev.txt + |-other files, if required (helper module, data, etc) + +You can optimize your notebook for testing by checking ``__name__``. When our tests run ``example.py`` they set the ``__name__`` global to ``"testing"``. For instance, your notebook should determine whether to import from ``mock_data`` or ``example_data`` using this method. + Contributing code ^^^^^^^^^^^^^^^^^ We welcome contributions to PySINDy. To contribute a new feature please submit a pull request. To get started we recommend installing the packages in ``requirements-dev.txt`` via From 37ca9b0dbefe877c7fea5af104107822bbe70997 Mon Sep 17 00:00:00 2001 From: Jake Stevens-Haas Date: Wed, 6 Jul 2022 13:53:39 -0700 Subject: [PATCH 08/12] CLN: Use user-agnostic kernel name in publish_notebooks.py --- examples/publish_notebook.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/examples/publish_notebook.py b/examples/publish_notebook.py index 726d4af2..f442e625 100644 --- a/examples/publish_notebook.py +++ b/examples/publish_notebook.py @@ -1,5 +1,4 @@ import os -import sys from argparse import ArgumentParser from pathlib import Path @@ -18,7 +17,7 @@ def _create_kernel() -> str: """Create a IPython Kernel for the current executable.""" - kernel_name = sys.executable.replace("/", ".").replace("\\", ".").replace(":", ".") + kernel_name = __name__ app.launch_new_instance(argv=["install", "--user", "--name", kernel_name]) return kernel_name From c22b72f91f69e092cf28a2ac20a252b30d31511b Mon Sep 17 00:00:00 2001 From: Jake Stevens-Haas Date: Wed, 6 Jul 2022 16:09:09 -0700 Subject: [PATCH 09/12] CLN: Refactor example 5 --- examples/5_differentiation.ipynb | 947 --------------------- examples/5_differentiation/example.ipynb | 847 ++++++++++++++++++ examples/5_differentiation/example.py | 299 +++++++ examples/5_differentiation/example_data.py | 58 ++ examples/5_differentiation/mock_data.py | 58 ++ examples/5_differentiation/utils.py | 118 +++ 6 files changed, 1380 insertions(+), 947 deletions(-) delete mode 100644 examples/5_differentiation.ipynb create mode 100644 examples/5_differentiation/example.ipynb create mode 100644 examples/5_differentiation/example.py create mode 100644 examples/5_differentiation/example_data.py create mode 100644 examples/5_differentiation/mock_data.py create mode 100644 examples/5_differentiation/utils.py diff --git a/examples/5_differentiation.ipynb b/examples/5_differentiation.ipynb deleted file mode 100644 index e59b9619..00000000 --- a/examples/5_differentiation.ipynb +++ /dev/null @@ -1,947 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Differentiators in PySINDy\n", - "\n", - "This notebook explores the differentiation methods available in PySINDy. Most of the methods are powered by the [derivative](https://pypi.org/project/derivative/) package. While this notebook explores these methods on temporal data, these apply equally well to the computation of spatial derivatives for SINDy for PDE identification (see example Jupyter notebooks 10 and 12, on PDEs and weak forms)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/dynamicslab/pysindy/v1.7?filepath=examples/5_differentiation.ipynb)" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:48:06.903196Z", - "start_time": "2020-10-22T00:48:05.715259Z" - } - }, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "from mpl_toolkits.mplot3d import Axes3D\n", - "import numpy as np\n", - "from scipy.integrate import solve_ivp\n", - "import seaborn as sns\n", - "from pysindy.utils import linear_damped_SHO, lorenz\n", - "\n", - "import pysindy as ps\n", - "\n", - "# ignore user warnings\n", - "import warnings\n", - "warnings.filterwarnings(\"ignore\", category=UserWarning)\n", - "\n", - "integrator_keywords = {}\n", - "integrator_keywords['rtol'] = 1e-12\n", - "integrator_keywords['method'] = 'LSODA'\n", - "integrator_keywords['atol'] = 1e-12" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the cell below we define all the available differentiators. Note that the different options in `SINDyDerivative` all originate from `derivative`.\n", - "\n", - "* `FiniteDifference` - First order (forward difference) or second order (centered difference) finite difference methods with the ability to drop endpoints. Does *not* assume a uniform time step. Appropriate for smooth data.\n", - "* `finite_difference` - Central finite differences of any order. Assumes a uniform time step. Appropriate for smooth data.\n", - "* `Smoothed Finite Difference` - `FiniteDifference` with a smoother (default is Savitzky Golay) applied to the data before differentiation. Appropriate for noisy data.\n", - "* `savitzky_golay` - Perform a least-squares fit of a polynomial to the data, then compute the derivative of the polynomial. Appropriate for noisy data.\n", - "* `spline` - Fit the data with a spline (of arbitrary order) then perform differentiation on the spline. Appropriate for noisy data.\n", - "* `trend_filtered` - Use total squared variations to fit the data (computes a global derivative that is a piecewise combination of polynomials of a chosen order). Set `order=0` to obtain the total-variational derivative. Appropriate for noisy data\n", - "* `spectral` - Compute the spectral derivative of the data via Fourier Transform. Appropriate for very smooth (i.e. analytic) data. There is an in-house PySINDy version for speed but this is also included in the derivative package." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:48:06.910728Z", - "start_time": "2020-10-22T00:48:06.904996Z" - } - }, - "outputs": [], - "source": [ - "diffs = [\n", - " ('PySINDy Finite Difference', ps.FiniteDifference()),\n", - " ('Finite Difference', ps.SINDyDerivative(kind='finite_difference', k=1)),\n", - " ('Smoothed Finite Difference', ps.SmoothedFiniteDifference()),\n", - " ('Savitzky Golay', ps.SINDyDerivative(kind='savitzky_golay', left=0.5, right=0.5, order=3)),\n", - " ('Spline', ps.SINDyDerivative(kind='spline', s=1e-2)),\n", - " ('Trend Filtered', ps.SINDyDerivative(kind='trend_filtered', order=0, alpha=1e-2)),\n", - " ('Spectral', ps.SINDyDerivative(kind='spectral')),\n", - " ('Spectral, PySINDy version', ps.SpectralDerivative()),\n", - "]\n", - "\n", - "plot_kws = dict(alpha=0.7, linewidth=3)\n", - "pal = sns.color_palette(\"Set1\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Compare differentiation methods directly\n", - "First we'll use the methods to numerically approximate derivatives to measurement data directly, without bringing SINDy into the picture. We'll compare the different methods' accuracies when working with clean data (\"approx\" in the plots) and data with a small amount of white noise (\"noisy\")." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:48:06.926293Z", - "start_time": "2020-10-22T00:48:06.913015Z" - } - }, - "outputs": [], - "source": [ - "noise_level = 0.01" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:48:06.941138Z", - "start_time": "2020-10-22T00:48:06.928146Z" - } - }, - "outputs": [], - "source": [ - "def compare_methods(diffs, x, y, y_noisy, y_dot):\n", - " n_methods = len(diffs)\n", - " n_rows = (n_methods // 3) + int(n_methods % 3 > 0)\n", - " fig, axs = plt.subplots(n_rows, 3, figsize=(15, 3 * n_rows), sharex=True)\n", - "\n", - " for (name, method), ax in zip(diffs, axs.flatten()):\n", - " ax.plot(x, y_dot, label='Exact', color=pal[0], **plot_kws)\n", - " ax.plot(x, method(y, x), ':', label='Approx.', color='black', **plot_kws)\n", - " ax.plot(x, method(y_noisy, x), label='Noisy', color=pal[1], **plot_kws)\n", - " ax.set(title=name)\n", - "\n", - " axs[0, 0].legend()\n", - " fig.show()\n", - " \n", - " return axs" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Sine" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:48:09.012229Z", - "start_time": "2020-10-22T00:48:06.943691Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# True data\n", - "x = np.linspace(0, 2 * np.pi, 100)\n", - "y = np.sin(x)\n", - "y_dot = np.cos(x)\n", - "\n", - "# Add noise\n", - "seed = 111\n", - "np.random.seed(seed)\n", - "y_noisy = y + noise_level * np.random.randn(len(y))\n", - "\n", - "axs = compare_methods(diffs, x, y, y_noisy, y_dot)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Absolute value" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:48:11.158330Z", - "start_time": "2020-10-22T00:48:09.015382Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Shrink window for Savitzky Golay method\n", - "diffs[3] = ('Savitzky Golay', ps.SINDyDerivative(kind='savitzky_golay', left=0.1, right=0.1, order=3))\n", - "\n", - "# True data\n", - "x = np.linspace(-1, 1, 100)\n", - "y = np.abs(x)\n", - "y_dot = np.sign(x)\n", - "\n", - "# Add noise\n", - "seed = 111\n", - "np.random.seed(seed)\n", - "y_noisy = y + noise_level * np.random.randn(len(y))\n", - "\n", - "axs = compare_methods(diffs, x, y, y_noisy, y_dot)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Compare differentiators when used in PySINDy\n", - "We got some idea of the performance of the differentiation options applied to raw data. Next we'll look at how they work as a single component of the SINDy algorithm." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:48:11.163238Z", - "start_time": "2020-10-22T00:48:11.159639Z" - } - }, - "outputs": [], - "source": [ - "def print_equations(equations_clean, equations_noisy):\n", - " print(f\"{'':<30} {'Noiseless':<40} {'Noisy':<40}\")\n", - " \n", - " for name in equations_clean.keys():\n", - " print(f\"{name:<30} {'':<40} {'':<40}\")\n", - "\n", - " for k, (eq1, eq2) in enumerate(zip(equations_clean[name], equations_noisy[name])):\n", - " print(f\"{'':<30} {'x' + str(k) + '=' + str(eq1):<40} {'x' + str(k) + '=' + str(eq2):<40}\")\n", - " \n", - " print(\"-------------------------------------------------------------------------------------------\")" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T01:05:13.309258Z", - "start_time": "2020-10-22T01:05:13.288904Z" - } - }, - "outputs": [], - "source": [ - "def plot_coefficients(coefficients, input_features=None, feature_names=None, ax=None, **heatmap_kws):\n", - " if input_features is None:\n", - " input_features = [f\"$\\dot x_{k}$\" for k in range(coefficients.shape[0])]\n", - " else:\n", - " input_features = [f\"$\\dot {fi}$\" for fi in input_features]\n", - " \n", - " if feature_names is None:\n", - " feature_names = [f\"f{k}\" for k in range(coefficients.shape[1])]\n", - "\n", - " \n", - " with sns.axes_style(style=\"white\", rc={\"axes.facecolor\": (0, 0, 0, 0)}): \n", - " if ax is None:\n", - " fig, ax = plt.subplots(1, 1)\n", - " \n", - " max_mag = np.max(np.abs(coefficients))\n", - " heatmap_args = {\n", - " \"xticklabels\": input_features,\n", - " \"yticklabels\": feature_names,\n", - " \"center\": 0.0,\n", - " \"cmap\": sns.color_palette(\"vlag\", n_colors=20, as_cmap=True),\n", - " \"ax\": ax,\n", - " \"linewidths\": 0.1,\n", - " \"linecolor\": \"whitesmoke\",\n", - " }\n", - " heatmap_args.update(**heatmap_kws)\n", - "\n", - " sns.heatmap(\n", - " coefficients.T,\n", - " **heatmap_args\n", - " )\n", - "\n", - " ax.tick_params(axis=\"y\", rotation=0)\n", - " \n", - " return ax" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T01:22:36.038884Z", - "start_time": "2020-10-22T01:22:36.027448Z" - } - }, - "outputs": [], - "source": [ - "def compare_coefficient_plots(\n", - " coefficients_clean,\n", - " coefficients_noisy,\n", - " input_features=None,\n", - " feature_names=None\n", - "):\n", - " n_cols = len(coefficients_clean)\n", - " \n", - " def signed_sqrt(x):\n", - " return np.sign(x) * np.sqrt(np.abs(x))\n", - " \n", - " \n", - " with sns.axes_style(style=\"white\", rc={\"axes.facecolor\": (0, 0, 0, 0)}):\n", - " fig, axs = plt.subplots(2, n_cols, figsize=(1.9 * n_cols, 8), sharey=True, sharex=True)\n", - " \n", - " max_clean = max(np.max(np.abs(c)) for c in coefficients_clean.values())\n", - " max_noisy = max(np.max(np.abs(c)) for c in coefficients_noisy.values())\n", - " max_mag = np.sqrt(max(max_clean, max_noisy))\n", - "\n", - " for k, name in enumerate(coefficients_clean.keys()):\n", - " plot_coefficients(\n", - " signed_sqrt(coefficients_clean[name]),\n", - " input_features=input_features,\n", - " feature_names=feature_names,\n", - " ax=axs[0, k],\n", - " cbar=False,\n", - " vmax=max_mag,\n", - " vmin=-max_mag\n", - " )\n", - "\n", - " plot_coefficients(\n", - " signed_sqrt(coefficients_clean[name]),\n", - " input_features=input_features,\n", - " feature_names=feature_names,\n", - " ax=axs[1, k],\n", - " cbar=False\n", - " )\n", - " \n", - " axs[0, k].set_title(name, rotation=45)\n", - " \n", - " axs[0, 0].set_ylabel(\"Noiseless\", labelpad=10)\n", - " axs[1, 0].set_ylabel(\"Noisy\", labelpad=10)\n", - " \n", - " fig.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Linear oscillator\n", - "$$ \\frac{d}{dt} \\begin{bmatrix}x \\\\ y\\end{bmatrix} = \\begin{bmatrix} -0.1 & 2 \\\\ -2 & -0.1 \\end{bmatrix} \\begin{bmatrix}x \\\\ y\\end{bmatrix} $$" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:48:11.217238Z", - "start_time": "2020-10-22T00:48:11.207399Z" - } - }, - "outputs": [], - "source": [ - "noise_level = 0.1" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:48:11.240884Z", - "start_time": "2020-10-22T00:48:11.221836Z" - } - }, - "outputs": [], - "source": [ - "# Generate training data\n", - "\n", - "dt = 0.01\n", - "t_train = np.arange(0, 10, dt)\n", - "t_train_span = (t_train[0], t_train[-1])\n", - "x0_train = [2, 0]\n", - "x_train = solve_ivp(linear_damped_SHO, t_train_span, x0_train, t_eval=t_train, **integrator_keywords).y.T\n", - "x_train_noisy = x_train + noise_level * np.random.randn(*x_train.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:48:11.699299Z", - "start_time": "2020-10-22T00:48:11.243364Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(1, 1, figsize=(5, 5))\n", - "\n", - "ax.plot(x_train[:, 0], x_train[:, 1], '.', label=\"Clean\", color=pal[0], **plot_kws)\n", - "ax.plot(x_train_noisy[:, 0], x_train_noisy[:, 1], '.', label=\"Noisy\", color=pal[1], **plot_kws)\n", - "\n", - "ax.set(title='Training data', xlabel='$x_0$', ylabel='$x_1$')\n", - "ax.legend()\n", - "fig.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:48:18.466181Z", - "start_time": "2020-10-22T00:48:11.700733Z" - } - }, - "outputs": [], - "source": [ - "# Allow Trend Filtered method to work with linear functions\n", - "diffs[5] = ('Trend Filtered', ps.SINDyDerivative(kind='trend_filtered', order=1, alpha=1e-2))\n", - "\n", - "equations_clean = {}\n", - "equations_noisy = {}\n", - "coefficients_clean = {}\n", - "coefficients_noisy = {}\n", - "input_features = ['x', 'y']\n", - "threshold = 0.5\n", - "\n", - "for name, method in diffs:\n", - " model = ps.SINDy(\n", - " differentiation_method=method,\n", - " optimizer=ps.STLSQ(threshold=threshold),\n", - " t_default=dt,\n", - " feature_names=input_features\n", - " )\n", - " \n", - " model.fit(x_train, quiet=True)\n", - " equations_clean[name] = model.equations()\n", - " coefficients_clean[name] = model.coefficients()\n", - " \n", - " model.fit(x_train_noisy, quiet=True)\n", - " equations_noisy[name] = model.equations()\n", - " coefficients_noisy[name] = model.coefficients()" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:48:18.505285Z", - "start_time": "2020-10-22T00:48:18.485290Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Noiseless Noisy \n", - "PySINDy Finite Difference \n", - " x0=2.006 y x0=2.034 y \n", - " x1=-1.994 x x1=-2.033 x \n", - "-------------------------------------------------------------------------------------------\n", - "Finite Difference \n", - " x0=2.006 y x0=2.034 y \n", - " x1=-1.994 x x1=-2.042 x \n", - "-------------------------------------------------------------------------------------------\n", - "Smoothed Finite Difference \n", - " x0=2.006 y x0=1.996 y \n", - " x1=-1.994 x x1=-2.020 x \n", - "-------------------------------------------------------------------------------------------\n", - "Savitzky Golay \n", - " x0=2.006 y x0=1.988 y \n", - " x1=-1.994 x x1=-2.011 x \n", - "-------------------------------------------------------------------------------------------\n", - "Spline \n", - " x0=2.006 y x0=1.943 y \n", - " x1=-1.996 x x1=-2.041 x \n", - "-------------------------------------------------------------------------------------------\n", - "Trend Filtered \n", - " x0=1.955 y x0=1.929 y \n", - " x1=-2.087 x + -0.522 x y x1=-2.005 x \n", - "-------------------------------------------------------------------------------------------\n", - "Spectral \n", - " x0=1.941 y x0=1.958 y \n", - " x1=-1.902 x x1=-1.920 x \n", - "-------------------------------------------------------------------------------------------\n", - "Spectral, PySINDy version \n", - " x0=1.941 y x0=1.958 y \n", - " x1=-1.902 x x1=-1.920 x \n", - "-------------------------------------------------------------------------------------------\n" - ] - } - ], - "source": [ - "print_equations(equations_clean, equations_noisy)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:48:21.413934Z", - "start_time": "2020-10-22T00:48:18.508010Z" - }, - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "feature_names = model.get_feature_names()\n", - "compare_coefficient_plots(\n", - " coefficients_clean,\n", - " coefficients_noisy,\n", - " input_features=input_features,\n", - " feature_names=feature_names\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Lorenz system\n", - "\n", - "$$ \\begin{aligned} \\dot x &= 10(y-x)\\\\ \\dot y &= x(28 - z) - y \\\\ \\dot z &= xy - \\tfrac{8}{3} z, \\end{aligned} $$\n" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:48:21.418648Z", - "start_time": "2020-10-22T00:48:21.415828Z" - } - }, - "outputs": [], - "source": [ - "noise_level = 0.5" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:48:21.454161Z", - "start_time": "2020-10-22T00:48:21.420600Z" - } - }, - "outputs": [], - "source": [ - "# Generate measurement data\n", - "dt = .002\n", - "\n", - "t_train = np.arange(0, 10, dt)\n", - "t_train_span = (t_train[0], t_train[-1])\n", - "x0_train = [-8, 8, 27]\n", - "x_train = solve_ivp(lorenz, t_train_span, x0_train, t_eval=t_train, **integrator_keywords).y.T\n", - "x_train_noisy = x_train + noise_level * np.random.randn(*x_train.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:48:21.698815Z", - "start_time": "2020-10-22T00:48:21.457194Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig = plt.figure(figsize=(8, 8))\n", - "ax = fig.add_subplot(1, 1, 1, projection=\"3d\")\n", - "ax.plot(\n", - " x_train[:, 0],\n", - " x_train[:, 1],\n", - " x_train[:, 2],\n", - " color=pal[0],\n", - " label='Clean',\n", - " **plot_kws\n", - ")\n", - "\n", - "ax.plot(\n", - " x_train_noisy[:, 0],\n", - " x_train_noisy[:, 1],\n", - " x_train_noisy[:, 2],\n", - " '.',\n", - " color=pal[1],\n", - " label='Noisy',\n", - " alpha=0.3,\n", - ")\n", - "ax.set(title='Training data', xlabel=\"$x$\", ylabel=\"$y$\", zlabel=\"$z$\")\n", - "ax.legend()\n", - "fig.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:57:36.953291Z", - "start_time": "2020-10-22T00:48:21.700494Z" - } - }, - "outputs": [], - "source": [ - "equations_clean = {}\n", - "equations_noisy = {}\n", - "coefficients_clean = {}\n", - "coefficients_noisy = {}\n", - "input_features = ['x', 'y', 'z']\n", - "\n", - "threshold = 0.5\n", - "\n", - "for name, method in diffs:\n", - " model = ps.SINDy(\n", - " differentiation_method=method,\n", - " optimizer=ps.STLSQ(threshold=threshold),\n", - " t_default=dt,\n", - " feature_names=input_features\n", - " )\n", - " \n", - " model.fit(x_train, quiet=True)\n", - " equations_clean[name] = model.equations()\n", - " coefficients_clean[name] = model.coefficients()\n", - " \n", - " model.fit(x_train_noisy, quiet=True)\n", - " equations_noisy[name] = model.equations()\n", - " coefficients_noisy[name] = model.coefficients()" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T00:57:37.011309Z", - "start_time": "2020-10-22T00:57:36.971242Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Noiseless Noisy \n", - "PySINDy Finite Difference \n", - " x0=-9.999 x + 9.999 y x0=-9.937 x + 9.968 y \n", - " x1=27.992 x + -0.999 y + -1.000 x z x1=0.651 1 + 24.904 x + -0.933 x z \n", - " x2=-2.666 z + 1.000 x y x2=-2.632 z + 0.994 x y \n", - "-------------------------------------------------------------------------------------------\n", - "Finite Difference \n", - " x0=-9.999 x + 9.999 y x0=-9.873 x + 9.907 y \n", - " x1=27.993 x + -0.999 y + -1.000 x z x1=0.633 1 + 24.937 x + -0.933 x z \n", - " x2=-2.666 z + 1.000 x y x2=-0.692 1 + -2.616 z + 0.995 x y \n", - "-------------------------------------------------------------------------------------------\n", - "Smoothed Finite Difference \n", - " x0=-9.999 x + 9.999 y x0=-9.714 x + 9.764 y \n", - " x1=27.992 x + -0.998 y + -1.000 x z x1=26.425 x + -0.533 y + -0.964 x z \n", - " x2=-2.666 z + 1.000 x y x2=-0.907 1 + -2.624 z + 0.998 x y \n", - "-------------------------------------------------------------------------------------------\n", - "Savitzky Golay \n", - " x0=-9.935 x + 9.935 y x0=-9.604 x + 9.651 y \n", - " x1=26.958 x + -0.776 y + -0.972 x z x1=24.677 x + -0.922 x z \n", - " x2=-2.635 z + 0.988 x y x2=-0.829 1 + -2.589 z + 0.986 x y \n", - "-------------------------------------------------------------------------------------------\n", - "Spline \n", - " x0=-10.000 x + 10.000 y x0=-9.935 x + 9.970 y \n", - " x1=28.003 x + -1.001 y + -1.000 x z x1=24.801 x + -0.929 x z \n", - " x2=-2.667 z + 1.000 x y x2=-61.574 1 + 1.062 x + -2.644 y + 0.857 x y\n", - "-------------------------------------------------------------------------------------------\n", - "Trend Filtered \n", - " x0=1.319 1 + -1.013 x + 0.948 y x0=1.357 1 + -0.987 x + 0.927 y \n", - " x1=0.000 x1=0.000 \n", - " x2=-1.109 1 x2=-1.152 1 \n", - "-------------------------------------------------------------------------------------------\n", - "Spectral \n", - " x0=-1.683 1 + -9.076 x + 9.149 y x0=-1.752 1 + -8.919 x + 9.042 y \n", - " x1=28.807 x + -1.369 y + -1.015 x z x1=26.175 x + -0.609 y + -0.954 x z \n", - " x2=86.435 1 + -7.282 z + 1.365 x^2 x2=83.111 1 + 0.519 y + -7.134 z + 1.335 x^2\n", - "-------------------------------------------------------------------------------------------\n", - "Spectral, PySINDy version \n", - " x0=-1.683 1 + -9.076 x + 9.149 y x0=-1.752 1 + -8.919 x + 9.042 y \n", - " x1=28.807 x + -1.369 y + -1.015 x z x1=26.175 x + -0.609 y + -0.954 x z \n", - " x2=86.435 1 + -7.282 z + 1.365 x^2 x2=83.111 1 + 0.519 y + -7.134 z + 1.335 x^2\n", - "-------------------------------------------------------------------------------------------\n" - ] - } - ], - "source": [ - "print_equations(equations_clean, equations_noisy)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-22T01:22:44.562073Z", - "start_time": "2020-10-22T01:22:42.078556Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "feature_names = model.get_feature_names()\n", - "compare_coefficient_plots(\n", - " coefficients_clean,\n", - " coefficients_noisy,\n", - " input_features=input_features,\n", - " feature_names=feature_names\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "import timeit\n", - "n_spectral = 8\n", - "N_spectral = np.logspace(1, 8, n_spectral, dtype=int)\n", - "spectral_times = np.zeros((n_spectral, 2))\n", - "for i in range(n_spectral):\n", - " # True data\n", - " x = np.linspace(0, 2 * np.pi, N_spectral[i])\n", - " y = np.sin(x)\n", - " y_dot = np.cos(x)\n", - " noise_level = 0.05\n", - " y_noisy = y + noise_level * np.random.randn(len(y))\n", - " \n", - " start = timeit.default_timer()\n", - " spectral1 = ps.SINDyDerivative(kind='spectral')(y_noisy, x)\n", - " stop = timeit.default_timer()\n", - " spectral_times[i, 0] = stop - start\n", - " \n", - " start = timeit.default_timer()\n", - " spectral2 = ps.SpectralDerivative(y_noisy, x)\n", - " stop = timeit.default_timer()\n", - " spectral_times[i, 1] = stop - start" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure()\n", - "plt.grid(True)\n", - "plt.semilogy(spectral_times[:, 0], label='derivative python package')\n", - "plt.semilogy(spectral_times[:, 1], label='In-house spectral derivative')\n", - "plt.ylabel('Time (s)')\n", - "plt.xlabel('Matrix size in powers of 10')\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Check error improves as order increases\n", - "x = np.linspace(0, 2 * np.pi, 100)\n", - "y = np.sin(x) - x ** 5\n", - "y_dot = np.cos(x) - 5 * x ** 4\n", - "err = np.zeros(9)\n", - "for order in range(1, 10):\n", - " diff = ps.FiniteDifference(d=1, order=order)\n", - " diff = diff(y, x)\n", - " err[order - 1] = np.sum(np.abs(y_dot - diff))\n", - "plt.figure()\n", - "plt.plot(range(1, 10), err)\n", - "plt.grid(True)\n", - "plt.ylabel('Derivative error')\n", - "plt.xlabel('Finite difference order')\n", - "plt.show()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.4" - }, - "toc": { - "base_numbering": 1, - "nav_menu": {}, - "number_sections": true, - "sideBar": true, - "skip_h1_title": false, - "title_cell": "Table of Contents", - "title_sidebar": "Contents", - "toc_cell": false, - "toc_position": {}, - "toc_section_display": true, - "toc_window_display": false - }, - "varInspector": { - "cols": { - "lenName": 16, - "lenType": 16, - "lenVar": 40 - }, - "kernels_config": { - "python": { - "delete_cmd_postfix": "", - "delete_cmd_prefix": "del ", - "library": "var_list.py", - "varRefreshCmd": "print(var_dic_list())" - }, - "r": { - "delete_cmd_postfix": ") ", - "delete_cmd_prefix": "rm(", - "library": "var_list.r", - "varRefreshCmd": "cat(var_dic_list()) " - } - }, - "types_to_exclude": [ - "module", - "function", - "builtin_function_or_method", - "instance", - "_Feature" - ], - "window_display": false - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/examples/5_differentiation/example.ipynb b/examples/5_differentiation/example.ipynb new file mode 100644 index 00000000..bf6e0da5 --- /dev/null +++ b/examples/5_differentiation/example.ipynb @@ -0,0 +1,847 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4f564d16", + "metadata": { + "lines_to_next_cell": 0 + }, + "source": [ + "# Differentiators in PySINDy\n", + "\n", + "This notebook explores the differentiation methods available in PySINDy. Most of the methods are powered by the [derivative](https://pypi.org/project/derivative/) package. While this notebook explores these methods on temporal data, these apply equally well to the computation of spatial derivatives for SINDy for PDE identification (see example Jupyter notebooks 10 and 12, on PDEs and weak forms)." + ] + }, + { + "cell_type": "markdown", + "id": "96350665", + "metadata": { + "lines_to_next_cell": 0 + }, + "source": [ + "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/dynamicslab/pysindy/v1.7?filepath=examples/5_differentiation.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5960f6ac", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:09:29.880939Z", + "iopub.status.busy": "2022-07-06T23:09:29.880342Z", + "iopub.status.idle": "2022-07-06T23:09:31.307218Z", + "shell.execute_reply": "2022-07-06T23:09:31.305943Z" + }, + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import warnings\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "import pysindy as ps\n", + "\n", + "# ignore user warnings\n", + "warnings.filterwarnings(\"ignore\", category=UserWarning)\n", + "\n", + "integrator_keywords = {}\n", + "integrator_keywords[\"rtol\"] = 1e-12\n", + "integrator_keywords[\"method\"] = \"LSODA\"\n", + "integrator_keywords[\"atol\"] = 1e-12\n", + "\n", + "from utils import (\n", + " plot_kws,\n", + " pal,\n", + " compare_methods,\n", + " print_equations,\n", + " compare_coefficient_plots,\n", + ")\n", + "\n", + "if __name__ != \"testing\":\n", + " from example_data import (\n", + " gen_data_sine,\n", + " gen_data_step,\n", + " gen_data_sho,\n", + " gen_data_lorenz,\n", + " n_spectral,\n", + " fd_order,\n", + " )\n", + "else:\n", + " from mock_data import (\n", + " gen_data_sine,\n", + " gen_data_step,\n", + " gen_data_sho,\n", + " gen_data_lorenz,\n", + " n_spectral,\n", + " fd_order,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "de5c5248", + "metadata": {}, + "source": [ + "In the cell below we define all the available differentiators. Note that the different options in `SINDyDerivative` all originate from `derivative`.\n", + "\n", + "* `FiniteDifference` - First order (forward difference) or second order (centered difference) finite difference methods with the ability to drop endpoints. Does *not* assume a uniform time step. Appropriate for smooth data.\n", + "* `finite_difference` - Central finite differences of any order. Assumes a uniform time step. Appropriate for smooth data.\n", + "* `Smoothed Finite Difference` - `FiniteDifference` with a smoother (default is Savitzky Golay) applied to the data before differentiation. Appropriate for noisy data.\n", + "* `savitzky_golay` - Perform a least-squares fit of a polynomial to the data, then compute the derivative of the polynomial. Appropriate for noisy data.\n", + "* `spline` - Fit the data with a spline (of arbitrary order) then perform differentiation on the spline. Appropriate for noisy data.\n", + "* `trend_filtered` - Use total squared variations to fit the data (computes a global derivative that is a piecewise combination of polynomials of a chosen order). Set `order=0` to obtain the total-variational derivative. Appropriate for noisy data\n", + "* `spectral` - Compute the spectral derivative of the data via Fourier Transform. Appropriate for very smooth (i.e. analytic) data. There is an in-house PySINDy version for speed but this is also included in the derivative package." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "95c0e048", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:09:31.312738Z", + "iopub.status.busy": "2022-07-06T23:09:31.312428Z", + "iopub.status.idle": "2022-07-06T23:09:31.318358Z", + "shell.execute_reply": "2022-07-06T23:09:31.317449Z" + } + }, + "outputs": [], + "source": [ + "diffs = [\n", + " (\"PySINDy Finite Difference\", ps.FiniteDifference()),\n", + " (\"Finite Difference\", ps.SINDyDerivative(kind=\"finite_difference\", k=1)),\n", + " (\"Smoothed Finite Difference\", ps.SmoothedFiniteDifference()),\n", + " (\n", + " \"Savitzky Golay\",\n", + " ps.SINDyDerivative(kind=\"savitzky_golay\", left=0.5, right=0.5, order=3),\n", + " ),\n", + " (\"Spline\", ps.SINDyDerivative(kind=\"spline\", s=1e-2)),\n", + " (\"Trend Filtered\", ps.SINDyDerivative(kind=\"trend_filtered\", order=0, alpha=1e-2)),\n", + " (\"Spectral\", ps.SINDyDerivative(kind=\"spectral\")),\n", + " (\"Spectral, PySINDy version\", ps.SpectralDerivative()),\n", + "]" + ] + }, + { + "cell_type": "markdown", + "id": "9fe16724", + "metadata": {}, + "source": [ + "## Compare differentiation methods directly\n", + "First we'll use the methods to numerically approximate derivatives to measurement data directly, without bringing SINDy into the picture. We'll compare the different methods' accuracies when working with clean data (\"approx\" in the plots) and data with a small amount of white noise (\"noisy\")." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "67417a70", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:09:31.323195Z", + "iopub.status.busy": "2022-07-06T23:09:31.322776Z", + "iopub.status.idle": "2022-07-06T23:09:31.326658Z", + "shell.execute_reply": "2022-07-06T23:09:31.325747Z" + } + }, + "outputs": [], + "source": [ + "noise_level = 0.01" + ] + }, + { + "cell_type": "markdown", + "id": "d6ea4986", + "metadata": {}, + "source": [ + "### Sine" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "50cc34fb", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:09:31.330293Z", + "iopub.status.busy": "2022-07-06T23:09:31.330008Z", + "iopub.status.idle": "2022-07-06T23:09:32.316519Z", + "shell.execute_reply": "2022-07-06T23:09:32.315303Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# True data\n", + "x, y, y_noisy, y_dot = gen_data_sine(noise_level)\n", + "axs = compare_methods(diffs, x, y, y_noisy, y_dot)" + ] + }, + { + "cell_type": "markdown", + "id": "ce89e215", + "metadata": {}, + "source": [ + "### Absolute value" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0839ce75", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:09:32.321402Z", + "iopub.status.busy": "2022-07-06T23:09:32.321185Z", + "iopub.status.idle": "2022-07-06T23:09:33.386267Z", + "shell.execute_reply": "2022-07-06T23:09:33.384935Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Shrink window for Savitzky Golay method\n", + "diffs[3] = (\n", + " \"Savitzky Golay\",\n", + " ps.SINDyDerivative(kind=\"savitzky_golay\", left=0.1, right=0.1, order=3),\n", + ")\n", + "\n", + "x, y, y_dot, y_noisy = gen_data_step(noise_level)\n", + "\n", + "axs = compare_methods(diffs, x, y, y_noisy, y_dot)" + ] + }, + { + "cell_type": "markdown", + "id": "06599fbb", + "metadata": {}, + "source": [ + "## Compare differentiators when used in PySINDy\n", + "We got some idea of the performance of the differentiation options applied to raw data. Next we'll look at how they work as a single component of the SINDy algorithm." + ] + }, + { + "cell_type": "markdown", + "id": "3a8b25c8", + "metadata": {}, + "source": [ + "### Linear oscillator\n", + "$$ \\frac{d}{dt} \\begin{bmatrix}x \\\\ y\\end{bmatrix} = \\begin{bmatrix} -0.1 & 2 \\\\ -2 & -0.1 \\end{bmatrix} \\begin{bmatrix}x \\\\ y\\end{bmatrix} $$" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f38fd27a", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:09:33.395957Z", + "iopub.status.busy": "2022-07-06T23:09:33.395672Z", + "iopub.status.idle": "2022-07-06T23:09:33.401695Z", + "shell.execute_reply": "2022-07-06T23:09:33.400708Z" + } + }, + "outputs": [], + "source": [ + "noise_level = 0.1" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "aaa58912", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:09:33.404670Z", + "iopub.status.busy": "2022-07-06T23:09:33.404454Z", + "iopub.status.idle": "2022-07-06T23:09:33.430406Z", + "shell.execute_reply": "2022-07-06T23:09:33.429484Z" + } + }, + "outputs": [], + "source": [ + "# Generate training data\n", + "\n", + "dt, t_train, x_train, x_train_noisy = gen_data_sho(noise_level, integrator_keywords)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9b848c29", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:09:33.434079Z", + "iopub.status.busy": "2022-07-06T23:09:33.433770Z", + "iopub.status.idle": "2022-07-06T23:09:33.700691Z", + "shell.execute_reply": "2022-07-06T23:09:33.699518Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 1, figsize=(5, 5))\n", + "\n", + "ax.plot(x_train[:, 0], x_train[:, 1], \".\", label=\"Clean\", color=pal[0], **plot_kws)\n", + "ax.plot(\n", + " x_train_noisy[:, 0],\n", + " x_train_noisy[:, 1],\n", + " \".\",\n", + " label=\"Noisy\",\n", + " color=pal[1],\n", + " **plot_kws\n", + ")\n", + "\n", + "ax.set(title=\"Training data\", xlabel=\"$x_0$\", ylabel=\"$x_1$\")\n", + "ax.legend()\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f9d57bfa", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:09:33.706134Z", + "iopub.status.busy": "2022-07-06T23:09:33.705806Z", + "iopub.status.idle": "2022-07-06T23:09:38.674620Z", + "shell.execute_reply": "2022-07-06T23:09:38.672267Z" + } + }, + "outputs": [], + "source": [ + "# Allow Trend Filtered method to work with linear functions\n", + "diffs[5] = (\n", + " \"Trend Filtered\",\n", + " ps.SINDyDerivative(kind=\"trend_filtered\", order=1, alpha=1e-2),\n", + ")\n", + "\n", + "equations_clean = {}\n", + "equations_noisy = {}\n", + "coefficients_clean = {}\n", + "coefficients_noisy = {}\n", + "input_features = [\"x\", \"y\"]\n", + "threshold = 0.5\n", + "\n", + "for name, method in diffs:\n", + " model = ps.SINDy(\n", + " differentiation_method=method,\n", + " optimizer=ps.STLSQ(threshold=threshold),\n", + " t_default=dt,\n", + " feature_names=input_features,\n", + " )\n", + "\n", + " model.fit(x_train, quiet=True)\n", + " equations_clean[name] = model.equations()\n", + " coefficients_clean[name] = model.coefficients()\n", + "\n", + " model.fit(x_train_noisy, quiet=True)\n", + " equations_noisy[name] = model.equations()\n", + " coefficients_noisy[name] = model.coefficients()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7fe931df", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:09:38.684121Z", + "iopub.status.busy": "2022-07-06T23:09:38.683272Z", + "iopub.status.idle": "2022-07-06T23:09:38.695906Z", + "shell.execute_reply": "2022-07-06T23:09:38.694023Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Noiseless Noisy \n", + "PySINDy Finite Difference \n", + " x0=2.006 y x0=2.034 y \n", + " x1=-1.994 x x1=-2.033 x \n", + "-------------------------------------------------------------------------------------------\n", + "Finite Difference \n", + " x0=2.006 y x0=2.034 y \n", + " x1=-1.994 x x1=-2.042 x \n", + "-------------------------------------------------------------------------------------------\n", + "Smoothed Finite Difference \n", + " x0=2.006 y x0=1.996 y \n", + " x1=-1.994 x x1=-2.020 x \n", + "-------------------------------------------------------------------------------------------\n", + "Savitzky Golay \n", + " x0=2.006 y x0=1.988 y \n", + " x1=-1.994 x x1=-2.011 x \n", + "-------------------------------------------------------------------------------------------\n", + "Spline \n", + " x0=2.006 y x0=1.943 y \n", + " x1=-1.996 x x1=-2.041 x \n", + "-------------------------------------------------------------------------------------------\n", + "Trend Filtered \n", + " x0=1.955 y x0=1.929 y \n", + " x1=-2.087 x + -0.522 x y x1=-2.005 x \n", + "-------------------------------------------------------------------------------------------\n", + "Spectral \n", + " x0=1.941 y x0=1.958 y \n", + " x1=-1.902 x x1=-1.920 x \n", + "-------------------------------------------------------------------------------------------\n", + "Spectral, PySINDy version \n", + " x0=1.941 y x0=1.958 y \n", + " x1=-1.902 x x1=-1.920 x \n", + "-------------------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "print_equations(equations_clean, equations_noisy)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "7a807897", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:09:38.702986Z", + "iopub.status.busy": "2022-07-06T23:09:38.702250Z", + "iopub.status.idle": "2022-07-06T23:09:41.034989Z", + "shell.execute_reply": "2022-07-06T23:09:41.033800Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "feature_names = model.get_feature_names()\n", + "compare_coefficient_plots(\n", + " coefficients_clean,\n", + " coefficients_noisy,\n", + " input_features=input_features,\n", + " feature_names=feature_names,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "62386501", + "metadata": {}, + "source": [ + "### Lorenz system\n", + "\n", + "$$ \\begin{aligned} \\dot x &= 10(y-x)\\\\ \\dot y &= x(28 - z) - y \\\\ \\dot z &= xy - \\tfrac{8}{3} z, \\end{aligned} $$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "93419e96", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:09:41.039987Z", + "iopub.status.busy": "2022-07-06T23:09:41.039750Z", + "iopub.status.idle": "2022-07-06T23:09:41.044014Z", + "shell.execute_reply": "2022-07-06T23:09:41.043178Z" + } + }, + "outputs": [], + "source": [ + "noise_level = 0.5" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "cf5f3b32", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:09:41.048536Z", + "iopub.status.busy": "2022-07-06T23:09:41.048231Z", + "iopub.status.idle": "2022-07-06T23:09:41.244831Z", + "shell.execute_reply": "2022-07-06T23:09:41.243652Z" + } + }, + "outputs": [], + "source": [ + "# Generate measurement data\n", + "dt, t_train, x_train, x_train_noisy = gen_data_lorenz(noise_level, integrator_keywords)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "1996edb0", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:09:41.248445Z", + "iopub.status.busy": "2022-07-06T23:09:41.248209Z", + "iopub.status.idle": "2022-07-06T23:09:41.442458Z", + "shell.execute_reply": "2022-07-06T23:09:41.441152Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(8, 8))\n", + "ax = fig.add_subplot(1, 1, 1, projection=\"3d\")\n", + "ax.plot(\n", + " x_train[:, 0], x_train[:, 1], x_train[:, 2], color=pal[0], label=\"Clean\", **plot_kws\n", + ")\n", + "\n", + "ax.plot(\n", + " x_train_noisy[:, 0],\n", + " x_train_noisy[:, 1],\n", + " x_train_noisy[:, 2],\n", + " \".\",\n", + " color=pal[1],\n", + " label=\"Noisy\",\n", + " alpha=0.3,\n", + ")\n", + "ax.set(title=\"Training data\", xlabel=\"$x$\", ylabel=\"$y$\", zlabel=\"$z$\")\n", + "ax.legend()\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "0f293962", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:09:41.448635Z", + "iopub.status.busy": "2022-07-06T23:09:41.448396Z", + "iopub.status.idle": "2022-07-06T23:14:29.433278Z", + "shell.execute_reply": "2022-07-06T23:14:29.430961Z" + } + }, + "outputs": [], + "source": [ + "equations_clean = {}\n", + "equations_noisy = {}\n", + "coefficients_clean = {}\n", + "coefficients_noisy = {}\n", + "input_features = [\"x\", \"y\", \"z\"]\n", + "\n", + "threshold = 0.5\n", + "\n", + "for name, method in diffs:\n", + " model = ps.SINDy(\n", + " differentiation_method=method,\n", + " optimizer=ps.STLSQ(threshold=threshold),\n", + " t_default=dt,\n", + " feature_names=input_features,\n", + " )\n", + "\n", + " model.fit(x_train, quiet=True)\n", + " equations_clean[name] = model.equations()\n", + " coefficients_clean[name] = model.coefficients()\n", + "\n", + " model.fit(x_train_noisy, quiet=True)\n", + " equations_noisy[name] = model.equations()\n", + " coefficients_noisy[name] = model.coefficients()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "0a514cc2", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:14:29.451420Z", + "iopub.status.busy": "2022-07-06T23:14:29.450431Z", + "iopub.status.idle": "2022-07-06T23:14:29.461840Z", + "shell.execute_reply": "2022-07-06T23:14:29.460329Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Noiseless Noisy \n", + "PySINDy Finite Difference \n", + " x0=-9.999 x + 9.999 y x0=-9.937 x + 9.968 y \n", + " x1=27.992 x + -0.999 y + -1.000 x z x1=0.651 1 + 24.904 x + -0.933 x z \n", + " x2=-2.666 z + 1.000 x y x2=-2.632 z + 0.994 x y \n", + "-------------------------------------------------------------------------------------------\n", + "Finite Difference \n", + " x0=-9.999 x + 9.999 y x0=-9.873 x + 9.907 y \n", + " x1=27.993 x + -0.999 y + -1.000 x z x1=0.633 1 + 24.937 x + -0.933 x z \n", + " x2=-2.666 z + 1.000 x y x2=-0.692 1 + -2.616 z + 0.995 x y \n", + "-------------------------------------------------------------------------------------------\n", + "Smoothed Finite Difference \n", + " x0=-9.999 x + 9.999 y x0=-9.714 x + 9.764 y \n", + " x1=27.992 x + -0.998 y + -1.000 x z x1=26.425 x + -0.533 y + -0.964 x z \n", + " x2=-2.666 z + 1.000 x y x2=-0.907 1 + -2.624 z + 0.998 x y \n", + "-------------------------------------------------------------------------------------------\n", + "Savitzky Golay \n", + " x0=-9.935 x + 9.935 y x0=-9.604 x + 9.651 y \n", + " x1=26.958 x + -0.776 y + -0.972 x z x1=24.677 x + -0.922 x z \n", + " x2=-2.635 z + 0.988 x y x2=-0.829 1 + -2.589 z + 0.986 x y \n", + "-------------------------------------------------------------------------------------------\n", + "Spline \n", + " x0=-10.000 x + 10.000 y x0=-9.935 x + 9.970 y \n", + " x1=28.003 x + -1.001 y + -1.000 x z x1=24.801 x + -0.929 x z \n", + " x2=-2.667 z + 1.000 x y x2=-61.574 1 + 1.062 x + -2.644 y + 0.857 x y\n", + "-------------------------------------------------------------------------------------------\n", + "Trend Filtered \n", + " x0=1.319 1 + -1.013 x + 0.948 y x0=1.357 1 + -0.987 x + 0.927 y \n", + " x1=0.000 x1=0.000 \n", + " x2=-1.109 1 x2=-1.152 1 \n", + "-------------------------------------------------------------------------------------------\n", + "Spectral \n", + " x0=-1.683 1 + -9.076 x + 9.149 y x0=-1.752 1 + -8.919 x + 9.042 y \n", + " x1=28.807 x + -1.369 y + -1.015 x z x1=26.175 x + -0.609 y + -0.954 x z \n", + " x2=86.435 1 + -7.282 z + 1.365 x^2 x2=83.111 1 + 0.519 y + -7.134 z + 1.335 x^2\n", + "-------------------------------------------------------------------------------------------\n", + "Spectral, PySINDy version \n", + " x0=-1.683 1 + -9.076 x + 9.149 y x0=-1.752 1 + -8.919 x + 9.042 y \n", + " x1=28.807 x + -1.369 y + -1.015 x z x1=26.175 x + -0.609 y + -0.954 x z \n", + " x2=86.435 1 + -7.282 z + 1.365 x^2 x2=83.111 1 + 0.519 y + -7.134 z + 1.335 x^2\n", + "-------------------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "print_equations(equations_clean, equations_noisy)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "7d737105", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:14:29.472262Z", + "iopub.status.busy": "2022-07-06T23:14:29.471494Z", + "iopub.status.idle": "2022-07-06T23:14:32.118310Z", + "shell.execute_reply": "2022-07-06T23:14:32.117140Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "feature_names = model.get_feature_names()\n", + "compare_coefficient_plots(\n", + " coefficients_clean,\n", + " coefficients_noisy,\n", + " input_features=input_features,\n", + " feature_names=feature_names,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "7dfa8383", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:14:32.124453Z", + "iopub.status.busy": "2022-07-06T23:14:32.124240Z", + "iopub.status.idle": "2022-07-06T23:15:39.732563Z", + "shell.execute_reply": "2022-07-06T23:15:39.731003Z" + } + }, + "outputs": [], + "source": [ + "import timeit\n", + "\n", + "N_spectral = np.logspace(1, 8, n_spectral, dtype=int)\n", + "spectral_times = np.zeros((n_spectral, 2))\n", + "for i in range(n_spectral):\n", + " # True data\n", + " x = np.linspace(0, 2 * np.pi, N_spectral[i])\n", + " y = np.sin(x)\n", + " y_dot = np.cos(x)\n", + " noise_level = 0.05\n", + " y_noisy = y + noise_level * np.random.randn(len(y))\n", + "\n", + " start = timeit.default_timer()\n", + " spectral1 = ps.SINDyDerivative(kind=\"spectral\")(y_noisy, x)\n", + " stop = timeit.default_timer()\n", + " spectral_times[i, 0] = stop - start\n", + "\n", + " start = timeit.default_timer()\n", + " spectral2 = ps.SpectralDerivative(y_noisy, x)\n", + " stop = timeit.default_timer()\n", + " spectral_times[i, 1] = stop - start" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "3338bd98", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:15:39.738608Z", + "iopub.status.busy": "2022-07-06T23:15:39.738368Z", + "iopub.status.idle": "2022-07-06T23:15:40.225042Z", + "shell.execute_reply": "2022-07-06T23:15:40.223990Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.grid(True)\n", + "plt.semilogy(spectral_times[:, 0], label=\"derivative python package\")\n", + "plt.semilogy(spectral_times[:, 1], label=\"In-house spectral derivative\")\n", + "plt.ylabel(\"Time (s)\")\n", + "plt.xlabel(\"Matrix size in powers of 10\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "69ba7802", + "metadata": { + "execution": { + "iopub.execute_input": "2022-07-06T23:15:40.230194Z", + "iopub.status.busy": "2022-07-06T23:15:40.229983Z", + "iopub.status.idle": "2022-07-06T23:15:40.367220Z", + "shell.execute_reply": "2022-07-06T23:15:40.366431Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Check error improves as order increases\n", + "x = np.linspace(0, 2 * np.pi, 100)\n", + "y = np.sin(x) - x**5\n", + "y_dot = np.cos(x) - 5 * x**4\n", + "err = np.zeros(9)\n", + "for order in range(1, fd_order + 1):\n", + " diff = ps.FiniteDifference(d=1, order=order)\n", + " diff = diff(y, x)\n", + " err[order - 1] = np.sum(np.abs(y_dot - diff))\n", + "plt.figure()\n", + "plt.plot(range(1, 10), err)\n", + "plt.grid(True)\n", + "plt.ylabel(\"Derivative error\")\n", + "plt.xlabel(\"Finite difference order\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all", + "text_representation": { + "extension": ".py", + "format_name": "percent" + } + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/5_differentiation/example.py b/examples/5_differentiation/example.py new file mode 100644 index 00000000..49b9a24c --- /dev/null +++ b/examples/5_differentiation/example.py @@ -0,0 +1,299 @@ +# %% [markdown] +# # Differentiators in PySINDy +# +# This notebook explores the differentiation methods available in PySINDy. Most of the methods are powered by the [derivative](https://pypi.org/project/derivative/) package. While this notebook explores these methods on temporal data, these apply equally well to the computation of spatial derivatives for SINDy for PDE identification (see example Jupyter notebooks 10 and 12, on PDEs and weak forms). +# %% [markdown] +# [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/dynamicslab/pysindy/v1.7?filepath=examples/5_differentiation.ipynb) +# %% +import warnings + +import matplotlib.pyplot as plt +import numpy as np + +import pysindy as ps + +# ignore user warnings +warnings.filterwarnings("ignore", category=UserWarning) + +integrator_keywords = {} +integrator_keywords["rtol"] = 1e-12 +integrator_keywords["method"] = "LSODA" +integrator_keywords["atol"] = 1e-12 + +from utils import ( + plot_kws, + pal, + compare_methods, + print_equations, + compare_coefficient_plots, +) + +if __name__ != "testing": + from example_data import ( + gen_data_sine, + gen_data_step, + gen_data_sho, + gen_data_lorenz, + n_spectral, + fd_order, + ) +else: + from mock_data import ( + gen_data_sine, + gen_data_step, + gen_data_sho, + gen_data_lorenz, + n_spectral, + fd_order, + ) + + +# %% [markdown] +# In the cell below we define all the available differentiators. Note that the different options in `SINDyDerivative` all originate from `derivative`. +# +# * `FiniteDifference` - First order (forward difference) or second order (centered difference) finite difference methods with the ability to drop endpoints. Does *not* assume a uniform time step. Appropriate for smooth data. +# * `finite_difference` - Central finite differences of any order. Assumes a uniform time step. Appropriate for smooth data. +# * `Smoothed Finite Difference` - `FiniteDifference` with a smoother (default is Savitzky Golay) applied to the data before differentiation. Appropriate for noisy data. +# * `savitzky_golay` - Perform a least-squares fit of a polynomial to the data, then compute the derivative of the polynomial. Appropriate for noisy data. +# * `spline` - Fit the data with a spline (of arbitrary order) then perform differentiation on the spline. Appropriate for noisy data. +# * `trend_filtered` - Use total squared variations to fit the data (computes a global derivative that is a piecewise combination of polynomials of a chosen order). Set `order=0` to obtain the total-variational derivative. Appropriate for noisy data +# * `spectral` - Compute the spectral derivative of the data via Fourier Transform. Appropriate for very smooth (i.e. analytic) data. There is an in-house PySINDy version for speed but this is also included in the derivative package. + +# %% +diffs = [ + ("PySINDy Finite Difference", ps.FiniteDifference()), + ("Finite Difference", ps.SINDyDerivative(kind="finite_difference", k=1)), + ("Smoothed Finite Difference", ps.SmoothedFiniteDifference()), + ( + "Savitzky Golay", + ps.SINDyDerivative(kind="savitzky_golay", left=0.5, right=0.5, order=3), + ), + ("Spline", ps.SINDyDerivative(kind="spline", s=1e-2)), + ("Trend Filtered", ps.SINDyDerivative(kind="trend_filtered", order=0, alpha=1e-2)), + ("Spectral", ps.SINDyDerivative(kind="spectral")), + ("Spectral, PySINDy version", ps.SpectralDerivative()), +] + +# %% [markdown] +# ## Compare differentiation methods directly +# First we'll use the methods to numerically approximate derivatives to measurement data directly, without bringing SINDy into the picture. We'll compare the different methods' accuracies when working with clean data ("approx" in the plots) and data with a small amount of white noise ("noisy"). + +# %% +noise_level = 0.01 + +# %% [markdown] +# ### Sine + +# %% +# True data +x, y, y_noisy, y_dot = gen_data_sine(noise_level) +axs = compare_methods(diffs, x, y, y_noisy, y_dot) + +# %% [markdown] +# ### Absolute value + +# %% +# Shrink window for Savitzky Golay method +diffs[3] = ( + "Savitzky Golay", + ps.SINDyDerivative(kind="savitzky_golay", left=0.1, right=0.1, order=3), +) + +x, y, y_dot, y_noisy = gen_data_step(noise_level) + +axs = compare_methods(diffs, x, y, y_noisy, y_dot) + +# %% [markdown] +# ## Compare differentiators when used in PySINDy +# We got some idea of the performance of the differentiation options applied to raw data. Next we'll look at how they work as a single component of the SINDy algorithm. + +# %% [markdown] +# ### Linear oscillator +# $$ \frac{d}{dt} \begin{bmatrix}x \\ y\end{bmatrix} = \begin{bmatrix} -0.1 & 2 \\ -2 & -0.1 \end{bmatrix} \begin{bmatrix}x \\ y\end{bmatrix} $$ + +# %% +noise_level = 0.1 + +# %% +# Generate training data + +dt, t_train, x_train, x_train_noisy = gen_data_sho(noise_level, integrator_keywords) + +# %% +fig, ax = plt.subplots(1, 1, figsize=(5, 5)) + +ax.plot(x_train[:, 0], x_train[:, 1], ".", label="Clean", color=pal[0], **plot_kws) +ax.plot( + x_train_noisy[:, 0], + x_train_noisy[:, 1], + ".", + label="Noisy", + color=pal[1], + **plot_kws +) + +ax.set(title="Training data", xlabel="$x_0$", ylabel="$x_1$") +ax.legend() +fig.show() + +# %% +# Allow Trend Filtered method to work with linear functions +diffs[5] = ( + "Trend Filtered", + ps.SINDyDerivative(kind="trend_filtered", order=1, alpha=1e-2), +) + +equations_clean = {} +equations_noisy = {} +coefficients_clean = {} +coefficients_noisy = {} +input_features = ["x", "y"] +threshold = 0.5 + +for name, method in diffs: + model = ps.SINDy( + differentiation_method=method, + optimizer=ps.STLSQ(threshold=threshold), + t_default=dt, + feature_names=input_features, + ) + + model.fit(x_train, quiet=True) + equations_clean[name] = model.equations() + coefficients_clean[name] = model.coefficients() + + model.fit(x_train_noisy, quiet=True) + equations_noisy[name] = model.equations() + coefficients_noisy[name] = model.coefficients() + +# %% +print_equations(equations_clean, equations_noisy) + +# %% +feature_names = model.get_feature_names() +compare_coefficient_plots( + coefficients_clean, + coefficients_noisy, + input_features=input_features, + feature_names=feature_names, +) + +# %% [markdown] +# ### Lorenz system +# +# $$ \begin{aligned} \dot x &= 10(y-x)\\ \dot y &= x(28 - z) - y \\ \dot z &= xy - \tfrac{8}{3} z, \end{aligned} $$ +# + +# %% +noise_level = 0.5 + +# %% +# Generate measurement data +dt, t_train, x_train, x_train_noisy = gen_data_lorenz(noise_level, integrator_keywords) + +# %% +fig = plt.figure(figsize=(8, 8)) +ax = fig.add_subplot(1, 1, 1, projection="3d") +ax.plot( + x_train[:, 0], x_train[:, 1], x_train[:, 2], color=pal[0], label="Clean", **plot_kws +) + +ax.plot( + x_train_noisy[:, 0], + x_train_noisy[:, 1], + x_train_noisy[:, 2], + ".", + color=pal[1], + label="Noisy", + alpha=0.3, +) +ax.set(title="Training data", xlabel="$x$", ylabel="$y$", zlabel="$z$") +ax.legend() +fig.show() + +# %% +equations_clean = {} +equations_noisy = {} +coefficients_clean = {} +coefficients_noisy = {} +input_features = ["x", "y", "z"] + +threshold = 0.5 + +for name, method in diffs: + model = ps.SINDy( + differentiation_method=method, + optimizer=ps.STLSQ(threshold=threshold), + t_default=dt, + feature_names=input_features, + ) + + model.fit(x_train, quiet=True) + equations_clean[name] = model.equations() + coefficients_clean[name] = model.coefficients() + + model.fit(x_train_noisy, quiet=True) + equations_noisy[name] = model.equations() + coefficients_noisy[name] = model.coefficients() + +# %% +print_equations(equations_clean, equations_noisy) + +# %% +feature_names = model.get_feature_names() +compare_coefficient_plots( + coefficients_clean, + coefficients_noisy, + input_features=input_features, + feature_names=feature_names, +) + +# %% +import timeit + +N_spectral = np.logspace(1, 8, n_spectral, dtype=int) +spectral_times = np.zeros((n_spectral, 2)) +for i in range(n_spectral): + # True data + x = np.linspace(0, 2 * np.pi, N_spectral[i]) + y = np.sin(x) + y_dot = np.cos(x) + noise_level = 0.05 + y_noisy = y + noise_level * np.random.randn(len(y)) + + start = timeit.default_timer() + spectral1 = ps.SINDyDerivative(kind="spectral")(y_noisy, x) + stop = timeit.default_timer() + spectral_times[i, 0] = stop - start + + start = timeit.default_timer() + spectral2 = ps.SpectralDerivative(y_noisy, x) + stop = timeit.default_timer() + spectral_times[i, 1] = stop - start + +# %% +plt.figure() +plt.grid(True) +plt.semilogy(spectral_times[:, 0], label="derivative python package") +plt.semilogy(spectral_times[:, 1], label="In-house spectral derivative") +plt.ylabel("Time (s)") +plt.xlabel("Matrix size in powers of 10") +plt.legend() +plt.show() + +# %% +# Check error improves as order increases +x = np.linspace(0, 2 * np.pi, 100) +y = np.sin(x) - x**5 +y_dot = np.cos(x) - 5 * x**4 +err = np.zeros(9) +for order in range(1, fd_order + 1): + diff = ps.FiniteDifference(d=1, order=order) + diff = diff(y, x) + err[order - 1] = np.sum(np.abs(y_dot - diff)) +plt.figure() +plt.plot(range(1, 10), err) +plt.grid(True) +plt.ylabel("Derivative error") +plt.xlabel("Finite difference order") +plt.show() diff --git a/examples/5_differentiation/example_data.py b/examples/5_differentiation/example_data.py new file mode 100644 index 00000000..c15f41fe --- /dev/null +++ b/examples/5_differentiation/example_data.py @@ -0,0 +1,58 @@ +import numpy as np +from scipy.integrate import solve_ivp + +from pysindy.utils import linear_damped_SHO +from pysindy.utils import lorenz + +n_spectral = 8 +fd_order = 9 + + +def gen_data_sine(noise_level: float): + # True data + x = np.linspace(0, 2 * np.pi, 100) + y = np.sin(x) + y_dot = np.cos(x) + + # Add noise + seed = 111 + np.random.seed(seed) + y_noisy = y + noise_level * np.random.randn(len(y)) + return x, y, y_noisy, y_dot + + +def gen_data_step(noise_level: float): + # True data + x = np.linspace(-1, 1, 100) + y = np.abs(x) + y_dot = np.sign(x) + + # Add noise + seed = 111 + np.random.seed(seed) + y_noisy = y + noise_level * np.random.randn(len(y)) + return x, y, y_dot, y_noisy + + +def gen_data_sho(noise_level: float, integrator_keywords: dict): + dt = 0.01 + t_train = np.arange(0, 10, dt) + t_train_span = (t_train[0], t_train[-1]) + x0_train = [2, 0] + x_train = solve_ivp( + linear_damped_SHO, t_train_span, x0_train, t_eval=t_train, **integrator_keywords + ).y.T + x_train_noisy = x_train + noise_level * np.random.randn(*x_train.shape) + return dt, t_train, x_train, x_train_noisy + + +def gen_data_lorenz(noise_level: float, integrator_keywords: dict): + dt = 0.002 + t_train = np.arange(0, 10, dt) + t_train_span = (t_train[0], t_train[-1]) + x0_train = [-8, 8, 27] + x_train = solve_ivp( + lorenz, t_train_span, x0_train, t_eval=t_train, **integrator_keywords + ).y.T + x_train_noisy = x_train + noise_level * np.random.randn(*x_train.shape) + return dt, t_train, x_train, x_train_noisy diff --git a/examples/5_differentiation/mock_data.py b/examples/5_differentiation/mock_data.py new file mode 100644 index 00000000..09543853 --- /dev/null +++ b/examples/5_differentiation/mock_data.py @@ -0,0 +1,58 @@ +import numpy as np +from scipy.integrate import solve_ivp + +from pysindy.utils import linear_damped_SHO +from pysindy.utils import lorenz + +n_spectral = 1 +fd_order = 1 + + +def gen_data_sine(noise_level: float): + # True data + x = np.linspace(0, 2 * np.pi / 15, 15) + y = np.sin(x) + y_dot = np.cos(x) + + # Add noise + seed = 111 + np.random.seed(seed) + y_noisy = y + noise_level * np.random.randn(len(y)) + return x, y, y_noisy, y_dot + + +def gen_data_step(noise_level: float): + # True data + x = np.linspace(-1, 1, 20) + y = np.abs(x) + y_dot = np.sign(x) + + # Add noise + seed = 111 + np.random.seed(seed) + y_noisy = y + noise_level * np.random.randn(len(y)) + return x, y, y_dot, y_noisy + + +def gen_data_sho(noise_level: float, integrator_keywords: dict): + dt = 0.01 + t_train = np.arange(0, 0.5, dt) + t_train_span = (t_train[0], t_train[-1]) + x0_train = [2, 0] + x_train = solve_ivp( + linear_damped_SHO, t_train_span, x0_train, t_eval=t_train, **integrator_keywords + ).y.T + x_train_noisy = x_train + noise_level * np.random.randn(*x_train.shape) + return dt, t_train, x_train, x_train_noisy + + +def gen_data_lorenz(noise_level: float, integrator_keywords: dict): + dt = 0.002 + t_train = np.arange(0, 0.5, dt) + t_train_span = (t_train[0], t_train[-1]) + x0_train = [-8, 8, 27] + x_train = solve_ivp( + lorenz, t_train_span, x0_train, t_eval=t_train, **integrator_keywords + ).y.T + x_train_noisy = x_train + noise_level * np.random.randn(*x_train.shape) + return dt, t_train, x_train, x_train_noisy diff --git a/examples/5_differentiation/utils.py b/examples/5_differentiation/utils.py new file mode 100644 index 00000000..2c1fe173 --- /dev/null +++ b/examples/5_differentiation/utils.py @@ -0,0 +1,118 @@ +import matplotlib.pyplot as plt +import numpy as np +import seaborn as sns + +pal = sns.color_palette("Set1") +plot_kws = dict(alpha=0.7, linewidth=3) + + +def compare_methods(diffs, x, y, y_noisy, y_dot): + n_methods = len(diffs) + n_rows = (n_methods // 3) + int(n_methods % 3 > 0) + fig, axs = plt.subplots(n_rows, 3, figsize=(15, 3 * n_rows), sharex=True) + + for (name, method), ax in zip(diffs, axs.flatten()): + ax.plot(x, y_dot, label="Exact", color=pal[0], **plot_kws) + ax.plot(x, method(y, x), ":", label="Approx.", color="black", **plot_kws) + ax.plot(x, method(y_noisy, x), label="Noisy", color=pal[1], **plot_kws) + ax.set(title=name) + + axs[0, 0].legend() + fig.show() + + return axs + + +def print_equations(equations_clean, equations_noisy): + print(f"{'':<30} {'Noiseless':<40} {'Noisy':<40}") + + for name in equations_clean.keys(): + print(f"{name:<30} {'':<40} {'':<40}") + + for k, (eq1, eq2) in enumerate( + zip(equations_clean[name], equations_noisy[name]) + ): + print( + f"{'':<30} {'x' + str(k) + '=' + str(eq1):<40} {'x' + str(k) + '=' + str(eq2):<40}" + ) + + print( + "-------------------------------------------------------------------------------------------" + ) + + +def plot_coefficients( + coefficients, input_features=None, feature_names=None, ax=None, **heatmap_kws +): + if input_features is None: + input_features = [r"$\dot x_" + f"{k}$" for k in range(coefficients.shape[0])] + else: + input_features = [r"$\dot " + f"{fi}$" for fi in input_features] + + if feature_names is None: + feature_names = [f"f{k}" for k in range(coefficients.shape[1])] + + with sns.axes_style(style="white", rc={"axes.facecolor": (0, 0, 0, 0)}): + if ax is None: + fig, ax = plt.subplots(1, 1) + + heatmap_args = { + "xticklabels": input_features, + "yticklabels": feature_names, + "center": 0.0, + "cmap": sns.color_palette("vlag", n_colors=20, as_cmap=True), + "ax": ax, + "linewidths": 0.1, + "linecolor": "whitesmoke", + } + heatmap_args.update(**heatmap_kws) + + sns.heatmap(coefficients.T, **heatmap_args) + + ax.tick_params(axis="y", rotation=0) + + return ax + + +def compare_coefficient_plots( + coefficients_clean, coefficients_noisy, input_features=None, feature_names=None +): + n_cols = len(coefficients_clean) + + def signed_sqrt(x): + return np.sign(x) * np.sqrt(np.abs(x)) + + with sns.axes_style(style="white", rc={"axes.facecolor": (0, 0, 0, 0)}): + fig, axs = plt.subplots( + 2, n_cols, figsize=(1.9 * n_cols, 8), sharey=True, sharex=True + ) + + max_clean = max(np.max(np.abs(c)) for c in coefficients_clean.values()) + max_noisy = max(np.max(np.abs(c)) for c in coefficients_noisy.values()) + max_mag = np.sqrt(max(max_clean, max_noisy)) + + for k, name in enumerate(coefficients_clean.keys()): + plot_coefficients( + signed_sqrt(coefficients_clean[name]), + input_features=input_features, + feature_names=feature_names, + ax=axs[0, k], + cbar=False, + vmax=max_mag, + vmin=-max_mag, + ) + + plot_coefficients( + signed_sqrt(coefficients_clean[name]), + input_features=input_features, + feature_names=feature_names, + ax=axs[1, k], + cbar=False, + ) + + axs[0, k].set_title(name, rotation=45) + + axs[0, 0].set_ylabel("Noiseless", labelpad=10) + axs[1, 0].set_ylabel("Noisy", labelpad=10) + + fig.tight_layout() From 68cd3d1c13855df6cc0929b0c9bddbb695de5837 Mon Sep 17 00:00:00 2001 From: Jake Stevens-Haas Date: Wed, 6 Jul 2022 16:44:36 -0700 Subject: [PATCH 10/12] CI: remove full notebook tests cause they take too long --- .github/workflows/main.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 903fc916..4294428e 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -37,7 +37,7 @@ jobs: pip install sympy # needed for notebook 9, but not required for pysindy - name: Test with pytest run: | - pytest test --cov=pysindy --cov-report=xml -m "slow or not slow" + pytest test --cov=pysindy --cov-report=xml - name: Upload coverage to Codecov uses: codecov/codecov-action@v1 with: From 3645b558bab1b588ce14cf7bf40de44f0dfc827a Mon Sep 17 00:00:00 2001 From: Jake Stevens-Haas Date: Wed, 6 Jul 2022 17:00:18 -0700 Subject: [PATCH 11/12] TST: compatibility with coverage --- test/test_notebooks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_notebooks.py b/test/test_notebooks.py index 2dad25fd..5e217b70 100644 --- a/test/test_notebooks.py +++ b/test/test_notebooks.py @@ -47,7 +47,7 @@ def _cwd(directory): def test_notebook_script(directory: Path): # Run in native directory with modified sys.path for imports to work with _cwd(notebook_dir / directory): - runpy.run_path(notebook_dir / directory / "example.py", run_name="testing") + runpy.run_path(str(notebook_dir / directory / "example.py"), run_name="testing") @pytest.mark.parametrize("filename", notebooks) From 285b02cae872734d4c83d7763672955a1c412cb5 Mon Sep 17 00:00:00 2001 From: Jake Stevens-Haas Date: Wed, 6 Jul 2022 17:48:26 -0700 Subject: [PATCH 12/12] BUG: Tear down common import names in notebook tests --- test/test_notebooks.py | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/test/test_notebooks.py b/test/test_notebooks.py index 5e217b70..0f573658 100644 --- a/test/test_notebooks.py +++ b/test/test_notebooks.py @@ -43,8 +43,28 @@ def _cwd(directory): os.chdir(cwd) +@pytest.fixture +def purge_notebook_modules(): + """Remove notebook modules from sys.modules after test. + + Because these modules share common names in each notebook and + module names have a system-wide scope, import machinery will not + import new modules for successive notebooks unless old modules of + same name are removed from sys.modules. + + This might be better served by fixing imports in notebooks using + importlib. + """ + SENTINEL = object() + sys.modules.pop("utils", SENTINEL) + sys.modules.pop("mock_data", SENTINEL) + yield + sys.modules.pop("utils", SENTINEL) + sys.modules.pop("mock_data", SENTINEL) + + @pytest.mark.parametrize("directory", notebook_scripts) -def test_notebook_script(directory: Path): +def test_notebook_script(directory: Path, purge_notebook_modules): # Run in native directory with modified sys.path for imports to work with _cwd(notebook_dir / directory): runpy.run_path(str(notebook_dir / directory / "example.py"), run_name="testing")