diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..c722213 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +autokoopman/_version.py export-subst +*.ipynb linguist-detectable=false diff --git a/.github/workflows/documentation.yaml b/.github/workflows/documentation.yml similarity index 78% rename from .github/workflows/documentation.yaml rename to .github/workflows/documentation.yml index 33a2896..fa9dfee 100644 --- a/.github/workflows/documentation.yaml +++ b/.github/workflows/documentation.yml @@ -1,7 +1,8 @@ -name: Docs +name: Sphinx Build on: [push, pull_request, workflow_dispatch] jobs: docs: + if: github.ref == 'refs/heads/develop' || github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags') runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 @@ -16,7 +17,7 @@ jobs: sphinx-build documentation/sphinx/source _build - name: Deploy uses: peaceiris/actions-gh-pages@v3 - if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/develop' }} + if: startsWith(github.ref, 'refs/tags') with: publish_branch: gh-pages github_token: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/notebook.yml b/.github/workflows/notebook.yml new file mode 100644 index 0000000..6c02fe0 --- /dev/null +++ b/.github/workflows/notebook.yml @@ -0,0 +1,31 @@ +name: Jupyter Notebooks + +on: [push] + +jobs: + build-linux: + runs-on: ubuntu-latest + strategy: + max-parallel: 5 + + steps: + - uses: actions/checkout@v2 + - name: Set up Python 3.9 + uses: actions/setup-python@v2 + with: + python-version: 3.9 + - name: Add conda to system path + run: | + # $CONDA is an environment variable pointing to the root of the miniconda directory + echo $CONDA/bin >> $GITHUB_PATH + - name: Install dependencies + run: | + conda env update --file environment.yml --name base + - name: Test with pytest + run: | + pip install . + conda install pytest + pip install nbmake==0.5 + pytest --nbmake "./notebooks/" + pytest + diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml new file mode 100644 index 0000000..5c279ef --- /dev/null +++ b/.github/workflows/publish.yml @@ -0,0 +1,45 @@ +name: Publish AutoKoopman + +on: [push] + +jobs: + publish-whl: + runs-on: ubuntu-latest + strategy: + max-parallel: 5 + + steps: + - uses: actions/checkout@v2 + - name: Set up Python 3.9 + uses: actions/setup-python@v2 + with: + python-version: 3.9 + - name: Add conda to system path + run: | + # $CONDA is an environment variable pointing to the root of the miniconda directory + echo $CONDA/bin >> $GITHUB_PATH + - name: Prepare build requirements + run: >- + python -m + pip install + build + --user + - name: Build a binary wheel and a source tarball + run: >- + python -m + build + --sdist + --wheel + --outdir dist/ + . + - name: Publish distribution 📦 to Test PyPI + if: startsWith(github.ref, 'refs/tags') + uses: pypa/gh-action-pypi-publish@release/v1 + with: + password: ${{ secrets.TEST_PYPI_API_TOKEN }} + repository_url: https://test.pypi.org/legacy/ + - name: Publish distribution 📦 to PyPI + if: startsWith(github.ref, 'refs/tags') + uses: pypa/gh-action-pypi-publish@release/v1 + with: + password: ${{ secrets.PYPI_API_TOKEN }} \ No newline at end of file diff --git a/.lift/config.toml b/.lift/config.toml new file mode 100644 index 0000000..dba7269 --- /dev/null +++ b/.lift/config.toml @@ -0,0 +1,3 @@ +ignoreFiles = ''' +autokoopman/_version.py +''' \ No newline at end of file diff --git a/CITATION.cff b/CITATION.cff new file mode 100644 index 0000000..72ef5f5 --- /dev/null +++ b/CITATION.cff @@ -0,0 +1,29 @@ +cff-version: 1.2.0 +message: "If you use this software, please cite it as below." +authors: +- family-names: "Lew" + given-names: "Ethan" + orcid: "https://orcid.org/0000-0002-6509-6846" +- family-names: "Hekal" + given-names: "Abdelrahman" + orcid: "https://orcid.org/0009-0008-9685-0558" +- family-names: "Potomkin" + given-names: "Kostiantyn" + orcid: "https://orcid.org/0000-0002-4726-8931" +- family-names: "Kochdumper" + given-names: "Niklas" + orcid: "https://orcid.org/0000-0001-6017-7623" +- family-names: "Hencey" + given-names: "Brandon" + orcid: "https://orcid.org/0000-0001-9240-7999" +- family-names: "Bak" + given-names: "Stanley" + orcid: "https://orcid.org/0000-0003-4947-9553" +- family-names: "Bogomolov" + given-names: "Sergiy" + orcid: "https://orcid.org/0000-0002-0686-0365" +title: "AutoKoopman: A Toolbox for Automated System Identification via Koopman Operator Linearization" +version: 0.30.0 +doi: 10.1007/978-3-031-45332-8_12 +date-released: 2023-10-19 +url: "https://github.com/EthanJamesLew/AutoKoopman" diff --git a/README.md b/README.md index 487998b..3d0a485 100644 --- a/README.md +++ b/README.md @@ -1,24 +1,47 @@ -# AutoKoopman +[![PyPI version](https://badge.fury.io/py/autokoopman.svg)](https://badge.fury.io/py/autokoopman) +[![license](https://img.shields.io/github/license/EthanJamesLew/AutoKoopman)](LICENSE) +[![Conda CI Workflow](https://github.com/EthanJamesLew/AutoKoopman/actions/workflows/python-package-conda.yml/badge.svg)](https://github.com/EthanJamesLew/AutoKoopman/actions/workflows/python-package-conda.yml) +[![Sphinx Workflow](https://github.com/EthanJamesLew/AutoKoopman/actions/workflows/documentation.yml/badge.svg)](https://github.com/EthanJamesLew/AutoKoopman/actions/workflows/documentation.yml) +[![Jupyter Workflow](https://github.com/EthanJamesLew/AutoKoopman/actions/workflows/notebook.yml/badge.svg)](https://github.com/EthanJamesLew/AutoKoopman/actions/workflows/notebook.yml) + +![](https://raw.githubusercontent.com/EthanJamesLew/AutoKoopman/enhancement/v-0.30-tweaks/documentation/img/brand/logo-full.svg) -![Conda CI Workflow](https://github.com/EthanJamesLew/AutoKoopman/actions/workflows/python-package-conda.yml/badge.svg) +# AutoKoopman ## Overview -AutoKoopman is a python library for the use of Koopman operator methods for data-driven dynamical systems analysis and control. The library -has convenient functions to learn systems using a few lines of code. It has a variety of linearization methods under -shared class interfaces. These methods are pluggable into hyperparameter optimizers which can automate the process of model -optimization. + +AutoKoopman is a high-level system identification tool that automatically optimizes all hyper-parameters to estimate accurate system models with globally linearized representations. Implemented as a python library under shared class interfaces, AutoKoopman uses a collection of Koopman-based algorithms centered on conventional dynamic mode decomposition and deep learning. Koopman theory relies on embedding system states to *observables*; AutoKoopman provides major types of static observables. + +The library supports +* Discrete-Time and Continuous-Time System Identification + * Extended Dynamic Mode Decomposition (EDMD) [[Williams et al.]](#1) + * Deep Koopman [[Li et al.]](#2) + * SINDy [[Brunton et al.]](#3) +* Static Observables + * Random Fourier Features [[Bak et al.]](#4) + * Polynomial + * Neural Network [[Li et al.]](#2) +* System Identification with Input and Control + * Koopman with Input and Control (KIC) [[Proctor et al.]](#5) +* Online (Streaming) System Identification + * Online DMD [[Zhang et al.]](#6) +* Hyperparameter Optimization + * Random Search + * Grid Search + * Bayesian Optimization ## Use Cases -A systems engineer / researcher who wishes to leverage data-driven dynamical systems techniques. The user may -have measurements of their system with no prior model. -* System Prediction - the user can simulate a model learned from their measurements. They use popular techniques like DMD and SINDy out of the box, and implement their own methods to plug into the provided analysis infrastructure (e.g. hyperparameter optimization, visualization). -* System Linearization - the user can get a linear representation of their system in its original states or koopman observables. They can use this linear form to perform tasks like controller synthesis and system reachability. +The library is intended for a systems engineer / researcher who wishes to leverage data-driven dynamical systems techniques. The user may have measurements of their system with no prior model. + +* **Prediction:** Predict the evolution of a system over long time horizons +* **Control:** Synthesize control signals that achieve desired closed-loop behaviors and are optimal with respect to some objective. +* **Verification:** Prove or falsify the safety requirements of a system. ## Installation -The module requires python 3.8 or higher. With pip installed, run +The module is published on [PyPI](https://pypi.org/project/autokoopman/). It requires python 3.8 or higher. With pip installed, run ```shell -pip install . +pip install autokoopman ``` at the repo root. Run ```shell @@ -28,7 +51,7 @@ to ensure that the module can be imported. ## Examples -### Complete Example +### A Complete Example AutoKoopman has a convenience function `auto_koopman` that can learn dynamical systems from data in one call, given training data of trajectories (list of arrays), ```python @@ -38,6 +61,8 @@ import numpy as np # this is the convenience function from autokoopman import auto_koopman +np.random.seed(20) + # for a complete example, let's create an example dataset using an included benchmark system import autokoopman.benchmark.fhn as fhn fhn = fhn.FitzHughNagumo() @@ -83,7 +108,28 @@ plt.plot(*trajectory.states.T) plt.plot(*true_trajectory.states.T) ``` +## Architecture + +The library architecture has a modular design, allowing users to implement custom modules and plug them into the learning pipeline with ease. + +![Library Architecture](https://github.com/EthanJamesLew/AutoKoopman/raw/enhancement/v-0.30-tweaks/documentation/img/autokoopman_objects.png) +*AutoKoopman Class Structure in the Training Pipeline*. A user can implement any of the classes to extend AutoKoopman (e.g., custom observables, a custom tuner, a new system id estimator). ## Documentation -[AutoKoopman Documentation](https://ethanjameslew.github.io/AutoKoopman/) +See the +[AutoKoopman Documentation](https://ethanjameslew.github.io/AutoKoopman/). + +## References + +[1] Williams, M. O., Kevrekidis, I. G., & Rowley, C. W. (2015). A data–driven approximation of the koopman operator: Extending dynamic mode decomposition. Journal of Nonlinear Science, 25, 1307-1346. + + [2] Li, Y., He, H., Wu, J., Katabi, D., & Torralba, A. (2019). Learning compositional koopman operators for model-based control. arXiv preprint arXiv:1910.08264. + + [3] Brunton, S. L., Proctor, J. L., & Kutz, J. N. (2016). Discovering governing equations from data by sparse identification of nonlinear dynamical systems. Proceedings of the national academy of sciences, 113(15), 3932-3937. + + [4] Bak, S., Bogomolov, S., Hencey, B., Kochdumper, N., Lew, E., & Potomkin, K. (2022, August). Reachability of Koopman linearized systems using random fourier feature observables and polynomial zonotope refinement. In Computer Aided Verification: 34th International Conference, CAV 2022, Haifa, Israel, August 7–10, 2022, Proceedings, Part I (pp. 490-510). Cham: Springer International Publishing. + + [5] Proctor, J. L., Brunton, S. L., & Kutz, J. N. (2018). Generalizing Koopman theory to allow for inputs and control. SIAM Journal on Applied Dynamical Systems, 17(1), 909-930. + + [6] Zhang, H., Rowley, C. W., Deem, E. A., & Cattafesta, L. N. (2019). Online dynamic mode decomposition for time-varying systems. SIAM Journal on Applied Dynamical Systems, 18(3), 1586-1609. diff --git a/autokoopman/__init__.py b/autokoopman/__init__.py index 6f08e09..81c76e2 100644 --- a/autokoopman/__init__.py +++ b/autokoopman/__init__.py @@ -11,11 +11,16 @@ "Sergiy Bogomolov", ] __license__ = "GPLv3" -__version__ = "0.21" __maintainer__ = "Ethan Lew" __email__ = "ethanlew16@gmail.com" __status__ = "Prototype" +# we auto-manage versions +from ._version import get_versions + +__version__ = get_versions()["version"] +del get_versions + from autokoopman.autokoopman import auto_koopman from autokoopman.core.system import ( @@ -30,3 +35,7 @@ UniformTimeTrajectoriesData, UniformTimeTrajectory, ) + +from . import _version + +__version__ = _version.get_versions()["version"] diff --git a/autokoopman/_version.py b/autokoopman/_version.py new file mode 100644 index 0000000..30f93da --- /dev/null +++ b/autokoopman/_version.py @@ -0,0 +1,658 @@ + +# This file helps to compute a version number in source trees obtained from +# git-archive tarball (such as those provided by githubs download-from-tag +# feature). Distribution tarballs (built by setup.py sdist) and build +# directories (produced by setup.py build) will contain a much shorter file +# that just contains the computed version number. + +# This file is released into the public domain. +# Generated by versioneer-0.28 +# https://github.com/python-versioneer/python-versioneer + +"""Git implementation of _version.py.""" + +import errno +import os +import re +import subprocess +import sys +from typing import Callable, Dict +import functools + + +def get_keywords(): + """Get the keywords needed to look up the version information.""" + # these strings will be replaced by git during git-archive. + # setup.py/versioneer.py will grep for the variable names, so they must + # each be defined on a line of their own. _version.py will just call + # get_keywords(). + git_refnames = "$Format:%d$" + git_full = "$Format:%H$" + git_date = "$Format:%ci$" + keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} + return keywords + + +class VersioneerConfig: + """Container for Versioneer configuration parameters.""" + + +def get_config(): + """Create, populate and return the VersioneerConfig() object.""" + # these strings are filled in when 'setup.py versioneer' creates + # _version.py + cfg = VersioneerConfig() + cfg.VCS = "git" + cfg.style = "pep440" + cfg.tag_prefix = "" + cfg.parentdir_prefix = "" + cfg.versionfile_source = "autokoopman/_version.py" + cfg.verbose = False + return cfg + + +class NotThisMethod(Exception): + """Exception raised if a method is not valid for the current scenario.""" + + +LONG_VERSION_PY: Dict[str, str] = {} +HANDLERS: Dict[str, Dict[str, Callable]] = {} + + +def register_vcs_handler(vcs, method): # decorator + """Create decorator to mark a method as the handler of a VCS.""" + def decorate(f): + """Store f in HANDLERS[vcs][method].""" + if vcs not in HANDLERS: + HANDLERS[vcs] = {} + HANDLERS[vcs][method] = f + return f + return decorate + + +def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, + env=None): + """Call the given command(s).""" + assert isinstance(commands, list) + process = None + + popen_kwargs = {} + if sys.platform == "win32": + # This hides the console window if pythonw.exe is used + startupinfo = subprocess.STARTUPINFO() + startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW + popen_kwargs["startupinfo"] = startupinfo + + for command in commands: + try: + dispcmd = str([command] + args) + # remember shell=False, so use git.cmd on windows, not just git + process = subprocess.Popen([command] + args, cwd=cwd, env=env, + stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr + else None), **popen_kwargs) + break + except OSError: + e = sys.exc_info()[1] + if e.errno == errno.ENOENT: + continue + if verbose: + print("unable to run %s" % dispcmd) + print(e) + return None, None + else: + if verbose: + print("unable to find command, tried %s" % (commands,)) + return None, None + stdout = process.communicate()[0].strip().decode() + if process.returncode != 0: + if verbose: + print("unable to run %s (error)" % dispcmd) + print("stdout was %s" % stdout) + return None, process.returncode + return stdout, process.returncode + + +def versions_from_parentdir(parentdir_prefix, root, verbose): + """Try to determine the version from the parent directory name. + + Source tarballs conventionally unpack into a directory that includes both + the project name and a version string. We will also support searching up + two directory levels for an appropriately named parent directory + """ + rootdirs = [] + + for _ in range(3): + dirname = os.path.basename(root) + if dirname.startswith(parentdir_prefix): + return {"version": dirname[len(parentdir_prefix):], + "full-revisionid": None, + "dirty": False, "error": None, "date": None} + rootdirs.append(root) + root = os.path.dirname(root) # up a level + + if verbose: + print("Tried directories %s but none started with prefix %s" % + (str(rootdirs), parentdir_prefix)) + raise NotThisMethod("rootdir doesn't start with parentdir_prefix") + + +@register_vcs_handler("git", "get_keywords") +def git_get_keywords(versionfile_abs): + """Extract version information from the given file.""" + # the code embedded in _version.py can just fetch the value of these + # keywords. When used from setup.py, we don't want to import _version.py, + # so we do it with a regexp instead. This function is not used from + # _version.py. + keywords = {} + try: + with open(versionfile_abs, "r") as fobj: + for line in fobj: + if line.strip().startswith("git_refnames ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["refnames"] = mo.group(1) + if line.strip().startswith("git_full ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["full"] = mo.group(1) + if line.strip().startswith("git_date ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["date"] = mo.group(1) + except OSError: + pass + return keywords + + +@register_vcs_handler("git", "keywords") +def git_versions_from_keywords(keywords, tag_prefix, verbose): + """Get version information from git keywords.""" + if "refnames" not in keywords: + raise NotThisMethod("Short version file found") + date = keywords.get("date") + if date is not None: + # Use only the last line. Previous lines may contain GPG signature + # information. + date = date.splitlines()[-1] + + # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant + # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 + # -like" string, which we must then edit to make compliant), because + # it's been around since git-1.5.3, and it's too difficult to + # discover which version we're using, or to work around using an + # older one. + date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) + refnames = keywords["refnames"].strip() + if refnames.startswith("$Format"): + if verbose: + print("keywords are unexpanded, not using") + raise NotThisMethod("unexpanded keywords, not a git-archive tarball") + refs = {r.strip() for r in refnames.strip("()").split(",")} + # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of + # just "foo-1.0". If we see a "tag: " prefix, prefer those. + TAG = "tag: " + tags = {r[len(TAG):] for r in refs if r.startswith(TAG)} + if not tags: + # Either we're using git < 1.8.3, or there really are no tags. We use + # a heuristic: assume all version tags have a digit. The old git %d + # expansion behaves like git log --decorate=short and strips out the + # refs/heads/ and refs/tags/ prefixes that would let us distinguish + # between branches and tags. By ignoring refnames without digits, we + # filter out many common branch names like "release" and + # "stabilization", as well as "HEAD" and "master". + tags = {r for r in refs if re.search(r'\d', r)} + if verbose: + print("discarding '%s', no digits" % ",".join(refs - tags)) + if verbose: + print("likely tags: %s" % ",".join(sorted(tags))) + for ref in sorted(tags): + # sorting will prefer e.g. "2.0" over "2.0rc1" + if ref.startswith(tag_prefix): + r = ref[len(tag_prefix):] + # Filter out refs that exactly match prefix or that don't start + # with a number once the prefix is stripped (mostly a concern + # when prefix is '') + if not re.match(r'\d', r): + continue + if verbose: + print("picking %s" % r) + return {"version": r, + "full-revisionid": keywords["full"].strip(), + "dirty": False, "error": None, + "date": date} + # no suitable tags, so version is "0+unknown", but full hex is still there + if verbose: + print("no suitable tags, using unknown + full revision id") + return {"version": "0+unknown", + "full-revisionid": keywords["full"].strip(), + "dirty": False, "error": "no suitable tags", "date": None} + + +@register_vcs_handler("git", "pieces_from_vcs") +def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): + """Get version from 'git describe' in the root of the source tree. + + This only gets called if the git-archive 'subst' keywords were *not* + expanded, and _version.py hasn't already been rewritten with a short + version string, meaning we're inside a checked out source tree. + """ + GITS = ["git"] + if sys.platform == "win32": + GITS = ["git.cmd", "git.exe"] + + # GIT_DIR can interfere with correct operation of Versioneer. + # It may be intended to be passed to the Versioneer-versioned project, + # but that should not change where we get our version from. + env = os.environ.copy() + env.pop("GIT_DIR", None) + runner = functools.partial(runner, env=env) + + _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, + hide_stderr=not verbose) + if rc != 0: + if verbose: + print("Directory %s not under git control" % root) + raise NotThisMethod("'git rev-parse --git-dir' returned error") + + # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] + # if there isn't one, this yields HEX[-dirty] (no NUM) + describe_out, rc = runner(GITS, [ + "describe", "--tags", "--dirty", "--always", "--long", + "--match", f"{tag_prefix}[[:digit:]]*" + ], cwd=root) + # --long was added in git-1.5.5 + if describe_out is None: + raise NotThisMethod("'git describe' failed") + describe_out = describe_out.strip() + full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) + if full_out is None: + raise NotThisMethod("'git rev-parse' failed") + full_out = full_out.strip() + + pieces = {} + pieces["long"] = full_out + pieces["short"] = full_out[:7] # maybe improved later + pieces["error"] = None + + branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], + cwd=root) + # --abbrev-ref was added in git-1.6.3 + if rc != 0 or branch_name is None: + raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") + branch_name = branch_name.strip() + + if branch_name == "HEAD": + # If we aren't exactly on a branch, pick a branch which represents + # the current commit. If all else fails, we are on a branchless + # commit. + branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) + # --contains was added in git-1.5.4 + if rc != 0 or branches is None: + raise NotThisMethod("'git branch --contains' returned error") + branches = branches.split("\n") + + # Remove the first line if we're running detached + if "(" in branches[0]: + branches.pop(0) + + # Strip off the leading "* " from the list of branches. + branches = [branch[2:] for branch in branches] + if "master" in branches: + branch_name = "master" + elif not branches: + branch_name = None + else: + # Pick the first branch that is returned. Good or bad. + branch_name = branches[0] + + pieces["branch"] = branch_name + + # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] + # TAG might have hyphens. + git_describe = describe_out + + # look for -dirty suffix + dirty = git_describe.endswith("-dirty") + pieces["dirty"] = dirty + if dirty: + git_describe = git_describe[:git_describe.rindex("-dirty")] + + # now we have TAG-NUM-gHEX or HEX + + if "-" in git_describe: + # TAG-NUM-gHEX + mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) + if not mo: + # unparsable. Maybe git-describe is misbehaving? + pieces["error"] = ("unable to parse git-describe output: '%s'" + % describe_out) + return pieces + + # tag + full_tag = mo.group(1) + if not full_tag.startswith(tag_prefix): + if verbose: + fmt = "tag '%s' doesn't start with prefix '%s'" + print(fmt % (full_tag, tag_prefix)) + pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" + % (full_tag, tag_prefix)) + return pieces + pieces["closest-tag"] = full_tag[len(tag_prefix):] + + # distance: number of commits since tag + pieces["distance"] = int(mo.group(2)) + + # commit: short hex revision ID + pieces["short"] = mo.group(3) + + else: + # HEX: no tags + pieces["closest-tag"] = None + out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root) + pieces["distance"] = len(out.split()) # total number of commits + + # commit date: see ISO-8601 comment in git_versions_from_keywords() + date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip() + # Use only the last line. Previous lines may contain GPG signature + # information. + date = date.splitlines()[-1] + pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) + + return pieces + + +def plus_or_dot(pieces): + """Return a + if we don't already have one, else return a .""" + if "+" in pieces.get("closest-tag", ""): + return "." + return "+" + + +def render_pep440(pieces): + """Build up version string, with post-release "local version identifier". + + Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you + get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty + + Exceptions: + 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + rendered += plus_or_dot(pieces) + rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + else: + # exception #1 + rendered = "0+untagged.%d.g%s" % (pieces["distance"], + pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + +def render_pep440_branch(pieces): + """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . + + The ".dev0" means not master branch. Note that .dev0 sorts backwards + (a feature branch will appear "older" than the master branch). + + Exceptions: + 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + else: + # exception #1 + rendered = "0" + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += "+untagged.%d.g%s" % (pieces["distance"], + pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + +def pep440_split_post(ver): + """Split pep440 version string at the post-release segment. + + Returns the release segments before the post-release and the + post-release version number (or -1 if no post-release segment is present). + """ + vc = str.split(ver, ".post") + return vc[0], int(vc[1] or 0) if len(vc) == 2 else None + + +def render_pep440_pre(pieces): + """TAG[.postN.devDISTANCE] -- No -dirty. + + Exceptions: + 1: no tags. 0.post0.devDISTANCE + """ + if pieces["closest-tag"]: + if pieces["distance"]: + # update the post release segment + tag_version, post_version = pep440_split_post(pieces["closest-tag"]) + rendered = tag_version + if post_version is not None: + rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"]) + else: + rendered += ".post0.dev%d" % (pieces["distance"]) + else: + # no commits, use the tag as the version + rendered = pieces["closest-tag"] + else: + # exception #1 + rendered = "0.post0.dev%d" % pieces["distance"] + return rendered + + +def render_pep440_post(pieces): + """TAG[.postDISTANCE[.dev0]+gHEX] . + + The ".dev0" means dirty. Note that .dev0 sorts backwards + (a dirty tree will appear "older" than the corresponding clean one), + but you shouldn't be releasing software with -dirty anyways. + + Exceptions: + 1: no tags. 0.postDISTANCE[.dev0] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + rendered += ".post%d" % pieces["distance"] + if pieces["dirty"]: + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "g%s" % pieces["short"] + else: + # exception #1 + rendered = "0.post%d" % pieces["distance"] + if pieces["dirty"]: + rendered += ".dev0" + rendered += "+g%s" % pieces["short"] + return rendered + + +def render_pep440_post_branch(pieces): + """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . + + The ".dev0" means not master branch. + + Exceptions: + 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + rendered += ".post%d" % pieces["distance"] + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "g%s" % pieces["short"] + if pieces["dirty"]: + rendered += ".dirty" + else: + # exception #1 + rendered = "0.post%d" % pieces["distance"] + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += "+g%s" % pieces["short"] + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + +def render_pep440_old(pieces): + """TAG[.postDISTANCE[.dev0]] . + + The ".dev0" means dirty. + + Exceptions: + 1: no tags. 0.postDISTANCE[.dev0] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + rendered += ".post%d" % pieces["distance"] + if pieces["dirty"]: + rendered += ".dev0" + else: + # exception #1 + rendered = "0.post%d" % pieces["distance"] + if pieces["dirty"]: + rendered += ".dev0" + return rendered + + +def render_git_describe(pieces): + """TAG[-DISTANCE-gHEX][-dirty]. + + Like 'git describe --tags --dirty --always'. + + Exceptions: + 1: no tags. HEX[-dirty] (note: no 'g' prefix) + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"]: + rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) + else: + # exception #1 + rendered = pieces["short"] + if pieces["dirty"]: + rendered += "-dirty" + return rendered + + +def render_git_describe_long(pieces): + """TAG-DISTANCE-gHEX[-dirty]. + + Like 'git describe --tags --dirty --always -long'. + The distance/hash is unconditional. + + Exceptions: + 1: no tags. HEX[-dirty] (note: no 'g' prefix) + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) + else: + # exception #1 + rendered = pieces["short"] + if pieces["dirty"]: + rendered += "-dirty" + return rendered + + +def render(pieces, style): + """Render the given version pieces into the requested style.""" + if pieces["error"]: + return {"version": "unknown", + "full-revisionid": pieces.get("long"), + "dirty": None, + "error": pieces["error"], + "date": None} + + if not style or style == "default": + style = "pep440" # the default + + if style == "pep440": + rendered = render_pep440(pieces) + elif style == "pep440-branch": + rendered = render_pep440_branch(pieces) + elif style == "pep440-pre": + rendered = render_pep440_pre(pieces) + elif style == "pep440-post": + rendered = render_pep440_post(pieces) + elif style == "pep440-post-branch": + rendered = render_pep440_post_branch(pieces) + elif style == "pep440-old": + rendered = render_pep440_old(pieces) + elif style == "git-describe": + rendered = render_git_describe(pieces) + elif style == "git-describe-long": + rendered = render_git_describe_long(pieces) + else: + raise ValueError("unknown style '%s'" % style) + + return {"version": rendered, "full-revisionid": pieces["long"], + "dirty": pieces["dirty"], "error": None, + "date": pieces.get("date")} + + +def get_versions(): + """Get version information or return default if unable to do so.""" + # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have + # __file__, we can work backwards from there to the root. Some + # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which + # case we can only use expanded keywords. + + cfg = get_config() + verbose = cfg.verbose + + try: + return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, + verbose) + except NotThisMethod: + pass + + try: + root = os.path.realpath(__file__) + # versionfile_source is the relative path from the top of the source + # tree (where the .git directory might live) to this file. Invert + # this to find the root from __file__. + for _ in cfg.versionfile_source.split('/'): + root = os.path.dirname(root) + except NameError: + return {"version": "0+unknown", "full-revisionid": None, + "dirty": None, + "error": "unable to find root of source tree", + "date": None} + + try: + pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) + return render(pieces, cfg.style) + except NotThisMethod: + pass + + try: + if cfg.parentdir_prefix: + return versions_from_parentdir(cfg.parentdir_prefix, root, verbose) + except NotThisMethod: + pass + + return {"version": "0+unknown", "full-revisionid": None, + "dirty": None, + "error": "unable to compute version", "date": None} diff --git a/autokoopman/autokoopman.py b/autokoopman/autokoopman.py index 5f8da32..47a8855 100644 --- a/autokoopman/autokoopman.py +++ b/autokoopman/autokoopman.py @@ -75,7 +75,7 @@ def get_parameter_space(obs_type, threshold_range, rank): return ParameterSpace( "koopman-polynomial", [ - DiscreteParameter("degree", 1, 5), + DiscreteParameter("degree", 1, 3), DiscreteParameter("rank", *rank), ], ) @@ -133,7 +133,7 @@ def auto_koopman( training_data: Union[TrajectoriesData, Sequence[np.ndarray]], inputs_training_data: Optional[Sequence[np.ndarray]] = None, sampling_period: Optional[float] = None, - normalize: bool = True, + normalize: bool = False, opt: Union[str, HyperparameterTuner] = "monte-carlo", max_opt_iter: int = 100, max_epochs: int = 500, diff --git a/autokoopman/core/system.py b/autokoopman/core/system.py index 75a0cbf..1d02a69 100644 --- a/autokoopman/core/system.py +++ b/autokoopman/core/system.py @@ -396,6 +396,10 @@ def evolv_func_scale(t, x, i): def A(self): return self._A + @property + def koopman_operator(self): + return self._A + @property def B(self): return self._B diff --git a/documentation/img/autokoopman_objects.png b/documentation/img/autokoopman_objects.png new file mode 100644 index 0000000..beb73a2 Binary files /dev/null and b/documentation/img/autokoopman_objects.png differ diff --git a/documentation/img/brand/logo-full.svg b/documentation/img/brand/logo-full.svg new file mode 100644 index 0000000..c991945 --- /dev/null +++ b/documentation/img/brand/logo-full.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/documentation/img/brand/logo-small.svg b/documentation/img/brand/logo-small.svg new file mode 100644 index 0000000..fb00966 --- /dev/null +++ b/documentation/img/brand/logo-small.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/documentation/sphinx/source/conf.py b/documentation/sphinx/source/conf.py index c844335..600d8e1 100644 --- a/documentation/sphinx/source/conf.py +++ b/documentation/sphinx/source/conf.py @@ -22,7 +22,9 @@ author = "Ethan Lew" # The full version, including alpha/beta/rc tags -release = "0.1b" +import autokoopman +release = autokoopman.__version__ +version = autokoopman.__version__ # -- General configuration --------------------------------------------------- @@ -55,8 +57,9 @@ # add this because of https://github.com/pydata/pydata-sphinx-theme/issues/1094 html_theme_options = { + "github_url": "https://github.com/EthanJamesLew/AutoKoopman", "logo": { - "image_light": "logo-light.png", - "image_dark": "logo-dark.png", + "image_light": "https://raw.githubusercontent.com/EthanJamesLew/AutoKoopman/enhancement/v-0.30-tweaks/documentation/img/brand/logo-small.svg", + "image_dark": "https://raw.githubusercontent.com/EthanJamesLew/AutoKoopman/enhancement/v-0.30-tweaks/documentation/img/brand/logo-small.svg", } } diff --git a/documentation/sphinx/source/index.rst b/documentation/sphinx/source/index.rst index 07eccc8..8936628 100644 --- a/documentation/sphinx/source/index.rst +++ b/documentation/sphinx/source/index.rst @@ -3,6 +3,8 @@ You can adapt this file completely to your liking, but it should at least contain the root `toctree` directive. +**Date**: |today| **Version**: |version| + .. mdinclude:: ../../../README.md Module Contents diff --git a/environment.yml b/environment.yml index 7a58fbb..ad9551c 100644 --- a/environment.yml +++ b/environment.yml @@ -1,48 +1,48 @@ name: autokoopman channels: + - conda-forge - defaults dependencies: - - _libgcc_mutex=0.1=main - - _openmp_mutex=5.1=1_gnu - - blas=1.0=mkl - - ca-certificates=2023.01.10=h06a4308_0 - - certifi=2022.12.7=py39h06a4308_0 - - cffi=1.15.1=py39h5eee18b_3 - - flit-core=3.6.0=pyhd3eb1b0_0 - - future=0.18.2=py39h06a4308_1 - - intel-openmp=2021.4.0=h06a4308_3561 - - ld_impl_linux-64=2.38=h1181459_1 - - libffi=3.4.2=h6a678d5_6 - - libgcc-ng=11.2.0=h1234567_1 - - libgomp=11.2.0=h1234567_1 - - libprotobuf=3.20.3=he621ea3_0 - - libstdcxx-ng=11.2.0=h1234567_1 - - mkl=2021.4.0=h06a4308_640 - - mkl-service=2.4.0=py39h7f8727e_0 - - mkl_fft=1.3.1=py39hd3c417c_0 - - mkl_random=1.2.2=py39h51133e4_0 - - ncurses=6.4=h6a678d5_0 - - ninja=1.10.2=h06a4308_5 - - ninja-base=1.10.2=hd09550d_5 - - numpy-base=1.23.5=py39h31eccc5_0 - - openssl=1.1.1s=h7f8727e_0 - - pip=22.3.1=py39h06a4308_0 - - pycparser=2.21=pyhd3eb1b0_0 - - python=3.9.16=h7a1cb2a_0 - - pytorch=1.12.1=cpu_py39hb1f1ab4_1 - - pyyaml=6.0=py39h5eee18b_1 - - readline=8.2=h5eee18b_0 - - setuptools=65.6.3=py39h06a4308_0 - - six=1.16.0=pyhd3eb1b0_1 - - sqlite=3.40.1=h5082296_0 - - tk=8.6.12=h1ccaba5_0 - - typing-extensions=4.4.0=py39h06a4308_0 - - typing_extensions=4.4.0=py39h06a4308_0 - - tzdata=2022g=h04d1e81_0 - - wheel=0.37.1=pyhd3eb1b0_0 - - xz=5.2.10=h5eee18b_1 - - yaml=0.2.5=h7b6447c_0 - - zlib=1.2.13=h5eee18b_0 + - blas=1.0 + - ca-certificates=2023.08.22 + - cffi=1.15.1 + - filelock=3.9.0 + - gmp=6.2.1 + - gmpy2=2.1.2 + - jinja2=3.1.2 + - libcxx=16.0.6 + - libffi=3.3 + - libopenblas=0.3.21 + - libprotobuf=3.20.3 + - libsqlite=3.43.2 + - libuv=1.44.2 + - libzlib=1.2.13 + - llvm-openmp=14.0.6 + - markupsafe=2.1.1 + - mpc=1.1.0 + - mpfr=4.0.2 + - ncurses=6.4 + - networkx=3.1 + - ninja=1.10.2 + - ninja-base=1.10.2 + - numpy-base=1.26.0 + - openssl=1.1.1w + - pip=23.3.1 + - pycparser=2.21 + - python=3.9.0 + - pytorch=2.0.1 + - readline=8.2 + - setuptools=68.2.2 + - sleef=3.5.1 + - sqlite=3.43.2 + - sympy=1.11.1 + - tk=8.6.13 + - typing-extensions=4.7.1 + - typing_extensions=4.7.1 + - tzdata=2023c + - wheel=0.41.2 + - xz=5.2.6 + - zlib=1.2.13 - pip: - attrs==22.2.0 - cmake==3.25.2 @@ -60,7 +60,7 @@ dependencies: - kiwisolver==1.4.4 - matplotlib==3.6.3 - mpmath==1.2.1 - - numpy==1.23.1 + - numpy==1.21.0 - packaging==23.0 - pandas==1.5.3 - paramz==0.9.5 @@ -73,7 +73,8 @@ dependencies: - pytz==2022.7.1 - scikit-learn==1.0.2 - scipy==1.10.0 - - sympy==1.11.1 + - six==1.16.0 - threadpoolctl==3.1.0 + - tomli==2.0.1 - tqdm==4.64.1 - odmd==0.1.3 diff --git a/notebooks/autokoopman-introduction.ipynb b/notebooks/autokoopman-introduction.ipynb index 7c62693..3b6304d 100644 --- a/notebooks/autokoopman-introduction.ipynb +++ b/notebooks/autokoopman-introduction.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "870f669b", "metadata": {}, "outputs": [], @@ -21,13 +21,15 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", + "import sys\n", + "sys.path.append(\"..\")\n", "# this is the convenience function\n", "from autokoopman import auto_koopman" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "d088fc8b", "metadata": {}, "outputs": [], @@ -44,10 +46,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "fb49b659", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tuning GridSearchTuner: 56%|██████████▋ | 14/25 [00:14<00:11, 1.06s/it]\n" + ] + } + ], "source": [ "# learn model from data\n", "experiment_results = auto_koopman(\n", @@ -65,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "0a302d65", "metadata": {}, "outputs": [], @@ -84,10 +94,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "601cc755", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# simulate the ground truth for comparison\n", "true_trajectory = fhn.solve_ivp(\n", @@ -128,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "6cf8a048", "metadata": {}, "outputs": [], @@ -150,14 +173,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "9f720271", "metadata": {}, "outputs": [], "source": [ "# training data\n", "teval = np.linspace(0, 10, 200)\n", - "params = np.random.rand(10, 3) * 2 - 1\n", + "params = np.random.rand(10, 3) * 4 - 1\n", "ivs = np.random.rand(10, 2) * 2 - 1\n", "steps = [make_input_step(*p, teval) for p in params]\n", "training_data = pendulum_sys.solve_ivps(ivs, inputs=steps, teval=teval)" @@ -165,10 +188,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "b96c9460", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + "Tuning GridSearchTuner: 0%| | 0/25 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "model = experiment_results['tuned_model']\n", "\n", @@ -213,7 +272,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "63b80758", "metadata": {}, "outputs": [], @@ -232,10 +291,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "dc341ce9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plt.figure(figsize=(10, 6))\n", "\n", @@ -269,9 +348,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python [conda env:trust-ml] *", + "display_name": "Python 3 (ipykernel)", "language": "python", - "name": "conda-env-trust-ml-py" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -282,7 +361,8 @@ "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython3" + "pygments_lexer": "ipython3", + "version": "3.9.7" } }, "nbformat": 4, diff --git a/notebooks/Deep Learning Koopman Operators.ipynb b/notebooks/deep-koopman.ipynb similarity index 100% rename from notebooks/Deep Learning Koopman Operators.ipynb rename to notebooks/deep-koopman.ipynb diff --git a/notebooks/linear_model_extraction.ipynb b/notebooks/linear-model.ipynb similarity index 100% rename from notebooks/linear_model_extraction.ipynb rename to notebooks/linear-model.ipynb diff --git a/pyproject.toml b/pyproject.toml index 13b1ef3..b035375 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,4 +1,4 @@ [build-system] -requires = ["setuptools>=61.0.0", "wheel"] +requires = ["setuptools>=61.0.0", "versioneer[toml]==0.28", "wheel"] build-backend = "setuptools.build_meta" diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 0000000..7c5cdd8 --- /dev/null +++ b/setup.cfg @@ -0,0 +1,7 @@ +[versioneer] +VCS = git +style = pep440 +versionfile_source = autokoopman/_version.py +versionfile_build = autokoopman/_version.py +tag_prefix = +parentdir_prefix = diff --git a/setup.py b/setup.py index d45f269..3f3e1cd 100644 --- a/setup.py +++ b/setup.py @@ -1,11 +1,13 @@ import setuptools +import versioneer with open("README.md", "r", encoding="utf-8") as fh: long_description = fh.read() setuptools.setup( name="autokoopman", - version="0.21", + version=versioneer.get_version(), + cmdclass=versioneer.get_cmdclass(), description="Automated Koopman Operator Linearization Library", long_description=long_description, long_description_content_type="text/markdown",