CliMA · ArneBouillon · Aug 25, 2025 · Jul 21, 2025 · Jul 21, 2025 · Aug 11, 2025
diff --git a/docs/src/API/GaussianProcess.md b/docs/src/API/GaussianProcess.md
@@ -15,7 +15,7 @@ GaussianProcess(
     ::FT,
     ::PredictionType,
 ) where {GPPkg <: GaussianProcessesPackage, K <: GaussianProcesses.Kernel, KPy <: PyObject, AK <:AbstractGPs.Kernel, FT <: AbstractFloat}
-build_models!(::GaussianProcess{GPJL}, ::PairedDataContainer{FT}, input_structure_matrix, output_structure_matrix) where {FT <: AbstractFloat}
+build_models!(::GaussianProcess{GPJL}, ::PairedDataContainer{FT}, input_structure_mats, output_structure_mats) where {FT <: AbstractFloat}
 optimize_hyperparameters!(::GaussianProcess{GPJL})
 predict(::GaussianProcess{GPJL},  ::AbstractMatrix{FT}) where {FT <: AbstractFloat}
 ```
diff --git a/docs/src/API/RandomFeatures.md b/docs/src/API/RandomFeatures.md
@@ -22,7 +22,7 @@ build_default_prior
 ```@docs
 ScalarRandomFeatureInterface
 ScalarRandomFeatureInterface(::Int,::Int)
-build_models!(::ScalarRandomFeatureInterface, ::PairedDataContainer{FT}, input_structure_matrix, output_structure_matrix) where {FT <: AbstractFloat}
+build_models!(::ScalarRandomFeatureInterface, ::PairedDataContainer{FT}, input_structure_mats, output_structure_mats) where {FT <: AbstractFloat}
 predict(::ScalarRandomFeatureInterface, ::M) where {M <: AbstractMatrix}
 ```
 
@@ -31,7 +31,7 @@ predict(::ScalarRandomFeatureInterface, ::M) where {M <: AbstractMatrix}
 ```@docs
 VectorRandomFeatureInterface
 VectorRandomFeatureInterface(::Int, ::Int, ::Int)
-build_models!(::VectorRandomFeatureInterface, ::PairedDataContainer{FT}, input_structure_matrix, output_structure_matrix) where {FT <: AbstractFloat}
+build_models!(::VectorRandomFeatureInterface, ::PairedDataContainer{FT}, input_structure_mats, output_structure_mats) where {FT <: AbstractFloat}
 predict(::VectorRandomFeatureInterface, ::M) where {M <: AbstractMatrix}
 ```
 

diff --git a/docs/src/data_processing.md b/docs/src/data_processing.md
@@ -28,7 +28,7 @@ complex_schedule = [
 In this (rather unrealistic) chain;
 1. The inputs are decorrelated with their sample mean and covariance (and projected to low dimensional subspace if necessary) i.e PCA
 2. The scaled inputs are then subject to a "Robust" univariate scaling, mapping 1st-3rd quartiles to [0,1]
-3. The outputs are decorrelated using an "output structure matrix" (provided to the emulator `output_structure_matrix=`). Furthermore, apply a dimension-reduction to a space that retains 95% of the total variance. 
+3. The outputs are decorrelated using an "output structure matrix" (provided to the emulator in the `encoder_kwargs` parameter, e.g. as `(; obs_cov_noise =)`). Furthermore, apply a dimension-reduction to a space that retains 95% of the total variance. 
 4. In the reduced input-output space, a canonical correlation analysis is performed. Data is oriented and reduced (if necessary) maximize the joint correlation between inputs and outputs.
 
 !!! note "Default Encoder schedule"
@@ -44,12 +44,12 @@ The schedule is then passed into the Emulator, along with the data and desired s
 ```julia
 emulator = Emulator(
     machine_learning_tool,       
-    input_output_pairs; 
-    output_structure_matrix = obs_noise_cov, 
+    input_output_pairs,
+    (; obs_noise_cov = obs_noise_cov);
     encoder_schedule = complex_schedule,
 )
 ```
-Note that due to the item `(decorrelate_structure_mat(retain_var=0.95), "out")` in the schedule, we must provide the `output_structure_matrix`.
+Note that due to the item `(decorrelate_structure_mat(retain_var=0.95), "out")` in the schedule, we must provide an output structure matrix. In this case, we provide `obs_noise_cov`.
 
 # Types of data processors
 

diff --git a/docs/src/emulate.md b/docs/src/emulate.md
@@ -16,8 +16,8 @@ Wrapping a predefined machine learning tool, e.g. a Gaussian process `gauss_proc
 ```julia
 emulator = Emulator(
     gauss_proc, 
-    input_output_pairs; # optional arguments after this
-    output_structure_matrix = Γy,
+    input_output_pairs,
+    (; obs_noise_cov = Γy); # optional arguments after this
     encoder_schedule = encoder_schedule,
 )
 ```
