Add the option to compute solutions on generate dataset

Author: BatyLeo

src/StochasticVehicleScheduling/StochasticVehicleScheduling.jl

@@ -66,17 +66,34 @@ end
 $TYPEDSIGNATURES
 
 Create a dataset of `dataset_size` instances for the given `StochasticVehicleSchedulingBenchmark`.
+If you want to also add label solutions in the dataset, set `compute_solutions=true`.
+By default, they will be computed using column generation.
+Note that computing solutions can be time-consuming, especially for large instances.
+You can also use instead `compact_mip` or `compact_linearized_mip` as the algorithm to compute solutions.
+If you want to provide a custom algorithm to compute solutions, you can pass it as the `algorithm` keyword argument.
+If `algorithm` takes keyword arguments, you can pass them as well directly in `kwargs...`.
 """
 function Utils.generate_dataset(
     benchmark::StochasticVehicleSchedulingBenchmark,
     dataset_size::Int;
+    compute_solutions=false,
     seed=nothing,
     rng=MersenneTwister(0),
+    algorithm=column_generation_algorithm,
+    kwargs...,
 )
     (; nb_tasks, nb_scenarios) = benchmark
     Random.seed!(rng, seed)
     instances = [Instance(; nb_tasks, nb_scenarios, rng=rng) for _ in 1:dataset_size]
     features = get_features.(instances)
+    if compute_solutions
+        solutions = [algorithm(instance; kwargs...) for instance in instances]
+        return [
+            DataSample(; x=feature, instance, y=solution) for
+            (instance, feature, solution) in zip(instances, features, solutions)
+        ]
+    end
+    # else
     return [
         DataSample(; x=feature, instance) for
         (instance, feature) in zip(instances, features)

src/StochasticVehicleScheduling/solution/exact_algorithms/column_generation.jl

@@ -89,35 +89,8 @@ function column_generation(
     end
 
     c_low = objective_value(model)
-    paths = cat(initial_paths, new_paths; dims=1)
-    c_upp, y, _ = compute_solution_from_selected_columns(instance, paths)
-
-    # If relaxation requested or solution is optimal, return
-    # if c_upp ≈ c_low || only_relaxation
-    #     return value.(λ),
-    #     objective_value(model), cat(initial_paths, new_paths; dims=1), dual.(con),
-    #     dual.(cons)
-    # end
-
-    # @info "hello"
-    # # else, try to close the gap
-    # threshold = (c_upp - c_low - vehicle_cost) / delay_cost
-    # λ_val = value.(λ)
-    # @info "" size(intrinsic_delays) threshold
-    # additional_paths, costs = stochastic_routing_shortest_path_with_threshold(
-    #     graph,
-    #     slacks,
-    #     intrinsic_delays,
-    #     λ_val ./ delay_cost;
-    #     threshold,
-    #     bounding,
-    #     use_convex_resources,
-    # )
-    # @info "done"
-
-    return value.(λ),
-    objective_value(model), unique(cat(initial_paths, new_paths; dims=1)), dual.(con),
-    dual.(cons)
+    columns = unique(cat(initial_paths, new_paths; dims=1))
+    return columns
 end
 
 """
@@ -171,15 +144,20 @@ function compute_solution_from_selected_columns(
     return objective_value(model), sol, paths[isapprox.([sol[p] for p in paths], 1.0)]
 end
 
+"""
+$TYPEDSIGNATURES
+
+Solve input instance using column generation.
+"""
 function column_generation_algorithm(
-    instance::Instance,
-    scenario_range=nothing;
-    bounding=false,
-    use_convex_resources=false,
+    instance::Instance;
+    scenario_range=nothing,
+    bounding=true,
+    use_convex_resources=true,
     silent=true,
 )
     Ω = isnothing(scenario_range) ? (1:get_nb_scenarios(instance)) : scenario_range
-    _, _, columns, _, _ = column_generation(
+    columns = column_generation(
         instance;
         bounding=bounding,
         use_convex_resources=use_convex_resources,

src/StochasticVehicleScheduling/solution/exact_algorithms/mip.jl

@@ -6,7 +6,7 @@ Quadratic constraints are linearized using Mc Cormick linearization.
 Note: If you have Gurobi, use `grb_model` as `model_builder` instead of `highs_model`.
 """
 function compact_linearized_mip(
-    instance::Instance, scenario_range=nothing; model_builder=scip_model, silent=true
+    instance::Instance; scenario_range=nothing, model_builder=scip_model, silent=true
 )
     (; graph, slacks, intrinsic_delays, vehicle_cost, delay_cost) = instance
     nb_nodes = nv(graph)
@@ -78,7 +78,7 @@ function compact_linearized_mip(
     solution = value.(y)
 
     sol = solution_from_JuMP_array(solution, graph)
-    return objective_value(model), sol
+    return sol
 end
 
 """
@@ -91,7 +91,7 @@ Note: If you have Gurobi, use `grb_model` as `model_builder` instead of `highs_m
     You need to use a solver that supports quadratic constraints to use this method.
 """
 function compact_mip(
-    instance::Instance, scenario_range=nothing; model_builder=scip_model, silent=true
+    instance::Instance; scenario_range=nothing, model_builder=scip_model, silent=true
 )
     (; graph, slacks, intrinsic_delays, vehicle_cost, delay_cost) = instance
     nb_nodes = nv(graph)
@@ -149,5 +149,5 @@ function compact_mip(
     solution = value.(y)
 
     sol = solution_from_JuMP_array(solution, graph)
-    return objective_value(model), sol
+    return sol
 end

test/vsp.jl

@@ -5,8 +5,14 @@
 
     b = StochasticVehicleSchedulingBenchmark(; nb_tasks=25, nb_scenarios=10)
 
-    N = 50
-    dataset = generate_dataset(b, N)
+    N = 10
+    dataset = generate_dataset(b, N; compute_solutions=true, seed=0)
+    mip_dataset = generate_dataset(
+        b, N; compute_solutions=true, seed=0, algorithm=compact_mip
+    )
+    mipl_dataset = generate_dataset(
+        b, N; compute_solutions=true, seed=0, algorithm=compact_linearized_mip
+    )
     @test length(dataset) == N
 
     maximizer = generate_maximizer(b)