implement DVSP under the new interface

Author: BatyLeo

Project.toml

@@ -4,6 +4,7 @@ authors = ["Members of JuliaDecisionFocusedLearning"]
 version = "0.2.2"
 
 [deps]
+CommonRLInterface = "d842c3ba-07a1-494f-bbec-f5741b0a3e98"
 ConstrainedShortestPaths = "b3798467-87dc-4d99-943d-35a1bd39e395"
 DataDeps = "124859b0-ceae-595e-8997-d05f6a7a8dfe"
 Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
@@ -30,6 +31,7 @@ Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
 
 [compat]
+CommonRLInterface = "0.3.3"
 ConstrainedShortestPaths = "0.6.0"
 DataDeps = "0.7"
 Distributions = "0.25"

src/DecisionFocusedLearningBenchmarks.jl

@@ -32,8 +32,8 @@ function __init__()
 
     register(
         DataDep(
-            "euro-neurips-2022",
-            "EURO-NeurIPs challenge 2022 dataset",
+            "dvrptw",
+            "EURO-NeurIPS challenge 2022 dataset for the dynamic vehicle routing problem with time windows",
             "https://github.com/ortec/euro-neurips-vrp-2022-quickstart/archive/refs/heads/main.zip";
             post_fetch_method=_euro_neurips_unpack,
         ),
@@ -54,7 +54,7 @@ include("Warcraft/Warcraft.jl")
 include("FixedSizeShortestPath/FixedSizeShortestPath.jl")
 include("PortfolioOptimization/PortfolioOptimization.jl")
 include("StochasticVehicleScheduling/StochasticVehicleScheduling.jl")
-# include("DynamicVehicleScheduling/DynamicVehicleScheduling.jl")
+include("DynamicVehicleScheduling/DynamicVehicleScheduling.jl")
 
 using .Utils
 using .Argmax
@@ -64,11 +64,11 @@ using .Warcraft
 using .FixedSizeShortestPath
 using .PortfolioOptimization
 using .StochasticVehicleScheduling
-# using .DynamicVehicleScheduling
+using .DynamicVehicleScheduling
 
 # Interface
 export AbstractBenchmark, AbstractStochasticBenchmark, AbstractDynamicBenchmark, DataSample
-export generate_dataset
+export generate_sample, generate_dataset, generate_scenario
 export generate_statistical_model
 export generate_maximizer, maximizer_kwargs
 export objective_value
@@ -83,5 +83,6 @@ export WarcraftBenchmark
 export FixedSizeShortestPathBenchmark
 export PortfolioOptimizationBenchmark
 export StochasticVehicleSchedulingBenchmark
+export DVSPBenchmark
 
 end # module DecisionFocusedLearningBenchmarks

src/DynamicVehicleScheduling/DynamicVSP/algorithms/anticipative_solver.jl

@@ -4,13 +4,14 @@ $TYPEDSIGNATURES
 Retrieve anticipative routes solution from the given MIP solution `y`.
 Outputs a set of routes per epoch.
 """
-function retrieve_routes_anticipative(y::AbstractArray, dvspenv::DVSPEnv)
-    nb_tasks = length(dvspenv.customer_index)
-    (; first_epoch, last_epoch) = dvspenv.config
+function retrieve_routes_anticipative(y::AbstractArray, dvspenv::DVSPEnv, customer_index)
+    nb_tasks = length(customer_index)
+    first_epoch = 1
+    (; last_epoch) = dvspenv.instance
     job_indices = 2:(nb_tasks)
     epoch_indices = first_epoch:last_epoch
 
-    routes = [Vector{Int}[] for t in epoch_indices]
+    routes = [Vector{Int}[] for _ in epoch_indices]
     for t in epoch_indices
         start = [i for i in job_indices if y[1, i, t] ≈ 1]
         for task in start
@@ -39,13 +40,21 @@ $TYPEDSIGNATURES
 Solve the anticipative VSP problem for environment `env`.
 For this, it uses the current environment history, so make sure that the environment is terminated before calling this method.
 """
-function anticipative_solver(env::DVSPEnv; model_builder=highs_model, draw_epochs=true)
-    draw_epochs && draw_all_epochs!(env)
-    (; customer_index, service_time, start_time, request_epoch) = env
-    duration = env.config.static_instance.duration[customer_index, customer_index]
-    (; first_epoch, last_epoch, epoch_duration, Δ_dispatch) = env.config
+function anticipative_solver(
+    env::DVSPEnv, scenario=env.scenario; model_builder=highs_model, reset_env=false
+)
+    reset_env && reset!(env)
+    request_epoch = [0]
+    for (epoch, indices) in enumerate(scenario.indices)
+        request_epoch = vcat(request_epoch, fill(epoch, length(indices)))
+    end
+    customer_index = vcat(1, scenario.indices...)
+    service_time = vcat(0.0, scenario.service_time...)
+    start_time = vcat(0.0, scenario.start_time...)
 
-    @assert first_epoch == 1
+    duration = env.instance.static_instance.duration[customer_index, customer_index]
+    first_epoch = 1
+    (; last_epoch, epoch_duration, Δ_dispatch) = env.instance
 
     model = model_builder()
     set_silent(model)
@@ -80,7 +89,7 @@ function anticipative_solver(env::DVSPEnv; model_builder=highs_model, draw_epoch
         sum(y[j, i, t] for j in 1:nb_nodes, t in epoch_indices) == 1
     )
 
-    # a trip from i can be planned only after request appeared
+    # a trip from i can be planned only after request appeared (release times)
     for i in job_indices, t in epoch_indices, j in 1:nb_nodes
         if t < request_epoch[i]
             @constraint(model, y[i, j, t] <= 0)
@@ -107,5 +116,6 @@ function anticipative_solver(env::DVSPEnv; model_builder=highs_model, draw_epoch
 
     optimize!(model)
 
-    return retrieve_routes_anticipative(value.(y), env)
+    return JuMP.objective_value(model),
+    retrieve_routes_anticipative(value.(y), env, customer_index)
 end

src/DynamicVehicleScheduling/DynamicVSP/algorithms/prize_collecting_vsp.jl

@@ -3,10 +3,10 @@ $TYPEDSIGNATURES
 
 Create the acyclic digraph associated with the given VSP `instance`.
 """
-function create_graph(instance::VSPInstance)
+function create_graph(instance::StaticInstance)
     (; duration, start_time, service_time) = instance
     # Initialize directed graph
-    nb_vertices = nb_locations(instance)
+    nb_vertices = location_count(instance)
     graph = SimpleDiGraph(nb_vertices)
 
     depot = 1  # depot is always index 1
@@ -42,8 +42,8 @@ $TYPEDSIGNATURES
 
 Create the acyclic digraph associated with the given VSP `state`.
 """
-function create_graph(state::VSPState)
-    return create_graph(state.instance)
+function create_graph(state::DVSPState)
+    return create_graph(state.state_instance)
 end
 
 """
@@ -82,9 +82,9 @@ $TYPEDSIGNATURES
 Solve the Prize Collecting Vehicle Scheduling Problem defined by `instance` and prize vector `θ`.
 """
 function prize_collecting_vsp(
-    θ::AbstractVector; instance::VSPState, model_builder=highs_model, kwargs...
+    θ::AbstractVector; instance::DVSPState, model_builder=highs_model, kwargs...
 )
-    (; duration) = instance.instance
+    (; duration) = instance.state_instance
     graph = create_graph(instance)
 
     model = model_builder()
@@ -95,7 +95,7 @@ function prize_collecting_vsp(
 
     @variable(model, y[i=1:nb_nodes, j=1:nb_nodes; has_edge(graph, i, j)] >= 0)
 
-    θ_ext = fill(0.0, nb_locations(instance))  # no prize for must dispatch requests, only hard constraints
+    θ_ext = fill(0.0, location_count(instance))  # no prize for must dispatch requests, only hard constraints
     θ_ext[instance.is_postponable] .= θ
 
     @objective(
@@ -131,7 +131,7 @@ end
 function prize_collecting_vsp_Q(
     θ::AbstractVector,
     vals::AbstractVector;
-    instance::VSPState,
+    instance::DVSPState,
     model_builder=highs_model,
     kwargs...,
 )
@@ -142,7 +142,7 @@ function prize_collecting_vsp_Q(
     nb_nodes = nv(graph)
     job_indices = 2:(nb_nodes)
     @variable(model, y[i=1:nb_nodes, j=1:nb_nodes; has_edge(graph, i, j)] >= 0)
-    θ_ext = fill(0.0, nb_locations(instance.instance))  # no prize for must dispatch requests, only hard constraints
+    θ_ext = fill(0.0, location_count(instance.instance))  # no prize for must dispatch requests, only hard constraints
     θ_ext[instance.is_postponable] .= θ
     # v_ext = fill(0.0, nb_locations(instance.instance))  # no prize for must dispatch requests, only hard constraints
     # v_ext[instance.is_postponable] .= vals
@@ -176,7 +176,7 @@ end
 function my_objective_value(θ, routes; instance)
     (; duration) = instance.instance
     total = 0.0
-    θ_ext = fill(0.0, nb_locations(instance))
+    θ_ext = fill(0.0, location_count(instance))
     θ_ext[instance.is_postponable] .= θ
     for route in routes
         for (u, v) in partition(vcat(1, route), 2, 1)
@@ -189,7 +189,7 @@ end
 function _objective_value(θ, routes; instance)
     (; duration) = instance.instance
     total = 0.0
-    θ_ext = fill(0.0, nb_locations(instance))
+    θ_ext = fill(0.0, location_count(instance))
     θ_ext[instance.is_postponable] .= θ
     mapping = cumsum(instance.is_postponable)
     g = falses(length(θ))