pysips 0.0.0__py3-none-any.whl

tests/unit/test_prior.py

@@ -0,0 +1,135 @@
+import pytest
+import numpy as np
+
+# Import the class to test
+from pysips.prior import Prior, MAX_REPEATS
+
+
+IMPORTMODULE = Prior.__module__
+
+
+class TestPrior:
+
+    @pytest.fixture
+    def mock_generator(self, mocker):
+        """Create a mock generator function"""
+        generator = mocker.MagicMock()
+
+        # Generate unique values when called
+        models = ["model1", "model2", "model3", "model4", "model5"]
+        generator.side_effect = models
+
+        return generator, models
+
+    def test_rvs_returns_correct_number_of_models(self, mock_generator, mocker):
+        """Test rvs returns the requested number of models"""
+        generator, models = mock_generator
+
+        prior = Prior(generator)
+
+        # Request 3 models
+        result = prior.rvs(3)
+
+        # Check generator called enough times
+        assert generator.call_count == 3
+
+        # Check correct shape and content
+        assert result.shape == (3, 1)
+        print(result)
+        assert set(result.flatten()) == set(models[:3])
+
+    def test_rvs_handles_duplicates(self, mocker):
+        """Test rvs correctly handles duplicate models from generator"""
+        # Create generator that sometimes returns duplicates
+        generator = mocker.MagicMock()
+        generator.side_effect = ["model1", "model2", "model2", "model3", "model4"]
+
+        prior = Prior(generator)
+
+        # Request 4 unique models (will need 5 calls due to duplicate)
+        result = prior.rvs(4)
+
+        # Check generator called enough times to get 4 unique models
+        assert generator.call_count == 5
+
+        # Check correct shape and content (should be 4 unique models)
+        assert result.shape == (4, 1)
+        assert set(result.flatten()) == {"model1", "model2", "model3", "model4"}
+
+    @pytest.mark.parametrize("N", [0, 1, 5, 10])
+    def test_rvs_with_various_sizes(self, mocker, N):
+        """Test rvs with different values of N"""
+        # Create generator that returns unique models
+        counter = [0]
+
+        def gen_unique_models():
+            counter[0] += 1
+            return f"model_{counter[0]}"
+
+        generator = mocker.MagicMock(side_effect=gen_unique_models)
+
+        prior = Prior(generator)
+
+        # Request N models
+        result = prior.rvs(N)
+
+        # Check generator called correct number of times
+        assert generator.call_count == N
+
+        # Check result has correct shape
+        assert result.shape == (N, 1)
+
+        # Check all models are unique
+        if N > 0:
+            unique_models = set(result.flatten())
+            assert len(unique_models) == N
+
+    def test_warning_issued_for_excessive_repeats(self, mocker):
+        """Test that a warning is issued when MAX_REPEATS consecutive duplicates occur"""
+        # Create generator that returns the same model repeatedly
+        generator = mocker.MagicMock()
+
+        # First returns "model1", then MAX_REPEATS duplicates, then "model2"
+        generator.side_effect = ["model1"] + ["model1"] * MAX_REPEATS + ["model2"]
+
+        prior = Prior(generator)
+
+        # Request 2 models, should get a warning due to MAX_REPEATS consecutive duplicates
+        with pytest.warns(
+            UserWarning, match=f"Generator called {MAX_REPEATS} times in a row"
+        ):
+            result = prior.rvs(2)
+
+        # Should eventually generate 2 models
+        assert result.shape == (2, 1)
+        assert (
+            generator.call_count == MAX_REPEATS + 2
+        )  # 1 unique + MAX_REPEATS duplicates + 1 more unique
+
+        # Verify we got the expected unique models
+        assert set(result.flatten()) == {"model1", "model2"}
+
+    def test_warning_issued_only_once(self, mocker):
+        """Test that the warning is issued only once per rvs call"""
+        # Create generator with many duplicates
+        generator = mocker.MagicMock()
+
+        # First "model1", then 2*MAX_REPEATS duplicates of "model1", then "model2"
+        generator.side_effect = ["model1"] + ["model1"] * (2 * MAX_REPEATS) + ["model2"]
+        prior = Prior(generator)
+
+        # Should see exactly 1 warning despite having 2*MAX_REPEATS duplicates
+        with pytest.warns(UserWarning) as record:
+            result = prior.rvs(2)
+
+        # Verify we got exactly 1 warning
+        assert len(record) == 1
+
+        # Verify the warning has the expected message
+        assert f"Generator called {MAX_REPEATS} times in a row" in str(
+            record[0].message
+        )
+
+        # Verify we got the 2 unique models
+        assert result.shape == (2, 1)
+        assert set(result.flatten()) == {"model1", "model2"}

