Tests

Author: filippozacchei

pysindy/feature_library/weighted_weak_pde_library.py

@@ -69,7 +69,6 @@ def _build_whitener_from_variance(self):
             # corresponding weak RHS weights, flattened to 1D
             wk = np.asarray(self.fulltweights[k], dtype=float).ravel(order="C")
 
-            # ensure same length (paranoia check)
             if wk.shape[0] != lin_idx.shape[0]:
                 raise RuntimeError(
                     f"Weight/variance size mismatch on cell {k}: "
@@ -86,16 +85,14 @@ def _build_whitener_from_variance(self):
         for k in range(K):
             vk = val_lists[k]
             Cov[k, k] = np.dot(vk, vk)
-            # off-diagonals via set intersection of supports
             idx_k = idx_lists[k]
-            # Use a dict for fast overlap accumulation
+            
             map_k = dict(zip(idx_k.tolist(), vk.tolist()))
             for ell in range(k + 1, K):
                 s = 0.0
                 idx_e = idx_lists[ell]
                 v_e = val_lists[ell]
                 map_e = dict(zip(idx_e.tolist(), v_e.tolist()))
-                # iterate the smaller map
                 if len(map_k) <= len(map_e):
                     for j, vkj in map_k.items():
                         ve = map_e.get(j)
@@ -109,12 +106,10 @@ def _build_whitener_from_variance(self):
                 Cov[k, ell] = s
                 Cov[ell, k] = s
 
-        # diagonal nugget for stability
         avg_diag = np.trace(Cov) / max(K, 1)
         nugget = 1e-12 * avg_diag
         Cov.flat[:: K + 1] += nugget
 
-        # robust Cholesky with fallback if needed
         try:
             self._L_chol = np.linalg.cholesky(Cov)
         except np.linalg.LinAlgError:
@@ -126,7 +121,6 @@ def _apply_whitener(self, A):
         """Return L^{-1} A without forming L^{-1} explicitly."""
         if self._L_chol is None:
             return A
-        # solve L X = A  →  X = L^{-1} A
         return np.linalg.solve(self._L_chol, A)
 
     # ------------------------------ hooks ------------------------------

pysindy/optimizers/base.py

@@ -173,32 +173,7 @@ def fit(self, x_, y, sample_weight=None, **reduce_kws):
         y = AxesArray(np.asarray(y), y_axes)
         x_, y = drop_nan_samples(x_, y)
         x_, y = check_X_y(x_, y, accept_sparse=[], y_numeric=True, multi_output=True)
-
-        # The next scope is for when the sample weights 
-        # are different for each output component
-        # we select the weights of the each output component and 
-        # recursively fit
-        if y.ndim == 2 and sample_weight is not None and sample_weight.shape == y.shape:
-            coefs, histories, inds = [], [], []
-            n_targets = y.shape[1]
-            subs = []
-            for j in range(n_targets):
-                sw_j = sample_weight[:, j].ravel()   # flatten to 1D
-                sub = clone(self)
-                sub.fit(x_, y[:, j:j+1], sample_weight=sw_j, **reduce_kws)
-                coefs.append(sub.coef_.reshape(1, -1))
-                histories.append(sub.history_)
-                inds.append(sub.ind_.reshape(1, -1))
-                subs.append(sub)
-
-            # stack results: shape (n_targets, n_features)
-            self.coef_ = np.vstack(coefs)
-            self.ind_ = np.vstack(inds)
-            self.history_ = [self.coef_]
-            self.Theta_ = subs[0].Theta_
-            self.intercept_ = np.zeros(n_targets, dtype=self.coef_.dtype)
-            return self
-            
+          
         x, y, X_offset, y_offset, X_scale = _preprocess_data(
             x_,
             y,

test/test_expand_weights.py

@@ -0,0 +1,53 @@
+import numpy as np
+import pytest
+from pysindy import _expand_sample_weights
+
+
+class DummyTraj:
+    def __init__(self, n_time, n_coord):
+        self.n_time = n_time
+        self.n_coord = n_coord
+
+
+@pytest.fixture
+def dummy_trajs():
+    """Simple fixture for two dummy trajectories."""
+    return [DummyTraj(5, 2), DummyTraj(5, 2)]
+
+
+def test_scalar_weights_none(dummy_trajs):
+    assert _expand_sample_weights(None, dummy_trajs) is None
+
+
+def test_1d_sample_weights(dummy_trajs):
+    """1D weights per trajectory concatenate correctly."""
+    weights = [np.ones(5), 2 * np.ones(5)]
+    out = _expand_sample_weights(weights, dummy_trajs)
+    assert out.shape == (10,)
+    assert np.all(out[:5] == 1)
+    assert np.all(out[5:] == 2)
+
+
+def test_2d_per_coord_weights(dummy_trajs):
+    """2D weights (n_time, n_coord) concatenate along samples."""
+    weights = [np.ones((5, 2)), np.full((5, 2), 2.0)]
+    out = _expand_sample_weights(weights, dummy_trajs)
+    assert out.shape == (10, 2)
+    assert np.allclose(out[:5], 1)
+    assert np.allclose(out[5:], 2)
+
+
+def test_promote_1d_to_2d(dummy_trajs):
+    """1D weights promoted to (n_time, n_coord)."""
+    weights = [np.arange(5), np.arange(5)]
+    out = _expand_sample_weights(weights, dummy_trajs)
+    assert out.ndim == 1  # still flattened because all dims == 1
+
+
+def test_weak_mode_expansion(dummy_trajs):
+    """Weak mode expands by n_test_funcs."""
+    weights = [np.ones(5), np.ones(5)]
+    class DummyLib: K = 3
+    out = _expand_sample_weights(weights, dummy_trajs, feature_library=DummyLib(), mode="weak")
+    assert out.shape == (10 * 3,)
+    assert np.allclose(np.unique(out), 1)

test/test_sample_weights.py

@@ -0,0 +1,67 @@
+import numpy as np
+import pytest
+from sklearn.linear_model import LinearRegression
+from pysindy import SINDy  # adjust import to your package path
+
+
+@pytest.fixture(scope="session")
+def simple_systems():
+    """Generate two simple 2D dynamical systems:
+    System A: x' = -y, y' = x  
+    System B: x' = -2y, y' = 2x  
+    """
+    t = np.linspace(0, 2 * np.pi, 50)
+    x_a = np.stack([np.cos(t), np.sin(t)], axis=1)
+    xdot_a = np.stack([-np.sin(t), np.cos(t)], axis=1)
+
+    x_b = np.stack([np.cos(2 * t), np.sin(2 * t)], axis=1)
+    xdot_b = np.stack([-2 * np.sin(2 * t), 2 * np.cos(2 * t)], axis=1)
+
+    return (x_a, xdot_a), (x_b, xdot_b)
+
+
+def test_metadata_routing_sample_weight(simple_systems):
+    """Test that sample weights route correctly through SINDy fit().
+
+    The expected coefficients are a convex combination of the systems'
+    true coefficients, weighted by the number of trajectories and/or
+    sample weights. This verifies that behind-the-scenes routing of
+    sample_weight → optimizer.fit() works correctly.
+    """
+    (x_a, xdot_a), (x_b, xdot_b) = simple_systems
+
+    # --- Build training trajectories ---
+    # One system duplicated twice (implicit weighting)
+    X_trajs = [x_a, x_a, x_b]
+    Xdot_trajs = [xdot_a, xdot_a, xdot_b]
+
+    # --- Simple library and optimizer setup ---
+    sindy = SINDy(optimizer=LinearRegression(fit_intercept=False))
+
+    # --- Fit without explicit sample weights ---
+    sindy.fit(X_trajs, t=0.1, x_dot=Xdot_trajs)
+    coef_unweighted = np.copy(sindy.model.named_steps["model"].coef_)
+
+    # --- Fit with sample weights to emphasize trajectory 3 (different system) ---
+    sample_weight = [np.ones(len(x_a)), np.ones(len(x_a)), 10 * np.ones(len(x_b))]
+    sindy.fit(X_trajs, t=0.1, x_dot=Xdot_trajs, sample_weight=sample_weight)
+    coef_weighted = np.copy(sindy.model.named_steps["model"].coef_)
+
+    # --- Assertions ---
+    # 1. Shapes are consistent
+    assert coef_weighted.shape == coef_unweighted.shape
+
+    # 2. The coefficients must differ when weighting is applied
+    assert not np.allclose(coef_weighted, coef_unweighted)
+
+    # 3. Weighted model should bias toward system B coefficients
+    #    since trajectory B had much higher weight
+    # True systems differ by factor of 2
+    ratio = np.mean(np.abs(coef_weighted / coef_unweighted))
+    assert ratio > 1.05, "Weighted coefficients should reflect stronger influence from system B"
+
+    # 4. Convex combination logic sanity check
+    # Unweighted: (A + A + B)/3 = A * 2/3 + B * 1/3
+    # Weighted:   (A + A + 10*B)/(12) ≈ A * 2/12 + B * 10/12
+    # So weighted coefficients should be closer to B's dynamics
+    assert np.linalg.norm(coef_weighted - 2 * coef_unweighted) < np.linalg.norm(coef_unweighted)