jcmoptimizer 3.0.9__tar.gz → 3.1.0__tar.gz

{jcmoptimizer-3.0.9 → jcmoptimizer-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jcmoptimizer
-Version: 3.0.9
+Version: 3.1.0
 Summary: The JCMoptimizer interface for Python
 Author-email: Philipp Schneider <philipp.schneider@jcmwave.com>
 License-Expression: MIT

{jcmoptimizer-3.0.9 → jcmoptimizer-3.1.0}/jcmoptimizer/benchmark.py

@@ -1,7 +1,6 @@
 from typing import Any, Callable, Literal, Optional, Union
 import time
 import datetime as dt
-import requests
 import atexit
 
 from .requestor import OptimizerRequestor, warn, inform

{jcmoptimizer-3.0.9 → jcmoptimizer-3.1.0}/jcmoptimizer/client.py

@@ -242,7 +242,7 @@ class Client:
 
             :name: Name of the parameter. E.g. ``'x1'``. The name should contain
                 no spaces and must not be equal to function names or mathematical
-                constants like ``'sin'``, ``'cos'``, ``'exp'``, ``'pi'`` etc.
+                constants like ``'sin'``, ``'cos'``, ``'exp'``, ``'PI'`` etc.
             :type: Type of the parameter. Either ``'variable'`` or ``'fixed'``.
                 Fixed parameters can be used in the constraint functions or other
                 expressions.

{jcmoptimizer-3.0.9 → jcmoptimizer-3.1.0}/jcmoptimizer/drivers/active_learning_drivers.py

@@ -1,10 +1,29 @@
 from typing import Any, Optional, Literal
-import requests
+import base64
 
 from .driver import Driver, Minimizer, LeastSquaresDriver
 from ..requestor import OptimizerRequestor
 
 class ActiveLearningDriver(Driver):
+    def download_neural_network(self, path: str, filename: str) -> None:
+        """Download a trained neural network ensemble artifact.
+
+        Args:
+          path: Dot-separated driver path to the neural network surrogate,
+            for example ``"surrogates.0"``.
+          filename: Target zip artifact path. The downloaded artifact can be
+            loaded with
+            :meth:`jcmoptimizer.utils.NeuralNetworkEnsemblePredictor.from_file`.
+        """
+        answer = self._post(
+            "download neural network",
+            "driver",
+            "export_neural_network",
+            data={"path": path},
+        )
+        with open(filename, "wb") as f:
+            f.write(base64.b64decode(answer["artifact"]))
+
     def describe(self) -> dict[str, Any]:
         """Get description of all modules and their parameters that are used
         by the driver. Example::
@@ -182,6 +201,11 @@ class ActiveLearningDriver(Driver):
               used for training the surrogate are neglected if their distance
               is smaller than min_dist (in terms of the length scales of the
               surrogate).
+
+        .. note:: This method only optimizes hyperparameters. If a surrogate
+            needs to be prepared or a neural network needs to be trained after
+            the hyperparameter update, call :func:`train` explicitly. The train
+            task saves the processed driver state.
         """
         self._run_task(
             "optimize hyperparameters",
@@ -189,6 +213,17 @@ class ActiveLearningDriver(Driver):
             data={"path": path, "num_samples": num_samples, "min_dist": min_dist},
         )
 
+    def train(self, path: Optional[str] = None) -> None:
+        """Prepare/train surrogate models explicitly. Example::
+
+            driver.train("driver.surrogates.0")
+
+        Args:
+          path: A dot-separated path to a surrogate. If no path is specified,
+              all surrogates are trained/prepared.
+        """
+        self._run_task("train", "train_surrogates", data={"path": path})
+
     def get_minima(
         self,
         object_type: Literal["surrogate", "variable", "objective"] = "objective",
@@ -822,6 +857,17 @@ class BayesianLeastSquares(SingleGPSingleVariable, LeastSquaresDriver):
         )
         return answer["state"]
 
+    @property
+    def covariance(self) -> list[list[float]]:
+        """Covariance matrix of the reconstructed continuous parameters."""
+        answer = self._post(
+            "get parameter covariance",
+            "driver",
+            "get_state",
+            data={"path": "variables.0.parameter_covariance"},
+        )
+        return answer["state"]
+
     def predict(
         self,
         points: list[list[float]],

{jcmoptimizer-3.0.9 → jcmoptimizer-3.1.0}/jcmoptimizer/drivers/driver.py

@@ -1,6 +1,4 @@
 from typing import Any, Optional, Union
-import requests
-import time
 
 from ..requestor import OptimizerRequestor
 
@@ -45,35 +43,7 @@ class Driver:
         return self._requestor.get(purpose, object, type, self.qualifier)
 
     def _run_task(self, purpose: str, task: str, data: dict[str, Any]) -> Any:
-        data["task"] = task
-        answer = self._post(purpose, "driver", "start_task", data=data)
-
-        print("\r" + purpose[0].capitalize() + purpose[1:] + ":      ", end="")
-        task_id = answer["task_id"]
-        try:
-            while True:
-                answer = self._post(
-                    purpose, "driver", "get_task_status", data={"task_id": task_id}
-                )
-
-                progress_msg = answer["progress_msg"]
-                status = answer["status"]
-                print("\r" + progress_msg + "      ", end="")
-
-                if status in ["stopped", "finished"]:
-                    print("")
-                    break
-                time.sleep(1)
-
-        except KeyboardInterrupt:
-            answer = self._post(
-                purpose, "driver", "stop_task", data={"task_id": task_id}
-            )
-
-        answer = self._post(
-            purpose, "driver", "fetch_task_result", data={"task_id": task_id}
-        )
-        return answer["result"]
+        return self._requestor.run_task(purpose, task, self.qualifier, data)
 
     def describe(self) -> dict[str, Any]:
         """Get description of all modules and their parameters that are used
@@ -129,7 +99,6 @@ class Driver:
         )
         return answer["values"]
 
-
 class Minimizer(Driver):
     """
     This class provides methods for retrieving and setting information of the
@@ -210,3 +179,14 @@ class LeastSquaresDriver(Minimizer):
             data={"path": "parameter_uncertainties"},
         )
         return answer["state"]
+
+    @property
+    def covariance(self) -> list[list[float]]:
+        """Covariance matrix of the reconstructed continuous parameters."""
+        answer = self._post(
+            "get parameter covariance",
+            "driver",
+            "get_state",
+            data={"path": "parameter_covariance"},
+        )
+        return answer["state"]

{jcmoptimizer-3.0.9 → jcmoptimizer-3.1.0}/jcmoptimizer/requestor.py

@@ -6,7 +6,6 @@ from datetime import datetime as dt
 from datetime import timedelta
 import json
 import itertools
-import threading
 import time
 
 template = 'Please install the package {p} (e.g. run "pip install {p}") .'
@@ -141,7 +140,7 @@ def parse_yaml(f: TextIO) -> dict[str, Any]:
                 "Expected format: key:value\n"
                 f"Found format: {line}"
             )