tests/unit/test_random_choice_proposal.py

@@ -0,0 +1,136 @@
+import pytest
+import numpy as np
+
+from pysips.random_choice_proposal import RandomChoiceProposal
+
+
+class TestRandomChoiceProposal:
+
+    @pytest.fixture
+    def mock_model(self, mocker):
+        """Create a mock model for testing"""
+        return mocker.MagicMock()
+
+    @pytest.fixture
+    def mock_proposals(self, mocker):
+        """Create mock proposals for testing"""
+        prop1 = mocker.MagicMock(name="proposal1")
+        prop1.return_value = mocker.MagicMock(name="result1")
+
+        prop2 = mocker.MagicMock(name="proposal2")
+        prop2.return_value = mocker.MagicMock(name="result2")
+
+        prop3 = mocker.MagicMock(name="proposal3")
+        prop3.return_value = mocker.MagicMock(name="result3")
+
+        return [prop1, prop2, prop3]
+
+    @pytest.fixture
+    def probabilities(self):
+        """Create probabilities for testing"""
+        return [0.2, 0.5, 0.3]
+
+    def test_initialization(self, mock_proposals, probabilities, mocker):
+        """Test proper initialization of RandomChoiceProposal"""
+        # Mock numpy random
+        mock_random = mocker.patch("numpy.random.default_rng")
+
+        seed = 42
+        _ = RandomChoiceProposal(
+            mock_proposals, probabilities, exclusive=True, seed=seed
+        )
+        mock_random.assert_called_once_with(seed)
+
+    def test_update_method(self, mock_proposals, probabilities, mocker):
+        """Test update method calls update on all proposals"""
+        # Initialize proposal
+        proposal = RandomChoiceProposal(mock_proposals, probabilities)
+
+        # Call update with args and kwargs
+        test_args = ["arg1", "arg2"]
+        test_kwargs = {"key1": "value1", "key2": "value2"}
+        proposal.update(*test_args, **test_kwargs)
+
+        # Assertions - each proposal should have update called with same args/kwargs
+        for mock_prop in mock_proposals:
+            mock_prop.update.assert_called_once_with(*test_args, **test_kwargs)
+
+    def test_call_exclusive_mode(
+        self, mock_proposals, probabilities, mock_model, mocker
+    ):
+        """Test __call__ method in exclusive mode selects one proposal and applies it"""
+        # Mock RNG to control which proposal is selected
+        mock_rng = mocker.MagicMock()
+        mock_rng.random.return_value = 0.5  # Will select proposals[1] (0.2 < 0.5 < 0.7)
+
+        # Initialize proposal with mocked RNG
+        proposal = RandomChoiceProposal(mock_proposals, probabilities, exclusive=True)
+        proposal._rng = mock_rng
+
+        # Call the proposal
+        result = proposal(mock_model)
+
+        # Assertions
+        mock_proposals[1].assert_called_once_with(mock_model)
+
+        # Only the selected proposal should be called
+        mock_proposals[0].assert_not_called()
+        mock_proposals[2].assert_not_called()
+
+        # Result should be the output of the selected proposal
+        assert result == mock_proposals[1].return_value
+
+    def test_call_non_exclusive_mode(
+        self, mock_proposals, probabilities, mock_model, mocker
+    ):
+        """Test __call__ method in non-exclusive mode can select multiple proposals"""
+        # Mock RNG to make proposals 0 and 2 be selected
+        mock_rng = mocker.MagicMock()
+        # For each proposal: [0:True, 1:False, 2:True]
+        mock_rng.random.side_effect = [0.1, 0.9, 0.1]  # < prob = select, > prob = skip
+        # Prevent random shuffling for predictable testing
+        mock_rng.shuffle.side_effect = lambda x: None
+
+        # Initialize proposal with mocked RNG
+        proposal = RandomChoiceProposal(mock_proposals, probabilities, exclusive=False)
+        proposal._rng = mock_rng
+
+        # Call the proposal
+        result = proposal(mock_model)
+
+        # Assertions - first proposal should be called with original model
+        mock_proposals[0].assert_called_once_with(mock_model)
+
+        # Second proposal should not be called
+        mock_proposals[1].assert_not_called()
+
+        # Third proposal should be called with result from first proposal
+        mock_proposals[2].assert_called_once_with(mock_proposals[0].return_value)
+
+        # Result should be the output of the last applied proposal
+        assert result == mock_proposals[2].return_value
+
+    def test_call_non_exclusive_empty_first_round(
+        self, mock_proposals, probabilities, mock_model, mocker
+    ):
+        """Test __call__ in non-exclusive mode retries if no proposals are selected initially"""
+        # Mock RNG to reject all on first pass, then select one on second pass
+        mock_rng = mocker.MagicMock()
+        # First round: all above threshold (none selected)
+        # Second round: select proposal 0
+        mock_rng.random.side_effect = [0.9, 0.9, 0.9, 0.1, 0.9, 0.9]
+
+        # Initialize proposal
+        proposal = RandomChoiceProposal(mock_proposals, probabilities, exclusive=False)
+        proposal._rng = mock_rng
+
+        # Call the proposal
+        result = proposal(mock_model)
+
+        # Assertions
+        mock_proposals[0].assert_called_once_with(mock_model)
+        mock_proposals[1].assert_not_called()
+        mock_proposals[2].assert_not_called()
+
+        # Result should be the output of the selected proposal
+        assert result == mock_proposals[0].return_value

