Basis Backend Maintenance (#82)

* Basis.fit_compress() method

* update basis tests

* pragma: no cover to verify() methods

* time() -> process_time() in TimedBlock

* PODBasis handle sparse weights (w/ warning) if svdsolver='dense'

Author: shanemcq18

src/opinf/basis/_base.py

@@ -6,6 +6,7 @@
 ]
 
 import abc
+import copy
 import numpy as np
 import scipy.linalg as la
 
@@ -102,13 +103,14 @@ def compress(self, states):
         Parameters
         ----------
         states : (n, ...) ndarray
-            Matrix of `n`-dimensional state vectors, or a single state vector.
+            Matrix of :math:`n`-dimensional state vectors, or a single state
+            vector.
 
         Returns
         -------
         states_compressed : (r, ...) ndarray
-            Matrix of `r`-dimensional latent coordinate vectors, or a single
-            coordinate vector.
+            Matrix of :math:`r`-dimensional latent coordinate vectors, or a
+            single coordinate vector.
         """
         raise NotImplementedError  # pragma: no cover
 
@@ -119,20 +121,37 @@ def decompress(self, states_compressed, locs=None):
         Parameters
         ----------
         states_compressed : (r, ...) ndarray
-            Matrix of `r`-dimensional latent coordinate vectors, or a single
-            coordinate vector.
+            Matrix of :math:`r`-dimensional latent coordinate vectors, or a
+            single coordinate vector.
         locs : slice or (p,) ndarray of integers or None
             If given, return the decompressed state at *only* the
             `p` specified locations (indices) described by ``locs``.
 
         Returns
         -------
         states_decompressed : (n, ...) or (p, ...) ndarray
-            Matrix of `n`-dimensional decompressed state vectors, or the `p`
-            entries of such at the entries specified by ``locs``.
+            Matrix of :math:`n`-dimensional decompressed state vectors, or the
+            :math:`p` entries of such at the entries specified by ``locs``.
         """
         raise NotImplementedError  # pragma: no cover
 
+    def fit_compress(self, states):
+        """Construct the basis and map high-dimensional states to
+        low-dimensional latent coordinates.
+
+        Parameters
+        ----------
+        states : (n, k) ndarray
+            Matrix of :math:`k` :math:`n`-dimensional snapshots.
+
+        Returns
+        -------
+        states_compressed : (r, k) ndarray
+            Matrix of :math:`r`-dimensional latent coordinate vectors.
+        """
+        self.fit(states)
+        return self.compress(states)
+
     # Projection --------------------------------------------------------------
     def project(self, state):
         """Project a high-dimensional state vector to the subset of the
@@ -150,13 +169,14 @@ def project(self, state):
         Parameters
         ----------
         states : (n, ...) ndarray
-            Matrix of `n`-dimensional state vectors, or a single state vector.
+            Matrix of :math:`n`-dimensional state vectors, or a single state
+            vector.
 
         Returns
         -------
         state_projected : (n, ...) ndarray
-            Matrix of `n`-dimensional projected state vectors, or a single
-            projected state vector.
+            Matrix of :math:`n`-dimensional projected state vectors, or a
+            single projected state vector.
         """
         return self.decompress(self.compress(state))
 
@@ -202,8 +222,12 @@ def load(cls, loadfile: str):
         """Load a transformer from an HDF5 file."""
         raise NotImplementedError("use pickle/joblib")  # pragma: no cover
 
+    def copy(self):
+        """Make a copy of the basis."""
+        return copy.deepcopy(self)
+
     # Verification ------------------------------------------------------------
-    def verify(self):
+    def verify(self):  # pragma: no cover
         """Verify that :meth:`compress()` and :meth:`decompress()` are
         consistent in the sense that the range of :meth:`decompress()` is in
         the domain of :meth:`compress()` and that :meth:`project()` defines
@@ -247,7 +271,9 @@ def verify(self):
             )
         print("compress() and decompress() are consistent")
 
-    def _verify_locs(self, states_compressed, states_projected):
+    def _verify_locs(
+        self, states_compressed, states_projected
+    ):  # pragma: no cover
         """Verification of decompress() with locs != None."""
         n = states_projected.shape[0]
         locs = np.sort(np.random.choice(n, size=(n // 3), replace=False))

src/opinf/basis/_pod.py

@@ -293,6 +293,14 @@ def __init__(
             if weights.ndim == 1:
                 self.__sqrt_weights = np.sqrt(weights)
             else:  # (weights.ndim == 2, checked by LinearBasis)
+                if sparse.issparse(weights):
+                    weights = weights.toarray()
+                if weights.shape[0] > 100:  # pragma: no cover
+                    warnings.warn(
+                        "computing the square root of a large weight matrix, "
+                        "consider using svdsolver='method-of-snapshots'",
+                        errors.OpInfWarning,
+                    )
                 self.__sqrt_weights = la.sqrtm(weights)
                 self.__sqrt_weights_cho = la.cho_factor(self.__sqrt_weights)
 

src/opinf/ddt/_base.py

@@ -174,7 +174,7 @@ def mask(self, arr):
         raise NotImplementedError  # pragma: no cover
 
     # Verification ------------------------------------------------------------
-    def verify_shapes(self, r: int = 5, m: int = 3):
+    def verify_shapes(self, r: int = 5, m: int = 3):  # pragma: no cover
         """Verify that :meth:`estimate()` is consistent in the sense that the
         all outputs have the same number of columns. This method does **not**
         check the accuracy of the derivative estimation.

