fix: deterministic expenv behaviour

experimental_env/analysis/analyze_summarizers/error_summarizer.py

@@ -38,13 +38,14 @@ def calculate(self, results: list[ExperimentDescription]) -> tuple:
 
             errors.append(error)
 
-        mean = np.sum(errors) / len(errors)
-        standart_deviation = np.sqrt(np.sum([(x - mean) ** 2 for x in errors]) / len(errors))
+        if not errors:
+            return 0, 0, 0
 
-        errors.sort()
-        median = errors[len(errors) // 2]
+        mean = np.mean(errors)
+        std = np.std(errors)
+        median = np.median(errors)
 
-        return float(mean), float(standart_deviation), float(median)
+        return float(mean), float(std), float(median)
 
     def analyze_method(self, results: list[ExperimentDescription], method: str):
         mean, deviation, median = self.calculate(results)

experimental_env/experiment/estimators.py

@@ -90,7 +90,7 @@ def __init__(self, brkpointer, dst_checker):
 
     @property
     def name(self):
-        return "LM-EM"
+        return "ELM"
 
     def _helper(self, problem: OrderedProblem):
         """

experimental_env/experiment/experiment_executors/abstract_executor.py

@@ -1,5 +1,6 @@
 """A module that provides an abstract class for performing the 2nd stage of the experiment"""
 
+import random
 import warnings
 from abc import ABC, abstractmethod
 from pathlib import Path
@@ -20,7 +21,7 @@ class AExecutor(ABC):
     as well as the implementation of the execute method, to implement the 2nd stage of the experiment.
     """
 
-    def __init__(self, path: Path, cpu_count: int, seed):
+    def __init__(self, path: Path, cpu_count: int, seed: int):
         """
         Class constructor
 
@@ -31,6 +32,8 @@ def __init__(self, path: Path, cpu_count: int, seed):
         self._out_dir = path
         self._cpu_count = cpu_count
         self._seed = seed
+
+        random.seed(self._seed)
         np.random.seed(self._seed)
 
     @abstractmethod

experimental_env/experiment/experiment_executors/random_executor.py

@@ -19,7 +19,7 @@ def init_problems(self, ds_descriptions, models):
         return [
             Problem(
                 descr.samples,
-                RandomMixtureGenerator(self._seed).create_mixture(models),
+                RandomMixtureGenerator().create_mixture(models),
             )
             for i, descr in enumerate(ds_descriptions)
         ]

experimental_env/experiment/experiment_executors/standart_executor.py

@@ -19,7 +19,7 @@ def init_problems(self, ds_descriptions, models):
         return [
             Problem(
                 descr.samples,
-                StandartMixtureGenerator(self._seed).create_mixture(models),
+                StandartMixtureGenerator().create_mixture(models),
             )
             for i, descr in enumerate(ds_descriptions)
         ]

experimental_env/mixture_generators/abstract_generator.py

@@ -1,6 +1,5 @@
 """A module that provides an abstract class for generating a mixture."""
 
-import random
 from abc import ABC, abstractmethod
 
 from mpest import Distribution, MixtureDistribution
@@ -12,9 +11,6 @@ class AMixtureGenerator(ABC):
     An abstract class for generating mixtures.
     """
 
-    def __init__(self, seed: int = 42):
-        random.seed(seed)
-
     @abstractmethod
     def generate_priors(self, models: list[type[AModel]]) -> list[float | None]:
         """

experimental_env/mixture_generators/utils.py

@@ -16,8 +16,8 @@ def generate_standart_params(models: list[type[AModel]]) -> list[Distribution]:
             params = [1.0]
         elif m == GaussianModel:
             params = [0.0, 1.0]
-        else:
-            params = [1.0, 1.5]
+        else:  # Weibull
+            params = [1.0, 1.0]
 
         dists.append(Distribution.from_params(m, params))
 
@@ -34,7 +34,7 @@ def generate_uniform_params(models: list[type[AModel]]) -> list[Distribution]:
             params = [uniform(0.1, 5.0)]
         elif m == GaussianModel:
             params = [uniform(-5.0, 5.0), uniform(0.1, 5.0)]
-        else:
+        else:  # Weibull
             params = [uniform(0.1, 5.0), uniform(0.1, 5.0)]
 
         dists.append(Distribution.from_params(m, params))

experimental_env/preparation/dataset_generator.py

@@ -26,9 +26,11 @@ def __init__(self, seed: int = 42):
         """
         Setting seed for determined result.
         """
-        random.seed(seed)
         self._seed = seed
 
+        random.seed(self._seed)
+        np.random.seed(self._seed)
+
     def generate(
         self,
         samples_size: int,
@@ -59,7 +61,6 @@ class ConcreteDatasetGenerator:
     """
 
     def __init__(self, seed: int = 42):
-        np.random.seed(seed)
         self._dists: list[Distribution] = []
         self._priors: list[float | None] = []
 

tests/core/test_distribution.py

@@ -0,0 +1,210 @@
+from unittest.mock import MagicMock, Mock
+
+import numpy as np
+import pytest
+from hypothesis import given
+from hypothesis import strategies as st
+
+from mpest.core.distribution import Distribution
+from mpest.models import AModel, AModelWithGenerator
+
+
+@st.composite
+def valid_params(draw, min_size=1, max_size=5):
+    size = draw(st.integers(min_value=min_size, max_value=max_size))
+    params_list = draw(
+        st.lists(
+            st.floats(min_value=-100, max_value=100, allow_nan=False, allow_infinity=False),
+            min_size=size,
+            max_size=size,
+        )
+    )
+    return np.array(params_list)
+
+
+@st.composite
+def valid_x(draw):
+    return draw(st.floats(min_value=-100, max_value=100, allow_nan=False, allow_infinity=False))
+
+
+@st.composite
+def valid_size(draw):
+    return draw(st.integers(min_value=1, max_value=100))
+
+
+class MockModel(AModel):
+    @property
+    def name(self):
+        return "MockModel"
+
+    def pdf(self, x, params):
+        return 0.1 * x * sum(params)
+
+    def lpdf(self, x, params):
+        return np.log(self.pdf(x, params))
+
+    def params_convert_to_model(self, params):
+        return params
+
+    def params_convert_from_model(self, params):
+        return params
+
+
+class MockModelWithGenerator(AModelWithGenerator):
+    @property
+    def name(self):
+        return "MockModelWithGenerator"
+
+    def pdf(self, x, params):
+        return 0.1 * x * sum(params)
+
+    def lpdf(self, x, params):
+        return np.log(self.pdf(x, params))
+
+    def params_convert_to_model(self, params):
+        return params
+
+    def params_convert_from_model(self, params):
+        return params
+
+    def generate(self, params, size=1, **kwargs):
+        return np.random.uniform(0, 1, size=size)
+
+
+class TestModuleDistribution:
+    def test_init(self):
+        model = Mock()
+        params = np.array([1.0, 2.0])
+
+        dist = Distribution(model=model, params=params)
+
+        assert dist._model is model
+        assert np.array_equal(dist._params, params)
+
+    def test_from_params(self):
+        MockModelClass = Mock()
+        mock_instance = Mock()
+        MockModelClass.return_value = mock_instance
+        params = [1.0, 2.0]
+
+        dist = Distribution.from_params(MockModelClass, params)
+
+        MockModelClass.assert_called_once()
+        assert dist._model is mock_instance
+        assert np.array_equal(dist._params, np.array(params))
+
+    def test_model_property(self):
+        model = Mock()
+        params = np.array([1.0, 2.0])
+
+        dist = Distribution(model=model, params=params)
+
+        assert dist.model is model
+
+    def test_params_property(self):
+        model = Mock()
+        params = np.array([1.0, 2.0])
+
+        dist = Distribution(model=model, params=params)
+
+        assert dist.params is params
+        assert np.array_equal(dist.params, params)
+
+    def test_has_generator_property_true(self):
+        model = MagicMock(spec=AModelWithGenerator)
+        params = np.array([1.0, 2.0])
+
+        dist = Distribution(model=model, params=params)
+
+        assert dist.has_generator is True
+
+    def test_has_generator_property_false(self):
+        model = MagicMock(spec=AModel)
+        params = np.array([1.0, 2.0])
+
+        dist = Distribution(model=model, params=params)
+
+        assert dist.has_generator is False
+
+    @given(valid_x(), valid_params())
+    def test_pdf_calls_model_pdf_correctly(self, x, params):
+        model = Mock()
+        return_value = 0.1
+        converted_params = np.array([3.0, 4.0])
+        model.params_convert_to_model.return_value = converted_params
+        model.pdf.return_value = return_value
+
+        dist = Distribution(model=model, params=params)
+        result = dist.pdf(x)
+
+        model.params_convert_to_model.assert_called_once_with(params)
+        model.pdf.assert_called_once_with(x, converted_params)
+        assert result == return_value
+
+    @given(valid_size(), valid_params())
+    def test_generate_with_generator_model(self, size, params):
+        model = MagicMock(spec=AModelWithGenerator)
+        converted_params = np.array([3.0, 4.0])
+        model.params_convert_to_model.return_value = converted_params
+        generated_samples = np.random.uniform(0, 1, size=size)
+        model.generate.return_value = generated_samples
+
+        dist = Distribution(model=model, params=params)
+        result = dist.generate(size=size)
+
+        model.params_convert_to_model.assert_called_once_with(params)
+        model.generate.assert_called_once_with(converted_params, size=size)
+        assert np.array_equal(result, generated_samples)
+
+    def test_generate_without_generator_raises_typeerror(self):
+        model = MagicMock(spec=AModel)
+        params = np.array([1.0, 2.0])
+
+        dist = Distribution(model=model, params=params)
+
+        with pytest.raises(TypeError):
+            dist.generate(size=3)
+
+
+class TestIntegrationDistribution:
+    @given(valid_x(), valid_params())
+    def test_pdf_integration(self, x, params):
+        model = MockModel()
+        dist = Distribution(model=model, params=params)
+
+        converted_params = model.params_convert_to_model(params)
+        expected = model.pdf(x, converted_params)
+        actual = dist.pdf(x)
+
+        assert actual == pytest.approx(expected)
+
+    @given(valid_size(), valid_params())
+    def test_generate_integration(self, size, params):
+        model = MockModelWithGenerator()
+
+        dist = Distribution(model=model, params=params)
+        result = dist.generate(size=size)
+
+        assert result.shape == (size,)
+        assert result.dtype == np.float64
+        assert np.all(result >= 0)
+        assert np.all(result < 1)
+
+    def test_generate_without_generator_raises_typeerror_integration(self):
+        model = MockModel()
+        params = np.array([1.0, 2.0])
+
+        dist = Distribution(model=model, params=params)
+
+        with pytest.raises(TypeError):
+            dist.generate(size=3)
+
+    @given(valid_x(), valid_params())
+    def test_pdf_consistent_results(self, x, params):
+        model = MockModel()
+        dist = Distribution(model=model, params=params)
+
+        result1 = dist.pdf(x)
+        result2 = dist.pdf(x)
+
+        assert result1 == pytest.approx(result2)