Merge pull request JuliaGaussianProcesses#85 from theogf/format_and_tests

Improved docs, printing and testing

Author: theogf

src/KernelFunctions.jl

@@ -10,7 +10,8 @@ export duplicate, set! # Helpers
 
 export Kernel
 export ConstantKernel, WhiteKernel, EyeKernel, ZeroKernel
-export SqExponentialKernel, ExponentialKernel, GammaExponentialKernel
+export SqExponentialKernel, RBFKernel, GaussianKernel, SEKernel
+export LaplacianKernel, ExponentialKernel, GammaExponentialKernel
 export ExponentiatedKernel
 export MaternKernel, Matern32Kernel, Matern52Kernel
 export LinearKernel, PolynomialKernel

src/basekernels/constant.jl

@@ -59,4 +59,4 @@ kappa(κ::ConstantKernel,x::Real) = first(κ.c)*one(x)
 
 metric(::ConstantKernel) = Delta()
 
-Base.show(io::IO, κ::ConstantKernel) = print(io, "Constant Kernel (c = $(first(κ.c)))")
+Base.show(io::IO, κ::ConstantKernel) = print(io, "Constant Kernel (c = ", first(κ.c), ")")

src/basekernels/exponential.jl

@@ -63,4 +63,4 @@ kappa(κ::GammaExponentialKernel, d²::Real) = exp(-d²^first(κ.γ))
 iskroncompatible(::GammaExponentialKernel) = true
 metric(::GammaExponentialKernel) = SqEuclidean()
 
-Base.show(io::IO, κ::GammaExponentialKernel) = print(io, "Gamma Exponential Kernel (γ = $(first(κ.γ)))")
+Base.show(io::IO, κ::GammaExponentialKernel) = print(io, "Gamma Exponential Kernel (γ = ", first(κ.γ), ")")

src/basekernels/fbm.jl

@@ -17,7 +17,7 @@ struct FBMKernel{T<:Real} <: BaseKernel
     end
 end
 
-Base.show(io::IO, κ::FBMKernel) = print(io, "Fractional Brownian Motion Kernel (h = $(first(k.h)))")
+Base.show(io::IO, κ::FBMKernel) = print(io, "Fractional Brownian Motion Kernel (h = ", first(κ.h), ")")
 
 const sqroundoff = 1e-15
 

src/basekernels/gabor.jl

@@ -30,7 +30,7 @@ function _gabor(; ell = nothing, p = nothing)
 end
 
 function Base.getproperty(k::GaborKernel, v::Symbol)
-    if v == :kernel 
+    if v == :kernel
         return getfield(k, v)
     elseif v == :ell
         kernel1 = k.kernel.kernels[1]
@@ -51,7 +51,7 @@ function Base.getproperty(k::GaborKernel, v::Symbol)
     end
 end
 
-Base.show(io::IO, κ::GaborKernel) = print(io, "Gabor Kernel (ell = $(κ.ell), p = $(κ.p))")
+Base.show(io::IO, κ::GaborKernel) = print(io, "Gabor Kernel (ell = ", κ.ell, ", p = ", κ.p, ")")
 
 kappa(κ::GaborKernel, x, y) = kappa(κ.kernel, x ,y)
 

src/basekernels/maha.jl

@@ -19,4 +19,4 @@ end
 kappa(κ::MahalanobisKernel, d::T) where {T<:Real} = exp(-d)
 metric(κ::MahalanobisKernel) = SqMahalanobis(κ.P)
 
-Base.show(io::IO, κ::MahalanobisKernel) = print(io, "Mahalanobis Kernel (size(P) = $(size(κ.P))")
+Base.show(io::IO, κ::MahalanobisKernel) = print(io, "Mahalanobis Kernel (size(P) = ", size(κ.P), ")")

src/basekernels/matern.jl

@@ -27,7 +27,7 @@ end
 
 metric(::MaternKernel) = Euclidean()
 
