pyepo 2.2.2__tar.gz → 2.2.3__tar.gz

{pyepo-2.2.2 → pyepo-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyepo
-Version: 2.2.2
+Version: 2.2.3
 Summary: PyTorch-based End-to-End Predict-then-Optimize Tool
 Author-email: Bo Tang <bolucas.tang@mail.utoronto.ca>
 License: MIT
@@ -76,12 +76,18 @@ Dynamic: license-file
 
 ## Features
 
-- Implement **SPO+**, **DBB**, **NID**, **DPO** (additive and multiplicative perturbations), **PFYL** (additive and multiplicative perturbations), L2-regularized **RFWO/RFYL**, **NCE**, **LTR**, **I-MLE**, **AI-MLE**, and **PG**
+- Implement **SPO+**, **PG**, **DPO** (additive and multiplicative perturbations), **PFYL** (additive and multiplicative perturbations), **I-MLE**, **AI-MLE**, L2-regularized **RFWO/RFYL**, **DBB**, **NID**, **CaVE**, **NCE**, and **LTR**
 - Support [Gurobi](https://www.gurobi.com/), [COPT](https://shanshu.ai/copt), [Pyomo](http://www.pyomo.org/), [Google OR-Tools](https://developers.google.com/optimization), and [MPAX](https://github.com/MIT-Lu-Lab/MPAX) API
+- Symbolic modeling with `pyepo.dsl`: define an LP, MIP, or QP once, then compile it to any backend
+- JAX frontend (`pyepo.func.jax`): train any loss in JAX/Flax with `jax.grad`
 - Support parallel computing for optimization solvers
 - Support solution caching to speed up training
 - Support kNN robust loss to improve decision quality
 
+## CaVE for Binary Linear Programs
+
+For end-to-end learning on **binary linear programs** (TSP, CVRP, knapsack, ...), ``PyEPO`` ships **CaVE**. CaVE replaces the per-step ILP solve with a cone-alignment projection onto the binding-constraint normals at the true optimum, backed by an interior-point QP solver (Clarabel). Because the cone projection is far cheaper than the per-instance ILP solve, CaVE trains an order of magnitude faster than SPO+ at TSP scale.
+
 ## GPU-Accelerated Solving with MPAX
 
 ``PyEPO`` integrates [MPAX](https://github.com/MIT-Lu-Lab/MPAX), a JAX-based mathematical programming solver using the PDHG algorithm for GPU-accelerated optimization. Key advantages: (1) **GPU-native solving** — the first-order PDHG method runs efficiently on GPU; (2) **batch solving** — an entire mini-batch can be solved simultaneously via vectorization; (3) **no GPU-CPU data transfer overhead** — both the neural network and the solver stay on GPU, eliminating the data transfer bottleneck.

{pyepo-2.2.2 → pyepo-2.2.3}/README.md

@@ -4,12 +4,18 @@
 
 ## Features
 
-- Implement **SPO+**, **DBB**, **NID**, **DPO** (additive and multiplicative perturbations), **PFYL** (additive and multiplicative perturbations), L2-regularized **RFWO/RFYL**, **NCE**, **LTR**, **I-MLE**, **AI-MLE**, and **PG**
+- Implement **SPO+**, **PG**, **DPO** (additive and multiplicative perturbations), **PFYL** (additive and multiplicative perturbations), **I-MLE**, **AI-MLE**, L2-regularized **RFWO/RFYL**, **DBB**, **NID**, **CaVE**, **NCE**, and **LTR**
 - Support [Gurobi](https://www.gurobi.com/), [COPT](https://shanshu.ai/copt), [Pyomo](http://www.pyomo.org/), [Google OR-Tools](https://developers.google.com/optimization), and [MPAX](https://github.com/MIT-Lu-Lab/MPAX) API
+- Symbolic modeling with `pyepo.dsl`: define an LP, MIP, or QP once, then compile it to any backend
+- JAX frontend (`pyepo.func.jax`): train any loss in JAX/Flax with `jax.grad`
 - Support parallel computing for optimization solvers
 - Support solution caching to speed up training
 - Support kNN robust loss to improve decision quality
 
+## CaVE for Binary Linear Programs
+
+For end-to-end learning on **binary linear programs** (TSP, CVRP, knapsack, ...), ``PyEPO`` ships **CaVE**. CaVE replaces the per-step ILP solve with a cone-alignment projection onto the binding-constraint normals at the true optimum, backed by an interior-point QP solver (Clarabel). Because the cone projection is far cheaper than the per-instance ILP solve, CaVE trains an order of magnitude faster than SPO+ at TSP scale.
+
 ## GPU-Accelerated Solving with MPAX
 
 ``PyEPO`` integrates [MPAX](https://github.com/MIT-Lu-Lab/MPAX), a JAX-based mathematical programming solver using the PDHG algorithm for GPU-accelerated optimization. Key advantages: (1) **GPU-native solving** — the first-order PDHG method runs efficiently on GPU; (2) **batch solving** — an entire mini-batch can be solved simultaneously via vectorization; (3) **no GPU-CPU data transfer overhead** — both the neural network and the solver stay on GPU, eliminating the data transfer bottleneck.

pyepo-2.2.3/pyepo/data/_validation.py

@@ -0,0 +1,32 @@
+"""Shared validation for synthetic data generators."""
+
+import math
+from numbers import Real
+
+
+def validate_degree(deg: int) -> None:
+    """Validate a positive integer polynomial degree."""
+    if not isinstance(deg, int) or isinstance(deg, bool) or deg <= 0:
+        raise ValueError(f"deg = {deg} should be a positive integer.")
+
+
+def validate_nonnegative(value: float, name: str) -> None:
+    """Validate a finite, non-negative real generator parameter."""
+    if not isinstance(value, Real) or isinstance(value, bool):
+        raise ValueError(f"{name} = {value} should be a finite non-negative number.")
+    number = float(value)
+    if not math.isfinite(number) or number < 0:
+        raise ValueError(f"{name} = {value} should be a finite non-negative number.")
+
+
+def validate_probability(value: float, name: str) -> None:
+    """Validate a finite real value in the closed interval [0, 1]."""
+    validate_nonnegative(value, name)
+    if float(value) > 1:
+        raise ValueError(f"{name} = {value} should be in [0, 1].")
+
+
+def validate_positive_int(value: int, name: str) -> None:
+    """Validate a strictly positive integer parameter."""
+    if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
+        raise ValueError(f"{name} = {value} should be a positive integer.")

{pyepo-2.2.2 → pyepo-2.2.3}/pyepo/data/dataset.py

@@ -15,19 +15,48 @@ from torch.utils.data import Dataset
 from tqdm import tqdm
 
 from pyepo import EPO
+from pyepo.data._validation import validate_positive_int, validate_probability
 from pyepo.model.opt import optModel
 
 if TYPE_CHECKING:
     from pyepo.model.mpax import optMpaxModel as _optMpaxModelT
 
 try:
-    from pyepo.model.mpax import optMpaxModel
+    from pyepo.model.mpax import optMpaxModel as _opt_mpax_model_cls
 except ImportError:
-    optMpaxModel = None  # type: ignore[assignment]
+    _opt_mpax_model_cls = None
 
 logger = logging.getLogger(__name__)
 
 
+def _validate_inputs(
+    model: optModel,
+    feats: np.ndarray | torch.Tensor,
+    costs: np.ndarray | torch.Tensor,
+) -> None:
+    """Validate the common constructor contract for optimization datasets."""
+    if not isinstance(model, optModel):
+        raise TypeError("arg model is not an optModel")
+    if len(feats) != len(costs):
+        raise ValueError(
+            f"feats and costs must have the same number of instances: {len(feats)} vs {len(costs)}."
+        )
+
+
+def _as_float_tensor(data) -> torch.Tensor:
+    """Convert dataset arrays to the common float32 tensor representation."""
+    return torch.as_tensor(data, dtype=torch.float32)
+
+
+def _solution_to_numpy(
+    solution: np.ndarray | torch.Tensor | list,
+) -> np.ndarray:
+    """Normalize a solver solution to a NumPy array."""
+    if isinstance(solution, torch.Tensor):
+        solution = solution.detach().cpu().numpy()
+    return np.asarray(solution)
+
+
 class optDataset(Dataset):
     """
     PyTorch ``Dataset`` for predict-then-optimize problems.
@@ -62,44 +91,35 @@ class optDataset(Dataset):
             feats: data features
             costs: costs of objective function
         """
-        if not isinstance(model, optModel):
-            raise TypeError("arg model is not an optModel")
-        if len(feats) != len(costs):
-            raise ValueError(
-                f"feats and costs must have the same number of instances: "
-                f"{len(feats)} vs {len(costs)}."
-            )
+        _validate_inputs(model, feats, costs)
         self.model = model
         # data
         self.feats = feats
         self.costs = costs
         # find optimal solutions
-        sols, objs = self._getSols()
-        self.feats = torch.as_tensor(feats, dtype=torch.float32)
-        self.costs = torch.as_tensor(costs, dtype=torch.float32)
-        self.sols = torch.as_tensor(sols, dtype=torch.float32)
-        self.objs = torch.as_tensor(objs, dtype=torch.float32)
+        sols, objs = self._get_sols()
+        self.feats = _as_float_tensor(feats)
+        self.costs = _as_float_tensor(costs)
+        self.sols = _as_float_tensor(sols)
+        self.objs = _as_float_tensor(objs)
 
-    def _getSols(self) -> tuple[np.ndarray, np.ndarray]:
+    def _get_sols(self) -> tuple[np.ndarray, np.ndarray]:
         """
         A method to get optimal solutions for all cost vectors
         """
         # MPAX fast path: vmap-solve the whole dataset in a single dispatch
-        if optMpaxModel is not None and isinstance(self.model, optMpaxModel):
-            return self._getSolsMpaxBatch()
+        if _opt_mpax_model_cls is not None and isinstance(self.model, _opt_mpax_model_cls):
+            return self._get_sols_mpax_batch()
         sols = []
         objs = []
         logger.info("Optimizing for optDataset...")
         for c in tqdm(self.costs):
             sol, obj = self._solve(c)
-            # to numpy
-            if isinstance(sol, torch.Tensor):
-                sol = sol.detach().cpu().numpy()
-            sols.append(np.asarray(sol))
+            sols.append(_solution_to_numpy(sol))
             objs.append(obj)
         return np.stack(sols), np.asarray(objs).reshape(-1, 1)
 
-    def _getSolsMpaxBatch(self) -> tuple[np.ndarray, np.ndarray]:
+    def _get_sols_mpax_batch(self) -> tuple[np.ndarray, np.ndarray]:
         """
         A method to batch-solve every cost vector in one MPAX vmap call.
         """
@@ -209,20 +229,14 @@ class optDatasetKNN(optDataset):
             k: number of nearest neighbours selected
             weight: self-weight in the kNN convex combination (1.0 = no smoothing)
         """
-        if not isinstance(model, optModel):
-            raise TypeError("arg model is not an optModel")
-        if len(feats) != len(costs):
-            raise ValueError(
-                f"feats and costs must have the same number of instances: "
-                f"{len(feats)} vs {len(costs)}."
-            )
+        _validate_inputs(model, feats, costs)
         self.model = model
         # at most num_data-1 neighbours exist (self excluded), so k must stay below it
         num_data = len(feats)
-        if not 1 <= k < num_data:
+        validate_positive_int(k, "k")
+        if k >= num_data:
             raise ValueError(f"Invalid k={k}; must satisfy 1 <= k < num_data ({num_data}).")
-        if not 0.0 <= weight <= 1.0:
-            raise ValueError(f"Invalid weight={weight}; must satisfy 0 <= weight <= 1.")
+        validate_probability(weight, "weight")
         # kNN loss parameters
         self.k = k
         self.weight = weight
@@ -230,13 +244,13 @@ class optDatasetKNN(optDataset):
         self.feats = feats
         self.costs = costs
         # find optimal solutions
-        sols, objs = self._getSols()
-        self.feats = torch.as_tensor(self.feats, dtype=torch.float32)
-        self.costs = torch.as_tensor(self.costs, dtype=torch.float32)
-        self.sols = torch.as_tensor(sols, dtype=torch.float32)
-        self.objs = torch.as_tensor(objs, dtype=torch.float32)
+        sols, objs = self._get_sols()
+        self.feats = _as_float_tensor(self.feats)
+        self.costs = _as_float_tensor(self.costs)
+        self.sols = _as_float_tensor(sols)
+        self.objs = _as_float_tensor(objs)
 
-    def _getSols(self) -> tuple[np.ndarray, np.ndarray]:
+    def _get_sols(self) -> tuple[np.ndarray, np.ndarray]:
         """
         A method to get optimal solutions for all cost vectors
         """
@@ -244,16 +258,14 @@ class optDatasetKNN(optDataset):
         objs = []
         logger.info("Optimizing for optDataset...")
         # get kNN costs
-        costs_knn = self._getKNN()
+        costs_knn = self._get_knn()
         # solve optimization
         for c_knn in tqdm(costs_knn):
             sol_knn = np.zeros((self.costs.shape[1], self.k))
             obj_knn = np.zeros(self.k)
             for i, c in enumerate(c_knn.T):
                 sol_i, obj_i = self._solve(c)
-                if isinstance(sol_i, torch.Tensor):
-                    sol_i = sol_i.detach().cpu().numpy()
-                sol_knn[:, i] = sol_i
+                sol_knn[:, i] = _solution_to_numpy(sol_i)
                 obj_knn[i] = obj_i
             # get average
             sol = sol_knn.mean(axis=1)
@@ -264,7 +276,7 @@ class optDatasetKNN(optDataset):
         self.costs = costs_knn.mean(axis=2)
         return np.stack(sols), np.asarray(objs).reshape(-1, 1)
 
-    def _getKNN(self) -> np.ndarray:
+    def _get_knn(self) -> np.ndarray:
         """
         A method to get kNN costs
         """
@@ -334,28 +346,22 @@ class optDatasetConstrs(optDataset):
             costs: costs of objective function
             skip_infeas: if True, drop infeasible instances instead of raising
         """
-        if not isinstance(model, optModel):
-            raise TypeError("arg model is not an optModel")
-        if len(feats) != len(costs):
-            raise ValueError(
-                f"feats and costs must have the same number of instances: "
-                f"{len(feats)} vs {len(costs)}."
-            )
+        _validate_inputs(model, feats, costs)
         self.model = model
         self.skip_infeas = skip_infeas
         # data
         self.feats = feats
         self.costs = costs
         # find optimal solutions and binding constraints
-        sols, objs, ctrs, valid = self._getSols()
+        sols, objs, ctrs, valid = self._get_sols()
         # pre-convert to tensors (on CPU) to avoid repeated numpy→tensor copies
-        self.feats = torch.as_tensor(self.feats[valid], dtype=torch.float32)
-        self.costs = torch.as_tensor(self.costs[valid], dtype=torch.float32)
-        self.sols = torch.as_tensor(sols, dtype=torch.float32)
-        self.objs = torch.as_tensor(objs, dtype=torch.float32)
-        self.ctrs = [torch.as_tensor(c, dtype=torch.float32) for c in ctrs]
+        self.feats = _as_float_tensor(self.feats[valid])
+        self.costs = _as_float_tensor(self.costs[valid])
+        self.sols = _as_float_tensor(sols)
+        self.objs = _as_float_tensor(objs)
+        self.ctrs = [_as_float_tensor(c) for c in ctrs]
 
-    def _getSols(  # type: ignore[override]
+    def _get_sols(  # type: ignore[override]
         self,
     ) -> tuple[np.ndarray, np.ndarray, list[np.ndarray], list[int]]:
         """
@@ -371,9 +377,8 @@ class optDatasetConstrs(optDataset):
         logger.info("Optimizing for optDatasetConstrs...")
         model = self.model
         for i, c in enumerate(tqdm(self.costs)):
-            model._setFullObj(model._fullCost(c))
             try:
-                sol, obj = model.solve()
+                sol, obj = self._solve(c)
             except RuntimeError as e:
                 if self.skip_infeas:
                     logger.warning("Instance %d had no solution, skipping: %s", i, e)
@@ -413,12 +418,6 @@ class optDatasetConstrs(optDataset):
             raise ValueError("No valid instances (all skipped or empty input).")
         return np.stack(sols), np.asarray(objs), ctrs, valid
 
-    def __len__(self) -> int:
-        """
-        A method to get data size
-        """
-        return len(self.feats)
-
     def __getitem__(  # type: ignore[override]
         self,
         index: int,
@@ -563,13 +562,12 @@ def _parse_temp_constraint(
     """
     Parse a Gurobi TempConstr into (coefs, rhs, sense) over the cost-vector dim
     """
-    # TempConstr internals
-    lhs = getattr(tc, "_lhs", None)
-    rhs = getattr(tc, "_rhs", None)
-    sense = getattr(tc, "_sense", None)
-    # unparseable fallback
-    if lhs is None or rhs is None or sense is None:
+    from pyepo.model.grb.grbmodel import _temp_constr_fields
+
+    fields = _temp_constr_fields(tc)
+    if fields is None:
         return None
+    lhs, rhs, sense = fields
     # project LinExpr terms onto cost-vector dim
     coefs = np.zeros(num_cost, dtype=np.float64)
     for i in range(lhs.size()):

{pyepo-2.2.2 → pyepo-2.2.3}/pyepo/data/knapsack.py

@@ -7,6 +7,8 @@ from __future__ import annotations
 
 import numpy as np
 
+from pyepo.data._validation import validate_degree, validate_nonnegative
+
 
 def genData(
     num_data: int,
@@ -39,13 +41,8 @@ def genData(
     Returns:
        tuple: weights of items (np.ndarray), data features (np.ndarray), costs (np.ndarray)
     """
-    # positive integer parameter
-    if not isinstance(deg, int):
-        raise ValueError(f"deg = {deg} should be int.")
-    if deg <= 0:
-        raise ValueError(f"deg = {deg} should be positive.")
-    if noise_width < 0:
-        raise ValueError(f"noise_width = {noise_width} should be non-negative.")
+    validate_degree(deg)
+    validate_nonnegative(noise_width, "noise_width")
     # set seed
     rnd = np.random.RandomState(seed)
     # number of data points

{pyepo-2.2.2 → pyepo-2.2.3}/pyepo/data/portfolio.py

@@ -7,6 +7,8 @@ from __future__ import annotations
 
 import numpy as np
 
+from pyepo.data._validation import validate_degree, validate_nonnegative
+
 
 def genData(
     num_data: int,
@@ -40,11 +42,8 @@ def genData(
     Returns:
         tuple: covariance matrix (np.ndarray), data features (np.ndarray), mean returns (np.ndarray)
     """
-    # positive integer parameter
-    if not isinstance(deg, int):
-        raise ValueError(f"deg = {deg} should be int.")
-    if deg <= 0:
-        raise ValueError(f"deg = {deg} should be positive.")
+    validate_degree(deg)
+    validate_nonnegative(noise_level, "noise_level")
     # set seed
     rnd = np.random.RandomState(seed)
     # number of data points

{pyepo-2.2.2 → pyepo-2.2.3}/pyepo/data/shortestpath.py

@@ -7,6 +7,8 @@ from __future__ import annotations
 
 import numpy as np
 
+from pyepo.data._validation import validate_degree, validate_nonnegative
+
 
 def genData(
     num_data: int,
@@ -36,13 +38,8 @@ def genData(
     Returns:
        tuple: data features (np.ndarray), costs (np.ndarray)
     """
-    # positive integer parameter
-    if not isinstance(deg, int):
-        raise ValueError(f"deg = {deg} should be int.")
-    if deg <= 0:
-        raise ValueError(f"deg = {deg} should be positive.")
-    if noise_width < 0:
-        raise ValueError(f"noise_width = {noise_width} should be non-negative.")
+    validate_degree(deg)
+    validate_nonnegative(noise_width, "noise_width")
     # set seed
     rnd = np.random.RandomState(seed)
     # number of data points

{pyepo-2.2.2 → pyepo-2.2.3}/pyepo/data/tsp.py

@@ -8,6 +8,8 @@ from __future__ import annotations
 import numpy as np
 from scipy.spatial import distance
 
+from pyepo.data._validation import validate_degree, validate_nonnegative
+
 
 def genData(
     num_data: int,
@@ -38,13 +40,8 @@ def genData(
     Returns:
         tuple: data features (np.ndarray), costs (np.ndarray)
     """
-    # positive integer parameter
-    if not isinstance(deg, int):
-        raise ValueError(f"deg = {deg} should be int.")
-    if deg <= 0:
-        raise ValueError(f"deg = {deg} should be positive.")
-    if noise_width < 0:
-        raise ValueError(f"noise_width = {noise_width} should be non-negative.")
+    validate_degree(deg)
+    validate_nonnegative(noise_width, "noise_width")
     # set seed
     rnd = np.random.RandomState(seed)
     # number of data points

{pyepo-2.2.2 → pyepo-2.2.3}/pyepo/dsl/compiled.py

@@ -11,11 +11,14 @@ subclass builds the solver model and provides the read / write hooks.
 
 from __future__ import annotations
 
+from copy import deepcopy
+
 import numpy as np
 import torch
 
+from pyepo.model._common import validate_constraint, validate_objective_shape
 from pyepo.model.opt import optModel
-from pyepo.utils import costToNumpy, getArgs
+from pyepo.utils import costToNumpy
 
 
 class compiledBase(optModel):
@@ -25,11 +28,18 @@ class compiledBase(optModel):
 
     def __init__(self, problem, params=None):
         # the source DSL Problem and backend solver parameters
-        self.problem = problem
+        self.problem = deepcopy(problem)
         self.params = dict(params) if params else {}
         super().__init__()
         self._apply_params()
 
+    def get_config(self) -> dict:
+        return {
+            **super().get_config(),
+            "problem": deepcopy(self.problem),
+            "params": self.params.copy(),
+        }
+
     @property
     def num_cost(self) -> int:
         # predicted cost dimension
@@ -44,20 +54,18 @@ class compiledBase(optModel):
         """Set the objective from a predicted cost of length ``num_cost``, scattered onto the known fixed costs."""
         prob = self.problem
         coef = costToNumpy(c)
+        validate_objective_shape(coef, (prob.num_cost, prob.num_vars))
         # scatter onto fixed costs; an unambiguous full-length vector passes through
         if coef.shape[-1] == prob.num_cost:
             full = prob.fixed_cost.copy()
             full[prob.c_pred_index] += coef
             coef = full
-        elif coef.shape[-1] != prob.num_vars:
-            raise ValueError("Size of cost vector does not match number of cost variables.")
         self._write_obj(coef)
 
     def _setFullObj(self, c):
         """Set the objective from full-space coefficients (length ``num_vars``), bypassing the predicted-cost scatter."""
         coef = costToNumpy(c)
-        if coef.shape[-1] != self.problem.num_vars:
-            raise ValueError("Size of cost vector does not match number of variables.")
+        validate_objective_shape(coef, self.problem.num_vars, full=True)
         self._write_obj(coef)
 
     def _fullCost(self, pred_cost):
@@ -85,15 +93,16 @@ class compiledBase(optModel):
 
     def addConstr(self, coefs, rhs):
         # add a cut coefs @ x <= rhs over the full variable vector
-        coefs = np.asarray(coefs, dtype=float).reshape(-1)
+        rhs = validate_constraint(coefs, rhs, self.problem.num_vars, full=True)
+        coefs = np.array(coefs, dtype=float, copy=True).reshape(-1)
         new_model = self._add_cut(coefs, rhs)
         # track for replay on relax
-        new_model._extra_constrs = [*self._extra_constrs, (coefs, float(rhs))]
+        new_model._extra_constrs = [*self._extra_constrs, (coefs, rhs)]
         return new_model
 
     def relax(self):
         # recompile the relaxed problem, preserving backend kwargs
-        kwargs = getArgs(self)
+        kwargs = self.get_config()
         kwargs["problem"] = self.problem.relax()
         model_rel = type(self)(**kwargs)
         # replay user cuts on the relaxation

{pyepo-2.2.2 → pyepo-2.2.3}/pyepo/dsl/problem.py

@@ -62,6 +62,8 @@ class Problem:
         # objective cost layout
         self.cost_param = objective.cost_param
         self.cost_var = objective.cost_var
+        self.modelSense = objective.modelSense
+        self.cost_var_name = objective.cost_var.name
         # assign flat slices in encounter order (objective var first)
         self._assign_flat()
         # finalize IR
@@ -69,7 +71,7 @@ class Problem:
 
     def __repr__(self) -> str:
         # one-line summary of the finalized problem
-        sense = "min" if self.objective.modelSense == EPO.MINIMIZE else "max"
+        sense = "min" if self.modelSense == EPO.MINIMIZE else "max"
         n_quad = sum(1 for Q, *_ in self.constrs if Q is not None)
         quad = f" [{n_quad} quad]" if n_quad else ""
         obj_q = " +quad obj" if self.obj_Q is not None else ""
@@ -160,7 +162,7 @@ class Problem:
         Return a new Problem with all integer / binary variables continuous
         (bounds preserved: binary ⇒ [0, 1]); objective and constraints unchanged.
         """
-        new = _copy.copy(self)
+        new = _copy.deepcopy(self)
         new.var_type = np.full(self.num_vars, EPO.CONTINUOUS, dtype=object)
         return new
 

pyepo-2.2.3/pyepo/func/_common.py

@@ -0,0 +1,65 @@
+"""Backend-independent policies shared by the Torch and JAX frontends."""
+
+import math
+from numbers import Real
+from typing import Optional, TypeVar
+
+from pyepo import EPO
+
+T = TypeVar("T")
+
+
+def is_minimize(model_sense) -> bool:
+    """Return the objective direction, rejecting unsupported sense values."""
+    if model_sense == EPO.MINIMIZE:
+        return True
+    if model_sense == EPO.MAXIMIZE:
+        return False
+    raise ValueError("Invalid modelSense. Must be EPO.MINIMIZE or EPO.MAXIMIZE.")
+
+
+def solution_pool_tolerance(num_cost: int) -> float:
+    """L1 tolerance used to deduplicate approximate solver solutions."""
+    return min(1e-4 * num_cost, 0.1)
+
+
+def validate_positive(value, name: str) -> None:
+    """Validate a finite, strictly positive real parameter."""
+    if not isinstance(value, Real) or isinstance(value, bool):
+        raise ValueError(f"{name} must be a finite positive number.")
+    number = float(value)
+    if not math.isfinite(number) or number <= 0:
+        raise ValueError(f"{name} must be a finite positive number.")
+
+
+def validate_positive_int(value, name: str) -> None:
+    """Validate a strictly positive integer parameter."""
+    if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
+        raise ValueError(f"{name} must be a positive integer.")
+
+
+def validate_nonnegative(value, name: str) -> None:
+    """Validate a finite, non-negative real parameter."""
+    if not isinstance(value, Real) or isinstance(value, bool):
+        raise ValueError(f"{name} must be a finite non-negative number.")
+    number = float(value)
+    if not math.isfinite(number) or number < 0:
+        raise ValueError(f"{name} must be a finite non-negative number.")
+
+
+def validate_probability(value, name: str) -> None:
+    """Validate a finite real probability in the closed interval [0, 1]."""
+    if not isinstance(value, Real) or isinstance(value, bool):
+        raise ValueError(f"{name} must be a finite number in [0, 1].")
+    number = float(value)
+    if not math.isfinite(number) or not 0.0 <= number <= 1.0:
+        raise ValueError(f"{name} must be a finite number in [0, 1].")
+
+
+def require_solution_pool(solpool: Optional[T]) -> T:
+    """Return an initialized solution pool or raise a stable runtime error."""
+    if solpool is None:
+        raise RuntimeError(
+            "Solution pool is unavailable; provide an optDataset when pool-based solving is enabled."
+        )
+    return solpool