pysips 0.0.0__py3-none-any.whl

tests/unit/test_crossover_proposal.py

@@ -0,0 +1,156 @@
+import pytest
+
+from pysips.crossover_proposal import CrossoverProposal
+
+IMPORTMODULE = CrossoverProposal.__module__
+
+
+class TestCrossoverProposal:
+
+    @pytest.fixture
+    def mock_model(self, mocker):
+        """Create a mock model for testing"""
+        mock_model = mocker.MagicMock()
+        mock_model.__eq__.side_effect = lambda x: x is mock_model
+        return mock_model
+
+    @pytest.fixture
+    def mock_gene_pool(self, mocker, mock_model):
+        """Create a mock gene pool with several models"""
+        model1 = mocker.MagicMock()
+        model2 = mocker.MagicMock()
+
+        # Configure models to be different from each other
+        model1.__eq__.side_effect = lambda x: x is model1
+        model2.__eq__.side_effect = lambda x: x is model2
+
+        return [mock_model, model1, model2]
+
+    def test_initialization(self, mock_gene_pool, mocker):
+        """Test proper initialization of CrossoverProposal"""
+        # Mock dependencies
+        mock_agraph_crossover = mocker.MagicMock()
+        mocker.patch(
+            f"{IMPORTMODULE}.AGraphCrossover", return_value=mock_agraph_crossover
+        )
+        mock_random = mocker.patch("numpy.random.default_rng")
+
+        # Initialize CrossoverProposal
+        seed = 42
+        crossover_proposal = CrossoverProposal(mock_gene_pool, seed=seed)
+
+        # Assertions
+        assert crossover_proposal._gene_pool == mock_gene_pool
+        mock_random.assert_called_once_with(seed)
+
+    def test_call_method_selects_different_parent(
+        self, mock_gene_pool, mock_model, mocker
+    ):
+        """Test that __call__ selects a parent different from the input model"""
+        # Mock AGraphCrossover
+        mock_crossover = mocker.MagicMock()
+        child_1 = mocker.MagicMock(name="child_1")
+        child_2 = mocker.MagicMock(name="child_2")
+        mock_crossover.return_value = (child_1, child_2)
+        mocker.patch(f"{IMPORTMODULE}.AGraphCrossover", return_value=mock_crossover)
+
+        # Mock random number generator
+        mock_rng = mocker.MagicMock()
+        mock_rng.integers.side_effect = [0, 1]
+        mock_rng.random.return_value = 0.4  # Will select first child
+
+        # Initialize CrossoverProposal with mocked RNG
+        crossover_proposal = CrossoverProposal(mock_gene_pool)
+        crossover_proposal._rng = mock_rng
+
+        # Call the method
+        result = crossover_proposal(mock_model)
+
+        # Assertions
+        # Check that crossover was called with model and a different parent
+        mock_crossover.assert_called_once()
+        args = mock_crossover.call_args[0]
+        assert args[0] == mock_model  # First arg is the input model
+        assert args[1] == mock_gene_pool[1]  # Second arg should be a different model
+        assert args[1] != mock_model  # Ensure it's not the same model
+
+        # Check we got the expected child
+        assert result == child_1
+
+    @pytest.mark.parametrize(
+        "random_value, expected_child_index",
+        [
+            (0.3, 0),
+            (0.8, 1),
+        ],
+    )
+    def test_call_method_selects_child_based_on_random(
+        self, mock_gene_pool, mock_model, mocker, random_value, expected_child_index
+    ):
+        """Test that __call__ selects the appropriate child based on random value"""
+        mock_crossover = mocker.MagicMock()
+        child_1 = mocker.MagicMock(name="child_1")
+        child_2 = mocker.MagicMock(name="child_2")
+        children = (child_1, child_2)
+        mock_crossover.return_value = children
+        mocker.patch(f"{IMPORTMODULE}.AGraphCrossover", return_value=mock_crossover)
+
+        # Mock random number generator
+        mock_rng = mocker.MagicMock()
+        mock_rng.integers.return_value = 1
+        mock_rng.random.return_value = random_value
+
+        # Initialize and call
+        crossover_proposal = CrossoverProposal(mock_gene_pool)
+        crossover_proposal._rng = mock_rng
+        result = crossover_proposal(mock_model)
+
+        # Assertions
+        expected_child = children[expected_child_index]
+        assert result == expected_child
+
+    def test_update_method(self, mock_gene_pool, mocker):
+        """Test update method updates the gene pool"""
+        # Mock AGraphCrossover
+        mocker.patch(f"{IMPORTMODULE}.AGraphCrossover")
+
+        # Initialize
+        crossover_proposal = CrossoverProposal(mock_gene_pool)
+
+        # Create new gene pool
+        new_model1 = mocker.MagicMock(name="new_model1")
+        new_model2 = mocker.MagicMock(name="new_model2")
+        new_gene_pool = (new_model1, new_model2)
+
+        # Update gene pool
+        crossover_proposal.update(new_gene_pool)
+
+        # Assertions
+        assert crossover_proposal._gene_pool == list(new_gene_pool)
+
+    # @pytest.mark.parametrize("seed", [None, 0, 42, 12345])
+    # def test_random_seed(self, mock_gene_pool, seed, mocker):
+    #     """Test that random seed is properly used"""
+    #     # Mock AGraphCrossover
+    #     mocker.patch(f"{IMPORTMODULE}.AGraphCrossover")
+
+    #     # Mock numpy random generator
+    #     mock_rng = mocker.patch("numpy.random.default_rng")
+
+    #     # Initialize with different seeds
+    #     CrossoverProposal(mock_gene_pool, seed=seed)
+
+    #     # Check the RNG was initialized with the right seed
+    #     mock_rng.assert_called_once_with(seed)
+
+    def test_empty_gene_pool_error(self, mocker):
+        """Test that an empty gene pool results in appropriate failure"""
+        # Mock AGraphCrossover
+        mocker.patch(f"{IMPORTMODULE}.AGraphCrossover")
+
+        # Initialize with empty pool
+        crossover_proposal = CrossoverProposal([])
+
+        # Call should raise exception due to empty pool
+        with pytest.raises(ValueError) as excinfo:
+            crossover_proposal(mocker.MagicMock())

