Make encoder_kwargs itself a kwarg

ArneBouillon · ArneBouillon · commit 6d422b76a692 · 2025-08-21T16:11:31.000+02:00
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 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. 
+3. The outputs are decorrelated using an "output structure matrix" (provided to the emulator in the `encoder_kwargs` keyword 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,9 +44,9 @@ The schedule is then passed into the Emulator, along with the data and desired s
 ```julia
 emulator = Emulator(
     machine_learning_tool,       
-    input_output_pairs,
-    (; obs_noise_cov = obs_noise_cov);
+    input_output_pairs;
     encoder_schedule = complex_schedule,
+    encoder_kwargs = (; obs_noise_cov = obs_noise_cov),
 )
 ```
 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`.
diff --git a/docs/src/emulate.md b/docs/src/emulate.md
@@ -16,9 +16,9 @@ Wrapping a predefined machine learning tool, e.g. a Gaussian process `gauss_proc
 ```julia
 emulator = Emulator(
     gauss_proc, 
-    input_output_pairs,
-    (; obs_noise_cov = Γy); # optional arguments after this
+    input_output_pairs; # optional arguments after this
     encoder_schedule = encoder_schedule,
+    encoder_kwargs = (; obs_noise_cov = Γy),
 )
 ```
 The optional arguments above relate to the data processing, which is described [here](@ref data-proc)
diff --git a/examples/Cloudy/Cloudy_emulate_sample.jl b/examples/Cloudy/Cloudy_emulate_sample.jl
@@ -171,9 +171,9 @@ function main()
         # build emulator
         emulator = Emulator(
             mlt,
-            input_output_pairs,
-            (; prior_cov = cov(priors), obs_noise_cov = Γy);
+            input_output_pairs;
             encoder_schedule = encoder_schedule,
+            encoder_kwargs = (; prior_cov = cov(priors), obs_noise_cov = Γy),
         )
 
         optimize_hyperparameters!(emulator)
diff --git a/examples/Darcy/emulate_sample.jl b/examples/Darcy/emulate_sample.jl
@@ -92,13 +92,13 @@ function main()
         @save joinpath(data_save_directory, "input_output_pairs.jld2") input_output_pairs
 
         # data processing
-        encoding_schedule = (decorrelate_structure_mat(), "in_and_out")
+        encoder_schedule = (decorrelate_structure_mat(), "in_and_out")
 
         emulator = Emulator(
             mlt,
-            input_output_pairs,
-            (; prior_cov = cov(prior), obs_noise_cov = Γy);
-            encoding_schedule = encoding_schedule,
+            input_output_pairs;
+            encoder_schedule = encoder_schedule,
+            encoder_kwargs = (; prior_cov = cov(prior), obs_noise_cov = Γy),
         )
         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
@@ -257,8 +257,8 @@ function main()
                 emulator = Emulator(
                     mlt,
                     train_pairs,
-                    (; prior_cov = cov(prior), obs_noise_cov = truth_cov);
                     encoder_schedule = encoder_schedule,
+                    encoder_kwargs = (; prior_cov = cov(prior), obs_noise_cov = truth_cov),
                 )
 
                 # Optimize the GP hyperparameters for better fit
diff --git a/examples/EDMF_data/uq_for_edmf.jl b/examples/EDMF_data/uq_for_edmf.jl
@@ -231,8 +231,8 @@ function main()
     emulator = Emulator(
         mlt,
         input_output_pairs,
-        (; prior_cov = cov(prior), obs_noise_cov = truth_cov);
         encoder_schedule = encoder_schedule,
+        encoder_kwargs = (; prior_cov = cov(prior), obs_noise_cov = truth_cov),
     )
 
     # Optimize the GP hyperparameters for better fit
diff --git a/examples/Emulator/G-function/emulate-test-n-features.jl b/examples/Emulator/G-function/emulate-test-n-features.jl
@@ -151,8 +151,12 @@ function main()
 
             # Emulate
             ttt[f_idx, rep_idx] = @elapsed begin
-                emulator =
-                    Emulator(mlt, iopairs, (; obs_noise_cov = Γ * I); encoder_schedule = deepcopy(encoder_schedule))
+                emulator = Emulator(
+                    mlt,
+                    iopairs;
+                    encoder_schedule = deepcopy(encoder_schedule),
+                    encoder_kwargs = (; obs_noise_cov = Γ * I),
+                )
                 optimize_hyperparameters!(emulator)
             end
 
diff --git a/examples/Emulator/G-function/emulate.jl b/examples/Emulator/G-function/emulate.jl
@@ -142,7 +142,12 @@ function main()
 
         # Emulate
         times[rep_idx] = @elapsed begin
-            emulator = Emulator(mlt, iopairs, (; obs_noise_cov = Γ * I); encoder_schedule = deepcopy(encoder_schedule))
+            emulator = Emulator(
+                mlt,
+                iopairs;
+                encoder_schedule = deepcopy(encoder_schedule),
+                encoder_kwargs = (; obs_noise_cov = Γ * I),
+            )
             optimize_hyperparameters!(emulator)
         end
 
diff --git a/examples/Emulator/Ishigami/emulate.jl b/examples/Emulator/Ishigami/emulate.jl
@@ -123,7 +123,12 @@ function main()
         end
 
         # Emulate
-        emulator = Emulator(mlt, iopairs, (; obs_noise_cov = Γ * I); encoder_schedule = deepcopy(encoder_schedule))
+        emulator = Emulator(
+            mlt,
+            iopairs;
+            encoder_schedule = deepcopy(encoder_schedule),
+            encoder_kwargs = (; obs_noise_cov = Γ * I),
+        )
         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,12 @@ function main()
         else
             encoder_schedule = (decorrelate_structure_mat(), "out")
         end
-        emulator = Emulator(mlt, iopairs, (; obs_noise_cov = Γy); encoder_schedule = deepcopy(encoder_schedule))
+        emulator = Emulator(
+            mlt,
+            iopairs;
+            encoder_schedule = deepcopy(encoder_schedule),
+            encoder_kwargs = (; obs_noise_cov = Γy),
+        )
         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,7 +191,12 @@ function main()
                 encoder_schedule = nothing
             end
             ttt[rank_id, rep_idx] = @elapsed begin
-                emulator = Emulator(mlt, iopairs, (; obs_noise_cov = Γy); encoder_schedule = deepcopy(encoder_schedule))
+                emulator = Emulator(
+                    mlt,
+                    iopairs;
+                    encoder_schedule = deepcopy(encoder_schedule),
+                    encoder_kwargs = (; obs_noise_cov = Γy),
+                )
                 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,7 +166,12 @@ function main()
 
             end
 
-            emulator = Emulator(mlt, iopairs, (; prior_cov = prior_cov, obs_noise_cov = Σ); encoder_schedule = enc)
+            emulator = Emulator(
+                mlt,
+                iopairs;
+                encoder_schedule = enc,
+                encoder_kwargs = (; prior_cov = prior_cov, obs_noise_cov = Σ),
+            )
 
 
             optimize_hyperparameters!(emulator) # although RF already optimized
diff --git a/examples/GCM/emulate_sample_script.jl b/examples/GCM/emulate_sample_script.jl
@@ -160,16 +160,20 @@ function main()
     if emulator_type == "VectorRFR-nondiag"
 
         encoder_schedule = [(quartile_scale(), "in"), (decorrelate_structure_mat(), "out")]
-        emulator =
-            Emulator(mlt, input_output_pairs, (; obs_noise_cov = obs_noise_cov); encoder_schedule = encoder_schedule)
+        emulator = Emulator(
+            mlt,
+            input_output_pairs;
+            encoder_schedule = encoder_schedule,
+            encoder_kwargs = (; obs_noise_cov = obs_noise_cov),
+        )
     else
         encoder_schedule = [(decorrelate_structure_mat(), "in_and_out")]
 
         emulator = Emulator(
             mlt,
             input_output_pairs,
-            (; prior_cov = cov(prior), obs_noise_cov = obs_noise_cov);
             encoder_schedule = encoder_schedule,
+            encoder_kwargs = (; prior_cov = cov(prior), obs_noise_cov = obs_noise_cov),
         )
 
     end
diff --git a/examples/Lorenz/emulate_sample.jl b/examples/Lorenz/emulate_sample.jl
@@ -170,7 +170,12 @@ 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, (; obs_noise_cov = Γy); encoder_schedule = encoder_schedule)
+        emulator = Emulator(
+            mlt,
+            input_output_pairs;
+            encoder_schedule = encoder_schedule,
+            encoder_kwargs = (; obs_noise_cov = Γy),
+        )
         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,9 @@ function main()
 
         emulator = Emulator(
             mlt,
-            input_output_pairs,
-            (; prior_cov = cov(priors), obs_noise_cov = Γy);
+            input_output_pairs;
             encoder_schedule = encoder_schedule,
+            encoder_kwargs = (; prior_cov = cov(priors), obs_noise_cov = Γy),
         )
         optimize_hyperparameters!(emulator)
 