@@ -44,7 +44,7 @@ Developers may contribute new tools by performing the following
 2. Create a struct `MyMLTool <: MachineLearningTool`, containing any arguments or optimizer options 
 3. Create the following three methods to build, train, and predict with your tool (use `GaussianProcess.jl` as a guide)
 ```
-build_models!(mlt::MyMLTool, iopairs::PairedDataContainer) -> Nothing
+build_models!(mlt::MyMLTool, iopairs::PairedDataContainer, input_structure_mats::Dict{Symbol, <:StructureMatrix}, output_structure_mats::Dict{Symbol, <:StructureMatrix}) -> Nothing
 optimize_hyperparameters!(mlt::MyMLTool, args...; kwargs...) -> Nothing
 function predict(mlt::MyMLTool, new_inputs::Matrix; kwargs...) -> Matrix, Union{Matrix, Array{,3}
 ```

diff --git a/examples/Cloudy/Cloudy_emulate_sample.jl b/examples/Cloudy/Cloudy_emulate_sample.jl
@@ -171,9 +171,8 @@ function main()
         # build emulator
         emulator = Emulator(
             mlt,
-            input_output_pairs;
-            input_structure_matrix = cov(priors),
-            output_structure_matrix = Γy,
+            input_output_pairs,
+            (; prior_cov = cov(priors), obs_noise_cov = Γy);
             encoder_schedule = encoder_schedule,
         )
 

diff --git a/examples/Darcy/emulate_sample.jl b/examples/Darcy/emulate_sample.jl
@@ -96,9 +96,8 @@ function main()
 
         emulator = Emulator(
             mlt,
-            input_output_pairs;
-            input_structure_matrix = cov(prior),
-            output_structure_matrix = Γy,
+            input_output_pairs,
+            (; prior_cov = cov(prior), obs_noise_cov = Γy);
             encoding_schedule = encoding_schedule,
         )
         optimize_hyperparameters!(emulator, kernbounds = [fill(-1e2, n_params + 1), fill(1e2, n_params + 1)])

diff --git a/examples/EDMF_data/emulator-rank-test.jl b/examples/EDMF_data/emulator-rank-test.jl
@@ -256,9 +256,8 @@ function main()
             ttt[rank_id, rep_idx] = @elapsed begin
                 emulator = Emulator(
                     mlt,
-                    train_pairs;
-                    input_structure_matrix = cov(prior),
-                    output_structure_matrix = truth_cov,
+                    train_pairs,
+                    (; prior_cov = cov(prior), obs_noise_cov = truth_cov);
                     encoder_schedule = encoder_schedule,
                 )
 

diff --git a/examples/EDMF_data/uq_for_edmf.jl b/examples/EDMF_data/uq_for_edmf.jl
@@ -230,9 +230,8 @@ function main()
     # Fit an emulator to the data
     emulator = Emulator(
         mlt,
-        input_output_pairs;
-        input_structure_matrix = cov(prior),
-        output_structure_matrix = truth_cov,
+        input_output_pairs,
+        (; prior_cov = cov(prior), obs_noise_cov = truth_cov);
         encoder_schedule = encoder_schedule,
     )
 

