Merge pull request #25 from niharika2999/Add_tests

Added tests to up the coverage to 95%

Author: yb6599

pysensors/optimizers/__init__.py

@@ -1,4 +1,4 @@
-from ._ccqr import CCQR
+from ._ccqr import CCQR, qr_reflector
 from ._gqr import GQR
 from ._qr import QR
 

tests/basis/test_basis.py

@@ -6,7 +6,7 @@
 import pytest
 from sklearn.exceptions import NotFittedError
 
-from pysensors.basis import SVD, Identity, RandomProjection
+from pysensors.basis import SVD, Custom, Identity, RandomProjection, _base
 
 
 @pytest.mark.parametrize("basis", [Identity(), SVD(), RandomProjection()])
@@ -75,7 +75,6 @@ def test_extra_basis_modes(basis, data_random):
     data = data_random
     n_basis_modes = data.shape[0] + 1
     b = basis(n_basis_modes=n_basis_modes)
-    # Can't have more basis modes than the number of training examples
     with pytest.raises(ValueError):
         b.fit(data)
 
@@ -90,3 +89,160 @@ def test_matrix_inverse_shape(basis, data_random):
     inverse = basis.matrix_inverse(n_basis_modes=n_basis_modes)
 
     assert inverse.shape == (n_basis_modes, n_features)
