update docs

Author: itsdfish

src/functions.jl

@@ -1,24 +1,87 @@
+"""
+    prior_probs(model::Model, parm_grid)
+
+Computes a grid of prior probabilities over model parameters.
+
+- `model::Model`: a model object
+- `parm_grid`: a grid of parameter values
+"""
 function prior_probs(model::Model, parm_grid)
     return prior_probs(model.prior, parm_grid)
 end
 
+"""
+    prior_probs(prior, parm_grid)
+
+Computes a grid of prior probabilities over model parameters.
+
+- `prior`: a vector of `Distribution` objects, one for each parameter
+- `parm_grid`: a grid of parameter values
+"""
 function prior_probs(prior, parm_grid)
     dens = [mapreduce((θ,d)->pdf(d, θ), *, g, prior) for g in parm_grid]
     return dens/sum(dens)
 end
 
+"""
+    prior_probs(prior, parm_grid)
+
+Computes a grid of uniform prior probabilities over model parameters.
+
+- `prior::Nothing`: a vector of `Distribution` objects, one for each parameter
+- `parm_grid`: a grid of parameter values
+"""
 function prior_probs(prior::Nothing, parm_grid)
     return fill(1/length(parm_grid), size(parm_grid))
 end
 
+"""
+    loglikelihood(model::Model, design_grid, parm_grid, data_grid, model_type, model_state)
+
+Computes a three dimensional grid of log likelihoods where the first dimension is the model parameters, the second
+dimension is the design parameters, and the third dimension is the data values.
+
+- `model::Model`: a model object containing a log likelihood function and prior distributions
+- `parm_grid`: a grid of model parameters
+- `design_grid`: a grid of design parameters
+- `data_grid`: a grid of data values
+- `model_type`: model type can be `Static` or `Dynamic`
+- `model_state`: model state variables that are updated for `Dynamic` models
+"""
 function loglikelihood(model::Model, design_grid, parm_grid, data_grid, model_type, model_state)
     return loglikelihood(model.loglike, design_grid, parm_grid, data_grid)
 end
 
+"""
+    loglikelihood(model::Model, design_grid, parm_grid, data_grid, model_type, model_state)
+
+Computes a three dimensional grid of log likelihoods where the first dimension is the model parameters, the second
+dimension is the design parameters, and the third dimension is the data values.
+
+- `model::Model`: a model object containing a log likelihood function and prior distributions
+- `parm_grid`: a grid of model parameters
+- `design_grid`: a grid of design parameters
+- `data_grid`: a grid of data values
+- `model_type`: model type can be `Static` or `Dynamic`
+- `model_state`: model state variables that are updated for `Dynamic` models
+"""
 function loglikelihood(model::Model, design_grid, parm_grid, data_grid, model_type::Dyn, model_state)
     return loglikelihood(model.loglike, design_grid, parm_grid, data_grid, model_state)
 end
 
+"""
+    loglikelihood(model::Model, design_grid, parm_grid, data_grid, model_type, model_state)
+
+Computes a three dimensional grid of log likelihoods where the first dimension is the model parameters, the second
+dimension is the design parameters, and the third dimension is the data values.
+
+- `loglike`: a model object containing a log likelihood function and prior distributions
+- `parm_grid`: a grid of model parameters
+- `design_grid`: a grid of design parameters
+- `data_grid`: a grid of data values
+- `model_type`: model type can be `Static` or `Dynamic`
+- `model_state`: model state variables that are updated for `Dynamic` models
+"""
 function loglikelihood(loglike, design_grid, parm_grid, data_grid)
     LLs = zeros(length(parm_grid), length(design_grid), length(data_grid))
     for (d, data) in enumerate(data_grid)
@@ -31,25 +94,61 @@ function loglikelihood(loglike, design_grid, parm_grid, data_grid)
     return LLs
 end
 
+"""
+    loglikelihood(model::Model, design_grid, parm_grid, data_grid, model_type, model_state)
+
+Computes a three dimensional grid of log likelihoods for a dynamic model where the first dimension is the model parameters, 
+the second dimension is the design parameters, and the third dimension is the data values.
+
+- `loglike`: a model object containing a log likelihood function and prior distributions
+- `parm_grid`: a grid of model parameters
+- `design_grid`: a grid of design parameters
+- `data_grid`: a grid of data values
+- `model_type`: model type can be `Static` or `Dynamic`
+- `model_state`: model state variables that are updated for `Dynamic` models
+"""
 function loglikelihood(loglike, design_grid, parm_grid, data_grid, model_state)
     LLs = zeros(length(parm_grid), length(design_grid), length(data_grid))
     i = 0
     for (d, data) in enumerate(data_grid)
         for (k,design) in enumerate(design_grid)
             for (p,parms) in enumerate(parm_grid)
                 i += 1
-                LLs[p,k,d] = loglike(parms..., design..., data..., model_state[i]) 
+                state = deepcopy(model_state[i])
+                LLs[p,k,d] = loglike(parms..., design..., data..., state) 
             end
         end
     end
     return LLs
 end
 
