Done:

 - Finalized gmatch4py
   - ADD Kernel (random walk)

Todo :
 - debug BP2 GEOWALK KERNEL and KSTEP WALk KERNEL

gmatch4py/deltacon.py

@@ -6,7 +6,7 @@ import scipy.sparse
 
 
 class DeltaCon0():
-
+    __type__ = "sim"
 
     @staticmethod
     def compare(list_gs):
@@ -60,7 +60,7 @@ class DeltaCon0():
         return dmax
 
 class DeltaCon():
-
+    __type__ = "sim"
 
     @staticmethod
     def relabel_nodes(graph_list):

gmatch4py/ged/algorithm/graph_edit_dist.py

@@ -3,7 +3,7 @@
 import sys
 
 import networkx as nx
-from gmatch4py.algorithm.edge_edit_dist import EdgeEditDistance
+from gmatch4py.ged.algorithm.edge_edit_dist import EdgeEditDistance
 
 from gmatch4py.ged.algorithm.abstract_graph_edit_dist import AbstractGraphEditDistance
 from gmatch4py.ged.graph.edge_graph import EdgeGraph

gmatch4py/ged/approximate_ged.py

+# coding = utf-8
+
+from gmatch4py.ged.algorithm.graph_edit_dist import GraphEditDistance
+import numpy as np
+class ApproximateGraphEditDistance():
+    __type__ = "dist"
+
+    @staticmethod
+    def compare(listgs,c_del_node=1,c_del_edge=1,c_ins_node=1,c_ins_edge=1):
+        n= len(listgs)
+        comparison_matrix = np.zeros((n,n))
+        for i in range(n):
+            for j in range(i,n):
+                comparison_matrix[i,j]= GraphEditDistance(listgs[i],listgs[j],False,node_del=c_del_node,node_ins=c_ins_node,edge_del=c_del_edge,edge_ins=c_ins_edge).distance()
+                comparison_matrix[j,i]= comparison_matrix[i,j]
+
+        return comparison_matrix
\ No newline at end of file

gmatch4py/ged/bipartite_graph_matching_2.py

@@ -2,7 +2,24 @@
 import numpy as np
 import networkx as nx
 class BP_2():
-    """"""
+    """
+
+    """
+    __type__="dist"
+    @staticmethod
+    def compare(listgs, c_del_node=1, c_del_edge=1, c_ins_node=1, c_ins_edge=1):
+        n = len(listgs)
+        comparator = BP_2(c_del_node, c_ins_node, c_del_edge, c_ins_edge)
+        comparison_matrix = np.zeros((n, n))
+        for i in range(n):
+            for j in range(i, n):
+                comparison_matrix[i, j] = comparator.bp2(listgs[i], listgs[j])
+                comparison_matrix[j, i] = comparison_matrix[i, j]
+
+
+
+
+        return comparison_matrix
 
     def __init__(self, node_del=1, node_ins=1, edge_del=1, edge_ins=1):
         """Constructor for HED"""

gmatch4py/ged/greedy_edit_distance.py

@@ -12,10 +12,24 @@ class GreedyEditDistance(GraphEditDistance):
     Andreas Fischer, Kaspar Riesen, Horst Bunke
     2016
     """
-
-    def __init__(self,g1,g2,debug=False):
+    __type__ = "dist"
+    @staticmethod
+    def compare(listgs, c_del_node=1, c_del_edge=1, c_ins_node=1, c_ins_edge=1):
+        n = len(listgs)
+        comparison_matrix = np.zeros((n, n))
+        for i in range(n):
+            for j in range(i, n):
+                comparison_matrix[i, j] = GreedyEditDistance(listgs[i], listgs[j],False, node_del=c_del_node,
+                                                            node_ins=c_ins_node, edge_del=c_del_edge,
+                                                            edge_ins=c_ins_edge).distance()
+                comparison_matrix[j, i] = comparison_matrix[i, j]
+
+
+        return comparison_matrix
+
+    def __init__(self,g1,g2,debug=False,**kwargs):
         """Constructor for GreedyEditDistance"""
-        super().__init__(g1,g2,debug)
+        super().__init__(g1,g2,debug,**kwargs)
 
 
     def edit_costs(self):

gmatch4py/ged/hausdorff_edit_distance.py

@@ -12,6 +12,19 @@ class HED():
     Andreas Fischer, Kaspar Riesen, Horst Bunke
     2016
     """
+    __type__ = "dist"
+    @staticmethod
+    def compare(listgs, c_del_node=1, c_del_edge=1, c_ins_node=1, c_ins_edge=1):
+        n = len(listgs)
+        comparator = HED(c_del_node, c_ins_node, c_del_edge, c_ins_edge)
+        comparison_matrix = np.zeros((n, n))
+        for i in range(n):
+            for j in range(i, n):
+                comparison_matrix[i, j] = comparator.hed(listgs[i], listgs[j])
+                comparison_matrix[j, i] = comparison_matrix[i, j]
+
+        return comparison_matrix
+
 
     def __init__(self, node_del=1, node_ins=1, edge_del=1, edge_ins=1):
         """Constructor for HED"""

