n_man() -> nobserved_vars()

alyst · alyst · commit 4c153289b297 · 2024-06-16T17:09:23.000-07:00
for missing data pattern: nobserved_vars() -&gt; nmeasured_vars(),
obs_cov/obs_mean -&gt; measured_cov/measured_mean
diff --git a/src/StructuralEquationModels.jl b/src/StructuralEquationModels.jl
@@ -82,7 +82,6 @@ include("frontend/fit/fitmeasures/df.jl")
 include("frontend/fit/fitmeasures/minus2ll.jl")
 include("frontend/fit/fitmeasures/p.jl")
 include("frontend/fit/fitmeasures/RMSEA.jl")
-include("frontend/fit/fitmeasures/n_man.jl")
 include("frontend/fit/fitmeasures/fit_measures.jl")
 # standard errors
 include("frontend/fit/standard_errors/hessian.jl")
@@ -169,7 +168,6 @@ export AbstractSem,
     nsamples,
     p_value,
     RMSEA,
-    n_man,
     EmMVNModel,
     se_hessian,
     se_bootstrap,
diff --git a/src/frontend/fit/fitmeasures/chi2.jl b/src/frontend/fit/fitmeasures/chi2.jl
@@ -15,7 +15,7 @@ Return the χ² value.
 # RAM + SemML
 χ²(lossfun::SemML, fit::SemFit, model::AbstractSemSingle) =
     (nsamples(fit) - 1) *
-    (fit.minimum - logdet(obs_cov(observed(model))) - n_man(observed(model)))
+    (fit.minimum - logdet(obs_cov(observed(model))) - nobserved_vars(observed(model)))
 
 # bollen, p. 115, only correct for GLS weight matrix
 χ²(lossfun::SemWLS, fit::SemFit, model::AbstractSemSingle) = (nsamples(fit) - 1) * fit.minimum
@@ -57,7 +57,7 @@ end
 function χ²(lossfun::SemML, fit::SemFit, models::SemEnsemble)
     G = sum(zip(models.weights, models.sems)) do (w, model)
         data = observed(model)
-        w * (logdet(obs_cov(data)) + n_man(data))
+        w * (logdet(obs_cov(data)) + nobserved_vars(data))
     end
     return (nsamples(models) - 1) * (fit.minimum - G)
 end
diff --git a/src/frontend/fit/fitmeasures/df.jl b/src/frontend/fit/fitmeasures/df.jl
@@ -11,10 +11,10 @@ df(sem_fit::SemFit) = df(sem_fit.model)
 df(model::AbstractSem) = n_dp(model) - nparams(model)
 
 function n_dp(model::AbstractSemSingle)
-    nman = n_man(model)
-    ndp = 0.5(nman^2 + nman)
+    nvars = nobserved_vars(model)
+    ndp = 0.5(nvars^2 + nvars)
     if !isnothing(model.imply.μ)
-        ndp += n_man(model)
+        ndp += nvars
     end
     return ndp
 end
diff --git a/src/frontend/fit/fitmeasures/minus2ll.jl b/src/frontend/fit/fitmeasures/minus2ll.jl
@@ -22,7 +22,7 @@ minus2ll(minimum::Number, model::AbstractSemSingle) =
 # SemML ------------------------------------------------------------------------------------
 function minus2ll(lossfun::SemML, minimum::Number, model::AbstractSemSingle)
     obs = observed(model)
-    return nsamples(obs) * (minimum + log(2π) * n_man(obs))
+    return nsamples(obs) * (minimum + log(2π) * nobserved_vars(obs))
 end
 
 # WLS --------------------------------------------------------------------------------------
@@ -33,7 +33,7 @@ minus2ll(lossfun::SemWLS, minimum::Number, model::AbstractSemSingle) = missing
 function minus2ll(lossfun::SemFIML, minimum::Number, model::AbstractSemSingle)
     obs = observed(model)::SemObservedMissing
     F = minimum * nsamples(obs)
-    F += log(2π) * sum(pat -> nsamples(pat) * nobserved_vars(pat), obs.patterns)
+    F += log(2π) * sum(pat -> nsamples(pat) * nmeasured_vars(pat), obs.patterns)
     return F
 end
 
@@ -46,17 +46,17 @@ function minus2ll(observed::SemObservedMissing)
     for pat in observed.patterns
         nᵢ = nsamples(pat)
         # implied covariance/mean
