Some unit tests are slow and require Mosek, so they can't be run server-side. Only a subset of the tests are currently run. Unit tests need to be reorganized so that the most possible tests can be run at each merge.

Resolves #121

Proposed Changes

• Remove date from CITATION.cff
• Add GitHub action to check version consistency

Checklist

• [x] Write unit tests
• [x] Add new estimators to existing scikit-learn compatibility tests
• [x] Write examples in docstrings
• [x] Update Sphinx documentation
• [x] Bump version number and date in setup.py, CITATION.cff, and README.rst

I forgot to bump the version in the source code from v1.1.0 to v1.1.1. PyPi rejected the release, but Zenodo accepted it. When fixing this, PyPi accepted the new package, but Zenodo rejected it. So I had to draft v1.1.2 to make everything consistent again.

I need to look into an automated check to prevent this from happening. If not that, then at least a written checklist to follow.

Fixes #73

Proposed Changes

• Implements new functions for quick-and-dirty plots:
  • plot_lifted_trajectory()
  • plot_bode()
  • plot_eigenvalues()
  • plot_koopman_matrix()
  • plot_svd()
  • plot_predicted_trajectory()
  • plot_bode()
  • plot_eigenvalues()
  • plot_koopman_matrix()
  • plot_svd()
• Allows predict_trajectory() to be called with initial condition X0 and input U, or a full data matrix X.

Scale only lifted states without rescaling original states? Maybe the PolynomialLiftingFn should handle its own scaling.

Either way, it's becoming more clear that normalizing and standardizing should be done outside of the KoopmanPipeline, or within each lifting function as needed. But having a "normalizing" lifting function is a bit awkward since we want to keep the original state inside the lifted state unmodified.

Resolves #126

Proposed Changes

• Add check to output of score_trajectory() in case the score becomes NaN or inf during its calculation.

Checklist

• [x] Write unit tests
• [x] Add new estimators to existing scikit-learn compatibility tests
• [x] Write examples in docstrings
• [x] Update Sphinx documentation
• [x] Bump version number and date in setup.py, CITATION.cff, and README.rst

KoopmanLiftingFn.transform() can return non-finite outputs. I'm not sure if I should add a check before returning the transformed values, or if I should check for this elsewhere. Warnings are already raised by NumPy, so I think it's better to leave it alone for the time being.

Expected Behavior

pykoop.score_trajectory() should always return a finite float (no np.inf or np.nan), return the error_score, or raise a ValueError.

Actual Behavior

If the inputs to pykoop.score_trajectory() are finite, but overflow during the calculation of the score, then the function will return -np.inf instead of error_score. This can cause external hyperparameter optimizers to crash.

Steps to Reproduce the Problem

import numpy as np

import pykoop

X_predicted = np.array([
    [1e-2, 1e-3],
]).T

X_expected = np.array([
    [1e150, 1e250],
]).T

score = pykoop.score_trajectory(X_predicted, X_expected, episode_feature=False)

print(score)

Specifications

• Package version: 1.1.3
• Python version: 3.10.9
• Platform: Arch Linux

Resolves #122

Proposed Changes

• Add error_score parameter to control behaviour of scorer when predictions diverge.

Checklist

• [x] Write unit tests
• [x] Add new estimators to existing scikit-learn compatibility tests
• [x] Write examples in docstrings
• [x] Update Sphinx documentation
• [x] Bump version number and date in setup.py, CITATION.cff, and README.rst

Scoring does not work correctly when X has NaN entries. Example to reproduce:

"""Example of how to use the Koopman pipeline."""

from sklearn.preprocessing import MaxAbsScaler, StandardScaler

import pykoop
import numpy as np


def example_pipeline_simple() -> None:
    """Demonstrate how to use the Koopman pipeline."""
    # Get example mass-spring-damper data
    eg = pykoop.example_data_msd()

    # Create pipeline
    kp = pykoop.KoopmanPipeline(
        lifting_functions=[
            ('pl', pykoop.PolynomialLiftingFn(order=10)),
        ],
        regressor=pykoop.Edmd(alpha=0),
    )

    # Fit the pipeline
    kp.fit(
        eg['X_train'],
        n_inputs=eg['n_inputs'],
        episode_feature=eg['episode_feature'],
    )

    # Predict using the pipeline
    X_pred = kp.predict_trajectory(eg['x0_valid'], eg['u_valid'])
    print(np.any(np.isnan(X_pred)))

    # Score using the pipeline
    score = kp.score(eg['X_valid'])
    print(score)


if __name__ == '__main__':
    example_pipeline_simple()

Solution is to implement the scikit-learn convention:

error_score 'raise' or numeric, default=np.nan Value to assign to the score if an error occurs in estimator fitting. If set to ‘raise’, the error is raised. If a numeric value is given, FitFailedWarning is raised. This parameter does not affect the refit step, which will always raise the error.

Resolves #117

Proposed Changes

• Remove reference to X_ikm1

Checklist

• [x] Write unit tests
• [x] Add new estimators to existing scikit-learn compatibility tests
• [x] Write examples in docstrings
• [x] Update Sphinx documentation

Resolves #125

Proposed Changes

• Add DataRegressor, which accepts a Koopman matrix in the form of a NumPy array as input.

Checklist

• [x] Write unit tests
• [x] Add new estimators to existing scikit-learn compatibility tests
• [x] Write examples in docstrings
• [x] Update Sphinx documentation
• [x] Bump version number and date in setup.py, CITATION.cff, and README.rst

Desired Behavior

Given a Koopman matrix U, create a KoopmanRegressor object that functions as if it was fit with pykoop.

Proposed Solution

Along these lines:

class DataRegressor(KoopmanRegressor):

    def __init__(self, U):
        self.U = U
        
    def fit(X, y):
        self.n_features_in_ = ...
        self.coef_ = U.copy()

Refactor PolynomialLiftingFn to support products of other polynomials instead of just monomials. For example, instead of x1^2 * x2, allow H2(x1) * H1(x2) where Hx is the xth Hermite polynomial.

This can be achieved by removing the wrapped scikit-learn polynomial transformer and using a custom one with similar functionality. Specifically the powers_ matrix.