tests/unit/test_laplace_nmll.py

@@ -0,0 +1,111 @@
+import pytest
+import numpy as np
+
+from pysips.laplace_nmll import LaplaceNmll
+
+IMPORTMODULE = LaplaceNmll.__module__
+
+
+class TestLaplaceNmll:
+
+    @pytest.fixture
+    def sample_data(self):
+        """Fixture to provide sample data for tests."""
+        X = np.array([[1, 2], [3, 4], [5, 6]])
+        y = np.array([10, 20, 30])
+        return X, y
+
+    @pytest.fixture
+    def mock_model(self, mocker):
+        """Fixture to provide a mock bingo AGraph model."""
+        model = mocker.MagicMock()
+        model.get_local_optimization_params.return_value = np.array([1.0, 2.0])
+        return model
+
+    def test_negative_is_applied_to_regression_output(
+        self, sample_data, mock_model, mocker
+    ):
+        X, y = sample_data
+
+        mock_regression = mocker.MagicMock(return_value=-5.0)
+        mocker.patch(f"{IMPORTMODULE}.ExplicitRegression", return_value=mock_regression)
+
+        mock_scipy_optimizer = mocker.MagicMock()
+        mocker.patch(
+            f"{IMPORTMODULE}.ScipyOptimizer",
+            return_value=mock_scipy_optimizer,
+        )
+
+        laplace_nmll = LaplaceNmll(X, y)
+        result = laplace_nmll(mock_model)
+
+        assert result == 5.0
+
+    @pytest.mark.parametrize("opt_restarts", [1, 3, 5, 10])
+    def test_number_of_restarts(self, sample_data, mock_model, mocker, opt_restarts):
+        """Test that the optimizer is run the correct number of times based on opt_restarts."""
+        X, y = sample_data
+
+        mock_regression = mocker.MagicMock()
+        mock_regression.return_value = -1.0  # Constant return value
+        mocker.patch(f"{IMPORTMODULE}.ExplicitRegression", return_value=mock_regression)
+
+        mock_scipy_optimizer = mocker.MagicMock()
+        mocker.patch(
+            f"{IMPORTMODULE}.ScipyOptimizer",
+            return_value=mock_scipy_optimizer,
+        )
+
+        laplace_nmll = LaplaceNmll(X, y, opt_restarts=opt_restarts)
+        laplace_nmll(mock_model)
+        assert mock_scipy_optimizer.call_count == opt_restarts
+
+    def test_constants_kept_from_best_trial(self, sample_data, mock_model, mocker):
+        """Test that constants are kept from optimizer trial with highest nmll."""
+        X, y = sample_data
+
+        # Return increasingly better values (-3 > -5 > -10 when negated)
+        mock_regression = mocker.MagicMock()
+        mock_regression.side_effect = [10.0, 5.0, 3.0]
+        mocker.patch(f"{IMPORTMODULE}.ExplicitRegression", return_value=mock_regression)
+
+        # Create different parameter sets for different optimization runs
+        mock_scipy_optimizer = mocker.MagicMock()
+        params_run1 = np.array([1.0, 1.0])
+        params_run2 = np.array([2.0, 2.0])
+        params_run3 = np.array([3.0, 3.0])  # This should be kept as the best
+        mock_model.get_local_optimization_params.side_effect = [
+            params_run1,
+            params_run2,
+            params_run3,
+        ]
+        mocker.patch(
+            f"{IMPORTMODULE}.ScipyOptimizer",
+            return_value=mock_scipy_optimizer,
+        )
+
+        laplace_nmll = LaplaceNmll(X, y, opt_restarts=3)
+        result = laplace_nmll(mock_model)
+
+        assert result == -3.0
+        mock_model.set_local_optimization_params.assert_called_once_with(params_run3)
+
+    def test_optimizer_kwargs_passed_through(self, sample_data, mocker):
+        """Test that optimizer kwargs are passed to the bingo deterministic optimizer."""
+        X, y = sample_data
+
+        scipy_optimizer_spy = mocker.patch(f"{IMPORTMODULE}.ScipyOptimizer")
+        mocker.patch(f"{IMPORTMODULE}.ExplicitRegression")
+
+        custom_kwargs = {
+            "param_init_bounds": [-10, 10],
+            "tol": 1e-8,
+            "options": {"maxiter": 500},
+        }
+        LaplaceNmll(X, y, **custom_kwargs)
+        expected_kwargs = {"method": "lm", **custom_kwargs}
+        _, actual_kwargs = scipy_optimizer_spy.call_args
+
+        for key, value in expected_kwargs.items():
+            assert key in actual_kwargs
+            assert actual_kwargs[key] == value

