format

Author: joaquimg

src/jump.jl

@@ -117,14 +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;
-        with_parametric_opt_interface = true,
-    )
-    JuMP.set_optimizer(
-        model.plan,
-        () -> new_diff_optimizer,
-    )
+    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)

src/simulation.jl

@@ -36,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,
-            DiffOpt.ReverseConstraintSet(),
-            ParameterRef(model.plan_forecast_params[j]),
-        ).value
+        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)