update

Author: BatyLeo

src/DynamicAssortment/DynamicAssortment.jl

@@ -110,12 +110,13 @@ end
 """
 $TYPEDSIGNATURES
 
-Creates an [`Environment`](@ref) from an [`Instance`](@ref) of the dynamic assortment benchmark.
-The seed of the environment is randomly generated using the provided random number generator.
+Creates an [`Environment`](@ref) for the dynamic assortment benchmark.
+The instance and seed are randomly generated using the provided random number generator.
 """
 function Utils.generate_environment(
-    ::DynamicAssortmentBenchmark, instance::Instance, rng::AbstractRNG; kwargs...
+    b::DynamicAssortmentBenchmark, rng::AbstractRNG; kwargs...
 )
+    instance = Instance(b, rng)
     seed = rand(rng, 1:typemax(Int))
     return Environment(instance; seed)
 end

src/DynamicVehicleScheduling/DynamicVehicleScheduling.jl

@@ -18,6 +18,25 @@ using Random: Random, AbstractRNG, MersenneTwister, seed!, randperm
 using Requires: @require
 using Statistics: mean, quantile
 
+"""
+$TYPEDEF
+
+Abstract type for dynamic vehicle scheduling benchmarks.
+
+# Fields
+$TYPEDFIELDS
+"""
+@kwdef struct DynamicVehicleSchedulingBenchmark <: AbstractDynamicBenchmark{true}
+    "maximum number of customers entering the system per epoch"
+    max_requests_per_epoch::Int = 10
+    "time between decision and dispatch of a vehicle"
+    Δ_dispatch::Float64 = 1.0
+    "duration of an epoch"
+    epoch_duration::Float64 = 1.0
+    "whether to use two-dimensional features"
+    two_dimensional_features::Bool = false
+end
+
 include("utils.jl")
 
 # static vsp stuff
@@ -38,46 +57,35 @@ include("anticipative_solver.jl")
 include("features.jl")
 include("policy.jl")
 
-"""
-$TYPEDEF
-
-Abstract type for dynamic vehicle scheduling benchmarks.
-
-# Fields
-$TYPEDFIELDS
-"""
-@kwdef struct DynamicVehicleSchedulingBenchmark <: AbstractDynamicBenchmark{true}
-    "maximum number of customers entering the system per epoch"
-    max_requests_per_epoch::Int = 10
-    "time between decision and dispatch of a vehicle"
-    Δ_dispatch::Float64 = 1.0
-    "duration of an epoch"
-    epoch_duration::Float64 = 1.0
-    "whether to use two-dimensional features"
-    two_dimensional_features::Bool = false
-end
-
 """
 $TYPEDSIGNATURES
 
-Generate a dataset for the dynamic vehicle scheduling benchmark.
-Returns a vector of [`DataSample`](@ref) objects, each containing an [`Instance`](@ref).
-The dataset is generated from pre-existing DVRPTW files.
+Generate environments for the dynamic vehicle scheduling benchmark.
+Reads from pre-existing DVRPTW files and creates [`DVSPEnv`](@ref) environments.
 """
-function Utils.generate_dataset(b::DynamicVehicleSchedulingBenchmark, dataset_size::Int=1)
+function Utils.generate_environments(
+    b::DynamicVehicleSchedulingBenchmark,
+    n::Int;
+    seed=nothing,
+    rng=MersenneTwister(seed),
+    kwargs...,
+)
     (; max_requests_per_epoch, Δ_dispatch, epoch_duration, two_dimensional_features) = b
     files = readdir(datadep"dvrptw"; join=true)
