Advance dynamic assortment

Author: BatyLeo

src/DecisionFocusedLearningBenchmarks.jl

@@ -71,10 +71,11 @@ using .DynamicAssortment
 # Interface
 export AbstractBenchmark, AbstractStochasticBenchmark, AbstractDynamicBenchmark, DataSample
 
-export generate_sample, generate_dataset, generate_environments
+export generate_sample, generate_dataset, generate_environments, generate_environment
 export generate_scenario_generator, generate_anticipative_solver
 export generate_statistical_model
 export generate_maximizer, maximizer_kwargs
+export is_exogenous, is_endogenous
 
 export objective_value
 export plot_data, plot_instance, plot_solution

src/DynamicAssortment/DynamicAssortment.jl

@@ -10,25 +10,69 @@ using Random: Random, AbstractRNG, MersenneTwister
 using Statistics: mean
 
 using Flux: Chain, Dense
-# using Flux.Optimise
-# using InferOpt
-# using Random
-# using JLD2
-# using Plots
-# using Distributions
-# using LinearAlgebra
 using Combinatorics: combinations
 
+"""
+$TYPEDEF
+
+Benchmark for the dynamic assortment problem.
+
+# Fields
+$TYPEDFIELDS
+"""
+struct DynamicAssortmentBenchmark{exogenous,M} <: AbstractDynamicBenchmark{exogenous}
+    "customer choice model (price, hype, saturation, and features)"
+    customer_choice_model::M
+    "number of items"
+    N::Int
+    "dimension of feature vectors (in addition to hype, satisfaction, and price)"
+    d::Int
+    "assortment size constraint"
+    K::Int
+    "number of steps per episode"
+    max_steps::Int
+end
+
+function DynamicAssortmentBenchmark(;
+    N=20,
+    d=2,
+    K=4,
+    max_steps=80,
+    customer_choice_model=Chain(Dense([-0.8 0.6 -0.4 0.3 0.5]), vec),
+    exogenous=false,
+)
+    return DynamicAssortmentBenchmark{exogenous,typeof(customer_choice_model)}(
+        customer_choice_model, N, d, K, max_steps
+    )
+end
+
+include("instance.jl")
 include("environment.jl")
 
-struct DynamicAssortmentBenchmark <: AbstractDynamicBenchmark end
+customer_choice_model(b::DynamicAssortmentBenchmark) = b.customer_choice_model
+item_count(b::DynamicAssortmentBenchmark) = b.N
+feature_count(b::DynamicAssortmentBenchmark) = b.d
+assortment_size(b::DynamicAssortmentBenchmark) = b.K
+max_steps(b::DynamicAssortmentBenchmark) = b.max_steps
+
+function Utils.generate_sample(
+    b::DynamicAssortmentBenchmark, rng::AbstractRNG=MersenneTwister(0); seed=nothing
+)
+    Random.seed!(rng, seed)
+    return DataSample(; instance=Instance(b, rng))
+end
 
-function Utils.generate_sample(::DynamicAssortmentBenchmark)
-    return DataSample(; instance=Instance())
+function Utils.generate_maximizer(b::DynamicAssortmentBenchmark)
+    return TopKMaximizer(assortment_size(b))
 end
 
-function Utils.generate_maximizer(::DynamicAssortmentBenchmark)
-    return DAP_optimization
+function Utils.generate_environment(
+    ::DynamicAssortmentBenchmark,
+    instance::Instance;
+    seed=nothing,
+    rng::AbstractRNG=MersenneTwister(seed),
+)
+    return Environment(instance; seed=seed, rng=rng)
 end
 
 export DynamicAssortmentBenchmark