Add GreedyForcedContentBalancer and PointwiseNextItemRule

Author: Frankie Robertson

Project.toml

@@ -48,7 +48,7 @@ Distributions = "^0.25.88"
 DocStringExtensions = " ^0.9"
 EffectSizes = "^1.0.1"
 FillArrays = "0.13, 1.5.0"
-FittedItemBanks = "^0.6.3, ^0.7.0"
+FittedItemBanks = "^0.7.2"
 ForwardDiff = "1"
 HypothesisTests = "^0.10.12, ^0.11.0"
 Interpolations = "^0.14, ^0.15"

src/next_item_rules/NextItemRules.jl

@@ -21,10 +21,11 @@ using PsychometricsBazaarBase.ConfigTools: @requiresome, @returnsome,
                                            find1_instance, find1_type
 using PsychometricsBazaarBase.Integrators: Integrator, intval
 using PsychometricsBazaarBase: Integrators
+using PsychometricsBazaarBase.IndentWrappers: indent
 import PsychometricsBazaarBase.IntegralCoeffs
 using FittedItemBanks: AbstractItemBank, DiscreteDomain, DomainType,
                        ItemResponse, OneDimContinuousDomain, domdims, item_params,
-                       resp, resp_vec, responses
+                       resp, resp_vec, responses, subset_view
 using ..Aggregators
 using ..Aggregators: covariance_matrix, FunctionProduct
 
@@ -34,6 +35,7 @@ using Base.Order
 using StaticArrays: SVector
 using ConstructionBase: constructorof
 import ForwardDiff
+import Base: show
 
 export ExpectationBasedItemCriterion, AbilityVarianceStateCriterion, init_thread
 export NextItemRule, ItemStrategyNextItemRule
@@ -46,7 +48,7 @@ export EmpiricalInformationPointwiseItemCategoryCriterion
 export TotalItemInformation
 export RandomNextItemRule
 export PiecewiseNextItemRule, MemoryNextItemRule, FixedFirstItemNextItemRule
-export ExhaustiveSearch
+export ExhaustiveSearch, RandomesqueStrategy
 export preallocate
 export compute_criteria, compute_criterion, compute_multi_criterion
 export best_item
@@ -68,6 +70,8 @@ include("./strategies/random.jl")
 include("./strategies/randomesque.jl")
 include("./strategies/sequential.jl")
 include("./strategies/exhaustive.jl")
+include("./strategies/pointwise.jl")
+include("./strategies/balance.jl")
 
 # Combinators
 include("./combinators/expectation.jl")

src/next_item_rules/prelude/next_item_rule.jl

@@ -53,6 +53,13 @@ function best_item(rule::NextItemRule, tracked_responses::TrackedResponses)
     best_item(rule, tracked_responses, tracked_responses.item_bank)
 end
 
+function Base.show(io::IO, ::MIME"text/plain", next_item_rule::ItemStrategyNextItemRule)
+    println(io, "Strategy:")
+    show(indent_io, MIME"text/plain"(), rules.strategy)
+    println(io, "Item criterion:")
+    show(indent_io, MIME"text/plain"(), rules.criterion)
+end
+
 # Default implementation
 function compute_criteria(::NextItemRule, ::TrackedResponses)
     nothing

src/next_item_rules/strategies/balance.jl

@@ -0,0 +1,90 @@
+"""
+$(TYPEDEF)
+$(TYPEDFIELDS)
+
+This content balancing procedure takes target proportions for each group of items.
+At each step the group with the lowest ratio of seen items to target is selected.
+
+http://dx.doi.org/10.1207/s15324818ame0403_4
+"""
+struct GreedyForcedContentBalancer{InnerRuleT <: NextItemRule} <: NextItemRule
+    targets::Vector{Float64}
+    groups::Vector{Int}
+    inner_rule::InnerRuleT
+end
+
+function GreedyForcedContentBalancer(targets::Dict, groups, bits...)
+    targets_vec = zeros(Float64, length(targets))
+    groups_idxs = zeros(Int, length(groups))
+    group_lookup = Dict{Any, Int}()
+    for (idx, group) in enumerate(groups)
+        if haskey(group_lookup, group)
+            group_idx = group_lookup[group]
+        else
+            group_idx = length(group_lookup) + 1
+            group_lookup[group] = group_idx
+        end
+        groups_idxs[idx] = group_idx
+    end
+    if length(group_lookup) != length(targets)
+        error("Number of groups $(length(group_lookup)) does not match number of targets $(length(targets))")
+    end
+    for (group, group_idx) in pairs(group_lookup)
+        targets_vec[group_idx] = get(targets, group, 0.0)
+    end
+    GreedyForcedContentBalancer(targets_vec, groups_idxs, bits...)
+end
+
+function GreedyForcedContentBalancer(targets::AbstractVector, groups, bits...)
+    GreedyForcedContentBalancer(targets, groups, NextItemRule(bits...))
+end
+
+function show(io::IO, ::MIME"text/plain", rule::GreedyForcedContentBalancer)
+    indent_io = indent(io, 2)
+    println(io, "Greedy + forced content balancer")
+    println(indent_io, "Target ratio: " * join(rule.targets, ", "))
+    print(indent_io, "Using rule: ")
+    show(indent_io, MIME("text/plain"), rule.inner_rule)
+end
+
+function next_item_bank(targets, groups, responses, items)
+    seen = zeros(UInt, size(targets))
+    indices = responses.responses.indices
+    for group_idx in groups[indices]
+        seen[group_idx] += 1
+    end
+    next_group_idx = argmin(seen ./ targets)
+    matching_indicator = groups .== next_group_idx
+    next_items = subset_view(items, matching_indicator)
+    return (next_items, matching_indicator)
+end
+
+function best_item(
+    rule::GreedyForcedContentBalancer,
+    responses::TrackedResponses,
+    items
+)
+    next_items, matching_indicator = next_item_bank(rule.targets, rule.groups, responses, items)
+    inner_idx = best_item(rule.inner_rule, responses, next_items)
+    for (outer_idx, in_group) in enumerate(matching_indicator)
+        if in_group
+            inner_idx -= 1
+            if inner_idx <= 0
+                return outer_idx
+            end
+        end
+    end
+    error("No item found in group length $(length(next_items)) with inner index $inner_idx")
+end
+
+function compute_criteria(
+    rule::GreedyForcedContentBalancer,
+    responses::TrackedResponses,
+    items
+)
+    next_items, matching_indicator = next_item_bank(rule.targets, rule.groups, responses, items)
+    criteria = compute_criteria(rule.inner_rule, responses, next_items)
+    expanded = fill(Inf, length(items))
+    expanded[matching_indicator] .= criteria
+    return expanded
+end