gmatch4py/kernels/random_walk_kernel.py

+# coding = utf-8
+
+import networkx as nx
+import numpy as np
+
+class GeometricRandomWalkKernel():
+    __type__ = "sim"
+    @staticmethod
+    def maxDegree(G):
+        degree_sequence = sorted(nx.degree(G).values(), reverse=True)  # degree sequence
+        # print "Degree sequence", degree_sequence
+        dmax = max(degree_sequence)
+        return dmax
+    @staticmethod
+    def compare(listgs):
+
+        n = len(listgs)
+        comparison_matrix=np.zeros((n,n))
+        for i in range(n):
+            for j in range(i,n):
+                direct_product_graph=nx.tensor_product(listgs[i],listgs[j])
+                Ax = nx.adjacency_matrix(direct_product_graph).todense()
+                la = 1/ GeometricRandomWalkKernel.maxDegree(direct_product_graph) # lambda value
+                eps = pow(10,-10)
+                I=np.identity(Ax.shape[0])
+                I_vec=np.ones(Ax.shape[0])
+                x=I_vec.copy()
+                x_pre=np.zeros(Ax.shape[0])
+                c=0
+                while (np.linalg.norm(x-x_pre)) > eps:
+                    if c > 100:
+                        break
+                    x_pre=x
+                    #print("I_vec",I_vec.shape)
+                    #print("Ax", Ax.shape)
+                    #print("x_pre", I_vec.shape)
+
+                    x= I_vec + la*(np.dot(Ax,x_pre.T))
+                    c+=1
+                comparison_matrix[i,j]=np.sum(x)
+                comparison_matrix[j,i]=comparison_matrix[i,j]
+
+        for i in range(n):
+            for j in range(i,n):
+                comparison_matrix[i,j] = comparison_matrix[i,j]/np.sqrt(comparison_matrix[i,i]*comparison_matrix[j,j])
+                comparison_matrix[j,i]=comparison_matrix[i,j]
+        return comparison_matrix
+
+class KStepRandomWalkKernel():
+    __type__ = "sim"
+    @staticmethod
+    def maxDegree(G):
+        degree_sequence = sorted(nx.degree(G).values(), reverse=True)  # degree sequence
+        # print "Degree sequence", degree_sequence
+        dmax = max(degree_sequence)
+        return dmax
+    @staticmethod
+    def compare(listgs,lambda_list=[1,2,3],k=3):
+        if not len(lambda_list) == k:
+            raise AttributeError
+        n = len(listgs)
+        comparison_matrix=np.zeros((n,n))
+        for i in range(n):
+            for j in range(i,n):
+                direct_product_graph=nx.tensor_product(listgs[i],listgs[j])
+                Ax = nx.adjacency_matrix(direct_product_graph).todense()
+                eps = pow(10,-10)
+                I=np.identity(Ax.shape[0])
+                ax_pow = I.copy()
+                sum_ = lambda_list[0] * I
+                for kk in range(1, k):
+                    ax_pow *= Ax
+                    sum_ += lambda_list[kk] * ax_pow
+
+                comparison_matrix[i, j] = np.sum(sum_)
+                comparison_matrix[j,i]=comparison_matrix[i,j]
+
+        for i in range(n):
+            for j in range(i,n):
+                comparison_matrix[i,j] = comparison_matrix[i,j]/np.sqrt(comparison_matrix[i,i]*comparison_matrix[j,j])
+                comparison_matrix[j,i]=comparison_matrix[i,j]
+        return comparison_matrix
\ No newline at end of file

gmatch4py/kernels/shortest_path_kernel.py

@@ -18,6 +18,7 @@ class ShortestPathGraphKernel:
     """
     Shorthest path graph kernel.
     """
+    __type__ = "sim"
     @staticmethod
     def compare( g_1, g_2, verbose=False):
         """Compute the kernel value (similarity) between two graphs.

gmatch4py/kernels/weisfeiler_lehman.py

@@ -17,7 +17,7 @@ import networkx as nx
 import copy
 
 class WeisfeleirLehmanKernel(object):
-
+    __type__ = "sim"
     @staticmethod
     def compare(graph_list,h=2):
         """Compute the all-pairs kernel values for a list of graphs.

gmatch4py/vertex_edge_overlap.py

@@ -7,6 +7,8 @@ import networkx as nx
 def intersect(a, b):
     return list(set(a) & set(b))
 class VertexEdgeOverlap():
+    __type__ = "sim"
+
     """
     Vertex/Edge Overlap Algorithm
     presented in Web graph similarity for anomaly detection, Journal of Internet Services and Applications, 2008

gmatch4py/vertex_ranking.py

@@ -16,6 +16,7 @@ class VertexRanking():
     Code Author : Jacques Fize
 
     """
+    __type__ = "sim"
     @staticmethod
     def compare(listgs):
         n = len(listgs)