add tests for encoder_kwargs_from

Author: odunbar

src/MarkovChainMonteCarlo.jl

@@ -601,7 +601,7 @@ function MCMCWrapper(
     prior::PD,
     em::EM;
     kwargs...,
-) where {AV <: AbstractVector, OB <: Observation, PD <: ParameterDistribution, EM <: Emulator}
+) where {OB <: Observation, PD <: ParameterDistribution, EM <: Emulator}
     return MCMCWrapper(mcmc_alg, get_obs(observation), prior, em; kwargs...)
 end
 
@@ -611,7 +611,7 @@ function MCMCWrapper(
     prior::PD,
     em::EM;
     kwargs...,
-) where {AV <: AbstractVector, OS <: ObservationSeries, PD <: ParameterDistribution, EM <: Emulator}
+) where {OS <: ObservationSeries, PD <: ParameterDistribution, EM <: Emulator}
     observations = [get_obs(ob) for ob in get_observations(observation_series)]
     return MCMCWrapper(mcmc_alg, observations, prior, em; kwargs...)
 end

src/Utilities.jl

@@ -27,7 +27,8 @@ export create_encoder_schedule,
     encode_structure_matrix,
     decode_data,
     decode_structure_matrix,
-    norm
+    norm,
+    encoder_kwargs_from
 
 
 const StructureMatrix = Union{UniformScaling, AbstractMatrix, AbstractVector, LinearMap} # The vector appears due to possible block-structured matrices (build=false)
@@ -71,32 +72,42 @@ end
 
 # Using Observation Objects:
 
+"""
+$(TYPEDSIGNATURES)
+
+Extracts the relevant encoder kwargs from the observation as a NamedTuple. Contains,
+- `:obs_noise_cov` as (unbuilt) noise covariance
+- `:observation` as obs vector
+"""
 function encoder_kwargs_from(obs::OB) where {OB <: Observation}
-    return (obs_noise_cov = get_covs(obs, build = false), observation = get_obs(obs))
+    return (; obs_noise_cov = get_obs_noise_cov(obs, build = false), observation = get_obs(obs))
 end
 
-function encoder_kwargs_from(os::OS) where {OS <: ObservationSeries}
-    obs_vec = get_observations(os)
-    return [encoder_kwargs_from(obs) for obs in obs_vec]
-end
+"""
+$(TYPEDSIGNATURES)
 
-function encoder_kwargs_from(prior::PD; rng = Random.default_rng(), n_samples = 100) where {PD <: ParameterDistribution}
-    return (prior_cov = cov(prior), prior_samples_in = sample(rng, prior, n_samples))
+Extracts the relevant encoder kwargs from the ObservationSeries as a NamedTuple. Assumes the same noise covariance for all observation vectors. Contains,
+- `:obs_noise_cov` as (unbuilt) noise covariance of FIRST observation
+- `:observation` as obs vector from all observations
+"""
+function encoder_kwargs_from(os::OS) where {OS <: ObservationSeries}
+    observations = get_observations(os)
+    obs_vec = [get_obs(obs) for obs in observations]
+    obs_noise_cov = get_obs_noise_cov(observations[1], build = false)
+    return (; obs_noise_cov = obs_noise_cov, observation = obs_vec)
 end
 
-##  multiplication with observation covariance objects without building
 """
 $(TYPEDSIGNATURES)
 
-Left-multiply `X` by structure matrix `A` without building it (if provided in a compact form).
-
-This is useful when A is high dimensional and provided as an `SVD` or `SumOfCovariances` etc. object from EnsembleKalmanProcesses. 
+Extracts the relevant encoder kwargs from the ParameterDistribution prior. Contains,
+- `:prior_cov` as prior covariance
 """
-function lmul_compact(A, X::AVorM) where {AVorM <: AbstractVecOrMat}
-    # A is presumed a vector, of (compact) matrix types.
-    return isa(A, AbstractVector) ? EKP.lmul_without_build(A, X) : EKP.lmul_without_build([A], X)
+function encoder_kwargs_from(prior::PD) where {PD <: ParameterDistribution}
+    return (; prior_cov = cov(prior))
 end
 
+##  multiplication with observation covariance objects without building
 """
 $(TYPEDSIGNATURES)
 
@@ -105,7 +116,7 @@ Produces a linear map of type `LinearMap` that can evaluates the stacked actions
 This compact map constructs the following form of the Linear map f:
 
 1. get compact form svd-plus-d form "USVt + D" of the `blocks`
-2. create the f via stacking `A.U * A.S * A.Vt * x[block] + A.D * x[block] for (A,block) in blocks`
+2. create the f via stacking `A.U * A.S * A.Vt * xblock + A.D * xblock for (A,xblock) in  (As, x)`
 
 kwargs:
 ------

test/Utilities/runtests.jl

@@ -7,6 +7,7 @@ using LinearAlgebra
 using CalibrateEmulateSample.Utilities
 using CalibrateEmulateSample.EnsembleKalmanProcesses
 using CalibrateEmulateSample.DataContainers
+using CalibrateEmulateSample.ParameterDistributions
 
 @testset "Utilities" begin
 
@@ -49,6 +50,29 @@ end
     # Seed for pseudo-random number generator
     rng = Random.MersenneTwister(4154)
 
+    # test getting encoder kwargs from observations and series
+    # from prior
+    pd = constrained_gaussian("name", 0.0, 2.0, -10, Inf, repeat = 5)
+    encoder_kwargs = encoder_kwargs_from(pd)
+    @test isapprox(norm(encoder_kwargs.prior_cov - cov(pd)), 0, atol = 1e-12)
+
+    # from observation
+    osample = [1.0, 2.0]
+    ocov = 4.0 * I(2)
+    obs = Observation(Dict("samples" => osample, "covariances" => ocov, "names" => "test"))
+    encoder_kwargs = encoder_kwargs_from(obs)
+    @test all(isapprox.(norm.(encoder_kwargs.obs_noise_cov - get_obs_noise_cov(obs, build = false)), 0.0, atol = 1e-12))
+    @test all(isapprox.(encoder_kwargs.observation - get_obs(obs), 0.0, atol = 1e-12))
+
+    # from observation series
+    obs2 = Observation(Dict("samples" => osample .+ 1.0, "covariances" => 2.0 .* ocov, "names" => "test"))
+    obs_series = ObservationSeries([obs, obs2])
+    encoder_kwargs = encoder_kwargs_from(obs_series)
+    @test all(isapprox.(norm.(encoder_kwargs.obs_noise_cov - get_obs_noise_cov(obs, build = false)), 0, atol = 1e-12))
+    diff = encoder_kwargs.observation - [get_obs(obs), get_obs(obs2)]
+    @test all([all(isapprox.(dd, 0.0, atol = 1e-12)) for dd in diff])
+
+
     # Tests for get_structure_vec and get_structure_mat
     structure_vecs = Dict("a" => [1, 2, 3], "b" => [4, 5, 6])
     structure_mats = Dict("c" => [1 2; 3 4], "d" => [5 6; 7 8])