bump to newer version of DFLBenchmarks

Author: BatyLeo

.JuliaFormatter.toml

@@ -1,2 +1 @@
-# See https://domluna.github.io/JuliaFormatter.jl/stable/ for a list of options
 style = "blue"

Project.toml

@@ -12,6 +12,7 @@ ProgressMeter = "92933f4c-e287-5a05-a399-4b506db050ca"
 UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
 
 [compat]
+DecisionFocusedLearningBenchmarks = "0.3.0"
 Flux = "0.16.5"
 InferOpt = "0.7.1"
 MLUtils = "0.4.8"

scripts/main.jl

@@ -2,6 +2,14 @@ using DecisionFocusedLearningAlgorithms
 using DecisionFocusedLearningBenchmarks
 using MLUtils
 using Statistics
+using Plots
+
+res = fyl_train_model(ArgmaxBenchmark(); epochs=10_000)
+plot(res.validation_loss[100:end]; label="Validation Loss")
+plot!(res.training_loss[100:end]; label="Training Loss")
+
+baty_train_model(DynamicVehicleSchedulingBenchmark(; two_dimensional_features=false))
+DAgger_train_model(DynamicVehicleSchedulingBenchmark(; two_dimensional_features=false))
 
 struct KleopatraPolicy{M}
     model::M
@@ -13,10 +21,6 @@ function (m::KleopatraPolicy)(env)
     return maximizer(θ; instance)
 end
 
-fyl_train_model(ArgmaxBenchmark(); epochs=1000)
-baty_train_model(DynamicVehicleSchedulingBenchmark(; two_dimensional_features=false))
-DAgger_train_model(DynamicVehicleSchedulingBenchmark(; two_dimensional_features=false))
-
 b = DynamicVehicleSchedulingBenchmark(; two_dimensional_features=false)
 dataset = generate_dataset(b, 100)
 train_instances, validation_instances, test_instances = splitobs(

src/fyl.jl

@@ -1,53 +1,75 @@
 # TODO: every N epochs
 # TODO: best_model saving method, using default metric validation loss, overwritten in dagger
 # TODO: Implement validation loss as a metric callback
+# TODO: batch training option
+# TODO: parallelize loss computation on validation set
 
 function fyl_train_model!(
     model,
     maximizer,
     train_dataset::AbstractArray{<:DataSample},
     validation_dataset;
     epochs=100,
-    maximizer_kwargs=(sample -> (; instance=sample.instance)),
+    maximizer_kwargs=(sample -> (; instance=sample.info)),
     metrics_callbacks::NamedTuple=NamedTuple(),
 )
-    perturbed = PerturbedAdditive(maximizer; nb_samples=20, ε=1.0, threaded=true)
+    perturbed = PerturbedAdditive(maximizer; nb_samples=50, ε=1.0, threaded=true, seed=0)
     loss = FenchelYoungLoss(perturbed)
 
     optimizer = Adam()
     opt_state = Flux.setup(optimizer, model)
 
     total_loss = 0.0
     for sample in validation_dataset
-        (; x, y_true) = sample
-        total_loss += loss(model(x), y_true; maximizer_kwargs(sample)...)
+        (; x, y) = sample
+        total_loss += loss(model(x), y; maximizer_kwargs(sample)...)
     end
     loss_history = [total_loss / length(validation_dataset)]
 
+    total_train_loss = 0.0
+    for sample in train_dataset
+        (; x, y) = sample
+        total_train_loss += loss(model(x), y; maximizer_kwargs(sample)...)
+    end
+
     # Initialize metrics history with epoch 0 for type stability
     metrics_history = _initialize_nested_metrics(metrics_callbacks, model, maximizer, 0)
 
     # Add validation loss to metrics
     metrics_history = merge(
-        metrics_history, (; validation_loss=[total_loss / length(validation_dataset)])
+        metrics_history,
+        (;
+            validation_loss=[total_loss / length(validation_dataset)],
+            training_loss=[total_train_loss / length(train_dataset)],
+        ),
     )
 
     @showprogress for epoch in 1:epochs
+        l = 0
         for sample in train_dataset
-            (; x, y_true) = sample
-            grads = Flux.gradient(model) do m
-                loss(m(x), y_true; maximizer_kwargs(sample)...)
+            (; x, y) = sample
+            val, grads = Flux.withgradient(model) do m
+                loss(m(x), y; maximizer_kwargs(sample)...)
             end
+            l += val
             Flux.update!(opt_state, model, grads[1])
         end
         # Evaluate on validation set
         total_loss = 0.0
         for sample in validation_dataset
-            (; x, y_true) = sample
-            total_loss += loss(model(x), y_true; maximizer_kwargs(sample)...)
+            (; x, y) = sample
+            total_loss += loss(model(x), y; maximizer_kwargs(sample)...)
         end
         push!(loss_history, total_loss / length(validation_dataset))
         push!(metrics_history.validation_loss, total_loss / length(validation_dataset))
+        # push!(metrics_history.training_loss, l / length(train_dataset))
+
+        total_loss = 0.0
+        for sample in train_dataset
+            (; x, y) = sample
+            total_loss += loss(model(x), y; maximizer_kwargs(sample)...)
+        end
+        push!(metrics_history.training_loss, total_loss / length(train_dataset))
 
         # Call metrics callbacks
         if !isempty(metrics_callbacks)
@@ -64,10 +86,8 @@ function fyl_train_model!(
 end
 
 function fyl_train_model(b::AbstractBenchmark; kwargs...)
-    dataset = generate_dataset(b, 30)
-    train_dataset, validation_dataset, test_dataset = dataset[2:2],
-    dataset[11:20],
-    dataset[21:30]
+    dataset = generate_dataset(b, 100)
+    train_dataset, validation_dataset, _ = splitobs(dataset; at=(0.3, 0.3, 0.4))
     model = generate_statistical_model(b)
     maximizer = generate_maximizer(b)
     return fyl_train_model!(model, maximizer, train_dataset, validation_dataset; kwargs...)