now anticipative solver sirectly creates an epoch dataset

Author: BatyLeo

src/DynamicVehicleScheduling/DynamicVSP/learning/2d_features.jl

@@ -36,12 +36,12 @@ include("environment/scenario.jl")
 include("environment/environment.jl")
 include("environment/plot.jl")
 
-include("DynamicVSP/algorithms/prize_collecting_vsp.jl")
-include("DynamicVSP/algorithms/anticipative_solver.jl")
+include("algorithms/prize_collecting_vsp.jl")
+include("algorithms/anticipative_solver.jl")
 
-include("DynamicVSP/learning/features.jl")
-include("DynamicVSP/learning/2d_features.jl")
-include("DynamicVSP/learning/dataset.jl")
+include("learning/features.jl")
+include("learning/2d_features.jl")
+include("learning/dataset.jl")
 
 include("policy/abstract_vsp_policy.jl")
 include("policy/greedy_policy.jl")
@@ -62,14 +62,18 @@ function Utils.generate_scenario_generator(::DVSPBenchmark)
 end
 
 function Utils.generate_anticipative_solver(::DVSPBenchmark; kwargs...)
-    return AnticipativeVSPPolicy(; kwargs...)
+    return anticipative_solver
 end
 
 function Utils.generate_environment(::DVSPBenchmark, instance::Instance; kwargs...)
     return DVSPEnv(instance; kwargs...)
 end
 
-export DVSPBenchmark, generate_environment # , generate_sample, generate_anticipative_solver
+function Utils.generate_maximizer(::DVSPBenchmark)
+    return prize_collecting_vsp
+end
+
+export DVSPBenchmark #, generate_environment # , generate_sample, generate_anticipative_solver
 export run_policy!,
     GreedyVSPPolicy, LazyVSPPolicy, KleopatraVSPPolicy, AnticipativeVSPPolicy
 

src/DynamicVehicleScheduling/DynamicVehicleScheduling.jl

