def test_graph_rcm_bucky():
"Graph: Reverse Cuthill-McKee Ordering (Bucky)"
B = np.load(pwd+'/bucky.npy')
B = sp.csr_matrix(B, dtype=float)
perm = reverse_cuthill_mckee(B)
ans = np.load(pwd+'/bucky_perm.npy')
assert_equal(perm, ans)
def test_graph_rcm_bucky():
"Graph: Reverse Cuthill-McKee Ordering (Bucky)"
B = np.load(pwd+'/bucky.npy')
B = sp.csr_matrix(B, dtype=float)
perm = reverse_cuthill_mckee(B)
ans = np.load(pwd+'/bucky_perm.npy')
assert_equal(perm, ans)
def test_graph_rcm_simple():
"Graph: Reverse Cuthill-McKee Ordering (simple)"
A = np.array([[1, 0, 0, 0, 1, 0, 0, 0], [0, 1, 1, 0, 0, 1, 0, 1],
[0, 1, 1, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 1, 0],
[1, 0, 1, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 1, 0, 1],
[0, 0, 0, 1, 0, 0, 1, 0], [0, 1, 0, 0, 0, 1, 0, 1]],
dtype=np.int32)
A = sp.csr_matrix(A)
perm = reverse_cuthill_mckee(A)
ans = np.array([6, 3, 7, 5, 1, 2, 4, 0])
assert_equal((perm - ans).all(), 0)
def test_graph_rcm_simple():
"Graph: Reverse Cuthill-McKee Ordering (simple)"
A = np.array([[1, 0, 0, 0, 1, 0, 0, 0],
[0, 1, 1, 0, 0, 1, 0, 1],
[0, 1, 1, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 1, 0],
[1, 0, 1, 0, 1, 0, 0, 0],
[0, 1, 0, 0, 0, 1, 0, 1],
[0, 0, 0, 1, 0, 0, 1, 0],
[0, 1, 0, 0, 0, 1, 0, 1]], dtype=np.int32)
A = sp.csr_matrix(A)
perm = reverse_cuthill_mckee(A)
ans = np.array([6, 3, 7, 5, 1, 2, 4, 0])
assert_equal((perm - ans).all(), 0)
def test_graph_rcm_qutip():
"Graph: Reverse Cuthill-McKee Ordering (qutip)"
kappa = 1
gamma = 0.01
g = 1
wc = w0 = wl = 0
N = 2
E = 1.5
a = tensor(destroy(N), qeye(2))
sm = tensor(qeye(N), sigmam())
H = (w0-wl)*sm.dag(
)*sm+(wc-wl)*a.dag()*a+1j*g*(a.dag()*sm-sm.dag()*a)+E*(a.dag()+a)
c_ops = [np.sqrt(2*kappa)*a, np.sqrt(gamma)*sm]
L = liouvillian(H, c_ops)
perm = reverse_cuthill_mckee(L.data)
ans = np.array([12, 14, 4, 6, 10, 8, 2, 15, 0, 13, 7, 5, 9, 11, 1, 3])
assert_equal(perm, ans)
def test_graph_rcm_qutip():
"Graph: Reverse Cuthill-McKee Ordering (qutip)"
kappa = 1
gamma = 0.01
g = 1
wc = w0 = wl = 0
N = 2
E = 1.5
a = tensor(destroy(N), qeye(2))
sm = tensor(qeye(N), sigmam())
H = (w0-wl)*sm.dag(
)*sm+(wc-wl)*a.dag()*a+1j*g*(a.dag()*sm-sm.dag()*a)+E*(a.dag()+a)
c_ops = [np.sqrt(2*kappa)*a, np.sqrt(gamma)*sm]
L = liouvillian(H, c_ops)
perm = reverse_cuthill_mckee(L.data)
ans = np.array([12, 14, 4, 6, 10, 8, 2, 15, 0, 13, 7, 5, 9, 11, 1, 3])
assert_equal(perm, ans)
def test_graph_rcm_boost():
"Graph: Reverse Cuthill-McKee Ordering (boost)"
M = np.zeros((10, 10))
M[0, [3, 5]] = 1
M[1, [2, 4, 6, 9]] = 1
M[2, [3, 4]] = 1
M[3, [5, 8]] = 1
M[4, 6] = 1
M[5, [6, 7]] = 1
M[6, 7] = 1
M = M+M.T
M = sp.csr_matrix(M)
perm = reverse_cuthill_mckee(M, 1)
ans_perm = np.array([9, 7, 6, 4, 1, 5, 0, 2, 3, 8])
assert_equal((perm - ans_perm).all(), 0)
P = sp_permute(M, perm, perm)
bw = sp_bandwidth(P)
assert_equal(bw[2], 4)
def test_graph_rcm_boost():
"Graph: Reverse Cuthill-McKee Ordering (boost)"
M = np.zeros((10, 10))
M[0, [3, 5]] = 1
M[1, [2, 4, 6, 9]] = 1
M[2, [3, 4]] = 1
M[3, [5, 8]] = 1
M[4, 6] = 1
M[5, [6, 7]] = 1
M[6, 7] = 1
M = M+M.T
M = sp.csr_matrix(M)
perm = reverse_cuthill_mckee(M, 1)
ans_perm = np.array([9, 7, 6, 4, 1, 5, 0, 2, 3, 8])
assert_equal((perm - ans_perm).all(), 0)
P = sp_permute(M, perm, perm)
bw = sp_bandwidth(P)
assert_equal(bw[2], 4)
def phones_test():
import sklearn.preprocessing
from conceptual_space import monary_load
topmodel = monary_load("phones", [
'Volume_(cubic_cm)', 'Display_Width(px)', 'Width_(mm)',
'Display_Diagonal_(in)', 'Display_Length(px)', 'Depth_(mm)',
'CPU_Clock_(MHz)', 'Mass_(grams)', 'ROM_Capacity_(Mb)', 'Length_(mm)',
'RAM_Capacity_(Mb)', 'Release_Year', 'Pixel_Density_(per_inch)'
], [])
F_by_O = topmodel.X.T
print F_by_O.shape
scipy.misc.imsave("F_by_O.png", F_by_O)
print "Data extraction complete"
#F_by_F = np.corrcoef(F_by_O)
#O_by_O = np.corrcoef(F_by_O.T)
#scipy.misc.imsave("O_by_O.png",O_by_O)
#print "Corrcoefs complete"
#SVD Calcs for O by O, comments taken from Som's community detection code.
#k = 13
for k in range(2, 7):
for t in [0.75]:
U, s, V = scipy.sparse.linalg.svds(
F_by_O.T, k=k
) # Question remains whether this should be F by O or O by O!
s = np.diagflat(s)
print U.shape
print s
print V.shape
# Perform dimensionality reduction, using parameter k. A good way to decide
# on an optimal k value is to run the algorithm once, and plot the singular
# values in decreasing order of magnitude. Then, choose k largest singular
# values (the ones which show maximum gaps), and rerun algorithm at this k.
#svdu = U[:,:k]
#svds = s[:k,:k]
#svdv = V[:,:k]
# Generate US or SV products for generating reduced dimensional vectors
# for nodes. This is the same if the matrix is symmetric and square.
#u_red = svdu*svds
u_red = np.matrix(U) * np.matrix(s)
print "u_red: ", u_red.shape
#v_red = svds*svdv.T
#v_red = v_red.T
v_red = np.matrix(s) * np.matrix(V)
print "v_red: ", v_red.shape
print "SVDs complete"
#scipy.misc.imsave("u_red"+str(k)+"_"+str(t)+".png",u_red)
#scipy.misc.imsave("v_red"+str(k)+"_"+str(t)+".png",v_red)
# Compute cosine measurements between all US combinations. Produce the
# cosine matrix in reduced k-space. Z_u will show communities for only Type
# 1 nodes (rows of the original matrix).
#Z_u = sklearn.metrics.pairwise.pairwise_distances(u_red,metric="cosine",n_jobs=-1)
Z_u = np.corrcoef(u_red) / 2 + 0.5
Z_u_labels = sklearn.cluster.MiniBatchKMeans(
n_clusters=k).fit_predict(Z_u)
clustersort = np.argsort(Z_u_labels)
cm = matplotlib.cm.get_cmap("jet")
cm.set_under(color="k", alpha=0)
Z_u_clusters = np.zeros(Z_u.shape) - 0.01
#Z_u_clusters = np.dstack([Z_u_clusters,Z_u_clusters,Z_u_clusters,np.ones(Z_u.shape)*255])
#for i in range(k):
# lmask = np.matrix((Z_u_labels == i).astype(int))
# Z_u_clusters += (lmask.T * lmask) * (float(i+1)/(k+1))
for i, l1 in enumerate(Z_u_labels):
for j, l2 in enumerate(Z_u_labels):
if l1 == l2:
Z_u_clusters[i, j] = float(l1 + 1) / k
#scipy.misc.imsave("Z_u_clusters_"+str(k)+".png",Z_u_clusters)
#Z_u_overlaid = cm(Z_u_clusters, bytes=True)*np.dstack([Z_u,Z_u,Z_u,np.ones((Z_u.shape))])
#TODO: WOrking on how to get this to add when the second image is 0s, and multiply when it's not
#Z_u_labels.shape = (Z_u_labels.shape[0],1)
#Z_u_overlaid = cm(Z_u_labels + Z_u)
scipy.misc.imsave("Z_u_clusters" + str(k) + "_" + str(t) + ".png",
cm(Z_u_clusters, bytes=True))
#pprint.pprint(Z_u_overlaid)
#scipy.misc.imsave("Z_u_clusters_"+str(k)+".png",cm(Z_u_clusters, bytes=True))
#scipy.misc.imsave("Z_u_nocorr_"+str(k)+".png",Z_u)
scipy.misc.imsave("Z_u_" + str(k) + ".png", Z_u)
Z_u_bin = sklearn.preprocessing.binarize(Z_u, t)
#scipy.misc.imsave("Z_u_bin_nocorr_"+str(k)+"_"+str(t)+".png",Z_u_bin)
scipy.misc.imsave("Z_u_bin_" + str(k) + "_" + str(t) + ".png",
Z_u_bin)
from networkx.utils import reverse_cuthill_mckee_ordering
rcm_order = qutip.reverse_cuthill_mckee(
scipy.sparse.csr_matrix(1 - Z_u_bin)
) # This *should* produce a good diagonalisation? Hasn't been tested.
Z_u_rcm = Z_u[rcm_order, :]
Z_u_rcm = Z_u_rcm[:, rcm_order]
Z_u_clst = Z_u[clustersort, :]
Z_u_clst = Z_u_clst[:, clustersort]
#Z_u_bin_rcm = Z_u_bin[rcm_order,:]
#Z_u_bin_rcm = Z_u_bin_rcm[:,rcm_order]
Z_u_clusters_rcm = Z_u_clusters[rcm_order, :]
Z_u_clusters_rcm = Z_u_clusters_rcm[:, rcm_order]
Z_u_clusters_clst = Z_u_clusters[clustersort, :]
Z_u_clusters_clst = Z_u_clusters_clst[:, clustersort]
#Z_u_overlaid = Z_u_overlaid[rcm_order,:,:]
#Z_u_overlaid = Z_u_overlaid[:,rcm_order,:]
#O_by_O_rcm = O_by_O[rcm_order,:]
#O_by_O_rcm = O_by_O_rcm[:,rcm_order]
#scipy.misc.imsave("Z_u_rcm_nocorr_"+str(k)+"_"+str(t)+".png",Z_u_rcm)
#scipy.misc.imsave("O_by_O_rcm_nocorr_"+str(k)+"_"+str(t)+".png",O_by_O_rcm)
scipy.misc.imsave("Z_u_rcm_" + str(k) + "_" + str(t) + ".png",
Z_u_rcm)
scipy.misc.imsave("Z_u_clst_" + str(k) + "_" + str(t) + ".png",
Z_u_clst)
#scipy.misc.imsave("Z_u_bin_rcm_"+str(k)+"_"+str(t)+".png",Z_u_bin_rcm)
#scipy.misc.imsave("Z_u_overlaid_rcm"+str(k)+"_"+str(t)+".png",Z_u_overlaid)
scipy.misc.imsave(
"Z_u_clusters_rcm_" + str(k) + "_" + str(t) + ".png",
cm(Z_u_clusters_rcm, bytes=True))
scipy.misc.imsave(
"Z_u_clusters_clst_" + str(k) + "_" + str(t) + ".png",
cm(Z_u_clusters_clst, bytes=True))
#scipy.misc.imsave("Z_u_bin_rcm_"+str(k)+"_"+str(t)+".png",Z_u_bin_rcm)
#scipy.misc.imsave("Z_u_clusters_rcm_"+str(k)+"_"+str(t)+".png",cm(Z_u_clusters_rcm, bytes=True))
#scipy.misc.imsave("O_by_O_rcm_"+str(k)+"_"+str(t)+".png",O_by_O_rcm)
print "Reorder and image saving complete"
#Now need to do a k-means on the matrices, pluck out groups, and then describe them. Also want to pluck groupings at different sizes.
sys.exit()
print model_inspector.deep_recon_errors(model["training_data"].X, topmodel)
errors = np.zeros(
(model["training_data"].X.shape[0], len(topmodel['layers'])))
Os = []
O_recons = []
for i, x in enumerate(model["training_data"].X):
Os.append(x)
errors[i] = model_inspector.deep_recon_errors(x, topmodel)[-1]
O_recons.append(model_inspector.reconstruct(topmodel, x))
