def __unit_test(graph):
A = merw.graph_to_matrix(graph)
n = len(graph)
print('\n>>>> GRAF: ')
print_adiacency_matrix(A)
Rsim, eps = merw.compute_basic_simrank(graph, .9, 0, 1000)
print('Zwykły SimRank')
print_similarity_matrix(Rsim)
print('Dokładność:', eps)
Rmerw, eps = merw.compute_merw_simrank(graph, 1., 0, 1000)
print('MERW SimRank')
print_similarity_matrix(Rmerw)
print('Dokładność:', eps)
print('Samo MERW')
P, vekt, val, dist = merw.compute_merw(A)
print('Rozkład stacjonarny: ', dist)
print_similarity_matrix(P)
print('Eigen-wieghted:')
for v in range(n):
for w in graph[v]:
if v < w:
print('(', v+1, w+1, ')', vekt[v]*vekt[w]/val)
print('Samo GRW')
P, dist = merw.compute_grw(A)
print('Rozkład stacjonarny: ', dist)
print_similarity_matrix(P)
def __experiment_02(data_set, set_no=1, aucn=2000, category='math.GN'):
print('Kategoria: ',category)
data = dataset.DataSet('../datasets/', category, data_set)
matrix = sparse.csc_matrix(
data.get_training_set(mode='adjacency_matrix_lil', ds_index=set_no), dtype='d')
training = data.get_training_set() #metrics.get_edges_set(data.get_training_set())
test = data.get_test_edges() #metrics.get_edges_set(data.get_test_edges())
print('Rozmiar grafu=',data.vx_count)
print('Obliczanie MERW i GRW...')
Pgrw, sd = merw.compute_grw(matrix)
Pmerw, vekt, eval, stat = merw.compute_merw_matrix(matrix)
for a in [.1, .5, .9]:
print('alfa=', a)
p_dist = merw.compute_P_distance(Pgrw, alpha=a)
print(' Skuteczność PD (AUC {}):'.format(aucn),
metrics.auc(data.vx_count, training, test, p_dist, aucn))
p_dist = merw.compute_P_distance(Pmerw, alpha=a)
print(' Skuteczność MEPD (AUC {}):'.format(aucn),
metrics.auc(data.vx_count, training, test, p_dist, aucn))
p_dist = merw.compute_P_distance(Pgrw, alpha=a)
print(' Skuteczność PDM (AUC {}):'.format(aucn),
metrics.auc(data.vx_count, training, test, p_dist, aucn))
p_dist = merw.compute_P_distance(Pmerw, alpha=a)
print('Skuteczność MEPDM (AUC {}):'.format(aucn),
metrics.auc(data.vx_count, training, test, p_dist, aucn))
def __test_pdistance_alpha(graph):
A = merw.graph_to_matrix(graph)
Pgrw, vekt = merw.compute_grw(A)
for a in [0.1, 0.2, 0.3, 0.4, 0.5 ,0.6, 0.7, 0.8, 0.9, 0.999]:
print("\nP-distance GRW: Alpha=", a)
R = merw.compute_P_distance(Pgrw, alpha=a)
diag = sparse.linalg.inv(sparse.diags([R.diagonal()], [0], format='csc'))
# każdy wiersz "normujemy" do wyrazu na przekątnej
print_similarity_matrix(diag * R)
def __test_pdistance(graph):
A = merw.graph_to_matrix(graph)
Pgrw, vekt = merw.compute_grw(A)
# print(vekt * Pgrw)
Pmerw, val, vekt, dist = merw.compute_merw(A)
R, eps = merw.compute_P_distance(Pgrw)
print("\nP-distance GRW")
print_similarity_matrix(R)
print(' Dokładność:', eps)
R, eps = merw.compute_P_distance(Pmerw)
print("P-distance MERW")
print_similarity_matrix(R)
print(' Dokładność:', eps)
def __experiment_01(data_set, skipSimRank=False, set_no=1, a=0.5, aucn=2000, simrank_iter=10, category='math.GN'):
print('Kategoria: ',category)
data = dataset.DataSet('../datasets/', category, data_set)
matrix = sparse.csc_matrix(
data.get_training_set(mode='adjacency_matrix_csc', ds_index=set_no), dtype='d')
training = data.get_training_set() #metrics.get_edges_set(data.get_training_set())
test = data.get_test_edges() #metrics.get_edges_set(data.get_test_edges())
print('Zestaw',set_no,' N=', data.vx_count)
#print('Obliczanie: macierzy przejścia MERW...', end=' ')
#print(vekt)
#print(Pmerw.get_shape()[0])
#print('macierzy "odległości"...')
#print('Obliczanie: macierzy przejścia GRW... ', end=' ')
Pgrw, sd = merw.compute_grw(matrix)
#print('macierzy "odległości"...')
p_dist_grw = merw.compute_P_distance(Pgrw, alpha=a)
print(' Skuteczność PD (AUC {}):'.format(aucn),
metrics.auc(data.vx_count, training, test, p_dist_grw, aucn))
Pmerw, vekt, eval, stat = merw.compute_merw_matrix(matrix)
p_dist_merw = merw.compute_P_distance(Pmerw, alpha=a)
print(' Skuteczność MEPD (AUC {}):'.format(aucn),
metrics.auc(data.vx_count, training, test, p_dist_merw, aucn))
ep_dist_grw = merw.compute_P_distance(Pgrw, alpha=a)
print(' Skuteczność PDM (AUC {}):'.format(aucn),
metrics.auc(data.vx_count, training, test, ep_dist_grw, aucn))
ep_dist_merw = merw.compute_P_distance(Pmerw, alpha=a)
print(' Skuteczność PDM (AUC {}):'.format(aucn),
metrics.auc(data.vx_count, training, test, ep_dist_merw, aucn))
if skipSimRank:
return
graph = merw.matrix_to_graph(matrix)
#print(graph)
print('SimRank...',end='')
sr, eps = merw.compute_basic_simrank(graph, a, maxiter=simrank_iter)
print(' Dokładność:', eps)
print(' Skuteczność SR (AUC {}):'.format(aucn),
metrics.auc(data.vx_count, training, test, sr, aucn))
print('MERW SimRank...',end='')
sr, eps = merw.compute_merw_simrank_ofmatrix(matrix, a, maxiter=simrank_iter)
print(' Dokładność:', eps)
print(' Skuteczność MESR (AUC {}):'.format(aucn),
metrics.auc(data.vx_count, training, test, sr, aucn))
def walks_survey(A):
print('A (adjacency matrix):')
print(A)
print()
print('-------------------------------------')
print('GRW:')
P_grw, pi_grw = rw.compute_grw(csc_matrix(A))
print()
print('P (GRW transition matrix):')
print_sparse_as_dense(P_grw)
print()
print('pi (GRW stationary distribution):')
print(pi_grw)
L_grw = kern.general_laplacian(P_grw, pi_grw)
print()
print('L (GRW general laplacian):')
print_sparse_as_dense(L_grw)
LL = kern.laplacian(csr_matrix(A, (A.shape[0], A.shape[1]), 'd'))
print()
print('LL (GRW laplacian):')
print_sparse_as_dense(LL)
LL_sym = kern.symmetric_normalized_laplacian(
csr_matrix(A, (A.shape[0], A.shape[1]), 'd'))
print()
print('L (GRW symmetric normalized laplacian):')
print_sparse_as_dense(LL_sym)
print()
print('-------------------------------------')
print('MERW:')
P_merw, v_merw, lambda_merw, pi_merw = \
rw.compute_merw(csr_matrix(A, (A.shape[0], A.shape[1]), 'd'))
v_merw *= -1
l, v = sla.eigsh(csr_matrix(A, (A.shape[0], A.shape[1]), 'd'),
1,
which='LA')
lambda_max = l[0]
v_max = v[:, 0]
print()
print('P (MERW transition matrix):')
print_sparse_as_dense(P_merw)
print()
print('pi (MERW stationary distribution):')
print(pi_merw)
print()
print('lambda (max eigenvalue):')
print(lambda_merw)
print(lambda_max)
print()
print('v (max eigenvector):')
print(v_merw)
print(v_max)
W = kern.compute_eigen_weighted_graph(
csr_matrix(A, (A.shape[0], A.shape[1]), 'd'), lambda_merw, v_merw)
print()
print('W (eigen-weighted graph):')
print_sparse_as_dense(W)
L_merw = kern.general_laplacian(P_merw, pi_merw)
print()
print('L (MERW general laplacian):')
print_sparse_as_dense(L_merw)
L = kern.mecl(csr_matrix(A, (A.shape[0], A.shape[1]), 'd'), lambda_merw,
v_merw)
print()
print('L (maximal entropy combinatorial laplacian):')
print_sparse_as_dense(L)
L_sym = kern.mecl(csr_matrix(A, (A.shape[0], A.shape[1]), 'd'),
lambda_merw,
v_merw,
type='sym')
print()
print('L_sym (symmetric normalized maximal entropy laplacian):')
print_sparse_as_dense(L_sym)
L_asym = kern.mecl(csr_matrix(A, (A.shape[0], A.shape[1]), 'd'),
lambda_merw,
v_merw,
type='asym')
print()
print('L_rw (asymmetric normalized maximal entropy laplacian):')
print_sparse_as_dense(L_asym)
CK = kern.commute_time_kernel(LL, 3)
print()
print('CK:')
print_sparse_as_dense(CK)
NCK = kern.commute_time_kernel(LL_sym, 3)
print()
print('NCK:')
print_sparse_as_dense(NCK)
MECK = kern.commute_time_kernel(L, 3)
print()
print('MECK:')
print_sparse_as_dense(MECK)
NMECK = kern.commute_time_kernel(L_sym, 3)
print()
print('NMECK:')
print_sparse_as_dense(NMECK)
DK = kern.heat_diffusion_kernel(LL)
print()
print('DK:')
print_sparse_as_dense(DK)
NDK = kern.heat_diffusion_kernel(LL_sym, 3)
print()
print('NDK:')
print_sparse_as_dense(NDK)
MEDK = kern.heat_diffusion_kernel(L)
print()
print('MEDK:')
print_sparse_as_dense(MEDK)
NMEDK = kern.heat_diffusion_kernel(L_sym, 3)
print()
print('NMEDK:')
print_sparse_as_dense(NMEDK)
RK = kern.regularized_laplacian_kernel(LL)
print()
print('RK:')
print_sparse_as_dense(RK)
NRK = kern.regularized_laplacian_kernel(LL_sym)
print()
print('NRK:')
print_sparse_as_dense(NRK)
MERK = kern.regularized_laplacian_kernel(L)
print()
print('MERK:')
print_sparse_as_dense(MERK)
NMERK = kern.regularized_laplacian_kernel(L_sym)
print()
print('NMERK:')
print_sparse_as_dense(NMERK)
MENK = kern.neumann_kernel(csr_matrix(A, (A.shape[0], A.shape[1]), 'd'),
lambda_merw, v_merw)
print()
print('MENK:')
print_sparse_as_dense(MENK)
NNK = kern.traditional_normalized_neumann_kernel(
csr_matrix(A, (A.shape[0], A.shape[1]), 'd'))
print()
print('NNK:')
print_sparse_as_dense(NNK)
NMENK = kern.normalized_neumann_kernel(
csr_matrix(A, (A.shape[0], A.shape[1]), 'd'), lambda_merw, v_merw)
print()
print('NMENK:')
print_sparse_as_dense(NMENK)