-Base.show(io::IO, κ::MaternKernel) = print(io, "Matern Kernel (ν = $(first(κ.ν)))")
+Base.show(io::IO, κ::MaternKernel) = print(io, "Matern Kernel (ν = ", first(κ.ν), ")")
 
 """
     Matern32Kernel()

src/basekernels/periodic.jl

@@ -24,4 +24,4 @@ metric(κ::PeriodicKernel) = Sinus(κ.r)
 
 kappa(κ::PeriodicKernel, d::Real) = exp(- 0.5d)
 
-Base.show(io::IO, κ::PeriodicKernel) = print(io, "Periodic Kernel, length(r) = $(length(κ.r))")
+Base.show(io::IO, κ::PeriodicKernel) = print(io, "Periodic Kernel, length(r) = ", length(κ.r), ")")

src/basekernels/piecewisepolynomial.jl

@@ -105,5 +105,5 @@ end
 metric(κ::PiecewisePolynomialKernel) = Mahalanobis(κ.maha)
 
 function Base.show(io::IO, κ::PiecewisePolynomialKernel{V}) where {V}
-    print(io, "Piecewise Polynomial Kernel (v = $(V), size(maha) = $(size(κ.maha))")
+    print(io, "Piecewise Polynomial Kernel (v = ", V, ", size(maha) = ", size(κ.maha), ")")
 end

src/basekernels/polynomial.jl

@@ -17,7 +17,7 @@ end
 kappa(κ::LinearKernel, xᵀy::Real) = xᵀy + first(κ.c)
 metric(::LinearKernel) = DotProduct()
 
-Base.show(io::IO, κ::LinearKernel) = print(io, "Linear Kernel (c = $(first(κ.c)))")
+Base.show(io::IO, κ::LinearKernel) = print(io, "Linear Kernel (c = ", first(κ.c), ")")
 
 """
     PolynomialKernel(; d = 2.0, c = 0.0)
@@ -40,4 +40,4 @@ end
 kappa(κ::PolynomialKernel, xᵀy::T) where {T<:Real} = (xᵀy + first(κ.c))^(first(κ.d))
 metric(::PolynomialKernel) = DotProduct()
 
-Base.show(io::IO, κ::PolynomialKernel) = print(io, "Polynomial Kernel (c = $(first(κ.c)), d = $(first(κ.d)))")
+Base.show(io::IO, κ::PolynomialKernel) = print(io, "Polynomial Kernel (c = ", first(κ.c), ", d = ", first(κ.d), ")")

src/basekernels/rationalquad.jl

@@ -18,7 +18,7 @@ end
 kappa(κ::RationalQuadraticKernel, d²::T) where {T<:Real} = (one(T)+d²/first(κ.α))^(-first(κ.α))
 metric(::RationalQuadraticKernel) = SqEuclidean()
 
-Base.show(io::IO, κ::RationalQuadraticKernel) = print(io, "Rational Quadratic Kernel (α = $(first(κ.α)))")
+Base.show(io::IO, κ::RationalQuadraticKernel) = print(io, "Rational Quadratic Kernel (α = ", first(κ.α), ")")
 
 """
 `GammaRationalQuadraticKernel([ρ=1.0[,α=2.0[,γ=2.0]]])`
@@ -41,4 +41,4 @@ end
 kappa(κ::GammaRationalQuadraticKernel, d²::T) where {T<:Real} = (one(T)+d²^first(κ.γ)/first(κ.α))^(-first(κ.α))
 metric(::GammaRationalQuadraticKernel) = SqEuclidean()
 
-Base.show(io::IO, κ::GammaRationalQuadraticKernel) = print(io, "Gamma Rational Quadratic Kernel (α = $(first(κ.α)), γ = $(first(κ.γ)))")
+Base.show(io::IO, κ::GammaRationalQuadraticKernel) = print(io, "Gamma Rational Quadratic Kernel (α = ", first(κ.α), ", γ = ", first(κ.γ), ")")

src/generic.jl

@@ -11,8 +11,8 @@ _scale(t::ScaleTransform, metric::Euclidean, x, y) =  first(t.s) * evaluate(metr
 _scale(t::ScaleTransform, metric::Union{SqEuclidean,DotProduct}, x, y) =  first(t.s)^2 * evaluate(metric, x, y)
 _scale(t::ScaleTransform, metric, x, y) = evaluate(metric, apply(t, x), apply(t, y))
 
-printshifted(io::IO,κ::Kernel,shift::Int) = print(io,"$κ")
-Base.show(io::IO,κ::Kernel) = print(io,nameof(typeof(κ)))
+printshifted(io::IO, o, shift::Int) = print(io, o)
+Base.show(io::IO, κ::Kernel) = print(io, nameof(typeof(κ)))
 
 ### Syntactic sugar for creating matrices and using kernel functions
 function concretetypes(k, ktypes::Vector)

src/transform/ardtransform.jl

@@ -1,39 +1,52 @@
 """