-    dataset_size = min(dataset_size, length(files))
+    n = min(n, length(files))
     return [
-        DataSample(;
-            instance=Instance(
+        generate_environment(
+            b,
+            Instance(
                 read_vsp_instance(files[i]);
                 max_requests_per_epoch,
                 Δ_dispatch,
                 epoch_duration,
                 two_dimensional_features,
             ),
-        ) for i in 1:dataset_size
+            rng;
+            kwargs...,
+        ) for i in 1:n
     ]
 end
 
@@ -87,7 +95,7 @@ $TYPEDSIGNATURES
 Creates an environment from an [`Instance`](@ref) of the dynamic vehicle scheduling benchmark.
 The seed of the environment is randomly generated using the provided random number generator.
 """
-function Utils.generate_environment(
+function generate_environment(
     ::DynamicVehicleSchedulingBenchmark, instance::Instance, rng::AbstractRNG; kwargs...
 )
     seed = rand(rng, 1:typemax(Int))
@@ -107,16 +115,6 @@ end
 """
 $TYPEDSIGNATURES
 
-Generate a scenario for the dynamic vehicle scheduling benchmark.
-This is a wrapper around the generic scenario generation function.
-"""
-function Utils.generate_scenario(b::DynamicVehicleSchedulingBenchmark, args...; kwargs...)
-    return Utils.generate_scenario(args...; kwargs...)
-end
-
-"""
-$TYPEDSIGNATURES
-
 Generate an anticipative solution for the dynamic vehicle scheduling benchmark.
 The solution is computed using the anticipative solver with the benchmark's feature configuration.
 """
@@ -131,6 +129,21 @@ end
 """
 $TYPEDSIGNATURES
 
+Return the anticipative solver for the dynamic vehicle scheduling benchmark.
+The callable takes a scenario and solver kwargs (including `instance`) and returns a
+training trajectory as a `Vector{DataSample}`.
+"""
+function Utils.generate_anticipative_solver(::DynamicVehicleSchedulingBenchmark)
+    return (scenario; instance, kwargs...) -> begin
+        env = DVSPEnv(instance, scenario)
+        _, trajectory = anticipative_solver(env; reset_env=false, kwargs...)
+        return trajectory
+    end
+end
+
+"""
+$TYPEDSIGNATURES
+
 Generate baseline policies for the dynamic vehicle scheduling benchmark.
 Returns a tuple containing:
 - `lazy`: A policy that dispatches vehicles only when they are ready

src/DynamicVehicleScheduling/environment.jl

@@ -23,6 +23,17 @@ function DVSPEnv(instance::Instance; seed=nothing)
     return DVSPEnv(instance, initial_state, scenario, rng, seed)
 end
 
+"""
+$TYPEDSIGNATURES
+
+Constructor for [`DVSPEnv`](@ref) from a pre-existing scenario.
+"""
+function DVSPEnv(instance::Instance, scenario::Scenario; seed=nothing)
+    rng = MersenneTwister(seed)
+    initial_state = DVSPState(instance; scenario[1]...)
+    return DVSPEnv(instance, initial_state, scenario, rng, seed)
+end
+
 currrent_epoch(env::DVSPEnv) = current_epoch(env.state)
 epoch_duration(env::DVSPEnv) = epoch_duration(env.instance)
 last_epoch(env::DVSPEnv) = last_epoch(env.instance)

src/DynamicVehicleScheduling/scenario.jl

@@ -1,4 +1,3 @@
-
 struct Scenario
     "indices of the new requests in each epoch"
     indices::Vector{Vector{Int}}
@@ -51,6 +50,8 @@ function Utils.generate_scenario(
     return Scenario(new_indices, new_service_time, new_start_time)
 end
 
-function Utils.generate_scenario(sample::DataSample; kwargs...)
-    return Utils.generate_scenario(sample.instance; kwargs...)
+function Utils.generate_scenario(
+    ::DynamicVehicleSchedulingBenchmark, rng::AbstractRNG; instance, kwargs...
+)
+    return generate_scenario(instance; rng)
 end

src/Maintenance/Maintenance.jl

@@ -114,12 +114,11 @@ end
 """
 $TYPEDSIGNATURES
 
-Creates an [`Environment`](@ref) from an [`Instance`](@ref) of the maintenance benchmark.
-The seed of the environment is randomly generated using the provided random number generator.
+Creates an [`Environment`](@ref) for the maintenance benchmark.
+The instance and seed are randomly generated using the provided random number generator.
 """
-function Utils.generate_environment(
-    ::MaintenanceBenchmark, instance::Instance, rng::AbstractRNG; kwargs...
-)
+function Utils.generate_environment(b::MaintenanceBenchmark, rng::AbstractRNG; kwargs...)
+    instance = Instance(b, rng)
     seed = rand(rng, 1:typemax(Int))
     return Environment(instance; seed)
 end

src/Utils/Utils.jl

@@ -33,6 +33,7 @@ export generate_scenario
 export generate_environment, generate_environments
 export generate_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