def test_erdosreny(self):
graphs.ErdosRenyi(N=100, connected=False, directed=False)
graphs.ErdosRenyi(N=100, connected=False, directed=True)
graphs.ErdosRenyi(N=100, connected=True, directed=False, seed=42)
graphs.ErdosRenyi(N=100, connected=True, directed=True, seed=42)
G = graphs.ErdosRenyi(N=100, p=1, self_loops=True)
self.assertEqual(G.W.nnz, 100**2)
def test_differential_operator(self, n_vertices=98):
r"""The Laplacian must always be the divergence of the gradient,
whether the Laplacian is combinatorial or normalized, and whether the
graph is directed or weighted."""
def test_incidence_nx(graph):
r"""Test that the incidence matrix corresponds to NetworkX."""
incidence_pg = np.sign(graph.D.toarray())
G = nx.OrderedDiGraph if graph.is_directed() else nx.OrderedGraph
graph_nx = nx.from_scipy_sparse_matrix(graph.W, create_using=G)
incidence_nx = nx.incidence_matrix(graph_nx, oriented=True)
np.testing.assert_equal(incidence_pg, incidence_nx.toarray())
for graph in [
graphs.Graph(np.zeros((n_vertices, n_vertices))),
graphs.Graph(np.identity(n_vertices)),
graphs.Graph([[0, 0.8], [0.8, 0]]),
graphs.Graph([[1.3, 0], [0.4, 0.5]]),
graphs.ErdosRenyi(n_vertices, directed=False, seed=42),
graphs.ErdosRenyi(n_vertices, directed=True, seed=42)
]:
for lap_type in ['combinatorial', 'normalized']:
graph.compute_laplacian(lap_type)
graph.compute_differential_operator()
L = graph.D.dot(graph.D.T)
np.testing.assert_allclose(L.toarray(), graph.L.toarray())
test_incidence_nx(graph)
def test_laplacian(self):
adjacency = np.array([
[0, 3, 0, 1],
[3, 0, 1, 0],
[0, 1, 0, 3],
[1, 0, 3, 0],
])
laplacian = np.array([
[+4, -3, +0, -1],
[-3, +4, -1, +0],
[+0, -1, +4, -3],
[-1, +0, -3, +4],
])
G = graphs.Graph(adjacency)
self.assertFalse(G.is_directed())
G.compute_laplacian('combinatorial')
np.testing.assert_allclose(G.L.toarray(), laplacian)
G.compute_laplacian('normalized')
np.testing.assert_allclose(G.L.toarray(), laplacian / 4)
adjacency = np.array([
[0, 6, 0, 1],
[0, 0, 0, 0],
[0, 2, 0, 3],
[1, 0, 3, 0],
])
G = graphs.Graph(adjacency)
self.assertTrue(G.is_directed())
G.compute_laplacian('combinatorial')
np.testing.assert_allclose(G.L.toarray(), laplacian)
G.compute_laplacian('normalized')
np.testing.assert_allclose(G.L.toarray(), laplacian / 4)
def test_combinatorial(G):
np.testing.assert_equal(G.L.toarray(), G.L.T.toarray())
np.testing.assert_equal(G.L.sum(axis=0), 0)
np.testing.assert_equal(G.L.sum(axis=1), 0)
np.testing.assert_equal(G.L.diagonal(), G.dw)
def test_normalized(G):
np.testing.assert_equal(G.L.toarray(), G.L.T.toarray())
np.testing.assert_equal(G.L.diagonal(), 1)
G = graphs.ErdosRenyi(100, directed=False)
self.assertFalse(G.is_directed())
G.compute_laplacian(lap_type='combinatorial')
test_combinatorial(G)
G.compute_laplacian(lap_type='normalized')
test_normalized(G)
G = graphs.ErdosRenyi(100, directed=True)
self.assertTrue(G.is_directed())
G.compute_laplacian(lap_type='combinatorial')
test_combinatorial(G)
G.compute_laplacian(lap_type='normalized')
test_normalized(G)
def main(_):
# Initialize tempdir
if tf.gfile.Exists(FLAGS.log_dir):
tf.gfile.DeleteRecursively(FLAGS.log_dir)
tf.gfile.MakeDirs(FLAGS.log_dir)
# Initialize data
G = graphs.ErdosRenyi(FLAGS.num_vertices, 0.1, seed=42)
G.compute_laplacian("normalized")
L = initialize_laplacian_tensor(G.W)
W = (G.W).astype(np.float32)
train_data, train_labels = generate_wave_samples(FLAGS.num_train,
W,
T=FLAGS.num_frames,
sigma=FLAGS.sigma)
train_mb_source = MinibatchSource(train_data, train_labels)
test_data, test_labels = generate_wave_samples(FLAGS.num_test,
W,
T=FLAGS.num_frames,
sigma=FLAGS.sigma)
# Run training and evaluation loop
run_training(train_mb_source, L, test_data, test_labels)
def test_edge_list(self):
for directed in [False, True]:
G = graphs.ErdosRenyi(100, directed=directed)
sources, targets, weights = G.get_edge_list()
if not directed:
self.assertTrue(np.all(sources <= targets))
edges = np.arange(G.n_edges)
np.testing.assert_equal(G.W[sources[edges], targets[edges]],
weights[edges][np.newaxis, :])
def __init__(self,
n_nodes,
ux,
spectral_profile,
type_graph="erdos",
type_noise="gaussian",
save_history=True,
seed=None,
**kargs):
####### The algorithm asks the user a spectral_profile for the Graph filter that will be applied
### to white noise so the output signal is stationary with respect to the graph structure.
#### This section initialize the structure of the graph signal
### Input
# n_nodes=number of nodes
# ux= mean of the signal
# spectral_profile= a function generating the power spectral density of the sygnal.
# type_graph=available graph model (erdos,euclidean,barabasi_albert)
# type_noise = distribution of the noise (gaussian,uniform) that will be used to ge
self.n_nodes = n_nodes
self.type_graph = type_graph
self.type_noise = type_noise
self.ux = ux
self.spectral_profile = spectral_profile
self.seed = seed
if type_graph == "erdos":
self.G = graphs.ErdosRenyi(self.n_nodes,
kargs['p'],
seed=self.seed)
self.G.set_coordinates()
if type_graph == "barabasi_albert":
self.G = graphs.BarabasiAlbert(self.n_nodes,
m=kargs['m'],
m0=kargs['m'],
seed=self.seed)
self.G.set_coordinates()
if type_graph == "Minnesota":
self.G = graphs.Minnesota()
self.generate_fourier()
self.generate_filter()
