add test for ComponentArrayInterpreter

and fix edge-case ambuiguity for empty ComponentVector put array adding empty dimesnions

Author: bgctw

Project.toml

@@ -3,31 +3,33 @@ uuid = "a108c475-a4e2-4021-9a84-cfa7df242f64"
 authors = ["Thomas Wutzler <twutz@bgc-jena.mpg.de> and contributors"]
 version = "1.0.0-DEV"
 
-[weakdeps]
-Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c"
-Lux = "b2108857-7c20-44ae-9111-449ecde12c47"
-SimpleChains = "de6bee2f-e2f4-4ec7-b6ed-219cc6f6e9e5"
-
 [deps]
 Combinatorics = "861a8166-3701-5b0c-9a16-15d98fcdc6aa"
 ComponentArrays = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
 StatsFuns = "4c63d2b9-4356-54db-8cca-17b64c39e42c"
 
+[weakdeps]
+Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c"
+Lux = "b2108857-7c20-44ae-9111-449ecde12c47"
+SimpleChains = "de6bee2f-e2f4-4ec7-b6ed-219cc6f6e9e5"
+
+[extensions]
+HybridVariationalInferenceFluxExt = "Flux"
+HybridVariationalInferenceLuxExt = "Lux"
+HybridVariationalInferenceSimpleChainsExt = "SimpleChains"
+
 [compat]
 Combinatorics = "1.0.2"
 ComponentArrays = "0.15.19"
 Flux = "v0.15.2"
 Lux = "1.4.2"
 Random = "1.10.0"
 SimpleChains = "0.4"
+StatsBase = "0.34.4"
+StatsFuns = "1.3.2"
 julia = "1.10"
 
-[extensions]
-HybridVariationalInferenceSimpleChainsExt = "SimpleChains"
-HybridVariationalInferenceFluxExt = "Flux"
-HybridVariationalInferenceLuxExt = "Lux"
-
 [workspace]
-projects = ["test", "docs"]
+projects = ["test", "docs"]

src/ComponentArrayInterpreter.jl