src/next_item_rules/strategies/exhaustive.jl

@@ -1,21 +1,18 @@
-function exhaustive_search(objective::ItemCriterionT,
-        responses::TrackedResponseT,
-        items::AbstractItemBank)::Tuple{
-        Int,
-        Float64
-} where {ItemCriterionT <: ItemCriterion, TrackedResponseT <: TrackedResponses}
-    #pre_next_item(expectation_tracker, items)
-    objective_state = init_thread(objective, responses)
+function exhaustive_search(
+        callback,
+        answered_items::AbstractVector{Int},
+        items::AbstractItemBank
+)::Tuple{Int, Float64}
     min_obj_idx::Int = -1
     min_obj_val::Float64 = Inf
     for item_idx in eachindex(items)
         # TODO: Add these back in
         #@init irf_states_storage = zeros(Int, length(responses) + 1)
-        if (findfirst(idx -> idx == item_idx, responses.responses.indices) !== nothing)
+        if (findfirst(idx -> idx == item_idx, answered_items) !== nothing)
             continue
         end
 
-        obj_val = compute_criterion(objective, objective_state, responses, item_idx)
+        obj_val = callback(item_idx)
 
         if obj_val <= min_obj_val
             min_obj_val = obj_val
@@ -25,6 +22,18 @@ function exhaustive_search(objective::ItemCriterionT,
     return (min_obj_idx, min_obj_val)
 end
 
+function exhaustive_search(objective::ItemCriterionT,
+        responses::TrackedResponseT,
+        items::AbstractItemBank)::Tuple{
+        Int,
+        Float64
+} where {ItemCriterionT <: ItemCriterion, TrackedResponseT <: TrackedResponses}
+    objective_state = init_thread(objective, responses)
+    return exhaustive_search(responses.responses.indices, items) do item_idx
+        return compute_criterion(objective, objective_state, responses, item_idx)
+    end
+end
+
 """
 $(TYPEDEF)
 $(TYPEDFIELDS)

src/next_item_rules/strategies/pointwise.jl

@@ -0,0 +1,21 @@
+struct PointwiseNextItemRule{CriterionT <: PointwiseItemCriterion, PointsT <: AbstractArray{<:Number}} <: NextItemRule
+    criterion::CriterionT
+    points::PointsT
+end
+
+function best_item(rule::PointwiseNextItemRule, responses::TrackedResponses, items)
+    num_responses = length(responses.responses.indices)
+    next_index = num_responses + 1
+    if next_index > length(rule.points)
+        error("Number of responses exceeds the number of points defined in the rule.")
+    end
+    current_point = rule.points[next_index]
+    idx, _ = exhaustive_search(responses.responses.indices, items) do item_idx
+        return compute_criterion(rule.criterion, ItemResponse(items, item_idx), current_point)
+    end
+    return idx
+end
+
+function PointwiseFirstNextItemRule(criterion, points, rule)
+    PiecewiseNextItemRule((length(points),), (PointwiseNextItemRule(criterion, points), rule))
+end

src/next_item_rules/strategies/sequential.jl

@@ -6,10 +6,10 @@ This is the most basic rule for choosing the next item in a CAT. It simply
 picks a random item from the set of items that have not yet been
 administered.
 """
-@kwdef struct PiecewiseNextItemRule{BreaksT, RulesT} <: NextItemRule
+@kwdef struct PiecewiseNextItemRule{RulesT} <: NextItemRule
     # Tuple of Ints
-    breaks::BreaksT
-    # Types of NextItemRules
+    breaks::Tuple{Int}
+    # Tuple of NextItemRules
     rules::RulesT
 end