plot instance and plot solution

Author: BatyLeo

src/DecisionFocusedLearningBenchmarks.jl

@@ -46,7 +46,7 @@ export AbstractBenchmark, DataSample
 export generate_dataset
 export generate_statistical_model
 export generate_maximizer
-export plot_data
+export plot_data, plot_instance, plot_solution
 export compute_gap
 
 # Export all benchmarks

src/StochasticVehicleScheduling/StochasticVehicleScheduling.jl

@@ -28,6 +28,7 @@ using JuMP:
     objective_value,
     set_silent,
     dual
+using Plots: Plots, plot, plot!, scatter!, annotate!, text
 using Printf: @printf
 using Random: Random, AbstractRNG, MersenneTwister
 using SparseArrays: sparse
@@ -72,6 +73,7 @@ Note that computing solutions can be time-consuming, especially for large instan
 You can also use instead `compact_mip` or `compact_linearized_mip` as the algorithm to compute solutions.
 If you want to provide a custom algorithm to compute solutions, you can pass it as the `algorithm` keyword argument.
 If `algorithm` takes keyword arguments, you can pass them as well directly in `kwargs...`.
+If `store_city=false`, the coordinates and unnecessary information about instances will not be stored in the dataset.
 """
 function Utils.generate_dataset(
     benchmark::StochasticVehicleSchedulingBenchmark,
@@ -80,11 +82,14 @@ function Utils.generate_dataset(
     seed=nothing,
     rng=MersenneTwister(0),
     algorithm=column_generation_algorithm,
+    store_city=true,
     kwargs...,
 )
     (; nb_tasks, nb_scenarios) = benchmark
     Random.seed!(rng, seed)
-    instances = [Instance(; nb_tasks, nb_scenarios, rng=rng) for _ in 1:dataset_size]
+    instances = [
+        Instance(; nb_tasks, nb_scenarios, rng, store_city) for _ in 1:dataset_size
+    ]
     features = get_features.(instances)
     if compute_solutions
         solutions = [algorithm(instance; kwargs...) for instance in instances]
@@ -114,8 +119,96 @@ function Utils.generate_statistical_model(bench::StochasticVehicleSchedulingBenc
     return Chain(Dense(20 => 1; bias=false), vec)
 end
 
+function plot_instance(
+    ::StochasticVehicleSchedulingBenchmark,
+    sample::DataSample{<:Instance{City}};
+    color_scheme=:lightrainbow,
+    kwargs...,
+)
+    (; tasks, district_width, width) = sample.instance.city
+    ticks = 0:district_width:width
+    max_time = maximum(t.end_time for t in sample.instance.city.tasks[1:(end - 1)])
+    pp = floor(Int, max(max_time))
+    palette = Plots.palette(color_scheme, pp)
+    fig = plot(;
+        xlabel="x",
+        ylabel="y",
+        legend=false,
+        gridlinewidth=3,
+        aspect_ratio=:equal,
+        size=(500, 500),
+        xticks=ticks,
+        yticks=ticks,
+        xlims=(-1, width + 1),
+        ylims=(-1, width + 1),
+    )
+    for (i_task, task) in enumerate(tasks[1:(end - 1)])
+        (; start_point, end_point) = task
+        points = [(start_point.x, start_point.y), (end_point.x, end_point.y)]
+        plot!(fig, points; color=:black)
+        scatter!(
+            fig,
+            points[1];
+            markersize=10,
+            marker=:rect,
+            color=palette[max(floor(Int, task.start_time), 1)],
+        )
+        scatter!(
+            fig,
+            points[2];
+            markersize=10,
+            marker=:rect,
+            color=palette[max(floor(Int, task.end_time), 1)],
+        )
+        annotate!(fig, (points[1]..., text("$(i_task-1)", 10)))
+    end
+    p2 = Plots.heatmap(
+        rand(2, 2); clims=(0, pp), framestyle=:none, c=palette, cbar=true, lims=(-1, -1)
+    )
+    l = Plots.@layout [a{0.99w} b]
+    return plot(fig, p2; layout=l)
+end
+
+function plot_solution(
+    ::StochasticVehicleSchedulingBenchmark, sample::DataSample{<:Instance{City}}; kwargs...
+)
+    (; tasks, district_width, width) = sample.instance.city
+    ticks = 0:district_width:width
+    path_list = compute_path_list(sample.y_true)
+    fig = plot(;
+        xlabel="x",
+        ylabel="y",
+        legend=false,
+        gridlinewidth=3,
+        aspect_ratio=:equal,
+        size=(500, 500),
+        xticks=ticks,
+        yticks=ticks,
+        xlims=(-1, width + 1),
+        ylims=(-1, width + 1),
+    )
+    for path in path_list
+        X = Float64[]
+        Y = Float64[]
+        (; start_point, end_point) = tasks[path[1]]
+        (; x, y) = end_point
+        push!(X, x)
+        push!(Y, y)
+        for task in path[2:end]
+            (; start_point, end_point) = tasks[task]
+            push!(X, start_point.x)
+            push!(Y, start_point.y)
+            push!(X, end_point.x)
+            push!(Y, end_point.y)
+        end
+        plot!(fig, X, Y; marker=:circle)
+    end
+    return fig
+end
+
 export StochasticVehicleSchedulingBenchmark
 export generate_dataset, generate_maximizer, generate_statistical_model
+export plot_instance, plot_solution
 export compact_linearized_mip,
     compact_mip, column_generation_algorithm, evaluate_solution, is_feasible
 

src/StochasticVehicleScheduling/instance/instance.jl

@@ -6,7 +6,7 @@ Instance of the stochastic VSP problem.
 # Fields
 $TYPEDFIELDS
 """
