0.15.12

- hidden_size generatot in nn_linear_regressor.py
- anisotropic is set to default in spot.py

Author: bartzbeielstein

notebooks/00_spotPython_tests.ipynb

@@ -4836,6 +4836,90 @@
         "spot_tuner = load_and_run_spot_python_experiment(\"spot_000_experiment.pickle\")"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Lightning "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def _generate_div2_list(n, n_min) -> list:\n",
+        "    \"\"\"\n",
+        "    Generate a list of numbers from n to n_min (inclusive) by dividing n by 2\n",
+        "    until the result is less than n_min.\n",
+        "    This function starts with n and keeps dividing it by 2 until n_min is reached.\n",
+        "    The number of times each value is added to the list is determined by n // current.\n",
+        "\n",
+        "    Args:\n",
+        "        n (int): The number to start with.\n",
+        "        n_min (int): The minimum number to stop at.\n",
+        "\n",
+        "    Returns:\n",
+        "        list: A list of numbers from n to n_min (inclusive).\n",
+        "\n",
+        "    Examples:\n",
+        "        _generate_div2_list(10, 1)\n",
+        "        [10, 5, 5, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]\n",
+        "        _generate_div2_list(10, 2)\n",
+        "        [10, 5, 5, 2, 2, 2, 2, 2]\n",
+        "    \"\"\"\n",
+        "    result = []\n",
+        "    current = n\n",
+        "    repeats = 1\n",
+        "    max_repeats = 4\n",
+        "    while current >= n_min:\n",
+        "        result.extend([current] * min(repeats, max_repeats))\n",
+        "        current = current // 2\n",
+        "        repeats = repeats + 1\n",
+        "    return result"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "[10, 5, 5]"
+            ]
+          },
+          "execution_count": 14,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "_generate_div2_list(10, 3)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "[128, 64, 64, 32, 32, 32]"
+            ]
+          },
+          "execution_count": 17,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "_generate_div2_list(128, 32)"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,

pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spotpython"
-version = "0.15.11"
+version = "0.15.12"
 authors = [
   { name="T. Bartz-Beielstein", email="tbb@bartzundbartz.de" }
 ]

src/spotpython/light/regression/netlightregression.py

@@ -155,7 +155,7 @@ def __init__(
         if self.hparams.l1 < 4:
             raise ValueError("l1 must be at least 4")
 
-        # TODO: Implement a hidden_sizes generator function. 
+        # TODO: Implement a hidden_sizes generator function.
         # This function is implemented in the updadated version of this class which
         # is available as nn_linear_regression.py in the same directory.
         hidden_sizes = [self.hparams.l1, self.hparams.l1 // 2, self.hparams.l1 // 2, self.hparams.l1 // 4]

src/spotpython/light/regression/nn_linear_regressor.py

@@ -3,6 +3,7 @@
 from torch import nn
 from spotpython.hyperparameters.optimizer import optimizer_handler
 import torchmetrics.functional.regression
+from spotpython.utils.math import generate_div2_list
 
 
 class NNLinearRegressor(L.LightningModule):
@@ -164,14 +165,7 @@ def __init__(
         self.example_input_array = torch.zeros((batch_size, self._L_in))
         if self.hparams.l1 < 4:
             raise ValueError("l1 must be at least 4")
-
-        # TODO: Implement a hidden_sizes generator function
-        hidden_sizes = [self.hparams.l1, self.hparams.l1 // 2, self.hparams.l1 // 2, self.hparams.l1 // 4]
-        # n_low = _L_in // 4
-        # # ensure that n_high is larger than n_low
-        # n_high = max(self.hparams.l1, 2 * n_low)
-        # hidden_sizes = generate_div2_list(n_high, n_low)
-
+        hidden_sizes = self._get_hidden_sizes()
         # Create the network based on the specified hidden sizes
         layers = []
         layer_sizes = [self._L_in] + hidden_sizes
@@ -187,6 +181,19 @@ def __init__(
         # nn.Sequential summarizes a list of modules into a single module, applying them in sequence
         self.layers = nn.Sequential(*layers)
 
+    def _get_hidden_sizes(self):
+        """
+        Generate the hidden layer sizes for the network.
+
+        Returns:
+            list: A list of hidden layer sizes.
+
+        """
+        n_low = self._L_in // 4
+        n_high = max(self.hparams.l1, 2 * n_low)
+        hidden_sizes = generate_div2_list(n_high, n_low)
+        return hidden_sizes
+
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         """
         Performs a forward pass through the model.

src/spotpython/spot/spot.py

@@ -311,7 +311,7 @@ def __init__(
             if self.surrogate_control["n_theta"] == "anisotropic":
                 surrogate_control.update({"n_theta": self.k})
             else:
-            # case "isotropic":
+                # case "isotropic":
                 surrogate_control.update({"n_theta": 1})
         if isinstance(self.surrogate_control["n_theta"], int):
             if self.surrogate_control["n_theta"] > 1:
@@ -2146,7 +2146,8 @@ def get_importance(self) -> list:
 
         Returns:
             output (list):
-                list of results. If the surrogate has more than one theta values, the importance is calculated. Otherwise, a list of zeros is returned.
+                list of results. If the surrogate has more than one theta values,
+                the importance is calculated. Otherwise, a list of zeros is returned.
 
         """
         if self.surrogate.n_theta > 1 and self.var_name is not None:

src/spotpython/utils/file.py

@@ -7,7 +7,6 @@
 import importlib
 from spotpython.hyperparameters.values import get_tuned_architecture
 from spotpython.utils.eda import gen_design_table
-from spotpython.utils.tensorboard import start_tensorboard, stop_tensorboard
 from spotpython.utils.init import setup_paths