Refactor BaselineGraphKernel to NoGraphBaselineGraphKernel (#9)

Author: simonschoelly

Project.toml

@@ -4,6 +4,7 @@ authors = ["Simon Schoelly <sischoel@gmail.com> and contributors"]
 version = "0.1.0"
 
 [deps]
+DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 LIBSVM = "b1bec4e5-fd48-53fe-b0cb-9723c09d164b"
 LightGraphs = "093fc24a-ae57-5d10-9952-331d41423f4d"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
@@ -14,6 +15,7 @@ Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 ThreadsX = "ac1d9e8a-700a-412c-b207-f0111f4b6c0d"
 
 [compat]
+DataStructures = "0.18.9"
 LIBSVM = "0.6"
 LightGraphs = "1.3"
 SimpleValueGraphs = "0.3"

src/GraphKernels.jl

@@ -14,7 +14,7 @@ import LIBSVM: svmtrain, svmpredict
 export
     AbstractGraphKernel,
 
-    BaselineGraphKernel,
+    NoGraphBaselineGraphKernel,
     ShortestPathGraphKernel,
     PyramidMatchGraphKernel,
     WeisfeilerLehmanGraphKernel,
@@ -34,6 +34,7 @@ export
     svmtrain,
     svmpredict
 
+include("utils.jl")
 include("replacedvertexvals.jl")
 include("vertex_kernels.jl")
 include("graph-kernels/abstract-graph-kernel.jl")

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

@@ -1,10 +1,119 @@
-#
-# very similar to the No-Graph Baseline Kernel from https://mlai.cs.uni-bonn.de/publications/schulz2019gem.pdf
-# but even simpler in that we do not consider any metadata
-struct BaselineGraphKernel <: AbstractGraphKernel end
 
-function apply_preprocessed(::BaselineGraphKernel, g1, g2)
+using DataStructures: counter, inc!
 
-    return exp(-( (ne(g1) - ne(g2))^2 + (Float64(nv(g1)) - Float64(nv(g2)))^2) )
+const LabelsType = Union{Auto, Colon, Tuple{Vararg{Int}}, Tuple{Vararg{Symbol}}}
+
+"""
+    NoGraphBaselineGraphKernel(;vertex_labels=Auto(), edge_labels=Auto(), gamma=0.5)
+
+A graph kernel that does not use structural information of the graph. Instead vertices and
+edges are considered as sets and features are created by splitting these sets into classes
+according to their labels. Then the kernel function is calculated by applying an RBF kernel
+on these features.
+
+This kernel provides a good baseline, as to verify if a graph kernel, that uses structural
+information, is meaningful on some data.
+
+# Keywords
+- `vertex_labels`: Which vertex labels to consider. Either `Auto`, `:` (all), or a tuple of vertex value keys.
+- `edge_labels`: Which edge labels to consider. Either `Auto`, `:` (all), or a tuple of edge value keys.
+- `gamma`: Scaling factor for the RBF kernel.
+
+# Examples
+```jldoctest
+julia> k1 = BaselineGraphKernel(gamma=2.0); # custom gamma value
+
+# no vertex and edge labels. In that case, only the number of vertices and edges are considered.
+julia> k2 = BaselineGraphKernel(vertex_labels=(), edge_labels=());
+
+# all vertex labels, and edge labels for the keys :a and :b are considered.
+julia> k3 = BaselineGraphKernel(vertex_labels=:, edge_labels=(:a, :b));
+
+# Suitable vertex and edge label keys are inferred from the types of these labels.
+julia> k4 = BaselineGraphKernel(vertex_labels=Auto(), edge_labels=Auto()));
+```
+
+# References
+<https://mlai.cs.uni-bonn.de/publications/schulz2019gem.pdf>
+"""
+struct NoGraphBaselineGraphKernel{VL <: LabelsType, EL <: LabelsType}<: AbstractGraphKernel
+
+    vertex_labels::VL
+    edge_labels::EL
+    gamma::Float64
+
+    function NoGraphBaselineGraphKernel(;vertex_labels=Auto(), edge_labels=Auto(), gamma=0.5)
+
+        (gamma > 0 && isfinite(gamma)) || throw(DomainError(gamma, "gamma must be 0 < gamma < ∞"))
+
+        return new{typeof(vertex_labels), typeof(edge_labels)}(vertex_labels, edge_labels, Float64(gamma))
+    end
+end
+
+function preprocessed_form(kernel::NoGraphBaselineGraphKernel, g::AbstractValGraph)
+
+    vertex_labels = _labels(kernel.vertex_labels, vertexvals_type(g))
+    edge_labels = _labels(kernel.edge_labels, edgevals_type(g))
+
+    # TODO, we should deduce the correct type instead of using Any
+    vertex_class_sizes = counter(Any)
+    for v in vertices(g)
+        class_key = tuple((get_vertexval(g, v, i) for i in vertex_labels)...)
+        inc!(vertex_class_sizes, class_key)
+    end
+
+    edge_class_sizes = counter(Any)
+    for e in edges(g, :)
+        class_key = tuple((get_edgeval(e, i) for i in edge_labels)...)
+        inc!(edge_class_sizes, class_key)
+    end
+
+    return (vertex_class_sizes=vertex_class_sizes, edge_class_sizes=edge_class_sizes)
+end
+
+_labels(::Colon, types) = fieldnames(types)
+
+function _is_suitable_label_type(T)
+
+    return T <: Union{Integer, AbstractString, AbstractChar, Symbol}
+end
+
+function _labels(::Auto, types)
+
+    return filter(i -> _is_suitable_label_type(fieldtype(types, i)), fieldnames(types))
+end
+
+# TODO we could actually verify that the keys are valid
+_labels(keys::Tuple, types) = keys
+
+function apply_preprocessed(kernel::NoGraphBaselineGraphKernel, sizes1, sizes2)
+
+    squared_sum = 0
+    # Some labels might occur in only one of the graphs. Therefore we need to loop
+    # over the labels of both graphs and ensure that the squared difference of the count
+    # of some label is used exactly once.
+    for (class1, count1) in sizes1.vertex_class_sizes
+        count2 = sizes2.vertex_class_sizes[class1]
+        squared_sum += (count1 - count2)^2
+    end
+    for (class2, count2) in sizes2.vertex_class_sizes
+        count1 = sizes1.vertex_class_sizes[class2]
+        if count1 == 0
+            squared_sum += count2^2
+        end
+    end
+
+    for (class1, count1) in sizes1.edge_class_sizes
+        count2 = sizes2.edge_class_sizes[class1]
+        squared_sum += (count1 - count2)^2
+    end
+    for (class2, count2) in sizes2.edge_class_sizes
+        count1 = sizes1.edge_class_sizes[class2]
+        if count1 == 0
+            squared_sum += count2^2
+        end
+    end
+
+    return exp(-kernel.gamma * squared_sum)
 end
 

src/utils.jl

@@ -0,0 +1,8 @@
+
+"""
+    Auto
+
+A singleton type to denote that some argument to a function or constructor should
+be automatically determined.
+"""
+struct Auto end