try

arnavk23 · ChrisRackauckas · commit 0c9522d476ec · 2025-08-06T05:21:14.000-04:00
diff --git a/benchmarks/OptimizationCUTEst/CUTEst_bounded.jmd b/benchmarks/OptimizationCUTEst/CUTEst_bounded.jmd
@@ -36,17 +36,21 @@ problems.
 
 ```julia
 optimizers = [
-        #Optimization.LBFGS(),
-        MOI.OptimizerWithAttributes(Ipopt.Optimizer, "print_level" => 0)
-    ]
-
-function get_stats(sol, ::Optimization.LBFGS)
-    return (length(sol.u), sol.stats.time, "LBFGS", Symbol(sol.retcode))
-end
-
-function get_stats(sol, ::OptimizationMOI.MOI.OptimizerWithAttributes)
-    return (length(sol.u), MOI.get(sol.original.model, MOI.SolveTimeSec()),
-        "Ipopt", Symbol(sol.retcode))
+    ("GradientDescent", Optimization.GradientDescent()),
+    ("LBFGS", Optimization.LBFGS()),
+    ("ConjugateGradient", Optimization.ConjugateGradient()),
+    ("NelderMead", Optimization.NelderMead()),
+    ("SimulatedAnnealing", Optimization.SimulatedAnnealing()),
+    ("ParticleSwarm", Optimization.ParticleSwarm()),
+]
+
+function get_stats(sol, optimizer_name)
+    if hasfield(typeof(sol), :stats) && hasfield(typeof(sol.stats), :time)
+        solve_time = sol.stats.time
+    else
+        solve_time = NaN
+    end
+    return (length(sol.u), solve_time, optimizer_name, Symbol(sol.retcode))
 end
 
 function run_benchmarks(problems, optimizers; chunk_size=1)
@@ -87,38 +91,34 @@ function run_benchmarks(problems, optimizers; chunk_size=1)
                 
                 prob = OptimizationNLPModels.OptimizationProblem(nlp_prob, Optimization.AutoForwardDiff())
                 
-                for optimizer in optimizers
+                for (optimizer_name, optimizer) in optimizers
                     try
-                        # Generous limits for 100GB memory
                         sol = solve(prob, optimizer; maxiters = 1000, maxtime = 30.0)
-
-                        @info "✓ Solved $(prob_name) with $(optimizer)"
-                        vars, time, alg, code = get_stats(sol, optimizer)
-
+                        @info "✓ Solved $(prob_name) with $(optimizer_name) - Status: $(sol.retcode)"
+                        vars, time, alg, code = get_stats(sol, optimizer_name)
                         push!(problem, prob_name)
                         push!(n_vars, vars)
                         push!(secs, time)
                         push!(solver, alg)
                         push!(retcode, code)
                     catch e
-                        @warn "✗ Failed to solve $(prob_name) with $(optimizer): $(e)"
-                        # Add failure entry
+                        @warn "✗ Failed to solve $(prob_name) with $(optimizer_name): $(e)"
                         push!(problem, prob_name)
                         push!(n_vars, -1)
                         push!(secs, NaN)
-                        push!(solver, string(optimizer))
+                        push!(solver, optimizer_name)
                         push!(retcode, :FAILED)
                     end
                 end
                 
             catch e
                 @warn "✗ Failed to load problem $(prob_name): $(e)"
                 # Add failure entries for all optimizers
-                for optimizer in optimizers
+                for (optimizer_name, optimizer) in optimizers
                     push!(problem, prob_name)
                     push!(n_vars, -1)
                     push!(secs, NaN)
-                    push!(solver, string(optimizer))
+                    push!(solver, optimizer_name)
                     push!(retcode, :LOAD_FAILED)
                 end
             finally
diff --git a/benchmarks/OptimizationCUTEst/CUTEst_quadratic.jmd b/benchmarks/OptimizationCUTEst/CUTEst_quadratic.jmd
@@ -36,16 +36,21 @@ problems.
 
 ```julia
 optimizers = [
-        MOI.OptimizerWithAttributes(Ipopt.Optimizer, "print_level" => 0)
-    ]
-
-function get_stats(sol, ::Optimization.LBFGS)
-    return (length(sol.u), sol.stats.time, "LBFGS", Symbol(sol.retcode))
-end
-
-function get_stats(sol, ::OptimizationMOI.MOI.OptimizerWithAttributes)
-    return (length(sol.u), MOI.get(sol.original.model, MOI.SolveTimeSec()),
-        "Ipopt", Symbol(sol.retcode))
+    ("GradientDescent", Optimization.GradientDescent()),
+    ("LBFGS", Optimization.LBFGS()),
+    ("ConjugateGradient", Optimization.ConjugateGradient()),
+    ("NelderMead", Optimization.NelderMead()),
+    ("SimulatedAnnealing", Optimization.SimulatedAnnealing()),
+    ("ParticleSwarm", Optimization.ParticleSwarm()),
+]
+
+function get_stats(sol, optimizer_name)
+    if hasfield(typeof(sol), :stats) && hasfield(typeof(sol.stats), :time)
+        solve_time = sol.stats.time
+    else
+        solve_time = NaN
+    end
+    return (length(sol.u), solve_time, optimizer_name, Symbol(sol.retcode))
 end
 
 function run_benchmarks(problems, optimizers; chunk_size=3)