-ARD Transform
+    ARDTransform(v::AbstractVector)
+    ARDTransform(s::Real, dims::Int)
+
+Multiply every vector of observation by `v` element-wise
 ```
     v = rand(3)
     tr = ARDTransform(v)
 ```
-Multiply every vector of observation by `v` element-wise
 """
 struct ARDTransform{T,N} <: Transform
     v::Vector{T}
 end
 
-function ARDTransform(s::T,dims::Integer) where {T<:Real}
+function ARDTransform(s::T, dims::Integer) where {T<:Real}
     @check_args(ARDTransform, s, s > zero(T), "s > 0")
-    ARDTransform{T,dims}(fill(s,dims))
+    ARDTransform{T,dims}(fill(s, dims))
 end
 
 function ARDTransform(v::AbstractVector{T}) where {T<:Real}
-    @check_args(ARDTransform, v, all(v.>zero(T)), "v > 0")
+    @check_args(ARDTransform, v, all(v .> zero(T)), "v > 0")
     ARDTransform{T,length(v)}(v)
 end
 
-function set!(t::ARDTransform{T},ρ::AbstractVector{T}) where {T<:Real}
+function set!(t::ARDTransform{T}, ρ::AbstractVector{T}) where {T<:Real}
     @assert length(ρ) == dim(t) "Trying to set a vector of size $(length(ρ)) to ARDTransform of dimension $(dim(t))"
     t.v .= ρ
 end
 
 dim(t::ARDTransform) = length(t.v)
 
-function apply(t::ARDTransform,X::AbstractMatrix{<:Real};obsdim::Int = defaultobs)
-    @boundscheck if dim(t) != size(X,feature_dim(obsdim))
+function apply(
+    t::ARDTransform,
+    X::AbstractMatrix{<:Real};
+    obsdim::Int = defaultobs,
+)
+    @boundscheck if dim(t) != size(X, feature_dim(obsdim))
         throw(DimensionMismatch("Array has size $(size(X,!Bool(obsdim-1)+1)) on dimension $(!Bool(obsdim-1)+1)) which does not match the length of the scale transform length , $(dim(t)).")) #TODO Add test
     end
-    _transform(t,X,obsdim)
+    _transform(t, X, obsdim)
 end
-apply(t::ARDTransform,x::AbstractVector{<:Real};obsdim::Int=defaultobs) = t.v .* x
-_transform(t::ARDTransform,X::AbstractMatrix{<:Real},obsdim::Int=defaultobs) = obsdim == 1 ? t.v'.*X : t.v .* X
+apply(t::ARDTransform, x::AbstractVector{<:Real}; obsdim::Int = defaultobs) =  t.v .* x
+_transform(
+    t::ARDTransform,
+    X::AbstractMatrix{<:Real},
+    obsdim::Int = defaultobs,
+) = obsdim == 1 ? t.v' .* X : t.v .* X
+
+Base.isequal(t::ARDTransform, t2::ARDTransform) = isequal(t.v, t2.v)
 
-Base.isequal(t::ARDTransform,t2::ARDTransform) = isequal(t.v,t2.v)
+Base.show(io::IO, t::ARDTransform) =
+    print(io, "ARD Transform (dims: ", dim(t),")")

src/transform/chaintransform.jl

@@ -1,22 +1,20 @@
 """
