Merge pull request #22 from LAMPSPUC/jg/version

Set versions

Author: joaquimg

.github/workflows/ci.yml

@@ -24,7 +24,7 @@ jobs:
       matrix:
         version:
           - '1.11'
-          - '1.6'
+          - '1'
         os:
           - ubuntu-latest
         arch:
@@ -39,4 +39,4 @@ jobs:
       - uses: julia-actions/julia-buildpkg@v1
       - uses: julia-actions/julia-runtest@v1
       - uses: julia-actions/julia-processcoverage@v1
-      - uses: codecov/codecov-action@v5
+      - uses: codecov/codecov-action@v5

Project.toml

@@ -14,3 +14,14 @@ Optim = "429524aa-4258-5aef-a3af-852621145aeb"
 ParametricOptInterface = "0ce4ce61-57bf-432b-a095-efac525d185e"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
+
+[compat]
+BilevelJuMP = "0.6.2"
+DiffOpt = "0.5.0"
+Flux = "0.14.25"
+JobQueueMPI = "0.1.1"
+JuMP = "1.24"
+Optim = "1.11"
+MPI = "0.20.22"
+ParametricOptInterface = "0.9.0"
+Zygote = "0.6.75"

src/jump.jl

@@ -117,12 +117,9 @@ JuMP.object_dictionary(model::Model) = model.obj_dict
 
 function JuMP.set_optimizer(model::Model, builder, evaluate_duals::Bool = true)
     # set diffopt optimizer for plan model
-    new_diff_optimizer = DiffOpt.diff_optimizer(builder)
-    JuMP.set_optimizer(
-        model.plan,
-        () ->
-            POI.Optimizer(new_diff_optimizer; evaluate_duals = evaluate_duals),
-    )
+    new_diff_optimizer =
+        DiffOpt.diff_optimizer(builder; with_parametric_opt_interface = true)
+    JuMP.set_optimizer(model.plan, () -> new_diff_optimizer)
 
     # basic setting for assess model
     return JuMP.set_optimizer(model.assess, builder)
@@ -133,10 +130,6 @@ function JuMP.set_silent(model::Model)
     return MOI.set(model.assess, MOI.Silent(), true)
 end
 
-function JuMP.num_variables(model::Model)
-    return JuMP.num_variables(model.plan) + JuMP.num_variables(model.assess)
-end
-
 function JuMP.num_constraints(model::Model)
     return JuMP.num_constraints(model.plan) + JuMP.num_constraints(model.assess)
 end

src/simulation.jl

@@ -25,6 +25,7 @@ function compute_single_step_gradient(
     dCdy::Vector{<:Real},
 )
     dCdz .= dual.(model.assess[:assess_policy_fix])
+    DiffOpt.empty_input_sensitivities!(model.plan)
     for i = 1:size(model.policy_vars, 1)
         MOI.set(
             model.plan,
@@ -35,11 +36,12 @@ function compute_single_step_gradient(
     end
     DiffOpt.reverse_differentiate!(model.plan)
     for j = 1:size(model.forecast_vars, 1)
-        dCdy[j] = MOI.get(
-            model.plan,
-            POI.ReverseParameter(),
-            model.plan_forecast_params[j],
-        )
+        dCdy[j] =
+            MOI.get(
+                model.plan,
+                DiffOpt.ReverseConstraintSet(),
+                ParameterRef(model.plan_forecast_params[j]),
+            ).value
     end
 
     return dCdy

test/runtests.jl

@@ -13,4 +13,4 @@ Random.seed!(123)
 
 include("utils.jl")
 include("test_predictive_model.jl")
-include("test_newsvendor.jl")
+include("test_newsvendor.jl")

test/test_newsvendor.jl

@@ -19,16 +19,27 @@ end)
     con1, y <= d.plan
     con2, y + w <= x.plan
 end)
-@objective(ApplicationDrivenLearning.Plan(model), Min, c * x.plan - q * y - r * w)
+@objective(
+    ApplicationDrivenLearning.Plan(model),
+    Min,
+    c * x.plan - q * y - r * w
+)
 @variables(ApplicationDrivenLearning.Assess(model), begin
     y >= 0
     w >= 0
 end)
-@constraints(ApplicationDrivenLearning.Assess(model), begin
-    con1, y <= d.assess
-    con2, y + w <= x.assess
-end)
-@objective(ApplicationDrivenLearning.Assess(model), Min, c * x.assess - q * y - r * w)
+@constraints(
+    ApplicationDrivenLearning.Assess(model),
+    begin
+        con1, y <= d.assess
+        con2, y + w <= x.assess
+    end
+)
+@objective(
+    ApplicationDrivenLearning.Assess(model),
+    Min,
+    c * x.assess - q * y - r * w
+)
 set_optimizer(model, HiGHS.Optimizer)
 set_silent(model)
 nn = Chain(Dense(1 => 1; bias = false, init = (size...) -> rand(size...)))