@@ -86,38 +91,34 @@ function run_benchmarks(problems, optimizers; chunk_size=3)
                 
                 prob = OptimizationNLPModels.OptimizationProblem(nlp_prob, Optimization.AutoForwardDiff())
                 
-                for optimizer in optimizers
+                for (optimizer_name, optimizer) in optimizers
                     try
-                        # Generous limits for 100GB memory
                         sol = solve(prob, optimizer; maxiters = 1000, maxtime = 30.0)
-
-                        @info "✓ Solved $(prob_name) with $(optimizer)"
-                        vars, time, alg, code = get_stats(sol, optimizer)
-
+                        @info "✓ Solved $(prob_name) with $(optimizer_name) - Status: $(sol.retcode)"
+                        vars, time, alg, code = get_stats(sol, optimizer_name)
                         push!(problem, prob_name)
                         push!(n_vars, vars)
                         push!(secs, time)
                         push!(solver, alg)
                         push!(retcode, code)
                     catch e
-                        @warn "✗ Failed to solve $(prob_name) with $(optimizer): $(e)"
-                        # Add failure entry
+                        @warn "✗ Failed to solve $(prob_name) with $(optimizer_name): $(e)"
                         push!(problem, prob_name)
                         push!(n_vars, -1)
                         push!(secs, NaN)
-                        push!(solver, string(optimizer))
+                        push!(solver, optimizer_name)
                         push!(retcode, :FAILED)
                     end
                 end
                 
             catch e
                 @warn "✗ Failed to load problem $(prob_name): $(e)"
                 # Add failure entries for all optimizers
-                for optimizer in optimizers
+                for (optimizer_name, optimizer) in optimizers
                     push!(problem, prob_name)
                     push!(n_vars, -1)
                     push!(secs, NaN)
-                    push!(solver, string(optimizer))
+                    push!(solver, optimizer_name)
                     push!(retcode, :LOAD_FAILED)
                 end
             finally
diff --git a/benchmarks/OptimizationCUTEst/CUTEst_safe_solvers.jmd b/benchmarks/OptimizationCUTEst/CUTEst_safe_solvers.jmd
@@ -24,30 +24,26 @@ using Statistics
 using Printf
 ```
 
-# Verified Optimizer Set
+# Extended Optimizer Set
 
 This version includes the same optimizers as the original benchmark, demonstrating that the framework can be extended:
 
 ```julia
-# Carefully selected optimizers that are known to work reliably
 optimizers = [
-    # Core gradient-based methods (OptimizationOptimJL)
+    ("GradientDescent", Optimization.GradientDescent()),
     ("LBFGS", Optimization.LBFGS()),
-    
-    # Constrained optimization (OptimizationMOI)
-    ("Ipopt", MOI.OptimizerWithAttributes(Ipopt.Optimizer, "print_level" => 0)),
+    ("ConjugateGradient", Optimization.ConjugateGradient()),
+    ("NelderMead", Optimization.NelderMead()),
+    ("SimulatedAnnealing", Optimization.SimulatedAnnealing()),
+    ("ParticleSwarm", Optimization.ParticleSwarm()),
 ]
 
 function get_stats(sol, optimizer_name)
