Use LinearTransform instead of LowRankTransform

Author: devmotion

docs/create_kernel_plots.jl

@@ -23,7 +23,7 @@ p = heatmap(K2,yflip=true,colorbar=false,framestyle=:none,background_color=RGBA(
 savefig(joinpath(@__DIR__,"src","assets","heatmap_matern.png"))
 
 
-k = transform(PolynomialKernel(c=0.0,d=2.0),LowRankTransform(randn(3,1)))
+k = transform(PolynomialKernel(c=0.0,d=2.0), LinearTransform(randn(3,1)))
 K3 = kernelmatrix(k,xrange,obsdim=1)
 p = heatmap(K3,yflip=true,colorbar=false,framestyle=:none,background_color=RGBA(0.0,0.0,0.0,0.0))
 savefig(joinpath(@__DIR__,"src","assets","heatmap_poly.png"))

src/KernelFunctions.jl

@@ -23,7 +23,8 @@ export KernelSum, KernelProduct
 export TransformedKernel, ScaledKernel
 export TensorProduct
 
-export Transform, SelectTransform, ChainTransform, ScaleTransform, LowRankTransform, IdentityTransform, FunctionTransform
+export Transform, SelectTransform, ChainTransform, ScaleTransform, LinearTransform,
+    ARDTransform, IdentityTransform, FunctionTransform
 
 export NystromFact, nystrom
 

src/trainable.jl

@@ -42,6 +42,6 @@ trainable(t::ChainTransform) = t.transforms
 
 trainable(t::FunctionTransform) = (t.f,)
 
-trainable(t::LowRankTransform) = (t.proj,)
+trainable(t::LinearTransform) = (t.A,)
 
 trainable(t::ScaleTransform) = (t.s,)

src/transform/chaintransform.jl

@@ -4,7 +4,7 @@
 Chain a series of transform, here `t1` will be called first
 ```
     t1 = ScaleTransform()
-    t2 = LowRankTransform(rand(3,4))
+    t2 = LinearTransform(rand(3,4))
     ct = ChainTransform([t1,t2]) #t1 will be called first
     ct == t2 ∘ t1
 ```

src/transform/lineartransform.jl

@@ -0,0 +1,36 @@
+"""
+    LinearTransform(A::AbstractMatrix)
+
+Apply the linear transformation realised by the matrix `A`.
+
+The second dimension of `A` must match the number of features of the target.
+
+# Examples
+
+```julia-repl
+julia> A = rand(10, 5)
+
+julia> tr = LinearTransform(A)
+```
+"""
+struct LinearTransform{T<:AbstractMatrix{<:Real}} <: Transform
+    A::T
+end
+
+function set!(t::LinearTransform{<:AbstractMatrix{T}}, A::AbstractMatrix{T}) where {T<:Real}
+    @assert size(t.A) == size(A) "Size of the given matrix $(size(A)) and the transformation matrix $(size(t.A)) are not the same"
+    t.A .= A
+end
+
+(t::LinearTransform)(x::Real) = vec(t.A * x)
+(t::LinearTransform)(x::AbstractVector{<:Real}) = t.A * x
+
+function Base.map(t::LinearTransform, x::AbstractVector{<:Real})
+    return ColVecs(t.A * x')
+end
+Base.map(t::LinearTransform, x::ColVecs) = ColVecs(t.A * x.X)
+Base.map(t::LinearTransform, x::RowVecs) = RowVecs(x.X * t.A')
+
+function Base.show(io::IO, t::LinearTransform)
+    print(io::IO, "Linear transform (size(A) = ", size(t.A), ")")
+end

src/transform/lowranktransform.jl

@@ -1,8 +1,6 @@
-export Transform, IdentityTransform, ScaleTransform, ARDTransform, LowRankTransform, FunctionTransform, ChainTransform
-
 include("scaletransform.jl")
 include("ardtransform.jl")
-include("lowranktransform.jl")
+include("lineartransform.jl")
 include("functiontransform.jl")
 include("selecttransform.jl")
 include("chaintransform.jl")

src/transform/transform.jl

@@ -45,10 +45,10 @@ end
             transform_AD(Val(Symbol($AD)),ScaleTransform(l),A)
             # ARD Transform
             transform_AD(Val(Symbol($AD)),ARDTransform(vl),A)
-            # LowRankTransform
-            transform_AD(Val(Symbol($AD)),LowRankTransform(rand(2,10)),A)
+            # Linear transform
+            transform_AD(Val(Symbol($AD)), LinearTransform(rand(2,10)),A)
             # Chain Transform
-            # transform_AD(Val(Symbol($AD)),LowRankTransform,A)
+            # transform_AD(Val(Symbol($AD)), LinearTransform, A)
             end
         end
     end

test/test_AD.jl

@@ -44,10 +44,10 @@
     @test all(params(k) .== params(v, kc))
 
     P = rand(3, 2)
-    k = transform(km,LowRankTransform(P))
+    k = transform(km, LinearTransform(P))
     @test all(params(k) .== params(P, km))
 
-    k = transform(km, LowRankTransform(P) ∘ ScaleTransform(s))
+    k = transform(km, LinearTransform(P) ∘ ScaleTransform(s))
     @test all(params(k) .== params([s], P, km))
 
     c = Chain(Dense(3, 2))

test/trainable.jl

@@ -2,7 +2,7 @@
     rng = MersenneTwister(123546)
 
     P = rand(rng, 3, 2)
-    tp = LowRankTransform(P)
+    tp = LinearTransform(P)
 
     f(x) = sin.(x)
     tf = FunctionTransform(f)