tests/unit/test_regressor.py

@@ -0,0 +1,227 @@
+import pytest
+import numpy as np
+from unittest.mock import MagicMock
+from pytest_mock import MockerFixture
+
+from pysips.regressor import PysipsRegressor
+
+# Dynamically get the module containing the PysipsRegressor class
+IMPORTMODULE = PysipsRegressor.__module__
+
+
+@pytest.fixture
+def sample_data():
+    """Fixture for sample data."""
+    X = np.array([[1.0], [2.0], [3.0], [4.0], [5.0]])
+    y = np.array([2.0, 4.0, 6.0, 8.0, 10.0])
+    return X, y
+
+
+@pytest.fixture
+def mock_external_components(mocker: MockerFixture):
+    """Mock all external components needed by the regressor."""
+    mock_component_gen = mocker.patch(
+        f"{IMPORTMODULE}.ComponentGenerator", autospec=True
+    )
+    # needs to provide unique outputs for pool generation
+    mock_agraph_gen = mocker.MagicMock(side_effect=lambda: np.random.random())
+    mock_agraph_gen_constructor = mocker.patch(
+        f"{IMPORTMODULE}.AGraphGenerator", autospec=True, return_value=mock_agraph_gen
+    )
+    mock_laplace_nmll = mocker.patch(f"{IMPORTMODULE}.LaplaceNmll", autospec=True)
+    mock_mutation_proposal = mocker.patch(
+        f"{IMPORTMODULE}.MutationProposal", autospec=True
+    )
+    mock_crossover_proposal = mocker.patch(
+        f"{IMPORTMODULE}.CrossoverProposal", autospec=True
+    )
+    mock_random_choice_proposal = mocker.patch(
+        f"{IMPORTMODULE}.RandomChoiceProposal", autospec=True
+    )
+    mock_sample = mocker.patch(f"{IMPORTMODULE}.sample", autospec=True)
+
+    # Configure the mock sample function to return a model and likelihood
+    mock_model = MagicMock()
+    mock_model.__str__.return_value = "2*X_0"
+    mock_likelihoods = np.array([0.9])
+    mock_sample.return_value = ([mock_model], mock_likelihoods)
+
+    return {
+        "component_gen": mock_component_gen,
+        "agraph_gen": mock_agraph_gen_constructor,
+        "laplace_nmll": mock_laplace_nmll,
+        "mutation_proposal": mock_mutation_proposal,
+        "crossover_proposal": mock_crossover_proposal,
+        "random_choice_proposal": mock_random_choice_proposal,
+        "sample": mock_sample,
+        "model": mock_model,
+    }
+
+
+def test_init_custom_parameters():
+    """Test initialization with custom parameters."""
+    regressor = PysipsRegressor(
+        operators=["+", "*", "sin", "cos"],
+        max_complexity=30,
+        terminal_probability=0.2,
+        num_particles=100,
+        random_state=42,
+    )
+
+    # Check custom values
+    assert regressor.operators == ["+", "*", "sin", "cos"]
+    assert regressor.max_complexity == 30
+    assert regressor.terminal_probability == 0.2
+    assert regressor.num_particles == 100
+    assert regressor.random_state == 42
+
+
+def test_fit(sample_data, mock_external_components):
+    """Test the fit method."""
+    X, y = sample_data
+    mock_model = mock_external_components["model"]
+    mock_sample = mock_external_components["sample"]
+
+    regressor = PysipsRegressor(random_state=42)
+    regressor.fit(X, y)
+
+    # Verify that sample was called
+    mock_sample.assert_called_once()
+
+    # Verify that attributes were set correctly
+    assert regressor.models_ == [mock_model]
+    assert np.array_equal(regressor.likelihoods_, np.array([0.9]))
+    assert regressor.best_model_ == mock_model
+
+    # Verify n_features_in_ is set correctly
+    assert regressor.n_features_in_ == X.shape[1]
+
+
+def test_predict_requires_fit(sample_data):
+    """Test that predict requires the model to be fitted first."""
+    X, _ = sample_data
+    regressor = PysipsRegressor()
+
+    with pytest.raises(Exception):  # Should raise NotFittedError
+        regressor.predict(X)
+
+
+def test_predict(sample_data, mocker: MockerFixture):
+    """Test the predict method."""
+    X, _ = sample_data
+
+    # Create a mock model with evaluate_equation_at method
+    mock_model = MagicMock()
+    mock_predictions = np.array([2.0, 4.0, 6.0, 8.0, 10.0])
+    mock_model.evaluate_equation_at.return_value = mock_predictions
+
+    # Mock check_is_fitted to avoid NotFittedError
+    mocker.patch(f"{IMPORTMODULE}.check_is_fitted")
+    # Mock check_array to return the input unchanged
+    mocker.patch(f"{IMPORTMODULE}.check_array", return_value=X)
+
+    regressor = PysipsRegressor()
+    regressor.best_model_ = mock_model
+    regressor.models_ = [mock_model]
+    regressor.likelihoods_ = np.array([1.0])
+    regressor.n_features_in_ = X.shape[1]
+
+    predictions = regressor.predict(X)
+
+    # Verify that evaluate_equation_at was called with X
+    mock_model.evaluate_equation_at.assert_called_once_with(X)
+    assert np.array_equal(predictions, mock_predictions)
+
+
+def test_predict_wrong_feature_count(sample_data, mocker: MockerFixture):
+    """Test predict raises error when input has wrong number of features."""
+    X, _ = sample_data
+    wrong_X = np.array([[1.0, 2.0], [3.0, 4.0]])  # 2 features instead of 1
+
+    # Mock check_is_fitted to avoid NotFittedError
+    mocker.patch(f"{IMPORTMODULE}.check_is_fitted")
+    # Mock check_array to return the input unchanged
+    mocker.patch(f"{IMPORTMODULE}.check_array", return_value=wrong_X)
+
+    regressor = PysipsRegressor()
+    regressor.best_model_ = MagicMock()
+    regressor.models_ = [MagicMock()]
+    regressor.n_features_in_ = X.shape[1]  # Trained with 1 feature
+
+    with pytest.raises(
+        ValueError
+    ):  # Should raise ValueError for feature count mismatch
+        regressor.predict(wrong_X)
+
+
+def test_score(sample_data, mocker: MockerFixture):
+    """Test the score method."""
+    X, y = sample_data
+
+    # Mock super().score to return a predetermined R² value
+    mocker.patch("sklearn.base.RegressorMixin.score", return_value=0.95)
+
+    regressor = PysipsRegressor()
+    regressor.best_model_ = MagicMock()
+
+    score = regressor.score(X, y)
+
+    assert score == 0.95
+
+
+def test_get_expression(mocker: MockerFixture):
+    """Test the get_expression method."""
+    # Mock check_is_fitted to avoid NotFittedError
+    mocker.patch(f"{IMPORTMODULE}.check_is_fitted")
+
+    mock_model = MagicMock()
+    mock_model.__str__.return_value = "2*X_0"
+
+    regressor = PysipsRegressor()
+    regressor.best_model_ = mock_model
+
+    expression = regressor.get_expression()
+
+    # Verify that __str__ was called on the best_model_
+    mock_model.__str__.assert_called_once()
+    assert expression == "2*X_0"
+
+
+def test_get_expression_not_fitted(mocker: MockerFixture):
+    """Test get_expression raises error when called on unfitted model."""
+    # Mock check_is_fitted to raise an exception
+    mocker.patch(f"{IMPORTMODULE}.check_is_fitted", side_effect=Exception("Not fitted"))
+
+    regressor = PysipsRegressor()
+
+    with pytest.raises(Exception):  # Should raise the exception from check_is_fitted
+        regressor.get_expression()
+
+
+def test_get_models(mocker: MockerFixture):
+    """Test the get_models method."""
+    # Mock check_is_fitted to avoid NotFittedError
+    mocker.patch(f"{IMPORTMODULE}.check_is_fitted")
+
+    mock_models = [MagicMock(), MagicMock()]
+    mock_likelihoods = np.array([0.8, 0.2])
+
+    regressor = PysipsRegressor()
+    regressor.models_ = mock_models
+    regressor.likelihoods_ = mock_likelihoods
+
+    models, likelihoods = regressor.get_models()
+
+    assert models == mock_models
+    assert np.array_equal(likelihoods, mock_likelihoods)
+
+
+def test_get_models_not_fitted(mocker: MockerFixture):
+    """Test get_models raises error when called on unfitted model."""
+    # Mock check_is_fitted to raise an exception
+    mocker.patch(f"{IMPORTMODULE}.check_is_fitted", side_effect=Exception("Not fitted"))
+
+    regressor = PysipsRegressor()
+
+    with pytest.raises(Exception):  # Should raise the exception from check_is_fitted
+        regressor.get_models()