+
+
+@pytest.fixture
+def sample_basis():
+    """Create a sample basis matrix for testing."""
+    return np.eye(5)
+
+
+def test_valid_n_basis_modes(sample_basis):
+    """Test initialization with valid n_basis_modes."""
+    custom = Custom(U=sample_basis, n_basis_modes=3)
+    assert custom._n_basis_modes == 3
+    np.testing.assert_array_equal(custom.custom_basis_, sample_basis)
+
+    custom = Custom(U=sample_basis, n_basis_modes=1)
+    assert custom._n_basis_modes == 1
+
+
+@pytest.mark.parametrize("value", [3.5, "3", [3], (3,), None])
+def test_n_basis_modes_not_integer(sample_basis, value):
+    """Test initialization with non-integer n_basis_modes."""
+    with pytest.raises(ValueError) as excinfo:
+        Custom(U=sample_basis, n_basis_modes=value)
+    assert "n_basis_modes must be a positive integer" in str(excinfo.value)
+
+
+@pytest.mark.parametrize("value", [0, -1, -10])
+def test_n_basis_modes_not_positive(sample_basis, value):
+    """Test initialization with non-positive n_basis_modes."""
+    with pytest.raises(ValueError) as excinfo:
+        Custom(U=sample_basis, n_basis_modes=value)
+    assert "n_basis_modes must be a positive integer" in str(excinfo.value)
+
+
+def test_with_keyword_arguments(sample_basis):
+    """Test initialization with additional keyword arguments."""
+    custom = Custom(
+        U=sample_basis, n_basis_modes=3, extra_param=True, another_param="value"
+    )
+    assert custom._n_basis_modes == 3
+
+
+@pytest.fixture
+def custom_instance(sample_basis):
+    """Create an initialized Custom instance for testing."""
+    return Custom(U=sample_basis, n_basis_modes=3)
+
+
+def test_fit_method(custom_instance, sample_basis):
+    """Test that fit correctly sets basis_matrix_ and returns self."""
+    result = custom_instance.fit()
+    expected_basis_matrix = sample_basis[:, :3]
+    np.testing.assert_array_equal(custom_instance.basis_matrix_, expected_basis_matrix)
+    assert result is custom_instance
+
+
+def test_matrix_inverse_default(custom_instance):
+    """Test matrix_inverse with default n_basis_modes."""
+    custom_instance.fit()
+    result = custom_instance.matrix_inverse()
+    expected_result = custom_instance.basis_matrix_.T
+    np.testing.assert_array_equal(result, expected_result)
+
+
+@pytest.mark.parametrize("n_modes", [1, 2])
+def test_matrix_inverse_with_n_basis_modes(custom_instance, n_modes):
+    """Test matrix_inverse with specified n_basis_modes."""
+    custom_instance.fit()
+    result = custom_instance.matrix_inverse(n_basis_modes=n_modes)
+    expected_result = custom_instance.basis_matrix_[:, :n_modes].T
+    np.testing.assert_array_equal(result, expected_result)
+    assert result.shape == (n_modes, 5)
+
+
+def test_n_basis_modes_getter(custom_instance):
+    """Test n_basis_modes property getter."""
+    assert custom_instance.n_basis_modes == 3
+    custom_instance._n_basis_modes = 4
+    assert custom_instance.n_basis_modes == 4
+
+
+def test_n_basis_modes_setter(custom_instance):
+    """Test n_basis_modes property setter."""
+    custom_instance.n_basis_modes = 2
+    assert custom_instance._n_basis_modes == 2
+    assert custom_instance.n_components == 2
+
+    custom_instance.n_basis_modes = 4
+    assert custom_instance._n_basis_modes == 4
+    assert custom_instance.n_components == 4
+
+
+def test_matrix_inverse_calls_validate_input(custom_instance, monkeypatch):
+    """Test that matrix_inverse calls _validate_input."""
+    custom_instance.fit()
+    validation_called = False
+    test_value = None
+
+    def mock_validate_input(self, value):
+        nonlocal validation_called, test_value
+        validation_called = True
+        test_value = value
+        return 2
+
+    monkeypatch.setattr(Custom, "_validate_input", mock_validate_input)
+    custom_instance.matrix_inverse(n_basis_modes=3)
+    assert validation_called
+    assert test_value == 3
+
+
+def test_invertible_basis_abstract_method():
+    class TestBasis(_base.InvertibleBasis):
+        pass
+
+    with pytest.raises(TypeError, match="Can't instantiate abstract class TestBasis"):
+        TestBasis()
+
+    class ProperTestBasis(_base.InvertibleBasis):
+        def matrix_inverse(self, n_basis_modes=None, **kwargs):
+            return None
+
+    with pytest.raises(
+        NotImplementedError, match="This method has not been implemented"
+    ):
+        _base.InvertibleBasis.matrix_inverse(None)
+
+
+def test_validate_input_too_many_modes_error():
+    basis = SVD()
+    n_available_modes = 5
+    basis.basis_matrix_ = np.random.rand(10, n_available_modes)
+    basis.n_basis_modes = n_available_modes
+    too_many_modes = 8
+
+    expected_error = (
+        f"Requested number of modes {too_many_modes} exceeds"
+        f" number available: {n_available_modes}"
+    )
+
+    with pytest.raises(ValueError, match=expected_error):
+        basis._validate_input(n_basis_modes=too_many_modes)
+
+
+def test_matrix_representation_copy():
+    basis = SVD()
+    n_features = 10
+    n_basis_modes = 5
+    basis.basis_matrix_ = np.random.rand(n_features, n_basis_modes)
+    result_copy = basis.matrix_representation(n_basis_modes=3, copy=True)
+    np.testing.assert_array_equal(result_copy, basis.basis_matrix_[:, :3])
+    original_value = basis.basis_matrix_[0, 0]
+    result_copy[0, 0] = 999
+    assert basis.basis_matrix_[0, 0] == original_value
+    result_view = basis.matrix_representation(n_basis_modes=3, copy=False)
+    np.testing.assert_array_equal(result_view, basis.basis_matrix_[:, :3])
+    result_view[0, 0] = 777
+    assert basis.basis_matrix_[0, 0] == 777

tests/classification/test_sspoc.py

@@ -1,5 +1,7 @@
 """Tests for SSPOC class."""
 
+from unittest.mock import Mock
+
 import numpy as np
 import pytest
 from pytest_lazyfixture import lazy_fixture