-        Σᵢ = Symmetric(Σ[pat.obs_mask, pat.obs_mask])
+        Σᵢ = Symmetric(Σ[pat.measured_mask, pat.measured_mask])
 
         ld = logdet(Σᵢ)
         Σᵢ⁻¹ = LinearAlgebra.inv!(cholesky!(Σᵢ))
-        μ_diffᵢ = pat.obs_mean - μ[pat.obs_mask]
+        μ_diffᵢ = pat.measured_mean - μ[pat.measured_mask]
 
         F_pat = ld + dot(μ_diffᵢ, Σᵢ⁻¹, μ_diffᵢ)
         if nsamples(pat) > 1
-            F_pat += dot(pat.obs_cov, Σᵢ⁻¹)
+            F_pat += dot(pat.measured_cov, Σᵢ⁻¹)
         end
-        F += (F_pat + log(2π) * nobserved_vars(pat)) * nsamples(pat)
+        F += (F_pat + log(2π) * nmeasured_vars(pat)) * nsamples(pat)
     end
 
     #F *= nsamples(observed)
diff --git a/src/frontend/fit/fitmeasures/n_man.jl b/src/frontend/fit/fitmeasures/n_man.jl
diff --git a/src/frontend/predict.jl b/src/frontend/predict.jl
@@ -84,9 +84,9 @@ function predict_latent_scores(
     params::AbstractVector,
     data::SemObserved,
 )
