Merge master-dev into master

Author: theogf

src/KernelFunctions.jl

@@ -22,17 +22,15 @@ using PDMats: PDMat
 
 const defaultobs = 2
 
-include("utils.jl")
-include("distances/dotproduct.jl")
-include("distances/delta.jl")
-
-
 """
 Abstract type defining a slice-wise transformation on an input matrix
 """
 abstract type Transform end
 abstract type Kernel{T,Tr<:Transform} end
 
+include("utils.jl")
+include("distances/dotproduct.jl")
+include("distances/delta.jl")
 include("transform/transform.jl")
 kernels = ["exponential","matern","polynomial","constant","rationalquad","exponentiated"]
 for k in kernels

src/generic.jl

@@ -32,3 +32,5 @@ end
 function set_params!(k::Kernel,x)
     @error "Setting parameters to this kernel is either not possible or has not been implemented"
 end
+
+params(k::Kernel) = (params(k.transform),)

src/kernels/constant.jl

@@ -55,6 +55,8 @@ struct ConstantKernel{T,Tr,Tc<:Real} <: Kernel{T,Tr}
     end
 end
 
+params(k::ConstantKernel) = (params(k.transform),k.c)
+
 function ConstantKernel(c::Tc=1.0) where {Tc<:Real}
     ConstantKernel{Float64,IdentityTransform,Tc}(IdentityTransform(),c)
 end

src/kernels/exponential.jl

@@ -60,6 +60,8 @@ struct GammaExponentialKernel{T,Tr,Tᵧ<:Real} <: Kernel{T,Tr}
     end
 end
 
+params(k::GammaExponentialKernel) = (params(transform),γ)
+
 function GammaExponentialKernel(ρ::T₁=1.0,gamma::T₂=2.0) where {T₁<:Real,T₂<:Real}
     @check_args(GammaExponentialKernel, gamma, gamma >= zero(T₂), "gamma > 0")
     GammaExponentialKernel{T₁,ScaleTransform{Base.RefValue{T₁}},T₂}(ScaleTransform(ρ),gamma)

src/kernels/kernelproduct.jl

@@ -18,6 +18,8 @@ function KernelProduct(kernels::AbstractVector{<:Kernel})
     KernelProduct{eltype(kernels),Transform}(kernels)
 end
 
+params(k::KernelProduct) = params.(k.kernels)
+
 Base.:*(k1::Kernel,k2::Kernel) = KernelProduct([k1,k2])
 Base.:*(k1::KernelProduct,k2::KernelProduct) = KernelProduct(vcat(k1.kernels,k2.kernels)) #TODO Add test
 Base.:*(k::Kernel,kp::KernelProduct) = KernelProduct(vcat(k,kp.kernels))

src/kernels/kernelsum.jl

@@ -19,13 +19,14 @@ struct KernelSum{T,Tr} <: Kernel{T,Tr}
     end
 end
 
-
 function KernelSum(kernels::AbstractVector{<:Kernel}; weights::AbstractVector{<:Real}=ones(Float64,length(kernels)))
     @assert length(kernels)==length(weights) "Weights and kernel vector should be of the same length"
     @assert all(weights.>=0) "All weights should be positive"
     KernelSum{eltype(kernels),Transform}(kernels,weights)
 end
 
+params(k::KernelSum) = (k.weights,params.(k.kernels))
+
 Base.:+(k1::Kernel,k2::Kernel) = KernelSum([k1,k2],weights=[1.0,1.0])
 Base.:+(k1::KernelSum,k2::KernelSum) = KernelSum(vcat(k1.kernels,k2.kernels),weights=vcat(k1.weights,k2.weights))
 Base.:+(k::Kernel,ks::KernelSum) = KernelSum(vcat(k,ks.kernels),weights=vcat(1.0,ks.weights))

src/kernels/matern.jl

@@ -30,6 +30,8 @@ function MaternKernel(t::Tr,ν::T=1.5) where {Tr<:Transform,T<:Real}
     MaternKernel{eltype(t),Tr,T}(t,ν)
 end
 
+params(k::MaternKernel) = (params(transform(k)),k.ν)
+
 @inline kappa(κ::MaternKernel, d::Real) = iszero(d) ? one(d) : exp((1.0-κ.ν)*logtwo-lgamma(κ.ν) + κ.ν*log(sqrt(2κ.ν)*d)+log(besselk(κ.ν,sqrt(2κ.ν)*d)))
 
 """

src/kernels/polynomial.jl

@@ -27,6 +27,8 @@ function LinearKernel(t::Tr,c::T=zero(Float64)) where {Tr<:Transform,T<:Real}
     LinearKernel{eltype(t),Tr,T}(t,c)
 end
 
+params(k::LinearKernel) = (params(transform(k)),k.c)
+
 @inline kappa(κ::LinearKernel, xᵀy::T) where {T<:Real} = xᵀy + κ.c
 
 """
@@ -62,4 +64,6 @@ function PolynomialKernel(t::Tr,d::T₁=2.0,c::T₂=zero(eltype(T₁))) where {T
     PolynomialKernel{eltype(Tr),Tr,T₁,T₂}(t,c,d)
 end
 
+params(k::PolynomialKernel) = (params(transform(k)),k.d,k.c)
+
 @inline kappa(κ::PolynomialKernel, xᵀy::T) where {T<:Real} = (xᵀy + κ.c)^(κ.d)

src/kernels/rationalquad.jl

@@ -30,6 +30,8 @@ function RationalQuadraticKernel(t::Tr,α::T=2.0) where {Tr<:Transform,T<:Real}
     RationalQuadraticKernel{eltype(t),Tr,T}(t,α)
 end
 
+params(k::RationalQuadraticKernel) = (params(transform(k)),k.α)
+
 @inline kappa(κ::RationalQuadraticKernel, d²::T) where {T<:Real} = (one(T)+d²/κ.α)^(-κ.α)
 
 
@@ -69,4 +71,6 @@ function GammaRationalQuadraticKernel(t::Tr,α::T₁=2.0,γ::T₂=2.0) where {Tr
     GammaRationalQuadraticKernel{eltype(t),Tr,T₁,T₂}(t,α,γ)
 end
 
+params(k::GammaRationalQuadraticKernel) = (params(k.transform),k.α,k.γ)
+
 @inline kappa(κ::GammaRationalQuadraticKernel, d²::T) where {T<:Real} = (one(T)+d²^κ.γ/κ.α)^(-κ.α)

src/transform/functiontransform.jl

@@ -13,3 +13,5 @@ struct FunctionTransform{F} <: Transform
 end
 
 transform(t::FunctionTransform,X::T,obsdim::Int=defaultobs) where {T} = mapslices(t.f,X,dims=obsdim)
+
+params(t::FunctionTransform) = t.f