src/opinf/lstsq/_base.py

@@ -296,7 +296,7 @@ def copy(self):
         return copy.deepcopy(self)
 
     # Verification ------------------------------------------------------------
-    def verify(self):
+    def verify(self):  # pragma: no cover
         """Verify the solver.
 
         If the solver is already trained, check :meth:`solve()`,

src/opinf/operators/_base.py

@@ -230,7 +230,7 @@ def verify(
         k: int = 10,
         fdifftol: float = 1e-5,
         ntests: int = 4,
-    ) -> None:
+    ) -> None:  # pragma: no cover
         """Verify consistency between dimension properties and required
         methods.
 
@@ -827,7 +827,7 @@ def verify(
         ntests: int = 4,
         r: int = 6,
         m: int = 3,
-    ) -> None:
+    ) -> None:  # pragma: no cover
         """Verify consistency between dimension properties and required
         methods.
 

src/opinf/pre/_base.py

@@ -229,7 +229,7 @@ def load(cls, loadfile):
         raise NotImplementedError("use pickle/joblib")  # pragma: no cover
 
     # Verification ------------------------------------------------------------
-    def verify(self, tol: float = 1e-4):
+    def verify(self, tol: float = 1e-4):  # pragma: no cover
         r"""Verify that :meth:`transform()` and :meth:`inverse_transform()`
         are consistent and that :meth:`transform_ddts()`, if implemented,
         is consistent with :meth:`transform()`.
@@ -333,7 +333,7 @@ def verify(self, tol: float = 1e-4):
             )
         print("transform() and transform_ddts() are consistent")
 
-    def _verify_locs(self, states, states_transformed):
+    def _verify_locs(self, states, states_transformed):  # pragma: no cover
         """Verification for inverse_transform() with locs != None"""
         n = states.shape[0]
         locs = np.sort(np.random.choice(n, size=(n // 3), replace=False))

src/opinf/roms/_base.py

@@ -404,6 +404,7 @@ def _process_training_data(
         # Dimensionality reduction.
         if self.basis is not None:
             if fit_basis:
+                # NOTE: self.basis.fit_compress() here?
                 self.basis.fit(np.hstack(states))
             states = [self.basis.compress(Q) for Q in states]
             if lhs is not None:
@@ -734,7 +735,7 @@ def training_error(reg_params):
             """
             try:
                 update_model(reg_params)
-            except Exception as ex:
+            except Exception as ex:  # pragma: no cover
                 if verbose:
                     print(f"{type(ex).__name__} in refit(): {ex}")
                 return np.inf
@@ -947,7 +948,7 @@ def training_error(reg_params):
             """
             try:
                 update_model(reg_params)
-            except Exception as ex:
+            except Exception as ex:  # pragma: no cover
                 if verbose:
                     print(f"{type(ex).__name__} in refit(): {ex}")
                 return np.inf

src/opinf/utils/_timer.py

@@ -139,15 +139,15 @@ def __enter__(self):
             sys.stdout = self.__new_buffer = io.StringIO()
         if self.verbose:
             print(f"{self.message}...", end=self.__front, flush=True)
-        self._tic = time.time()
+        self._tic = time.process_time()
         if self.timelimit is not None:
             signal.signal(signal.SIGALRM, self._signal_handler)
             signal.alarm(self.timelimit)
         return self
 
     def __exit__(self, exc_type, exc_value, exc_traceback):
         """Calculate and report the elapsed time."""
-        self._toc = time.time()
+        self._toc = time.process_time()
         if self.timelimit is not None:
             signal.alarm(0)
         elapsed = self._toc - self._tic
@@ -170,7 +170,7 @@ def __exit__(self, exc_type, exc_value, exc_traceback):
                 self._reset_stdout()
             raise
         else:  # If no exception, report execution time.
-            if self.verbose:
+            if self.verbose and self.message:
                 print(f"done in {elapsed:.2f} s.", flush=True, end=self.__back)
             logging.info(f"{self.message}...done in {elapsed:.6f} s.")
         self.__elapsed = elapsed