@@ -137,6 +137,13 @@ function ComponentArrayInterpreter(
     ComponentArrayInterpreter(axes_ext)
 end
 
+# ambuiguity with two empty Tuples (edge case that does not make sense)
+# Empty ComponentVector with no other array dimenstions -> empty componentVector
+function ComponentArrayInterpreter(n_dims1::Tuple{}, n_dims2::Tuple{})
+    ComponentArrayInterpreter(CA.ComponentVector())
+end
+
+
 
 
 # not exported, but required for testing

src/HybridVariationalInference.jl

@@ -5,7 +5,7 @@ using Random
 using StatsBase # fit ZScoreTransform
 using Combinatorics # gen_hybridcase_synthetic/combinations
 
-export ComponentArrayInterpreter, flatten1
+export ComponentArrayInterpreter, flatten1, get_concrete
 include("ComponentArrayInterpreter.jl")
 
 export AbstractModelApplicator, construct_SimpleChainsApplicator, construct_FluxApplicator,

test/runtests.jl

@@ -3,6 +3,8 @@ const GROUP = get(ENV, "GROUP", "All") # defined in in CI.yml
 
 @time begin
     if GROUP == "All" || GROUP == "Basic"
+        #@safetestset "test" include("test/test_ComponentArrayInterpreter.jl")
+        @time @safetestset "test_ComponentArrayInterpreter" include("test_ComponentArrayInterpreter.jl")
         #@safetestset "test" include("test/test_gencovar.jl")
         @time @safetestset "test_gencovar" include("test_gencovar.jl")
         #@safetestset "test" include("test/test_SimpleChains.jl")

test/test_ComponentArrayInterpreter.jl

@@ -0,0 +1,91 @@
+using Test
+using HybridVariationalInference
+using HybridVariationalInference: HybridVariationalInference as CM
+using ComponentArrays: ComponentArrays as CA
+
+@testset "ComponentArrayInterpreter vector" begin
+    component_counts = comp_cnts = (; P=2, M=3, Unc=5)
+    m = ComponentArrayInterpreter(; comp_cnts...)
+    testm = (m) -> begin
+        @test CM._get_ComponentArrayInterpreter_axes(m) == (CA.Axis(P=1:2, M=3:5, Unc=6:10),)
+        @test length(m) == 10
+        v = 1:length(m)
+        cv = m(v)
+        @test cv.Unc == 6:10
+    end
+    testm(m)
+    testm(get_concrete(m))
+    Base.isconcretetype(typeof(m))
+end;
+
+# () -> begin
+#     # test generate code for length
+#     @code_llvm length(m)
+#     mc = get_concrete(m)
+#     @code_llvm length(mc)
+#     v = 1:length(m)
+#     @code_llvm as_ca(v,m)
+#     @code_llvm as_ca(v,mc)
+# end
+
+@testset "ComponentArrayInterpreter matrix in vector" begin
+    component_shapes = (; P=2, M=(2, 3), Unc=5)
+    m = ComponentArrayInterpreter(; component_shapes...)
+    testm = (m) -> begin
+        @test length(m) == 13
+        a = 1:length(m)
+        cv = m(a)
+        @test cv.M == 2 .+ [1 3 5; 2 4 6]
+    end
+    testm(m)
+    testm(get_concrete(m))
+end;
+
+@testset "ComponentArrayInterpreter matrix and array" begin
+    mv = ComponentArrayInterpreter(; c1=2, c2=3)
+    cv = mv(1:length(mv))
+    n_col = 4
+    mm = ComponentArrayInterpreter(cv, (n_col,)) # 1-tuple
+    testm = (m) -> begin
+        @test length(mm) == length(cv) * n_col
+        cm = mm(1:length(mm))
+        #cm[:c1,:]
+        @test cm[:c1, 2] == 6:7
+    end
+    testm(mm)
+    mmc = get_concrete(mm)
+    testm(mmc)
+    #
+    n_z = 3
+    mm = ComponentArrayInterpreter(cv, (n_col, n_z))
+    testm = (m) -> begin
+        @test length(mm) == length(cv) * n_col * n_z
+        cm = mm(1:length(mm))
+        @test cm[:c1, 2, 2] == 26:27
+    end
+    testm(mm)
+    testm(get_concrete(mm))
+    #
+    n_row = 3
+    mm = ComponentArrayInterpreter((n_row,), cv)
+    testm = (m) -> begin
+        @test length(mm) == n_row * length(cv)
+        cm = mm(1:length(mm))
+        @test cm[2, :c1] == [2, 5]
+    end
+    testm(mm)
+    testm(get_concrete(mm))
+end;
+
+@testset "empty ComponentVector" begin
+    x = CA.ComponentVector{Float32}()
+    int1 = ComponentArrayInterpreter(x) 
+    @test int1(CA.getdata(x)) == x
+    int2 = ComponentArrayInterpreter(x, ())
+    @test int2 == int1
+    int3 = ComponentArrayInterpreter((), x)
+    @test int3 == int1
+end;
+
+
+

test/test_doubleMM.jl

@@ -50,7 +50,8 @@ end
     optf = Optimization.OptimizationFunction((ϕg, p) -> loss_g(ϕg, xM, g)[1],
         Optimization.AutoZygote())
     optprob = Optimization.OptimizationProblem(optf, ϕg0);
-    res = Optimization.solve(optprob, Adam(0.02), callback = callback_loss(100), maxiters = 600);
+    #res = Optimization.solve(optprob, Adam(0.02), callback = callback_loss(100), maxiters = 600);
+    res = Optimization.solve(optprob, Adam(0.02), maxiters = 600);
 
     ϕg_opt1 = res.u;
     pred = loss_g(ϕg_opt1, xM, g)
@@ -79,7 +80,8 @@ end
     optprob = OptimizationProblem(optf, p0, train_loader)
 
     res = Optimization.solve(
-        optprob, Adam(0.02), callback = callback_loss(100), maxiters = 1000);
+#        optprob, Adam(0.02), callback = callback_loss(100), maxiters = 1000);
+        optprob, Adam(0.02), maxiters = 1000);
 
     l1, y_pred_global, y_pred, θMs_pred = loss_gf(res.u, train_loader.data...)
     @test isapprox(par_templates.θP, int_ϕθP(res.u).θP, rtol = 0.11)