+"""
+    loglikelihood(optimizer::Optimizer)
+
+Computes a three dimensional grid of log likelihoods for a dynamic model where the first dimension is the model parameters,
+the second dimension is the design parameters, and the third dimension is the data values.
+
+- `optimizer`: an optimizer object
+
+"""
 function loglikelihood!(optimizer) 
     @unpack model, log_like, design_grid, parm_grid, data_grid, model_state = optimizer
     return loglikelihood!(model.loglike, log_like, design_grid, parm_grid, data_grid, model_state)
 end
 
+"""
+    loglikelihood(optimizer::Optimizer)
+
+Computes a three dimensional grid of log likelihoods where the first dimension is the model parameters, the second
+dimension is the design parameters, and the third dimension is the data values.
+
+- `loglike`: a model object containing a log likelihood function and prior distributions
+- `parm_grid`: a grid of model parameters
+- `design_grid`: a grid of design parameters
+- `data_grid`: a grid of data values
+- `model_type`: model type can be `Static` or `Dynamic`
+- `model_state`: model state variables that are updated for `Dynamic` models
+"""
 function loglikelihood!(loglike, log_like, design_grid, parm_grid, data_grid, model_state)
     i = 0
     for (d, data) in enumerate(data_grid)
@@ -64,18 +163,48 @@ function loglikelihood!(loglike, log_like, design_grid, parm_grid, data_grid, mo
     return nothing
 end
 
+"""
+    marginal_log_like!(optimizer)
+
+Marginalizes the log likelihoods over model parameters, resulting in a three dimensional array where the first dimension is length 1,
+the second dimension is the design parameters, and the third dimension is the data values.
+
+- `optimizer`: an optimizer object
+"""
 function marginal_log_like!(optimizer)
     @unpack marg_log_like,log_like,log_post = optimizer
     marg_log_like .= marginal_log_like(log_post, log_like)
 end
 
+"""
+    marginal_log_like(optimizer)
+
+Marginalizes the log likelihoods over model parameters, resulting in a three dimensional array where the first dimension is length 1,
+the second dimension is the design parameters, and the third dimension is the data values.
+
+- `log_post`: a vector of posterior log likelihood values for the model parameters
+- `log_like`: a three dimensional vector of log likelihood values where the first dimension corresponds to the model parameters,
+the second dimension corresponds to the design parameters, and the third dimension corresponds to the data values
+"""
 function marginal_log_like(log_post, log_like)
     return logsumexp(log_post .+ log_like, dims=1)
 end
 
-function marginal_posterior(optimizer)
-    @unpack posteriors = optimizer
-    return map(d->sum(posterior, dims=d), ndims(posterior):-1:1)
+# """
+#     marginal_posterior(optimizer)
+
+# Computes a three dimensional grid of log likelihoods where the first dimension is the model parameters, the second
+# dimension is the design parameters, and the third dimension is the data values.
+
+# - `optimizer`: an optimizer object
+# """
+# function marginal_posterior(optimizer)
+#     @unpack posteriors = optimizer
+#     return map(d->sum(posterior, dims=d), ndims(posterior):-1:1)
+# end
+
+function compute_entropy(log_like)
+    return -1*sum(exp.(log_like) .* log_like, dims=3)[:,:]
 end
 
 function conditional_entropy(entropy, post)
@@ -88,10 +217,6 @@ function conditional_entropy!(optimizer)
     cond_entropy .= conditional_entropy(entropy, post)
 end
 
-function compute_entropy(log_like)
-    return -1*sum(exp.(log_like) .* log_like, dims=3)[:,:]
-end
-
 function marginal_entropy!(optimizer::Optimizer)
     @unpack marg_entropy,marg_log_like = optimizer
     marg_entropy .= marginal_entropy(marg_log_like)
@@ -101,10 +226,25 @@ function marginal_entropy(marg_log_like)
     return -sum(exp.(marg_log_like).*marg_log_like, dims=3)[:]
 end
 
+"""
+    mutual_information(optimizer)
+
+Computes a vector of the mutual information values where each element corresponds to a design parameter. 
+
+- `marg_entropy`: a vector of marginal entropy values where each element corresponds to a design parameter
+- `cond_entropy`: a vector of conditional entropy values where each element corresponds to a design parameter
+"""
 function mutual_information(marg_entropy, cond_entropy)
     return marg_entropy .- cond_entropy
 end
 
+"""
+    mutual_information!(optimizer)
+
+Computes a vector of the mutual information values where each element corresponds to a design parameter. 
+
+- `optimizer`: an optimizer object
+"""
 function mutual_information!(optimizer)
     @unpack mutual_info,marg_entropy,cond_entropy = optimizer
     mutual_info .= mutual_information(marg_entropy, cond_entropy)
@@ -249,4 +389,42 @@ end
 
 function create_state(model_type::Stat, T, dims, args...; kwargs...)
     return nothing
-end
+end
+
+# function update(θ1, θ2, p, data)
+#     #like = pdf.(Binomial.(n, x), k)
+#     like = pdf.(Bernoulli.(x), d)
+#     for d in data
+#         θ1 .*= like
+#         θ2 .*= like
+#     end
+
+#     # e1 = θ1'*like
+#     # e2 = θ2'*like
+
+#     # θ1 .= (θ1 .* like)/e1
+#     # θ2 .= (θ2 .* like)/e2
+#     e1 = sum(θ1)
+#     e2 = sum(θ2)
+#     θ1 ./= e1
+#     θ2 ./= e2
+
+#     post_odds = (p * e1) / ((1 - p) * e2)
+#     p = post_odds/(1 + post_odds)
+#     return p, θ1, θ2
+# end
+
+# # function update_model_posterior(ps, es)
+# #     map(i->ps[i]./(sum(ps.*(es./es[i]))),1:length(ps))
+# # end
+
+# using Distributions
+# p = .5
+# x = .001:.001:.999
+# θ1 = pdf.(Beta(10,1), x)
+# θ1 /= sum(θ1)
+
+# θ2 = pdf.(Beta(1,1), x)
+# θ2 /= sum(θ2)
+
+# p, θ1, θ2 = update(θ1, θ2, p, [1])

src/structs.jl

@@ -61,7 +61,7 @@ function Model(args...; prior=nothing, loglike, kwargs...)
 end
 
 """
-*Optimizer*
+    Optimizer(;task, model, grid_design, grid_parms, grid_response)
 
 `Optimizer` constructs a model object for adaptive design optimization
 
@@ -75,13 +75,7 @@ end
 - `log_post`: a one dimensional array of log posterior probabilities for parameters
 - `entropy`: a two dimensional array of entropy values for parameter and design combinations
 - 
-
-Constructor
-
-````julia
-Optimizer(;task, model, grid_design, grid_parms, grid_response)
-````
-# """
+"""
 mutable struct Optimizer{A,MT,M<:Model,T1,T2,T3,T4,T5,T6,T7,T8,T9,
     T10,T11}
     design_type::A

test/runtests.jl

@@ -36,6 +36,40 @@ using SafeTestsets
     @test std_post(randomizer)[1] ≈ std(Beta(α+1,β+2)) atol = 5e-3
 end
 
+@safetestset "Updating Default Prior" begin
+    using Test, Distributions, AdaptiveDesignOptimization
+
+    α = 1
+    β = 1
+    loglike(θ, d, data) = logpdf(Bernoulli(θ), data)
+    model = Model(; loglike)
+
+    parm_list = (
+        θ = range(0, 1, length=200),
+    )
+
+    design_list = (d = [1,2],)
+
+    data_list = (choice=[true, false],)
+
+    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
+
+    update!(randomizer, false)
+    @test mean_post(randomizer)[1] ≈ mean(Beta(α,β+1)) atol = 5e-3
+    @test std_post(randomizer)[1] ≈ std(Beta(α,β+1)) atol = 5e-3
+
+    update!(randomizer, false)
+    @test mean_post(randomizer)[1] ≈ mean(Beta(α,β+2)) atol = 5e-3
+    @test std_post(randomizer)[1] ≈ std(Beta(α,β+2)) atol = 5e-3
+
+    update!(randomizer, true)
+    @test mean_post(randomizer)[1] ≈ mean(Beta(α+1,β+2)) atol = 5e-3
+    @test std_post(randomizer)[1] ≈ std(Beta(α+1,β+2)) atol = 5e-3
+end
 
 @safetestset "Updating Prior Dynamic Model" begin
     using Test, Distributions, AdaptiveDesignOptimization
@@ -77,3 +111,39 @@ end
     @test std_post(randomizer)[1] ≈ std(Beta(α+1,β+2)) atol = 5e-3
 end
 
+
+@safetestset "Dimension Check" begin
+    using Test, Distributions, AdaptiveDesignOptimization
+
+    loglike(μ, σ, data, args...) = logpdf(Normal(μ, σ), data)
+    model = Model(; loglike)
+
+    parm_list = (
+        μ = range(0, 10, length=10),
+        σ = range(1, 5, length=10),
+    )
+
+    design_list = (
+        d = range(1, 5, length=10),
+        z = range(1, 5, length=10),
+        v = range(1, 5, length=10)
+    )
+
+    data_list = (
+        choice=[true, false],
+        v = 1:3    
+    )
+
+    optimizer = Optimizer(;design_list, parm_list, data_list, model)
+
+    @test optimizer.parm_grid |> size == (10,10)
+    @test optimizer.design_grid |> size == (10,10,10)
+    @test optimizer.data_grid |> size == (2,3)
+    @test optimizer.log_like |> size == (100,1000,6)
+    @test optimizer.log_post |> size == (100,)
+    @test optimizer.priors |> size == (10,10)
+    @test optimizer.mutual_info |> size == (1000,)
+    @test optimizer.marg_log_like |> size == (1,1000,6) 
+    @test optimizer.marg_entropy |> size == (1000,)
+    @test optimizer.cond_entropy |> size == (1000,)
+end