-    """Extract statistics from solution - unified for all optimizer types"""
     if hasfield(typeof(sol), :stats) && hasfield(typeof(sol.stats), :time)
         solve_time = sol.stats.time
-    elseif hasfield(typeof(sol), :original) && hasfield(typeof(sol.original), :model)
-        solve_time = MOI.get(sol.original.model, MOI.SolveTimeSec())
     else
         solve_time = NaN
     end
-    
     return (length(sol.u), solve_time, optimizer_name, Symbol(sol.retcode))
 end
 
@@ -95,28 +91,22 @@ function run_benchmarks(problems, optimizers; chunk_size=3)
                 
                 for (optimizer_name, optimizer) in optimizers
                     @printf("  Testing %-20s... ", optimizer_name)
-                    
                     try
                         sol = solve(prob, optimizer; 
                                    maxiters = 1000,
-                                   maxtime = 30.0,  # 30 seconds timeout for 100GB system
+                                   maxtime = 30.0,
                                    abstol = 1e-6,
                                    reltol = 1e-6)
-
                         vars, time, alg, code = get_stats(sol, optimizer_name)
-
                         push!(problem, prob_name)
                         push!(n_vars, vars)
                         push!(secs, time)
                         push!(solver, alg)
                         push!(retcode, code)
-                        
                         success = code == :Success
                         @printf("%s (%.3fs)\n", success ? "✓" : "✗", time)
-                        
                     catch e
                         @printf("ERROR: %s\n", string(e))
-                        # Still record failed attempts
                         push!(problem, prob_name)
                         push!(n_vars, nlp_prob.meta.nvar)
                         push!(secs, NaN)
@@ -301,6 +291,18 @@ end
 ```
 
 ```julia, echo = false
-using SciMLBenchmarks
-SciMLBenchmarks.bench_footer(WEAVE_ARGS[:folder], WEAVE_ARGS[:file])
+# Only add the footer if WEAVE_ARGS is defined and has the required keys
+try
+    if isdefined(Main, :WEAVE_ARGS) && haskey(WEAVE_ARGS, :folder) && haskey(WEAVE_ARGS, :file)
+        using SciMLBenchmarks
+        SciMLBenchmarks.bench_footer(WEAVE_ARGS[:folder], WEAVE_ARGS[:file])
+    end
+catch e
+    @warn "Footer not added: $e"
+end
 ```
+# Introduction
+
+"""
+NOTE: Ensure all code chunks are evaluated in order. If running in a notebook or Weave, do not skip any chunks.
+"""
diff --git a/benchmarks/OptimizationCUTEst/CUTEst_unbounded.jmd b/benchmarks/OptimizationCUTEst/CUTEst_unbounded.jmd
@@ -1,3 +1,19 @@
+# Setup chunk for Weave: must be first in file
+```julia; setup=true
+using Pkg; Pkg.instantiate()
+using Optimization
+using OptimizationNLPModels
+using CUTEst
+using OptimizationOptimJL
+using Ipopt
+using OptimizationMOI
+using OptimizationMOI: MOI as MOI
+# Analysis and plotting
+using DataFrames
+using Plots
+using StatsPlots
+using StatsBase: countmap
+```
 ---
 title: CUTEst Unbounded Constrained Nonlinear Optimization Benchmarks
 author: Alonso M. Cisneros
@@ -12,7 +28,6 @@ optimization routines. The wrapper
 to the problem collection, which we can leverage to test the optimizers made available by
 Optimization.jl.
 
-This benchmark uses the following packages:
 
 ```julia
 using Optimization
