fix features

Author: BatyLeo

src/DynamicVehicleScheduling/algorithms/anticipative_solver.jl

@@ -139,9 +139,6 @@ function anticipative_solver(
     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(
@@ -182,7 +179,8 @@ function anticipative_solver(
             current_epoch=epoch,
         )
 
-        x = compute_2D_features(state, env.instance)
+        # x = compute_2D_features(state, env.instance)
+        x = compute_features(state, env.instance)
 
         return DataSample(; instance=state, y_true, x)
     end

src/DynamicVehicleScheduling/learning/features.jl

@@ -1,21 +1,19 @@
-function get_features_quantileTimeToRequests(env::DVSPEnv)
+function get_features_quantileTimeToRequests(state::DVSPState, instance::Instance)
     quantiles = [i * 0.1 for i in 1:9]
-    a = env.config.static_instance.duration[
-        env.customer_index[.!env.request_is_dispatched], 2:end
-    ]
+    a = instance.static_instance.duration[state.location_indices, 2:end]
     quantileTimeToRequests = mapslices(x -> quantile(x, quantiles), a; dims=2)
     return quantileTimeToRequests
 end
 
-function compute_model_free_features(state::DVSPState; env::DVSPEnv)
-    (; instance, is_postponable) = state
+function compute_model_free_features(state::DVSPState, instance::Instance)
+    (; state_instance, is_postponable) = state
 
-    startTimes = instance.start_time
-    endTimes = startTimes .+ instance.service_time
-    timeDepotRequest = instance.duration[:, 1]
-    timeRequestDepot = instance.duration[1, :]
+    startTimes = state_instance.start_time
+    endTimes = startTimes .+ state_instance.service_time
+    timeDepotRequest = state_instance.duration[:, 1]
+    timeRequestDepot = state_instance.duration[1, :]
 
-    slack_next_epoch = startTimes .- env.config.epoch_duration
+    slack_next_epoch = startTimes .- instance.epoch_duration
 
     model_free_features = hcat(
         startTimes[is_postponable], # 1
@@ -27,49 +25,18 @@ function compute_model_free_features(state::DVSPState; env::DVSPEnv)
     return model_free_features
 end
 
-function compute_model_aware_features(state::DVSPState; env::DVSPEnv)
-    quantileTimeToRequests = get_features_quantileTimeToRequests(env)
+function compute_model_aware_features(state::DVSPState, instance::Instance)
+    quantileTimeToRequests = get_features_quantileTimeToRequests(state, instance)
     model_aware_features = quantileTimeToRequests
     return model_aware_features[state.is_postponable, :]
 end
 
-function compute_features(env::DVSPEnv)
-    state = env.state
-    model_free_features = compute_model_free_features(state; env)
-    model_aware_features = compute_model_aware_features(state; env)
+function compute_features(state::DVSPState, instance::Instance)
+    model_free_features = compute_model_free_features(state, instance)
+    model_aware_features = compute_model_aware_features(state, instance)
     return hcat(model_free_features, model_aware_features)'
 end
 
-# # ? why is this needed
-# function model_free_features_critic(state::DVSPState; env::DVSPEnv)
-#     (; instance) = state
-#     startTimes = instance.start_time
-#     endTimes = instance.service_time .+ instance.start_time
-#     timeDepotRequest = instance.duration[:, 1]
-#     timeRequestDepot = instance.duration[1, :]
-#     slack_next_epoch = startTimes .- env.config.epoch_duration
-#     model_free_features = hcat(
-#         startTimes, endTimes, timeDepotRequest, timeRequestDepot, slack_next_epoch
-#     )
-#     return model_free_features
-# end
-
-# # ?
-# function compute_critic_features(env::DVSPEnv)
-#     state = env.state
-#     model_free_features = model_free_features_critic(state; env)
-#     model_aware_features = get_features_quantileTimeToRequests(env)
-#     postpon = state.is_postponable
-#     return hcat(model_free_features, model_aware_features, postpon)'
-# end
-
-# # ?
-# function compute_critic_2D_features(env::DVSPEnv)
-#     state = env.state
-#     timeDepotRequest = state.instance.duration[:, 1]
-#     quantileTimeToRequests = get_features_meanTimeToRequests(env)
-#     postpon = state.is_postponable
-#     # time_postpon = timeDepotRequest .* postpon
-#     # quant_postpon = quantileTimeToRequests .* postpon
-#     return hcat(timeDepotRequest, quantileTimeToRequests, postpon)'
-# end
+function compute_features(env::DVSPEnv)
+    return compute_features(env.state, env.instance)
+end