-    n_man(data) == nobserved_vars(model) || throw(
+    nobserved_vars(data) == nobserved_vars(model) || throw(
         DimensionMismatch(
-            "Number of variables in data ($(n_man(data))) does not match the number of observed variables in the model ($(nobserved_vars(model)))",
+            "Number of variables in data ($(nobserved_vars(data))) does not match the number of observed variables in the model ($(nobserved_vars(model)))",
         ),
     )
     length(params) == nparams(model) || throw(
diff --git a/src/imply/RAM/generic.jl b/src/imply/RAM/generic.jl
@@ -203,7 +203,7 @@ end
 ############################################################################################
 
 function update_observed(imply::RAM, observed::SemObserved; kwargs...)
-    if n_man(observed) == size(imply.Σ, 1)
+    if nobserved_vars(observed) == size(imply.Σ, 1)
         return imply
     else
         return RAM(; observed = observed, kwargs...)
diff --git a/src/imply/RAM/symbolic.jl b/src/imply/RAM/symbolic.jl
@@ -221,7 +221,7 @@ end
 ############################################################################################
 
 function update_observed(imply::RAMSymbolic, observed::SemObserved; kwargs...)
-    if n_man(observed) == size(imply.Σ, 1)
+    if nobserved_vars(observed) == size(imply.Σ, 1)
         return imply
     else
         return RAMSymbolic(; observed = observed, kwargs...)
diff --git a/src/loss/ML/FIML.jl b/src/loss/ML/FIML.jl
@@ -12,25 +12,25 @@ end
 
 # allocate arrays for pattern FIML
 function SemFIMLPattern(pat::SemObservedMissingPattern)
-    nobserved = nobserved_vars(pat)
+    nmes = nmeasured_vars(pat)
     nmissed = nmissed_vars(pat)
 
     # linear indicies of co-observed variable pairs for each pattern
-    Σ_linind = LinearIndices((n_man(pat), n_man(pat)))
+    Σ_linind = LinearIndices((nobserved_vars(pat), nobserved_vars(pat)))
     ∇ind = vec([
-        Σ_linind[CartesianIndex(x, y)] for x in findall(pat.obs_mask),
-        y in findall(pat.obs_mask)
+        Σ_linind[CartesianIndex(x, y)] for x in findall(pat.measured_mask),
+        y in findall(pat.measured_mask)
     ])
 
-    return SemFIMLPattern(∇ind, zeros(nobserved, nobserved), Ref(NaN), zeros(nobserved))
+    return SemFIMLPattern(∇ind, zeros(nmes, nmes), Ref(NaN), zeros(nmes))
 end
 
 function prepare!(fiml::SemFIMLPattern, pat::SemObservedMissingPattern, implied::SemImply)
     Σ = implied.Σ
     μ = implied.μ
     @inbounds @. @views begin
-        fiml.Σ⁻¹ = Σ[pat.obs_mask, pat.obs_mask]
-        fiml.μ_diff = pat.obs_mean - μ[pat.obs_mask]
+        fiml.Σ⁻¹ = Σ[pat.measured_mask, pat.measured_mask]
+        fiml.μ_diff = pat.measured_mean - μ[pat.measured_mask]
     end
     Σ_chol = cholesky!(Symmetric(fiml.Σ⁻¹))
     fiml.logdet[] = logdet(Σ_chol)
@@ -42,7 +42,7 @@ end
 function objective(fiml::SemFIMLPattern{T}, pat::SemObservedMissingPattern) where {T}
     F = fiml.logdet[] + dot(fiml.μ_diff, fiml.Σ⁻¹, fiml.μ_diff)
     if nsamples(pat) > 1
-        F += dot(pat.obs_cov, fiml.Σ⁻¹)
+        F += dot(pat.measured_cov, fiml.Σ⁻¹)
         F *= nsamples(pat)
     end
     return F
@@ -52,15 +52,15 @@ function gradient!(JΣ, Jμ, fiml::SemFIMLPattern, pat::SemObservedMissingPatter
     Σ⁻¹ = Symmetric(fiml.Σ⁻¹)
     μ_diff⨉Σ⁻¹ = fiml.μ_diff' * Σ⁻¹
     if nsamples(pat) > 1
-        JΣ_pat = Σ⁻¹ * (I - pat.obs_cov * Σ⁻¹ - fiml.μ_diff * μ_diff⨉Σ⁻¹)
+        JΣ_pat = Σ⁻¹ * (I - pat.measured_cov * Σ⁻¹ - fiml.μ_diff * μ_diff⨉Σ⁻¹)
         JΣ_pat .*= nsamples(pat)
     else
         JΣ_pat = Σ⁻¹ * (I - fiml.μ_diff * μ_diff⨉Σ⁻¹)
     end
     @inbounds vec(JΣ)[fiml.∇ind] .+= vec(JΣ_pat)
 
     lmul!(2 * nsamples(pat), μ_diff⨉Σ⁻¹)
-    @inbounds Jμ[pat.obs_mask] .+= μ_diff⨉Σ⁻¹'
+    @inbounds Jμ[pat.measured_mask] .+= μ_diff⨉Σ⁻¹'
     return nothing
 end
 
@@ -104,7 +104,7 @@ end
 function SemFIML(; observed::SemObservedMissing, specification, kwargs...)
     return SemFIML(
         [SemFIMLPattern(pat) for pat in observed.patterns],
-        zeros(n_man(observed), n_man(observed)),
+        zeros(nobserved_vars(observed), nobserved_vars(observed)),
         CommutationMatrix(nvars(specification)),
         nothing,
     )
@@ -186,8 +186,8 @@ function F_FIML(
 end
 
 function ∇F_FIML!(G, fiml::SemFIML, observed::SemObservedMissing, model::AbstractSemSingle)
-    Jμ = zeros(n_man(model))
-    JΣ = zeros(n_man(model)^2)
+    Jμ = zeros(nobserved_vars(model))
+    JΣ = zeros(nobserved_vars(model)^2)
 
     for (pat_fiml, pat) in zip(fiml.patterns, observed.patterns)
         gradient!(JΣ, Jμ, pat_fiml, pat)
diff --git a/src/loss/WLS/WLS.jl b/src/loss/WLS/WLS.jl
@@ -59,7 +59,7 @@ function SemWLS(;
     meanstructure = false,
     kwargs...,
 )
-    n_obs = n_man(observed)
+    n_obs = nobserved_vars(observed)
     tril_ind = filter(x -> (x[1] >= x[2]), CartesianIndices(obs_cov(observed)))
     s = obs_cov(observed)[tril_ind]
 
diff --git a/src/observed/EM.jl b/src/observed/EM.jl
@@ -31,11 +31,11 @@ function em_mvn(
     max_nobs_em::Union{Integer, Nothing} = nothing,
     kwargs...,
 )
-    n_man = SEM.n_man(patterns[1])
+    nvars = SEM.nobserved_vars(patterns[1])
 
     # precompute for full cases
-    𝔼x_full = zeros(n_man)
-    𝔼xxᵀ_full = zeros(n_man, n_man)
+    𝔼x_full = zeros(nvars)
+    𝔼xxᵀ_full = zeros(nvars, nvars)
     nobs_full = 0
     for pat in patterns
         if nmissed_vars(pat) == 0
@@ -115,7 +115,7 @@ function em_step!(
 
         # observed and unobserved vars
         u = pat.miss_mask
-        o = pat.obs_mask
+        o = pat.measured_mask
 
         # compute cholesky to speed-up ldiv!()
         Σ₀oo_chol = cholesky(Symmetric(Σ₀[o, o]))
@@ -203,8 +203,8 @@ end
 function start_em_observed(patterns::AbstractVector{<:SemObservedMissingPattern}; kwargs...)
     fullpat = patterns[1]
     if (nmissed_vars(fullpat) == 0) && (nsamples(fullpat) > 1)
-        μ = copy(fullpat.obs_mean)
-        Σ = copy(parent(fullpat.obs_cov))
+        μ = copy(fullpat.measured_mean)
+        Σ = copy(parent(fullpat.measured_cov))
         if !isposdef(Σ)
             Σ = Diagonal(Σ)
         end
@@ -216,11 +216,11 @@ end
 
 # use μ = O and Σ = I
 function start_em_simple(patterns::AbstractVector{<:SemObservedMissingPattern}; kwargs...)
-    nvars = n_man(first(patterns))
+    nvars = nobserved_vars(first(patterns))
     μ = zeros(nvars)
     Σ = rand(nvars, nvars)
     Σ = Σ * Σ'
-    # Σ = Matrix(1.0I, n_man, n_man)
+    # Σ = Matrix(1.0I, nvars, nvars)
     return Σ, μ
 end
 
diff --git a/src/observed/data.jl b/src/observed/data.jl
@@ -19,7 +19,7 @@ For observed data without missings.
 # Extended help
 ## Interfaces
 - `nsamples(::SemObservedData)` -> number of observed data points
-- `n_man(::SemObservedData)` -> number of manifest variables
+- `nobserved_vars(::SemObservedData)` -> number of observed (manifested) variables
 
 - `get_data(::SemObservedData)` -> observed data
 - `obs_cov(::SemObservedData)` -> observed.obs_cov
@@ -41,7 +41,7 @@ struct SemObservedData{A, B, C} <: SemObserved
     data::A
     obs_cov::B
     obs_mean::C
-    n_man::Int
+    nobs_vars::Int
     nsamples::Int
 end
 
@@ -113,7 +113,7 @@ end
 ############################################################################################
 
 nsamples(observed::SemObservedData) = observed.nsamples
-n_man(observed::SemObservedData) = observed.n_man
+nobserved_vars(observed::SemObservedData) = observed.nobs_vars
 
 ############################################################################################
 ### additional methods
diff --git a/src/observed/missing.jl b/src/observed/missing.jl
@@ -21,7 +21,7 @@ For observed data with missing values.
 # Extended help
 ## Interfaces
 - `nsamples(::SemObservedMissing)` -> number of observed data points
-- `n_man(::SemObservedMissing)` -> number of manifest variables
+- `nobserved_vars(::SemObservedMissing)` -> number of manifest variables
 
 - `get_data(::SemObservedMissing)` -> observed data
 - `em_model(::SemObservedMissing)` -> `EmMVNModel` that contains the covariance matrix and mean vector found via expectation maximization
@@ -40,7 +40,7 @@ use this if you are sure your observed data is in the right format.
 struct SemObservedMissing{A <: AbstractMatrix, P <: SemObservedMissingPattern, T <: Real} <:
        SemObserved
     data::A
-    n_man::Int
+    nobs_vars::Int
     nsamples::Int
     patterns::Vector{P}
 
@@ -98,7 +98,7 @@ function SemObservedMissing(;
         data = Matrix(data)
     end
 
-    nsamples, n_man = size(data)
+    nsamples, nobs_vars = size(data)
 
     # detect all different missing patterns with their row indices
     pattern_to_rows = Dict{BitVector, Vector{Int}}()
@@ -117,11 +117,11 @@ function SemObservedMissing(;
 
     em_cov, em_mean = em_mvn(patterns; kwargs...)
 
-    return SemObservedMissing(data, n_man, nsamples, patterns, em_cov, em_mean)
+    return SemObservedMissing(data, nobs_vars, nsamples, patterns, em_cov, em_mean)
 end
 
 nsamples(observed::SemObservedMissing) = observed.nsamples
-n_man(observed::SemObservedMissing) = observed.n_man
+nobserved_vars(observed::SemObservedMissing) = observed.nobs_vars
 
 obs_cov(observed::SemObservedMissing) = observed.obs_cov
 obs_mean(observed::SemObservedMissing) = observed.obs_mean
diff --git a/src/observed/missing_pattern.jl b/src/observed/missing_pattern.jl
@@ -1,24 +1,22 @@
 # data associated with the specific pattern of missing manifested variables
 struct SemObservedMissingPattern{T, S}
-    obs_mask::BitVector     # observed vars mask
+    measured_mask::BitVector     # measured vars mask
     miss_mask::BitVector    # missing vars mask
-    nobserved::Int
-    nmissed::Int
     rows::Vector{Int}       # rows in original data
     data::Matrix{T}         # non-missing submatrix of data (vars × observations)
 
-    obs_mean::Vector{S} # means of observed vars
-    obs_cov::Symmetric{S, Matrix{S}}  # covariance of observed vars
+    measured_mean::Vector{S}     # means of measured vars
+    measured_cov::Symmetric{S, Matrix{S}}  # covariance of measured vars
 end
 
 function SemObservedMissingPattern(
-    obs_mask::BitVector,
+    measured_mask::BitVector,
     rows::AbstractVector{<:Integer},
     data::AbstractMatrix,
 )
     T = nonmissingtype(eltype(data))
 
-    pat_data = convert(Matrix{T}, view(data, rows, obs_mask))
+    pat_data = convert(Matrix{T}, view(data, rows, measured_mask))
     if size(pat_data, 1) > 1
         pat_mean, pat_cov = mean_and_cov(pat_data, 1, corrected = false)
         @assert size(pat_cov) == (size(pat_data, 2), size(pat_data, 2))
@@ -27,22 +25,20 @@ function SemObservedMissingPattern(
         pat_cov = fill(zero(T), 1, 1)
     end
 
-    miss_mask = .!obs_mask
+    miss_mask = .!measured_mask
 
     return SemObservedMissingPattern{T, eltype(pat_mean)}(
-        obs_mask,
+        measured_mask,
         miss_mask,
-        sum(obs_mask),
-        sum(miss_mask),
         rows,
         permutedims(pat_data),
         dropdims(pat_mean, dims = 1),
         Symmetric(pat_cov),
     )
 end
 
-n_man(pat::SemObservedMissingPattern) = length(pat.obs_mask)
+nobserved_vars(pat::SemObservedMissingPattern) = length(pat.measured_mask)
 nsamples(pat::SemObservedMissingPattern) = length(pat.rows)
 
-nobserved_vars(pat::SemObservedMissingPattern) = pat.nobserved
-nmissed_vars(pat::SemObservedMissingPattern) = pat.nmissed
+nmeasured_vars(pat::SemObservedMissingPattern) = length(pat.measured_mean)
+nmissed_vars(pat::SemObservedMissingPattern) = nobserved_vars(pat) - nmeasured_vars(pat)

Original file line number	Diff line number	Diff line change
`@@ -84,9 +84,9 @@ function predict_latent_scores(`
`84`	`84`	`params::AbstractVector,`
`85`	`85`	`data::SemObserved,`
`86`	`86`	`)`
`87`		`- n_man(data) == nobserved_vars(model) \|\| throw(`
	`87`	`+ nobserved_vars(data) == nobserved_vars(model) \|\| throw(`
`88`	`88`	`DimensionMismatch(`
`89`		`- "Number of variables in data ($(n_man(data))) does not match the number of observed variables in the model ($(nobserved_vars(model)))",`
	`89`	`+ "Number of variables in data ($(nobserved_vars(data))) does not match the number of observed variables in the model ($(nobserved_vars(model)))",`
`90`	`90`	`),`
`91`	`91`	`)`
`92`	`92`	`length(params) == nparams(model) \|\| throw(`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ function SemWLS(;`
`59`	`59`	`meanstructure = false,`
`60`	`60`	`kwargs...,`
`61`	`61`	`)`
`62`		`- n_obs = n_man(observed)`
	`62`	`+ n_obs = nobserved_vars(observed)`
`63`	`63`	`tril_ind = filter(x -> (x[1] >= x[2]), CartesianIndices(obs_cov(observed)))`
`64`	`64`	`s = obs_cov(observed)[tril_ind]`
`65`	`65`