+    ChainTransform(ts::AbstractVector{<:Transform})
+
 Chain a series of transform, here `t1` will be called first
 ```
     t1 = ScaleTransform()
     t2 = LowRankTransform(rand(3,4))
     ct = ChainTransform([t1,t2]) #t1 will be called first
-    ct == t2∘t1
+    ct == t2 ∘ t1
 ```
 """
-struct ChainTransform <: Transform
-    transforms::Vector{Transform}
+struct ChainTransform{V<:AbstractVector{<:Transform}} <: Transform
+    transforms::V
 end
 
 Base.length(t::ChainTransform) = length(t.transforms) #TODO Add test
 
-function ChainTransform(v::AbstractVector{<:Transform})
-    ChainTransform(v)
-end
-
 ## Constructor to create a chain transform with an array of parameters
 function ChainTransform(v::AbstractVector{<:Type{<:Transform}},θ::AbstractVector)
     @assert length(v) == length(θ)
@@ -34,6 +32,23 @@ end
 set!(t::ChainTransform,θ) = set!.(t.transforms,θ)
 duplicate(t::ChainTransform,θ) = ChainTransform(duplicate.(t.transforms,θ))
 
-Base.:∘(t₁::Transform,t₂::Transform) = ChainTransform([t₂,t₁])
-Base.:∘(t::Transform,tc::ChainTransform) = ChainTransform(vcat(tc.transforms,t)) #TODO add test
-Base.:∘(tc::ChainTransform,t::Transform) = ChainTransform(vcat(t,tc.transforms))
+Base.:∘(t₁::Transform, t₂::Transform) = ChainTransform([t₂, t₁])
+Base.:∘(t::Transform, tc::ChainTransform) =
+    ChainTransform(vcat(tc.transforms, t)) #TODO add test
+Base.:∘(tc::ChainTransform, t::Transform) =
+    ChainTransform(vcat(t, tc.transforms))
+
+Base.show(io::IO, t::ChainTransform) = printshifted(io, t, 0)
+
+function printshifted(io::IO, t::ChainTransform, shift::Int)
+    println(io, "Chain of ", length(t), " transforms:")
+    for _ in 1:(shift + 1)
+        print(io, "\t")
+    end
+    print(io, " - ")
+    printshifted(io, t.transforms[1], shift + 2)
+    for i in 2:length(t)
+        print(io, " |> ")
+        printshifted(io, t.transforms[i], shift + 2)
+    end
+end

src/transform/functiontransform.jl

@@ -1,12 +1,13 @@
 """
-FunctionTransform
+    FunctionTransform(f)
+
+Take a function or object `f` as an argument which is going to act on each vector individually.
+Make sure that `f` is supposed to act on a vector.
+For example replace `f(x)=sin(x)` by `f(x)=sin.(x)`
 ```
     f(x) = abs.(x)
     tr = FunctionTransform(f)
 ```
-Take a function or object `f` as an argument which is going to act on each vector individually.
-Make sure that `f` is supposed to act on a vector by eventually using broadcasting
-For example `f(x)=sin(x)` -> `f(x)=sin.(x)`
 """
 struct FunctionTransform{F} <: Transform
     f::F
@@ -15,3 +16,5 @@ end
 apply(t::FunctionTransform, X::T; obsdim::Int = defaultobs) where {T} = mapslices(t.f, X, dims = feature_dim(obsdim))
 
 duplicate(t::FunctionTransform,f) = FunctionTransform(f)
+
+Base.show(io::IO, t::FunctionTransform) = print(io, "Function Transform: ", t.f)

src/transform/lowranktransform.jl

@@ -1,11 +1,12 @@
 """
-LowRankTransform
+    LowRankTransform(P::AbstractMatrix)
+
+Apply the low-rank projection realised by the matrix `P`
+The second dimension of `P` must match the number of features of the target.
 ```
     P = rand(10,5)
     tr = LowRankTransform(P)
 ```
-Apply the low-rank projection realised by the matrix `P`
-The second dimension of `P` must match the number of features of the target.
 """
 struct LowRankTransform{T<:AbstractMatrix{<:Real}} <: Transform
     proj::T
@@ -32,3 +33,5 @@ function apply(t::LowRankTransform, x::AbstractVector{<:Real}; obsdim::Int = def
 end
 
 _transform(t::LowRankTransform,X::AbstractVecOrMat{<:Real},obsdim::Int=defaultobs) = obsdim == 2 ? t.proj * X : X * t.proj'
+
+Base.show(io::IO, t::LowRankTransform) = print(io::IO, "Low Rank Transform (size(P) = ", size(t.proj), ")")

src/transform/scaletransform.jl

@@ -1,10 +1,11 @@
 """
