Various changes

 * Add pointwise/category information criterion
 * Make a bunch of stuff generic for number
 * Other stuff too

Author: Frankie Robertson

src/aggregators/Aggregators.jl

@@ -10,6 +10,7 @@ using StaticArrays: SVector
 using Distributions: Distribution, Normal, Distributions
 using Base.Threads
 using ForwardDiff: ForwardDiff
+using LogarithmicNumbers: Logarithmic, ULogarithmic
 
 using FittedItemBanks: AbstractItemBank, ContinuousDomain,
                        DichotomousSmoothedItemBank, DiscreteIndexableDomain,
@@ -24,12 +25,14 @@ using PsychometricsBazaarBase.ConfigTools: @requiresome, @returnsome,
                                            find1_type_sloppy
 using PsychometricsBazaarBase.Integrators: Integrators,
                                            BareIntegrationResult,
-                                           FixedGridIntegrator, IntReturnType,
+                                           FixedGridIntegrator,
+                                           IntReturnType,
                                            IntValue, Integrator,
                                            PreallocatedFixedGridIntegrator,
                                            normdenom
 using PsychometricsBazaarBase.Optimizers: OneDimOptimOptimizer, Optimizer
 using PsychometricsBazaarBase.ConstDistributions: std_normal, std_mv_normal
+import Distributions: pdf
 
 import FittedItemBanks
 import PsychometricsBazaarBase.IntegralCoeffs
@@ -38,7 +41,8 @@ export AbilityEstimator, TrackedResponses
 export AbilityTracker, NullAbilityTracker, PointAbilityTracker, GriddedAbilityTracker
 export ClosedFormNormalAbilityTracker, track!
 export response_expectation, expectation, distribution_estimator
-export PointAbilityEstimator, PriorAbilityEstimator, LikelihoodAbilityEstimator
+export PointAbilityEstimator, PriorAbilityEstimator
+export SafeLikelihoodAbilityEstimator, LikelihoodAbilityEstimator
 export ModeAbilityEstimator, MeanAbilityEstimator
 export Speculator, replace_speculation!, normdenom, maybe_tracked_ability_estimate
 export AbilityIntegrator, AbilityOptimizer
@@ -70,6 +74,10 @@ end
 abstract type DistributionAbilityEstimator <: AbilityEstimator end
 function DistributionAbilityEstimator(bits...)
     @returnsome find1_instance(DistributionAbilityEstimator, bits)
+    point_ability_estimator = find1_instance(PointAbilityEstimator, bits)
+    if point_ability_estimator !== nothing
+        return distribution_estimator(point_ability_estimator)
+    end
 end
 
 abstract type PointAbilityEstimator <: AbilityEstimator end

src/aggregators/optimizers.jl

@@ -47,5 +47,6 @@ function (optim::AbilityOptimizer)(f::F,
         est,
         tracked_responses::TrackedResponses;
         kwargs...) where {F}
-    optim(maybe_apply_prior(f, est), AbilityLikelihood(tracked_responses); kwargs...)
+    #optim(maybe_apply_prior(f, est), AbilityLikelihood(tracked_responses); kwargs...)
+    optim(f, pdf(est, tracked_responses); kwargs...)
 end

src/aggregators/riemann.jl

