openscvx 0.4.1.dev152__tar.gz → 0.4.1.dev153__tar.gz

{openscvx-0.4.1.dev152/openscvx.egg-info → openscvx-0.4.1.dev153}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.4.1.dev152
+Version: 0.4.1.dev153
 Summary: A general Python-based successive convexification implementation which uses a JAX backend.
 Author-email: Chris Hayner and Griffin Norris <haynec@uw.edu>
 License: Apache Software License

{openscvx-0.4.1.dev152 → openscvx-0.4.1.dev153}/examples/abstract/stl_or.py

@@ -89,14 +89,9 @@ problem = Problem(
     controls=controls,
     N=N,
     time=time,
-    algorithm={"autotuner": ox.ConstantProximalWeight()},
     float_dtype="float64",
 )
 
-problem.algorithm.lam_vb = 1e2
-
-problem.algorithm.lam_vc = 1e1
-
 if __name__ == "__main__":
     problem.initialize()
     results = problem.solve()

{openscvx-0.4.1.dev152 → openscvx-0.4.1.dev153}/examples/car/dubins_car_stl_or.py

@@ -92,8 +92,8 @@ wp1_pred = ox.linalg.Norm(position - wp1_center) <= wp1_radius
 wp2_pred = ox.linalg.Norm(position - wp2_center) <= wp2_radius
 
 # Visit waypoint constraints using symbolic Or
-# Note: visit_wp_or_expr is already a constraint, so we can use .over() directly
-constraints.append(ox.stl.Or(wp1_pred, wp2_pred).over((3, 5), penalty="squared_relu"))
+# Note: visit_wp_or_expr is already a constraint, so we can use .at() directly
+constraints.append(ox.stl.Or(wp1_pred, wp2_pred).at([3, 4, 5]))
 
 # Build the problem
 constraints.append((time.at(5) - time.at(3) == 1.23).convex())
@@ -105,6 +105,7 @@ problem = Problem(
     time=time,  # Time is already defined above as ox.Time
     constraints=constraints,
     N=n,
+    algorithm={"autotuner": ox.AugmentedLagrangian(eta_lambda=1e0), "lam_vb": 1e0},
     float_dtype="float64",
 )
 

{openscvx-0.4.1.dev152 → openscvx-0.4.1.dev153}/examples/car/dubins_car_waypoint_stl.py

@@ -85,7 +85,7 @@ safety_region = ox.linalg.Norm(position - obs_center) <= 1.6
 # Globally the control bound is 10.0; inside the waypoint window we restrict to 1.0.
 slow_speed_in_waypoint = ox.linalg.Norm(speed) <= 1.0
 
