From 9ca0570646676562f59c13a664a3b80a8157b88d Mon Sep 17 00:00:00 2001
From: Jake Stevens-Haas <37048747+Jacob-Stevens-Haas@users.noreply.github.com>
Date: Tue, 8 Oct 2024 09:08:32 -0700
Subject: [PATCH 1/9] DOC: Begin building directive for offloading examples
---
docs/conf.py | 81 ++++++++++++++++++++++++++++++++++++++++++++-
examples/README.rst | 24 +++++---------
pyproject.toml | 3 +-
3 files changed, 90 insertions(+), 18 deletions(-)
diff --git a/docs/conf.py b/docs/conf.py
index ad14183e..1d5baf53 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -1,6 +1,16 @@
import importlib
+import os
+import re
import shutil
from pathlib import Path
+from typing import TypeVar
+
+import requests
+from docutils import nodes
+from docutils.statemachine import StringList
+from sphinx.application import Sphinx
+from sphinx.directives.other import TocTree
+from sphinx.util.docutils import SphinxDirective
author = "dynamicslab"
project = "pysindy" # package name
@@ -105,7 +115,7 @@ def patched_parse(self):
GoogleDocstring._parse = patched_parse
-def setup(app):
+def setup(app: Sphinx):
"""Our sphinx extension for copying from examples/ to docs/examples
Since nbsphinx does not handle glob/regex paths, we need to
@@ -135,3 +145,72 @@ def setup(app):
)
if (here / "static/custom.css").exists():
app.add_css_file("custom.css")
+
+ app.add_directive("pysindy-example", PysindyExample)
+
+
+class PysindyExample(SphinxDirective):
+ required_arguments = 0
+ optional_arguments = 0
+ final_argument_whitespace = True
+ option_spec = {"repo": str, "ref": str, "title": str}
+ has_content = True
+
+ def run(self) -> list[nodes.Node]:
+ repo = self.options.get("repo")
+ ref = self.options.get("ref")
+ base = f"https://raw.githubusercontent.com/{repo}/{ref}/docs/build/"
+ example_node = nodes.subtitle(text=self.options.get("title"))
+ content_node = nodes.paragraph(text="\n".join(self.content))
+ documents = fetch_notebook_list(base)
+ local_docs = [(name, copy_html(base, url, repo)) for name, url in documents]
+ toc_items = [f"{name} <{url}>" for name, url in local_docs]
+ toc_nodes = TocTree(
+ name="PysindyExample",
+ options={},
+ arguments=[],
+ content=StringList(initlist=toc_items),
+ lineno=self.lineno,
+ block_text="",
+ content_offset=0,
+ state=self.state,
+ state_machine=self.state_machine,
+ ).run()
+ return [example_node, content_node, *toc_nodes]
+
+
+def fetch_notebook_list(base: str) -> list[tuple[str, str]]:
+ """Gets the list of example notebooks from a repo's index.html
+
+ Each entry is a tuple of the title name of a link and the address
+ """
+
+ index = requests.get(base + "index.html")
+ if index.status_code != 200:
+ raise RuntimeError("Unable to locate external example directory")
+ text = str(index.content, encoding="utf-8")
+ start = '
'
+ end = "\n"
+ matchstr = start + "(.*)" + mid + "(.*)" + end
+ T = TypeVar("T")
+
+ def deduplicate(mylist: list[T]) -> list[T]:
+ return list(set(mylist))
+
+ rellinks: list[str] = deduplicate(re.findall(matchstr, text))
+ return [(name, address) for address, name in rellinks]
+
+
+def copy_html(base: str, location: str, repo: str) -> str:
+ """Create a local copy of external file, returning relative reference"""
+ example_dir = Path(__file__).parent / "examples"
+ repo_root = example_dir / repo
+ repo_root.mkdir(parents=True, exist_ok=True)
+ page = requests.get(base + location)
+ if page.status_code != 200:
+ raise RuntimeError("Unable to locate external example notebook")
+ filename = repo_root / location.rsplit("/", 1)[1]
+ with open(filename, "wb") as f:
+ f.write(page.content)
+ return os.path.relpath(filename, start=example_dir)
diff --git a/examples/README.rst b/examples/README.rst
index e8791740..52ab5e25 100644
--- a/examples/README.rst
+++ b/examples/README.rst
@@ -1,7 +1,14 @@
PySINDy Examples
================
-This directory showcases the following examples of PySINDy in action.
+
+.. pysindy-example::
+ :repo: dynamicslab/pysindy-example
+ :ref: 673d8b3
+ :title: An Example
+
+ This directory showcases the following examples of PySINDy in action.
+
`Feature overview <./1_feature_overview/example.ipynb>`_
-----------------------------------------------------------------------------------------------------------
@@ -24,23 +31,8 @@ We recommend that people new to SINDy start here. We give a gentle introduction
./2_introduction_to_sindy/example
-`Original paper <./3_original_paper/example.ipynb>`_
--------------------------------------------------------------------------------------------------------
-This notebook uses PySINDy to reproduce the examples in the `original SINDy paper `_. Namely, it applies PySINDy to the following problems:
-
-* Linear 2D ODE
-* Cubic 2D ODE
-* Linear 3D ODE
-* Lorenz system
-* Fluid wake behind a cylinder
-* Logistic map
-* Hopf system
-.. toctree::
- :hidden:
- :maxdepth: 1
- ./3_original_paper/example
`Scikit-learn compatibility <./4_scikit_learn_compatibility/example.ipynb>`_
-------------------------------------------------------------------------------------------------------------------------------
diff --git a/pyproject.toml b/pyproject.toml
index 8946355d..d6a6de6c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -48,11 +48,12 @@ dev = [
]
docs = [
"ipython",
+ "nbsphinx",
"pandoc",
+ "requests",
"sphinx-rtd-theme",
"sphinx==7.1.2",
"sphinxcontrib-apidoc",
- "nbsphinx"
]
miosr = [
"gurobipy>=9.5.1,!=10.0.0"
From 04721a30793cda8b4969b64f3ffe5e4d1485c471 Mon Sep 17 00:00:00 2001
From: Jake Stevens-Haas <37048747+Jacob-Stevens-Haas@users.noreply.github.com>
Date: Mon, 4 Nov 2024 19:16:51 -0800
Subject: [PATCH 2/9] DOC: Attempt to copy example html to _static
---
docs/conf.py | 40 ++++++++++++++++++++++++++++------------
examples/README.rst | 3 +--
examples/external.yml | 3 +++
3 files changed, 32 insertions(+), 14 deletions(-)
create mode 100644 examples/external.yml
diff --git a/docs/conf.py b/docs/conf.py
index 1d5baf53..49eb3be6 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -6,6 +6,7 @@
from typing import TypeVar
import requests
+import yaml
from docutils import nodes
from docutils.statemachine import StringList
from sphinx.application import Sphinx
@@ -52,8 +53,7 @@
here = Path(__file__).parent.resolve()
-if (here / "static/custom.css").exists():
- html_static_path = ["static"]
+html_static_path = ["_static"]
exclude_patterns = ["build", "_build", "Youtube"]
# pygments_style = "sphinx"
@@ -146,25 +146,41 @@ def setup(app: Sphinx):
if (here / "static/custom.css").exists():
app.add_css_file("custom.css")
+ _grab_external_examples(example_source, doc_examples)
app.add_directive("pysindy-example", PysindyExample)
+EXTERNAL_EXAMPLES: dict[str, dict[str, os.PathLike]] = {}
+
+
+def _grab_external_examples(example_source: Path, doc_examples: Path):
+ ext_config = example_source / "external.yml"
+ with open(ext_config) as f:
+ ext_examples = yaml.safe_load(f)
+ for example in ext_examples:
+ repo = example["repo"]
+ ref = example["ref"]
+ base = f"https://raw.githubusercontent.com/{repo}/{ref}/docs/build/"
+ documents = fetch_notebook_list(base)
+ file_map = {}
+ for name, url in documents:
+ file_map[name] = copy_html(base, url, repo)
+ EXTERNAL_EXAMPLES[example["key"]] = file_map
+
+
class PysindyExample(SphinxDirective):
required_arguments = 0
optional_arguments = 0
- final_argument_whitespace = True
- option_spec = {"repo": str, "ref": str, "title": str}
+ option_spec = {"key": str, "title": str}
has_content = True
def run(self) -> list[nodes.Node]:
- repo = self.options.get("repo")
- ref = self.options.get("ref")
- base = f"https://raw.githubusercontent.com/{repo}/{ref}/docs/build/"
+ key = self.options["key"]
example_node = nodes.subtitle(text=self.options.get("title"))
content_node = nodes.paragraph(text="\n".join(self.content))
- documents = fetch_notebook_list(base)
- local_docs = [(name, copy_html(base, url, repo)) for name, url in documents]
- toc_items = [f"{name} <{url}>" for name, url in local_docs]
+ toc_items = [
+ f"{name} <{relpath}>" for name, relpath in EXTERNAL_EXAMPLES[key].items()
+ ]
toc_nodes = TocTree(
name="PysindyExample",
options={},
@@ -172,7 +188,7 @@ def run(self) -> list[nodes.Node]:
content=StringList(initlist=toc_items),
lineno=self.lineno,
block_text="",
- content_offset=0,
+ content_offset=self.content_offset,
state=self.state,
state_machine=self.state_machine,
).run()
@@ -205,7 +221,7 @@ def deduplicate(mylist: list[T]) -> list[T]:
def copy_html(base: str, location: str, repo: str) -> str:
"""Create a local copy of external file, returning relative reference"""
example_dir = Path(__file__).parent / "examples"
- repo_root = example_dir / repo
+ repo_root = Path(__file__).parent / "_static" / repo
repo_root.mkdir(parents=True, exist_ok=True)
page = requests.get(base + location)
if page.status_code != 200:
diff --git a/examples/README.rst b/examples/README.rst
index 52ab5e25..63584650 100644
--- a/examples/README.rst
+++ b/examples/README.rst
@@ -3,8 +3,7 @@ PySINDy Examples
.. pysindy-example::
- :repo: dynamicslab/pysindy-example
- :ref: 673d8b3
+ :key: sample
:title: An Example
This directory showcases the following examples of PySINDy in action.
diff --git a/examples/external.yml b/examples/external.yml
new file mode 100644
index 00000000..11420163
--- /dev/null
+++ b/examples/external.yml
@@ -0,0 +1,3 @@
+- key: sample
+ repo: "dynamicslab/pysindy-example"
+ ref: 673d8b3
From 64e7a026332123ff7c6e3f36a7dbed14f5fbc6da Mon Sep 17 00:00:00 2001
From: Jake Stevens-Haas <37048747+Jacob-Stevens-Haas@users.noreply.github.com>
Date: Tue, 5 Nov 2024 19:00:49 -0800
Subject: [PATCH 3/9] DOC: Abandon attempts at copying HTML; instead, copy
external nb to build
This takes a bit more work, which is less desirable, but at least the build
completes!
Build successful!
---
docs/conf.py | 56 ++++++++++++++++++++++---------------------
examples/external.yml | 8 ++++---
2 files changed, 34 insertions(+), 30 deletions(-)
diff --git a/docs/conf.py b/docs/conf.py
index 49eb3be6..6cdda1ab 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -150,7 +150,7 @@ def setup(app: Sphinx):
app.add_directive("pysindy-example", PysindyExample)
-EXTERNAL_EXAMPLES: dict[str, dict[str, os.PathLike]] = {}
+EXTERNAL_EXAMPLES: dict[str, list[tuple[str, str]]] = {}
def _grab_external_examples(example_source: Path, doc_examples: Path):
@@ -158,14 +158,16 @@ def _grab_external_examples(example_source: Path, doc_examples: Path):
with open(ext_config) as f:
ext_examples = yaml.safe_load(f)
for example in ext_examples:
- repo = example["repo"]
- ref = example["ref"]
- base = f"https://raw.githubusercontent.com/{repo}/{ref}/docs/build/"
- documents = fetch_notebook_list(base)
- file_map = {}
- for name, url in documents:
- file_map[name] = copy_html(base, url, repo)
- EXTERNAL_EXAMPLES[example["key"]] = file_map
+ ex_name: str = example["name"]
+ user: str = example["user"]
+ repo: str = example["repo"]
+ ref: str = example["ref"]
+ dir: str = example["dir"]
+ base = f"https://raw.githubusercontent.com/{user}/{repo}/{ref}/{dir}/"
+ notebooks = fetch_notebook_list(base)
+ base = f"https://raw.githubusercontent.com/{user}/{repo}/{ref}/"
+ local_nbs = [(name, copy_nb(base, pth, repo)) for name, pth in notebooks]
+ EXTERNAL_EXAMPLES[ex_name] = local_nbs
class PysindyExample(SphinxDirective):
@@ -178,9 +180,13 @@ def run(self) -> list[nodes.Node]:
key = self.options["key"]
example_node = nodes.subtitle(text=self.options.get("title"))
content_node = nodes.paragraph(text="\n".join(self.content))
- toc_items = [
- f"{name} <{relpath}>" for name, relpath in EXTERNAL_EXAMPLES[key].items()
- ]
+ toc_items = []
+ for name, relpath in EXTERNAL_EXAMPLES[key]:
+ if name:
+ toc_str = f"{name} <{relpath}>"
+ if not name:
+ toc_str = relpath
+ toc_items.append(toc_str)
toc_nodes = TocTree(
name="PysindyExample",
options={},
@@ -200,33 +206,29 @@ def fetch_notebook_list(base: str) -> list[tuple[str, str]]:
Each entry is a tuple of the title name of a link and the address
"""
-
- index = requests.get(base + "index.html")
+ index = requests.get(base + "index.rst")
if index.status_code != 200:
raise RuntimeError("Unable to locate external example directory")
text = str(index.content, encoding="utf-8")
- start = ''
- end = "\n"
- matchstr = start + "(.*)" + mid + "(.*)" + end
+ link_line = r"^\s+(.*)[^\S\r\n]+(\S+.ipynb)"
T = TypeVar("T")
def deduplicate(mylist: list[T]) -> list[T]:
return list(set(mylist))
- rellinks: list[str] = deduplicate(re.findall(matchstr, text))
- return [(name, address) for address, name in rellinks]
+ rellinks = deduplicate(re.findall(link_line, text, flags=re.MULTILINE))
+ return rellinks
-def copy_html(base: str, location: str, repo: str) -> str:
- """Create a local copy of external file, returning relative reference"""
+def copy_nb(base: str, relpath: str, repo: str) -> str:
+ """Create a local copy of external file, modifying relative reference"""
example_dir = Path(__file__).parent / "examples"
- repo_root = Path(__file__).parent / "_static" / repo
- repo_root.mkdir(parents=True, exist_ok=True)
- page = requests.get(base + location)
+ repo_local_dir = example_dir / repo
+ repo_local_dir.mkdir(exist_ok=True)
+ page = requests.get(base + relpath)
if page.status_code != 200:
- raise RuntimeError("Unable to locate external example notebook")
- filename = repo_root / location.rsplit("/", 1)[1]
+ raise RuntimeError(f"Unable to locate external notebook at {base + relpath}")
+ filename = repo_local_dir / relpath.rsplit("/", 1)[1]
with open(filename, "wb") as f:
f.write(page.content)
return os.path.relpath(filename, start=example_dir)
diff --git a/examples/external.yml b/examples/external.yml
index 11420163..abafae0f 100644
--- a/examples/external.yml
+++ b/examples/external.yml
@@ -1,3 +1,5 @@
-- key: sample
- repo: "dynamicslab/pysindy-example"
- ref: 673d8b3
+- name: "sample"
+ user: "dynamicslab"
+ repo: "pysindy-example"
+ ref: "673d8b3"
+ dir: "examples"
From 15b1e2d10402663591d42712e5cd40d4304016ff Mon Sep 17 00:00:00 2001
From: Jake Stevens-Haas <37048747+Jacob-Stevens-Haas@users.noreply.github.com>
Date: Wed, 6 Nov 2024 14:56:39 -0800
Subject: [PATCH 4/9] DOC: Improve look of pysindy-example directives
---
docs/conf.py | 13 +++++++++++--
examples/README.rst | 7 ++++---
2 files changed, 15 insertions(+), 5 deletions(-)
diff --git a/docs/conf.py b/docs/conf.py
index 6cdda1ab..5fe3250e 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -178,7 +178,12 @@ class PysindyExample(SphinxDirective):
def run(self) -> list[nodes.Node]:
key = self.options["key"]
- example_node = nodes.subtitle(text=self.options.get("title"))
+ heading_text: str = self.options.get("title")
+ normalized_text = re.sub(r"\s", "_", heading_text)
+ tgt_node = nodes.target(refid=normalized_text)
+ title_node = nodes.title()
+ title_text = nodes.Text(heading_text)
+ title_node += [title_text, tgt_node]
content_node = nodes.paragraph(text="\n".join(self.content))
toc_items = []
for name, relpath in EXTERNAL_EXAMPLES[key]:
@@ -198,7 +203,11 @@ def run(self) -> list[nodes.Node]:
state=self.state,
state_machine=self.state_machine,
).run()
- return [example_node, content_node, *toc_nodes]
+ section_node = nodes.section(ids=[heading_text], names=[heading_text])
+ section_node += [title_node, content_node, *toc_nodes]
+ # test_ref = nodes.reference(name="boo", refuri="normalized_text")
+ # section_node += test_ref
+ return [section_node]
def fetch_notebook_list(base: str) -> list[tuple[str, str]]:
diff --git a/examples/README.rst b/examples/README.rst
index 63584650..e9017000 100644
--- a/examples/README.rst
+++ b/examples/README.rst
@@ -1,15 +1,16 @@
PySINDy Examples
================
+This directory showcases examples of PySINDy in action.
.. pysindy-example::
:key: sample
- :title: An Example
+ :title: Template
- This directory showcases the following examples of PySINDy in action.
+ This repository is a sample of how to build external documentation examples
-`Feature overview <./1_feature_overview/example.ipynb>`_
+Feature overview
-----------------------------------------------------------------------------------------------------------
This notebook gives an almost exhaustive overview of the different features available in PySINDy. It's a good reference for how to set various options and work with different types of datasets.
From 841092f0e6a0f458a5235e1b101113b089937910 Mon Sep 17 00:00:00 2001
From: Jake Stevens-Haas <37048747+Jacob-Stevens-Haas@users.noreply.github.com>
Date: Wed, 6 Nov 2024 19:22:05 -0800
Subject: [PATCH 5/9] DOC: Allow additional RST and linking to source repo in
custom directive
---
docs/conf.py | 38 +-
examples/3_original_paper.ipynb | 1365 ------------------------
examples/README.rst | 27 +-
examples/data/PODcoefficients.mat | Bin 1150576 -> 0 bytes
examples/data/PODcoefficients_run1.mat | Bin 412493 -> 0 bytes
examples/external.yml | 6 +-
pyproject.toml | 2 +-
7 files changed, 49 insertions(+), 1389 deletions(-)
delete mode 100644 examples/3_original_paper.ipynb
delete mode 100644 examples/data/PODcoefficients.mat
delete mode 100644 examples/data/PODcoefficients_run1.mat
diff --git a/docs/conf.py b/docs/conf.py
index 5fe3250e..f727f320 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -146,23 +146,28 @@ def setup(app: Sphinx):
if (here / "static/custom.css").exists():
app.add_css_file("custom.css")
- _grab_external_examples(example_source, doc_examples)
+ _grab_external_examples(example_source)
app.add_directive("pysindy-example", PysindyExample)
EXTERNAL_EXAMPLES: dict[str, list[tuple[str, str]]] = {}
-def _grab_external_examples(example_source: Path, doc_examples: Path):
+def _load_ext_config(example_source: Path) -> list[dict[str, str]]:
ext_config = example_source / "external.yml"
with open(ext_config) as f:
ext_examples = yaml.safe_load(f)
+ return ext_examples
+
+
+def _grab_external_examples(example_source: Path):
+ ext_examples = _load_ext_config(example_source)
for example in ext_examples:
- ex_name: str = example["name"]
- user: str = example["user"]
- repo: str = example["repo"]
- ref: str = example["ref"]
- dir: str = example["dir"]
+ ex_name = example["name"]
+ user = example["user"]
+ repo = example["repo"]
+ ref = example["ref"]
+ dir = example["dir"]
base = f"https://raw.githubusercontent.com/{user}/{repo}/{ref}/{dir}/"
notebooks = fetch_notebook_list(base)
base = f"https://raw.githubusercontent.com/{user}/{repo}/{ref}/"
@@ -178,13 +183,24 @@ class PysindyExample(SphinxDirective):
def run(self) -> list[nodes.Node]:
key = self.options["key"]
+ example_config = _load_ext_config((here / "../examples").resolve())
+ try:
+ this_example = [ex for ex in example_config if ex["name"] == key][0]
+ except IndexError:
+ RuntimeError("Unknown configuration key for external example")
heading_text: str = self.options.get("title")
+ base_repo = f"https://github.com/{this_example['user']}/{this_example['repo']}"
+ repo_ref = nodes.reference(name="Source repo", refuri=base_repo)
+ ref_text = nodes.Text("Source repo")
+ repo_ref += ref_text
+ repo_par = nodes.paragraph()
+ repo_par += repo_ref
normalized_text = re.sub(r"\s", "_", heading_text)
tgt_node = nodes.target(refid=normalized_text)
title_node = nodes.title()
title_text = nodes.Text(heading_text)
title_node += [title_text, tgt_node]
- content_node = nodes.paragraph(text="\n".join(self.content))
+ content_nodes = self.parse_content_to_nodes()
toc_items = []
for name, relpath in EXTERNAL_EXAMPLES[key]:
if name:
@@ -194,7 +210,7 @@ def run(self) -> list[nodes.Node]:
toc_items.append(toc_str)
toc_nodes = TocTree(
name="PysindyExample",
- options={},
+ options={"maxdepth": 1},
arguments=[],
content=StringList(initlist=toc_items),
lineno=self.lineno,
@@ -204,9 +220,7 @@ def run(self) -> list[nodes.Node]:
state_machine=self.state_machine,
).run()
section_node = nodes.section(ids=[heading_text], names=[heading_text])
- section_node += [title_node, content_node, *toc_nodes]
- # test_ref = nodes.reference(name="boo", refuri="normalized_text")
- # section_node += test_ref
+ section_node += [title_node, *content_nodes, *toc_nodes, repo_par]
return [section_node]
diff --git a/examples/3_original_paper.ipynb b/examples/3_original_paper.ipynb
deleted file mode 100644
index d1e6922a..00000000
--- a/examples/3_original_paper.ipynb
+++ /dev/null
@@ -1,1365 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Original Paper: Sparse Identification of Nonlinear Dynamical systems (SINDy)\n",
- "\n",
- "This notebook uses PySINDy to reproduce the example systems from the paper \"[Discovering governing equations from data: Sparse identification of nonlinear dynamical systems](https://www.pnas.org/content/113/15/3932)\". We provide some mathematical background regarding each example in this notebook and suggest looking to the original paper for further details."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/dynamicslab/pysindy/v1.7.3?filepath=examples/3_original_paper.ipynb)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2020-04-03T00:38:14.539346Z",
- "start_time": "2020-04-03T00:38:13.386464Z"
- }
- },
- "outputs": [],
- "source": [
- "import matplotlib.pyplot as plt\n",
- "from mpl_toolkits.mplot3d import Axes3D\n",
- "from matplotlib.cm import rainbow\n",
- "import numpy as np\n",
- "from scipy.integrate import solve_ivp\n",
- "from scipy.io import loadmat\n",
- "from pysindy.utils import linear_damped_SHO\n",
- "from pysindy.utils import cubic_damped_SHO\n",
- "from pysindy.utils import linear_3D\n",
- "from pysindy.utils import hopf\n",
- "from pysindy.utils import lorenz\n",
- "\n",
- "import pysindy as ps\n",
- "\n",
- "# ignore user warnings\n",
- "import warnings\n",
- "warnings.filterwarnings(\"ignore\", category=UserWarning)\n",
- "\n",
- "np.random.seed(1000) # Seed for reproducibility\n",
- "\n",
- "# Integrator keywords for solve_ivp\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": [
- "## Simple illustrative systems\n",
- "Here we give examples of SINDy applied to simple linear and nonlinear dynamical systems. In each instance the `SINDy` object is given measurements of state variables, but not their derivatives, and is tasked with identifying the equations to describe their dynamics."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Linear 2D ODE\n",
- "\n",
- "The first example shows a demonstration of SINDy on a linear two-dimensional damped harmonic oscillator.\n",
- "\n",
- "We generate training data by integrating the following linear system of differential equations with initial condtion $(2,0)$.\n",
- "\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": 2,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2020-04-03T00:38:15.150040Z",
- "start_time": "2020-04-03T00:38:15.080973Z"
- }
- },
- "outputs": [],
- "source": [
- "# Generate training data\n",
- "\n",
- "dt = 0.01\n",
- "t_train = np.arange(0, 25, 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, \n",
- " x0_train, t_eval=t_train, **integrator_keywords).y.T"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Next we fit a SINDy model to the training data, finding that it recovers the correct governing equations."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2020-04-03T00:38:15.245967Z",
- "start_time": "2020-04-03T00:38:15.154825Z"
- }
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "(x0)' = -0.100 x0 + 2.000 x1\n",
- "(x1)' = -2.000 x0 + -0.100 x1\n"
- ]
- }
- ],
- "source": [
- "# Fit the model\n",
- "\n",
- "poly_order = 5\n",
- "threshold = 0.05\n",
- "\n",
- "model = ps.SINDy(\n",
- " optimizer=ps.STLSQ(threshold=threshold),\n",
- " feature_library=ps.PolynomialLibrary(degree=poly_order),\n",
- ")\n",
- "model.fit(x_train, t=dt)\n",
- "model.print()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "The learned model can be used to evolve initial conditions forward in time. Here we plot the trajectories predicted by the SINDy model against those of the true governing equations."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2020-04-03T00:38:16.557027Z",
- "start_time": "2020-04-03T00:38:15.250741Z"
- }
- },
- "outputs": [
- {
- "data": {
- "image/png": "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\n",
- "text/plain": [
- "