@@ -41,7 +52,10 @@ nn = Chain(Dense(1 => 1; bias = false, init = (size...) -> rand(size...)))
     opt = ApplicationDrivenLearning.Options(
         ApplicationDrivenLearning.BilevelMode,
         optimizer = HiGHS.Optimizer,
-        mode = BilevelJuMP.FortunyAmatMcCarlMode(primal_big_M = 100, dual_big_M = 100),
+        mode = BilevelJuMP.FortunyAmatMcCarlMode(
+            primal_big_M = 100,
+            dual_big_M = 100,
+        ),
         silent = true,
     )
     sol = ApplicationDrivenLearning.train!(model, X, Y, opt)

test/test_predictive_model.jl

@@ -3,16 +3,20 @@ in_size = 3
 out_size = 2
 
 @testset "Single-Dense" begin
-    forecaster =
-        ApplicationDrivenLearning.PredictiveModel(Flux.Dense(in_size => out_size) |> f64)
+    forecaster = ApplicationDrivenLearning.PredictiveModel(
+        Flux.Dense(in_size => out_size) |> f64,
+    )
     x = ones((in_size, 1))
     @test size(forecaster(x)) == (out_size, 1)
 
     θ = ApplicationDrivenLearning.extract_params(forecaster)
     expected_params_size = in_size * out_size + out_size
     @test size(θ) == (expected_params_size,)
 
-    ApplicationDrivenLearning.apply_params(forecaster, ones(expected_params_size))
+    ApplicationDrivenLearning.apply_params(
+        forecaster,
+        ones(expected_params_size),
+    )
     x = ones(in_size)
     @test forecaster(x) == (in_size + 1) .* ones(out_size)
 
@@ -22,7 +26,8 @@ out_size = 2
         ones((1, in_size)),
         Flux.Descent(0.1),
     )
-    @test Flux.params(forecaster.networks[1])[1] == 0.9 * ones((out_size, in_size))
+    @test Flux.params(forecaster.networks[1])[1] ==
+          0.9 * ones((out_size, in_size))
     @test Flux.params(forecaster.networks[1])[2] == 0.9 * ones(out_size)
 end
 
@@ -37,7 +42,10 @@ end
     expected_params_size = in_size * out_size + out_size
     @test size(θ) == (expected_params_size,)
 
-    ApplicationDrivenLearning.apply_params(forecaster, ones(expected_params_size))
+    ApplicationDrivenLearning.apply_params(
+        forecaster,
+        ones(expected_params_size),
+    )
     x = ones(in_size)
     @test forecaster(x) == (in_size + 1) .* ones(out_size)
 
@@ -47,7 +55,8 @@ end
         ones((1, in_size)),
         Flux.Descent(0.1),
     )
-    @test Flux.params(forecaster.networks[1])[1] == 0.9 * ones((out_size, in_size))
+    @test Flux.params(forecaster.networks[1])[1] ==
+          0.9 * ones((out_size, in_size))
     @test Flux.params(forecaster.networks[1])[2] == 0.9 * ones(out_size)
 end
 
@@ -64,7 +73,10 @@ end
     expected_params_size = model_in_size * model_out_size + model_out_size
     @test size(θ) == (expected_params_size,)
 
-    ApplicationDrivenLearning.apply_params(forecaster, ones(expected_params_size))
+    ApplicationDrivenLearning.apply_params(
+        forecaster,
+        ones(expected_params_size),
+    )
     x = ones(in_size)
     @test forecaster(x) == (model_in_size + 1) .* ones(out_size)
 
@@ -85,8 +97,12 @@ end
     nn1 = Flux.Dense(model_in_size => model_out_size) |> f64
     nn2 = Flux.Dense(model_in_size => model_out_size) |> f64
     in_out_map = [Dict([1, 2] => [1]), Dict([1, 3] => [2])]
-    forecaster =
-        ApplicationDrivenLearning.PredictiveModel([nn1, nn2], in_out_map, in_size, out_size)
+    forecaster = ApplicationDrivenLearning.PredictiveModel(
+        [nn1, nn2],
+        in_out_map,
+        in_size,
+        out_size,
+    )
 
     x = ones((in_size, 1))
     @test size(forecaster(x)) == (out_size, 1)
@@ -95,7 +111,10 @@ end
     expected_params_size = 2 * (model_in_size * model_out_size + model_out_size)
     @test size(θ) == (expected_params_size,)
 
-    ApplicationDrivenLearning.apply_params(forecaster, ones(expected_params_size))
+    ApplicationDrivenLearning.apply_params(
+        forecaster,
+        ones(expected_params_size),
+    )
     x = ones(in_size)
     @test forecaster(x) == (model_in_size + 1) .* ones(out_size)