@@ -35,17 +50,23 @@ We will be testing the [Ipopt]() and the [LBFGS]() optimizers on these classes o
 problems.
 
 ```julia
+# Standard low-memory optimizer set
 optimizers = [
-        MOI.OptimizerWithAttributes(Ipopt.Optimizer, "print_level" => 0)
-    ]
-
-function get_stats(sol, ::Optimization.LBFGS)
-    return (length(sol.u), sol.stats.time, "LBFGS", Symbol(sol.retcode))
-end
-
-function get_stats(sol, ::OptimizationMOI.MOI.OptimizerWithAttributes)
-    return (length(sol.u), MOI.get(sol.original.model, MOI.SolveTimeSec()),
-        "Ipopt", Symbol(sol.retcode))
+    ("GradientDescent", Optimization.GradientDescent()),
+    ("LBFGS", Optimization.LBFGS()),
+    ("ConjugateGradient", Optimization.ConjugateGradient()),
+    ("NelderMead", Optimization.NelderMead()),
+    ("SimulatedAnnealing", Optimization.SimulatedAnnealing()),
+    ("ParticleSwarm", Optimization.ParticleSwarm()),
+]
+
+function get_stats(sol, optimizer_name)
+    if hasfield(typeof(sol), :stats) && hasfield(typeof(sol.stats), :time)
+        solve_time = sol.stats.time
+    else
+        solve_time = NaN
+    end
+    return (length(sol.u), solve_time, optimizer_name, Symbol(sol.retcode))
 end
 
 function run_benchmarks(problems, optimizers; chunk_size=3)
@@ -86,38 +107,34 @@ function run_benchmarks(problems, optimizers; chunk_size=3)
                 
                 prob = OptimizationNLPModels.OptimizationProblem(nlp_prob, Optimization.AutoForwardDiff())
                 
-                for optimizer in optimizers
+                for (optimizer_name, optimizer) in optimizers
                     try
-                        # Generous limits for 100GB memory
                         sol = solve(prob, optimizer; maxiters = 1000, maxtime = 30.0)
-
-                        @info "✓ Solved $(prob_name) with $(optimizer)"
-                        vars, time, alg, code = get_stats(sol, optimizer)
-
+                        @info "✓ Solved $(prob_name) with $(optimizer_name) - Status: $(sol.retcode)"
+                        vars, time, alg, code = get_stats(sol, optimizer_name)
                         push!(problem, prob_name)
                         push!(n_vars, vars)
                         push!(secs, time)
                         push!(solver, alg)
                         push!(retcode, code)
                     catch e
-                        @warn "✗ Failed to solve $(prob_name) with $(optimizer): $(e)"
-                        # Add failure entry
+                        @warn "✗ Failed to solve $(prob_name) with $(optimizer_name): $(e)"
                         push!(problem, prob_name)
                         push!(n_vars, -1)
                         push!(secs, NaN)
-                        push!(solver, string(optimizer))
+                        push!(solver, optimizer_name)
                         push!(retcode, :FAILED)
                     end
                 end
                 
             catch e
                 @warn "✗ Failed to load problem $(prob_name): $(e)"
                 # Add failure entries for all optimizers
-                for optimizer in optimizers
+                for (optimizer_name, optimizer) in optimizers
                     push!(problem, prob_name)
                     push!(n_vars, -1)
                     push!(secs, NaN)
-                    push!(solver, string(optimizer))
+                    push!(solver, optimizer_name)
                     push!(retcode, :LOAD_FAILED)
                 end
             finally
@@ -203,6 +220,12 @@ success_rate = total_attempts > 0 ? round(successful_attempts / total_attempts *
 ```
 
 ```julia, echo = false
-using SciMLBenchmarks
-SciMLBenchmarks.bench_footer(WEAVE_ARGS[:folder],WEAVE_ARGS[:file])
+try
+    using SciMLBenchmarks
+    folder = haskey(WEAVE_ARGS, :folder) ? WEAVE_ARGS[:folder] : ""
+    file = haskey(WEAVE_ARGS, :file) ? WEAVE_ARGS[:file] : ""
+    SciMLBenchmarks.bench_footer(folder, file)
+catch e
+    @warn "bench_footer failed: $e"
+end
 ```
diff --git a/benchmarks/OptimizationCUTEst/CUTEst_unconstrained.jmd b/benchmarks/OptimizationCUTEst/CUTEst_unconstrained.jmd
diff --git a/benchmarks/OptimizationCUTEst/Manifest.toml b/benchmarks/OptimizationCUTEst/Manifest.toml
