Merge pull request #178 from decargroup/bugfix/175-fix-inverse-fourier-transform-in-parameters-and-docs-of-rff-lifting-functions

Fix inverse Fourier transform naming

Author: sdahdah

.github/workflows/test-package-no-mosek.yml

@@ -0,0 +1,26 @@
+name: Test package (no MOSEK)
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.8', '3.9', '3.10', '3.11']
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{matrix.python-version}}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{matrix.python-version}}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install -r requirements-dev.txt
+    - name: Test with pytest
+      run: |
+        pytest --exitfirst -k "not mosek"

.github/workflows/test-package.yml

@@ -10,7 +10,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ['3.8', '3.9', '3.10', '3.11', '3.12']
+        python-version: ['3.12']
     steps:
     - uses: actions/checkout@v2
     - name: Set up Python ${{matrix.python-version}}

CITATION.cff

@@ -10,6 +10,6 @@ authors:
     orcid: "https://orcid.org/0000-0002-1987-9268"
     affiliation: "McGill University"
 title: "decargroup/pykoop"
-version: v1.2.4
+version: v2.0.0
 doi: 10.5281/zenodo.5576490
 url: "https://github.com/decargroup/pykoop"

README.rst

@@ -221,7 +221,7 @@ If you use this software in your research, please cite it as below or see
         url={https://github.com/decargroup/pykoop},
         publisher={Zenodo},
         author={Steven Dahdah and James Richard Forbes},
-        version = {{v1.2.4}},
+        version = {{v2.0.0}},
         year={2022},
     }
 

pykoop/kernel_approximation.py

@@ -93,9 +93,8 @@ class RandomFourierKernelApprox(KernelApproximation):
     n_features_out_ : int
         Number of features output. This attribute is not available in
         estimators from :mod:`sklearn.kernel_approximation`.
-    ift_ : scipy.stats.rv_continuous
-        Probability distribution corresponding to inverse Fourier transform of
-        chosen kernel.
+    ft_ : scipy.stats.rv_continuous
+        Probability distribution corresponding to Fourier transform of chosen kernel.
     random_weights_ : np.ndarray, shape (n_features, n_components)
         Random weights to inner-product with features.
     random_offsets_ : np.ndarray, shape (n_features, )
@@ -106,7 +105,7 @@ class RandomFourierKernelApprox(KernelApproximation):
     Generate random Fourier features from a Gaussian kernel
 
     >>> ka = pykoop.RandomFourierKernelApprox(
-    ...     kernel_or_ift='gaussian',
+    ...     kernel_or_ft='gaussian',
     ...     n_components=10,
     ...     shape=1,
     ...     random_state=1234,
@@ -117,20 +116,20 @@ class RandomFourierKernelApprox(KernelApproximation):
     array([...])
     """
 
-    _ift_lookup = {
+    _ft_lookup = {
         'gaussian': scipy.stats.norm,
         'laplacian': scipy.stats.cauchy,
         'cauchy': scipy.stats.laplace,
     }
-    """Lookup table for inverse Fourier transform of kernel.
+    """Lookup table for Fourier transform of kernel.
 
     Laplacian and Cauchy being swapped is not a typo. They are Fourier
     transforms of each other.
     """
 
     def __init__(
         self,
-        kernel_or_ift: Union[str, scipy.stats.rv_continuous] = 'gaussian',
+        kernel_or_ft: Union[str, scipy.stats.rv_continuous] = 'gaussian',
         n_components: int = 100,
         shape: float = 1,
         method: str = 'weight_offset',
@@ -140,19 +139,19 @@ def __init__(
 
         Parameters
         ----------
-        kernel_or_ift : Union[str, scipy.stats.rv_continuous]
+        kernel_or_ft : Union[str, scipy.stats.rv_continuous]
             Kernel to approximate. Possible options are
 
-                - ``'gaussian'`` -- Gaussian kernel, with inverse Fourier
-                  transform :class:`scipy.stats.norm` (default),
-                - ``'laplacian'`` -- Laplacian kernel, with inverse Fourier
-                  transform :class:`scipy.stats.cauchy`, or
-                - ``'cauchy'`` -- Cauchy kernel, with inverse Fourier transform
-                  :class:`scipy.stats.laplace`.
+                - ``'gaussian'`` -- Gaussian kernel, with Fourier transform
+                   :class:`scipy.stats.norm` (default),
+                - ``'laplacian'`` -- Laplacian kernel, with Fourier transform
+                   :class:`scipy.stats.cauchy`, or
+                - ``'cauchy'`` -- Cauchy kernel, with Fourier transform
+                   :class:`scipy.stats.laplace`.
 
             Alternatively, a positive, shift-invariant kernel can be implicitly
-            specified by providing its inverse Fourier transform as a
-            univariate probability distribution subclassing
+            specified by providing its Fourier transform as a univariate
+            probability distribution subclassing
             :class:`scipy.stats.rv_continuous`.
 
         n_components : int
@@ -179,7 +178,7 @@ def __init__(
         random_state : Union[int, np.random.RandomState, None]
             Random seed.
         """
-        self.kernel_or_ift = kernel_or_ift
+        self.kernel_or_ft = kernel_or_ft
         self.n_components = n_components
         self.shape = shape
         self.method = method
@@ -210,11 +209,11 @@ def fit(
             If any of the constructor parameters are incorrect.
         """
         X = sklearn.utils.validation.check_array(X)
-        # Set inverse Fourier transform
-        if isinstance(self.kernel_or_ift, str):
-            self.ift_ = self._ift_lookup[self.kernel_or_ift]
+        # Set Fourier transform
+        if isinstance(self.kernel_or_ft, str):
+            self.ft_ = self._ft_lookup[self.kernel_or_ft]
         else:
-            self.ift_ = self.kernel_or_ift
+            self.ft_ = self.kernel_or_ft
         # Validate input
         if self.n_components <= 0:
             raise ValueError('`n_components` must be positive.')
@@ -230,7 +229,7 @@ def fit(
         else:
             self.n_features_out_ = self.n_components
         # Generate random weights
-        self.random_weights_ = self.ift_.rvs(
+        self.random_weights_ = self.ft_.rvs(
             scale=1,
             size=(self.n_features_in_, self.n_components),
             random_state=self.random_state,
@@ -249,7 +248,7 @@ def fit(
         # Easiest way to make sure distribution is univariate is to check the
         # dimension of the output.
         if self.random_weights_.ndim != 2:
-            raise ValueError('`kernel_or_ift` must specify a univariate '
+            raise ValueError('`kernel_or_ft` must specify a univariate '
                              'probability distribution.')
         return self
 

pykoop/koopman_pipeline.py

@@ -9,7 +9,6 @@
 import sklearn.base
 import sklearn.exceptions
 import sklearn.metrics
-from deprecated import deprecated
 from matplotlib import pyplot as plt
 from scipy import linalg
 
@@ -2410,88 +2409,6 @@ def score(self, X: np.ndarray, y: Optional[np.ndarray] = None) -> float:
         score = scorer(self, X, None)
         return score
 
-    @deprecated('Use `predict_trajectory` instead')
-    def predict_multistep(self, X: np.ndarray) -> np.ndarray:
-        """Perform a multi-step prediction for the first state of each episode.
-
-        This function takes the first ``min_samples_`` states of the input,
-        along with all of its inputs, and predicts the next ``X.shape[0]``
-        states of the system. This action is performed on a per-episode basis.
-        The state features of ``X`` (other than the first ``min_samples_``
-        features) are not used at all.
-
-        If prediction fails numerically, missing predictions are filled with
-        ``np.nan``.
-
-        Parameters
-        ----------
-        X : np.ndarray
-            Data matrix.
-
-        Returns
-        -------
-        np.ndarray
-            Predicted data matrix.
-
-        Raises
-        ------
-        ValueError
-            If an episode is shorter than ``min_samples_``.
-
-        Warning
-        -------
-        Deprecated in favour of
-        :func:`pykoop.KoopmanPipeline.predict_trajectory`.
-
-        """
-        sklearn.utils.validation.check_is_fitted(self, 'regressor_fit_')
-        X = sklearn.utils.validation.check_array(X, **self._check_array_params)
-        # Split episodes
-        episodes = split_episodes(X, episode_feature=self.episode_feature_)
-        # Loop over episodes
-        predictions = []
-        for (i, X_i) in episodes:
-            # Check length of episode.
-            if X_i.shape[0] < self.min_samples_:
-                raise ValueError(f'Episode {i} has {X_i.shape[0]} samples but '
-                                 f'`min_samples_`={self.min_samples_} samples '
-                                 'are required.')
-            # Index where prediction blows up (if it does)
-            crash_index = None
-            # Extract initial state and input
-            x0 = X_i[:self.min_samples_, :self.n_states_in_]
-            u = X_i[:, self.n_states_in_:]
-            # Create array to hold predicted states
-            X_pred_i = np.zeros((X_i.shape[0], self.n_states_in_))
-            # Set the initial condition
-            X_pred_i[:self.min_samples_, :] = x0
-            # Predict all time steps
-            for k in range(self.min_samples_, X_i.shape[0]):
-                # Stack episode feature, previous predictions, and input
-                X_ik = combine_episodes(
-                    [(i,
-                      np.hstack((
-                          X_pred_i[(k - self.min_samples_):k, :],
-                          X_i[(k - self.min_samples_):k, self.n_states_in_:],
-                      )))],
-                    episode_feature=self.episode_feature_)
-                # Predict next step
-                try:
-                    X_pred_ik = self.predict(X_ik)[[-1], :]
-                except ValueError:
-                    crash_index = k
-                    break
-                # Extract data matrix from prediction
-                X_pred_i[[k], :] = split_episodes(
-                    X_pred_ik, episode_feature=self.episode_feature_)[0][1]
-            if crash_index is not None:
-                X_pred_i[crash_index:, :] = np.nan
-            predictions.append((i, X_pred_i))
-        # Combine episodes
-        X_p = combine_episodes(predictions,
-                               episode_feature=self.episode_feature_)
-        return X_p
-
     def predict_trajectory(
         self,
         X0_or_X: np.ndarray,

setup.py

@@ -7,7 +7,7 @@
 
 setuptools.setup(
     name='pykoop',
-    version='1.2.4',
+    version='2.0.0',
     description=('Koopman operator identification library in Python, '
                  'compatible with `scikit-learn`'),
     long_description=readme,