diff --git a/examples/Emulator/G-function/emulate-test-n-features.jl b/examples/Emulator/G-function/emulate-test-n-features.jl
@@ -151,12 +151,8 @@ function main()
 
             # Emulate
             ttt[f_idx, rep_idx] = @elapsed begin
-                emulator = Emulator(
-                    mlt,
-                    iopairs;
-                    output_structure_matrix = Γ * I,
-                    encoder_schedule = deepcopy(encoder_schedule),
-                )
+                emulator =
+                    Emulator(mlt, iopairs, (; obs_noise_cov = Γ * I); encoder_schedule = deepcopy(encoder_schedule))
                 optimize_hyperparameters!(emulator)
             end
 

diff --git a/examples/Emulator/G-function/emulate.jl b/examples/Emulator/G-function/emulate.jl
@@ -142,12 +142,7 @@ function main()
 
         # Emulate
         times[rep_idx] = @elapsed begin
-            emulator = Emulator(
-                mlt,
-                iopairs;
-                output_structure_matrix = Γ * I,
-                encoder_schedule = deepcopy(encoder_schedule),
-            )
+            emulator = Emulator(mlt, iopairs, (; obs_noise_cov = Γ * I); encoder_schedule = deepcopy(encoder_schedule))
             optimize_hyperparameters!(emulator)
         end
 

diff --git a/examples/Emulator/Ishigami/emulate.jl b/examples/Emulator/Ishigami/emulate.jl
@@ -123,8 +123,7 @@ function main()
         end
 
         # Emulate
-        emulator =
-            Emulator(mlt, iopairs; output_structure_matrix = Γ * I, encoder_schedule = deepcopy(encoder_schedule))
+        emulator = Emulator(mlt, iopairs, (; obs_noise_cov = Γ * I); encoder_schedule = deepcopy(encoder_schedule))
         optimize_hyperparameters!(emulator)
 
         # get EKP errors - just stored in "optimizer" box for now

diff --git a/examples/Emulator/L63/emulate.jl b/examples/Emulator/L63/emulate.jl
@@ -215,7 +215,7 @@ function main()
         else
             encoder_schedule = (decorrelate_structure_mat(), "out")
         end
-        emulator = Emulator(mlt, iopairs; output_structure_matrix = Γy, encoder_schedule = deepcopy(encoder_schedule))
+        emulator = Emulator(mlt, iopairs, (; obs_noise_cov = Γy); encoder_schedule = deepcopy(encoder_schedule))
         optimize_hyperparameters!(emulator)
 
         # diagnostics

diff --git a/examples/Emulator/L63/emulate_diff-rank-test.jl b/examples/Emulator/L63/emulate_diff-rank-test.jl
@@ -191,12 +191,7 @@ function main()
                 encoder_schedule = nothing
             end
             ttt[rank_id, rep_idx] = @elapsed begin
-                emulator = Emulator(
-                    mlt,
-                    iopairs;
-                    output_structure_matrix = Γy,
-                    encoder_schedule = deepcopy(encoder_schedule),
-                )
+                emulator = Emulator(mlt, iopairs, (; obs_noise_cov = Γy); encoder_schedule = deepcopy(encoder_schedule))
                 optimize_hyperparameters!(emulator)
             end
 

diff --git a/examples/Emulator/Regression_2d_2d/compare_regression.jl b/examples/Emulator/Regression_2d_2d/compare_regression.jl
@@ -166,13 +166,7 @@ function main()
 
             end
 
-            emulator = Emulator(
-                mlt,
-                iopairs,
-                encoder_schedule = enc,
-                input_structure_matrix = prior_cov,
-                output_structure_matrix = Σ,
-            )
+            emulator = Emulator(mlt, iopairs, (; prior_cov = prior_cov, obs_noise_cov = Σ); encoder_schedule = enc)
 
 
             optimize_hyperparameters!(emulator) # although RF already optimized