@@ -31,8 +33,6 @@ def data_multiclass_classification():
 def test_not_fitted(data_binary_classification):
     x, y, _ = data_binary_classification
     model = SSPOC()
-
-    # Shouldn't be able to call any of these methods before fitting
     with pytest.raises(NotFittedError):
         model.predict(x)
     with pytest.raises(NotFittedError):
@@ -271,3 +271,176 @@ def test_sspoc_selector_equivalence(data_multiclass_classification):
     model = SSPOC().fit(x, y)
 
     np.testing.assert_array_equal(model.get_selected_sensors(), model.selected_sensors)
+
+
+@pytest.fixture
+def sspoc_instance():
+    """Create a mock SSPOC instance with refit=False."""
+    sspoc = SSPOC()
+    sspoc.refit_ = False
+    sspoc.n_sensors = 3
+    sspoc.basis_matrix_inverse_ = np.array(
+        [[0.1, 0.2, 0.3], [0.4, 0.5, 0.6], [0.7, 0.8, 0.9]]
+    )
+    sspoc.classifier = Mock()
+    sspoc.classifier.predict.return_value = np.array([0, 1, 0])
+    sspoc.sensor_coef_ = np.array([1, 2, 3])
+
+    return sspoc
+
+
+def test_predict_with_refit_false(sspoc_instance):
+    """Test predict method when refit is False."""
+    X_test = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]])
+    expected_transformed_input = np.dot(X_test, sspoc_instance.basis_matrix_inverse_.T)
+    result = sspoc_instance.predict(X_test)
+    sspoc_instance.classifier.predict.assert_called_once()
+    actual_arg = sspoc_instance.classifier.predict.call_args[0][0]
+    np.testing.assert_array_almost_equal(actual_arg, expected_transformed_input)
+    assert np.array_equal(result, np.array([0, 1, 0]))
+
+
+def test_predict_with_refit_true(sspoc_instance):
+    """Test predict method when refit is True."""
+    sspoc_instance.refit_ = True
+    X_test = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]])
+    result = sspoc_instance.predict(X_test)
+    sspoc_instance.classifier.predict.assert_called_once_with(X_test)
+    assert np.array_equal(result, np.array([0, 1, 0]))
+
+
+def test_predict_with_zero_sensors():
+    """Test predict method when n_sensors is 0."""
+    sspoc = SSPOC()
+    sspoc.n_sensors = 0
+    sspoc.sensor_coef_ = np.array([])
+    sspoc.dummy_ = Mock()
+    sspoc.dummy_.predict.return_value = np.array([1, 1, 1])
+
+    X_test = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]])
+    with pytest.warns(UserWarning, match="SSPOC model has no selected sensors"):
+        sspoc.predict(X_test)
+    sspoc.dummy_.predict.assert_called_once()
+    np.testing.assert_array_equal(sspoc.dummy_.predict.call_args[0][0], X_test[:, 0])
+
+
+@pytest.fixture
+def sspoc_mock():
+    """Create a mock SSPOC instance that will actually trigger the warning."""
+    sspoc = SSPOC()
+    sspoc.sensor_coef_ = np.array([0.9, 0.8, 0.0, 0.3, 0.2])
+    sspoc.classifier = Mock()
+
+    def custom_update(
+        n_sensors=None,
+        threshold=None,
+        xy=None,
+        quiet=False,
+        method=np.max,
+        **method_kws,
+    ):
+        if n_sensors is not None:
+            sorted_indices = np.argsort(-np.abs(sspoc.sensor_coef_))
+            print(f"Sorted indices: {sorted_indices}")
+            print(f"n_sensors-1 index: {sorted_indices[n_sensors - 1]}")
+            print(
+                f"Value at index: {sspoc.sensor_coef_[sorted_indices[n_sensors - 1]]}"
+            )
+            print(
+                f"Is 0?{np.abs(sspoc.sensor_coef_[sorted_indices[n_sensors - 1]]) == 0}"
+            )
+        original = sspoc.update_sensors
+        return original(n_sensors, threshold, xy, quiet, method, **method_kws)
+
+    return sspoc
+
+
+@pytest.fixture
+def sspoc_multiclass_mock():
+    """Create a mock SSPOC instance for multiclass case that will trigger warning."""
+    sspoc = SSPOC()
+    sspoc.sensor_coef_ = np.array(
+        [
+            [0.9, 0.8, 0.7],
+            [0.6, 0.5, 0.4],
+            [0.0, 0.0, 0.0],
+            [0.2, 0.1, 0.3],
+            [0.05, 0.04, 0.03],
+        ]
+    )
+    sspoc.classifier = Mock()
+    return sspoc
+
+
+def test_warning_when_threshold_too_high(sspoc_mock):
+    """Test warning when threshold is set too high and no sensors are selected."""
+    with pytest.warns(UserWarning, match="Threshold set too high.*no sensors selected"):
+        sspoc_mock.update_sensors(threshold=1.0)
+    assert len(sspoc_mock.sparse_sensors_) == 0
+    assert sspoc_mock.n_sensors == 0
+
+
+def test_warning_when_no_sensors_selected_for_refit(sspoc_mock):
+    """Test warning when trying to refit with no sensors selected."""
+    X = np.random.rand(10, 5)
+    y = np.random.randint(0, 2, 10)
+
+    with pytest.warns(UserWarning, match="No selected sensors; model was not refit"):
+        sspoc_mock.update_sensors(threshold=1.0, xy=(X, y))
+    sspoc_mock.classifier.fit.assert_not_called()
+
+
+def test_warning_when_both_n_sensors_and_threshold_provided(sspoc_mock):
+    """Test that warning is issued when both n_sensors and threshold are provided."""
+    with pytest.warns(
+        UserWarning,
+        match="Both n_sensors.*and threshold.*were passed so threshold will be ignored",
+    ):
+        sspoc_mock.update_sensors(n_sensors=2, threshold=0.4)
+
+
+def test_update_sensors_too_many_sensors_error():
+    n_available_sensors = 10
+    model = SSPOC()
+    model.sensor_coef_ = np.random.rand(n_available_sensors)
+    too_many_sensors = n_available_sensors + 5
+
+    expected_error = (
+        f"n_sensors\\({too_many_sensors}\\) cannot exceed number of "
+        f"available sensors \\({n_available_sensors}\\)"
+    )
+
+    with pytest.raises(ValueError, match=expected_error):
+        model.update_sensors(n_sensors=too_many_sensors)
+
+
+def test_uninformative_sensors_warning():
+    n_available_sensors = 10
+    n_sensors_to_select = 6
+    model = SSPOC()
+    sensor_coef = np.zeros(n_available_sensors)
+    sensor_coef[:5] = np.random.rand(5)
+    sensor_coef[:5] = -np.sort(-np.abs(sensor_coef[:5]))
+    model.sensor_coef_ = sensor_coef
+    with pytest.warns(
+        UserWarning,
+        match="Some uninformative sensors were selected. Consider decreasing n_sensors",
+    ):
+        model.update_sensors(n_sensors=n_sensors_to_select)
+
+
+def test_uninformative_sensors_multiclass_warning():
+    n_available_sensors = 10
+    n_classes = 3
+    n_sensors_to_select = 6
+    model = SSPOC()
+    sensor_coef = np.zeros((n_available_sensors, n_classes))
+    sensor_coef[:5, :] = np.random.rand(5, n_classes)
+    for i in range(5):
+        sensor_coef[i, :] = np.abs(sensor_coef[i, :]) + 0.5
+    model.sensor_coef_ = sensor_coef
+    with pytest.warns(
+        UserWarning,
+        match="Some uninformative sensors were selected. Consider decreasing n_sensors",
+    ):
+        model.update_sensors(n_sensors=n_sensors_to_select, method=np.mean)