diff --git a/src/Emulator.jl b/src/Emulator.jl
@@ -108,17 +108,17 @@ Constructor of the Emulator object,
 Positional Arguments
  - `machine_learning_tool`: the selected machine learning tool object (e.g. Gaussian process / Random feature interface)
  - `input_output_pairs`: the paired input-output data points stored in a `PairedDataContainer`
- - `encoder_kwargs`[=`NamedTuple()`]: a Dict or NamedTuple with keyword arguments to be passed to `initialize_and_encode_with_schedule!`
 
 Keyword Arguments 
  -  `encoder_schedule`[=`nothing`]: the schedule of data encoding/decoding. This will be passed into the method `create_encoder_schedule` internally. `nothing` sets sets a default schedule `[(decorrelate_sample_cov(), "in_and_out")]`, or `[(decorrelate_sample_cov(), "in"), (decorrelate_structure_mat(), "out")]` if an `encoder_kwargs` has a key `:obs_noise_cov`. Pass `[]` for no encoding.
+ - `encoder_kwargs`[=`NamedTuple()`]: a Dict or NamedTuple with keyword arguments to be passed to `initialize_and_encode_with_schedule!`
 Other keywords are passed to the machine learning tool initialization
 """
 function Emulator(
     machine_learning_tool::MachineLearningTool,
-    input_output_pairs::PairedDataContainer{FT},
-    encoder_kwargs = NamedTuple();
+    input_output_pairs::PairedDataContainer{FT};
     encoder_schedule = nothing,
+    encoder_kwargs = NamedTuple(),
     obs_noise_cov = nothing, # temporary
     mlt_kwargs...,
 ) where {FT <: AbstractFloat}
@@ -145,8 +145,12 @@ function Emulator(
     end
 
     encoder_schedule = create_encoder_schedule(encoder_schedule)
-    (encoded_io_pairs, input_structure_mats, output_structure_mats, _, _) =
-        initialize_and_encode_with_schedule!(encoder_schedule, input_output_pairs; obs_noise_cov = obs_noise_cov, encoder_kwargs...)
+    (encoded_io_pairs, input_structure_mats, output_structure_mats, _, _) = initialize_and_encode_with_schedule!(
+        encoder_schedule,
+        input_output_pairs;
+        obs_noise_cov = obs_noise_cov,
+        encoder_kwargs...,
+    )
 
     # build the machine learning tool in the encoded space
     build_models!(machine_learning_tool, encoded_io_pairs, input_structure_mats, output_structure_mats; mlt_kwargs...)
diff --git a/test/Emulator/runtests.jl b/test/Emulator/runtests.jl
@@ -73,11 +73,11 @@ struct MLTester <: Emulators.MachineLearningTool end
     @test_logs (:warn,) (:info,) (:info,) (:warn,) Emulator(gp, io_pairs, obs_noise_cov = Σ)
     @test_logs (:warn,) (:info,) (:info,) (:warn,) Emulator(
         gp,
-        io_pairs,
-        (; prior_cov = 4.0 * I, obs_noise_cov = 2.0 * I);
+        io_pairs;
+        encoder_kwargs = (; prior_cov = 4.0 * I, obs_noise_cov = 2.0 * I),
         obs_noise_cov = 3.0 * I,
     )
-    em1 = Emulator(gp, io_pairs, (; obs_noise_cov = Σ))
+    em1 = Emulator(gp, io_pairs; encoder_kwargs = (; obs_noise_cov = Σ))
 
     enc_sch1 = create_encoder_schedule([(decorrelate_sample_cov(), "in"), (decorrelate_structure_mat(), "out")])
     initialize_and_encode_with_schedule!(
diff --git a/test/GaussianProcess/runtests.jl b/test/GaussianProcess/runtests.jl
@@ -177,11 +177,11 @@ using CalibrateEmulateSample.Utilities
     # with noise learning - e.g. we add a kernel to learn the noise (even though we provide the Sigma to the emulator)
     gp4_noise_learnt = GaussianProcess(gppackage; kernel = nothing, noise_learn = true, prediction_type = pred_type)
     # without noise learning, just use the SVD transform to deal with observational noise
-    em4_noise_learnt = Emulator(gp4_noise_learnt, iopairs2, (; obs_noise_cov = Σ))
+    em4_noise_learnt = Emulator(gp4_noise_learnt, iopairs2; encoder_kwargs = (; obs_noise_cov = Σ))
 
     gp4 = GaussianProcess(gppackage; kernel = nothing, noise_learn = false, prediction_type = pred_type)
 
-    em4_noise_from_Σ = Emulator(gp4, iopairs2, (; obs_noise_cov = Σ))
+    em4_noise_from_Σ = Emulator(gp4, iopairs2; encoder_kwargs = (; obs_noise_cov = Σ))
 
     Emulators.optimize_hyperparameters!(em4_noise_learnt)
     Emulators.optimize_hyperparameters!(em4_noise_from_Σ)
@@ -226,7 +226,7 @@ using CalibrateEmulateSample.Utilities
         ) for model_params in gp4_opt_params
     ]
 
-    em_agp_from_gp4 = Emulator(agp4, iopairs2, (; obs_noise_cov = Σ); kernel_params = kernel_params)
+    em_agp_from_gp4 = Emulator(agp4, iopairs2; encoder_kwargs = (; obs_noise_cov = Σ), kernel_params = kernel_params)
 
     μ4b, σ4b² = Emulators.predict(em_agp_from_gp4, new_inputs, transform_to_real = true)
 
diff --git a/test/MarkovChainMonteCarlo/runtests.jl b/test/MarkovChainMonteCarlo/runtests.jl
@@ -57,7 +57,7 @@ function test_gp_mv(y, σ2_y, iopairs::PairedDataContainer)
     # Squared exponential kernel (note that hyperparameters are on log scale)
     # with observational noise
     gp = GaussianProcess(gppackage; noise_learn = true, prediction_type = pred_type)
-    em = Emulator(gp, iopairs, (; obs_noise_cov = σ2_y))
+    em = Emulator(gp, iopairs; encoder_kwargs = (; obs_noise_cov = σ2_y))
     Emulators.optimize_hyperparameters!(em)
     return em
 end
@@ -70,7 +70,7 @@ function test_gp_1(y, σ2_y, iopairs::PairedDataContainer)
     # with observational noise
     GPkernel = SE(log(1.0), log(1.0))
     gp = GaussianProcess(gppackage; kernel = GPkernel, noise_learn = true, prediction_type = pred_type)
-    em = Emulator(gp, iopairs, (; obs_noise_cov = σ2_y); encoder_schedule = [])
+    em = Emulator(gp, iopairs; encoder_schedule = [], encoder_kwargs = (; obs_noise_cov = σ2_y))
     Emulators.optimize_hyperparameters!(em)
     return em
 end
@@ -83,7 +83,7 @@ function test_gp_and_agp_1(y, σ2_y, iopairs::PairedDataContainer)
     # with observational noise
     GPkernel = SE(log(1.0), log(1.0))
     gp = GaussianProcess(gppackage; kernel = GPkernel, noise_learn = true, prediction_type = pred_type)
-    em = Emulator(gp, iopairs, (; obs_noise_cov = σ2_y); encoder_schedule = [])
+    em = Emulator(gp, iopairs; encoder_schedule = [], encoder_kwargs = (; obs_noise_cov = σ2_y))
     Emulators.optimize_hyperparameters!(em)
 
     # now make agp from gp
@@ -100,7 +100,13 @@ function test_gp_and_agp_1(y, σ2_y, iopairs::PairedDataContainer)
         ) for model_params in gp_opt_params
     ]
 
-    em_agp = Emulator(agp, iopairs, (; obs_noise_cov = σ2_y); encoder_schedule = [], kernel_params = kernel_params)
+    em_agp = Emulator(
+        agp,
+        iopairs;
+        encoder_schedule = [],
+        encoder_kwargs = (; obs_noise_cov = σ2_y),
+        kernel_params = kernel_params,
+    )
 
     return em, em_agp
 end
@@ -116,7 +122,7 @@ function test_gp_2(y, σ2_y, iopairs::PairedDataContainer)
     gp = GaussianProcess(gppackage; kernel = GPkernel, noise_learn = true, prediction_type = pred_type)
     retain_var = 0.95
     encoder_schedule = [(quartile_scale(), "out"), (decorrelate_structure_mat(retain_var = retain_var), "out")]
-    em = Emulator(gp, iopairs, (; obs_noise_cov = σ2_y); encoder_schedule = encoder_schedule)
+    em = Emulator(gp, iopairs; encoder_schedule = encoder_schedule, encoder_kwargs = (; obs_noise_cov = σ2_y))
     Emulators.optimize_hyperparameters!(em)
 
     return em
diff --git a/test/RandomFeature/runtests.jl b/test/RandomFeature/runtests.jl

Original file line number	Diff line number	Diff line change
`@@ -257,8 +257,8 @@ function main()`
`257`	`257`	`emulator = Emulator(`
`258`	`258`	`mlt,`
`259`	`259`	`train_pairs,`
`260`		`- (; prior_cov = cov(prior), obs_noise_cov = truth_cov);`
`261`	`260`	`encoder_schedule = encoder_schedule,`
	`261`	`+ encoder_kwargs = (; prior_cov = cov(prior), obs_noise_cov = truth_cov),`
`262`	`262`	`)`
`263`	`263`
`264`	`264`	`# Optimize the GP hyperparameters for better fit`
Original file line number	Diff line number	Diff line change
`@@ -231,8 +231,8 @@ function main()`
`231`	`231`	`emulator = Emulator(`
`232`	`232`	`mlt,`
`233`	`233`	`input_output_pairs,`
`234`		`- (; prior_cov = cov(prior), obs_noise_cov = truth_cov);`
`235`	`234`	`encoder_schedule = encoder_schedule,`
	`235`	`+ encoder_kwargs = (; prior_cov = cov(prior), obs_noise_cov = truth_cov),`
`236`	`236`	`)`
`237`	`237`
`238`	`238`	`# Optimize the GP hyperparameters for better fit`