remove unnecessary attribute descriptions, move params_config to function argument

Author: adrianmolzon

bayes_opt/bayesian_optimization.py

@@ -76,27 +76,6 @@ class BayesianOptimization:
         This behavior may be desired in high noise situations where repeatedly probing
         the same point will give different answers. In other situations, the acquisition
         may occasionally generate a duplicate point.
-
-    Attributes
-    ----------
-    space : TargetSpace
-        The target space object containing the function to optimize.
-
-    acquisition_function : AcquisitionFunction
-        The acquisition function used to propose new points.
-
-    constraint : ConstraintModel or None
-        The constraint model, if any.
-
-    max : dict or None
-        Maximum target value observed and corresponding parameters.
-
-    res : list
-        All target values observed and corresponding parameters and timestamps.
-
-    logger : ScreenLogger
-        The logger used for displaying optimization progress.
-        You can customize the logger's properties (e.g., colors, verbosity, formatting).
     """
 
     def __init__(
@@ -167,11 +146,7 @@ def __init__(
         self._sorting_warning_already_shown = False  # TODO: remove in future version
 
         # Initialize logger
-        self.logger = ScreenLogger(
-            verbose=self._verbose,
-            is_constrained=self.is_constrained,
-            params_config=self._space._params_config,
-        )
+        self.logger = ScreenLogger(verbose=self._verbose, is_constrained=self.is_constrained)
 
     @property
     def space(self) -> TargetSpace:
@@ -234,7 +209,9 @@ def register(
             warn(msg, stacklevel=1)
             self._sorting_warning_already_shown = True
         self._space.register(params, target, constraint_value)
-        self.logger.log_optimization_step(self._space.keys, self._space.res()[-1], self.max)
+        self.logger.log_optimization_step(
+            self._space.keys, self._space.res()[-1], self._space.params_config, self.max
+        )
 
     def probe(self, params: ParamsType, lazy: bool = True) -> None:
         """Evaluate the function at the given points.
@@ -266,7 +243,9 @@ def probe(self, params: ParamsType, lazy: bool = True) -> None:
             self._queue.append(params)
         else:
             self._space.probe(params)
-            self.logger.log_optimization_step(self._space.keys, self._space.res()[-1], self.max)
+            self.logger.log_optimization_step(
+                self._space.keys, self._space.res()[-1], self._space.params_config, self.max
+            )
 
     def suggest(self) -> dict[str, float | NDArray[Float]]:
         """Suggest a promising point to probe next."""

bayes_opt/logger.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
-from datetime import datetime
 from typing import TYPE_CHECKING, Any
 
 from colorama import Fore, just_fix_windows_console
@@ -33,15 +32,9 @@ class ScreenLogger:
     _colour_regular_message = Fore.RESET
     _colour_reset = Fore.RESET
 
-    def __init__(
-        self,
-        verbose: int = 2,
-        is_constrained: bool = False,
-        params_config: Mapping[str, ParameterConfig] | None = None,
-    ) -> None:
+    def __init__(self, verbose: int = 2, is_constrained: bool = False) -> None:
         self._verbose = verbose
         self._is_constrained = is_constrained
-        self._params_config = params_config
         self._header_length = None
         self._iterations = 0
         self._previous_max = None
@@ -70,22 +63,6 @@ def is_constrained(self) -> bool:
         """Return whether the logger is constrained."""
         return self._is_constrained
 
-    @property
-    def params_config(self) -> Mapping[str, ParameterConfig] | None:
-        """Return the parameter configuration used for formatting."""
-        return self._params_config
-
-    @params_config.setter
-    def params_config(self, config: Mapping[str, ParameterConfig]) -> None:
-        """Set the parameter configuration used for formatting.
-
-        Parameters
-        ----------
-        config : Mapping[str, ParameterConfig]
-            New parameter configuration.
-        """
-        self._params_config = config
-
     def _format_number(self, x: float) -> str:
         """Format a number.
 
@@ -142,7 +119,11 @@ def _format_str(self, str_: str) -> str:
         return s
 
     def _print_step(
-        self, result: dict[str, Any], keys: list[str], colour: str = _colour_regular_message
+        self,
+        result: dict[str, Any],
+        keys: list[str],
+        params_config: Mapping[str, ParameterConfig],
+        colour: str = _colour_regular_message,
     ) -> str:
         """Print a step.
 
