cache C problem in best of

Author: dance858

cvxpy/reductions/solvers/nlp_solvers/copt_nlpif.py

@@ -121,8 +121,15 @@ def solve_via_data(self, data, warm_start: bool, verbose: bool, solver_opts, sol
         # COPT always uses exact Hessian (no quasi-Newton option currently)
         use_hessian = True
 
-        oracles = Oracles(bounds.new_problem, bounds.x0, len(bounds.cl),
-                          verbose=verbose, use_hessian=use_hessian)
+        if solver_cache is None:
+            oracles = Oracles(bounds.new_problem, bounds.x0, len(bounds.cl),
+                            verbose=verbose, use_hessian=use_hessian)
+        elif 'oracles' in solver_cache:
+            oracles = solver_cache['oracles']
+        else:
+            oracles = Oracles(bounds.new_problem, bounds.x0, len(bounds.cl),
+                            verbose=verbose, use_hessian=use_hessian)
+            solver_cache['oracles'] = oracles
 
         class COPTNlpCallbackCVXPY(copt.NlpCallbackBase):
             def __init__(self, oracles, m):

cvxpy/reductions/solvers/nlp_solvers/ipopt_nlpif.py

@@ -110,7 +110,6 @@ def solve_via_data(self, data, warm_start: bool, verbose: bool, solver_opts, sol
         data : dict
         Data used by the solver.
         This consists of:
-        - "oracles": An Oracles object that computes the objective and constraints
         - "x0": Initial guess for the primal variables
         - "lb": Lower bounds on the primal variables
         - "ub": Upper bounds on the primal variables
@@ -150,9 +149,16 @@ def solve_via_data(self, data, warm_start: bool, verbose: bool, solver_opts, sol
             hessian_approx = solver_opts.get('hessian_approximation', 'exact')
         use_hessian = (hessian_approx == 'exact')
 
-        oracles = Oracles(bounds.new_problem, bounds.x0, len(bounds.cl),
-                          verbose=verbose, use_hessian=use_hessian)
-
+        if solver_cache is None:
+            oracles = Oracles(bounds.new_problem, bounds.x0, len(bounds.cl),
+                            verbose=verbose, use_hessian=use_hessian)
+        elif 'oracles' in solver_cache:
+            oracles = solver_cache['oracles']
+        else:
+            oracles = Oracles(bounds.new_problem, bounds.x0, len(bounds.cl),
+                            verbose=verbose, use_hessian=use_hessian)
+            solver_cache['oracles'] = oracles
+          
         nlp = cyipopt.Problem(
         n=len(data["x0"]),
         m=len(data["cl"]),

cvxpy/reductions/solvers/nlp_solvers/knitro_nlpif.py

@@ -176,8 +176,15 @@ def solve_via_data(self, data, warm_start: bool, verbose: bool, solver_opts, sol
         hessopt = solver_opts.get('hessopt', 1) if solver_opts else 1
         use_hessian = (hessopt == 1)
 
-        oracles = Oracles(bounds.new_problem, bounds.x0, len(bounds.cl),
-                          verbose=verbose, use_hessian=use_hessian)
+        if solver_cache is None:
+            oracles = Oracles(bounds.new_problem, bounds.x0, len(bounds.cl),
+                            verbose=verbose, use_hessian=use_hessian)
+        elif 'oracles' in solver_cache:
+            oracles = solver_cache['oracles']
+        else:
+            oracles = Oracles(bounds.new_problem, bounds.x0, len(bounds.cl),
+                            verbose=verbose, use_hessian=use_hessian)
+            solver_cache['oracles'] = oracles
 
         # Extract data from the data dictionary
         x0 = data["x0"]

cvxpy/reductions/solvers/nlp_solvers/uno_nlpif.py

@@ -135,8 +135,15 @@ def solve_via_data(self, data, warm_start: bool, verbose: bool, solver_opts, sol
         # UNO always uses exact Hessian (no quasi-Newton option currently)
         use_hessian = True
 
-        oracles = Oracles(bounds.new_problem, bounds.x0, len(bounds.cl),
-                          verbose=verbose, use_hessian=use_hessian)
+        if solver_cache is None:
+            oracles = Oracles(bounds.new_problem, bounds.x0, len(bounds.cl),
+                            verbose=verbose, use_hessian=use_hessian)
+        elif 'oracles' in solver_cache:
+            oracles = solver_cache['oracles']
+        else:
+            oracles = Oracles(bounds.new_problem, bounds.x0, len(bounds.cl),
+                            verbose=verbose, use_hessian=use_hessian)
+            solver_cache['oracles'] = oracles
 
         # Extract data from the data dictionary
         x0 = data["x0"]

cvxpy/reductions/solvers/nlp_solving_chain.py

@@ -175,30 +175,35 @@ def solve_nlp(problem, solver, warm_start, verbose, **kwargs):
         The optimal problem value.
     """
     nlp_chain, kwargs = _build_nlp_chain(problem, solver, kwargs)
-    best_of = kwargs.pop("best_of", 1)
-
-    if not isinstance(best_of, int) or best_of < 1:
-        raise ValueError("best_of must be a positive integer.")
-
+    
     # Standard single solve
-    if best_of == 1:
+    if "best_of" not in kwargs:
         _set_nlp_initial_point(problem)
         canon_problem, inverse_data = nlp_chain.apply(problem=problem)
         solution = nlp_chain.solver.solve_via_data(canon_problem, warm_start,
                                                    verbose, solver_opts=kwargs)
         problem.unpack_results(solution, nlp_chain, inverse_data)
         return problem.value
+    
+    best_of = kwargs.pop("best_of")
+    if not isinstance(best_of, int) or best_of < 1:
+        raise ValueError("best_of must be a positive integer.")
 
     # Best-of-N solve
     best_obj, best_solution = float("inf"), None
     all_objs = np.zeros(shape=(best_of,))
     user_initials = {}
 
+    # inside solve_via_data we cache the construction of the C problem
+    # (which includes the construction of the oracles)
+    solver_cache = {} 
+
     for run in range(best_of):
         _set_random_nlp_initial_point(problem, run, user_initials)
         canon_problem, inverse_data = nlp_chain.apply(problem=problem)
         solution = nlp_chain.solver.solve_via_data(canon_problem, warm_start,
-                                                   verbose, solver_opts=kwargs)
+                                                   verbose, solver_opts=kwargs, 
+                                                   solver_cache=solver_cache)
 
         # Unpack to get the objective value in the original problem space
         problem.unpack_results(solution, nlp_chain, inverse_data)
@@ -212,6 +217,7 @@ def solve_nlp(problem, solver, warm_start, verbose, **kwargs):
         if verbose:
             print("Run %d/%d: obj = %.6e | best so far = %.6e"
                   % (run + 1, best_of, obj_value, best_obj))
+            print("-" * 60)
 
     # Unpack best solution
     if type(problem.objective) == Maximize: