Remove transform and test deprecations

Author: devmotion

docs/create_kernel_plots.jl

@@ -13,7 +13,7 @@ n_grid = 101
 fill(x₀, n_grid, 1)
 xrange = reshape(collect(range(-3, 3; length=n_grid)), :, 1)
 
-k = transform(SqExponentialKernel(), 1.0)
+k = SqExponentialKernel() ∘ ScaleTransform(1.0)
 K1 = kernelmatrix(k, xrange; obsdim=1)
 p = heatmap(
     K1;
@@ -35,7 +35,7 @@ p = heatmap(
 )
 savefig(joinpath(@__DIR__, "src", "assets", "heatmap_matern.png"))
 
-k = transform(PolynomialKernel(; c=0.0, d=2.0), LinearTransform(randn(3, 1)))
+k = PolynomialKernel(; c=0.0, d=2.0) ∘ LinearTransform(randn(3, 1))
 K3 = kernelmatrix(k, xrange; obsdim=1)
 p = heatmap(
     K3;
@@ -47,7 +47,7 @@ p = heatmap(
 savefig(joinpath(@__DIR__, "src", "assets", "heatmap_poly.png"))
 
 k =
-    0.5 * SqExponentialKernel() * transform(LinearKernel(), 0.5) +
+    0.5 * SqExponentialKernel() * (LinearKernel() ∘ ScaleTransform(0.5)) +
     0.4 * (@kernel Matern32Kernel() FunctionTransform(x -> sin.(x)))
 K4 = kernelmatrix(k, xrange; obsdim=1)
 p = heatmap(

src/basekernels/gabor.jl

@@ -25,18 +25,22 @@ end
 (κ::GaborKernel)(x, y) = κ.kernel(x, y)
 
 function _gabor(; ell=nothing, p=nothing)
-    if ell === nothing
-        if p === nothing
-            return SqExponentialKernel() * CosineKernel()
-        else
-            return SqExponentialKernel() * transform(CosineKernel(), 1 ./ p)
-        end
-    elseif p === nothing
-        return transform(SqExponentialKernel(), 1 ./ ell) * CosineKernel()
+    ell_transform = if ell === nothing
+        IdentityTransform()
+    elseif ell isa Real
+        ScaleTransform(inv(ell))
     else
-        return transform(SqExponentialKernel(), 1 ./ ell) *
-               transform(CosineKernel(), 1 ./ p)
+        ARDTransform(inv.(ell))
     end
+    p_transform = if p === nothing
+        IdentityTransform()
+    elseif p isa Real
+        ScaleTransform(inv(p))
+    else
+        ARDTransform(inv.(p))
+    end
+
+    return (SqExponentialKernel() ∘ ell_transform) * (CosineKernel() ∘ p_transform)
 end
 
 function Base.getproperty(k::GaborKernel, v::Symbol)

src/kernels/transformedkernel.jl

@@ -3,9 +3,9 @@
 
 Kernel derived from `k` for which inputs are transformed via a [`Transform`](@ref) `t`.
 
-It is preferred to create kernels with input transformations with [`∘`](@ref), or its
-alias [`compose`](@ref), instead of `TransformedKernel` directly since [`∘`](@ref)
-allows optimized implementations for specific kernels and transformations.
+It is preferred to create kernels with input transformations with `∘` or its alias
+`compose` instead of `TransformedKernel` directly since this allows optimized
+implementations for specific kernels and transformations.
 
 # Definition
 

src/transform/chaintransform.jl

@@ -19,8 +19,8 @@ julia> map(t2 ∘ t1, ColVecs(X)) == ColVecs(A * (l .* X))
 true
 ```
 """
-struct ChainTransform{V<:AbstractVector{<:Transform}} <: Transform
-    transforms::V
+struct ChainTransform{T} <: Transform
+    transforms::T
 end
 
 @functor ChainTransform
@@ -33,10 +33,37 @@ function ChainTransform(v::AbstractVector{<:Type{<:Transform}}, θ::AbstractVect
     return ChainTransform(v.(θ))
 end
 
-Base.:∘(t₁::Transform, t₂::Transform) = ChainTransform([t₂, t₁])
-Base.:∘(t::Transform, tc::ChainTransform) = ChainTransform(vcat(tc.transforms, t))
+Base.:∘(t₁::Transform, t₂::Transform) = ChainTransform((t₂, t₁))
+function Base.:∘(t::Transform, tc::ChainTransform{<:AstractVector{<:Transform}})
+    return ChainTransform(vcat(tc.transforms, t))
+end
+function Base.:∘(tc::ChainTransform{<:AstractVector{<:Transform}}, t::Transform)
+    return ChainTransform(vcat(t, tc.transforms))
+end
+function Base.:∘(
+    tc1::ChainTransform{<:AstractVector{<:Transform}},
+    tc2::ChainTransform{<:AstractVector{<:Transform}},
+)
+    return ChainTransform(vcat(tc2.transforms, tc1.transforms))
+end
 Base.:∘(tc::ChainTransform, t::Transform) = ChainTransform(vcat(t, tc.transforms))
 
+        $M.$op(k1::Kernel, k2::Kernel) = $T(k1, k2)
+
+        $M.$op(k1::$T, k2::$T) = $T(k1.kernels..., k2.kernels...)
+        function $M.$op(
+            k1::$T{<:AbstractVector{<:Kernel}}, k2::$T{<:AbstractVector{<:Kernel}}
+        )
+            return $T(vcat(k1.kernels, k2.kernels))
+        end
+
+        $M.$op(k::Kernel, ks::$T) = $T(k, ks.kernels...)
+        $M.$op(k::Kernel, ks::$T{<:AbstractVector{<:Kernel}}) = $T(vcat(k, ks.kernels))
+
+        $M.$op(ks::$T, k::Kernel) = $T(ks.kernels..., k)
+        $M.$op(ks::$T{<:AbstractVector{<:Kernel}}, k::Kernel) = $T(vcat(ks.kernels, k))
+
+
 (t::ChainTransform)(x) = foldl((x, t) -> t(x), t.transforms; init=x)
 
 function _map(t::ChainTransform, x::AbstractVector)

test/basekernels/gabor.jl

@@ -10,8 +10,8 @@
     k_manual = exp(-sqeuclidean(v1, v2) / (2 * k.ell^2)) * cospi(euclidean(v1, v2) / k.p)
     @test k(v1, v2) ≈ k_manual atol = 1e-5
 
-    lhs_manual = transform(SqExponentialKernel(), 1 / k.ell)(v1, v2)
-    rhs_manual = transform(CosineKernel(), 1 / k.p)(v1, v2)
+    lhs_manual = (SqExponentialKernel() ∘ ScaleTransform(1 / k.ell))(v1, v2)
+    rhs_manual = (CosineKernel() ∘ ScaleTransform(1 / k.p))(v1, v2)
     @test k(v1, v2) ≈ lhs_manual * rhs_manual atol = 1e-5
 
     k = GaborKernel()

test/deprecations.jl

@@ -0,0 +1,13 @@
+@testset "deprecations.jl" begin
+    p = rand()
+    v = rand(3)
+    M = rand(3, 3)
+    kernel = SqExponentialKernel()
+    
+    @test (@test_deprecated transform(kernel, LinearTransform(M))) ==
+        kernel ∘ LinearTransform(M)
+    @test (@test_deprecated transform(kernel ∘ ScaleTransform(p), ARDTransform(v))) ==
+        kernel ∘ ARDTransform(v) ∘ ScaleTransform(p)
+    @test (@test_deprecated transform(kernel, p)) == kernel ∘ ScaleTransform(p)
+    @test (@test_deprecated transform(kernel, v)) == kernel ∘ ARDTransform(v)
+end

test/kernels/transformedkernel.jl

@@ -10,16 +10,11 @@
     k = SqExponentialKernel()
     kt = TransformedKernel(k, ScaleTransform(s))
     ktard = TransformedKernel(k, ARDTransform(v))
-    @test kt(v1, v2) == transform(k, ScaleTransform(s))(v1, v2)
-    @test kt(v1, v2) == transform(k, s)(v1, v2)
     @test kt(v1, v2) == (k ∘ ScaleTransform(s))(v1, v2)
     @test kt(v1, v2) ≈ k(s * v1, s * v2) atol = 1e-5
-    @test ktard(v1, v2) ≈ transform(k, ARDTransform(v))(v1, v2) atol = 1e-5
     @test ktard(v1, v2) == (k ∘ ARDTransform(v))(v1, v2)
-    @test ktard(v1, v2) == transform(k, v)(v1, v2)
     @test ktard(v1, v2) == k(v .* v1, v .* v2)
-    @test transform(kt, s2)(v1, v2) ≈ kt(s2 * v1, s2 * v2)
-    @test KernelFunctions.kernel(kt) == k
+    @test (kt ∘ s2)(v1, v2) ≈ kt(s2 * v1, s2 * v2)
     @test repr(kt) == repr(k) * "\n\t- " * repr(ScaleTransform(s))
 
     TestUtils.test_interface(k, Float64)
@@ -51,15 +46,12 @@
     P = rand(3, 2)
     c = Chain(Dense(3, 2))
 
-    test_params(transform(k, s), (k, [s]))
-    test_params(transform(k, v), (k, v))
-    test_params(transform(k, LinearTransform(P)), (k, P))
-    test_params(transform(k, LinearTransform(P) ∘ ScaleTransform(s)), (k, [s], P))
-    test_params(transform(k, FunctionTransform(c)), (k, c))
+    test_params(k ∘ ScaleTransform(s), (k, [s]))
+    test_params(k ∘ ARDTransform(v), (k, v))
+    test_params(k ∘ LinearTransform(P), (k, P))
+    test_params(k ∘ (LinearTransform(P) ∘ ScaleTransform(s)), (k, [s], P))
+    test_params(k ∘ FunctionTransform(c), (k, c))
 
     @test (k ∘ (LinearTransform(P') ∘ ScaleTransform(s)))(v1, v2) ==
           ((k ∘ LinearTransform(P')) ∘ ScaleTransform(s))(v1, v2)
-    test_params(k ∘ LinearTransform(P), (P, k))
-    test_params(k ∘ LinearTransform(P) ∘ ScaleTransform(s), ([s], P, k))
-    test_params(k ∘ FunctionTransform(c), (c, k))
 end

test/runtests.jl

@@ -148,6 +148,8 @@ include("test_utils.jl")
     include("chainrules.jl")
     include("zygoterules.jl")
 
+    include("deprecations.jl")
+
     @testset "doctests" begin
         DocMeta.setdocmeta!(
             KernelFunctions,

test/transform/ardtransform.jl

@@ -42,5 +42,5 @@
     @test_throws DimensionMismatch map(t, ColVecs(randn(rng, D + 1, 3)))
 
     @test repr(t) == "ARD Transform (dims: $D)"
-    test_ADs(x -> transform(SEKernel(), exp.(x)), randn(rng, 3))
+    test_ADs(x -> SEKernel() ∘ ARDTransform(exp.(x)), randn(rng, 3))
 end

test/transform/chaintransform.jl

@@ -23,7 +23,7 @@
     # Verify printing works as expected.
     @test repr(tp ∘ tf) == "Chain of 2 transforms:\n\t - $(tf) |> $(tp)"
     test_ADs(
-        x -> transform(SEKernel(), ScaleTransform(exp(x[1])) ∘ ARDTransform(exp.(x[2:4]))),
+        x -> SEKernel() ∘ (ScaleTransform(exp(x[1])) ∘ ARDTransform(exp.(x[2:4]))),
         randn(rng, 4),
     )
 end