Vectorized parameters of each kernel and add trainable function

Author: theogf

src/kernels/constant.jl

@@ -35,15 +35,14 @@ metric(::WhiteKernel) = Delta()
 Kernel function always returning a constant value `c`
 """
 struct ConstantKernel{Tc<:Real} <: BaseKernel
-    c::Tc
+    c::Vector{Tc}
     function ConstantKernel(;c::T=1.0) where {T<:Real}
-        new{T}(c)
+        new{T}([c])
     end
 end
 
-params(k::ConstantKernel) = (k.c,)
-opt_params(k::ConstantKernel) = (k.c,)
+trainable(k::ConstantKernel) = (k.c,)
 
-kappa(κ::ConstantKernel,x::Real) = κ.c*one(x)
+kappa(κ::ConstantKernel,x::Real) = first(κ.c)*one(x)
 
 metric(::ConstantKernel) = Delta()

src/kernels/exponential.jl

@@ -47,16 +47,15 @@ The γ-exponential kernel is an isotropic Mercer kernel given by the formula:
 ```
 """
 struct GammaExponentialKernel{Tγ<:Real} <: BaseKernel
-    γ::Tγ
+    γ::Vector{Tγ}
     function GammaExponentialKernel(;γ::T=2.0) where {T<:Real}
         @check_args(GammaExponentialKernel, γ, γ >= zero(T), "γ > 0")
-        return new{T}(γ)
+        return new{T}([γ])
     end
 end
 
-params(k::GammaExponentialKernel) = (γ,)
-opt_params(k::GammaExponentialKernel) = (γ,)
+trainable(k::GammaExponentialKernel) = (γ,)
 
-kappa(κ::GammaExponentialKernel, d²::Real) = exp(-d²^κ.γ)
+kappa(κ::GammaExponentialKernel, d²::Real) = exp(-d²^first(κ.γ))
 iskroncompatible(::GammaExponentialKernel) = true
 metric(::GammaExponentialKernel) = SqEuclidean()

src/kernels/matern.jl

@@ -7,17 +7,19 @@ The matern kernel is an isotropic Mercer kernel given by the formula:
 For `ν=n+1/2, n=0,1,2,...` it can be simplified and you should instead use [`ExponentialKernel`](@ref) for `n=0`, [`Matern32Kernel`](@ref), for `n=1`, [`Matern52Kernel`](@ref) for `n=2` and [`SqExponentialKernel`](@ref) for `n=∞`.
 """
 struct MaternKernel{Tν<:Real} <: BaseKernel
-    ν::Tν
+    ν::Vector{Tν}
     function MaternKernel(;ν::T=1.5) where {T<:Real}
         @check_args(MaternKernel, ν, ν > zero(T), "ν > 0")
-        return new{T}(ν)
+        return new{T}([ν])
     end
 end
 
-params(k::MaternKernel) = (k.ν,)
-opt_params(k::MaternKernel) = (k.ν,)
+trainable(k::MaternKernel) = (k.ν,)
 
-@inline kappa(κ::MaternKernel, d::Real) = iszero(d) ? one(d) : exp((one(d)-κ.ν)*logtwo-logabsgamma(κ.ν)[1] + κ.ν*log(sqrt(2κ.ν)*d)+log(besselk(κ.ν,sqrt(2κ.ν)*d)))
+@inline function kappa(κ::MaternKernel, d::Real)
+    ν = first(κ.ν)
+    iszero(d) ? one(d) : exp((one(d)-ν)*logtwo-logabsgamma(ν)[1] + ν*log(sqrt(2ν)*d)+log(besselk(ν,sqrt(2ν)*d)))
+end
 
 metric(::MaternKernel) = Euclidean()
 

src/kernels/polynomial.jl

@@ -7,16 +7,15 @@ The linear kernel is a Mercer kernel given by
 Where `c` is a real number
 """
 struct LinearKernel{Tc<:Real} <: BaseKernel
-    c::Tc
+    c::Vector{Tc}
     function LinearKernel(;c::T=0.0) where {T}
-        new{T}(c)
+        new{T}([c])
     end
 end
 
-params(k::LinearKernel) = (k.c,)
-opt_params(k::LinearKernel) = (k.c,)
+trainable(k::LinearKernel) = (k.c,)
 
-kappa(κ::LinearKernel, xᵀy::Real) = xᵀy + κ.c
+kappa(κ::LinearKernel, xᵀy::Real) = xᵀy + first(κ.c)
 
 metric(::LinearKernel) = DotProduct()
 