@@ -154,6 +135,9 @@ def _print_step(
         keys : list[str]
             The parameter keys.
 
+        params_config : Mapping[str, ParameterConfig]
+            The configuration to map the key to the parameter for correct formatting.
+
         colour : str, optional
             Color to use for the output.
             (Default value = _colour_regular_message, equivalent to Fore.RESET)
@@ -162,10 +146,6 @@ def _print_step(
         -------
         A stringified, formatted version of the most recent optimization step.
         """
-        if self._params_config is None:
-            err_msg = "Parameter configuration is not set. Call set_params_config before logging."
-            raise ValueError(err_msg)
-
         # iter, target, allowed [, *params]
         cells: list[str | None] = [None] * (3 + len(keys))
 
@@ -174,7 +154,7 @@ def _print_step(
             cells[2] = self._format_bool(result["allowed"])
         params = result.get("params", {})
         cells[3:] = [
-            self._params_config[key].to_string(val, self._default_cell_size) for key, val in params.items()
+            params_config[key].to_string(val, self._default_cell_size) for key, val in params.items()
         ]
 
         return "| " + " | ".join(colour + x + self._colour_reset for x in cells if x is not None) + " |"
@@ -241,20 +221,6 @@ def _update_tracker(self, current_max: dict[str, Any] | None) -> None:
             self._previous_max = current_max["target"]
             self._previous_max_params = current_max["params"]
 
-    def _time_metrics(self) -> tuple[str, float, float]:
-        """Return time passed since last call."""
-        now = datetime.now()  # noqa: DTZ005
-        if self._start_time is None:
-            self._start_time = now
-        if self._previous_time is None:
-            self._previous_time = now
-
-        time_elapsed = now - self._start_time
-        time_delta = now - self._previous_time
-
-        self._previous_time = now
-        return (now.strftime("%Y-%m-%d %H:%M:%S"), time_elapsed.total_seconds(), time_delta.total_seconds())
-
     def log_optimization_start(self, keys: list[str]) -> None:
         """Log the start of the optimization process.
 
@@ -268,7 +234,11 @@ def log_optimization_start(self, keys: list[str]) -> None:
             print(line, end="")
 
     def log_optimization_step(
-        self, keys: list[str], result: dict[str, Any], current_max: dict[str, Any] | None
+        self,
+        keys: list[str],
+        result: dict[str, Any],
+        params_config: Mapping[str, ParameterConfig],
+        current_max: dict[str, Any] | None,
     ) -> None:
         """Log an optimization step.
 
@@ -280,6 +250,9 @@ def log_optimization_step(
         result : dict[str, Any]
             The result dictionary for the most recent step.
 
+        params_config : Mapping[str, ParameterConfig]
+            The configuration to map the key to the parameter for correct formatting.
+
         current_max : dict[str, Any] | None
             The current maximum target value and its parameters.
         """
@@ -288,7 +261,7 @@ def log_optimization_step(
 
         if self._verbose != 1 or is_new_max:
             colour = self._colour_new_max if is_new_max else self._colour_regular_message
-            line = self._print_step(result, keys, colour=colour) + "\n"
+            line = self._print_step(result, keys, params_config, colour=colour) + "\n"
             if self._verbose:
                 print(line, end="")
 

tests/test_logger.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
 import io
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 
-import pytest
 from colorama import Fore
 
 from bayes_opt import BayesianOptimization
@@ -52,44 +51,6 @@ def test_is_constrained_property():
     assert logger.is_constrained
 
 
-def test_params_config_property():
-    """Test the params_config property getter and setter."""
-    # Test the getter with default initialization (None)
-    logger = ScreenLogger()
-    assert logger.params_config is None
-
-    # Test initialization with a params_config
-    mock_config = {"param1": MagicMock(), "param2": MagicMock()}
-    logger_with_config = ScreenLogger(params_config=mock_config)
-    assert logger_with_config.params_config is mock_config
-
-    # Test the setter
-    new_config = {"param3": MagicMock(), "param4": MagicMock()}
-    logger.params_config = new_config
-    assert logger.params_config is new_config
-
-    # Test that the logger actually uses the params_config
-    optimizer = BayesianOptimization(target_func, PBOUNDS, random_state=1)
-    logger.params_config = optimizer._space._params_config
-    optimizer.register(params={"p1": 1.5, "p2": 2.5}, target=4.0)
-
-    # This should not raise an error now that params_config is set
-    step_str = logger._print_step(optimizer._space.res()[-1], optimizer._space.keys)
-    assert "|" in step_str
-    assert "1" in step_str  # iteration
-    assert "4.0" in step_str  # target value
-
-
-def test_print_step_without_params_config():
-    """Test that _print_step raises an error when params_config is None."""
-    logger = ScreenLogger()
-    optimizer = BayesianOptimization(target_func, PBOUNDS, random_state=1)
-    optimizer.register(params={"p1": 1.5, "p2": 2.5}, target=4.0)
-
-    with pytest.raises(ValueError, match="Parameter configuration is not set"):
-        logger._print_step(optimizer._space.res()[-1], optimizer._space.keys)
-
-
 def test_format_number():
     """Test the _format_number method."""
     logger = ScreenLogger()
@@ -155,22 +116,23 @@ def test_step():
     """Test the _print_step method."""
     optimizer = BayesianOptimization(target_func, PBOUNDS, random_state=1)
 
-    # Create a logger with the params_config from the optimizer
-    logger = ScreenLogger(params_config=optimizer._space._params_config)
+    logger = ScreenLogger()
 
     # Register a point so we have something to log
     optimizer.register(params={"p1": 1.5, "p2": 2.5}, target=4.0)
 
     # Test default color
-    step_str = logger._print_step(optimizer._space.res()[-1], optimizer._space.keys)
+    step_str = logger._print_step(
+        optimizer._space.res()[-1], optimizer._space.keys, optimizer._space.params_config
+    )
     assert "|" in step_str
     assert "1" in step_str  # iteration
     assert "4.0" in step_str  # target value
 
     # Test with custom color
     custom_color = Fore.RED
     step_str_colored = logger._print_step(
-        optimizer._space.res()[-1], optimizer._space.keys, colour=custom_color
+        optimizer._space.res()[-1], optimizer._space.keys, optimizer._space.params_config, colour=custom_color
     )
     assert custom_color in step_str_colored
 
@@ -252,26 +214,6 @@ def test_update_tracker():
     assert logger._previous_max_params == {"p1": 2, "p2": 2}  # Updated
 
 
-def test_time_metrics():
-    """Test the _time_metrics method."""
-    logger = ScreenLogger()
-
-    # First call initializes times
-    time_str, total_elapsed, delta = logger._time_metrics()
-    assert isinstance(time_str, str)
-    assert isinstance(total_elapsed, float)
-    assert isinstance(delta, float)
-    assert delta <= 0.1  # First call should have very small delta
-
-    # Subsequent call should show time difference
-    import time
-
-    time.sleep(0.01)  # Small delay to ensure time difference
-    time_str2, total_elapsed2, delta2 = logger._time_metrics()
-    assert total_elapsed2 > total_elapsed
-    assert delta2 > 0
-
-
 @patch("sys.stdout", new_callable=io.StringIO)
 def test_log_optimization_start(mock_stdout):
     """Test the log_optimization_start method."""
@@ -297,8 +239,7 @@ def test_log_optimization_step(mock_stdout):
     """Test the log_optimization_step method."""
     optimizer = BayesianOptimization(target_func, PBOUNDS, random_state=1)
 
-    # Create a logger with the params_config from the optimizer
-    logger = ScreenLogger(params_config=optimizer._space._params_config)
+    logger = ScreenLogger()
 
     # Create logger with verbose=1 specifically, as this is the only verbose level
     # that doesn't print for non-max points according to the implementation:
@@ -317,14 +258,18 @@ def test_log_optimization_step(mock_stdout):
     # For a point that is not a new max with verbose=1, should not print
     mock_stdout.truncate(0)
     mock_stdout.seek(0)
-    logger.log_optimization_step(optimizer._space.keys, optimizer._space.res()[-1], optimizer.max)
+    logger.log_optimization_step(
+        optimizer._space.keys, optimizer._space.res()[-1], optimizer._space.params_config, optimizer.max
+    )
     assert mock_stdout.getvalue() == ""  # Nothing printed for non-max point with verbose=1
 
     # Register a higher value, which should trigger output with verbose=1
     optimizer.register(params={"p1": 2, "p2": 2}, target=4)
     mock_stdout.truncate(0)
     mock_stdout.seek(0)
-    logger.log_optimization_step(optimizer._space.keys, optimizer._space.res()[-1], optimizer.max)
+    logger.log_optimization_step(
+        optimizer._space.keys, optimizer._space.res()[-1], optimizer._space.params_config, optimizer.max
+    )
     max_output = mock_stdout.getvalue()
     assert max_output != ""  # Something printed for new max point with verbose=1
     assert "4.0" in max_output  # Should show target value