@@ -26,13 +26,32 @@ function (integrator::RiemannEnumerationIntegrator)(f::F,
     return BareIntegrationResult(result)
 end
 
-function (integrator::Union{RiemannEnumerationIntegrator, FunctionIntegrator})(f::F,
-        ncomp,
-        est,
-        tracked_responses::TrackedResponses;
-        kwargs...) where {F}
-    integrator(maybe_apply_prior(f, est),
+function (integrator::RiemannEnumerationIntegrator)(
+    f::F,
+    ncomp,
+    est,
+    tracked_responses::TrackedResponses;
+    kwargs...
+) where {F}
+    integrator(
+        maybe_apply_prior(f, est),
         ncomp,
         AbilityLikelihood(tracked_responses);
-        kwargs...)
+        kwargs...
+    )
+end
+
+function (integrator::FunctionIntegrator)(
+    f::F,
+    ncomp,
+    est,
+    tracked_responses::TrackedResponses;
+    kwargs...
+) where {F}
+    integrator(
+        f,
+        ncomp,
+        pdf(est, tracked_responses);
+        kwargs...
+    )
 end

src/logitembank.jl

@@ -21,18 +21,18 @@ inner_ir(ir::ItemResponse{<:LogItemBank}) = ItemResponse(ir.item_bank.inner, ir.
 ## TODO: Support item banks with other response types e.g. Float32
 
 function FittedItemBanks.resp(ir::ItemResponse{<:LogItemBank}, θ)
-    exp(ULogarithmic{Float64}, FittedItemBanks.log_resp(inner_ir(ir), θ))
+    exp(ULogarithmic, FittedItemBanks.log_resp(inner_ir(ir), θ))
 end
 
 function FittedItemBanks.resp(ir::ItemResponse{<:LogItemBank}, response, θ)
     exp(
-        ULogarithmic{Float64},
+        ULogarithmic,
         FittedItemBanks.log_resp(inner_ir(ir), response, θ)
     )
 end
 
 function FittedItemBanks.resp_vec(ir::ItemResponse{<:LogItemBank}, θ)
-    exp.(ULogarithmic{Float64}, FittedItemBanks.log_resp_vec(inner_ir(ir), θ))
+    exp.(ULogarithmic, FittedItemBanks.log_resp_vec(inner_ir(ir), θ))
 end
 
 @forward LogItemBank.inner Base.length,

src/next_item_rules/NextItemRules.jl

@@ -11,22 +11,22 @@ Springer, New York, NY.
 module NextItemRules
 
 using DocStringExtensions: FUNCTIONNAME, TYPEDEF, TYPEDFIELDS
-using PsychometricsBazaarBase.Parameters: @with_kw
+using PsychometricsBazaarBase.Parameters
 using LinearAlgebra: det, tr
 using Random: AbstractRNG, Xoshiro
 
 using ..Responses: BareResponses
 using ..ConfigBase
 using PsychometricsBazaarBase.ConfigTools: @requiresome, @returnsome,
                                            find1_instance, find1_type
-using PsychometricsBazaarBase.Integrators: Integrator
+using PsychometricsBazaarBase.Integrators: Integrator, intval
 using PsychometricsBazaarBase: Integrators
 import PsychometricsBazaarBase.IntegralCoeffs
 using FittedItemBanks: AbstractItemBank, DiscreteDomain, DomainType,
                        ItemResponse, OneDimContinuousDomain, domdims, item_params,
                        resp, resp_vec, responses
 using ..Aggregators
-using ..Aggregators: covariance_matrix
+using ..Aggregators: covariance_matrix, FunctionProduct
 
 using Distributions: logccdf, logcdf, pdf
 using Base.Threads
@@ -38,13 +38,17 @@ import ForwardDiff
 export ExpectationBasedItemCriterion, AbilityVarianceStateCriterion, init_thread
 export NextItemRule, ItemStrategyNextItemRule
 export UrryItemCriterion, InformationItemCriterion
+export LikelihoodWeightedItemCriterion, PointItemCriterion
+export LikelihoodWeightedItemCategoryCriterion, PointItemCategoryCriterion
+export ObservedInformationPointwiseItemCategoryCriterion
+export RawEmpiricalInformationPointwiseItemCategoryCriterion
+export EmpiricalInformationPointwiseItemCategoryCriterion
+export TotalItemInformation
 export RandomNextItemRule
 export PiecewiseNextItemRule, MemoryNextItemRule, FixedFirstItemNextItemRule
 export ExhaustiveSearch
-export catr_next_item_aliases
 export preallocate
-export compute_criteria, compute_criterion, compute_multi_criterion,
-       compute_pointwise_criterion
+export compute_criteria, compute_criterion, compute_multi_criterion
 export best_item
 export PointResponseExpectation, DistributionResponseExpectation
 export MatrixScalarizer, DeterminantScalarizer, TraceScalarizer
@@ -70,15 +74,15 @@ include("./combinators/scalarizers.jl")
 include("./combinators/likelihood.jl")
 
 # Criteria
-include("./criteria/item/information_special.jl")
-include("./criteria/item/information_support.jl")
 include("./criteria/item/information.jl")
 include("./criteria/item/urry.jl")
 include("./criteria/state/ability_variance.jl")
+include("./criteria/pointwise/information_special.jl")
+include("./criteria/pointwise/information_support.jl")
+include("./criteria/pointwise/information.jl")
 include("./criteria/pointwise/kl.jl")
 
 # Porcelain
 include("./porcelain/porcelain.jl")
-include("./porcelain/aliases.jl")
 
 end

src/next_item_rules/combinators/expectation.jl

@@ -67,15 +67,16 @@ item 1-ply ahead.
 """
 struct ExpectationBasedItemCriterion{
     ResponseExpectationT <: ResponseExpectation,
-    CriterionT <: Union{StateCriterion, ItemCriterion}
+    CriterionT <: Union{StateCriterion, ItemCriterion, ItemCategoryCriterion},
 } <: ItemCriterion
     response_expectation::ResponseExpectationT
     criterion::CriterionT
 end
 
 function _get_some_criterion(bits...; kwargs...)
     @returnsome StateCriterion(bits...; kwargs...)
-    @returnsome ItemCriterion(bits...; kwargs...)
+    @returnsome ItemCriterion(bits...; skip_expectation=true, kwargs...)
+    @returnsome ItemCategoryCriterion(bits...)
 end
 
 function ExpectationBasedItemCriterion(bits...;
@@ -95,13 +96,16 @@ function init_thread(::ExpectationBasedItemCriterion, responses::TrackedResponse
     Speculator(responses, 1)
 end
 
-function _generic_criterion(criterion::StateCriterion, tracked_responses, item_idx)
+function _generic_criterion(criterion::StateCriterion, tracked_responses, _item_idx, _response)
     compute_criterion(criterion, tracked_responses)
 end
 # TODO: Support init_thread for wrapped ItemCriterion
-function _generic_criterion(criterion::ItemCriterion, tracked_responses, item_idx)
+function _generic_criterion(criterion::ItemCriterion, tracked_responses, item_idx, _response)
     compute_criterion(criterion, tracked_responses, item_idx)
 end
+function _generic_criterion(criterion::ItemCategoryCriterion, tracked_responses, item_idx, response)
+    compute_criterion(criterion, tracked_responses, item_idx, response)
+end
 
 function compute_criterion(
         item_criterion::ExpectationBasedItemCriterion,
@@ -116,7 +120,7 @@ function compute_criterion(
     for (prob, possible_response) in zip(exp_resp, possible_responses)
         replace_speculation!(speculator, SVector(item_idx), SVector(possible_response))
         res += prob *
-               _generic_criterion(item_criterion.criterion, speculator.responses, item_idx)
+               _generic_criterion(item_criterion.criterion, speculator.responses, item_idx, possible_response)
     end
     res
 end

src/next_item_rules/combinators/likelihood.jl

@@ -8,12 +8,90 @@ struct LikelihoodWeightedItemCriterion{
     estimator::AbilityEstimatorT
 end
 
+function LikelihoodWeightedItemCriterion(bits...)
+    @requiresome dist_est_integrator_pair = get_dist_est_and_integrator(bits...)
+    (dist_est, integrator) = dist_est_integrator_pair
+    criterion = PointwiseItemCriterion(bits...)
+    return LikelihoodWeightedItemCriterion(criterion, integrator, dist_est)
+end
+
 function compute_criterion(
-        lwic::LikelihoodWeightedItemCriterion,
-        tracked_responses::TrackedResponses,
-        item_idx
+    lwic::LikelihoodWeightedItemCriterion,
+    tracked_responses::TrackedResponses,
+    item_idx
 )
     func = FunctionProduct(
-        pdf(lwic.estimator, tracked_responses), lwic.criterion(tracked_responses, item_idx))
-    lwic.integrator(func, 0, lwic.estimator, tracked_responses)
+        pdf(lwic.estimator, tracked_responses), ability -> compute_criterion(lwic.criterion, tracked_responses, item_idx, ability))
+    intval(lwic.integrator(func, 0, lwic.estimator, tracked_responses))
+end
+
+struct PointItemCriterion{
+    PointwiseItemCriterionT <: PointwiseItemCriterion,
+    AbilityEstimatorT <: PointAbilityEstimator
+} <: ItemCriterion
+    criterion::PointwiseItemCriterionT
+    estimator::AbilityEstimatorT
 end
+
+function compute_criterion(
+    pic::PointItemCriterion,
+    tracked_responses::TrackedResponses,
+    item_idx
+)
+    ability = maybe_tracked_ability_estimate(
+        tracked_responses,
+        pic.estimator
+    )
+    return compute_criterion(pic.criterion, tracked_responses, item_idx, ability)
+end
+
+struct LikelihoodWeightedItemCategoryCriterion{
+    PointwiseItemCategoryCriterionT <: PointwiseItemCategoryCriterion,
+    AbilityIntegratorT <: AbilityIntegrator,
+    AbilityEstimatorT <: DistributionAbilityEstimator
+} <: ItemCategoryCriterion
+    criterion::PointwiseItemCategoryCriterionT
+    integrator::AbilityIntegratorT
+    estimator::AbilityEstimatorT
+end
+
+function LikelihoodWeightedItemCategoryCriterion(bits...)
+    @requiresome dist_est_integrator_pair = get_dist_est_and_integrator(bits...)
+    (dist_est, integrator) = dist_est_integrator_pair
+    criterion = PointwiseItemCategoryCriterion(bits...)
+    return LikelihoodWeightedItemCategoryCriterion(criterion, integrator, dist_est)
+end
+
+function compute_criterion(
+    lwicc::LikelihoodWeightedItemCategoryCriterion,
+    tracked_responses::TrackedResponses,
+    item_idx,
+    category
+)
+    func = FunctionProduct(
+        pdf(lwicc.estimator, tracked_responses),
+        ability -> compute_criterion(lwicc.criterion, tracked_responses, item_idx, ability, category)
+    )
+    intval(lwicc.integrator(func, 0, lwicc.estimator, tracked_responses))
+end
+
+struct PointItemCategoryCriterion{
+    PointwiseItemCategoryCriterionT <: PointwiseItemCategoryCriterion,
+    AbilityEstimatorT <: PointAbilityEstimator
+} <: ItemCategoryCriterion
+    criterion::PointwiseItemCategoryCriterionT
+    estimator::AbilityEstimatorT
+end
+
+function compute_criterion(
+    pic::PointItemCategoryCriterion,
+    tracked_responses::TrackedResponses,
+    item_idx,
+    category
+)
+    ability = maybe_tracked_ability_estimate(
+        tracked_responses,
+        pic.estimator
+    )
+    return compute_criterion(pic.criterion, tracked_responses, item_idx, ability, category)
+end

src/next_item_rules/criteria/item/information.jl

@@ -1,12 +1,20 @@
 # TODO: Should have Variants for point ability versus distribution ability
-struct InformationItemCriterion{AbilityEstimatorT <: PointAbilityEstimator, F} <:
+@kw_only struct InformationItemCriterion{AbilityEstimatorT <: PointAbilityEstimator, F} <:
        ItemCriterion
     ability_estimator::AbilityEstimatorT
     expected_item_information::F
 end
 
-function InformationItemCriterion(ability_estimator)
-    InformationItemCriterion(ability_estimator, expected_item_information)
+function InformationItemCriterion(ability_estimator::PointAbilityEstimator)
+    InformationItemCriterion(;
+        ability_estimator,
+        expected_item_information
+    )
+end
+
+function InformationItemCriterion(bits...)
+    @requiresome ability_estimator = PointAbilityEstimator(bits...)
+    InformationItemCriterion(ability_estimator)
 end
 
 function compute_criterion(

src/next_item_rules/criteria/item/urry.jl

@@ -9,6 +9,11 @@ struct UrryItemCriterion{AbilityEstimatorT <: PointAbilityEstimator} <: ItemCrit
     ability_estimator::AbilityEstimatorT
 end
 
+function UrryItemCriterion(bits...)
+    @requiresome ability_estimator = PointAbilityEstimator(bits...)
+    UrryItemCriterion(ability_estimator)
+end
+
 # TODO: Slow + poor error handling
 function raw_difficulty(item_bank, item_idx)
     item_params(item_bank, item_idx).difficulty