fix subset selection tests

Author: BatyLeo

src/SubsetSelection/subset_selection.jl

@@ -55,7 +55,7 @@ function Utils.generate_dataset(
 )
     (; n, k) = bench
     rng = MersenneTwister(seed)
-    features = [randn(rng, n) for _ in 1:dataset_size]
+    features = [randn(rng, Float32, n) for _ in 1:dataset_size]
     costs = copy(features)  # we assume that the cost is the same as the feature
     solutions = top_k.(features, k)
     return InferOptDataset(; features, solutions, costs)
@@ -68,5 +68,5 @@ Initialize a linear model for `bench` using `Flux`.
 """
 function Utils.generate_statistical_model(bench::SubsetSelectionBenchmark)
     (; n) = bench
-    return Chain(Dense(n => n; bias=false))
+    return Dense(n => n; bias=false)
 end

test/portfolio_optimization.jl

@@ -1,20 +1,36 @@
-using InferOptBenchmarks.PortfolioOptimization
+# @testitem "Portfolio Optimization" begin
+#     using InferOptBenchmarks
+#     using InferOpt
+#     using Flux
+#     using Zygote
 
-using Flux
-using InferOpt
-using ProgressMeter
-using UnicodePlots
-using Zygote
+#     b = PortfolioOptimizationBenchmark()
 
-bench = PortfolioOptimizationBenchmark()
+#     dataset = generate_dataset(b, 100)
+#     model = generate_statistical_model(b)
+#     maximizer = generate_maximizer(b)
 
-(; features, costs, solutions) = generate_dataset(bench, 1000)
-model = generate_statistical_model(bench)
-maximizer = generate_maximizer(bench)
+#     train_dataset, test_dataset = dataset[1:50], dataset[50:100]
+#     X_train = train_dataset.features
+#     Y_train = train_dataset.solutions
 
-x = features[1]
-y = solutions[1]
-θ = model(x)
-y_pred = maximizer(θ)
+#     perturbed_maximizer = PerturbedAdditive(maximizer; ε=0.1, nb_samples=100)
+#     loss = FenchelYoungLoss(perturbed_maximizer)
 
-maximum(y_pred)
+#     starting_gap = compute_gap(b, test_dataset, model, maximizer)
+
+#     opt_state = Flux.setup(Adam(), model)
+#     loss_history = Float64[]
+#     for epoch in 1:50
+#         val, grads = Flux.withgradient(model) do m
+#             sum(loss(m(x), y) for (x, y) in zip(X_train, Y_train)) / length(train_dataset)
+#         end
+#         Flux.update!(opt_state, model, grads[1])
+#         push!(loss_history, val)
+#     end
+
+#     final_gap = compute_gap(b, test_dataset, model, maximizer)
+
+#     @test loss_history[end] < loss_history[1]
+#     @test final_gap < starting_gap
+# end

test/subset_selection.jl

@@ -2,24 +2,25 @@
     using InferOptBenchmarks
     using InferOpt
     using Flux
+    using UnicodePlots
     using Zygote
 
     b = SubsetSelectionBenchmark()
 
-    dataset = generate_dataset(b, 100)
+    dataset = generate_dataset(b, 500)
     model = generate_statistical_model(b)
     maximizer = generate_maximizer(b)
 
-    train_dataset, test_dataset = dataset[1:50], dataset[50:100]
+    train_dataset, test_dataset = dataset[1:450], dataset[451:500]
     X_train = train_dataset.features
     Y_train = train_dataset.solutions
 
-    perturbed_maximizer = PerturbedAdditive(maximizer; ε=0.1, nb_samples=100)
+    perturbed_maximizer = PerturbedAdditive(maximizer; ε=1.0, nb_samples=100)
     loss = FenchelYoungLoss(perturbed_maximizer)
 
     starting_gap = compute_gap(b, test_dataset, model, maximizer)
 
-    opt_state = Flux.setup(Adam(1e-3), model)
+    opt_state = Flux.setup(Adam(0.1), model)
     loss_history = Float64[]
     for epoch in 1:50
         val, grads = Flux.withgradient(model) do m
@@ -31,6 +32,7 @@
 
     final_gap = compute_gap(b, test_dataset, model, maximizer)
 
+    lineplot(loss_history)
     @test loss_history[end] < loss_history[1]
-    @test final_gap < starting_gap
+    @test final_gap < starting_gap / 10
 end