Merge pull request #106 from devmotion/lineartransform

Use LinearTransform instead of LowRankTransform

Author: theogf

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}
+    size(t.A) == size(A) ||
+        error("size of the given matrix ", size(A), " and of 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
+
+Base.map(t::LinearTransform, x::AbstractVector{<:Real}) = ColVecs(t.A * x')
+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

@@ -56,7 +56,7 @@ using KernelFunctions: metric, kappa
         include(joinpath("transform", "transform.jl"))
         include(joinpath("transform", "scaletransform.jl"))
         include(joinpath("transform", "ardtransform.jl"))
-        include(joinpath("transform", "lowranktransform.jl"))
+        include(joinpath("transform", "lineartransform.jl"))
         include(joinpath("transform", "functiontransform.jl"))
         include(joinpath("transform", "selecttransform.jl"))
         include(joinpath("transform", "chaintransform.jl"))

test/runtests.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)

test/transform/chaintransform.jl

@@ -1,9 +1,9 @@
-@testset "lowranktransform" begin
+@testset "lineartransform" begin
     rng = MersenneTwister(123546)
 
     @testset "Real inputs" begin
         P = randn(rng, 3, 1)
-        t = LowRankTransform(P)
+        t = LinearTransform(P)
 
         x = randn(rng, 4)
         x′ = map(t, x)
@@ -16,7 +16,7 @@
         Din = 3
         Dout = 4
         P = randn(rng, Dout, Din)
-        t = LowRankTransform(P)
+        t = LinearTransform(P)
 
         x_cols = ColVecs(randn(rng, Din, 8))
         x_rows = RowVecs(randn(rng, 9, Din))
@@ -31,14 +31,14 @@
     Din = 2
     Dout = 5
     P = randn(rng, Dout, Din)
-    t = LowRankTransform(P)
+    t = LinearTransform(P)
 
     P2 = randn(rng, Dout, Din)
     KernelFunctions.set!(t, P2)
-    @test t.proj == P2
-    @test_throws AssertionError KernelFunctions.set!(t, rand(rng, Din + 1, Dout))
+    @test t.A == P2
+    @test_throws ErrorException KernelFunctions.set!(t, rand(rng, Din + 1, Dout))
 
     @test_throws DimensionMismatch map(t, ColVecs(randn(rng, Din + 1, Dout)))
 
-    @test repr(t) == "Low Rank Transform (size(P) = ($Dout, $Din))"
+    @test repr(t) == "Linear transform (size(A) = ($Dout, $Din))"
 end