simplify interface

Author: BatyLeo

src/DecisionFocusedLearningBenchmarks.jl

@@ -74,9 +74,11 @@ using .DynamicAssortment
 export AbstractBenchmark, AbstractStochasticBenchmark, AbstractDynamicBenchmark, DataSample
 
 export generate_sample, generate_dataset, generate_environments, generate_environment
+export generate_scenario
 export generate_scenario_generator, generate_anticipative_solver
 export generate_statistical_model
 export generate_maximizer, maximizer_kwargs
+export generate_anticipative_solution
 export is_exogenous, is_endogenous
 
 export objective_value
@@ -92,7 +94,7 @@ export WarcraftBenchmark
 export FixedSizeShortestPathBenchmark
 export PortfolioOptimizationBenchmark
 export StochasticVehicleSchedulingBenchmark
-export DVSPBenchmark
+export DynamicVehicleSchedulingBenchmark
 export DynamicAssortmentBenchmark
 
 end # module DecisionFocusedLearningBenchmarks

src/DynamicVehicleScheduling/DynamicVehicleScheduling.jl

@@ -55,7 +55,7 @@ Abstract type for dynamic vehicle scheduling benchmarks.
 # Fields
 $TYPEDFIELDS
 """
-@kwdef struct DVSPBenchmark <: AbstractDynamicBenchmark{true}
+@kwdef struct DynamicVehicleSchedulingBenchmark <: AbstractDynamicBenchmark{true}
     "todo"
     max_requests_per_epoch::Int = 10
     "todo"
@@ -66,7 +66,7 @@ $TYPEDFIELDS
     two_dimensional_features::Bool = false
 end
 
-function Utils.generate_dataset(b::DVSPBenchmark, dataset_size::Int=1)
+function Utils.generate_dataset(b::DynamicVehicleSchedulingBenchmark, dataset_size::Int=1)
     (; max_requests_per_epoch, Δ_dispatch, epoch_duration) = b
     files = readdir(datadep"dvrptw"; join=true)
     dataset_size = min(dataset_size, length(files))
@@ -82,23 +82,29 @@ function Utils.generate_dataset(b::DVSPBenchmark, dataset_size::Int=1)
     ]
 end
 
-function Utils.generate_environment(::DVSPBenchmark, instance::Instance; kwargs...)
+function Utils.generate_environment(
+    ::DynamicVehicleSchedulingBenchmark, instance::Instance; kwargs...
+)
     return DVSPEnv(instance; kwargs...)
 end
 
-function Utils.generate_maximizer(::DVSPBenchmark)
+function Utils.generate_maximizer(::DynamicVehicleSchedulingBenchmark)
     return LinearMaximizer(oracle; g, h)
 end
 
-function Utils.generate_scenario_generator(::DVSPBenchmark)
-    return generate_scenario
+function Utils.generate_scenario(b::DynamicVehicleSchedulingBenchmark, args...; kwargs...)
+    return Utils.generate_scenario(args...; kwargs...)
 end
 
-function Utils.generate_anticipative_solver(b::DVSPBenchmark; kwargs...)
-    return AnticipativeSolver(b.two_dimensional_features)
+function Utils.generate_anticipative_solution(
+    b::DynamicVehicleSchedulingBenchmark, args...; kwargs...
+)
+    return anticipative_solver(
+        args...; kwargs..., two_dimensional_features=b.two_dimensional_features
+    )
 end
 
-export DVSPBenchmark #, generate_environment # , generate_sample, generate_anticipative_solver
+export DynamicVehicleSchedulingBenchmark
 export run_policy!,
     GreedyVSPPolicy, LazyVSPPolicy, KleopatraVSPPolicy, AnticipativeVSPPolicy
 

src/DynamicVehicleScheduling/algorithms/anticipative_solver.jl

@@ -196,16 +196,16 @@ function anticipative_solver(
     return obj, dataset
 end
 
-@kwdef struct AnticipativeSolver
-    is_2D::Bool = false
-end
-
-function (solver::AnticipativeSolver)(env::DVSPEnv, scenario=env.scenario; reset_env=false)
-    return anticipative_solver(
-        env,
-        scenario;
-        model_builder=highs_model,
-        reset_env,
-        two_dimensional_features=solver.is_2D,
-    )
-end
+# @kwdef struct AnticipativeSolver
+#     is_2D::Bool = false
+# end
+
+# function (solver::AnticipativeSolver)(env::DVSPEnv, scenario=env.scenario; reset_env=false)
+#     return generate_anticipative_decision(
+#         env,
+#         scenario;
+#         model_builder=highs_model,
+#         reset_env,
+#         two_dimensional_features=solver.is_2D,
+#     )
+# end

src/DynamicVehicleScheduling/environment/environment.jl

@@ -13,7 +13,7 @@ $TYPEDSIGNATURES
 Constructor for [`DVSPEnv`](@ref).
 """
 function DVSPEnv(instance::Instance; seed=nothing, rng=MersenneTwister(seed))
