Make kernels subtypes of KernelFunctions.Kernel

Author: simonschoelly

Project.toml

@@ -5,6 +5,7 @@ version = "0.1.0"
 
 [deps]
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
+KernelFunctions = "ec8451be-7e33-11e9-00cf-bbf324bd1392"
 LIBSVM = "b1bec4e5-fd48-53fe-b0cb-9723c09d164b"
 LightGraphs = "093fc24a-ae57-5d10-9952-331d41423f4d"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
@@ -16,6 +17,7 @@ ThreadsX = "ac1d9e8a-700a-412c-b207-f0111f4b6c0d"
 
 [compat]
 DataStructures = "0.18.9"
+KernelFunctions = "0.10.5"
 LIBSVM = "0.6"
 LightGraphs = "1.3"
 SimpleValueGraphs = "0.3"

src/GraphKernels.jl

@@ -11,6 +11,9 @@ using ThreadsX
 
 import LIBSVM: svmtrain, svmpredict
 
+using KernelFunctions: kernelmatrix, kernelmatrix_diag
+import KernelFunctions
+
 export
     AbstractGraphKernel,
 
@@ -19,17 +22,16 @@ export
     PyramidMatchGraphKernel,
     WeisfeilerLehmanGraphKernel,
 
-    NormalizeGraphKernel,
-
     ConstVertexKernel,
     DiracVertexKernel,
     DotVertexKernel,
 
+    k_fold_cross_validation,
+
+    # reexport from KernelFunctions
     kernelmatrix,
     kernelmatrix_diag,
 
-    k_fold_cross_validation,
-
     # overridden methods from LIBSVM
     svmtrain,
     svmpredict
@@ -39,7 +41,6 @@ include("replacedvertexvals.jl")
 include("vertex_kernels.jl")
 include("graph-kernels/abstract-graph-kernel.jl")
 include("graph-kernels/baseline-graph-kernel.jl")
-include("graph-kernels/normalize-graph-kernel.jl")
 include("graph-kernels/pyramid-match-graph-kernel.jl")
 include("graph-kernels/shortest-path-graph-kernel.jl")
 include("graph-kernels/weisfeiler-lehman-graph-kernel.jl")

src/graph-kernels/abstract-graph-kernel.jl

@@ -3,7 +3,7 @@
 # ================================================================
 
 """
-    abstract type AbstractGraphKernel
+    abstract type AbstractGraphKernel <: KernelFunctions.Kernel
 
 A kernel function between two graphs.
 
@@ -17,10 +17,10 @@ that transforms a single graph into a suitable representation and `apply_preproc
 takes the representations for both graphs and calculates the kernel function.
 
 ### See also
-[`preprocessed_form`](@ref), [`apply_preprocessed`](@ref), [`kernel_matrix`](@ref), [`kernel_matrix_diag`](@ref)
+[`preprocessed_form`](@ref), [`apply_preprocessed`](@ref), [`KernelFunctions.Kernel`](@ref), [`kernel_matrix`](@ref), [`kernel_matrix_diag`](@ref)
 
 """
-abstract type AbstractGraphKernel end
+abstract type AbstractGraphKernel <: KernelFunctions.Kernel end
 
 """
     preprocessed_form(k::AbstractGraphKernel, g::AbstractGraph) = g
@@ -39,7 +39,7 @@ method.
 """
 preprocessed_form(::AbstractGraphKernel, g::AbstractGraph) = g
 
-function (kernel::AbstractGraphKernel)(g1, g2)
+function (kernel::AbstractGraphKernel)(g1::AbstractGraph, g2::AbstractGraph)
 
     return apply_preprocessed(kernel, preprocessed_form(kernel, g1), preprocessed_form(kernel, g2))
 end
@@ -52,7 +52,7 @@ function _map_preprocessed_form(kernel::AbstractGraphKernel, graphs)
 
     # TODO we should be able to avoid collecting the graphs
     # but currently ThreadX cannot split them otherwise,
-    # maybe we can create some wrapper type that is splitable around graphs
+    # maybe we can create some wrapper type that is splittable around graphs
     return ThreadsX.map(g -> preprocessed_form(kernel, g), collect(graphs))
 end
 
@@ -63,7 +63,7 @@ Return a matrix of running the kernel on all pairs of graphs.
 ### See also
 [`kernelmatrix_diag`](@ref)
 """
-function kernelmatrix(kernel::AbstractGraphKernel, graphs)
+function KernelFunctions.kernelmatrix(kernel::AbstractGraphKernel, graphs::AbstractVector)
 
     pre = _map_preprocessed_form(kernel, graphs)
 
@@ -92,15 +92,7 @@ function _kernelmatrix_from_preprocessed(kernel, pre)
     return G
 end
 
-"""
-    kernelmatrix_diag(kernel::AbstractGraphKernel, graphs)
-
-Calculate the diagonal of the kernelmatrix matrix of the graphs.
-
-### See also
-[`kernelmatrix`](@ref)
-"""
-function kernelmatrix_diag(kernel::AbstractGraphKernel, graphs)
+function KernelFunctions.kernelmatrix_diag(kernel::AbstractGraphKernel, graphs::AbstractVector)
 
     n = length(graphs)
     pre = _map_preprocessed_form(kernel, graphs)
@@ -112,13 +104,8 @@ function kernelmatrix_diag(kernel::AbstractGraphKernel, graphs)
     return D
 end
 
-"""
-    kernelmatrix(kernel::AbstractGraphKernel, graphs1, graphs2)
 
-Calculate a matrix of invoking the kernel on all pairs.
-Entry `(i, j)` of the resulting matrix contains `kernel(graphs1[i], graphs2[j]`.
-"""
-function kernelmatrix(kernel::AbstractGraphKernel, graphs1, graphs2)
+function KernelFunctions.kernelmatrix(kernel::AbstractGraphKernel, graphs1::AbstractVector, graphs2::AbstractVector)
 
     n_rows = length(graphs1)
     n_cols = length(graphs2)

src/graph-kernels/normalize-graph-kernel.jl

@@ -4,10 +4,12 @@
 #     AbstractVertexKernel
 # ================================================================
 
-abstract type AbstractVertexKernel end
+abstract type AbstractVertexKernel <: KernelFunctions.Kernel end
 
-function (kernel::AbstractVertexKernel)((g1, v1), (g2, v2))
+function (kernel::AbstractVertexKernel)(gv1::Tuple{AbstractGraph, Integer}, gv2::Tuple{AbstractGraph, Integer})
 
+    (g1, v1) = gv1
+    (g2, v2) = gv2
     return kernel(g1, v1, g2, v2)
 end