def parse_input(self, X):
"""Parse and create features for the `subgraph_matching` kernel.
Parameters
----------
X : iterable
For the input to pass the test, we must have:
Each element must be an iterable with at most three features and at
least one. The first that is obligatory is a valid graph structure
(adjacency matrix or edge_dictionary) while the second is
node_labels and the third edge_labels (that correspond to the given
graph format). A valid input also consists of graph type objects.
Returns
-------
out : list
The extracted adjacency matrices for any given input.
"""
if not isinstance(X, collections.Iterable):
raise TypeError('input must be an iterable\n')
else:
i = 0
out = list()
for (idx, x) in enumerate(iter(X)):
is_iter = False
if isinstance(x, collections.Iterable):
is_iter = True
x = list(x)
if type(x) is Graph:
g = Graph(
x.get_adjacency_matrix(),
x.get_labels(purpose="adjacency"),
x.get_labels(purpose="adjacency", label_type="edge"),
self._graph_format)
elif is_iter and len(x) in [0, 3]:
x = list(x)
if len(x) == 0:
warnings.warn('Ignoring empty element' +
' on index: ' + str(idx))
continue
elif len(x) == 3:
g = Graph(x[0], x[1], x[2], "adjacency")
g.change_format(self._graph_format)
else:
raise TypeError('each element of X must be either a ' +
'graph object or a list with at least ' +
'a graph like object and node, ' +
'edge labels dict \n')
n = g.nv()
E = g.get_edge_dictionary()
L = g.get_labels(purpose="dictionary",
return_none=(self.kv is None))
Le = g.get_labels(purpose="dictionary",
label_type="edge",
return_none=(self.ke is None))
Er = set(
(a, b) for a in E.keys() for b in E[a].keys() if a != b)
i += 1
out.append((n, Er, L, Le))
if i == 0:
raise ValueError('parsed input is empty')
return out
def parse_input(self, X):
"""Parse and create features for the attributed propation kernel.
Parameters
----------
X : iterable
For the input to pass the test, we must have:
Each element must be an iterable with at most three features and at
least one. The first that is obligatory is a valid graph structure
(adjacency matrix or edge_dictionary) while the second is
node_labels and the third edge_labels (that correspond to the given
graph format). A valid input also consists of graph type objects.
Returns
-------
local_values : dict
A dictionary of pairs between each input graph and a bins where the
sampled graphlets have fallen.
"""
if not isinstance(X, collections.Iterable):
raise ValueError('input must be an iterable\n')
else:
# The number of parsed graphs
n = 0
transition_matrix = dict()
indexes = [0]
Attr = list()
for (idx, x) in enumerate(iter(X)):
is_iter = isinstance(x, collections.Iterable)
if is_iter:
x = list(x)
if is_iter and len(x) in [0, 2, 3, 4]:
if len(x) == 0:
warnings.warn('Ignoring empty element on ' +
'index: ' + str(idx))
continue
if len(x) == 2 and type(x[0]) is Graph:
g, T = x
else:
g = Graph(x[0], x[1], {}, self._graph_format)
if len(x) == 4:
T = x[3]
else:
T = None
elif type(x) is Graph:
g, T = x, None
else:
raise ValueError('Each element of X must be either a ' +
'Graph or an iterable with at least 2 ' +
'and at most 4 elements\n')
if T is not None:
if T.shape[0] != T.shape[1]:
raise TypeError('Transition matrix on index' + ' ' +
str(idx) + 'must be ' +
'a square matrix.')
if T.shape[0] != g.nv():
raise TypeError('Propagation matrix must ' +
'have the same dimension ' +
'as the number of vertices.')
else:
T = g.get_adjacency_matrix()
nv = g.nv()
transition_matrix[n] = (T.T / np.sum(T, axis=1)).T
attr = g.get_labels(purpose="adjacency")
try:
attributes = np.array([attr[j] for j in range(nv)])
except TypeError:
raise TypeError(
'All attributes of a single graph should have the same dimension.'
)
Attr.append(attributes)
indexes.append(indexes[-1] + nv)
n += 1
try:
P = np.vstack(Attr)
except ValueError:
raise ValueError(
'Attribute dimensions should be the same, for all graphs')
if self._method_calling == 1:
self._dim = P.shape[1]
else:
if self._dim != P.shape[1]:
raise ValueError('transform attribute vectors should'
'have the same dimension as in fit')
if n == 0:
raise ValueError('Parsed input is empty')
# feature vectors
if self._method_calling == 1:
# simple normal
self._u, self._b, self._hd = list(), list(), list()
for t in range(self.t_max):
u = self.random_state_.randn(self._dim)
if self.take_cauchy_:
# cauchy
u = np.divide(u, self.random_state_.randn(self._dim))
self._u.append(u)
# random offset
self._b.append(self.w *
self.random_state_.randn(self._dim))
phi = {k: dict() for k in range(n)}
for t in range(self.t_max):
# for hash all graphs inside P and produce the feature vectors
hashes = self.calculate_LSH(P, self._u[t],
self._b[t]).tolist()
hd = {
j: i
for i, j in enumerate({tuple(l)
for l in hashes})
}
self._hd.append(hd)
features = np.array([hd[tuple(l)] for l in hashes])
# Accumulate the results.
for k in range(n):
phi[k][t] = Counter(
features[indexes[k]:indexes[k + 1]].flat)
# calculate the Propagation matrix if needed
if t < self.t_max - 1:
for k in range(n):
start, end = indexes[k:k + 2]
P[start:end, :] = np.dot(transition_matrix[k],
P[start:end, :])
return [phi[k] for k in range(n)]
if self._method_calling == 3:
phi = {k: dict() for k in range(n)}
for t in range(self.t_max):
# for hash all graphs inside P and produce the feature vectors
hashes = self.calculate_LSH(P, self._u[t],
self._b[t]).tolist()
hd = dict(
chain(
iteritems(self._hd[t]),
iter((j, i)
for i, j in enumerate(
filterfalse(lambda x: x in self._hd[t],
{tuple(l)
for l in hashes}),
len(self._hd[t])))))
features = np.array([hd[tuple(l)] for l in hashes])
# Accumulate the results.
for k in range(n):
phi[k][t] = Counter(features[indexes[k]:indexes[k +
1]])
# calculate the Propagation matrix if needed
if t < self.t_max - 1:
for k in range(n):
start, end = indexes[k:k + 2]
P[start:end, :] = np.dot(transition_matrix[k],
P[start:end, :])
return [phi[k] for k in range(n)]
def parse_input(self, X):
"""Parse and check the given input for the Graph Hopper kernel.
Parameters
----------
X : iterable
For the input to pass the test, we must have:
Each element must be an iterable with at most three features and at
least one. The first that is obligatory is a valid graph structure
(adjacency matrix or edge_dictionary) while the second is
node_labels and the third edge_labels (that fitting the given graph
format).
Returns
-------
out : np.array, shape=(len(X), n_labels)
A np array for frequency (cols) histograms for all Graphs (rows).
"""
if not isinstance(X, Iterable):
raise TypeError('input must be an iterable\n')
else:
ni = 0
diam = list()
graphs = list()
for (i, x) in enumerate(iter(X)):
is_iter = False
if isinstance(x, Iterable):
is_iter = True
x = list(x)
if type(x) is Graph:
g = Graph(x.get_adjacency_matrix(),
x.get_labels(purpose="adjacency"), {},
self._graph_format)
elif is_iter and len(x) == 0 or len(x) >= 2:
if len(x) == 0:
warn('Ignoring empty element on index: ' + str(i))
continue
elif len(x) >= 2:
g = Graph(x[0], x[1], {}, "adjacency")
g.change_format(self._graph_format)
else:
raise TypeError('each element of X must be either a '
'graph object or a list with at least '
'a graph like object and node, ')
spm, attr = g.build_shortest_path_matrix(labels="vertex")
nv = g.nv()
try:
attributes = np.array([attr[j] for j in range(nv)])
except TypeError:
raise TypeError(
'All attributes of a single graph should have the same dimension.'
)
diam.append(int(np.max(spm[spm < float("Inf")])))
graphs.append((g.get_adjacency_matrix(), nv, attributes))
ni += 1
if self._method_calling == 1:
max_diam = self._max_diam = max(diam) + 1
else:
max_diam = max(self._max_diam, max(diam) + 1)
out = list()
for i in range(ni):
AM, node_nr, attributes = graphs[i]
des = np.zeros(shape=(node_nr, node_nr, max_diam), dtype=int)
occ = np.zeros(shape=(node_nr, node_nr, max_diam), dtype=int)
# Convert adjacency matrix to dictionary
idx_i, idx_j = np.where(AM > 0)
ed = defaultdict(dict)
for (a, b) in filterfalse(lambda a: a[0] == a[1],
zip(idx_i, idx_j)):
ed[a][b] = AM[a, b]
for j in range(node_nr):
A = np.zeros(shape=AM.shape)
# Single-source shortest path from node j
D, p = dijkstra(ed, j)
D = np.array(
list(D.get(k, float("Inf")) for k in range(node_nr)))
p[j] = -1
# Restrict to the connected component of node j
conn_comp = np.where(D < float("Inf"))[0]
# To-be DAG adjacency matrix of connected component of node j
A_cc = A[conn_comp, :][:, conn_comp]
# Adjacency matrix of connected component of node j
AM_cc = AM[conn_comp, :][:, conn_comp]
D_cc = D[conn_comp]
conn_comp_converter = np.zeros(shape=(A.shape[0], 1),
dtype=int)
for k in range(conn_comp.shape[0]):
conn_comp_converter[conn_comp[k]] = k
conn_comp_converter = np.vstack([0, conn_comp_converter])
p_cc = conn_comp_converter[
np.array(list(p[k] for k in conn_comp)) + 1]
# Number of nodes in connected component of node j
conncomp_node_nr = A_cc.shape[0]
for v in range(conncomp_node_nr):
if p_cc[v] > 0:
# Generate A_cc by adding directed edges of form (parent(v), v)
A_cc[p_cc[v], v] = 1
# Distance from v to j
v_dist = D_cc[v]
# All neighbors of v in the undirected graph
v_nbs = np.where(AM_cc[v, :] > 0)[0]
# Distances of neighbors of v to j
v_nbs_dists = D_cc[v_nbs]
# All neighbors of v in undirected graph who are
# one step closer to j than v is; i.e. SP-DAG parents
v_parents = v_nbs[v_nbs_dists == (v_dist - 1)]
# Add SP-DAG parents to A_cc
A_cc[v_parents, v] = 1
# Computes the descendants & occurence vectors o_j(v), d_j(v)
# for all v in the connected component
occ_p, des_p = od_vectors_dag(A_cc, D_cc)
if des_p.shape[0] == 1 and j == 0:
des[j, 0, 0] = des_p
occ[j, 0, 0] = occ_p
else:
# Convert back to the indices of the original graph
for v in range(des_p.shape[0]):
for l in range(des_p.shape[1]):
des[j, conn_comp[v], l] = des_p[v, l]
# Convert back to the indices of the original graph
for v in range(occ_p.shape[0]):
for l in range(occ_p.shape[1]):
occ[j, conn_comp[v], l] = occ_p[v, l]
M = np.zeros(shape=(node_nr, max_diam, max_diam))
# j loops through choices of root
for j in range(node_nr):
des_mat_j_root = np.squeeze(des[j, :, :])
occ_mat_j_root = np.squeeze(occ[j, :, :])
# v loops through nodes
for v in range(node_nr):
for a in range(max_diam):
for b in range(a, max_diam):
# M[v,:,:] is M[v]; a = node coordinate in path, b = path length
M[v, a,
b] += des_mat_j_root[v, b -
a] * occ_mat_j_root[v, a]
if self.calculate_norm_:
out.append((M, attributes, np.sum(attributes**2, axis=1)))
else:
out.append((M, attributes))
return out
def parse_input(self, X):
"""Parse and create features for the propation kernel.
Parameters
----------
X : iterable
For the input to pass the test, we must have:
Each element must be an iterable with at most three features and at
least one. The first that is obligatory is a valid graph structure
(adjacency matrix or edge_dictionary) while the second is
node_labels and the third edge_labels (that correspond to the given
graph format). A valid input also consists of graph type objects.
Returns
-------
local_values : dict
A dictionary of pairs between each input graph and a bins where the
sampled graphlets have fallen.
"""
if not isinstance(X, collections.Iterable):
raise ValueError('input must be an iterable\n')
else:
i = -1
transition_matrix = dict()
labels = set()
L = list()
for (idx, x) in enumerate(iter(X)):
is_iter = isinstance(x, collections.Iterable)
if is_iter:
x = list(x)
if is_iter and len(x) in [0, 2, 3, 4]:
if len(x) == 0:
warnings.warn('Ignoring empty element on ' +
'index: ' + str(idx))
continue
if len(x) == 2 and type(x[0]) is Graph:
g, T = x
else:
g = Graph(x[0], x[1], {}, self._graph_format)
if len(x) == 4:
T = x[3]
else:
T = None
elif type(x) is Graph:
g, T = x, None
else:
raise ValueError('Each element of X must be either a ' +
'Graph or an iterable with at least 2 ' +
'and at most 4 elements\n')
if T is not None:
if T.shape[0] != T.shape[1]:
raise TypeError('Transition matrix on index' + ' ' +
str(idx) + 'must be ' +
'a square matrix.')
if T.shape[0] != g.nv():
raise TypeError('Propagation matrix must ' +
'have the same dimension ' +
'as the number of vertices.')
else:
T = g.get_adjacency_matrix()
i += 1
transition_matrix[i] = (T.T / np.sum(T, axis=1)).T
label = g.get_labels(purpose='adjacency')
try:
labels |= set(itervalues(label))
except TypeError:
raise TypeError(
'For a non attributed kernel, labels should be hashable.'
)
L.append((g.nv(), label))
if i == -1:
raise ValueError('Parsed input is empty')
# The number of parsed graphs
n = i + 1
# enumerate labels
if self._method_calling == 1:
enum_labels = {l: i for (i, l) in enumerate(list(labels))}
self._enum_labels = enum_labels
self._parent_labels = labels
elif self._method_calling == 3:
new_elements = labels - self._parent_labels
if len(new_elements) > 0:
new_enum_labels = iter((l, i) for (i, l) in enumerate(
list(new_elements), len(self._enum_labels)))
enum_labels = dict(
chain(iteritems(self._enum_labels), new_enum_labels))
else:
enum_labels = self._enum_labels
# make a matrix for all graphs that contains label vectors
P, data, indexes = dict(), list(), [0]
for (k, (nv, label)) in enumerate(L):
data += [(indexes[-1] + j, enum_labels[label[j]])
for j in range(nv)]
indexes.append(indexes[-1] + nv)
# Initialise the on hot vector
rows, cols = zip(*data)
P = np.zeros(shape=(indexes[-1], len(enum_labels)))
P[rows, cols] = 1
dim_orig = len(self._enum_labels)
# feature vectors
if self._method_calling == 1:
# simple normal
self._u, self._b, self._hd = list(), list(), list()
for t in range(self.t_max):
u = self.random_state_.randn(len(enum_labels))
if self.take_cauchy_:
# cauchy
u = np.divide(
u, self.random_state_.randn(len(enum_labels)))
self._u.append(u)
# random offset
self._b.append(self.w * self.random_state_.rand())
phi = {k: dict() for k in range(n)}
for t in range(self.t_max):
# for hash all graphs inside P and produce the feature vectors
hashes = self.calculate_LSH(P, self._u[t], self._b[t])
hd = dict(
(j, i) for i, j in enumerate(set(np.unique(hashes))))
self._hd.append(hd)
features = np.vectorize(lambda i: hd[i])(hashes)
# Accumulate the results.
for k in range(n):
phi[k][t] = Counter(features[indexes[k]:indexes[k +
1]])
# calculate the Propagation matrix if needed
if t < self.t_max - 1:
for k in range(n):
start, end = indexes[k:k + 2]
P[start:end, :] = np.dot(transition_matrix[k],
P[start:end, :])
return [phi[k] for k in range(n)]
elif (self._method_calling == 3 and dim_orig >= len(enum_labels)):
phi = {k: dict() for k in range(n)}
for t in range(self.t_max):
# for hash all graphs inside P and produce the feature vectors
hashes = self.calculate_LSH(P, self._u[t], self._b[t])
hd = dict(
chain(
iteritems(self._hd[t]),
iter((j, i)
for i, j in enumerate(
filterfalse(lambda x: x in self._hd[t],
np.unique(hashes)),
len(self._hd[t])))))
features = np.vectorize(lambda i: hd[i])(hashes)
# Accumulate the results.
for k in range(n):
phi[k][t] = Counter(features[indexes[k]:indexes[k +
1]])
# calculate the Propagation matrix if needed
if t < self.t_max - 1:
for k in range(n):
start, end = indexes[k:k + 2]
P[start:end, :] = np.dot(transition_matrix[k],
P[start:end, :])
return [phi[k] for k in range(n)]
else:
cols = np.array(cols)
vertices = np.where(cols < dim_orig)[0]
vertices_p = np.where(cols >= dim_orig)[0]
nnv = len(enum_labels) - dim_orig
phi = {k: dict() for k in range(n)}
for t in range(self.t_max):
# hash all graphs inside P and produce the feature vectors
hashes = self.calculate_LSH(P[vertices, :dim_orig],
self._u[t], self._b[t])
hd = dict(
chain(
iteritems(self._hd[t]),
iter((j, i)
for i, j in enumerate(
filterfalse(lambda x: x in self._hd[t],
np.unique(hashes)),
len(self._hd[t])))))
features = np.vectorize(lambda i: hd[i],
otypes=[int])(hashes)
# for each the new labels graph hash P and produce the feature vectors
u = self.random_state_.randn(nnv)
if self.take_cauchy_:
# cauchy
u = np.divide(u, self.random_state_.randn(nnv))
u = np.hstack((self._u[t], u))
# calculate hashes for the remaining
hashes = self.calculate_LSH(P[vertices_p, :], u,
self._b[t])
hd = dict(
chain(
iteritems(hd),
iter((j, i)
for i, j in enumerate(hashes, len(hd)))))
features_p = np.vectorize(lambda i: hd[i],
otypes=[int])(hashes)
# Accumulate the results
for k in range(n):
A = Counter(features[np.logical_and(
indexes[k] <= vertices,
vertices <= indexes[k + 1])])
B = Counter(features_p[np.logical_and(
indexes[k] <= vertices_p,
vertices_p <= indexes[k + 1])])
phi[k][t] = A + B
# calculate the Propagation matrix if needed
if t < self.t_max - 1:
for k in range(n):
start, end = indexes[k:k + 2]
P[start:end, :] = np.dot(transition_matrix[k],
P[start:end, :])
Q = np.all(P[:, dim_orig:] > 0, axis=1)
vertices = np.where(~Q)[0]
vertices_p = np.where(Q)[0]
return [phi[k] for k in range(n)]