tests/unit/test_metropolis.py

@@ -0,0 +1,111 @@
+import inspect
+import numpy as np
+import pytest
+from pysips.sampler import Metropolis  # Adjust import as needed
+
+IMPORTMODULE = Metropolis.__module__
+
+
+def dummy_likelihood(x):
+    return x.value * 2
+
+
+@pytest.fixture
+def metropolis(mocker):
+    mock_likelihood = dummy_likelihood
+    mock_proposal = mocker.Mock()
+    return Metropolis(
+        likelihood=mock_likelihood,
+        proposal=mock_proposal,
+        prior=None,
+        multiprocess=False,
+    )
+
+
+class DummyGraph:
+    def __init__(self, value):
+        self.value = value
+        self.fitness = None
+
+
+class TestMetropolis:
+    def test_evaluate_model_returns_none(self, metropolis):
+        assert metropolis.evaluate_model() is None
+
+    def test_evaluate_log_priors_returns_ones(self, metropolis):
+        x = np.empty((5, 1))
+        np.testing.assert_array_equal(
+            metropolis.evaluate_log_priors(x), np.ones((5, 1))
+        )
+
+    def test_evaluate_log_likelihood_no_multiproc(self, metropolis):
+        graphs = np.array(
+            [[DummyGraph(1)], [DummyGraph(2)], [DummyGraph(3)]], dtype=object
+        )
+        result = metropolis.evaluate_log_likelihood(graphs)
+        np.testing.assert_array_equal(result, np.c_[[2, 4, 6]])
+
+    def test_evaluate_log_likelihood_multiproc(self, mocker, metropolis):
+        metropolis._is_multiprocess = True
+
+        dummy_pool = mocker.MagicMock()
+        dummy_pool.__enter__.return_value = dummy_pool
+        dummy_pool.__exit__.return_value = None
+        dummy_pool.map.side_effect = lambda func, iterable: list(map(func, iterable))
+
+        mocker.patch(f"{IMPORTMODULE}.Pool", return_value=dummy_pool)
+
+        graphs = np.array(
+            [[DummyGraph(1)], [DummyGraph(2)], [DummyGraph(3)]], dtype=object
+        )
+        result = metropolis.evaluate_log_likelihood(graphs)
+
+        expected = np.c_[[2, 4, 6]]
+        np.testing.assert_array_equal(result, expected)
+
+        for g, l in zip(graphs.flatten(), expected.flatten()):
+            assert g.fitness == l
+
+
+def test_smc_metropolis(mocker, metropolis):
+    inputs = np.array([[DummyGraph(1)], [DummyGraph(2)]], dtype=object)
+    num_samples = 2
+
+    mocker.patch.object(
+        metropolis,
+        "_initialize_probabilities",
+        return_value=(np.array([0, 0]), np.array([10, 10])),
+    )
+    mocker.patch.object(
+        metropolis,
+        "_perform_mcmc_step",
+        side_effect=lambda inputs, a, b, c: (inputs, b, None, None),
+    )
+
+    update_spy = mocker.spy(metropolis._equ_proposal, "update")
+
+    out_inputs, out_log_like = metropolis.smc_metropolis(inputs, num_samples)
+
+    update_spy.assert_called_once()
+    called_args, called_kwargs = update_spy.call_args
+
+    assert "gene_pool" in called_kwargs
+    np.testing.assert_array_equal(called_kwargs["gene_pool"], inputs.flatten())
+    assert np.array_equal(out_inputs, inputs)
+    assert np.array_equal(out_log_like, np.array([10, 10]))
+
+
+def test_smc_metropolis_accepts_cov_kwarg(metropolis):
+    sig = inspect.signature(metropolis.smc_metropolis)
+    assert "cov" in sig.parameters
+
+
+def test_proposal_applies_equ_proposal_elementwise():
+    equ_proposal = lambda x: x * 2
+    m = Metropolis(prior=None, likelihood=lambda x: 0, proposal=equ_proposal)
+
+    x = np.c_[[1.0, 2.0]]
+    result = m.proposal(x, None)
+
+    expected = np.c_[[2.0, 4.0]]
+    np.testing.assert_array_equal(result, expected)