@@ -116,6 +116,76 @@ function anticipative_solver(
 
     optimize!(model)
 
-    return JuMP.objective_value(model),
-    retrieve_routes_anticipative(value.(y), env, customer_index)
+    obj = JuMP.objective_value(model)
+    epoch_routes = retrieve_routes_anticipative(value.(y), env, customer_index)
+
+    epoch_indices = Vector{Int}[]
+    N = 1
+    indices = [1]
+    for epoch in 1:last_epoch
+        M = length(scenario.indices[epoch])
+        indices = vcat(indices, (N + 1):(N + M))
+        push!(epoch_indices, copy(indices))
+        N = N + M
+        epoch_routes[epoch]
+        dispatched = vcat(epoch_routes[epoch]...)
+        indices = setdiff(indices, dispatched)
+    end
+
+    indices = vcat(1, scenario.indices...)
+    start_time = vcat(0.0, scenario.start_time...)
+    service_time = vcat(0.0, scenario.service_time...)
+
+    dataset = map(1:last_epoch) do epoch
+        routes = epoch_routes[epoch]
+        epoch_customers = epoch_indices[epoch]
+        # y_true = [
+        #     map(idx -> findfirst(==(idx), epoch_customers), route) for route in routes
+        # ]
+
+        y_true =
+            VSPSolution(
+                Vector{Int}[
+                    map(idx -> findfirst(==(idx), epoch_customers), route) for
+                    route in routes
+                ];
+                max_index=length(epoch_customers),
+            ).edge_matrix
+
+        location_indices = indices[epoch_customers]
+        new_coordinates = env.instance.static_instance.coordinate[location_indices]
+        new_start_time = start_time[epoch_customers]
+        new_service_time = service_time[epoch_customers]
+        new_duration = env.instance.static_instance.duration[
+            location_indices, location_indices
+        ]
+        static_instance = StaticInstance(
+            new_coordinates, new_service_time, new_start_time, new_duration
+        )
+
+        is_must_dispatch = falses(length(location_indices))
+        is_postponable = falses(length(location_indices))
+
+        epoch_duration = env.instance.epoch_duration
+        Δ_dispatch = env.instance.Δ_dispatch
+        planning_start_time = (epoch - 1) * epoch_duration + Δ_dispatch
+        is_must_dispatch[2:end] .=
+            planning_start_time .+ epoch_duration .+ @view(new_duration[1, 2:end]) .>
+            new_start_time[2:end]
+        is_postponable[2:end] .= .!is_must_dispatch[2:end]
+
+        state = DVSPState(;
+            state_instance=static_instance,
+            is_must_dispatch,
+            is_postponable,
+            location_indices,
+            current_epoch=epoch,
+        )
+
+        x = compute_2D_features(state, env.instance)
+
+        return DataSample(; instance=state, y_true, x)
+    end
+
+    return obj, dataset
 end

src/DynamicVehicleScheduling/DynamicVSP/algorithms/anticipative_solver.jl renamed to src/DynamicVehicleScheduling/algorithms/anticipative_solver.jl

@@ -127,83 +127,83 @@ function prize_collecting_vsp(
     return retrieve_routes(value.(y), graph)
 end
 
-# ?
-function prize_collecting_vsp_Q(
-    θ::AbstractVector,
-    vals::AbstractVector;
-    instance::DVSPState,
-    model_builder=highs_model,
-    kwargs...,
-)
-    (; duration) = instance.instance
-    graph = create_graph(instance)
-    model = model_builder()
-    set_silent(model)
-    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, 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
-    @objective(
-        model,
-        Max,
-        sum(
-            (θ_ext[dst(edge)] + vals[dst(edge)] - duration[src(edge), dst(edge)]) *
-            y[src(edge), dst(edge)] for edge in edges(graph)
-        )
-    )
-    @constraint(
-        model,
-        flow[i in 2:nb_nodes],
-        sum(y[j, i] for j in inneighbors(graph, i)) ==
-            sum(y[i, j] for j in outneighbors(graph, i))
-    )
-    @constraint(
-        model, demand[i in job_indices], sum(y[j, i] for j in inneighbors(graph, i)) <= 1
-    )
-    # must dispatch constraints
-    @constraint(
-        model,
-        demand_must_dispatch[i in job_indices; instance.is_must_dispatch[i]],
-        sum(y[j, i] for j in inneighbors(graph, i)) == 1
-    )
-    optimize!(model)
-    return retrieve_routes(value.(y), graph)
-end
+# # ?
+# function prize_collecting_vsp_Q(
+#     θ::AbstractVector,
+#     vals::AbstractVector;
+#     instance::DVSPState,
+#     model_builder=highs_model,
+#     kwargs...,
+# )
+#     (; duration) = instance.instance
+#     graph = create_graph(instance)
+#     model = model_builder()
+#     set_silent(model)
+#     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, 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
+#     @objective(
+#         model,
+#         Max,
+#         sum(
+#             (θ_ext[dst(edge)] + vals[dst(edge)] - duration[src(edge), dst(edge)]) *
+#             y[src(edge), dst(edge)] for edge in edges(graph)
+#         )
+#     )
+#     @constraint(
+#         model,
+#         flow[i in 2:nb_nodes],
+#         sum(y[j, i] for j in inneighbors(graph, i)) ==
+#             sum(y[i, j] for j in outneighbors(graph, i))
+#     )
+#     @constraint(
+#         model, demand[i in job_indices], sum(y[j, i] for j in inneighbors(graph, i)) <= 1
+#     )
+#     # must dispatch constraints
+#     @constraint(
+#         model,
+#         demand_must_dispatch[i in job_indices; instance.is_must_dispatch[i]],
+#         sum(y[j, i] for j in inneighbors(graph, i)) == 1
+#     )
+#     optimize!(model)
+#     return retrieve_routes(value.(y), graph)
+# end
 
-function my_objective_value(θ, routes; instance)
-    (; duration) = instance.instance
-    total = 0.0
-    θ_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)
-            total += θ_ext[v] - duration[u, v]
-        end
-    end
-    return -total
-end
+# function my_objective_value(θ, routes; instance)
+#     (; duration) = instance.instance
+#     total = 0.0
+#     θ_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)
+#             total += θ_ext[v] - duration[u, v]
+#         end
+#     end
+#     return -total
+# end
 
-function _objective_value(θ, routes; instance)
-    (; duration) = instance.instance
-    total = 0.0
-    θ_ext = fill(0.0, location_count(instance))
-    θ_ext[instance.is_postponable] .= θ
-    mapping = cumsum(instance.is_postponable)
-    g = falses(length(θ))
-    for route in routes
-        for (u, v) in partition(vcat(1, route), 2, 1)
-            total -= duration[u, v]
-            if instance.is_postponable[v]
-                total += θ_ext[v]
-                g[mapping[v]] = 1
-            end
-        end
-    end
-    return -total, g
-end
+# function _objective_value(θ, routes; instance)
+#     (; duration) = instance.instance
+#     total = 0.0
+#     θ_ext = fill(0.0, location_count(instance))
+#     θ_ext[instance.is_postponable] .= θ
+#     mapping = cumsum(instance.is_postponable)
+#     g = falses(length(θ))
+#     for route in routes
+#         for (u, v) in partition(vcat(1, route), 2, 1)
+#             total -= duration[u, v]
+#             if instance.is_postponable[v]
+#                 total += θ_ext[v]
+#                 g[mapping[v]] = 1
+#             end
+#         end
+#     end
+#     return -total, g
+# end
 
 # function ChainRulesCore.rrule(::typeof(my_objective_value), θ, routes; instance)
 #     total, g = _objective_value(θ, routes; instance)

src/DynamicVehicleScheduling/DynamicVSP/algorithms/prize_collecting_vsp.jl renamed to src/DynamicVehicleScheduling/algorithms/prize_collecting_vsp.jl

@@ -52,15 +52,6 @@ Check if the episode is terminated, i.e. if the current epoch is the last one.
 """
 CommonRLInterface.terminated(env::DVSPEnv) = current_epoch(env) >= last_epoch(env)
 
-"""
-draw new customers in scenario
-"""
-function draw_next_epoch!(env::DVSPEnv, scenario=env.scenario)
-    env.state.current_epoch += 1
-
-    return nothing
-end
-
 """
 $TYPEDSIGNATURES
 
@@ -78,10 +69,9 @@ remove dispatched customers, advance time, and add new requests to the environme
 function CommonRLInterface.act!(env::DVSPEnv, routes, scenario=env.scenario)
     reward = -apply_routes!(env.state, routes)
     env.state.current_epoch += 1
-    if current_epoch(env) > last_epoch(env)
-        return nothing
+    if current_epoch(env) <= last_epoch(env)
+        add_new_customers!(env.state, env.instance; scenario[current_epoch(env)]...)
     end
-    add_new_customers!(env.state, env.instance; scenario[current_epoch(env)]...)
     return reward
 end
 

src/DynamicVehicleScheduling/environment/environment.jl

@@ -0,0 +1,16 @@
+function get_features_meanTimeToRequests(state::DVSPState, instance::Instance)
+    quantiles = [0.5]
+    a = instance.static_instance.duration[state.location_indices, 2:end]
+    quantileTimeToRequests = mapslices(x -> quantile(x, quantiles), a; dims=2)
+    return quantileTimeToRequests
+end
+
+function compute_2D_features(state::DVSPState, instance::Instance)
+    timeDepotRequest = state.state_instance.duration[:, 1][state.is_postponable]
+    quantileTimeToRequests = get_features_meanTimeToRequests(state, instance)[state.is_postponable]
+    return hcat(timeDepotRequest, quantileTimeToRequests)'
+end
+
+function compute_2D_features(env::DVSPEnv)
+    return compute_2D_features(env.state, env.instance)
+end