@@ -28,18 +27,17 @@ The polynomial kernel is a Mercer kernel given by
 ```
 Where `c` is a real number, and `d` is a shape parameter bigger than 1
 """
-struct PolynomialKernel{Td<:Real,Tc<:Real} <: BaseKernel
-    d::Td
-    c::Tc
+struct PolynomialKernel{Td<:Real, Tc<:Real} <: BaseKernel
+    d::Vector{Td}
+    c::Vector{Tc}
     function PolynomialKernel(; d::Td=2.0, c::Tc=0.0) where {Td<:Real, Tc<:Real}
         @check_args(PolynomialKernel, d, d >= one(Td), "d >= 1")
-        return new{Td, Tc}(d, c)
+        return new{Td, Tc}([d], [c])
     end
 end
 
-params(k::PolynomialKernel) = (k.d,k.c)
-opt_params(k::PolynomialKernel) = (k.d,k.c)
+trainable(k::PolynomialKernel) = (k.d,k.c)
 
-kappa(κ::PolynomialKernel, xᵀy::T) where {T<:Real} = (xᵀy + κ.c)^(κ.d)
+kappa(κ::PolynomialKernel, xᵀy::T) where {T<:Real} = (xᵀy + first(κ.c))^(first(κ.d))
 
 metric(::PolynomialKernel) = DotProduct()

src/kernels/rationalquad.jl

@@ -7,17 +7,16 @@ The rational-quadratic kernel is an isotropic Mercer kernel given by the formula
 where `α` is a shape parameter of the Euclidean distance. Check [`GammaRationalQuadraticKernel`](@ref) for a generalization.
 """
 struct RationalQuadraticKernel{Tα<:Real} <: BaseKernel
-    α::Tα
+    α::Vector{Tα}
     function RationalQuadraticKernel(;α::T=2.0) where {T}
         @check_args(RationalQuadraticKernel, α, α > zero(T), "α > 1")
-        return new{T}(α)
+        return new{T}([α])
     end
 end
 
-params(k::RationalQuadraticKernel) = (k.α,)
-opt_params(k::RationalQuadraticKernel) = (k.α,)
+trainable(k::RationalQuadraticKernel) = (k.α,)
 
-kappa(κ::RationalQuadraticKernel, d²::T) where {T<:Real} = (one(T)+d²/κ.α)^(-κ.α)
+kappa(κ::RationalQuadraticKernel, d²::T) where {T<:Real} = (one(T)+d²/first(κ.α))^(-first(κ.α))
 
 metric(::RationalQuadraticKernel) = SqEuclidean()
 
@@ -30,18 +29,17 @@ The Gamma-rational-quadratic kernel is an isotropic Mercer kernel given by the f
 where `α` is a shape parameter of the Euclidean distance and `γ` is another shape parameter.
 """
 struct GammaRationalQuadraticKernel{Tα<:Real, Tγ<:Real} <: BaseKernel
-    α::Tα
-    γ::Tγ
+    α::Vector{Tα}
+    γ::Vector{Tγ}
     function GammaRationalQuadraticKernel(;α::Tα=2.0, γ::Tγ=2.0) where {Tα<:Real, Tγ<:Real}
         @check_args(GammaRationalQuadraticKernel, α, α > one(Tα), "α > 1")
         @check_args(GammaRationalQuadraticKernel, γ, γ >= one(Tγ), "γ >= 1")
-        return new{Tα, Tγ}(α, γ)
+        return new{Tα, Tγ}([α], [γ])
     end
 end
 
-params(k::GammaRationalQuadraticKernel) = (k.α,k.γ)
-opt_params(k::GammaRationalQuadraticKernel) = (k.α,k.γ)
+trainable(k::GammaRationalQuadraticKernel) = (k.α,k.γ)
 
-kappa(κ::GammaRationalQuadraticKernel, d²::T) where {T<:Real} = (one(T)+d²^κ.γ/κ.α)^(-κ.α)
+kappa(κ::GammaRationalQuadraticKernel, d²::T) where {T<:Real} = (one(T)+d²^first(κ.γ)/first(κ.α))^(-first(κ.α))
 
 metric(::GammaRationalQuadraticKernel) = SqEuclidean()

src/kernels/scaledkernel.jl

@@ -12,8 +12,7 @@ kappa(k::ScaledKernel, x) = first(k.σ)*kappa(k.kernel, x)
 
 metric(k::ScaledKernel) = metric(k.kernel)
 
-params(k::ScaledKernel) = (k.σ,params(k.kernel))
-opt_params(k::ScaledKernel) = (k.σ,opt_params(k.kernel))
+trainable(k::ScaledKernel) = (k.σ,k.kernel)
 
 Base.:*(w::Real,k::Kernel) = ScaledKernel(k,w)
 

src/kernels/transformedkernel.jl

@@ -27,7 +27,7 @@ kappa(κ::TransformedKernel, x) = kappa(κ.kernel, x)
 
 metric(κ::TransformedKernel) = metric(κ.kernel)
 
-params(κ::TransformedKernel) = (params(κ.transform),params(κ.kernel))
+trainable(κ::TransformedKernel) = (κ.transform,κ.kernel)
 
 Base.show(io::IO,κ::TransformedKernel) = printshifted(io,κ,0)