Add Weisfeiler-Lehman graph kernel (#8)

Author: simonschoelly

src/GraphKernels.jl

@@ -17,6 +17,7 @@ export
     BaselineGraphKernel,
     ShortestPathGraphKernel,
     PyramidMatchGraphKernel,
+    WeisfeilerLehmanGraphKernel,
 
     NormalizeGraphKernel,
 
@@ -33,12 +34,14 @@ export
     svmtrain,
     svmpredict
 
+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")
 include("integrations/LIBSVM.jl")
 
 # ================================================================

src/graph-kernels/weisfeiler-lehman-graph-kernel.jl

@@ -0,0 +1,56 @@
+
+"""
+    WeisfeilerLehmanGraphKernel(;base_kernel, num_iterations=5) <: AbstractGraphKernel
+"""
+struct WeisfeilerLehmanGraphKernel{BK<:AbstractGraphKernel} <: AbstractGraphKernel
+
+    base_kernel::BK
+    num_iterations::Int
+
+    function WeisfeilerLehmanGraphKernel(base_kernel::AbstractGraphKernel, num_iterations::Integer)
+
+        num_iterations >= 1 || throw(DomainError(num_iterations, "num_iterations must be >= 1"))
+        return new{typeof(base_kernel)}(base_kernel, num_iterations)
+    end
+end
+
+function WeisfeilerLehmanGraphKernel(;base_kernel::AbstractGraphKernel, num_iterations::Integer=5)
+
+    return WeisfeilerLehmanGraphKernel(base_kernel, num_iterations)
+end
+
+function preprocessed_form(kernel::WeisfeilerLehmanGraphKernel, g::AbstractGraph)
+
+    nvg = nv(g)
+    num_iterations = kernel.num_iterations
+
+    vertexvals = Matrix{UInt}(undef, nvg, num_iterations)
+
+    for u in vertices(g)
+        vertexvals[u, 1] = hash(get_vertexval(g, u, :))
+    end
+
+    sort_buffer = Vector{UInt}(undef, Δ(g))
+    for i in 2:num_iterations
+        for u in vertices(g)
+            deg_u = degree(g, u)
+            for (j, v) in enumerate(neighbors(g, u))
+                sort_buffer[j] = vertexvals[u, i-1]
+            end
+            sort!(@view sort_buffer[1:deg_u])
+            h = vertexvals[u, i-1]
+            for j in 1:deg_u
+                h = hash(sort_buffer[j], h)
+            end
+            vertexvals[u, i] = h
+        end
+    end
+
+    return [preprocessed_form(kernel.base_kernel, ReplacedVertexVals(g, vertexvals[:, i])) for i in  1:num_iterations]
+end
+
+function apply_preprocessed(kernel::WeisfeilerLehmanGraphKernel, pre1, pre2)
+
+    return sum(t -> apply_preprocessed(kernel.base_kernel, t[1], t[2]), zip(pre1, pre2))
+end
+

src/replacedvertexvals.jl

@@ -0,0 +1,37 @@
+
+struct ReplacedVertexVals{V, V_VAL, E_VALS, G_VALS, G <: AbstractValGraph} <: AbstractValGraph{V, Tuple{V_VAL}, E_VALS, G_VALS}
+
+    graph::G
+    vertexvals::Vector{V_VAL}
+
+    function ReplacedVertexVals(graph::AbstractValGraph, vertexvals::Vector)
+
+        # TODO throw proper error
+        @assert nv(graph) == length(vertexvals)
+
+        V = eltype(graph)
+        V_VAL = eltype(vertexvals)
+        E_VALS = edgevals_type(graph)
+        G_VALS = graphvals_type(graph)
+        G = typeof(graph)
+        return new{V, V_VAL, E_VALS, G_VALS, G}(graph, vertexvals)
+    end
+end
+
+
+SimpleValueGraphs.nv(g::ReplacedVertexVals) = nv(g.graph)
+SimpleValueGraphs.has_edge(g::ReplacedVertexVals, s::Integer, d::Integer) = has_edge(g.graph, s, d)
+SimpleValueGraphs.is_directed(::Type{<:ReplacedVertexVals{V, V_VAL, E_VALS, G_VALS, G}}) where {V, V_VAL, E_VALS, G_VALS, G} = is_directed(G)
+
+SimpleValueGraphs.ne(g::ReplacedVertexVals) = ne(g.graph)
+
+SimpleValueGraphs.get_edgeval(g::ReplacedVertexVals, s::Integer, d::Integer, i::Integer) = get_edgeval(g.graph, s, d, i)
+
+function SimpleValueGraphs.get_vertexval(g::ReplacedVertexVals, v::Integer, i::Integer)
+
+    # TODO might verify that this is a correct vertex
+    # TODO might verify that i is 1
+    return g.vertexvals[v]
+end
+
+