remove randomizer

Author: itsdfish

Examples/Delay_Discounting/Run_Delay_Discounting.jl

@@ -7,12 +7,12 @@ cd(@__DIR__)
 using Pkg
 # activate the project environment
 Pkg.activate("../../")
-using AdaptiveDesignOptimization, Random, UtilityModels, Distributions
+using Revise, AdaptiveDesignOptimization, Random, UtilityModels, Distributions
 include("Delay_Discounting.jl")
 #######################################################################################
 #                                  Define Model
 #######################################################################################
-Random.seed!(204)
+Random.seed!(1204)
 prior = [Uniform(-5, 5), Uniform(-5, 50)]
 
 model = Model(;prior, loglike)
@@ -41,14 +41,13 @@ design_list = (
 # )
 
 data_list = (choice=[true, false],)
-
-optimizer = Optimizer(;design_list, parm_list, data_list, model);
 #######################################################################################
 #                              Simulate Experiment
 #######################################################################################
 using DataFrames
 true_parms = (κ=.12, τ=1.5)
 n_trials = 100
+optimizer = Optimizer(;design_list, parm_list, data_list, model);
 design = optimizer.best_design
 df = DataFrame(design=Symbol[], trial=Int[], mean_κ=Float64[], mean_τ=Float64[],
     std_κ=Float64[], std_τ=Float64[])
@@ -64,7 +63,7 @@ end
 #######################################################################################
 #                              Random Experiment
 #######################################################################################
-randomizer = Randomizer(;design_list, parm_list, data_list, model);
+randomizer = Optimizer(;design_list, parm_list, data_list, model, approach=Randomize);
 design = randomizer.best_design
 new_data = [:random, 0, mean_post(randomizer)..., std_post(randomizer)...]
 push!(df, new_data)
@@ -88,4 +87,3 @@ hline!([true_parms.τ], label="true")
 @df df plot(:trial, :std_κ, xlabel="trial", ylabel="σ of κ", grid=false, group=:design, ylims=(0,.3))
 
 @df df plot(:trial, :std_τ, xlabel="trial", ylabel="σ of τ", grid=false, group=:design, ylims=(0,2))
-

src/AdaptiveDesignOptimization.jl

@@ -1,6 +1,6 @@
 module AdaptiveDesignOptimization
     using Distributions, Parameters, StatsFuns
-    export Optimizer, Model, Randomizer
+    export Optimizer, Model, Optimize, Randomize
     export update!, mean_post, std_post, get_best_design
 
     include("structs.jl")

src/functions.jl

@@ -92,10 +92,10 @@ function find_best_design(mutual_info, design_grid, design_names)
     return best_design
 end
 
-function find_best_design!(randomizer::Randomizer)
-    @unpack design_grid,design_names = randomizer
+function find_best_design!(optimizer::Optimizer{A}) where {A<:Rand}
+    @unpack design_grid,design_names = optimizer
     best_design = rand(design_grid)
-    randomizer.best_design = best_design
+    optimizer.best_design = best_design
     return best_design
 end
 
@@ -120,9 +120,9 @@ function update!(optimizer, data)
     return best_design
 end
 
-function update!(randomizer::Randomizer, data)
-    update_posterior!(randomizer, data)
-    best_design = find_best_design!(randomizer)
+function update!(optimizer::Optimizer{A}, data) where {A<:Rand}
+    update_posterior!(optimizer, data)
+    best_design = find_best_design!(optimizer)
     return best_design
 end
 
@@ -169,4 +169,10 @@ function std_post(optimizer)
     @unpack log_post,parm_grid = optimizer
     post = exp.(log_post)
     return std_post(post, parm_grid)
-end
+end
+
+function create_state(T, dims, args...; kwargs...)
+    state = fill(T(args...; kwargs...), dims)
+    state .= deepcopy.(state)
+end
+

src/structs.jl

@@ -1,5 +1,15 @@
 import Base.Iterators: product
 
+abstract type Approach end
+
+struct Opt <: Approach
+end
+struct Rand <:Approach
+end
+
+const Optimize = Opt()
+const Randomize = Rand()
+
 """
 **Model**
 
@@ -46,7 +56,8 @@ Constructor
 Optimizer(;task, model, grid_design, grid_parms, grid_response)
 ````
 """
-mutable struct Optimizer{M<:Model,T1,T2,T3,T4,T5,T6,T7,T8,T9}
+mutable struct Optimizer{A,M<:Model,T1,T2,T3,T4,T5,T6,T7,T8,T9}
+    approach::A
     model::M
     design_grid::T1
     parm_grid::T2
@@ -64,7 +75,7 @@ mutable struct Optimizer{M<:Model,T1,T2,T3,T4,T5,T6,T7,T8,T9}
     design_names::T9
 end
 
-function Optimizer(;model, design_list, parm_list, data_list)
+function Optimizer(; model, design_list, parm_list, data_list, approach=Optimize)
     design_names,design_grid = to_grid(design_list)
     parm_names,parm_grid = to_grid(parm_list)
     _,data_grid = to_grid(data_list)
@@ -78,34 +89,29 @@ function Optimizer(;model, design_list, parm_list, data_list)
     cond_entropy = conditional_entropy(entropy, post)
     mutual_info = mutual_information(marg_entropy, cond_entropy)
     best_design = find_best_design(mutual_info, design_grid, design_names)
-    return Optimizer(model, design_grid, parm_grid, data_grid, log_like,
+    return Optimizer(approach, model, design_grid, parm_grid, data_grid, log_like,
         marg_log_like, priors, log_post, entropy, marg_entropy, cond_entropy, 
         mutual_info, best_design, parm_names, design_names)
 end
 
-
-mutable struct Randomizer{M<:Model,T1,T2,T3,T4,T5,T6,T7}
-    model::M
-    design_grid::T1
-    parm_grid::T2
-    data_grid::T3
-    log_like::Array{Float64,3}
-    priors::T4
-    log_post::Vector{Float64}
-    best_design::T5
-    parm_names::T6
-    design_names::T7
-end
-
-function Randomizer(;model, design_list, parm_list, data_list)
-    design_names,design_grid = to_grid(design_list)
-    parm_names,parm_grid = to_grid(parm_list)
-    _,data_grid = to_grid(data_list)
-    log_like = loglikelihood(model, design_grid, parm_grid, data_grid)
-    priors = prior_probs(model, parm_grid)
-    post = priors[:]
-    log_post = log.(post)
-    best_design = rand(design_grid)
-    return Randomizer(model, design_grid, parm_grid, data_grid, log_like,
-        priors, log_post, best_design, parm_names, design_names)
-end
+# function Optimizer(args...; update_log_like, model, design_list, parm_list, data_list,
+#     state_type, kwargs...)
+#     design_names,design_grid = to_grid(design_list)
+#     parm_names,parm_grid = to_grid(parm_list)
+#     _,data_grid = to_grid(data_list)
+#     dims = map(length, (parm_grid,design_grid,data_grid))
+#     state = create_state(state_type, dims, args...; kwargs...)
+#     log_like = loglikelihood(model, design_grid, parm_grid, data_grid)
+#     priors = prior_probs(model, parm_grid)
+#     post = priors[:]
+#     log_post = log.(post)
+#     entropy = compute_entropy(log_like)
+#     marg_log_like = marginal_log_like(log_post, log_like)
+#     marg_entropy = marginal_entropy(marg_log_like)
+#     cond_entropy = conditional_entropy(entropy, post)
+#     mutual_info = mutual_information(marg_entropy, cond_entropy)
+#     best_design = find_best_design(mutual_info, design_grid, design_names)
+#     return Optimizer(model, design_grid, parm_grid, data_grid, log_like,
+#         marg_log_like, priors, log_post, entropy, marg_entropy, cond_entropy, 
+#         mutual_info, best_design, parm_names, design_names, update_log_like, state)
+# end

test/runtests.jl

@@ -17,7 +17,8 @@ using SafeTestsets
 
     data_list = (choice=[true, false],)
 
-    randomizer = Randomizer(;design_list, parm_list, data_list, model)
+    randomizer = Optimizer(;design_list, parm_list, data_list, model,
+        approach=Randomize)
 
     @test mean_post(randomizer)[1] ≈ mean(Beta(α,β)) atol = 5e-3
     @test std_post(randomizer)[1] ≈ std(Beta(α,β)) atol = 5e-3