-struct Instance{G<:AbstractGraph,M1<:AbstractMatrix,M2<:AbstractMatrix,F,C}
+struct Instance{CC,G<:AbstractGraph,M1<:AbstractMatrix,M2<:AbstractMatrix,F,C}
     "graph computed from `city` with the `create_VSP_graph(city::City)` method"
     graph::G
     "features matrix computed from `city`"
@@ -19,6 +19,8 @@ struct Instance{G<:AbstractGraph,M1<:AbstractMatrix,M2<:AbstractMatrix,F,C}
     vehicle_cost::C
     "cost of one minute delay"
     delay_cost::C
+    "associated city"
+    city::CC
 end
 
 """
@@ -69,15 +71,25 @@ Constructor for [`Instance`](@ref).
 Build an `Instance` for the stochatsic vehicle scheduling problem, with `nb_tasks` tasks and `nb_scenarios` scenarios.
 """
 function Instance(;
-    nb_tasks::Int, nb_scenarios::Int, rng::AbstractRNG=Random.default_rng(), kwargs...
+    nb_tasks::Int,
+    nb_scenarios::Int,
+    rng::AbstractRNG=Random.default_rng(),
+    store_city=true,
+    kwargs...,
 )
     city = create_random_city(; rng=rng, nb_tasks, nb_scenarios, kwargs...)
     graph = create_VSP_graph(city)
     features = compute_features(city)
     slacks = compute_slacks(city, graph)
     intrinsic_delays = compute_delays(city)
     return Instance(
-        graph, features, slacks, intrinsic_delays, city.vehicle_cost, city.delay_cost
+        graph,
+        features,
+        slacks,
+        intrinsic_delays,
+        city.vehicle_cost,
+        city.delay_cost,
+        store_city ? city : nothing,
     )
 end
 

src/Utils/data_sample.jl

@@ -6,7 +6,7 @@ Data sample data structure.
 # Fields
 $TYPEDFIELDS
 """
-@kwdef struct DataSample{F,S,C,I}
+@kwdef struct DataSample{I,F,S,C}
     "features"
     x::F
     "target cost parameters (optional)"

src/Utils/interface.jl

@@ -46,6 +46,8 @@ Plot a data sample from the dataset created by [`generate_dataset`](@ref).
 Check the specific benchmark documentation of `plot_data` for more details on the arguments.
 """
 function plot_data end
+function plot_instance end
+function plot_solution end
 
 """
     compute_gap(::AbstractBenchmark, dataset::Vector{<:DataSample}, statistical_model, maximizer) -> Float64

test/vsp.jl

@@ -15,6 +15,11 @@
     )
     @test length(dataset) == N
 
+    figure_1 = plot_instance(b, dataset[1])
+    @test figure_1 isa Plots.Plot
+    figure_2 = plot_solution(b, dataset[1])
+    @test figure_2 isa Plots.Plot
+
     maximizer = generate_maximizer(b)
     model = generate_statistical_model(b)