Complete revamp of the interface

Author: BatyLeo

src/DecisionFocusedLearningBenchmarks.jl

@@ -67,9 +67,10 @@ export AbstractEnvironment, get_seed, is_terminated, observe, reset!, step!
 
 export Policy, evaluate_policy!
 
-export generate_sample, generate_dataset, generate_environments, generate_environment
+export generate_instance,
+    generate_sample, generate_dataset, generate_environments, generate_environment
 export generate_scenario
-export generate_policies
+export generate_baseline_policies
 export generate_statistical_model
 export generate_maximizer
 export generate_anticipative_solution

src/DynamicAssortment/DynamicAssortment.jl

@@ -128,7 +128,7 @@ Returns two policies for the dynamic assortment benchmark:
 - `Greedy`: selects the assortment containing items with the highest prices
 - `Expert`: selects the assortment with the highest expected revenue (through brute-force enumeration)
 """
-function Utils.generate_policies(::DynamicAssortmentBenchmark)
+function Utils.generate_baseline_policies(::DynamicAssortmentBenchmark)
     greedy = Policy(
         "Greedy",
         "policy that selects the assortment with items with the highest prices",

src/DynamicVehicleScheduling/DynamicVehicleScheduling.jl

@@ -149,7 +149,7 @@ Returns a tuple containing:
 - `lazy`: A policy that dispatches vehicles only when they are ready
 - `greedy`: A policy that dispatches vehicles to the nearest customer
 """
-function Utils.generate_policies(b::DynamicVehicleSchedulingBenchmark)
+function Utils.generate_baseline_policies(::DynamicVehicleSchedulingBenchmark)
     lazy = Policy(
         "Lazy",
         "Lazy policy that dispatches vehicles only when they are ready.",

src/FixedSizeShortestPath/FixedSizeShortestPath.jl

@@ -133,7 +133,10 @@ $TYPEDSIGNATURES
 
 Initialize a linear model for `bench` using `Flux`.
 """
-function Utils.generate_statistical_model(bench::FixedSizeShortestPathBenchmark)
+function Utils.generate_statistical_model(
+    bench::FixedSizeShortestPathBenchmark; seed=nothing
+)
+    Random.seed!(seed)
     (; p, graph) = bench
     return Chain(Dense(p, ne(graph)))
 end

src/Maintenance/Maintenance.jl

@@ -129,7 +129,7 @@ $TYPEDSIGNATURES
 Returns two policies for the dynamic assortment benchmark:
 - `Greedy`: maintains components when they are in the last state before failure, up to the maintenance capacity
 """
-function Utils.generate_policies(::MaintenanceBenchmark)
+function Utils.generate_baseline_policies(::MaintenanceBenchmark)
     greedy = Policy(
         "Greedy",
         "policy that maintains components when they are in the last state before failure, up to the maintenance capacity",

src/PortfolioOptimization/PortfolioOptimization.jl

@@ -7,7 +7,7 @@ using Flux: Chain, Dense
 using Ipopt: Ipopt
 using JuMP: @variable, @objective, @constraint, optimize!, value, Model, set_silent
 using LinearAlgebra: I
-using Random: AbstractRNG, MersenneTwister
+using Random: Random, AbstractRNG, MersenneTwister
 
 """
 $TYPEDEF
@@ -107,7 +107,10 @@ $TYPEDSIGNATURES
 
 Initialize a linear model for `bench` using `Flux`.
 """
-function Utils.generate_statistical_model(bench::PortfolioOptimizationBenchmark)
+function Utils.generate_statistical_model(
+    bench::PortfolioOptimizationBenchmark; seed=nothing
+)
+    Random.seed!(seed)
     (; p, d) = bench
     return Dense(p, d)
 end

src/StochasticVehicleScheduling/StochasticVehicleScheduling.jl

@@ -73,32 +73,29 @@ end
 """
 $TYPEDSIGNATURES
 
-Generate a sample for the given `StochasticVehicleSchedulingBenchmark`.
-If you want to not add label solutions in the sample, set `compute_solutions=false`.
-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...`.
-If `store_city=false`, the coordinates and unnecessary information about instances will not be stored in the sample.
-"""
-function Utils.generate_sample(
+Generate an unlabeled instance for the given `StochasticVehicleSchedulingBenchmark`.
+Returns a [`DataSample`](@ref) with features `x` and `instance` set, but `y=nothing`.
+
+To obtain labeled samples, pass a `target_policy` to [`generate_dataset`](@ref):
+
+```julia
+policy = sample -> DataSample(; sample.context..., x=sample.x,
+                                y=column_generation_algorithm(sample.instance))
+dataset = generate_dataset(benchmark, N; target_policy=policy)
+```
+
+If `store_city=false`, coordinates and city information are not stored in the instance.
+"""
+function Utils.generate_instance(
     benchmark::StochasticVehicleSchedulingBenchmark,
     rng::AbstractRNG;
     store_city=true,
-    compute_solutions=true,
-    algorithm=column_generation_algorithm,
     kwargs...,
 )
     (; nb_tasks, nb_scenarios) = benchmark
     instance = Instance(; nb_tasks, nb_scenarios, rng, store_city)
     x = get_features(instance)
-    y_true = if compute_solutions
-        algorithm(instance; kwargs...)
-    else
-        nothing
-    end
-    return DataSample(; x, instance, y=y_true)
+    return DataSample(; x, instance)
 end
 
 """

src/Utils/Utils.jl

@@ -27,13 +27,12 @@ export TopKMaximizer
 export AbstractEnvironment, get_seed, is_terminated, observe, reset!, step!
 
 export AbstractBenchmark, AbstractStochasticBenchmark, AbstractDynamicBenchmark
-export generate_sample, generate_dataset
+export generate_instance, generate_sample, generate_dataset
 export generate_statistical_model, generate_maximizer
 export generate_scenario
 export generate_environment, generate_environments
-export generate_policies
+export generate_baseline_policies
 export generate_anticipative_solution
-export generate_instance_samples, generate_environment_samples
 
 export plot_data, compute_gap
 export grid_graph, get_path, path_to_matrix