diff --git a/examples/GCM/emulate_sample_script.jl b/examples/GCM/emulate_sample_script.jl
@@ -160,20 +160,15 @@ function main()
     if emulator_type == "VectorRFR-nondiag"
 
         encoder_schedule = [(quartile_scale(), "in"), (decorrelate_structure_mat(), "out")]
-        emulator = Emulator(
-            mlt,
-            input_output_pairs;
-            output_structure_matrix = obs_noise_cov,
-            encoder_schedule = encoder_schedule,
-        )
+        emulator =
+            Emulator(mlt, input_output_pairs, (; obs_noise_cov = obs_noise_cov); encoder_schedule = encoder_schedule)
     else
         encoder_schedule = [(decorrelate_structure_mat(), "in_and_out")]
 
         emulator = Emulator(
             mlt,
-            input_output_pairs;
-            input_structure_matrix = cov(prior),
-            output_structure_matrix = obs_noise_cov,
+            input_output_pairs,
+            (; prior_cov = cov(prior), obs_noise_cov = obs_noise_cov);
             encoder_schedule = encoder_schedule,
         )
 

diff --git a/examples/Lorenz/emulate_sample.jl b/examples/Lorenz/emulate_sample.jl
@@ -170,7 +170,7 @@ function main()
         retain_var = 0.95
         encoder_schedule = [(quartile_scale(), "in"), (decorrelate_structure_mat(retain_var = retain_var), "out")]
 
-        emulator = Emulator(mlt, input_output_pairs; output_structure_matrix = Γy, encoder_schedule = encoder_schedule)
+        emulator = Emulator(mlt, input_output_pairs, (; obs_noise_cov = Γy); encoder_schedule = encoder_schedule)
         optimize_hyperparameters!(emulator)
 
         # Check how well the Gaussian Process regression predicts on the

diff --git a/examples/Lorenz/emulate_sample_spatial_dep.jl b/examples/Lorenz/emulate_sample_spatial_dep.jl
@@ -143,9 +143,8 @@ function main()
 
         emulator = Emulator(
             mlt,
-            input_output_pairs;
-            input_structure_matrix = cov(priors),
-            output_structure_matrix = Γy,
+            input_output_pairs,
+            (; prior_cov = cov(priors), obs_noise_cov = Γy);
             encoder_schedule = encoder_schedule,
         )
         optimize_hyperparameters!(emulator)

diff --git a/examples/Sinusoid/emulate.jl b/examples/Sinusoid/emulate.jl
@@ -75,7 +75,7 @@ gauss_proc = Emulators.GaussianProcess(gppackage, noise_learn = false)
 encoder_schedule = [(decorrelate_sample_cov(), "in"), (decorrelate_structure_mat(), "out")]
 
 # Build emulator with data
-emulator_gp = Emulator(gauss_proc, input_output_pairs, output_structure_matrix = Γ, encoder_schedule = encoder_schedule)
+emulator_gp = Emulator(gauss_proc, input_output_pairs, (obs_cov_noise = Γ,); encoder_schedule)
 optimize_hyperparameters!(emulator_gp)
 
 # We have built the Gaussian process emulator and we can now use it for prediction. We will validate the emulator 
@@ -113,7 +113,7 @@ random_features = VectorRandomFeatureInterface(
 )
 encoder_schedule_rf = [(decorrelate_sample_cov(), "in"), (decorrelate_structure_mat(), "out")]
 emulator_random_features =
-    Emulator(random_features, input_output_pairs, encoder_schedule = encoder_schedule_rf, output_structure_matrix = Γ)
+    Emulator(random_features, input_output_pairs, (obs_cov_noise = Γ,); encoder_schedule = encoder_schedule_rf)
 optimize_hyperparameters!(emulator_random_features)