tests/unit/test_sampler.py

@@ -0,0 +1,133 @@
+import numpy as np
+import pytest
+
+from pysips.sampler import sample, run_smc
+
+IMPORTMODULE = sample.__module__
+
+
+class TestSampleFunction:
+    def test_default_kwargs(self, mocker):
+        mock_run_smc = mocker.patch(
+            f"{IMPORTMODULE}.run_smc",
+            return_value=("mock_models", "mock_likelihoods"),
+        )
+
+        likelihood = lambda x: x
+        proposal = object()
+        generator = object()
+        seed = 42
+
+        result = sample(likelihood, proposal, generator, seed=seed)
+
+        assert result == ("mock_models", "mock_likelihoods")
+
+        mock_run_smc.assert_called_once()
+        args, _ = mock_run_smc.call_args
+
+        assert args[0] == likelihood
+        assert args[1] == proposal
+        assert args[2] == generator
+        assert args[3] is False
+
+        kwargs_passed = args[4]
+        rng_passed = args[5]
+
+        assert kwargs_passed == {"num_particles": 5000, "num_mcmc_samples": 10}
+        assert isinstance(rng_passed, np.random.Generator)
+
+    def test_custom_kwargs(self, mocker):
+        mock_run_smc = mocker.patch(
+            f"{IMPORTMODULE}.run_smc", return_value=("mock_models", "mock_likelihoods")
+        )
+
+        likelihood = lambda x: x
+        proposal = object()
+        generator = object()
+        custom_kwargs = {"num_particles": 100, "num_mcmc_samples": 3}
+
+        result = sample(likelihood, proposal, generator, kwargs=custom_kwargs, seed=24)
+
+        assert result == ("mock_models", "mock_likelihoods")
+        mock_run_smc.assert_called_once()
+
+        args, _ = mock_run_smc.call_args
+        assert args[0] == likelihood
+        assert args[1] == proposal
+        assert args[2] == generator
+        assert args[3] is False
+        assert args[4] == custom_kwargs
+
+
+class TestRunSMC:
+    @pytest.mark.parametrize("multiproc", [True, False])
+    def test_functionality(self, mocker, multiproc):
+        mock_rng_instance = mocker.Mock(name="rngInstance")
+        mock_rng = mocker.patch(
+            f"{IMPORTMODULE}.np.random.default_rng", return_value=mock_rng_instance
+        )
+
+        mock_prior_instance = mocker.Mock(name="PriorInstance")
+        mock_prior = mocker.patch(
+            f"{IMPORTMODULE}.Prior", return_value=mock_prior_instance
+        )
+
+        mock_mcmc_instance = mocker.Mock(name="MetropolisInstance")
+        mock_metropolis = mocker.patch(
+            f"{IMPORTMODULE}.Metropolis", return_value=mock_mcmc_instance
+        )
+
+        mock_kernel_instance = mocker.Mock(name="VectorMCMCKernelInstance")
+        mock_vector_kernel = mocker.patch(
+            f"{IMPORTMODULE}.VectorMCMCKernel", return_value=mock_kernel_instance
+        )
+
+        mock_sampler_instance = mocker.Mock(name="AdaptiveSamplerInstance")
+        mock_adaptive_sampler = mocker.patch(
+            f"{IMPORTMODULE}.AdaptiveSampler", return_value=mock_sampler_instance
+        )
+
+        dummy_params = np.array([[1], [2], [3]])
+        dummy_step = mocker.Mock(params=dummy_params)
+        mock_sampler_instance.sample.return_value = ([dummy_step], None)
+
+        likelihood = mocker.Mock(side_effect=lambda x: x * 10)
+
+        proposal = "proposal"
+        generator = "generator"
+        kwargs = {"num_particles": 3, "num_mcmc_samples": 4}
+
+        models, likelihoods = sample(
+            likelihood,
+            proposal,
+            generator,
+            multiprocess=multiproc,
+            kwargs=kwargs,
+            seed=0,
+        )
+
+        mock_prior.assert_called_once_with(generator)
+
+        mock_metropolis.assert_called_once_with(
+            likelihood=likelihood,
+            proposal=proposal,
+            prior=mock_prior_instance,
+            multiprocess=multiproc,
+        )
+
+        mock_vector_kernel.assert_called_once_with(
+            mock_mcmc_instance, param_order=["f"], rng=mock_rng_instance
+        )
+
+        mock_adaptive_sampler.assert_called_once_with(mock_kernel_instance)
+
+        mock_sampler_instance.sample.assert_called_once_with(**kwargs)
+
+        assert mock_sampler_instance._mutator._compute_cov is False
+
+        expected_models = dummy_params[:, 0].tolist()
+        assert models == expected_models
+
+        expected_likelihoods = [m * 10 for m in expected_models]
+        assert likelihoods == expected_likelihoods
+        assert likelihood.call_count == len(expected_models)