diff --git a/.gitignore b/.gitignore
index 2fa705c840ffe1e56bb5b7390a62dc59e0a3ad43..572be86ffe526155cc18737764a5f524cc854654 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,3 +11,4 @@ test*
 __pycache__/
 /UNHCR_en.txt
 !/tests/
+.DS_Store
diff --git a/gmatch4py/__init__.py b/gmatch4py/__init__.py
deleted file mode 100644
index 950f6351f2b5c063c306b42eb677bb9695abdd58..0000000000000000000000000000000000000000
--- a/gmatch4py/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# coding = utf-8
\ No newline at end of file
diff --git a/gmatch4py/exception/__init__.py b/gmatch4py/exception/__init__.py
deleted file mode 100644
index 950f6351f2b5c063c306b42eb677bb9695abdd58..0000000000000000000000000000000000000000
--- a/gmatch4py/exception/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# coding = utf-8
\ No newline at end of file
diff --git a/gmatch4py/ged/__init__.py b/gmatch4py/ged/__init__.py
deleted file mode 100644
index e5c6c3cf41f050a3a264593b6ecb526318bf65a2..0000000000000000000000000000000000000000
--- a/gmatch4py/ged/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-# coding = utf-8
-
diff --git a/gmatch4py/ged/algorithm/__init__.py b/gmatch4py/ged/algorithm/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/gmatch4py/ged/graph/__init__.py b/gmatch4py/ged/graph/__init__.py
deleted file mode 100644
index 950f6351f2b5c063c306b42eb677bb9695abdd58..0000000000000000000000000000000000000000
--- a/gmatch4py/ged/graph/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# coding = utf-8
\ No newline at end of file
diff --git a/gmatch4py/kernels/__init__.py b/gmatch4py/kernels/__init__.py
deleted file mode 100644
index 950f6351f2b5c063c306b42eb677bb9695abdd58..0000000000000000000000000000000000000000
--- a/gmatch4py/kernels/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# coding = utf-8
\ No newline at end of file
diff --git a/gmatch4py_cython/README.md b/gmatch4py_cython/README.md
deleted file mode 100644
index d30da9a417e7af4b4dd83e3990632240e30b0183..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/README.md
+++ /dev/null
@@ -1,43 +0,0 @@
-# Gmatch4py a graph matching library for Python
-
-Gmatch4py is a library dedicated to graph matching. Graph structure are stored in NetworkX.Graph objects.
-
-## List of algorithm
-
- * DeltaCon and DeltaCon0 (*debug needed*) [1]
- * Vertex Ranking (*debug needed*) [2]
- * Vertex Edge Overlap [2]
- * Graph kernels
-    * Random Walk Kernel (*debug needed*) [3]
-        * Geometrical 
-        * K-Step 
-    * Shortest Path Kernel [3]
-    * Weisfeiler-Lehman Kernel [4]
-        * Subtree Kernel 
-        * Edge Kernel
-        * Subtree Geo Kernel [new]
-        * Edge Geo Kernel [new]
- * Graph Edit Distance [5]
-    * Approximated Graph Edit Distance 
-    * Hausdorff Graph Edit Distance 
-    * Bipartite Graph Edit Distance 
-    * Greedy Edit Distance
- * MCS [6]
-    
-
-## Publications associated
-
-  * [1] Koutra, D., Vogelstein, J. T., & Faloutsos, C. (2013, May). Deltacon: A principled massive-graph similarity function. In Proceedings of the 2013 SIAM International Conference on Data Mining (pp. 162-170). Society for Industrial and Applied Mathematics.
-  * [2] Papadimitriou, P., Dasdan, A., & Garcia-Molina, H. (2010). Web graph similarity for anomaly detection. Journal of Internet Services and Applications, 1(1), 19-30.
-  * [3] Vishwanathan, S. V. N., Schraudolph, N. N., Kondor, R., & Borgwardt, K. M. (2010). Graph kernels. Journal of Machine Learning Research, 11(Apr), 1201-1242.
-  * [4] Shervashidze, N., Schweitzer, P., Leeuwen, E. J. V., Mehlhorn, K., & Borgwardt, K. M. (2011). Weisfeiler-lehman graph kernels. Journal of Machine Learning Research, 12(Sep), 2539-2561.
-  * [5] Fischer, A., Riesen, K., & Bunke, H. (2017). Improved quadratic time approximation of graph edit distance by combining Hausdorff matching and greedy assignment. Pattern Recognition Letters, 87, 55-62.
-  * [6] A graph distance metric based on the maximal common subgraph, H. Bunke and K. Shearer, Pattern Recognition Letters, 1998  
-
-## Authors
-
-Jacques Fize
-
-## TODO
-
-  * Debug algorithms with --> (*debug needed*)
\ No newline at end of file
diff --git a/gmatch4py_cython/__init__.py b/gmatch4py_cython/__init__.py
deleted file mode 100644
index 950f6351f2b5c063c306b42eb677bb9695abdd58..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# coding = utf-8
\ No newline at end of file
diff --git a/gmatch4py_cython/gmatch4py/__init__.py b/gmatch4py_cython/gmatch4py/__init__.py
deleted file mode 100644
index 950f6351f2b5c063c306b42eb677bb9695abdd58..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# coding = utf-8
\ No newline at end of file
diff --git a/gmatch4py_cython/gmatch4py/bag_of_cliques.pyx b/gmatch4py_cython/gmatch4py/bag_of_cliques.pyx
deleted file mode 100644
index 14c22da478a6f2e33e966649bd75231fc8d22703..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/bag_of_cliques.pyx
+++ /dev/null
@@ -1,168 +0,0 @@
-# coding = utf-8
-
-import copy
-from typing import Sequence
-
-import networkx as nx
-import numpy as np
-cimport numpy as np
-import sys
-
-from networkit import graph
-from networkit.clique import MaximalCliques
-
-def nx2nk(nxG, weightAttr=None):
-    """
-    Convert a networkx.Graph to a NetworKit.Graph
-        :param weightAttr: the edge attribute which should be treated as the edge weight.
-    """
-
-    # map networkx node ids to consecutive numerical node ids
-    idmap = dict((id, u) for (id, u) in zip(nxG.nodes(), range(nxG.number_of_nodes())))
-    z = max(idmap.values()) + 1
-    # print("z = {0}".format(z))
-
-    if weightAttr is not None:
-        nkG = graph.Graph(z, weighted=True, directed=nxG.is_directed())
-        for (u_, v_) in nxG.edges():
-            u, v = idmap[u_], idmap[v_]
-            w = nxG[u_][v_][weightAttr]
-            nkG.addEdge(u, v, w)
-    else:
-        nkG = graph.Graph(z, directed=nxG.is_directed())
-        for (u_, v_) in nxG.edges():
-            u, v = idmap[u_], idmap[v_]
-            # print(u_, v_, u, v)
-            assert (u < z)
-            assert (v < z)
-            nkG.addEdge(u, v)
-
-    assert (nkG.numberOfNodes() == nxG.number_of_nodes())
-    assert (nkG.numberOfEdges() == nxG.number_of_edges())
-    return nkG.removeSelfLoops(),idmap
-
-def getClique(nx_graph):
-    final_cliques=[]
-    if len(nx_graph) ==0:
-        return final_cliques
-    netkit_graph,idmap=nx2nk(nx_graph)
-    idmap={v:k for k,v in idmap.items()}
-    cliques=MaximalCliques(netkit_graph).run().getCliques()
-    for cl in cliques:
-        final_cliques.append(list(map(lambda x:idmap[x],cl)))
-    return final_cliques
-
-class BagOfCliques():
-
-    @staticmethod
-    def compare(graphs,selected):
-        b=BagOfCliques()
-        bog=b.getBagOfCliques(graphs).astype(np.float32)
-        #Compute cosine similarity
-        cdef int n=bog.shape[0]
-        cdef double[:,:] scores = np.zeros((n,n))
-        cdef int i
-        for i in range(len(scores)):
-            if not i in selected:
-                continue
-            for j in range(i,len(scores)):
-                scores[i,j]=(np.dot(bog[i],bog[j]))/(np.sqrt(np.sum(bog[i]**2))*np.sqrt(np.sum(bog[j]**2))) # Can be computed in one line
-                scores[j,i]=scores[i,j]
-        return scores
-
-    def getUniqueCliques(self,graphs):
-        """
-        Return unique cliques from a population of graphs
-        :return:
-        """
-        t = {}
-        c_ = 0
-        cdef list clique_vocab = []
-        cdef list cli_temp
-        cdef list cliques
-        cdef int len_graphs=len(graphs)
-        cdef int km= -1
-        for g in graphs:
-            km+=1
-            if not g:
-                continue
-            sys.stdout.write("\r{0}/{1} -- {2}".format(km,len_graphs,len(g)))
-            try:
-                cliques = list(getClique(nx.Graph(g)))
-            except:
-                #no clique found
-                print(nx.Graph(g).edges())
-                cliques =[]
-            for clique in cliques:
-
-                cli_temp = copy.deepcopy(clique)
-                new_clique = False
-                for i in range(len(clique)):
-                    flag = False
-                    v = None  # vertex deleted
-                    for vertex in cli_temp:
-                        if vertex in t:
-                            v = vertex
-                            flag = True
-
-                    if not flag in t:
-                        v = cli_temp[0]
-                        t[v] = {}
-                        new_clique = True
-                    t = t[v]
-                    cli_temp.remove(v)
-
-                if new_clique:
-                    c_ += 1
-                    clique_vocab.append(clique)
-        return clique_vocab
-
-
-    def clique2str(self,cliques):
-        return "".join(sorted(cliques))
-
-    def transform_clique_vocab(self,clique_vocab):
-        cdef dict new_vocab={}
-        cdef int len_voc=len(clique_vocab)
-        for c in range(len_voc):
-            print(c)
-            new_vocab[self.clique2str(clique_vocab[c])]=c
-        return new_vocab
-
-
-    def ifHaveMinor(self,clique, dict mapping):
-        """
-        If a clique (minor) H belong to a graph G
-        :param H:
-        :return:
-        """
-        if self.clique2str(clique) in mapping:
-            return 1
-        return 0
-
-
-    def getBagOfCliques(self,graphs ):
-        """
-
-        :param clique_vocab:
-        :return:
-        """
-        cdef list clique_vocab=self.getUniqueCliques(graphs)
-        print("DONE")
-        cdef dict map_str_cliques=self.transform_clique_vocab(clique_vocab)
-        print("DONE2")
-        cdef int l_v=len(clique_vocab)
-        cdef np.ndarray boc = np.zeros((len(graphs), l_v))
-        cdef np.ndarray vector
-        cdef list cliques
-        for g in range(len(graphs)):
-            sys.stdout.write("\r{0}/{1}".format(g,5552))
-            gr = graphs[g]
-            vector = np.zeros(l_v)
-            cliques = list(getClique(nx.Graph(gr)))
-            for clique in cliques:
-                hash=self.clique2str(clique)
-                if hash in map_str_cliques:
-                    vector[map_str_cliques[hash]] = 1
-            boc[g] = vector
-        return boc
\ No newline at end of file
diff --git a/gmatch4py_cython/gmatch4py/deltacon.pyx b/gmatch4py_cython/gmatch4py/deltacon.pyx
deleted file mode 100644
index 6749994367b37eb8fb5351c4ac61ff4b85b9e73d..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/deltacon.pyx
+++ /dev/null
@@ -1,153 +0,0 @@
-# coding = utf-8
-
-import networkx as nx
-import numpy as np
-import scipy.sparse
-
-
-class DeltaCon0():
-    __type__ = "sim"
-
-    @staticmethod
-    def compare(list_gs,selected):
-        n=len(list_gs)
-
-        comparison_matrix = np.zeros((n,n))
-        for i in range(n):
-            for j in range(i,n):
-                g1,g2=list_gs[i],list_gs[j]
-                f=True
-                if not list_gs[i] or not list_gs[j]:
-                    f=False
-                elif len(list_gs[i])== 0 or len(list_gs[j]) == 0:
-                    f=False
-                if selected:
-                    if not i in selected:
-                        f=False
-                if f:
-                    # S1
-                    epsilon = 1/(1+DeltaCon0.maxDegree(g1))
-                    D, A = DeltaCon0.degreeAndAdjacencyMatrix(g1)
-                    S1 = np.linalg.inv(np.identity(len(g1))+(epsilon**2)*D -epsilon*A)
-
-                    # S2
-                    D, A = DeltaCon0.degreeAndAdjacencyMatrix(g2)
-                    epsilon = 1 / (1 + DeltaCon0.maxDegree(g2))
-                    S2 = np.linalg.inv(np.identity(len(g2))+(epsilon**2)*D -epsilon*A)
-
-
-                    comparison_matrix[i,j] = 1/(1+DeltaCon0.rootED(S1,S2))
-                    comparison_matrix[j,i] = comparison_matrix[i,j]
-                else:
-                    comparison_matrix[i, j] = 0.
-                comparison_matrix[j, i] = comparison_matrix[i, j]
-
-
-        return comparison_matrix
-
-    @staticmethod
-    def rootED(S1,S2):
-        return np.sqrt(np.sum((S1-S2)**2)) # Long live numpy !
-
-    @staticmethod
-    def degreeAndAdjacencyMatrix(G):
-        """
-        Return the Degree(D) and Adjacency Matrix(A) from a graph G.
-        Inspired of nx.laplacian_matrix(G,nodelist,weight) code proposed by networkx
-        :param G:
-        :return:
-        """
-        A = nx.to_scipy_sparse_matrix(G, nodelist=G.nodes(), weight="weight",
-                                      format='csr')
-        n, m = A.shape
-        diags = A.sum(axis=1)
-        D = scipy.sparse.spdiags(diags.flatten(), [0], m, n, format='csr')
-
-        return D, A
-    @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
-
-class DeltaCon():
-    __type__ = "sim"
-
-    @staticmethod
-    def relabel_nodes(graph_list):
-        label_lookup = {}
-        label_counter = 0
-        n= len(graph_list)
-        # label_lookup is an associative array, which will contain the
-        # mapping from multiset labels (strings) to short labels
-        # (integers)
-        for i in range(n):
-            nodes = graph_list[i].nodes()
-
-            for j in range(len(nodes)):
-                if not (nodes[j] in label_lookup):
-                    label_lookup[nodes[j]] = label_counter
-                    label_counter += 1
-
-            graph_list[i] = nx.relabel_nodes(graph_list[i], label_lookup)
-        return graph_list
-    @staticmethod
-    def compare(list_gs, g=3):
-        n=len(list_gs)
-        list_gs=DeltaCon.relabel_nodes(list_gs)
-        comparison_matrix = np.zeros((n,n))
-        for i in range(n):
-            for j in range(i,n):
-                g1,g2=list_gs[i],list_gs[j]
-
-                V = g1.nodes()
-                V.extend(g2.nodes())
-                V=np.unique(V)
-
-                partitions=V.copy()
-                np.random.shuffle(partitions)
-                if len(partitions)< g:
-                    partitions=np.array([partitions])
-                else:
-                    partitions=np.array_split(partitions,g)
-                partitions_e_1 = DeltaCon.partitions2e(partitions, g1.nodes())
-                partitions_e_2 = DeltaCon.partitions2e(partitions, g2.nodes())
-                S1,S2=[],[]
-                for k in range(len(partitions)):
-                    s0k1,s0k2=partitions_e_1[k],partitions_e_2[k]
-
-                    # S1
-                    epsilon = 1/(1+DeltaCon0.maxDegree(g1))
-                    D, A = DeltaCon0.degreeAndAdjacencyMatrix(g1)
-                    s1k = np.linalg.inv(np.identity(len(g1))+(epsilon**2)*D -epsilon*A)
-                    s1k=np.linalg.solve(s1k,s0k1).tolist()
-
-                    # S2
-                    D, A = DeltaCon0.degreeAndAdjacencyMatrix(g2)
-                    epsilon = 1 / (1 + DeltaCon0.maxDegree(g2))
-                    s2k= np.linalg.inv(np.identity(len(g2))+(epsilon**2)*D -epsilon*A)
-                    s2k = np.linalg.solve(s2k, s0k2).tolist()
-
-
-
-                    S1.append(s1k)
-                    S2.append(s2k)
-
-                comparison_matrix[i,j] = 1/(1+DeltaCon0.rootED(np.array(S1),np.array(S2)))
-                comparison_matrix[j,i] = comparison_matrix[i,j]
-
-        return comparison_matrix
-
-
-    @staticmethod
-    def partitions2e( partitions, V):
-        e = [ [] for i in range(len(partitions))]
-        for p in range(len(partitions)):
-            e[p] = []
-            for i in range(len(V)):
-                if i in partitions[p]:
-                    e[p].append(1.0)
-                else:
-                    e[p].append(0.0)
-        return e
\ No newline at end of file
diff --git a/gmatch4py_cython/gmatch4py/exception/__init__.py b/gmatch4py_cython/gmatch4py/exception/__init__.py
deleted file mode 100644
index 950f6351f2b5c063c306b42eb677bb9695abdd58..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/exception/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# coding = utf-8
\ No newline at end of file
diff --git a/gmatch4py_cython/gmatch4py/ged/__init__.py b/gmatch4py_cython/gmatch4py/ged/__init__.py
deleted file mode 100644
index e5c6c3cf41f050a3a264593b6ecb526318bf65a2..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/ged/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-# coding = utf-8
-
diff --git a/gmatch4py_cython/gmatch4py/ged/algorithm/__init__.py b/gmatch4py_cython/gmatch4py/ged/algorithm/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/gmatch4py_cython/gmatch4py/ged/algorithm/abstract_graph_edit_dist.pyx b/gmatch4py_cython/gmatch4py/ged/algorithm/abstract_graph_edit_dist.pyx
deleted file mode 100644
index 481ec690903c3e1f45897e27af4dbc07129ed377..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/ged/algorithm/abstract_graph_edit_dist.pyx
+++ /dev/null
@@ -1,118 +0,0 @@
-# -*- coding: UTF-8 -*-
-from __future__ import print_function
-
-import sys
-
-import numpy as np
-from scipy.optimize import linear_sum_assignment
-cimport numpy as np
-
-
-class AbstractGraphEditDistance(object):
-
-
-    def __init__(self, g1, g2,debug=False,**kwargs):
-        self.g1 = g1
-        self.g2 = g2
-        self.debug=debug
-
-        self.node_del = kwargs.get("node_del",1)
-        self.node_ins = kwargs.get("node_ins",1)
-        self.edge_del = kwargs.get("edge_del",1)
-        self.edge_ins = kwargs.get("edge_ins",1)
-
-
-    def distance(self):
-        opt_path = self.edit_costs()
-        if self.debug:
-            print("Edit path for ",str(self.__class__.__name__),"\n",opt_path)
-        return sum(opt_path)
-
-    def print_operations(self,cost_matrix,row_ind,col_ind):
-        cdef list nodes1 = self.g1.nodes()
-        cdef list nodes2 = self.g2.nodes()
-        dn1 = self.g1.node
-        dn2 = self.g2.node
-
-        cdef int n=len(nodes1)
-        cdef int m=len(nodes2)
-        cdef int x,y,i
-        for i in range(len(row_ind)):
-            y,x=row_ind[i],col_ind[i]
-            val=cost_matrix[row_ind[i]][col_ind[i]]
-            if x<m and y<n:
-                print("SUB {0} to {1} cost = {2}".format(dn1[nodes1[y]]["label"],dn2[nodes2[x]]["label"],val))
-            elif x <m and y>=n:
-                print("ADD {0} cost = {1}".format(dn2[nodes2[y-n]]["label"],val))
-            elif x>=m and y<n:
-                print("DEL {0} cost = {1}".format(dn1[nodes1[m-x]]["label"],val))
-
-    def edit_costs(self):
-        cdef np.ndarray cost_matrix = self.create_cost_matrix()
-        if self.debug:
-            np.set_printoptions(precision=3)
-            print("Cost Matrix for ",str(self.__class__.__name__),"\n",cost_matrix)
-
-        row_ind,col_ind = linear_sum_assignment(cost_matrix)
-        if self.debug:
-            self.print_operations(cost_matrix,row_ind,col_ind)
-        cdef int f=len(row_ind)
-        return [cost_matrix[row_ind[i]][col_ind[i]] for i in range(f)]
-
-    def create_cost_matrix(self):
-        """
-        Creates a |N+M| X |N+M| cost matrix between all nodes in
-        graphs g1 and g2
-        Each cost represents the cost of substituting,
-        deleting or inserting a node
-        The cost matrix consists of four regions:
-
-        substitute 	| insert costs
-        -------------------------------
-        delete 		| delete -> delete
-
-        The delete -> delete region is filled with zeros
-        """
-        cdef int n = len(self.g1)
-        cdef int m = len(self.g2)
-        cdef np.ndarray cost_matrix = np.zeros((n+m,n+m))
-        #cost_matrix = [[0 for i in range(n + m)] for j in range(n + m)]
-        cdef list nodes1 = self.g1.nodes()
-        cdef list nodes2 = self.g2.nodes()
-        cdef int i,j
-        for i in range(n):
-            for j in range(m):
-                cost_matrix[i,j] = self.substitute_cost(nodes1[i], nodes2[j])
-
-        for i in range(m):
-            for j in range(m):
-                cost_matrix[i+n,j] = self.insert_cost(i, j, nodes2)
-
-        for i in range(n):
-            for j in range(n):
-                cost_matrix[j,i+m] = self.delete_cost(i, j, nodes1)
-
-        self.cost_matrix = cost_matrix
-        return cost_matrix
-
-    def insert_cost(self, int i, int j):
-        raise NotImplementedError
-
-    def delete_cost(self, int i, int j):
-        raise NotImplementedError
-
-    def substitute_cost(self, nodes1, nodes2):
-        raise NotImplementedError
-
-    def print_matrix(self):
-        print("cost matrix:")
-        print(self.g1.nodes())
-        print(self.g2.nodes())
-        print(np.array(self.create_cost_matrix()))
-        for column in self.create_cost_matrix():
-            for row in column:
-                if row == sys.maxsize:
-                    print ("inf\t")
-                else:
-                    print ("%.2f\t" % float(row))
-            print("")
diff --git a/gmatch4py_cython/gmatch4py/ged/algorithm/edge_edit_dist.pyx b/gmatch4py_cython/gmatch4py/ged/algorithm/edge_edit_dist.pyx
deleted file mode 100644
index 6f0c587ce96f1f9f1e30bba386189546413b831d..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/ged/algorithm/edge_edit_dist.pyx
+++ /dev/null
@@ -1,29 +0,0 @@
-import sys
-
-from gmatch4py_old.ged.algorithm.abstract_graph_edit_dist import AbstractGraphEditDistance
-
-
-class EdgeEditDistance(AbstractGraphEditDistance):
-    """
-    Calculates the graph edit distance between two edges.
-    A node in this context is interpreted as a graph,
-    and edges are interpreted as nodes.
-    """
-
-    def __init__(self, g1, g2,**kwargs):
-        AbstractGraphEditDistance.__init__(self, g1, g2,**kwargs)
-
-    def insert_cost(self, int i, int j, nodes2):
-        if i == j:
-            return self.edge_ins
-        return sys.maxsize
-
-    def delete_cost(self, int i, int j, nodes1):
-        if i == j:
-            return self.edge_del
-        return sys.maxsize
-
-    def substitute_cost(self, edge1, edge2):
-        if edge1 == edge2:
-            return 0.
-        return self.edge_del+self.edge_ins
diff --git a/gmatch4py_cython/gmatch4py/ged/algorithm/graph_edit_dist.pyx b/gmatch4py_cython/gmatch4py/ged/algorithm/graph_edit_dist.pyx
deleted file mode 100644
index 1dcd1e9bdf5a69bd1c64a888eaa4bace4b8f6898..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/ged/algorithm/graph_edit_dist.pyx
+++ /dev/null
@@ -1,72 +0,0 @@
-# -*- coding: UTF-8 -*-
-
-import sys
-
-import networkx as nx
-
-from gmatch4py_old.ged.algorithm.abstract_graph_edit_dist import AbstractGraphEditDistance
-from gmatch4py_old.ged.algorithm.edge_edit_dist import EdgeEditDistance
-from gmatch4py_old.ged.graph.edge_graph import EdgeGraph
-
-
-def compare(g1, g2, print_details=False):
-    ged = GraphEditDistance(g1, g2,print_details)
-    return ged.distance()
-
-
-class GraphEditDistance(AbstractGraphEditDistance):
-
-    def __init__(self, g1, g2,debug=False,**kwargs):
-        AbstractGraphEditDistance.__init__(self, g1, g2,debug,**kwargs)
-
-    def substitute_cost(self, node1, node2):
-        return self.relabel_cost(node1, node2) + self.edge_diff(node1, node2)
-
-    def relabel_cost(self, node1, node2):
-        if node1 == node2:
-            edges1=set(self.get_edge_multigraph(self.g1,node1))
-            edges2=set(self.get_edge_multigraph(self.g2,node2))
-            return abs(len(edges2.difference(edges1))) # Take in account if there is a different number of edges
-        else:
-            return self.node_ins+self.node_del
-
-    def delete_cost(self, int i, int j, nodes1):
-        if i == j:
-            return self.node_del+self.g1.degree(nodes1[i]) # Deleting a node implicate to delete in and out edges
-        return sys.maxsize
-
-    def insert_cost(self, int i, int j, nodes2):
-        if i == j:
-            deg=self.g2.degree(nodes2[j])
-            if isinstance(deg,dict):deg=0
-            return self.node_ins+deg
-        else:
-            return sys.maxsize
-
-    def get_edge_multigraph(self,g,node):
-        cdef list edges=[]
-        for id_,val in g.edge[node].items():
-            if not 0 in val:
-                edges.append(str(id_) + val["color"])
-            else:
-                for _,edge in val.items():
-                    edges.append(str(id_)+edge["color"])
-        return edges
-
-    def edge_diff(self, node1, node2):
-        cdef list edges1,edges2
-        if isinstance(self.g1,nx.MultiDiGraph):
-            edges1 = self.get_edge_multigraph(self.g1,node1)
-            edges2 = self.get_edge_multigraph(self.g2,node2)
-        else:
-            edges1 = list(self.g1.edge[node1].keys())
-            edges2 = list(self.g2.edge[node2].keys())
-        if len(edges1) == 0 or len(edges2) == 0:
-            return max(len(edges1), len(edges2))
-
-        edit_edit_dist = EdgeEditDistance(
-            EdgeGraph(node1,edges1),
-            EdgeGraph(node2,edges2),
-            edge_del=self.edge_del,edge_ins=self.edge_ins,node_ins=self.node_ins,node_del=self.node_del
-        )
-        return edit_edit_dist.distance()
diff --git a/gmatch4py_cython/gmatch4py/ged/approximate_ged.pyx b/gmatch4py_cython/gmatch4py/ged/approximate_ged.pyx
deleted file mode 100644
index 27ea4371ad287ebd14b05a613d9b02025a2f8651..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/ged/approximate_ged.pyx
+++ /dev/null
@@ -1,33 +0,0 @@
-# coding = utf-8
-
-import numpy as np
-
-from .algorithm.graph_edit_dist import GraphEditDistance
-from cython.parallel import prange
-
-class ApproximateGraphEditDistance():
-    __type__ = "dist"
-
-    @staticmethod
-    def compare(listgs,selected,c_del_node=1,c_del_edge=1,c_ins_node=1,c_ins_edge=1):
-        cdef int n= len(listgs)
-        cdef double[:,:] comparison_matrix = np.zeros((n,n))
-        cdef int i,j
-        for i in prange(n,nogil=True):
-            for j in range(i,n):
-                with gil:
-                    f=True
-                    if not listgs[i] or not listgs[j]:
-                        f=False
-                    elif len(listgs[i])== 0 or len(listgs[j]) == 0:
-                        f=False
-                    if selected:
-                        if not i in selected:
-                            f=False
-
-                    if f:
-                        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()
-                    else:
-                        comparison_matrix[i][j] = np.inf
-                    comparison_matrix[j][i] = comparison_matrix[i][j]
-        return comparison_matrix
\ No newline at end of file
diff --git a/gmatch4py_cython/gmatch4py/ged/bipartite_graph_matching_2.pyx b/gmatch4py_cython/gmatch4py/ged/bipartite_graph_matching_2.pyx
deleted file mode 100644
index d6d68e653e0ab3da6572087108b472ad341f6b97..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/ged/bipartite_graph_matching_2.pyx
+++ /dev/null
@@ -1,161 +0,0 @@
-# coding = utf-8
-import numpy as np
-cimport numpy as np
-
-cdef class BP_2():
-    """
-
-    """
-    __type__="dist"
-
-    cdef int node_del
-    cdef int node_ins
-    cdef int edge_del
-    cdef int edge_ins
-
-    @staticmethod
-    def compare(listgs,selected, c_del_node=1, c_del_edge=1, c_ins_node=1, c_ins_edge=1):
-        cdef int n = len(listgs)
-        comparator = BP_2(c_del_node, c_ins_node, c_del_edge, c_ins_edge)
-        cdef np.ndarray comparison_matrix = np.zeros((n, n))
-        for i in range(n):
-            for j in range(i, n):
-                f=True
-                if not listgs[i] or not listgs[j]:
-                    f=False
-                elif len(listgs[i])== 0 or len(listgs[j]) == 0:
-                    f=False
-                if selected:
-                    if not i in selected:
-                        f=False
-                if f:
-                    comparison_matrix[i, j] = comparator.bp2(listgs[i], listgs[j])
-                else:
-                    comparison_matrix[i, j] = np.inf
-                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"""
-        self.node_del = node_del
-        self.node_ins = node_ins
-        self.edge_del = edge_del
-        self.edge_ins = edge_ins
-
-    def bp2(self, g1, g2):
-        """
-        Compute de Hausdorff Edit Distance
-        :param g1: first graph
-        :param g2: second graph
-        :return:
-        """
-        return np.min(self.distance(self.psi(g1,g2)),self.distance(self.psi(g2,g1)))
-
-    def distance(self,e):
-        return np.sum(e)
-
-    cdef list psi(self,g1,g2):
-        cdef list psi_=[]
-        cdef list nodes1 = g1.nodes()
-        cdef list nodes2 = g2.nodes()
-        for u in nodes1:
-            v=None
-            for w in nodes2:
-                if 2*self.fuv(g1,g2,u,w) < self.fuv(g1,g2,u,None) + self.fuv(g1,g2,None,w)\
-                     and self.fuv(g1,g2,u,w) < self.fuv(g1,g2,u,v):
-                    v=w
-                psi_.append(self.fuv(g1,g2,u,v))
-            if u:
-                nodes1= list(set(nodes1).difference(set([u])))
-            if v:
-                nodes2= list(set(nodes2).difference(set([v])))
-        for v in nodes2:
-            psi_.append(self.fuv(g1,g2,None,v))
-        return  psi_
-
-
-    cdef float fuv(self, g1, g2, n1, n2):
-        """
-        Compute the Node Distance function
-        :param g1: first graph
-        :param g2: second graph
-        :param n1: node of the first graph
-        :param n2: node of the second graph
-        :return:
-        """
-        if n2 == None:  # Del
-            return self.node_del + ((self.edge_del / 2) * g1.degree(n1))
-        if n1 == None:  # Insert
-            return self.node_ins + ((self.edge_ins / 2) * g2.degree(n2))
-        else:
-            if n1 == n2:
-                return 0.
-            return (self.node_del + self.node_ins + self.hed_edge(g1, g2, n1, n2)) / 2
-
-    cdef float hed_edge(self, g1, g2, n1, n2):
-        """
-        Compute HEDistance between edges of n1 and n2, respectively in g1 and g2
-        :param g1: first graph
-        :param g2: second graph
-        :param n1: node of the first graph
-        :param n2: node of the second graph
-        :return:
-        """
-        return self.sum_gpq(g1, n1, g2, n2) + self.sum_gpq(g1, n1, g2, n2)
-
-    cdef list get_edge_multigraph(self, g, node):
-        """
-        Get list of edge around a node in a Multigraph
-        :param g: multigraph
-        :param node: node in the multigraph
-        :return:
-        """
-
-        cdef list originals_ = g.edges(node, data=True)
-        cdef int n= len(originals_)
-        if n == 0:
-            return []
-
-        cdef list edges = [""]*n
-        for i in range(n):
-            edge=originals_[i]
-            edges[i]=("{0}-{1}".format(edge[0],edge[1]))
-        return edges
-
-    cdef float sum_gpq(self, g1, n1, g2, n2):
-        """
-        Compute Nearest Neighbour Distance between edges around n1 in G1  and edges around n2 in G2
-        :param g1: first graph
-        :param n1: node in the first graph
-        :param g2: second graph
-        :param n2: node in the second graph
-        :return:
-        """
-        cdef list edges1 = self.get_edge_multigraph(g1, n1)
-        cdef list edges2 = self.get_edge_multigraph(g2, n2)
-        edges2.extend([None])
-        cdef np.ndarray min_sum = np.zeros(len(edges1))
-        for i in range(len(edges1)):
-            min_i = np.zeros(len(edges2))
-            for j in range(len(edges2)):
-                min_i[j] = self.gpq(edges1[i], edges2[j])
-            min_sum[i] = np.min(min_i)
-        return np.sum(min_sum)
-
-    cdef float gpq(self, e1, e2):
-        """
-        Compute the edge distance function
-        :param e1: edge1
-        :param e2: edge2
-        :return:
-        """
-        if e2 == None:  # Del
-            return self.edge_del
-        if e1 == None:  # Insert
-            return self.edge_ins
-        else:
-            if e1 == e2:
-                return 0.
-            return (self.edge_del + self.edge_ins) / 2
-
diff --git a/gmatch4py_cython/gmatch4py/ged/graph/__init__.py b/gmatch4py_cython/gmatch4py/ged/graph/__init__.py
deleted file mode 100644
index 950f6351f2b5c063c306b42eb677bb9695abdd58..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/ged/graph/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# coding = utf-8
\ No newline at end of file
diff --git a/gmatch4py_cython/gmatch4py/ged/graph/__init__.pyx b/gmatch4py_cython/gmatch4py/ged/graph/__init__.pyx
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/gmatch4py_cython/gmatch4py/ged/graph/edge_graph.pyx b/gmatch4py_cython/gmatch4py/ged/graph/edge_graph.pyx
deleted file mode 100644
index 24b8bda1ed36c399cbe58eb0115b2cee4d85841d..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/ged/graph/edge_graph.pyx
+++ /dev/null
@@ -1,16 +0,0 @@
-# -*- coding: UTF-8 -*-
-
-
-class EdgeGraph():
-
-    def __init__(self, init_node, nodes):
-        self.init_node=init_node
-        self.nodes_ = nodes
-        self.edge=nodes
-    def nodes(self):
-        return self.nodes_
-
-    def size(self):
-        return len(self.nodes)
-    def __len__(self):
-        return len(self.nodes_)
diff --git a/gmatch4py_cython/gmatch4py/ged/greedy_edit_distance.pyx b/gmatch4py_cython/gmatch4py/ged/greedy_edit_distance.pyx
deleted file mode 100644
index 77520305011396a5b41f36f40394d415ea2d5efe..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/ged/greedy_edit_distance.pyx
+++ /dev/null
@@ -1,55 +0,0 @@
-# coding = utf-8
-import numpy as np
-
-from .algorithm.graph_edit_dist import GraphEditDistance
-cimport numpy as np
-
-class GreedyEditDistance(GraphEditDistance):
-    """
-    Implementation of the Greedy Edit Distance presented in :
-
-    Improved quadratic time approximation of graph edit distance by Hausdorff matching and greedy assignement
-    Andreas Fischer, Kaspar Riesen, Horst Bunke
-    2016
-    """
-    __type__ = "dist"
-    @staticmethod
-    def compare(listgs, selected, c_del_node=1, c_del_edge=1, c_ins_node=1, c_ins_edge=1):
-        cdef int n = len(listgs)
-        cdef np.ndarray comparison_matrix = np.zeros((n, n))
-        for i in range(n):
-            for j in range(i, n):
-                f=True
-                if not listgs[i] or not listgs[j]:
-                    f=False
-                elif len(listgs[i])== 0 or len(listgs[j]) == 0:
-                    f=False
-                if selected:
-                    if not i in selected:
-                        f=False
-                if f:
-                    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()
-                else:
-                    comparison_matrix[i, j] =  np.inf
-                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,**kwargs)
-
-
-    def edit_costs(self):
-        cdef np.ndarray cost_matrix=self.create_cost_matrix()
-        cdef np.ndarray cost_matrix_2=cost_matrix.copy()
-        cdef list psi=[]
-        for i in range(len(cost_matrix)):
-            phi_i=np.argmin((cost_matrix[i]))
-            cost_matrix=np.delete(cost_matrix,phi_i,1)
-            psi.append([i,phi_i+i]) #+i to compensate the previous column deletion
-        return [cost_matrix_2[psi[i][0]][psi[i][1]] for i in range(len(psi))]
-
diff --git a/gmatch4py_cython/gmatch4py/ged/hausdorff_edit_distance.pyx b/gmatch4py_cython/gmatch4py/ged/hausdorff_edit_distance.pyx
deleted file mode 100644
index 06dc664ca5bb863aced9297c7687db8e7a2f6298..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/ged/hausdorff_edit_distance.pyx
+++ /dev/null
@@ -1,171 +0,0 @@
-# coding = utf-8
-
-import numpy as np
-cimport numpy as np
-#from libcpp.list cimport list as cpplist
-cdef class HED:
-    """
-    Implementation of Hausdorff Edit Distance described in
-
-    Improved quadratic time approximation of graph edit distance by Hausdorff matching and greedy assignement
-    Andreas Fischer, Kaspar Riesen, Horst Bunke
-    2016
-    """
-
-    cdef int node_del
-    cdef int node_ins
-    cdef int edge_del
-    cdef int edge_ins
-
-    __type__ = "dist"
-    @staticmethod
-    def compare(list listgs, selected, int c_del_node=1, int c_del_edge=1, int c_ins_node=1, int c_ins_edge=1):
-        cdef int n = len(listgs)
-        comparator = HED(c_del_node, c_ins_node, c_del_edge, c_ins_edge)
-        cdef np.ndarray comparison_matrix = np.zeros((n, n))
-        for i in range(n):
-            for j in range(i, n):
-                f=True
-                if not listgs[i] or not listgs[j]:
-                    f=False
-                elif len(listgs[i])== 0 or len(listgs[j]) == 0:
-                    f=False
-                if selected:
-                    if not i in selected:
-                        f=False
-                if f:
-                    comparison_matrix[i, j] = comparator.hed(listgs[i], listgs[j])
-                else:
-                    comparison_matrix[i, j] = np.inf
-                comparison_matrix[j, i] = comparison_matrix[i, j]
-
-        return comparison_matrix
-
-
-    def __init__(self, int node_del=1, int node_ins=1, int edge_del=1, int edge_ins=1):
-        """Constructor for HED"""
-        self.node_del = node_del
-        self.node_ins = node_ins
-        self.edge_del = edge_del
-        self.edge_ins = edge_ins
-
-    cpdef float hed(self, g1, g2):
-        """
-        Compute de Hausdorff Edit Distance
-        :param g1: first graph
-        :param g2: second graph
-        :return:
-        """
-        return self.sum_fuv(g1, g2) + self.sum_fuv(g2, g1)
-
-    cdef float sum_fuv(self, g1, g2):
-        """
-        Compute Nearest Neighbour Distance between G1 and G2
-        :param g1: First Graph
-        :param g2: Second Graph
-        :return:
-        """
-        cdef np.ndarray min_sum = np.zeros(len(g1))
-        nodes1 = g1.nodes()
-        nodes2 = g2.nodes()
-        nodes2.extend([None])
-        cdef np.ndarray min_i
-        for i in range(len(nodes1)):
-            min_i = np.zeros(len(nodes2))
-            for j in range(len(nodes2)):
-                min_i[j] = self.fuv(g1, g2, nodes1[i], nodes2[j])
-            min_sum[i] = np.min(min_i)
-        return np.sum(min_sum)
-
-    cdef float fuv(self, g1, g2, n1, n2):
-        """
-        Compute the Node Distance function
-        :param g1: first graph
-        :param g2: second graph
-        :param n1: node of the first graph
-        :param n2: node of the second graph
-        :return:
-        """
-        if n2 == None:  # Del
-            return self.node_del + ((self.edge_del / 2) * g1.degree(n1))
-        if n1 == None:  # Insert
-            return self.node_ins + ((self.edge_ins / 2) * g2.degree(n2))
-        else:
-            if n1 == n2:
-                return 0
-            return (self.node_del + self.node_ins + self.hed_edge(g1, g2, n1, n2)) / 2
-
-    cdef float hed_edge(self, g1, g2, n1, n2):
-        """
-        Compute HEDistance between edges of n1 and n2, respectively in g1 and g2
-        :param g1: first graph
-        :param g2: second graph
-        :param n1: node of the first graph
-        :param n2: node of the second graph
-        :return:
-        """
-        return self.sum_gpq(g1, n1, g2, n2) + self.sum_gpq(g1, n1, g2, n2)
-
-    cdef list get_edge_multigraph(self, g, node):
-        """
-        Get list of edge around a node in a Multigraph
-        :param g: multigraph
-        :param node: node in the multigraph
-        :return:
-        """
-
-        cdef list originals_ = g.edges(node, data=True)
-        cdef int n= len(originals_)
-        if n == 0:
-            return []
-
-
-        cdef list edges = [""]*n
-        for i in range(n):
-            edge=originals_[i]
-            edges[i]=("{0}-{1}".format(edge[0],edge[1]))
-        return edges
-
-    cdef float  sum_gpq(self, g1, n1, g2, n2):
-        """
-        Compute Nearest Neighbour Distance between edges around n1 in G1  and edges around n2 in G2
-        :param g1: first graph
-        :param n1: node in the first graph
-        :param g2: second graph
-        :param n2: node in the second graph
-        :return:
-        """
-
-        #if isinstance(g1, nx.MultiDiGraph):
-        cdef list edges1 = self.get_edge_multigraph(g1, n1)
-        cdef list edges2 = self.get_edge_multigraph(g2, n2)
-
-        #else:
-            #edges1 = [str(n1 + "-" + ef) for ef in list(g1.edge[n1].keys())]
-            #edges2 = [str(n2 + "-" + ef) for ef in list(g2.edge[n2].keys())]
-
-        cdef np.ndarray min_sum = np.zeros(len(edges1))
-        edges2.extend([None])
-        cdef np.ndarray min_i
-        for i in range(len(edges1)):
-            min_i = np.zeros(len(edges2))
-            for j in range(len(edges2)):
-                min_i[j] = self.gpq(edges1[i], edges2[j])
-            min_sum[i] = np.min(min_i)
-        return np.sum(min_sum)
-
-    cdef float gpq(self, str e1, str e2):
-        """
-        Compute the edge distance function
-        :param e1: edge1
-        :param e2: edge2
-        :return:
-        """
-        if e2 == None:  # Del
-            return self.edge_del
-        if e1 == None:  # Insert
-            return self.edge_ins
-        else:
-            if e1 == e2:
-                return 0
-            return (self.edge_del + self.edge_ins) / 2
diff --git a/gmatch4py_cython/gmatch4py/graph_matching_algorithm.pyx b/gmatch4py_cython/gmatch4py/graph_matching_algorithm.pyx
deleted file mode 100644
index 5b2ed35470875d50570b1836b19320d4d18d00d6..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/graph_matching_algorithm.pyx
+++ /dev/null
@@ -1,37 +0,0 @@
-# coding = utf-8
-import numpy as np
-cimport numpy as np
-
-cdef class GraphMatchingAlgorithm:
-
-    def __init__(self,type="distance",max_value="inf"):
-        self.type=type
-        self.maxvalue=max_value
-
-    def comparator(self,g1, g2, int c_del_node, int c_del_edge, int c_ins_node, int c_ins_edge,h):
-        pass
-
-    def null_value(self):
-        if self.type == "distance":
-            return np.nan
-        else: # if similarity
-            return 0
-
-    def compare(self,list listgs, selected=None, int c_del_node=1, int c_del_edge=1, int c_ins_node=1, int c_ins_edge=1,int h=2):
-        n = len(listgs)
-        comparison_matrix = np.zeros((n, n))
-        for i in range(n):
-            for j in range(i, n):
-                f=True
-                if not listgs[i] or not listgs[j]:
-                    f=False
-                if selected:
-                    if not i in selected:
-                        f=False
-                if f:
-                    comparison_matrix[i, j] = self.comparator(listgs[i], listgs[j],c_del_node=c_del_node, c_del_edge=c_del_edge, c_ins_node=c_ins_node, c_ins_edge=c_ins_edge,h=h)
-                else:
-                    comparison_matrix[i, j] = self.null_value()
-                comparison_matrix[j, i] = comparison_matrix[i, j]
-
-        return comparison_matrix
diff --git a/gmatch4py_cython/gmatch4py/jaccard.pyx b/gmatch4py_cython/gmatch4py/jaccard.pyx
deleted file mode 100644
index 894afc61538fc9f9137d2ef7a8e82e0aa9e1c1c7..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/jaccard.pyx
+++ /dev/null
@@ -1,95 +0,0 @@
-# coding = utf-8
-
-# coding = utf-8
-
-import numpy as np
-cimport numpy as np
-
-def intersect(a, b):
-    return list(set(a) & set(b))
-class Jaccard():
-    __type__ = "sim"
-
-
-    @staticmethod
-    def compare(listgs,selected):
-        cdef int n = len(listgs)
-        cdef np.ndarray comparison_matrix = np.zeros((n, n))
-        cdef i=0
-        cdef j=0
-        for i in range(n):
-            for j in range(i,n):
-                g1 = listgs[i]
-                g2 = listgs[j]
-                f=True
-                if not listgs[i] or not listgs[j]:
-                    f=False
-                elif len(listgs[i])== 0 or len(listgs[j]) == 0:
-                    f=False
-                if selected:
-                    if not i in selected:
-                        f=False
-                if f:
-                    inter_ver,inter_ed = Jaccard.intersect_graph(g1,g2)
-                    un_ver,un_edg=Jaccard.union_nodes(g1,g2),Jaccard.union_edges(g1,g2)
-                    if len(un_ver) == 0 or len(un_edg) == 0:
-                        comparison_matrix[i, j] = 0.
-                    else:
-                        comparison_matrix[i,j]=(len(inter_ver)/len(un_ver))*(len(inter_ed)/len(un_edg))
-                else:
-                    comparison_matrix[i, j] = 0.
-
-                comparison_matrix[j, i] = comparison_matrix[i, j]
-
-        return comparison_matrix
-
-
-    @staticmethod
-    def intersect_edges(g1,g2):
-        cdef list ed1 = Jaccard.transform_edges(g1.edges(data=True))
-        cdef list ed2 = Jaccard.transform_edges(g2.edges(data=True))
-        cdef list inter_ed=[]
-        for e1 in ed1:
-            for e2 in ed2:
-                if e1 == e2:
-                    inter_ed.append(e1)
-        return inter_ed
-
-    @staticmethod
-    def union_nodes(g1, g2):
-        cdef set union=set([])
-        for n in g1.nodes():union.add(n)
-        for n in g2.nodes(): union.add(n)
-        return union
-
-    @staticmethod
-    def union_edges(g1, g2):
-        cdef list ed1 = Jaccard.transform_edges(g1.edges(data=True))
-        cdef list ed2 = Jaccard.transform_edges(g2.edges(data=True))
-        cdef list union = []
-        cdef set register=set([])
-        trans_=lambda x : "{0}-{1}:{2}".format(x[0],x[1],x[2]["color"])
-        for e1 in ed1:
-            if not trans_(e1) in register:
-                union.append(e1)
-                register.add(trans_(e1))
-        for e2 in ed2:
-            if not trans_(e2) in register:
-                union.append(e2)
-                register.add(trans_(e2))
-        return union
-    @staticmethod
-    def intersect_nodes(g1,g2):
-        return intersect(g1.nodes(),g2.nodes())
-
-    @staticmethod
-    def intersect_graph(g1,g2):
-        return Jaccard.intersect_nodes(g1,g2),Jaccard.intersect_edges(g1,g2)
-
-    @staticmethod
-    def transform_edges(ed):
-        for e in range(len(ed)):
-            if "id" in ed[e][-1]:
-                del ed[e][-1]["id"]
-        return ed
-
diff --git a/gmatch4py_cython/gmatch4py/kernels/__init__.py b/gmatch4py_cython/gmatch4py/kernels/__init__.py
deleted file mode 100644
index 950f6351f2b5c063c306b42eb677bb9695abdd58..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/kernels/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# coding = utf-8
\ No newline at end of file
diff --git a/gmatch4py_cython/gmatch4py/kernels/random_walk_kernel.pyx b/gmatch4py_cython/gmatch4py/kernels/random_walk_kernel.pyx
deleted file mode 100644
index d780eb08273d0c77232d3ebdab446c902e13ac59..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/kernels/random_walk_kernel.pyx
+++ /dev/null
@@ -1,93 +0,0 @@
-# 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):
-                if len(listgs[i]) <1 or len(listgs[j]) <1:
-                    comparison_matrix[i, j] = 0
-                    comparison_matrix[j, i] = 0
-                    continue
-                direct_product_graph=nx.tensor_product(listgs[i],listgs[j])
-                Ax = nx.adjacency_matrix(direct_product_graph).todense()
-                try:
-                    la = 1/ ((GeometricRandomWalkKernel.maxDegree(direct_product_graph)**2)+1) # lambda value
-                except:
-                    la= pow(1,-6)
-                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
-
-                    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]
-        print(comparison_matrix)
-        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,1,1]):
-        k=len(lambda_list)
-        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):
-                if len(listgs[i]) <1 or len(listgs[j]) <1:
-                    comparison_matrix[i, j] = 0
-                    comparison_matrix[j, i] = 0
-                    continue
-                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_)/(len(listgs[i])**2 * len(listgs[j])**2)
-                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
diff --git a/gmatch4py_cython/gmatch4py/kernels/shortest_path_kernel.pyx b/gmatch4py_cython/gmatch4py/kernels/shortest_path_kernel.pyx
deleted file mode 100644
index e7e7444f49afd0a2af30cfff17a9ef3b3a2209d9..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/kernels/shortest_path_kernel.pyx
+++ /dev/null
@@ -1,88 +0,0 @@
-# coding = utf-8
-
-"""
-Shortest-Path graph kernel.
-Python implementation based on: "Shortest-path kernels on graphs", by
-Borgwardt, K.M.; Kriegel, H.-P., in Data Mining, Fifth IEEE
-International Conference on , vol., no., pp.8 pp.-, 27-30 Nov. 2005
-doi: 10.1109/ICDM.2005.132
-Author : Sandro Vega-Pons, Emanuele Olivetti
-Modified by : Jacques Fize
-"""
-
-import networkx as nx
-import numpy as np
-
-
-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.
-        Parameters
-        ----------
-        g1 : networkx.Graph
-            First graph.
-        g2 : networkx.Graph
-            Second graph.
-        Returns
-        -------
-        k : The similarity value between g1 and g2.
-        """
-        # Diagonal superior matrix of the floyd warshall shortest
-        # paths:
-        fwm1 = np.array(nx.floyd_warshall_numpy(g_1))
-        fwm1 = np.where(fwm1 == np.inf, 0, fwm1)
-        fwm1 = np.where(fwm1 == np.nan, 0, fwm1)
-        fwm1 = np.triu(fwm1, k=1)
-        bc1 = np.bincount(fwm1.reshape(-1).astype(int))
-
-        fwm2 = np.array(nx.floyd_warshall_numpy(g_2))
-        fwm2 = np.where(fwm2 == np.inf, 0, fwm2)
-        fwm2 = np.where(fwm2 == np.nan, 0, fwm2)
-        fwm2 = np.triu(fwm2, k=1)
-        bc2 = np.bincount(fwm2.reshape(-1).astype(int))
-
-        # Copy into arrays with the same length the non-zero shortests
-        # paths:
-        v1 = np.zeros(max(len(bc1), len(bc2)) - 1)
-        v1[range(0, len(bc1)-1)] = bc1[1:]
-
-        v2 = np.zeros(max(len(bc1), len(bc2)) - 1)
-        v2[range(0, len(bc2)-1)] = bc2[1:]
-
-        return np.sum(v1 * v2)
-
-
-    @staticmethod
-    def compare_list(graph_list, verbose=False):
-        """Compute the all-pairs kernel values for a list of graphs.
-        This function can be used to directly compute the kernel
-        matrix for a list of graphs. The direct computation of the
-        kernel matrix is faster than the computation of all individual
-        pairwise kernel values.
-        Parameters
-        ----------
-        graph_list: list
-            A list of graphs (list of networkx graphs)
-        Return
-        ------
-        K: numpy.array, shape = (len(graph_list), len(graph_list))
-        The similarity matrix of all graphs in graph_list.
-        """
-        n = len(graph_list)
-        k = np.zeros((n, n))
-        for i in range(n):
-            for j in range(i, n):
-                k[i, j] = ShortestPathGraphKernel.compare(graph_list[i], graph_list[j])
-                k[j, i] = k[i, j]
-
-        k_norm = np.zeros(k.shape)
-        for i in range(k.shape[0]):
-            for j in range(k.shape[1]):
-                k_norm[i, j] = k[i, j] / np.sqrt(k[i, i] * k[j, j])
-
-        return k_norm
\ No newline at end of file
diff --git a/gmatch4py_cython/gmatch4py/kernels/weisfeiler_lehman.pyx b/gmatch4py_cython/gmatch4py/kernels/weisfeiler_lehman.pyx
deleted file mode 100644
index 2731f0fc0ac0e29e48e86b129835aa7d43e9dc4f..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/kernels/weisfeiler_lehman.pyx
+++ /dev/null
@@ -1,143 +0,0 @@
-# coding = utf-8
-
-"""Weisfeiler_Lehman graph kernel.
-
-Python implementation based on: "Weisfeiler-Lehman Graph Kernels", by:
-Nino Shervashidze, Pascal Schweitzer, Erik J. van Leeuwen, Kurt
-Mehlhorn, Karsten M. Borgwardt, JMLR, 2012.
-http://jmlr.csail.mit.edu/papers/v12/shervashidze11a.html
-
-Author : Sandro Vega-Pons, Emanuele Olivetti
-Source : https://github.com/emanuele/jstsp2015/blob/master/gk_weisfeiler_lehman.py
-Modified by : Jacques Fizen
-"""
-
-import copy
-
-import networkx as nx
-import numpy as np
-cimport numpy as np
-
-
-class WeisfeleirLehmanKernel(object):
-    __type__ = "sim"
-    @staticmethod
-    def compare(graph_list,selected,h=2):
-        """Compute the all-pairs kernel values for a list of graphs.
-        This function can be used to directly compute the kernel
-        matrix for a list of graphs. The direct computation of the
-        kernel matrix is faster than the computation of all individual
-        pairwise kernel values.
-        Parameters
-        ----------
-        graph_list: list
-            A list of graphs (list of networkx graphs)
-        h : interger
-            Number of iterations.
-        node_label : boolean
-            Whether to use original node labels. True for using node labels
-            saved in the attribute 'node_label'. False for using the node
-            degree of each node as node attribute.
-        Return
-        ------
-        K: numpy.array, shape = (len(graph_list), len(graph_list))
-        The similarity matrix of all graphs in graph_list.
-        """
-
-        cdef int n = len(graph_list)
-        cdef np.ndarray phi
-        cdef int n_nodes = 0
-        cdef int n_max = 0
-        cdef int i,j
-        # Compute adjacency lists and n_nodes, the total number of
-        # nodes in the dataset.
-        for i in range(n):
-            n_nodes += graph_list[i].number_of_nodes()
-
-            # Computing the maximum number of nodes in the graphs. It
-            # will be used in the computation of vectorial
-            # representation.
-            if (n_max < graph_list[i].number_of_nodes()):
-                n_max = graph_list[i].number_of_nodes()
-
-        phi = np.zeros((n_nodes, n), dtype=np.uint64)
-
-        # INITIALIZATION: initialize the nodes labels for each graph
-        # with their labels or with degrees (for unlabeled graphs)
-
-        cdef list labels = [0] * n
-        cdef dict label_lookup = {}
-        cdef int label_counter = 0
-
-
-        # label_lookup is an associative array, which will contain the
-        # mapping from multiset labels (strings) to short labels
-        # (integers)
-
-        cdef list nodes
-        for i in range(n):
-            nodes = graph_list[i].nodes()
-            # It is assumed that the graph has an attribute
-            # 'node_label'
-            labels[i] = np.zeros(len(nodes), dtype=np.int32)
-
-            for j in range(len(nodes)):
-                if not (nodes[j] in label_lookup):
-                    label_lookup[nodes[j]] = str(label_counter)
-                    labels[i][j] = label_counter
-                    label_counter += 1
-                else:
-                    labels[i][j] = label_lookup[nodes[j]]
-                # labels are associated to a natural number
-                # starting with 0.
-
-                phi[labels[i][j], i] += 1
-
-            graph_list[i]=nx.relabel_nodes(graph_list[i],label_lookup)
-
-        cdef np.ndarray[np.float64_t] k
-        k = np.dot(phi.transpose(), phi)
-
-        # MAIN LOOP
-        cdef int it = 0
-
-        new_labels = copy.deepcopy(labels) # Can't work without it !!!
-
-        while it < h:
-            # create an empty lookup table
-            label_lookup = {}
-            label_counter = 0
-
-            phi = np.zeros((n_nodes, n))
-            for i in range(n):
-                nodes = graph_list[i].nodes()
-                for v in range(len(nodes)):
-                    # form a multiset label of the node v of the i'th graph
-                    # and convert it to a string
-
-                    long_label = []
-                    long_label.extend(nx.neighbors(graph_list[i],nodes[v]))
-
-                    long_label_string = "".join(long_label)
-                    # if the multiset label has not yet occurred, add it to the
-                    # lookup table and assign a number to it
-                    if not (long_label_string in label_lookup):
-                        label_lookup[long_label_string] = str(label_counter)
-                        new_labels[i][v] = label_counter
-                        label_counter += 1
-                    else:
-                        new_labels[i][v] = label_lookup[long_label_string]
-                # fill the column for i'th graph in phi
-                aux = np.bincount(new_labels[i])
-                phi[new_labels[i], i] += aux[new_labels[i]]
-
-            k += np.dot(phi.transpose(), phi)
-            it = it + 1
-
-        # Compute the normalized version of the kernel
-        cdef  np.ndarray[np.float64_t] k_norm = np.zeros((k.shape[0],k.shape[1]))
-        for i in range(k.shape[0]):
-            for j in range(k.shape[1]):
-                k_norm[i, j] = k[i, j] / np.sqrt(k[i, i] * k[j, j])
-
-        return k_norm
\ No newline at end of file
diff --git a/gmatch4py_cython/gmatch4py/kernels/weisfeiler_lehman_edge.pyx b/gmatch4py_cython/gmatch4py/kernels/weisfeiler_lehman_edge.pyx
deleted file mode 100644
index 367e09935d569f4c81584be09b288bbe09fa832a..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/kernels/weisfeiler_lehman_edge.pyx
+++ /dev/null
@@ -1,192 +0,0 @@
-# coding = utf-8
-
-# coding = utf-8# coding = utf-8
-
-from helpers.gazeteer_helpers import get_data,get_data_by_wikidata_id
-
-# coding = utf-8
-
-"""Weisfeiler_Lehman GEO graph kernel.
-
-"""
-
-import numpy as np
-import networkx as nx
-import copy
-
-class WeisfeleirLehmanKernelEdge(object):
-    __type__ = "sim"
-
-
-    @staticmethod
-    def compare(graph_list,h=3):
-        """Compute the all-pairs kernel values for a list of graphs.
-        This function can be used to directly compute the kernel
-        matrix for a list of graphs. The direct computation of the
-        kernel matrix is faster than the computation of all individual
-        pairwise kernel values.
-        Parameters
-        ----------
-        graph_list: list
-            A list of graphs (list of networkx graphs)
-        h : interger
-            Number of iterations.
-        node_label : boolean
-            Whether to use original node labels. True for using node labels
-            saved in the attribute 'node_label'. False for using the node
-            degree of each node as node attribute.
-        Return
-        ------
-        K: numpy.array, shape = (len(graph_list), len(graph_list))
-        The similarity matrix of all graphs in graph_list.
-        """
-
-        n = len(graph_list)
-        k = [0] * (h + 1)
-        n_nodes = 0
-        n_max = 0
-        ams=[nx.adjacency_matrix(g).todense() for g in graph_list]
-        inclusion_dictionnary={}
-
-        # Compute adjacency lists and n_nodes, the total number of
-        # nodes in the dataset.
-        for i in range(n):
-            n_nodes += graph_list[i].number_of_nodes()
-
-            """
-            Store Inclusion Informations
-            """
-            for node in graph_list[i].nodes():
-                graph_list[i].node[node]["id_GD"]=node
-                if not node in inclusion_dictionnary:
-                    inc_list = []
-                    try:
-                        inc_list = get_data(node)["inc_P131"]
-                    except:
-                        try:
-                            inc_list=get_data_by_wikidata_id(get_data(node)["continent"])["id"]
-                        except:
-                            pass # No inclusion
-                    if inc_list:
-                        inc_list = inc_list if isinstance(inc_list,list) else [inc_list]
-
-                        inclusion_dictionnary[node]=inc_list[0]
-                        for j in range(1,len(inc_list)):
-                            if j+1 < len(inc_list):
-                                inclusion_dictionnary[inc_list[j]]=inc_list[j+1]
-
-
-
-
-            # Computing the maximum number of nodes in the graphs. It
-            # will be used in the computation of vectorial
-            # representation.
-            if (n_max < graph_list[i].number_of_nodes()):
-                n_max = graph_list[i].number_of_nodes()
-
-        phi = np.zeros((n_nodes, n), dtype=np.uint64)
-        #print(inclusion_dictionnary)
-        # INITIALIZATION: initialize the nodes labels for each graph
-        # with their labels or with degrees (for unlabeled graphs)
-
-        labels = [0] * n
-        label_lookup = {}
-        label_counter = 0
-
-        # label_lookup is an associative array, which will contain the
-        # mapping from multiset labels (strings) to short labels
-        # (integers)
-        for i in range(n):
-            nodes = graph_list[i].nodes()
-            # It is assumed that the graph has an attribute
-            # 'node_label'
-            labels[i] = np.zeros(len(nodes), dtype=np.int32)
-
-            for j in range(len(nodes)):
-                if not (nodes[j] in label_lookup):
-                    label_lookup[nodes[j]] = str(label_counter)
-                    labels[i][j] = label_counter
-                    label_counter += 1
-                else:
-                    labels[i][j] = label_lookup[nodes[j]]
-                # labels are associated to a natural number
-                # starting with 0.
-
-                phi[labels[i][j], i] += 1
-
-            graph_list[i]=nx.relabel_nodes(graph_list[i],label_lookup)
-
-        L=label_counter
-        print("L1",L)
-        ed=np.zeros((np.int((L*(L+1))),n))
-        # MAIN LOOP
-        it = 0
-        new_labels = copy.deepcopy(labels) # Can't work without it !!!
-
-        for i in range(n):
-            labels_aux =  np.tile(new_labels[i].reshape(-1,1),len(new_labels[i]))
-            a=np.minimum(labels_aux,labels_aux.T)
-            b=np.maximum(labels_aux,np.transpose(labels_aux))
-            I=np.triu((ams[i] !=0),1)
-            a_i=np.extract(I,a)
-            b_i = np.extract(I, b)
-            Ind=np.abs(np.multiply((a[I]-1),(2*L+2-a[I])/2+b[I]-a[I]+1).astype(int))
-            minind=np.min(Ind)
-            aux=np.bincount(Ind)
-            ed[Ind,i]=aux[Ind]
-
-        mask=np.sum(ed,1) !=0
-        ed= ed[mask]
-        k=np.dot(ed.T,ed)
-
-        it = 0
-        new_labels = copy.deepcopy(new_labels)  # Can't work without it !!!
-
-        while it < h:
-            label_lookup={}
-            label_counter=0
-            for i in range(n):
-                nodes = graph_list[i].nodes()
-                for v in range(len(nodes)):
-                    # form a multiset label of the node v of the i'th graph
-                    # and convert it to a string
-
-                    long_label = []
-                    long_label.extend(nx.neighbors(graph_list[i],nodes[v]))
-
-                    long_label_string = "".join(long_label)
-                    # if the multiset label has not yet occurred, add it to the
-                    # lookup table and assign a number to it
-                    if not (long_label_string in label_lookup):
-                        label_lookup[long_label_string] = str(label_counter)
-                        new_labels[i][v] = label_counter
-                        label_counter += 1
-                    else:
-                        new_labels[i][v] = label_lookup[long_label_string]
-
-            L = label_counter
-            print("L2",L)
-            ed = np.zeros((np.int((L * (L + 1))), n))
-            for i in range(n):
-                labels_aux = np.tile(new_labels[i].reshape(-1, 1), len(new_labels[i]))
-                a = np.minimum(labels_aux, labels_aux.T)
-                b = np.maximum(labels_aux, np.transpose(labels_aux))
-                I = np.triu((ams[i] != 0), 1)
-                a_i = np.extract(I, a)
-                b_i = np.extract(I, b)
-                Ind = np.abs(np.multiply((a[I] - 1), (2 * L + 2 - a[I]) / 2 + b[I] - a[I] + 1).astype(int))
-                minind = np.min(Ind)
-                aux = np.bincount(Ind)
-                ed[Ind, i] = aux[Ind]
-
-            mask = np.sum(ed, 1) != 0
-            ed = ed[mask]
-            k += np.dot(ed.T, ed)
-            print(k)
-            it+=1
-        k_norm = np.zeros(k.shape)
-        for i in range(k.shape[0]):
-            for j in range(k.shape[1]):
-                k_norm[i, j] = k[i, j] / np.sqrt(k[i, i] * k[j, j])
-
-        return k_norm
\ No newline at end of file
diff --git a/gmatch4py_cython/gmatch4py/kernels/weisfeiler_lehman_geo.pyx b/gmatch4py_cython/gmatch4py/kernels/weisfeiler_lehman_geo.pyx
deleted file mode 100644
index 59c2b1be4d1426910ed52efe4833d495e211300b..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/kernels/weisfeiler_lehman_geo.pyx
+++ /dev/null
@@ -1,165 +0,0 @@
-# coding = utf-8
-
-from helpers.gazeteer_helpers import get_data,get_data_by_wikidata_id
-
-# coding = utf-8
-
-"""Weisfeiler_Lehman GEO graph kernel.
-
-"""
-
-import numpy as np
-import networkx as nx
-import copy
-
-
-class WeisfeleirLehmanKernelGEO(object):
-    __type__ = "sim"
-    __depreciated__=True
-
-    @staticmethod
-    def compare(graph_list,h=2,verbose=False):
-        """Compute the all-pairs kernel values for a list of graphs.
-        This function can be used to directly compute the kernel
-        matrix for a list of graphs. The direct computation of the
-        kernel matrix is faster than the computation of all individual
-        pairwise kernel values.
-        Parameters
-        ----------
-        graph_list: list
-            A list of graphs (list of networkx graphs)
-        h : interger
-            Number of iterations.
-        node_label : boolean
-            Whether to use original node labels. True for using node labels
-            saved in the attribute 'node_label'. False for using the node
-            degree of each node as node attribute.
-        Return
-        ------
-        K: numpy.array, shape = (len(graph_list), len(graph_list))
-        The similarity matrix of all graphs in graph_list.
-        """
-
-        n = len(graph_list)
-        k = [0] * (h + 1)
-        n_nodes = 0
-        n_max = 0
-
-        inclusion_dictionnary={}
-
-        # Compute adjacency lists and n_nodes, the total number of
-        # nodes in the dataset.
-        for i in range(n):
-            n_nodes += graph_list[i].number_of_nodes()
-
-            """
-            Store Inclusion Informations
-            """
-            for node in graph_list[i].nodes():
-                graph_list[i].node[node]["id_GD"]=node
-                if not node in inclusion_dictionnary:
-                    inc_list = []
-                    try:
-                        inc_list = get_data(node)["inc_P131"]
-                    except:
-                        try:
-                            inc_list=get_data_by_wikidata_id(get_data(node)["continent"])["id"]
-                        except:
-                            pass # No inclusion
-                    if inc_list:
-                        inc_list = inc_list if isinstance(inc_list,list) else [inc_list]
-
-                        inclusion_dictionnary[node]=inc_list[0]
-                        for j in range(1,len(inc_list)):
-                            if j+1 < len(inc_list):
-                                inclusion_dictionnary[inc_list[j]]=inc_list[j+1]
-
-
-
-
-            # Computing the maximum number of nodes in the graphs. It
-            # will be used in the computation of vectorial
-            # representation.
-            if (n_max < graph_list[i].number_of_nodes()):
-                n_max = graph_list[i].number_of_nodes()
-
-        phi = np.zeros((n_nodes, n), dtype=np.uint64)
-        if verbose: print(inclusion_dictionnary)
-        # INITIALIZATION: initialize the nodes labels for each graph
-        # with their labels or with degrees (for unlabeled graphs)
-
-        labels = [0] * n
-        label_lookup = {}
-        label_counter = 0
-
-        # label_lookup is an associative array, which will contain the
-        # mapping from multiset labels (strings) to short labels
-        # (integers)
-        for i in range(n):
-            nodes = graph_list[i].nodes()
-            # It is assumed that the graph has an attribute
-            # 'node_label'
-            labels[i] = np.zeros(len(nodes), dtype=np.int32)
-
-            for j in range(len(nodes)):
-                if not (nodes[j] in label_lookup):
-                    label_lookup[nodes[j]] = str(label_counter)
-                    labels[i][j] = label_counter
-                    label_counter += 1
-                else:
-                    labels[i][j] = label_lookup[nodes[j]]
-                # labels are associated to a natural number
-                # starting with 0.
-
-                phi[labels[i][j], i] += 1
-
-            graph_list[i]=nx.relabel_nodes(graph_list[i],label_lookup)
-        k = np.dot(phi.transpose(), phi).astype(np.float64)
-
-        # MAIN LOOP
-        it = 0
-        new_labels = copy.deepcopy(labels) # Can't work without it !!!
-
-        while it < h:
-            # create an empty lookup table
-            label_lookup = {}
-            label_counter = 0
-
-            phi = np.zeros((n_nodes, n))
-            for i in range(n):
-                nodes = graph_list[i].nodes()
-                for v in range(len(nodes)):
-                    # form a multiset label of the node v of the i'th graph
-                    # and convert it to a string
-
-                    id_GD = graph_list[i].node[nodes[v]]['id_GD']
-                    if id_GD in inclusion_dictionnary:
-
-                        long_label_string = inclusion_dictionnary[id_GD]
-                        graph_list[i].node[nodes[v]]['id_GD']=inclusion_dictionnary[id_GD]
-                    else:
-                        long_label_string = id_GD
-
-
-                    # if the multiset label has not yet occurred, add it to the
-                    # lookup table and assign a number to it
-                    if not (long_label_string in label_lookup):
-                        label_lookup[long_label_string] = str(label_counter)
-                        new_labels[i][v] = label_counter
-                        label_counter += 1
-                    else:
-                        new_labels[i][v] = label_lookup[long_label_string]
-                # fill the column for i'th graph in phi
-                aux = np.bincount(new_labels[i])
-                phi[new_labels[i], i] += (1/(it+2))*aux[new_labels[i]] # +2 because it0 =0
-
-            k += np.dot(phi.transpose(), phi)
-            it = it + 1
-
-        # Compute the normalized version of the kernel
-        k_norm = np.zeros(k.shape)
-        for i in range(k.shape[0]):
-            for j in range(k.shape[1]):
-                k_norm[i, j] = k[i, j] / np.sqrt(k[i, i] * k[j, j])
-
-        return k_norm
\ No newline at end of file
diff --git a/gmatch4py_cython/gmatch4py/mcs.pyx b/gmatch4py_cython/gmatch4py/mcs.pyx
deleted file mode 100644
index 93365efe4d1893627d0a69031a3494aea3563124..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/mcs.pyx
+++ /dev/null
@@ -1,74 +0,0 @@
-# coding = utf-8
-import networkx as nx
-import numpy as np
-cimport numpy as np
-
-class MCS():
-    """
-    *A graph distance metric based on the maximal common subgraph, H. Bunke and K. Shearer,
-    Pattern Recognition Letters, 1998*
-    """
-    @staticmethod
-    def compare(listgs,selected):
-        cdef int n = len(listgs)
-        cdef np.ndarray comparison_matrix = np.zeros((n, n))
-        for i in range(n):
-            for j in range(i, n):
-                f=True
-                if not listgs[i] or not listgs[j]:
-                    f=False
-                elif len(listgs[i])== 0 or len(listgs[j]) == 0:
-                    f=False
-                if selected:
-                    if not i in selected:
-                        f=False
-                if f:
-                    comparison_matrix[i, j] = MCS.s_mcs(listgs[i],listgs[j])
-                else:
-                    comparison_matrix[i, j] = 0.
-                comparison_matrix[j, i] = comparison_matrix[i, j]
-        return comparison_matrix
-
-
-    @staticmethod
-    def intersect(a, b):
-        return list(set(a) & set(b))
-
-    @staticmethod
-    def transform_edges(ed):
-        for e in range(len(ed)):
-            if "id" in ed[e][-1]:
-                del ed[e][-1]["id"]
-        return ed
-
-
-    @staticmethod
-    def intersect_edges(g1, g2):
-        cdef list ed1 = MCS.transform_edges(g1.edges(data=True))
-        cdef list ed2 = MCS.transform_edges(g2.edges(data=True))
-        inter_ed = []
-        for e1 in ed1:
-            for e2 in ed2:
-                if e1 == e2:
-                    inter_ed.append(e1)
-        return inter_ed
-
-    @staticmethod
-    def intersect_nodes(g1, g2):
-        return MCS.intersect(g1.nodes(), g2.nodes())
-
-    @staticmethod
-    def maximum_common_subgraph(g1, g2):
-        """
-        Extract maximum common subgraph
-        """
-        res = nx.MultiDiGraph()
-        res.add_nodes_from(MCS.intersect_nodes(g1, g2))
-        res.add_edges_from(MCS.intersect_edges(g1, g2))
-        return res
-
-    @staticmethod
-    def s_mcs(g1, g2):
-
-        return len(MCS.maximum_common_subgraph(g1, g2)) / float(max(len(g1), len(g2)))
-
diff --git a/gmatch4py_cython/gmatch4py/vertex_edge_overlap.pyx b/gmatch4py_cython/gmatch4py/vertex_edge_overlap.pyx
deleted file mode 100644
index 78883764be51ccaa4beb226058f1697855b24474..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/vertex_edge_overlap.pyx
+++ /dev/null
@@ -1,78 +0,0 @@
-# coding = utf-8
-
-import numpy as np
-cimport numpy as np
-
-
-
-cdef list 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
-    by P. Papadimitriou, A. Dasdan and H.Gracia-Molina
-
-    Code Author : Jacques Fize
-    """
-
-    @staticmethod
-    def compare(list listgs,selected):
-        n = len(listgs)
-        cdef np.ndarray comparison_matrix = np.zeros((n, n))
-        cdef list inter_ver
-        cdef list inter_ed
-        cdef int denom
-        for i in range(n):
-            for j in range(i,n):
-                f=True
-                if not listgs[i] or not listgs[j]:
-                    f=False
-                elif len(listgs[i])== 0 or len(listgs[j]) == 0:
-                    f=False
-                if selected:
-                    if not i in selected:
-                        f=False
-                if f:
-                    g1 = listgs[i]
-                    g2 = listgs[j]
-                    inter_ver,inter_ed = VertexEdgeOverlap.intersect_graph(g1,g2)
-                    denom=len(g1)+len(g2)+len(g1.edges(data=True))+len(g2.edges(data=True))
-                    if denom == 0:
-                        continue
-                    comparison_matrix[i,j]=2*(len(inter_ver)+len(inter_ed))/denom # Data = True --> For nx.MultiDiGraph
-                else:
-                    comparison_matrix[i, j] = 0.
-                comparison_matrix[j, i] = comparison_matrix[i, j]
-        return comparison_matrix
-
-
-    @staticmethod
-    def intersect_edges(g1,g2):
-        cdef list ed1 = VertexEdgeOverlap.transform_edges(g1.edges(data=True))
-        cdef list ed2 = VertexEdgeOverlap.transform_edges(g2.edges(data=True))
-        cdef list inter_ed=[]
-        for e1 in ed1:
-            for e2 in ed2:
-                if e1 == e2:
-                    inter_ed.append(e1)
-        return inter_ed
-
-
-    @staticmethod
-    def intersect_nodes(g1,g2):
-        return intersect(g1.nodes(),g2.nodes())
-
-    @staticmethod
-    def intersect_graph(g1,g2):
-        return VertexEdgeOverlap.intersect_nodes(g1,g2),VertexEdgeOverlap.intersect_edges(g1,g2)
-
-    @staticmethod
-    def transform_edges(ed):
-        for e in range(len(ed)):
-            if "id" in ed[e][-1]:
-                del ed[e][-1]["id"]
-        return ed
-
diff --git a/gmatch4py_cython/gmatch4py/vertex_ranking.pyx b/gmatch4py_cython/gmatch4py/vertex_ranking.pyx
deleted file mode 100644
index 8f72a4df204b7d5d90159ab58196f09be1e30dbc..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/gmatch4py/vertex_ranking.pyx
+++ /dev/null
@@ -1,39 +0,0 @@
-# coding = utf-8
-
-import networkx as nx
-import numpy as np
-cimport numpy as np
-from scipy.stats import spearmanr
-
-
-def intersect(a, b):
-    return list(set(a) & set(b))
-
-class VertexRanking():
-    """
-    Vertex Ranking
-    presented in Web graph similarity for anomaly detection, Journal of Internet Services and Applications, 2008 # Maybe not ??
-    by P. Papadimitriou, A. Dasdan and H.Gracia-Molina
-
-    Code Author : Jacques Fize
-
-    """
-    __type__ = "sim"
-    @staticmethod
-    def  compare(listgs):
-        cdef int n = len(listgs)
-        cdef np.ndarray comparison_matrix = np.zeros((n,n))
-        cdef list page_r=[nx.pagerank(nx.DiGraph(g)) for g in listgs]
-        cdef list node_intersection
-        cdef list X
-        cdef list Y
-        for i in range(n):
-            for j in range(i,n):
-                node_intersection=intersect(list(page_r[i].keys()),list(page_r[j].keys()))
-                X,Y=[],[]
-                for node in node_intersection:
-                    X.append(page_r[i][node])
-                    Y.append(page_r[j][node])
-                comparison_matrix[i,j] = spearmanr(X,Y)[0]
-                comparison_matrix[j,i] = comparison_matrix[i,j]
-        return comparison_matrix
diff --git a/gmatch4py_cython/setup.py b/gmatch4py_cython/setup.py
deleted file mode 100644
index 8f84375f4f14f44b184575929f9c784052cd0ca4..0000000000000000000000000000000000000000
--- a/gmatch4py_cython/setup.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import sys, os
-from distutils.core import setup
-from distutils.extension import Extension
-
-# we'd better have Cython installed, or it's a no-go
-try:
-    from Cython.Distutils import build_ext
-except:
-    print("You don't seem to have Cython installed. Please get a")
-    print("copy from www.cython.org and install it")
-    sys.exit(1)
-
-
-# scan the 'dvedit' directory for extension files, converting
-# them to extension names in dotted notation
-def scandir(dir, files=[]):
-    for file in os.listdir(dir):
-        path = os.path.join(dir, file)
-        if os.path.isfile(path) and path.endswith(".pyx"):
-            files.append(path.replace(os.path.sep, ".")[:-4])
-        elif os.path.isdir(path):
-            scandir(path, files)
-    return files
-
-
-# generate an Extension object from its dotted name
-def makeExtension(extName):
-    extPath = extName.replace(".", os.path.sep)+".pyx"
-    return Extension(
-        extName,
-        [extPath],
-        language="c++",
-        extra_compile_args = ["-O3", "-Wall",'-std=c++11', '-v'],
-        )
-
-# get the list of extensions
-extNames = scandir("gmatch4py")
-
-# and build up the set of Extension objects
-extensions = [makeExtension(name) for name in extNames]
-
-# finally, we can pass all this to distutils
-setup(
-  name="gmatch4py_test",
-  packages=["gmatch4py", "gmatch4py.ged","gmatch4py.kernels"],
-  ext_modules=extensions,
-  cmdclass = {'build_ext': build_ext},
-)
\ No newline at end of file
diff --git a/helpers/boundary.py b/helpers/boundary.py
index 28e8c8253700421962d754395026f5c48fb47110..0ea1d40a7a7f0052e60c38362dcaa6305eeef665 100644
--- a/helpers/boundary.py
+++ b/helpers/boundary.py
@@ -8,7 +8,7 @@ from helpers.gazeteer_helpers import get_data
 from scipy.spatial import ConvexHull
 from shapely.geometry import Polygon, Point, shape
 from config.configuration import config
-from .collision_c import collide
+from .collision import collide
 
 __collisions={}
 
diff --git a/helpers/collision_with_gazetteer_data.py b/helpers/collision_with_gazetteer_data.py
index 9cc8aff2bf250bdae1482f72c934fdcb3f6aa2d7..8042d7476fa5511f34dce414865721433905cce2 100644
--- a/helpers/collision_with_gazetteer_data.py
+++ b/helpers/collision_with_gazetteer_data.py
@@ -7,7 +7,7 @@ from shapely.geometry import Polygon, Point, shape
 
 from config.configuration import config
 from helpers.gazeteer_helpers import get_data
-from .collision_c import collide
+from .collision import collide
 
 __cache={}
 __cache_adjacency={}
diff --git a/models/node2vec.py b/models/node2vec.py
index e5d04143eec1b7e6e7d33b311562d3a6819242a3..b36e7e5ffc62f489bd434c82828bcdf76f7c5c5b 100644
--- a/models/node2vec.py
+++ b/models/node2vec.py
@@ -45,7 +45,7 @@ class Graph():
         # sys.stdout.write("\r")
         G = self.G
         walks = []
-        nodes = list(G.nodes())
+        nodes = list(G.nodes)
         for walk_iter in range(num_walks):
             # sys.stdout.write(
             #     '\rWalk iteration: {0}/{1}'.format(walk_iter + 1, num_walks))
@@ -86,7 +86,7 @@ class Graph():
         is_directed = self.is_directed
 
         alias_nodes = {}
-        for node in G.nodes():
+        for node in list(G.nodes):
             unnormalized_probs = [G[node][nbr]['weight']
                                   for nbr in sorted(G.neighbors(node))]
             norm_const = sum(unnormalized_probs)
@@ -98,10 +98,10 @@ class Graph():
         triads = {}
 
         if is_directed:
-            for edge in G.edges():
+            for edge in list(G.edges()):
                 alias_edges[edge] = self.get_alias_edge(edge[0], edge[1])
         else:
-            for edge in G.edges():
+            for edge in list(G.edges()):
                 alias_edges[edge] = self.get_alias_edge(edge[0], edge[1])
                 alias_edges[(edge[1], edge[0])] = self.get_alias_edge(
                     edge[1], edge[0])
diff --git a/models/str.py b/models/str.py
index e93613dcd8e8b15bd207bfb861cd57f575b1562a..7b800759468b8e310c44ae17b666823a3bc3f576 100644
--- a/models/str.py
+++ b/models/str.py
@@ -61,7 +61,7 @@ class STR(object):
         sp_en = {}
         for nod in g:
             try:
-                sp_en[nod] = g.node[nod]["label"]
+                sp_en[nod] = g.nodes[nod]["label"]
             except KeyError:  # If no label found, grab one from the geo-database
                 data = get_data(nod)
                 if data:
@@ -157,7 +157,7 @@ class STR(object):
                 warnings.warn("{0} doesn't exists in the geo database!".format(new_se))
         self.graph = nx.relabel_nodes(self.graph, final_transform_map)
         for se_ in new_label:
-            self.graph.node[se_]["label"] = new_label[se_]
+            self.graph.nodes[se_]["label"] = new_label[se_]
 
     def update(self):
         """