-speed_constraint = ox.stl.IfThen(safety_region, slow_speed_in_waypoint, c=1e-18)
+speed_constraint = ox.stl.IfThen(safety_region, slow_speed_in_waypoint, c=1e-2)
 
 constraints.append(
     speed_constraint.over(
@@ -128,12 +128,12 @@ problem = Problem(
     N=n,
     algorithm={"autotuner": ox.RampProximalWeight()},
     float_dtype="float64",
-    licq_max=1e-8,
+    licq_max=1e-10,
 )
 
-problem.algorithm.ep_vc = 1e-6
-problem.algorithm.ep_tr = 5e-4
-problem.algorithm.lam_vc = 1e3
+# problem.algorithm.ep_vc = 1e-6
+# problem.algorithm.ep_tr = 5e-4
+problem.algorithm.lam_vc = 2e3
 
 plotting_dict = {
     "obs_radius": problem.parameters["obs_radius"],

{openscvx-0.4.1.dev152 → openscvx-0.4.1.dev153}/examples/drone/dr_vp_nodal.py

@@ -226,11 +226,8 @@ problem = Problem(
     constraints=constraints,
     N=n,
     algorithm={
-        "lam_prox": 8e1,
-        "lam_cost": 2e1,
         "lam_vc": 1e2,
         "lam_vb": 4e0,
-        "ep_tr": 1e-3,
     },
 )
 

{openscvx-0.4.1.dev152 → openscvx-0.4.1.dev153}/openscvx/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.4.1.dev152'
-__version_tuple__ = version_tuple = (0, 4, 1, 'dev152')
+__version__ = version = '0.4.1.dev153'
+__version_tuple__ = version_tuple = (0, 4, 1, 'dev153')
 
-__commit_id__ = commit_id = 'gd78c3c228'
+__commit_id__ = commit_id = 'g8bdc94692'

{openscvx-0.4.1.dev152 → openscvx-0.4.1.dev153}/openscvx/algorithms/augmented_lagrangian.py

@@ -59,7 +59,7 @@ class AugmentedLagrangian(AutotuningBase):
         eta_1: float = 1e-1,
         eta_2: float = 0.8,
         ep: float = 0.5,
-        eta_lambda: float = 1e0,
+        eta_lambda: float = 1e1,
         lam_vc_max: float = 1e5,
         lam_prox_min: float = 1e-3,
         lam_prox_max: float = 2e5,
@@ -134,6 +134,91 @@ class AugmentedLagrangian(AutotuningBase):
         vc_new = np.where(mask, case1, case2)
         return np.minimum(self.lam_vc_max, vc_new)
 
+    def _update_virtual_buffer_nodal_weights(
+        self,
+        candidate: "CandidateIterate",
+        nodal_constraints: "LoweredJaxConstraints",
+        params: dict,
+        lam_vb_nodal: np.ndarray,
+        lam_prox: np.ndarray,
+    ) -> np.ndarray:
+        """
+        !!! warning
+            This code is WIP and may not be correct.
+
+        TODO: (haynec) Flush this out.
+
+        Update virtual buffer penalty weights for nodal constraints.
+
+        Evaluates each nodal constraint to obtain violation
+        nu = max(0, g(x, u)), then applies the same two-case update rule
+        used for virtual control weights: linear when nu > ep, quadratic
+        otherwise. Result is clipped to lam_vc_max.
+        """
+        lam_vb_new = lam_vb_nodal.copy()
+        lam_prox_scalar = float(np.max(lam_prox))
+        scale = self.eta_lambda * (1 / (2 * lam_prox_scalar))
+
+        for idx, constraint in enumerate(nodal_constraints.nodal):
+            g = constraint.func(candidate.x, candidate.u, 0, params)
+            nu = np.maximum(0, g)
+
+            if constraint.nodes is not None:
+                nodes_array = np.array(constraint.nodes)
+                nu_slice = nu[nodes_array]
+                current = lam_vb_nodal[nodes_array, idx]
+            else:
+                nu_slice = nu
+                current = lam_vb_nodal[:, idx]
+
+            mask = nu_slice > self.ep
+            case1 = current + nu_slice * scale
+            case2 = current + (nu_slice**2) / self.ep * scale
+            updated = np.where(mask, case1, case2)
+
+            if constraint.nodes is not None:
+                lam_vb_new[nodes_array, idx] = updated
+            else:
+                lam_vb_new[:, idx] = updated
+
+        return np.minimum(self.lam_vc_max, lam_vb_new)
+
+    def _update_virtual_buffer_cross_weights(
+        self,
+        candidate: "CandidateIterate",
+        nodal_constraints: "LoweredJaxConstraints",
+        params: dict,
+        lam_vb_cross: np.ndarray,
+        lam_prox: np.ndarray,
+    ) -> np.ndarray:
+        """
+        !!! warning
+            This code is WIP and may not be correct.
+
+        TODO: (haynec) Flush this out.
+
+        Update virtual buffer penalty weights for cross-node constraints.
+
+        Evaluates each cross-node constraint to obtain total violation
+        nu = sum(max(0, g(X, U))), then applies the same two-case update
+        rule used for virtual control weights. Result is clipped to lam_vc_max.
+        """
+        lam_vb_new = lam_vb_cross.copy()
+        lam_prox_scalar = float(np.max(lam_prox))
+        scale = self.eta_lambda * (1 / (2 * lam_prox_scalar))
+
+        for idx, constraint in enumerate(nodal_constraints.cross_node):
+            g = constraint.func(candidate.x, candidate.u, params)
+            nu = np.sum(np.maximum(0, g))
+
+            current = lam_vb_cross[idx]
+            if nu > self.ep:
+                lam_vb_new[idx] = current + nu * scale
+            else:
+                lam_vb_new[idx] = current + (nu**2) / self.ep * scale
+
+        return np.minimum(self.lam_vc_max, lam_vb_new)
+
     def update_weights(
         self,
         state: "AlgorithmState",
@@ -225,51 +310,45 @@ class AugmentedLagrangian(AutotuningBase):
             if rho < self.eta_0:
                 # Reject Solution and higher weight
                 lam_prox_k1 = np.minimum(self.lam_prox_max, self.gamma_1 * lam_prox_k)
-                state.lam_prox_history.append(lam_prox_k1)
+                candidate.lam_prox = lam_prox_k1
+                state.reject_solution(candidate)
                 adaptive_state = "Reject Higher"
             elif rho >= self.eta_0 and rho < self.eta_1:
                 # Accept Solution with heigher weight
                 lam_prox_k1 = np.minimum(self.lam_prox_max, self.gamma_1 * lam_prox_k)
-                state.lam_prox_history.append(lam_prox_k1)
-
+                candidate.lam_prox = lam_prox_k1
                 # Update virtual control weight matrix
                 candidate.lam_vc = self._update_virtual_control_weights(
-                    candidate, candidate_x_prop, settings, state.lam_vc, state.lam_prox
+                    candidate, candidate_x_prop, settings, state.lam_vc, candidate.lam_prox
                 )
-                candidate.lam_vb_nodal = state.lam_vb_nodal
-                candidate.lam_vb_cross = state.lam_vb_cross
 
                 state.accept_solution(candidate)
                 adaptive_state = "Accept Higher"
             elif rho >= self.eta_1 and rho < self.eta_2:
                 # Accept Solution with constant weight
                 lam_prox_k1 = lam_prox_k
-                state.lam_prox_history.append(lam_prox_k1)
-
+                candidate.lam_prox = lam_prox_k1
                 # Update virtual control weight matrix
                 candidate.lam_vc = self._update_virtual_control_weights(
-                    candidate, candidate_x_prop, settings, state.lam_vc, state.lam_prox
+                    candidate, candidate_x_prop, settings, state.lam_vc, candidate.lam_prox
                 )
-                candidate.lam_vb_nodal = state.lam_vb_nodal
-                candidate.lam_vb_cross = state.lam_vb_cross
 
                 state.accept_solution(candidate)
                 adaptive_state = "Accept Constant"
             else:
                 # Accept Solution with lower weight
                 lam_prox_k1 = np.maximum(self.lam_prox_min, self.gamma_2 * lam_prox_k)
-                state.lam_prox_history.append(lam_prox_k1)
+                candidate.lam_prox = lam_prox_k1
                 # Update virtual control weight matrix
                 candidate.lam_vc = self._update_virtual_control_weights(
-                    candidate, candidate_x_prop, settings, state.lam_vc, state.lam_prox
+                    candidate, candidate_x_prop, settings, state.lam_vc, candidate.lam_prox
                 )
-                candidate.lam_vb_nodal = state.lam_vb_nodal
-                candidate.lam_vb_cross = state.lam_vb_cross
+
                 state.accept_solution(candidate)
                 adaptive_state = "Accept Lower"
 
         else:
-            state.lam_prox_history.append(lam_prox_k)
+            candidate.lam_prox = lam_prox_k
             candidate.lam_vc = state.lam_vc
             candidate.lam_vb_nodal = state.lam_vb_nodal
             candidate.lam_vb_cross = state.lam_vb_cross

{openscvx-0.4.1.dev152 → openscvx-0.4.1.dev153}/openscvx/algorithms/base.py

@@ -740,7 +740,6 @@ class AlgorithmState:
 
     def accept_solution(self, cand: CandidateIterate) -> None:
         """Accept the given candidate iterate by updating the state in place."""
-
         if cand.x is None or cand.u is None:
             raise ValueError(
                 "No candidate iterate to accept. Expected algorithm to set "
@@ -775,6 +774,8 @@ class AlgorithmState:
         if cand.TR is not None:
             self.TR_history.append(cand.TR)
 
+        if cand.lam_prox is not None:
+            self.lam_prox_history.append(cand.lam_prox)
         if cand.lam_vc is not None:
             self.lam_vc_history.append(cand.lam_vc)
         if cand.lam_cost is not None:
@@ -789,6 +790,21 @@ class AlgorithmState:
         if cand.J_lin is not None:
             self.J_lin_history.append(cand.J_lin)
 
+    def reject_solution(self, cand: CandidateIterate) -> None:
+        """Reject the current candidate and update only the trust-region weight.
+
+        This is intended for autotuners that decide to *reject* a candidate
+        iterate but still want to adapt the proximal (trust-region) weight
+        for the next solve. The new trust region weight is taken from
+        ``cand.lam_prox`` (shape ``(N, n_states + n_controls)``) and appended
+        to the history. It does **not** modify trajectories or any other
+        histories.
+
+        Args:
+            cand: The rejected candidate iterate; its ``lam_prox`` is recorded.
+        """
+        self.lam_prox_history.append(cand.lam_prox)
+
     @property
     def x(self) -> np.ndarray:
         """Get current state trajectory array.

{openscvx-0.4.1.dev152 → openscvx-0.4.1.dev153}/openscvx/algorithms/constant_proximal_weight.py

@@ -57,6 +57,6 @@ class ConstantProximalWeight(AutotuningBase):
         else:
             candidate.lam_cost = weights.lam_cost
 
-        state.lam_prox_history.append(state.lam_prox)
+        candidate.lam_prox = state.lam_prox
         state.accept_solution(candidate)
         return "Accept Constant"

{openscvx-0.4.1.dev152 → openscvx-0.4.1.dev153}/openscvx/algorithms/ramp_proximal_weight.py

@@ -67,7 +67,7 @@ class RampProximalWeight(AutotuningBase):
 
         # Calculate and append new value
         new_lam_prox = np.minimum(state.lam_prox * self.ramp_factor, self.lam_prox_max)
-        state.lam_prox_history.append(new_lam_prox)
+        candidate.lam_prox = new_lam_prox
 
         # If we were already at max, or if we just reached it and it's staying constant
         if was_at_max:

{openscvx-0.4.1.dev152 → openscvx-0.4.1.dev153/openscvx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.4.1.dev152
+Version: 0.4.1.dev153
 Summary: A general Python-based successive convexification implementation which uses a JAX backend.
 Author-email: Chris Hayner and Griffin Norris <haynec@uw.edu>
 License: Apache Software License

{openscvx-0.4.1.dev152 → openscvx-0.4.1.dev153}/tests/test_autotuning.py

@@ -1024,8 +1024,12 @@ def test_augmented_lagrangian_accept_decrease(
     assert len(algorithm_state.X) == initial_x_len + 1
     assert len(algorithm_state.lam_vc_history) == 2
     assert np.allclose(algorithm_state.lam_vc_history[-1], candidate.lam_vc)
-    assert len(algorithm_state.lam_vb_nodal_history) == 2
-    assert len(algorithm_state.lam_vb_cross_history) == 2
+    # Virtual buffer weight updates are currently disabled (commented out),
+    # so these histories should not grow in accept branches.
+    assert candidate.lam_vb_nodal is None
+    assert candidate.lam_vb_cross is None
+    assert len(algorithm_state.lam_vb_nodal_history) == 1
+    assert len(algorithm_state.lam_vb_cross_history) == 1
     assert len(algorithm_state.lam_cost_history) == 2
     assert algorithm_state.lam_cost_history[-1] == pytest.approx(candidate.lam_cost)
 
@@ -1183,13 +1187,14 @@ def test_augmented_lagrangian_accept_higher(
     # Candidate should have updated virtual control weights and be accepted,
     # and those weights must be recorded back into the algorithm_state histories.
     assert candidate.lam_vc is not None
-    assert candidate.lam_vb_nodal is not None
-    assert candidate.lam_vb_cross is not None
     assert len(algorithm_state.X) == initial_x_len + 1
     assert len(algorithm_state.lam_vc_history) == 2
     assert np.allclose(algorithm_state.lam_vc_history[-1], candidate.lam_vc)
-    assert len(algorithm_state.lam_vb_nodal_history) == 2
-    assert len(algorithm_state.lam_vb_cross_history) == 2
+    # Virtual buffer weight updates are currently disabled (commented out)
+    assert candidate.lam_vb_nodal is None
+    assert candidate.lam_vb_cross is None
+    assert len(algorithm_state.lam_vb_nodal_history) == 1
+    assert len(algorithm_state.lam_vb_cross_history) == 1
     assert len(algorithm_state.lam_cost_history) == 2
     assert algorithm_state.lam_cost_history[-1] == pytest.approx(candidate.lam_cost)
 
@@ -1282,13 +1287,14 @@ def test_augmented_lagrangian_accept_constant(
     # Candidate should have updated virtual control weights and be accepted,
     # and those weights must be recorded back into the algorithm_state histories.
     assert candidate.lam_vc is not None
-    assert candidate.lam_vb_nodal is not None
-    assert candidate.lam_vb_cross is not None
     assert len(algorithm_state.X) == initial_x_len + 1
     assert len(algorithm_state.lam_vc_history) == 2
     assert np.allclose(algorithm_state.lam_vc_history[-1], candidate.lam_vc)
-    assert len(algorithm_state.lam_vb_nodal_history) == 2
-    assert len(algorithm_state.lam_vb_cross_history) == 2
+    # Virtual buffer weight updates are currently disabled (commented out)
+    assert candidate.lam_vb_nodal is None
+    assert candidate.lam_vb_cross is None
+    assert len(algorithm_state.lam_vb_nodal_history) == 1
+    assert len(algorithm_state.lam_vb_cross_history) == 1
     assert len(algorithm_state.lam_cost_history) == 2
     assert algorithm_state.lam_cost_history[-1] == pytest.approx(candidate.lam_cost)
 

{openscvx-0.4.1.dev152 → openscvx-0.4.1.dev153}/tests/test_brachistochrone.py

@@ -358,13 +358,26 @@ def test_constraint_types(constraint_type):
     jax.clear_caches()
 
 
-@pytest.mark.parametrize("algorithm_type", ["augmented_lagrangian", "constant_proximal"])
-def test_algorithm_types(algorithm_type):
+@pytest.mark.parametrize(
+    "autotuner_spec",
+    [
+        "augmented_lagrangian",
+        "constant_proximal",
+        "ramp_proximal",
+        "string_augmented_lagrangian",
+        "dict_ramp_proximal",
+    ],
+)
+def test_autotuning(autotuner_spec):
     """
-    Test brachistochrone with different algorithm types.
+    Test brachistochrone with different autotuning strategies.
+
+    Covers all three autotuner implementations (AugmentedLagrangian,
+    ConstantProximalWeight, RampProximalWeight) as well as the string
+    and dict-based resolution paths in ``_resolve_autotuner``.
 
     Args:
-        constraint_type: Specifies which algorithm is used.
+        autotuner_spec: Identifies the autotuner and how it is specified.
     """
     import jax.numpy as jnp
 
@@ -412,7 +425,7 @@ def test_algorithm_types(algorithm_type):
         "velocity": g * ox.Cos(theta[0]),
     }
 
-    # Generate box constraints for all states based on constraint_type
+    # Generate box constraints for all states
     constraint_exprs = []
     for state in states:
         constraint_exprs.extend([ox.ctcs(state <= state.max), ox.ctcs(state.min <= state)])
@@ -425,10 +438,16 @@ def test_algorithm_types(algorithm_type):
         uniform_time_grid=True,
     )
 
-    if algorithm_type == "augmented_lagrangian":
+    if autotuner_spec == "augmented_lagrangian":
         autotuner = ox.AugmentedLagrangian()
-    elif algorithm_type == "constant_proximal":
+    elif autotuner_spec == "constant_proximal":
         autotuner = ox.ConstantProximalWeight()
+    elif autotuner_spec == "ramp_proximal":
+        autotuner = ox.RampProximalWeight()
+    elif autotuner_spec == "string_augmented_lagrangian":
+        autotuner = "AugmentedLagrangian"
+    elif autotuner_spec == "dict_ramp_proximal":
+        autotuner = {"type": "RampProximalWeight", "ramp_factor": 1.0}
 
     problem = Problem(
         dynamics=dynamics,
@@ -469,7 +488,7 @@ def test_algorithm_types(algorithm_type):
         g,
     )
 
-    _print_comparison_metrics(comparison, f"Brachistochrone {algorithm_type.capitalize()}")
+    _print_comparison_metrics(comparison, f"Brachistochrone Autotuning ({autotuner_spec})")
     _assert_brachistochrone_accuracy(comparison, problem, result)
 
     # Clean up JAX caches
@@ -712,7 +731,12 @@ def test_parameters():
         constraints=constraint_exprs,
         N=n,
         licq_max=1e-8,
-        algorithm={"lam_prox": 1e0, "lam_cost": 6e-1, "lam_vc": 1e1},
+        algorithm={
+            "autotuner": ox.ConstantProximalWeight(),
+            "lam_prox": 1e0,
+            "lam_cost": 6e-1,
+            "lam_vc": 1e1,
+        },
     )
 
     problem.solver.solver_args = {"abstol": 1e-6, "reltol": 1e-9}