tests/unit/test_mutation_proposal.py

@@ -0,0 +1,196 @@
+import pytest
+
+from pysips.mutation_proposal import MutationProposal
+
+
+IMPORTMODULE = MutationProposal.__module__
+
+
+class TestMutationProposal:
+
+    @pytest.fixture
+    def basic_setup(self):
+        """Basic setup for mutation proposal tests"""
+        X_dim = 2
+        operators = ["+", "-", "*"]
+        return X_dim, operators
+
+    @pytest.fixture
+    def mock_model(self, mocker):
+        """Create a mock model for testing"""
+        return mocker.MagicMock()
+
+    def test_initialization_passes_info_to_bingo(self, mocker):
+        """Test proper initialization of MutationProposal"""
+        X_dim = 3
+        operators = ["+", "-", "*", "sin"]
+
+        mock_component_gen = mocker.MagicMock()
+        mock_component_gen_cls = mocker.patch(
+            f"{IMPORTMODULE}.ComponentGenerator", return_value=mock_component_gen
+        )
+        mock_agraph_mutation = mocker.MagicMock()
+        mock_agraph_mutation_cls = mocker.patch(
+            f"{IMPORTMODULE}.AGraphMutation", return_value=mock_agraph_mutation
+        )
+
+        mutation_proposal = MutationProposal(
+            x_dim=X_dim,
+            operators=operators,
+            terminal_probability=0.2,
+            constant_probability=0.5,
+            command_probability=0.1,
+            node_probability=0.3,
+            parameter_probability=0.15,
+            prune_probability=0.25,
+            fork_probability=0.2,
+            repeat_mutation_probability=0.1,
+            seed=42,
+        )
+
+        mock_component_gen_cls.assert_called_once_with(
+            input_x_dimension=X_dim, terminal_probability=0.2, constant_probability=0.5
+        )
+
+        assert mock_component_gen.add_operator.call_count == len(operators)
+        for op in operators:
+            mock_component_gen.add_operator.assert_any_call(op)
+
+        mock_agraph_mutation_cls.assert_called_once_with(
+            mock_component_gen,
+            0.1,  # command_probability
+            0.3,  # node_probability
+            0.15,  # parameter_probability
+            0.25,  # prune_probability
+            0.2,  # fork_probability
+        )
+
+    def test_do_mutation_single(self, basic_setup, mock_model, mocker):
+        """Test _do_mutation method without repeat"""
+        X_dim, operators = basic_setup
+
+        # Setup mocks
+        mock_mutation = mocker.MagicMock()
+        mutated_model = mocker.MagicMock()
+        mock_mutation.return_value = mutated_model
+
+        # Patch random generator to ensure no repeat
+        mock_rng = mocker.MagicMock()
+        mock_rng.random.return_value = 1.0  # > repeat_mutation_prob
+
+        mocker.patch(f"{IMPORTMODULE}.ComponentGenerator")
+        mocker.patch(f"{IMPORTMODULE}.AGraphMutation", return_value=mock_mutation)
+
+        mutation_proposal = MutationProposal(x_dim=X_dim, operators=operators)
+        mutation_proposal._rng = mock_rng
+
+        result = mutation_proposal._do_mutation(mock_model)
+        mock_mutation.assert_called_once_with(mock_model)
+        assert result == mutated_model
+        assert mock_rng.random.call_count == 1
+
+    def test_do_mutation_with_repeat(self, basic_setup, mock_model, mocker):
+        """Test _do_mutation method with repeated mutations"""
+        X_dim, operators = basic_setup
+
+        mock_mutation = mocker.MagicMock()
+        mutated_model1 = mocker.MagicMock(name="mutated_model1")
+        mutated_model2 = mocker.MagicMock(name="mutated_model2")
+        mutated_model3 = mocker.MagicMock(name="mutated_model3")
+        mock_mutation.side_effect = [mutated_model1, mutated_model2, mutated_model3]
+
+        # Patch random generator to ensure repeat twice
+        mock_rng = mocker.MagicMock()
+        mock_rng.random.side_effect = [
+            0.1,
+            0.2,
+            0.9,
+        ]  # First two < repeat_mutation_prob
+
+        mocker.patch(f"{IMPORTMODULE}.ComponentGenerator")
+        mocker.patch(f"{IMPORTMODULE}.AGraphMutation", return_value=mock_mutation)
+
+        mutation_proposal = MutationProposal(
+            x_dim=X_dim, operators=operators, repeat_mutation_probability=0.5
+        )
+        mutation_proposal._rng = mock_rng
+
+        result = mutation_proposal(mock_model)
+
+        assert mock_mutation.call_count == 3
+        mock_mutation.assert_any_call(mock_model)
+        mock_mutation.assert_any_call(mutated_model1)
+        mock_mutation.assert_any_call(mutated_model2)
+        assert result == mutated_model3
+        assert mock_rng.random.call_count == 3
+
+    def test_call_different_model(self, basic_setup, mock_model, mocker):
+        """Test __call__ when mutation immediately produces a different model"""
+        X_dim, operators = basic_setup
+
+        mocker.patch(f"{IMPORTMODULE}.ComponentGenerator")
+
+        mutated_model = mocker.MagicMock()
+        mock_mutation = mocker.MagicMock(return_value=mutated_model)
+        mocker.patch(f"{IMPORTMODULE}.AGraphMutation", return_value=mock_mutation)
+
+        # Ensure models are different
+        mock_model.__eq__.return_value = False
+
+        mutation_proposal = MutationProposal(
+            x_dim=X_dim, operators=operators, repeat_mutation_probability=0.0
+        )
+        result = mutation_proposal(mock_model)
+
+        # Assertions
+        mock_mutation.assert_called_once_with(mock_model)
+        assert result == mutated_model
+
+    def test_call_retry_mutation(self, basic_setup, mock_model, mocker):
+        """Test __call__ when mutation initially produces an equivalent model"""
+        X_dim, operators = basic_setup
+
+        mocker.patch(f"{IMPORTMODULE}.ComponentGenerator")
+
+        equivalent_model = mock_model
+        different_model = mocker.MagicMock()
+        mock_mutation = mocker.MagicMock(
+            side_effect=[equivalent_model, different_model]
+        )
+        mocker.patch(f"{IMPORTMODULE}.AGraphMutation", return_value=mock_mutation)
+
+        mock_model.__eq__.side_effect = lambda other: other is equivalent_model
+
+        mutation_proposal = MutationProposal(
+            x_dim=X_dim, operators=operators, repeat_mutation_probability=0.0
+        )
+        result = mutation_proposal(mock_model)
+
+        assert mock_mutation.call_count == 2
+        assert result == different_model
+
+    def test_update_method(self, basic_setup, mocker):
+        """Test update method (should be a no-op)"""
+        X_dim, operators = basic_setup
+
+        mocker.patch(f"{IMPORTMODULE}.ComponentGenerator")
+        mocker.patch(f"{IMPORTMODULE}.AGraphMutation")
+
+        mutation_proposal = MutationProposal(x_dim=X_dim, operators=operators)
+
+        # This should not raise any errors
+        mutation_proposal.update(some_param=10)
+        mutation_proposal.update()
+
+    @pytest.mark.parametrize("seed", [None, 0, 42, 12345])
+    def test_random_seed(self, mocker, basic_setup, seed):
+        """Test that random seed is properly used"""
+        X_dim, operators = basic_setup
+
+        # Create class with different seeds
+        mocker.patch(f"{IMPORTMODULE}.ComponentGenerator"),
+        mocker.patch(f"{IMPORTMODULE}.AGraphMutation"),
+        mock_rng = mocker.patch("numpy.random.default_rng")
+
+        _ = MutationProposal(x_dim=X_dim, operators=operators, seed=seed)
+        mock_rng.assert_called_once_with(seed)