diff --git a/models/transformation/transform.py b/models/transformation/transform.py
index d643fb949c938cddf2720c3e511a69411c4ebb46..5839b6342391958cb0d3b0050aa992e779e35a54 100644
--- a/models/transformation/transform.py
+++ b/models/transformation/transform.py
@@ -172,7 +172,7 @@ class Expansion(Transformation):
         return []
 
     def select_es(self,graph):
-        es = np.array(graph.nodes())
+        es = np.array(list(graph.nodes))
         score = [np.inf for i in range(len(es))]
         for e in range(len(es)):
             data = get_data(es[e])
diff --git a/nlp/bow_se.py b/nlp/bow_se.py
index 43e67c5c153e5f5b0c655cbd62f5ac1bdad69b79..90c32fd274954a33d69d731bed430113f4a11cf3 100644
--- a/nlp/bow_se.py
+++ b/nlp/bow_se.py
@@ -46,7 +46,7 @@ class BOWSE(object):
             # Computing the maximum number of nodes in the graphs. It
             # will be used in the computation of vectorial
             # representation.
-            if (n_max < graph_list[i].number_of_nodes()):
+            if n_max < graph_list[i].number_of_nodes():
                 n_max = graph_list[i].number_of_nodes()
 
         phi = np.zeros((n_nodes, n), dtype=np.uint64)
