def test_cm_0(self):
"""test with 3 classes of cardinality 1
and no zero degrees
"""
A = np.array(
[
[0, 1, 1],
[1, 0, 1],
[1, 1, 0],
]
)
g = sample.UndirectedGraph(A)
g._solve_problem(
model="cm",
method="newton",
max_steps=100,
verbose=False,
linsearch=True,
initial_guess='degrees_minor'
)
g._solution_error()
# print('degseq = ', np.concatenate((g.dseq_out, g.dseq_in)))
# print('expected degseq = ',g.expected_dseq)
# debug
# print(g.r_dseq_out)
# print(g.r_dseq_in)
# print(g.rnz_dseq_out)
# print(g.rnz_dseq_in)
# print('\ntest 5: error = {}'.format(g.error))
# test result
self.assertTrue(g.error < 1e-1)
def test_cm_2(self):
"""classes with cardinality more than 1 and zero degrees"""
# test Matrix 1
n, seed = (100, 22)
A = mg.random_binary_matrix_generator_dense(n, sym=True, seed=seed)
g = sample.UndirectedGraph(A)
g._solve_problem(
model="cm",
method="newton",
max_steps=300,
verbose=False,
linsearch="True",
initial_guess='random'
)
g._solution_error()
# print('degseq = ', np.concatenate((g.dseq_out, g.dseq_in)))
# print('expected degseq = ',g.expected_dseq)
# debug
# print(g.r_dseq_out)
# print(g.r_dseq_in)
# print(g.rnz_dseq_out)
# print(g.rnz_dseq_in)
# print('\ntest 9: error = {}'.format(g.error))
# test result
self.assertTrue(g.error < 1e-1)
def test_ECM_Dianati_random_dense_20_undir(self):
network = mg.random_weighted_matrix_generator_dense(n=20,
sup_ext=10,
sym=True,
seed=None,
intweights=True)
network_bin = (network > 0).astype(int)
g = sample_und.UndirectedGraph(adjacency=network)
g.solve_tool(
model="ecm_exp",
method="newton",
max_steps=1000,
verbose=False,
initial_guess="uniform",
)
g._solution_error()
# test result
self.assertTrue(g.error < 1e-1)
self.assertTrue(g.error < 1e-2)
def test_fixedpoint_cm_6(self):
"""classes with cardinality > 1, no zero degree"""
n, seed = (20, 22)
A = mg.random_binary_matrix_generator_dense(n, sym=True, seed=seed)
g = sample.UndirectedGraph(A)
g._solve_problem(
model="cm_exp",
method="fixed-point",
initial_guess="random",
max_steps=300,
verbose=False,
linsearch="True",
)
g._solution_error()
# print('degseq = ', np.concatenate((g.dseq_out, g.dseq_in)))
# print('expected degseq = ',g.expected_dseq)
# debug
# print(g.r_dseq_out)
# print(g.r_dseq_in)
# print(g.rnz_dseq_out)
# print(g.rnz_dseq_in)
# print('\ntest 6: error = {}'.format(g.error))
# test result
self.assertTrue(g.error < 1e-1)
def test_crema_original_newton_random_dense_20_undir(self):
network = mg.random_weighted_matrix_generator_dense(n=20,
sup_ext=10,
sym=True,
seed=None)
network_bin = (network > 0).astype(int)
g = sample_und.UndirectedGraph(adjacency=network)
g.solve_tool(
model="crema",
method="quasinewton",
initial_guess="random",
adjacency=network_bin,
max_steps=1000,
verbose=False,
)
g._solution_error()
# test result
self.assertTrue(g.relative_error_strength < 1e-1)
self.assertTrue(g.relative_error_strength < 1e-2)
def test_edgelist_init_string_undirected(self):
e = np.array([("1", "a"), ("2", "b"), ("2", "a")])
k = np.array([1, 2, 2, 1])
g0 = sample.UndirectedGraph()
g0._initialize_graph(edgelist=e)
# debug
# test result
self.assertTrue(k.all() == g0.dseq.all())
def test_cm_uniform(self):
n, seed = (4, 22)
A = mg.random_binary_matrix_generator_dense(n, sym=True, seed=seed)
g = sample_u.UndirectedGraph(A)
g.initial_guess = 'uniform'
g.last_model = "cm"
g._set_initial_guess('cm')
self.assertTrue(g.x0.all() == np.array([0.5, 0.5]).all())
def test_edgelist_init_string_undirected_weighted(self):
e = np.array([("1", "a", 3), ("2", "b", 4), ("2", "a", 3)])
k = np.array([1, 2, 2, 1])
s = np.array([3., 7., 6., 4.])
g0 = sample.UndirectedGraph()
g0._initialize_graph(edgelist=e)
# debug
# test result
self.assertTrue((k == g0.dseq).all())
self.assertTrue((s == g0.strength_sequence).all())
def test_cm(self):
n, seed = (4, 22)
A = mg.random_binary_matrix_generator_dense(n, sym=True, seed=seed)
x0 = np.random.rand(n)
g = sample_u.UndirectedGraph(A)
g.initial_guess = x0
g._set_initial_guess_cm()
g.full_return = False
g.last_model = "cm"
g._set_solved_problem_cm(g.x0)
self.assertTrue(g.x.all() == x0.all())
def test_ecm(self):
n, seed = (4, 22)
A = mg.random_weighted_matrix_generator_dense(n,
sym=False,
seed=seed,
sup_ext=100,
intweights=True)
x0 = np.random.rand(n)
g = sample_u.UndirectedGraph(A)
g.initial_guess = x0
g._set_initial_guess_crema_undirected()
self.assertTrue(g.x0.all() == x0.all())
def test_crema_uniform(self):
n, seed = (4, 22)
A = mg.random_weighted_matrix_generator_dense(n,
sym=False,
seed=seed,
sup_ext=100,
intweights=True)
g = sample_u.UndirectedGraph(A)
g.initial_guess = 'strengths_minor'
g._set_initial_guess('crema')
x = (g.strength_sequence > 0).astype(float) / (g.strength_sequence + 1)
self.assertTrue(g.x0.all() == x.all())
def test_ECM_quasinewton_random_dense_20_undir(self):
network = mg.random_weighted_matrix_generator_dense(n=20,
sup_ext=10,
sym=True,
seed=10,
intweights=True)
g = sample_und.UndirectedGraph(adjacency=network)
g.solve_tool(
model="ecm",
method="quasinewton",
max_steps=1000,
verbose=False,
initial_guess="random",
)
g._solution_error()
# test result
self.assertTrue(g.error < 1e-1)
def test_0(self):
"""test with 3 classes of cardinality 1
and no zero degrees
"""
"""
A = np.array(
[
[0, 1, 1, 0],
[1, 0, 0, 1],
[1, 0, 0, 0],
[0, 1, 0, 0],
]
)
e = [(0,1), (0,2), (1,3)]
d = [1,1,2,2]
print(e)
print(d)
"""
N, seed = (50, 42)
A = mg.random_binary_matrix_generator_dense(N, sym=True, seed=seed)
# number of copies to generate
g = sample.UndirectedGraph(A)
g._solve_problem(
model="cm",
method="fixed-point",
max_steps=100,
verbose=False,
linsearch=True,
initial_guess="uniform",
)
x = g.x
# g._solution_error()
err = g.error
# print('\ntest 5: error = {}'.format(g.error))
n = 100
output_dir = "sample_cm/"
# random.seed(100)
g.ensemble_sampler(n=n, output_dir=output_dir, seed=42)
d = {'{}'.format(i): g.dseq[i] for i in range(N)}
# read all sampled graphs and check the average degree distribution is close enough
d_emp = {'{}'.format(i): 0 for i in range(N)}
for l in range(n):
f = output_dir + "{}.txt".format(l)
if not os.stat(f).st_size == 0:
g_tmp = nx.read_edgelist(f)
d_tmp = dict(g_tmp.degree)
for item in d_tmp.keys():
d_emp[item] += d_tmp[item]
for item in d_emp.keys():
d_emp[item] = d_emp[item] / n
a_diff = np.array([abs(d[item] - d_emp[item]) for item in d.keys()])
d_diff = {item: d[item] - d_emp[item] for item in d.keys()}
ensemble_error = np.linalg.norm(a_diff, np.inf)
#debug
"""
for i in range(N):
for j in range(N):
if i!=j:
aux = x[i]*x[j]
# print("({},{}) p = {}".format(i,j,aux/(1+aux)))
"""
# debug
"""
print('original dseq',d)
print('original dseq sum ',g.dseq.sum())
print('ensemble average dseq', d_emp)
print('ensemble dseq sum ',np.array([d_emp[key] for key in d_emp.keys()]).sum())
print(d_diff)
print('empirical error', ensemble_error)
print('theoretical error', err)
"""
l = os.listdir(output_dir)
for f in l:
os.remove(output_dir + f)
os.rmdir(output_dir)
# test result
self.assertTrue(ensemble_error < 3)
def test_1(self):
n, seed = (10, 42)
# network = mg.random_weighted_matrix_generator_dense(n=n, sup_ext=10, sym=True, seed=seed, intweights=True)
network = mg.random_weighted_matrix_generator_uniform_custom_density(
n=n, p=0.2, sym=True, sup_ext=30, intweights=True, seed=seed)
# number of copies to generate
g = sample.UndirectedGraph(adjacency=network)
g.solve_tool(
model="crema",
method="quasinewton",
initial_guess="random",
adjacency="cm",
max_steps=1000,
verbose=False,
)
# g._solution_error()
err = g.error
# print('\ntest 5: error = {}'.format(g.error))
n_sample = 300
output_dir = "sample_crema_ecm_prob/"
# random.seed(100)
g.ensemble_sampler(n=n_sample, output_dir=output_dir, seed=42)
d = {'{}'.format(i): g.dseq[i] for i in range(n)}
s = {'{}'.format(i): g.strength_sequence[i] for i in range(n)}
# read all sampled graphs and check the average degree distribution
d_emp = {'{}'.format(i): 0 for i in range(n)}
s_emp = {'{}'.format(i): 0 for i in range(n)}
for l in range(n_sample):
f = output_dir + "{}.txt".format(l)
if not os.stat(f).st_size == 0:
g_tmp = nx.read_edgelist(f, data=(("weight", float), ))
d_tmp = dict(g_tmp.degree)
s_tmp = dict(g_tmp.degree(weight='weight'))
for item in d_tmp.keys():
d_emp[item] += d_tmp[item]
s_emp[item] += s_tmp[item]
for item in d_emp.keys():
d_emp[item] = d_emp[item] / n_sample
s_emp[item] = s_emp[item] / n_sample
ad_diff = np.array([abs(d[item] - d_emp[item]) for item in d.keys()])
as_diff = np.array([abs(s[item] - s_emp[item]) for item in s.keys()])
a_diff = np.concatenate((ad_diff, as_diff))
d_diff = {item: abs(d[item] - d_emp[item]) for item in d.keys()}
s_diff = {item: abs(s[item] - s_emp[item]) for item in s.keys()}
ensemble_error = np.linalg.norm(a_diff, np.inf)
# debug
"""
print('\n original degree sequence ', d)
print('\n original strength sequence ', s)
print('\n ensemble average strength sequence', s_emp)
print('\n degree by degree difference vector ', d_diff)
print('\n strength by strength difference vector ', s_diff)
print('\n empirical error = {}'.format(ensemble_error))
print('\n theoretical error = {}'.format(err))
"""
l = os.listdir(output_dir)
for f in l:
os.remove(output_dir + f)
os.rmdir(output_dir)
# test result
self.assertTrue(ensemble_error < 4)
def test_0(self):
"""test with 3 classes of cardinality 1
and no zero degrees
"""
"""
A = np.array(
[
[0, 1, 1, 0],
[1, 0, 0, 1],
[1, 0, 0, 0],
[0, 1, 0, 0],
]
)
e = [(0,1), (0,2), (1,3)]
d = [1,1,2,2]
print(e)
print(d)
"""
N, seed = (50, 42)
A = mg.random_weighted_matrix_generator_dense(
n=N, sup_ext=10, sym=True, seed=seed, intweights=True
)
# number of copies to generate
g = sample.UndirectedGraph(A)
g._solve_problem(
model="ecm",
method="newton",
max_steps=100,
verbose=False,
linsearch=True,
initial_guess="uniform",
)
x = g.x
# g._solution_error()
err = g.error
# print('\ntest 5: error = {}'.format(g.error))
n = 1000
output_dir = "sample_ecm/"
# random.seed(100)
g.ensemble_sampler(n=n, output_dir=output_dir, seed=42)
d = {'{}'.format(i):g.dseq[i] for i in range(N)}
s = {'{}'.format(i):g.strength_sequence[i] for i in range(N)}
# read all sampled graphs and check the average degree distribution is close enough
d_emp = {'{}'.format(i):0 for i in range(N)}
s_emp = {'{}'.format(i):0 for i in range(N)}
for l in range(n):
f = output_dir + "{}.txt".format(l)
if not os.stat(f).st_size == 0:
g_tmp = nx.read_edgelist(f, data=(("weight", float),))
d_tmp = dict(g_tmp.degree)
s_tmp = dict(g_tmp.degree(weight='weight'))
for item in d_tmp.keys():
d_emp[item] += d_tmp[item]
s_emp[item] += s_tmp[item]
for item in d_emp.keys():
d_emp[item] = d_emp[item]/n
s_emp[item] = s_emp[item]/n
ad_diff = np.array([abs(d[item] - d_emp[item]) for item in d.keys()])
as_diff = np.array([abs(s[item] - s_emp[item]) for item in s.keys()])
a_diff = np.concatenate((ad_diff, as_diff))
d_diff = {item:d[item] - d_emp[item] for item in d.keys()}
s_diff = {item:s[item] - s_emp[item] for item in s.keys()}
ensemble_error = np.linalg.norm(a_diff, np.inf)
#debug
"""
for i in range(N):
for j in range(N):
if i!=j:
aux = x[i]*x[j]
# print("({},{}) p = {}".format(i,j,aux/(1+aux)))
"""
# debug
"""
print('\n original degree sequence ', d)
print('\n original strength sequence ', s)
print('\n ensemble average strength sequence', s_emp)
print('\n degree by degree difference vector ', d_diff)
print('\n strength by strength difference vector ', s_diff)
print('\n empirical error = {}'.format(ensemble_error))
print('\n theoretical error = {}'.format(err))
"""
l = os.listdir(output_dir)
for f in l:
os.remove(output_dir + f)
os.rmdir(output_dir)
# test result
self.assertTrue(ensemble_error<3)
def test_0(self):
"""test with 3 classes of cardinality 1
and no zero degrees
"""
"""
A = np.array(
[
[0, 1, 1, 0],
[1, 0, 0, 1],
[1, 0, 0, 0],
[0, 1, 0, 0],
]
)
e = [(0,1), (0,2), (1,3)]
d = [1,1,2,2]
print(e)
print(d)
"""
N, seed = (10, 42)
A = mg.random_binary_matrix_generator_dense(N, sym=True, seed=seed)
# number of copies to generate
g = sample.UndirectedGraph(A)
g._solve_problem(
model="cm",
method="fixed-point",
max_steps=100,
verbose=False,
linsearch=True,
initial_guess="uniform",
)
x = g.x
# g._solution_error()
err = g.error
# print('\ntest 5: error = {}'.format(g.error))
n = 10
output_dir = "sample/"
# random.seed(100)
g_list = []
for i in range(n):
g.ensemble_sampler(n=1, output_dir=output_dir)
g_list.append(np.loadtxt("sample/0.txt"))
appo = True
old = g_list[0]
for i in range(1, n):
appo = appo * np.all(old == g_list[i])
# debug
"""
print('original dseq',d)
print('original dseq sum ',g.dseq.sum())
print('ensemble average dseq', d_emp)
print('ensemble dseq sum ',np.array([d_emp[key] for key in d_emp.keys()]).sum())
print(d_diff)
print('empirical error', ensemble_error)
print('theoretical error', err)
"""
l = os.listdir(output_dir)
for f in l:
os.remove(output_dir + f)
os.rmdir(output_dir)
# test result
self.assertTrue(not appo)