-    scenario = generate_scenario(instance; rng, seed)
+    scenario = Utils.generate_scenario(instance; rng, seed)
     initial_state = DVSPState(instance; scenario[1]...)
     return DVSPEnv(instance, initial_state, scenario)
 end
@@ -76,6 +76,6 @@ function CommonRLInterface.act!(env::DVSPEnv, routes, scenario=env.scenario)
     return reward
 end
 
-function generate_scenario(env::DVSPEnv; kwargs...)
+function Utils.generate_scenario(env::DVSPEnv; kwargs...)
     return generate_scenario(env.instance; kwargs...)
 end

src/DynamicVehicleScheduling/environment/scenario.jl

@@ -16,7 +16,7 @@ function Base.getindex(scenario::Scenario, idx::Integer)
     )
 end
 
-function generate_scenario(
+function Utils.generate_scenario(
     instance::Instance; seed=nothing, rng::AbstractRNG=MersenneTwister(seed)
 )
     (; Δ_dispatch, static_instance, last_epoch, epoch_duration, max_requests_per_epoch) =
@@ -46,6 +46,6 @@ function generate_scenario(
     return Scenario(new_indices, new_service_time, new_start_time)
 end
 
-function generate_scenario(sample::DataSample; kwargs...)
-    return generate_scenario(sample.instance; kwargs...)
+function Utils.generate_scenario(sample::DataSample; kwargs...)
+    return Utils.generate_scenario(sample.instance; kwargs...)
 end

src/DynamicVehicleScheduling/policy/anticipative_policy.jl

@@ -13,5 +13,5 @@ Apply the anticipative policy to the environment.
 function run_policy!(
     ::AnticipativeVSPPolicy, env::DVSPEnv, scenario=env.scenario; model_builder=highs_model
 )
-    return anticipative_solver(env, scenario; model_builder, reset_env=true)
+    return generate_anticipative_solution(env, scenario; model_builder, reset_env=true)
 end

src/Utils/Utils.jl

@@ -25,10 +25,12 @@ export generate_dataset,
     generate_statistical_model,
     generate_maximizer,
     generate_sample,
+    generate_scenario,
     generate_scenario_generator,
     generate_anticipative_solver,
     generate_environment,
     generate_environments
+export generate_anticipative_solution
 export plot_data, compute_gap
 export maximizer_kwargs
 export grid_graph, get_path, path_to_matrix

src/Utils/interface.jl

@@ -192,18 +192,25 @@ abstract type AbstractStochasticBenchmark{exogenous} <: AbstractBenchmark end
 is_exogenous(::AbstractStochasticBenchmark{exogenous}) where {exogenous} = exogenous
 is_endogenous(::AbstractStochasticBenchmark{exogenous}) where {exogenous} = !exogenous
 
-# only works for exogenous noise
-function generate_scenario end
-
 """
-    generate_scenario_generator(::AbstractStochasticBenchmark{true}; kwargs...)
+    generate_anticipative_solver(::AbstractStochasticBenchmark{true}, instance; kwargs...)
 """
-function generate_scenario_generator end
+function generate_scenario end
 
 """
-    generate_anticipative_solver(::AbstractStochasticBenchmark{true}; kwargs...)
+    anticipative_policy(::AbstractStochasticBenchmark{true}, instance, scenario; kwargs...)
 """
-function generate_anticipative_solver end
+function generate_anticipative_solution end
+
+# """
+#     generate_scenario_generator(::AbstractStochasticBenchmark{true}; kwargs...)
+# """
+# function generate_scenario_generator end
+
+# """
+#     generate_anticipative_solver(::AbstractStochasticBenchmark{true}; kwargs...)
+# """
+# function generate_anticipative_solver end
 
 """
 $TYPEDEF