-Scale Transform
+    ScaleTransform(l::Real)
+
+Multiply every element of the input by `l`
 ```
     l = 2.0
     tr = ScaleTransform(l)
 ```
-Multiply every element of the input by `l`
 """
 struct ScaleTransform{T<:Real} <: Transform
     s::Vector{T}
@@ -22,4 +23,4 @@ apply(t::ScaleTransform,x::AbstractVecOrMat;obsdim::Int=defaultobs) = first(t.s)
 
 Base.isequal(t::ScaleTransform,t2::ScaleTransform) = isequal(first(t.s),first(t2.s))
 
-Base.show(io::IO,t::ScaleTransform) = print(io,"Scale Transform s=$(first(t.s))")
+Base.show(io::IO,t::ScaleTransform) = print(io,"Scale Transform (s = ", first(t.s), ")")

src/transform/selecttransform.jl

@@ -1,12 +1,13 @@
 """
-SelectTransform
+    SelectTransform(dims::AbstractVector{Int})
+
+Select the dimensions `dims` that the kernel is applied to.
 ```
     dims = [1,3,5,6,7]
     tr = SelectTransform(dims)
     X = rand(100,10)
     transform(tr,X,obsdim=2) == X[dims,:]
 ```
-Select the dimensions `dims` that the kernel is applied to.
 """
 struct SelectTransform{T<:AbstractVector{<:Int}} <: Transform
     select::T
@@ -38,3 +39,5 @@ function apply(t::SelectTransform, x::AbstractVector{<:Real}; obsdim::Int = defa
 end
 
 _transform(t::SelectTransform,X::AbstractMatrix{<:Real},obsdim::Int=defaultobs) = obsdim == 2 ? view(X,t.select,:) : view(X,:,t.select)
+
+Base.show(io::IO, t::SelectTransform) = print(io, "Select Transform (dims: ", t.select, ")")

src/transform/transform.jl

@@ -8,13 +8,15 @@ include("selecttransform.jl")
 include("chaintransform.jl")
 
 """
-`apply(t::Transform, x; obsdim::Int=defaultobs)`
-Apply the transform `t` per slice on the array `x`
+    apply(t::Transform, x; obsdim::Int=defaultobs)
+
+Apply the transform `t` vector-wise on the array `x`
 """
 apply
 
 """
-IdentityTransform
+    IdentityTransform()
+
 Return exactly the input
 """
 struct IdentityTransform <: Transform end

test/basekernels/constant.jl

@@ -4,6 +4,7 @@
         @test eltype(k) == Any
         @test kappa(k,2.0) == 0.0
         @test KernelFunctions.metric(ZeroKernel()) == KernelFunctions.Delta()
+        @test repr(k) == "Zero Kernel"
     end
     @testset "WhiteKernel" begin
         k = WhiteKernel()
@@ -12,6 +13,7 @@
         @test kappa(k,0.0) == 0.0
         @test EyeKernel == WhiteKernel
         @test metric(WhiteKernel()) == KernelFunctions.Delta()
+        @test repr(k) == "White Kernel"
     end
     @testset "ConstantKernel" begin
         c = 2.0
@@ -21,5 +23,6 @@
         @test kappa(k,0.5) == c
         @test metric(ConstantKernel()) == KernelFunctions.Delta()
         @test metric(ConstantKernel(c=2.0)) == KernelFunctions.Delta()
+        @test repr(k) == "Constant Kernel (c = $(c))"
     end
 end

test/basekernels/cosine.jl

@@ -11,4 +11,5 @@
     @test kappa(k, 1.5) ≈ 0.0 atol=1e-5
     @test kappa(k,x) ≈ cospi(x) atol=1e-5
     @test k(v1, v2) ≈ cospi(sqrt(sum(abs2.(v1-v2)))) atol=1e-5
+    @test repr(k) == "Cosine Kernel"
 end