-        except SyntaxError as e:
+        except SyntaxError:
             raise SyntaxError(
                 f"Invalid format of config file "
                 f"at {f.name}:{line_num + 1}.\n"
@@ -206,7 +205,7 @@ class Requestor:
                 else:
                     raise NotImplementedError
 
-        except requests.exceptions.ConnectionError as e:
+        except requests.exceptions.ConnectionError:
             raise ConnectionError(
                 f"Could not connect to server at URL {self.endpoint}. "
                 "Please, check your internet connection and that the server is running."
@@ -366,3 +365,44 @@ class OptimizerRequestor(Requestor):
         r = self.request("POST", purpose, url, data=data)
         self._print_messages(r)
         return r.json()
+
+    def run_task(
+        self,
+        purpose: str,
+        task: str,
+        id: str,
+        data: dict[str, Any],
+    ) -> Any:
+        data["task"] = task
+        answer = self.post(purpose, "driver", "start_task", id=id, data=data)
+
+        print("\r" + purpose[0].capitalize() + purpose[1:] + ":      ", end="")
+        task_id = answer["task_id"]
+        try:
+            while True:
+                answer = self.post(
+                    purpose,
+                    "driver",
+                    "get_task_status",
+                    id=id,
+                    data={"task_id": task_id},
+                )
+
+                progress_msg = answer["progress_msg"]
+                status = answer["status"]
+                print("\r" + progress_msg + "      ", end="")
+
+                if status in ["stopped", "finished"]:
+                    print("")
+                    break
+                time.sleep(1)
+
+        except KeyboardInterrupt:
+            self.post(
+                purpose, "driver", "stop_task", id=id, data={"task_id": task_id}
+            )
+
+        answer = self.post(
+            purpose, "driver", "fetch_task_result", id=id, data={"task_id": task_id}
+        )
+        return answer["result"]

{jcmoptimizer-3.0.9 → jcmoptimizer-3.1.0}/jcmoptimizer/server.py

@@ -1,5 +1,4 @@
-from typing import Any, Optional, Union, Callable, Literal, TextIO
-from io import BufferedRandom
+from typing import Any, Optional, Literal
 import os
 import sys
 import json
@@ -8,11 +7,9 @@ import time
 import subprocess
 from datetime import datetime, timedelta
 import atexit
-import requests
 
 from .requestor import (
     read_yml_config_files,
-    warn,
     inform,
     CloudRequestor,
     show_working,
@@ -65,7 +62,7 @@ def _wait_for_server_startup(
     t0 = time.time()
     while time.time() - t0 < STARTUP_TIMEOUT:
         try:
-            client = Client(
+            Client(
                 host=host,
                 verbose=False,
                 cloud_endpoint=cloud_endpoint,
@@ -343,7 +340,7 @@ class Server:
     def _shutdown_at_exit(self) -> None:
         try:
             self.shutdown(force=True)
-        except ConnectionError as err:
+        except ConnectionError:
             pass
         
     def _start_local_server(
@@ -389,12 +386,12 @@ class Server:
             env["JCM_LICENSE_DIR"] = license_dir
 
         # Start JCMoptimizer
-        cmd: list[str] = [f'"{jcmoptimizer_exe}"']
+        cmd = [jcmoptimizer_exe]
         if port is not None:
-            cmd.append(f"--port {port}")
+            cmd.extend(["--port", str(port)])
         cmd.append("--print_json")
         if not persistent:
-            cmd.append(f"--calling_pid {os.getpid()}")
+            cmd.extend(["--calling_pid", str(os.getpid())])
         close_fds = os.name != "nt"
 
         # Generate temporary files for errors and log
@@ -402,9 +399,8 @@ class Server:
             tempfile.TemporaryFile() as error_file,
             tempfile.TemporaryFile() as log_file,
         ):
-            Popen(
-                " ".join(cmd),
-                shell=True,
+            server_proc = Popen(
+                cmd,
                 stdout=log_file,
                 stderr=error_file,
                 close_fds=close_fds,
@@ -414,36 +410,41 @@ class Server:
                 env=env,
             )
 
-            # Poll process for new output until first line with port information
-            line = b""
-            for _ in range(round(10 * timeout)):
-                error_file.seek(0)
-                if len(error_file.readlines()):
+            try:
+                # Poll process for new output until first line with port information
+                line = b""
+                for _ in range(round(10 * timeout)):
+                    error_file.seek(0)
+                    if len(error_file.readlines()):
+                        response = _server_response(log_file, error_file)
+                        raise EnvironmentError(
+                            "Could not start optimization server. "
+                            f"Server response: \n{response}"
+                        )
+
+                    log_file.seek(0)
+                    for line in iter(log_file.readline, b""):
+                        if line[:17] == b'{"optimizer_port"':
+                            break
+                    else:
+                        time.sleep(0.1)
+                        continue
+                    break
+                else:
                     response = _server_response(log_file, error_file)
+                    raise TimeoutError(response)
+                response = _server_response(log_file, error_file)
+                try:
+                    info = json.loads(line)
+                except Exception as err:
                     raise EnvironmentError(
                         "Could not start optimization server. "
                         f"Server response: \n{response}"
-                    )
-
-                log_file.seek(0)
-                for line in iter(log_file.readline, b""):
-                    if line[:17] == b'{"optimizer_port"':
-                        break
-                else:
-                    time.sleep(0.1)
-                    continue
-                break
-            else:
-                response = _server_response(log_file, error_file)
-                raise TimeoutError(response)
-            try:
-                info = json.loads(line)
-            except Exception as err:
-                response = _server_response(log_file, error_file)
-                raise EnvironmentError(
-                    "Could not start optimization server. "
-                    f"Server response: \n{response}"
-                ) from err
+                    ) from err
+            except BaseException:
+                server_proc.kill()
+                server_proc.wait(timeout=5)
+                raise
 
         self._port = int(info["optimizer_port"])
         self._pid = int(info["pid"])

{jcmoptimizer-3.0.9 → jcmoptimizer-3.1.0}/jcmoptimizer/study.py

@@ -1,10 +1,8 @@
 from typing import Any, Callable, Optional, Union
 import time
 import threading
-import warnings
 import traceback
 import atexit
-import requests
 from datetime import datetime, timedelta
 
 from .requestor import OptimizerRequestor, NumParallelError, warn
@@ -90,6 +88,11 @@ class Study:
             self._extend_shutdown_time(self._extend_on_suggestion)
         return result
 
+    def _run_task(self, purpose: str, task: str, data: dict[str, Any]) -> Any:
+        result = self._requestor.run_task(purpose, task, self.qualifier, data)
+        self._extend_shutdown_time(self._extend_on_request)
+        return result
+
     def _get(self, purpose: str, object: str, type: str) -> dict[str, Any]:
         result = self._requestor.get(purpose, object, type, self.qualifier)
         self._extend_shutdown_time(self._extend_on_request)
@@ -294,6 +297,7 @@ class Study:
         """
         observations: list[Observation] = []
         design_values: list[list[Union[float, str]]] = []
+        obs = self.new_observation()
         last_design_value = None
         for idx in range(len(data["value"])):
             design_value = data["design_value"][idx]
@@ -528,6 +532,13 @@ class Study:
            shown on the dashboard. To avoid this, one has to add the observations
            one by one using :func:`add_observation`.
 
+        .. note:: After adding many observations, we recommend explicitly running
+           :meth:`jcmoptimizer.ActiveLearning.optimize_hyperparameters` if desired,
+           followed by :meth:`jcmoptimizer.ActiveLearning.train`. This keeps the
+           bulk-import driver state clean
+           and makes the expensive processing steps and processed-state saving
+           explicit.
+
         """
         obs_data = []
         for o in observations:
@@ -535,7 +546,6 @@ class Study:
                 raise TypeError("observations -> expected Observation objects.")
             obs_data.append(o.data)
 
-        # todo: check
         self._post(
             "add observations",
             "observation",

jcmoptimizer-3.1.0/jcmoptimizer/utils/__init__.py

@@ -0,0 +1,5 @@
+"""Utility classes for specialized client workflows."""
+
+from .neural_network import NeuralNetworkEnsemblePredictor
+
+__all__ = ["NeuralNetworkEnsemblePredictor"]

jcmoptimizer-3.1.0/jcmoptimizer/utils/neural_network.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Optional, Union
+import io
+import json
+import zipfile
+
+if TYPE_CHECKING:
+    import torch
+
+
+class NeuralNetworkEnsemblePredictor:
+    """Client-side predictor for a downloaded neural network ensemble.
+
+    Use :meth:`from_file` to load an artifact created with
+    :meth:`jcmoptimizer.ActiveLearning.download_neural_network`. Predictions are
+    evaluated locally with PyTorch and return one prediction per ensemble
+    member.
+    """
+
+    def __init__(
+        self,
+        metadata: dict[str, Any],
+        member_model_bytes: bytes,
+        member_state_bytes: bytes,
+        device: Optional[Union[str, torch.device]] = None,
+    ) -> None:
+        """Create a predictor from loaded artifact metadata and model bytes.
+
+        Args:
+          metadata: Artifact metadata read from ``metadata.json``.
+          member_model_bytes: Serialized exported PyTorch member model.
+          member_state_bytes: Serialized stacked ensemble member state.
+          device: PyTorch device for prediction. If omitted, CUDA is used when
+            available and CPU otherwise.
+        """
+        if metadata.get("format") != "jcmoptimizer_neural_network_ensemble":
+            raise ValueError(
+                f"Unsupported neural network artifact format {metadata.get('format')!r}."
+            )
+        if metadata.get("artifact_type") != "torch_export_member_vmap":
+            raise ValueError(
+                "Unsupported neural network artifact type "
+                f"{metadata.get('artifact_type')!r}."
+            )
+
+        try:
+            import torch
+            from torch.func import functional_call, vmap
+        except ImportError as error:
+            raise ImportError(
+                "NeuralNetworkEnsemblePredictor requires PyTorch. "
+                "Install the optional torch dependency to use it."
+            ) from error
+
+        self.metadata = metadata
+        self._torch = torch
+        self.device = torch.device(
+            device if device is not None else "cuda" if torch.cuda.is_available() else "cpu"
+        )
+        exported_program = torch.export.load(io.BytesIO(member_model_bytes))
+        self.base_model = exported_program.module().to(self.device)
+        stacked_state = torch.load(
+            io.BytesIO(member_state_bytes), map_location=self.device, weights_only=True
+        )
+        parameter_names = {name for name, _ in self.base_model.named_parameters()}
+        buffer_names = {name for name, _ in self.base_model.named_buffers()}
+        self.params = {
+            name: value.to(self.device)
+            for name, value in stacked_state.items()
+            if name in parameter_names
+        }
+        self.buffers = {
+            name: value.to(self.device)
+            for name, value in stacked_state.items()
+            if name in buffer_names
+        }
+        self.dtype = self._infer_dtype(stacked_state)
+        self.num_input = int(metadata["num_input"])
+
+        def predict_member(
+            params: dict[str, torch.Tensor],
+            buffers: dict[str, torch.Tensor],
+            x: torch.Tensor,
+        ) -> torch.Tensor:
+            return functional_call(self.base_model, (params, buffers), (x,))
+
+        self._vmap = vmap(predict_member, in_dims=(0, 0, None))
+
+    @classmethod
+    def from_file(
+        cls,
+        filename: str,
+        device: Optional[Union[str, torch.device]] = None,
+    ) -> "NeuralNetworkEnsemblePredictor":
+        """Load a downloaded neural network ensemble artifact.
+
+        Args:
+          filename: Path to the zip artifact written by
+            :meth:`jcmoptimizer.ActiveLearning.download_neural_network`.
+          device: PyTorch device for prediction. If omitted, CUDA is used when
+            available and CPU otherwise.
+
+        Returns:
+          A predictor that evaluates the ensemble locally.
+        """
+        with zipfile.ZipFile(filename, "r") as zf:
+            metadata = json.loads(zf.read("metadata.json").decode("utf-8"))
+            member_model_bytes = zf.read(metadata["member_model_file"])
+            member_state_bytes = zf.read(metadata["member_state_file"])
+        return cls(metadata, member_model_bytes, member_state_bytes, device=device)
+
+    def _infer_dtype(self, stacked_state: dict[str, torch.Tensor]) -> torch.dtype:
+        for value in stacked_state.values():
+            if self._torch.is_tensor(value) and value.is_floating_point():
+                return value.dtype
+        return self._torch.get_default_dtype()
+
+    def predict(self, x: Union[torch.Tensor, list[list[float]]]) -> torch.Tensor:
+        """Predict for one or more input points.
+
+        Args:
+          x: Input points with shape ``(num_points, num_input)``. For
+            one-dimensional input spaces, a one-dimensional sequence is also
+            accepted and interpreted as multiple points.
+
+        Returns:
+          Tensor with shape ``(num_models, num_points, num_output)``.
+        """
+        x_tensor = self._torch.as_tensor(x, dtype=self.dtype, device=self.device)
+        if x_tensor.ndim == 1:
+            if self.num_input != 1:
+                raise ValueError(
+                    f"Expected input with {self.num_input} columns, got a 1D input."
+                )
+            x_tensor = x_tensor.reshape(-1, 1)
+        if x_tensor.ndim != 2 or x_tensor.shape[1] != self.num_input:
+            raise ValueError(
+                f"Expected input of shape (num_points, {self.num_input}), "
+                f"got {tuple(x_tensor.shape)}."
+            )
+        return self._vmap(self.params, self.buffers, x_tensor)

jcmoptimizer-3.1.0/jcmoptimizer/version.py

@@ -0,0 +1 @@
+__version__ = '3.1.0'

{jcmoptimizer-3.0.9 → jcmoptimizer-3.1.0}/jcmoptimizer.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jcmoptimizer
-Version: 3.0.9
+Version: 3.1.0
 Summary: The JCMoptimizer interface for Python
 Author-email: Philipp Schneider <philipp.schneider@jcmwave.com>
 License-Expression: MIT

{jcmoptimizer-3.0.9 → jcmoptimizer-3.1.0}/jcmoptimizer.egg-info/SOURCES.txt

@@ -17,4 +17,6 @@ jcmoptimizer.egg-info/top_level.txt
 jcmoptimizer/drivers/__init__.py
 jcmoptimizer/drivers/active_learning_drivers.py
 jcmoptimizer/drivers/driver.py
-jcmoptimizer/drivers/third_party_drivers.py
+jcmoptimizer/drivers/third_party_drivers.py
+jcmoptimizer/utils/__init__.py
+jcmoptimizer/utils/neural_network.py

jcmoptimizer-3.0.9/jcmoptimizer/version.py

@@ -1 +0,0 @@
-__version__ = '3.0.9'