@@ -62,7 +62,7 @@ class BOWSE(object):
         # mapping from multiset labels (strings) to short labels
         # (integers)
         for i in range(n):
-            nodes = graph_list[i].nodes()
+            nodes = list(graph_list[i].nodes)
             # It is assumed that the graph has an attribute
             # 'node_label'
             labels[i] = np.zeros(len(nodes), dtype=np.int32)
diff --git a/nlp/disambiguator/wikipedia_cooc.py b/nlp/disambiguator/wikipedia_cooc.py
index c1b262ad0929f3cc79669c45b4d4b81d00c875e4..45e865f3222ac69e05938c913e52535a566c7a27 100644
--- a/nlp/disambiguator/wikipedia_cooc.py
+++ b/nlp/disambiguator/wikipedia_cooc.py
@@ -49,7 +49,7 @@ class WikipediaDisambiguator(Disambiguator):
         g = nx.Graph()
 
         possible_candidates = []
-        betw_cand={} # indicate which toponym group a candidate belong to # maybe useless ...
+        betw_cand={} # indicate which toponym group a candidate belong to #w maybe useless ...
         group_candidate = {} #candidates per toponym
         for e in spat_en:
             cand = get_top_candidate(e, lang)
@@ -78,7 +78,7 @@ class WikipediaDisambiguator(Disambiguator):
                     prob = 0.0
                 if not cand == cand2:
                     # take the lowest co-occurrency between two candidates
-                    if (cand2, cand) in g.edges():
+                    if (cand2, cand) in list(g.edges):
                         if g.edge[cand2][cand]["weight"] < prob:
                             continue
                     g.add_edge(cand, cand2, weight=prob)
diff --git a/notebooks/Eval.ipynb b/notebooks/Eval.ipynb
index acab54efecd9da2c0d05c3d44a1fe172d337cfde..f5096dac998463eb6ad959beb2fda3fcc0d4645e 100644
--- a/notebooks/Eval.ipynb
+++ b/notebooks/Eval.ipynb
@@ -82542,7 +82542,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.0"
+   "version": "3.6.5"
   },
   "toc": {
    "nav_menu": {},
diff --git a/requirements.txt b/requirements.txt
index eab91499d8f8acbf5491414f82d69089c3caee50..c8a121fae2f7cf18de9cedfb6fed75aa67408364 100755
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,7 +2,7 @@ Flask_Session==0.3.1
 Shapely==1.5.17.post1
 matplotlib==2.0.2
 termcolor==1.1.0
-networkx==1.9
+networkx==2.1
 requests==2.18.4
 numpy==1.14.0
 gensim==1.0.1