Improved tests considerably and corrected a lot of bugs

Author: theogf

README.md

@@ -1,4 +1,5 @@
 [![Build Status](https://travis-ci.org/theogf/KernelFunctions.jl.svg?branch=master)](https://travis-ci.org/theogf/AugmentedGaussianProcesses.jl)
+[![Coverage Status](https://coveralls.io/repos/github/theogf/KernelFunctions.jl/badge.svg?branch=master)](https://coveralls.io/github/theogf/KernelFunctions.jl?branch=master)
 [![Documentation](https://img.shields.io/badge/docs-dev-blue.svg)](https://theogf.github.io/KernelFunctions.jl/dev/)
 # KernelFunctions.jl (WIP)
 Julia Package for kernel functions for machine learning

docs/src/transform.md

@@ -1 +1,15 @@
 # Transform
+
+`Transform` is the object that takes care of transforming the input data before distances are being computed. It can be as standard as `IdentityTransform` returning the same input, can be a scalar with `ScaleTransform` multiplying the vectors by a scalar or a vector.
+There is a more general `Transform`: `FunctionTransform` that uses a function and apply it on each vector via `mapslices`.
+You can also create a pipeline of `Transform` via `TransformChain`. For example `LowRankTransform(rand(10,5))∘ScaleTransform(2.0)`.
+
+## Transforms :
+
+```@docs
+  IdentityTransform
+  ScaleTransform
+  LowRankTransform
+  FunctionTransform
+  TransformChain
+```

src/KernelFunctions.jl

@@ -2,10 +2,11 @@ module KernelFunctions
 
 export kernelmatrix, kernelmatrix!, kerneldiagmatrix, kerneldiagmatrix!, kappa
 export Kernel
+export ConstantKernel, WhiteKernel, ZeroKernel
 export SqExponentialKernel, ExponentialKernel, GammaExponentialKernel
+export ExponentiatedKernel
 export MaternKernel, Matern32Kernel, Matern52Kernel
 export LinearKernel, PolynomialKernel
-export ConstantKernel, WhiteKernel, ZeroKernel
 
 
 

src/generic.jl

@@ -4,9 +4,9 @@
 for k in [:ExponentialKernel,:SqExponentialKernel,:GammaExponentialKernel,:MaternKernel,:Matern32Kernel,:Matern52Kernel,:LinearKernel,:PolynomialKernel,:ExponentiatedKernel,:ZeroKernel,:WhiteKernel,:ConstantKernel,:RationalQuadraticKernel,:GammaRationalQuadraticKernel]
     @eval begin
         @inline (κ::$k)(d::Real) = kappa(κ,d)
-        @inline (κ::$k)(x::AbstractVector{T},y::AbstractVector{T}) where {T} = kernel(κ,evaluate(κ.(metric),x,y))
-        @inline (κ::$k)(x::AbstractMatrix{T},y::AbstractMatrix{T};obsdim::Integer=defaultobs) where {T} = kernelmatrix(κ,x,y,obsdim=obsdim)
-        @inline (κ::$k)(x::AbstractMatrix{T};obsdim::Integer=defaultobs) where {T} = kernelmatrix(κ,x,obsdim=obsdim)
+        @inline (κ::$k)(x::AbstractVector{<:Real},y::AbstractVector{<:Real}) = kappa(κ,evaluate(κ.metric,transform(κ,x),transform(κ,y)))
+        @inline (κ::$k)(X::AbstractMatrix{T},Y::AbstractMatrix{T};obsdim::Integer=defaultobs) where {T} = kernelmatrix(κ,X,Y,obsdim=obsdim)
+        @inline (κ::$k)(X::AbstractMatrix{T};obsdim::Integer=defaultobs) where {T} = kernelmatrix(κ,X,obsdim=obsdim)
     end
 end
 

src/kernels/constant.jl

@@ -8,10 +8,14 @@ struct ZeroKernel{T,Tr} <: Kernel{T,Tr}
     transform::Tr
     metric::Delta
     function ZeroKernel{T,Tr}(t::Tr) where {T,Tr<:Transform}
-        new{eltype{Tr},Tr}(t,Delta())
+        new{T,Tr}(t,Delta())
     end
 end
 
+function ZeroKernel(t::Tr=IdentityTransform()) where {Tr<:Transform}
+    ZeroKernel{eltype(Tr),Tr}(t)
+end
+
 @inline kappa(κ::ZeroKernel,d::T) where {T<:Real} = zero(T)
 
 """
@@ -30,11 +34,7 @@ struct WhiteKernel{T,Tr} <: Kernel{T,Tr}
     end
 end
 
-function WhiteKernel()
-    WhiteKernel{Float64,IdentityTransform}(IdentityTransform())
-end
-
-function WhiteKernel(t::Tr) where {Tr<:Transform}
+function WhiteKernel(t::Tr=IdentityTransform()) where {Tr<:Transform}
     WhiteKernel{eltype(Tr),Tr}(t)
 end
 

src/kernels/exponential.jl

@@ -80,7 +80,7 @@ end
 
 function GammaExponentialKernel(ρ::T₁=1.0,gamma::T₂=2.0) where {T₁<:Real,T₂<:Real}
     @check_args(GammaExponentialKernel, gamma, gamma >= zero(T₂), "gamma > 0")
-    Polynomial{T₁,ScaleTransform{T₁},T₂}(ScaleTransform(ρ),gamma)
+    GammaExponentialKernel{T₁,ScaleTransform{T₁},T₂}(ScaleTransform(ρ),gamma)
 end
 
 function GammaExponentialKernel(ρ::A,gamma::T₁=2.0) where {A<:AbstractVector{<:Real},T₁<:Real}
@@ -93,4 +93,4 @@ function GammaExponentialKernel(t::Tr,gamma::T₁=2.0) where {Tr<:Transform,T₁
     GammaExponentialKernel{eltype(Tr),Tr,T₁}(t,gamma)
 end
 
-@inline kappa(κ::GammaExponentialKernel, d²::Real) where {T} = exp(-d²^γ)
+@inline kappa(κ::GammaExponentialKernel, d²::Real) where {T} = exp(-d²^κ.γ)

src/kernels/exponentiated.jl

@@ -10,7 +10,7 @@
 struct ExponentiatedKernel{T,Tr} <: Kernel{T,Tr}
     transform::Tr
     metric::DotProduct
-    function ExponentiatedKernel{T}(transform::Tr) where {T,Tr<:Transform}
+    function ExponentiatedKernel{T,Tr}(transform::Tr) where {T,Tr<:Transform}
         return new{T,Tr}(transform,DotProduct())
     end
 end

src/transform/scaletransform.jl

@@ -1,3 +1,6 @@
+"""
+    Scale Transform
+"""
 struct ScaleTransform{T<:Union{Real,AbstractVector{<:Real}}} <: Transform
     s::T
 end
@@ -26,7 +29,7 @@ function transform(t::ScaleTransform{<:AbstractVector{<:Real}},X::AbstractMatrix
     end
     _transform(t,X,obsdim)
 end
-_transform(t::ScaleTransform{<:AbstractVector{<:Real}},x::AbstractVector{<:Real}) = t.s .* x
+transform(t::ScaleTransform{<:AbstractVector{<:Real}},x::AbstractVector{<:Real},obsdim::Int=defaultobs) = t.s .* x
 _transform(t::ScaleTransform{<:AbstractVector{<:Real}},X::AbstractMatrix{<:Real},obsdim::Int=defaultobs) = obsdim == 1 ? t.s'.*X : t.s .* X
 
 transform(t::ScaleTransform{<:Real},x::AbstractVecOrMat,obsdim::Int=defaultobs) = t.s .* x

src/transform/transform.jl

@@ -1,4 +1,4 @@
-export Transform, ScaleTransform, LowRankTransform, FunctionTransform, TransformChain
+export Transform, IdentityTransform, ScaleTransform, LowRankTransform, FunctionTransform, ChainTransform
 
 
 abstract type Transform end
@@ -7,27 +7,27 @@ include("scaletransform.jl")
 include("lowranktransform.jl")
 include("functiontransform.jl")
 
-struct TransformChain <: Transform
+struct ChainTransform <: Transform
     transforms::Vector{Transform}
 end
 
-Base.length(t::TransformChain) = length(t.transforms)
+Base.length(t::ChainTransform) = length(t.transforms)
 
-function TransformChain(v::AbstractVector{<:Transform})
-    TransformChain(v)
+function ChainTransform(v::AbstractVector{<:Transform})
+    ChainTransform(v)
 end
 
-function transform(t::TransformChain,X::T,obsdim::Int=defaultobs) where {T}
+function transform(t::ChainTransform,X::T,obsdim::Int=defaultobs) where {T}
     Xtr = copy(X)
     for tr in t.transforms
         Xtr = transform(tr,Xtr,obsdim)
     end
     return Xtr
 end
 
-Base.:∘(t₁::Transform,t₂::Transform) = TransformChain([t₂,t₁])
-Base.:∘(t::Transform,tc::TransformChain) = TransformChain(vcat(tc.transforms,t))
-Base.:∘(tc::TransformChain,t::Transform) = TransformChain(vcat(t,tc.transforms))
+Base.:∘(t₁::Transform,t₂::Transform) = ChainTransform([t₂,t₁])
+Base.:∘(t::Transform,tc::ChainTransform) = ChainTransform(vcat(tc.transforms,t))
+Base.:∘(tc::ChainTransform,t::Transform) = ChainTransform(vcat(t,tc.transforms))
 
 struct IdentityTransform <: Transform end
 

test/test_distances.jl

@@ -0,0 +1,22 @@
+using Test
+using Distances, LinearAlgebra
+using KernelFunctions
+
+A = rand(10,5)
+B = rand(20,5)
+@testset "Distance" begin
+    @testset "Dot Product" begin
+        d = KernelFunctions.DotProduct()
+        @test diag(pairwise(d,A,dims=2)) == dot.(eachcol(A),eachcol(A))
+        @test_throws DimensionMismatch d(rand(3),rand(4))
+        @test d(3.0,2.0) == 6.0
+    end
+    @testset "Delta" begin
+        d = KernelFunctions.Delta()
+        @test pairwise(d,A,dims=1) == Matrix(I,size(A,1),size(A,1))
+        @test pairwise(d,A,B,dims=1) == zeros(size(A,1),size(B,1))
+        @test d(1,2) == 0
+        @test d(1,1) == 1
+        @test_throws DimensionMismatch d(rand(3),rand(4))
+    end
+end

test/test_kernelmatrix.jl

@@ -8,25 +8,19 @@ A = rand(dims...)
 B = rand(dims...)
 K = [zeros(dims[1],dims[1]),zeros(dims[2],dims[2])]
 Kdiag = [zeros(dims[1]),zeros(dims[2])]
-kernels = [SqExponentialKernel(),MaternKernel(),Matern32Kernel(),Matern52Kernel()]
+k = SqExponentialKernel()
 @testset "Inplace Kernel Matrix" begin
-    for k in kernels
-        @testset "$k" begin
-            for obsdim in [1,2]
-                @test kernelmatrix!(K[obsdim],k,A,B,obsdim=obsdim) == kernelmatrix(k,A,B,obsdim=obsdim)
-                @test kerneldiagmatrix!(Kdiag[obsdim],k,A,obsdim=obsdim) == kerneldiagmatrix(k,A,obsdim=obsdim)
-            end
-        end
+    for obsdim in [1,2]
+        @test kernelmatrix!(K[obsdim],k,A,B,obsdim=obsdim) == kernelmatrix(k,A,B,obsdim=obsdim)
+        @test kerneldiagmatrix!(Kdiag[obsdim],k,A,obsdim=obsdim) == kerneldiagmatrix(k,A,obsdim=obsdim)
     end
 end
 
 @testset "Kernel matrix" begin
-    for k in kernels
-        @testset "$k" begin
-            for obsdim in [1,2]
-                @test kernelmatrix(k,A,B,obsdim=obsdim) == kappa.([k],pairwise(KernelFunctions.metric(k),A,B,dims=obsdim))
-                @test kernelmatrix(k,A,obsdim=obsdim) == kappa.([k],pairwise(KernelFunctions.metric(k),A,dims=obsdim))
-            end
-        end
+    for obsdim in [1,2]
+        @test kernelmatrix(k,A,B,obsdim=obsdim) == kappa.([k],pairwise(KernelFunctions.metric(k),A,B,dims=obsdim))
+        @test kernelmatrix(k,A,obsdim=obsdim) == kappa.([k],pairwise(KernelFunctions.metric(k),A,dims=obsdim))
+        @test k(A,B,obsdim=obsdim) == kernelmatrix(k,A,B,obsdim=obsdim)
+        @test k(A,obsdim=obsdim) == kernelmatrix(k,A,obsdim=obsdim)
     end
 end

test/test_kernels.jl

@@ -0,0 +1,128 @@
+using Test
+using LinearAlgebra
+using KernelFunctions
+using SpecialFunctions
+
+x = rand()*2; v1 = rand(3); v2 = rand(3)
+@testset "Kappa functions of kernels" begin
+    @testset "Constant" begin
+        @testset "ZeroKernel" begin
+            k = ZeroKernel()
+            @test eltype(k) == Any
+            @test kappa(k,2.0) == 0.0
+        end
+        @testset "WhiteKernel" begin
+            k = WhiteKernel()
+            @test eltype(k) == Any
+            @test kappa(k,1.0) == 1.0
+            @test kappa(k,0.0) == 0.0
+        end
+        @testset "ConstantKernel" begin
+            c = 2.0
+            k = ConstantKernel(c)
+            k₂ = ConstantKernel(IdentityTransform(),c)
+            @test eltype(k) == Any
+            @test kappa(k,1.5)== kappa(k₂,1.5)
+            @test kappa(k,1.0) == c
+            @test kappa(k,0.5) == c
+        end
+    end
+    @testset "Exponential" begin
+        @testset "SqExponentialKernel" begin
+            k = SqExponentialKernel()
+            @test kappa(k,x) ≈ exp(-x)
+            @test k(v1,v2) ≈ exp(-norm(v1-v2)^2)
+            l = 0.5
+            k = SqExponentialKernel(l)
+            @test k(v1,v2) ≈ exp(-l^2*norm(v1-v2)^2)
+            v = rand(3)
+            k = SqExponentialKernel(v)
+            @test k(v1,v2) ≈ exp(-norm(v.*(v1-v2))^2)
+        end
+        @testset "ExponentialKernel" begin
+            k = ExponentialKernel()
+            @test kappa(k,x) ≈ exp(-x)
+            @test k(v1,v2) ≈ exp(-norm(v1-v2))
+            l = 0.5
+            k = ExponentialKernel(l)
+            @test k(v1,v2) ≈ exp(-l*norm(v1-v2))
+            v = rand(3)
+            k = ExponentialKernel(v)
+            @test k(v1,v2) ≈ exp(-norm(v.*(v1-v2)))
+        end
+        @testset "GammaExponentialKernel" begin
+            k = GammaExponentialKernel(1.0,2.0)
+            @test kappa(k,x) ≈ exp(-(x)^(k.γ))
+            @test k(v1,v2) ≈ exp(-norm(v1-v2)^(2k.γ))
+            l = 0.5
+            k = GammaExponentialKernel(l,1.5)
+            @test k(v1,v2) ≈ exp(-l^(3.0)*norm(v1-v2)^(3.0))
+            v = rand(3)
+            k = GammaExponentialKernel(v,3.0)
+            @test k(v1,v2) ≈ exp(-norm(v.*(v1-v2)).^6.0)
+        end
+    end
+    @testset "Exponentiated" begin
+        @testset "ExponentiatedKernel" begin
+            k = ExponentiatedKernel()
+            @test kappa(k,x) ≈ exp(x)
+            @test kappa(k,-x) ≈ exp(-x)
+            @test k(v1,v2) ≈ exp(dot(v1,v2))
+            l = 0.5
+            k = ExponentiatedKernel(l)
+            @test k(v1,v2) ≈ exp(l^2*dot(v1,v2))
+            v = rand(3)
+            k = ExponentiatedKernel(v)
+            @test k(v1,v2) ≈ exp(dot(v.*v1,v.*v2))
+        end
+    end
+    @testset "Matern" begin
+        @testset "MaternKernel" begin
+            ν = 2.0
+            k = MaternKernel(1.0,ν)
+            matern(x,ν) = 2^(1-ν)/gamma(ν)*(sqrt(2ν)*x)^ν*besselk(ν,sqrt(2ν)*x)
+            @test kappa(k,x) ≈ matern(x,ν)
+            @test kappa(k,0.0) == 1.0
+            l = 0.5; ν = 3.0
+            k = MaternKernel(l,ν)
+            @test k(v1,v2) ≈ matern(l*norm(v1-v2),ν)
+            v = rand(3); ν = 2.1
+            k = MaternKernel(v,ν)
+            @test k(v1,v2) ≈ matern(norm(v.*(v1-v2)),ν)
+        end
+        @testset "Matern32Kernel" begin
+            k = Matern32Kernel()
+            @test kappa(k,x) ≈ (1+sqrt(3)*x)exp(-sqrt(3)*x)
+            @test k(v1,v2) ≈ (1+sqrt(3)*norm(v1-v2))exp(-sqrt(3)*norm(v1-v2))
+            l = 0.5
+            k = Matern32Kernel(l)
+            @test k(v1,v2) ≈ (1+l*sqrt(3)*norm(v1-v2))exp(-l*sqrt(3)*norm(v1-v2))
+            v = rand(3)
+            k = Matern32Kernel(v)
+            @test k(v1,v2) ≈ (1+sqrt(3)*norm(v.*(v1-v2)))exp(-sqrt(3)*norm(v.*(v1-v2)))
+        end
+        @testset "Matern52Kernel" begin
+            k = Matern52Kernel()
+            @test kappa(k,x) ≈ (1+sqrt(5)*x+5/3*x^2)exp(-sqrt(5)*x)
+            @test k(v1,v2) ≈ (1+sqrt(5)*norm(v1-v2)+5/3*norm(v1-v2)^2)exp(-sqrt(5)*norm(v1-v2))
+            l = 0.5
+            k = Matern52Kernel(l)
+            @test k(v1,v2) ≈ (1+l*sqrt(5)*norm(v1-v2)+l^2*5/3*norm(v1-v2)^2)exp(-l*sqrt(5)*norm(v1-v2))
+            v = rand(3)
+            k = Matern52Kernel(v)
+            @test k(v1,v2) ≈ (1+sqrt(5)*norm(v.*(v1-v2))+5/3*norm(v.*(v1-v2))^2)exp(-sqrt(5)*norm(v.*(v1-v2)))
+        end
+        @testset "Coherence Materns" begin
+            x = 0.5
+            @test kappa(MaternKernel(1.0,0.5),x) ≈ kappa(ExponentialKernel(),x)
+            @test kappa(MaternKernel(1.0,1.5),x) ≈ kappa(Matern32Kernel(),x)
+            @test kappa(MaternKernel(1.0,2.5),x) ≈ kappa(Matern52Kernel(),x)
+        end
+    end
+    @testset "Polynomial" begin
+        c = randn();
+
+    end
+    @testset "RationalQuadratic" begin
+    end
+end

test/test_transform.jl

@@ -29,4 +29,4 @@ KernelFunctions.transform(tf,X,1)
 tchain = TransformChain([t,tp,tf])
 t∘tp∘tf
 TransformChain([t,tp])
-@test all(KernelFunctions.transform(tchain,X).==f(P*(s*X)))
+@test all(KernelFunctions.transform(tchain,X,2).==f(P*(s*X)))