def worker():
x = diags([1, -2, 1], [-1, 0, 1], shape=(50, 50))
w, v = eigs(x, k=3, v0=v0)
results.append(w)
w, v = eigsh(x, k=3, v0=v0)
results.append(w)
def _sparse_left_svd():
# for some reasons arpack does not allow computation of rank(A) eigenvectors (??)
AA = self.data.transpose()*self.data
if self.data.shape[1] > 1:
# do not compute full rank if desired
if self._k > 0 and self._k < self.data.shape[1]-1:
k = self._k
else:
k = self.data.shape[1]-1
try:
values, v_vectors = linalg.eigen_symmetric(AA,k=k)
except AttributeError:
values, v_vectors = linalg.eigsh(AA,k=k)
else:
values, v_vectors = eigh(AA.todense())
# get rid of too low eigenvalues
v_vectors = v_vectors[:, values > self._EPS]
values = values[values > self._EPS]
# sort eigenvectors according to largest value
idx = np.argsort(values)
values = values[idx[::-1]]
# argsort sorts in ascending order -> access is backwards
self.V = scipy.sparse.csc_matrix(v_vectors[:,idx[::-1]])
# compute S
self.S = scipy.sparse.csc_matrix(np.diag(np.sqrt(values)))
# and the inverse of it
S_inv = scipy.sparse.csc_matrix(np.diag(1.0/np.sqrt(values)))
self.U = self.data * self.V * S_inv
self.V = self.V.transpose()
def ED(n):
#n: number of sites
J = 1 #coupling for sum_{<ij>}s^z_i s^z_j
h = 1 #coupling for sum_{i}s^x_i
row = np.array(range(2**n))
l = [bin(x)[2:].rjust(n, '0') for x in range(2**n)]
b = np.array([np.array(map(int, i)) for i in l])
d = np.array([np.array(map(int, i)) for i in l])
onlyone1 = []
for i in range(n):
onlyone1.append(b[2**i])
onlyone1 = np.asarray(onlyone1)
###########################################################
'''Sort Tags'''
T = []
for i in range(2**n):
T.append(calculateTag(b[i]))
Tsorted = np.asarray(qsort(T))
###########################################################
data = [-J*(n-1.)]
rowcol = [0]
abc = np.zeros((n-1), dtype=np.double)
off_row = []
off_col = []
off_data = []
for i in range(2**n):
'''Diagonal'''
for j in reversed(range(n-1)):
if b[i,j]==b[i,j+1]:
abc[j] = binary_search(Tsorted,calculateTag(b[i]))
else:
abc[j] = -binary_search(Tsorted,calculateTag(b[i]))
if np.sum(abc)!=0:
rowcol.append(i)
data.append(-J * (np.sum(abc))/(abs(abc[0])))
'''Off Diagonal'''
for j in range(n):
off_col.append(binary_search(Tsorted,calculateTag(np.bitwise_xor(d[i],onlyone1[j]))))
off_row.append(i)
off_data.append(-h)
Diagonal = sparse.csr_matrix((data,(rowcol,rowcol)), dtype=np.double).toarray()
Off_Diagonal = sparse.csr_matrix((off_data, (off_row,off_col)), dtype=np.double).toarray()
##########################################################
'''Diagonalize Full Hamiltonian'''
Ham = Diagonal + Off_Diagonal
print Ham
vals, vecs = arp.eigsh(Ham, k=1, which='SA')
print vals
def arpack_eigsh(A, **kwargs):
"""
Scipy 0.9 renamed eigen_symmetric to eigsh in
scipy.sparse.linalg.eigen.arpack
"""
from scipy.sparse.linalg.eigen import arpack
if hasattr(arpack, 'eigsh'):
return arpack.eigsh(A, **kwargs)
else:
return arpack.eigen_symmetric(A, **kwargs)
def compute_rank_approx(sz, routes):
A, b, N, block_sizes, x_true = util.load_data(str(sz)+"/experiment2_waypoints_matrices_routes_"+str(routes)+".mat")
def matvec_XH_X(x):
return A.dot(A.T.dot(x))
XH_X = LinearOperator(matvec=matvec_XH_X, dtype=A.dtype, shape=(A.shape[0], A.shape[0]))
eigvals, eigvec = eigsh(XH_X, k=500, tol=10**-5)
eigvals = eigvals[::-1]
for i, val in enumerate(eigvals):
if val < 10**-6:
return (N.shape[1], i)
def arpack_eigsh(A, **kwargs):
"""Compat function for sparse symmetric eigen vectors decomposition
Scipy 0.9 renamed eigen_symmetric to eigsh in
scipy.sparse.linalg.eigen.arpack
"""
from scipy.sparse.linalg.eigen import arpack
if hasattr(arpack, 'eigsh'):
return arpack.eigsh(A, **kwargs)
else:
return arpack.eigen_symmetric(A, **kwargs)
def test_symmetric_no_convergence():
np.random.seed(1234)
m = generate_matrix(30, hermitian=True, pos_definite=True)
tol, rtol, atol = _get_test_tolerance('d')
try:
w, v = eigsh(m, 4, which='LM', v0=m[:, 0], maxiter=5, tol=tol)
raise AssertionError("Spurious no-error exit")
except ArpackNoConvergence as err:
k = len(err.eigenvalues)
if k <= 0:
raise AssertionError("Spurious no-eigenvalues-found case")
w, v = err.eigenvalues, err.eigenvectors
assert_allclose(dot(m, v), w * v, rtol=rtol, atol=atol)
def eval_evec(self,d,typ,k,which,v0=None):
a=d['mat'].astype(typ)
if v0 == None:
v0 = d['v0']
exact_eval=self.get_exact_eval(d,typ,k,which)
eval,evec=eigsh(a,k,which=which,v0=v0)
# check eigenvalues
assert_array_almost_equal(eval,exact_eval,decimal=_ndigits[typ])
# check eigenvectors A*evec=eval*evec
for i in range(k):
assert_array_almost_equal(dot(a,evec[:,i]),
eval[i]*evec[:,i],
decimal=_ndigits[typ])
def test_eigsh_for_k_greater():
# Test eigsh() for k beyond limits.
A_sparse = diags([1, -2, 1], [-1, 0, 1], shape=(4, 4)) # sparse
A = generate_matrix(4, sparse=False)
M_dense = generate_matrix_symmetric(4, pos_definite=True)
M_sparse = generate_matrix_symmetric(4, pos_definite=True, sparse=True)
M_linop = aslinearoperator(M_dense)
eig_tuple1 = eigh(A, b=M_dense)
eig_tuple2 = eigh(A, b=M_sparse)
with suppress_warnings() as sup:
sup.filter(RuntimeWarning)
assert_equal(eigsh(A, M=M_dense, k=4), eig_tuple1)
assert_equal(eigsh(A, M=M_dense, k=5), eig_tuple1)
assert_equal(eigsh(A, M=M_sparse, k=5), eig_tuple2)
# M as LinearOperator
assert_raises(TypeError, eigsh, A, M=M_linop, k=4)
# Test 'A' for different types
assert_raises(TypeError, eigsh, aslinearoperator(A), k=4)
assert_raises(TypeError, eigsh, A_sparse, M=M_dense, k=4)
def pca(self, data):
# get dimensions
num_data,dim = data.shape
if dim>num_data:
K = np.dot(data,data.T)
eigen_values,eigen_vectors = eigsh(K,k = np.linalg.matrix_rank(K)-1,which = 'LA')
U = np.dot(data.T,eigen_vectors/np.sqrt(eigen_values))
eigen_values, eigen_vectors = eigen_values[::-1]/(len(data)-1),U[:,::-1]
else:
U,eigen_values,eigen_vectors = np.linalg.svd(data,full_matrices=False)
eigen_vectors=eigen_vectors.T
return eigen_vectors, eigen_values.cumsum(axis=0)/eigen_values.sum()
def test_no_convergence(self):
np.random.seed(1234)
m = np.random.rand(30, 30)
m = m + m.T
try:
w, v = eigsh(m, 4, which='LM', v0=m[:,0], maxiter=5)
raise AssertionError("Spurious no-error exit")
except ArpackNoConvergence, err:
k = len(err.eigenvalues)
if k <= 0:
raise AssertionError("Spurious no-eigenvalues-found case")
w, v = err.eigenvalues, err.eigenvectors
for ww, vv in zip(w, v.T):
assert_array_almost_equal(dot(m, vv), ww*vv,
decimal=_ndigits['d'])
def ncut( W, nbEigenValues ):
# parameters
offset=.5
maxiterations=100
eigsErrorTolerence=1e-6
truncMin=1e-6
eps=2.2204e-16
m=shape(W)[1]
# make sure that W is symmetric, this is a computationally expensive operation, only use for debugging
#if (W-W.transpose()).sum() != 0:
# print "W should be symmetric!"
# exit(0)
# degrees and regularization
# S Yu Understanding Popout through Repulsion CVPR 2001
# Allows negative values as well as improves invertability
# of d for small numbers
# i bet that this is what improves the stability of the eigen
d=abs(W).sum(0)
dr=0.5*(d-W.sum(0))
d=d+offset*2
dr=dr+offset
# calculation of the normalized LaPlacian
W=W+spdiags(dr,[0],m,m,"csc")
Dinvsqrt=spdiags((1.0/sqrt(d+eps)),[0],m,m,"csc")
P=Dinvsqrt*(W*Dinvsqrt);
# perform the eigen decomposition
eigen_val,eigen_vec=eigsh(P,nbEigenValues,maxiter=maxiterations,tol=eigsErrorTolerence,which='LA')
# sort the eigen_vals so that the first
# is the largest
i=argsort(-eigen_val)
eigen_val=eigen_val[i]
eigen_vec=eigen_vec[:,i]
# normalize the returned eigenvectors
eigen_vec=Dinvsqrt*matrix(eigen_vec)
norm_ones=norm(ones((m,1)))
for i in range(0,shape(eigen_vec)[1]):
eigen_vec[:,i]=(eigen_vec[:,i] / norm(eigen_vec[:,i]))*norm_ones
if eigen_vec[0,i] != 0:
eigen_vec[:,i] = -1 * eigen_vec[:,i] * sign( eigen_vec[0,i] )
return(eigen_val, eigen_vec)
def update_bond(self, i):
j = i + 1
# get effective Hamiltonian
Heff = HEffective(self.LPs[i], self.RPs[j], self.H_mpo[i], self.H_mpo[j])
# Diagonalize Heff, find ground state `theta`
theta0 = np.reshape(self.psi.get_theta2(i), [Heff.shape[0]]) # initial guess
e, v = arp.eigsh(Heff, k=1, which='SA', return_eigenvectors=True, v0=theta0)
theta = np.reshape(v[:, 0], Heff.theta_shape)
# split and truncate
Ai, Sj, Bj = split_truncate_theta(theta, self.chi_max, self.eps)
# put back into MPS
Gi = np.tensordot(np.diag(self.psi.Ss[i]**(-1)), Ai, axes=[1, 0]) # vL [vL*], [vL] i vC
self.psi.Bs[i] = np.tensordot(Gi, np.diag(Sj), axes=[2, 0]) # vL i [vC], [vC*] vC
self.psi.Ss[j] = Sj # vC
self.psi.Bs[j] = Bj # vC j vR
self.update_LP(i)
self.update_RP(j)
def kpca(data, k):
"""
Performs the eigen decomposition of the kernel matrix.
arguments:
* data: 2D numpy array representing the symmetric kernel matrix.
* k: number of principal components to keep.
return:
* w: the eigen values of the covariance matrix sorted in from
highest to lowest.
* u: the corresponding eigen vectors. u[:,i] is the vector
corresponding to w[i]
Notes: If you want to perform the full decomposition, consider
using 'full_kpca' instead.
"""
w, u = eigsh(data, k=k, which='LA')
return w[::-1], u[:, ::-1]
def _sparse_left_svd():
# for some reasons arpack does not allow computation of rank(A) eigenvectors (??)
AA = self.data.transpose()*self.data
if self.data.shape[1] > 1:
# do not compute full rank if desired
if self._k > 0 and self._k < AA.shape[1]-1:
k = self._k
else:
k = self.data.shape[1]-1
if scipy.version.version == '0.9.0':
values, v_vectors = linalg.eigsh(AA,k=k)
else:
values, v_vectors = linalg.eigen_symmetric(AA,k=k)
else:
values, v_vectors = eigh(AA.todense())
# get rid of negative/too low eigenvalues
s = np.where(values > self._EPS)[0]
v_vectors = v_vectors[:, s]
values = values[s]
# sort eigenvectors according to largest value
idx = np.argsort(values)[::-1]
values = values[idx]
# argsort sorts in ascending order -> access is backwards
self.V = scipy.sparse.csc_matrix(v_vectors[:,idx])
# compute S
tmp_val = np.sqrt(values)
l = len(idx)
self.S = scipy.sparse.spdiags(tmp_val, 0, l, l,format='csc')
# and the inverse of it
S_inv = scipy.sparse.spdiags(1.0/tmp_val, 0, l, l,format='csc')
self.U = self.data * self.V * S_inv
self.V = self.V.transpose()
def pca(data, k):
"""
Performs the eigen decomposition of the covariance matrix.
arguments:
* data: 2D numpy array where each row is a sample and
each column a feature.
* k: number of principal components to keep.
return:
* w: the eigen values of the covariance matrix sorted in from
highest to lowest.
* u: the corresponding eigen vectors. u[:,i] is the vector
corresponding to w[i]
Notes: If the number of samples is much smaller than the number
of features, you should consider the use of 'svd_pca'.
"""
cov = np.cov(data.T)
w, u = eigsh(cov, k=k, which='LA')
return w[::-1], u[:, ::-1]
def chebyshev_polynomials(adj, k):
"""Calculate Chebyshev polynomials up to order k. Return a list of sparse matrices (tuple representation)."""
print("Calculating Chebyshev polynomials up to order {}...".format(k))
adj_normalized = normalize_adj(adj)
laplacian = sp.eye(adj.shape[0]) - adj_normalized
largest_eigval, _ = eigsh(laplacian, 1, which='LM')
scaled_laplacian = (2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0])
t_k = list()
t_k.append(sp.eye(adj.shape[0]))
t_k.append(scaled_laplacian)
def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):
s_lap = sp.csr_matrix(scaled_lap, copy=True)
return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two
for i in range(2, k+1):
t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))
return sparse_to_tuple(t_k)
def _sparse_right_svd():
## for some reasons arpack does not allow computation of rank(A) eigenvectors (??) #
AA = self.data * self.data.transpose()
if self.data.shape[0] > 1:
# only compute a few eigenvectors ...
if self._k > 0 and self._k < self.data.shape[0] - 1:
k = self._k
else:
k = self.data.shape[0] - 1
if scipy.version.version == "0.9.0":
values, u_vectors = linalg.eigsh(AA, k=k)
else:
values, u_vectors = linalg.eigen_symmetric(AA, k=k)
else:
values, u_vectors = eigh(AA.todense())
# get rid of negative/too low eigenvalues
s = np.where(values > self._EPS)[0]
u_vectors = u_vectors[:, s]
values = values[s]
# sort eigenvectors according to largest value
# argsort sorts in ascending order -> access is backwards
idx = np.argsort(values)[::-1]
values = values[idx]
self.U = scipy.sparse.csc_matrix(u_vectors[:, idx])
# compute S
tmp_val = np.sqrt(values)
l = len(idx)
self.S = scipy.sparse.spdiags(tmp_val, 0, l, l, format="csc")
# and the inverse of it
S_inv = scipy.sparse.spdiags(1.0 / tmp_val, 0, l, l, format="csc")
# compute V from it
self.V = self.U.transpose() * self.data
self.V = S_inv * self.V
def extern_pca(data, k):
"""
Performs the eigen decomposition of the covariance matrix based
on the eigen decomposition of the exterior product matrix.
arguments:
* data: 2D numpy array where each row is a sample and
each column a feature.
* k: number of principal components to keep.
return:
* w: the eigen values of the covariance matrix sorted in from
highest to lowest.
* u: the corresponding eigen vectors. u[:,i] is the vector
corresponding to w[i]
Notes: This function computes PCA, based on the exterior product
matrix (C = X*X.T/(n-1)) instead of the covariance matrix
(C = X.T*X) and uses relations based of the singular
value decomposition to compute the corresponding the
final eigen vectors. While this can be much faster when
the number of samples is much smaller than the number
of features, it can lead to loss of precisions.
The (centered) data matrix X can be decomposed as:
X.T = U * S * v.T
On computes the eigen decomposition of :
X * X.T = v*S^2*v.T
and the eigen vectors of the covariance matrix are
computed as :
U = X.T * v * S^(-1)
"""
data_m = data - data.mean(0)
K = np.dot(data_m, data_m.T)
w, v = eigsh(K, k=k, which='LA')
U = np.dot(data.T, v / np.sqrt(w))
return w[::-1] / (len(data) - 1), U[:, ::-1]
def _sparse_right_svd():
## for some reasons arpack does not allow computation of rank(A) eigenvectors (??) #
AA = self.data*self.data.transpose()
if self.data.shape[0] > 1:
# only compute a few eigenvectors ...
if self._k > 0 and self._k < self.data.shape[0]-1:
k = self._k
else:
k = self.data.shape[0]-1
values, u_vectors = linalg.eigsh(AA,k=k)
else:
values, u_vectors = eigh(AA.todense())
# get rid of negative/too low eigenvalues
s = np.where(values > self._EPS)[0]
u_vectors = u_vectors[:, s]
values = values[s]
# sort eigenvectors according to largest value
# argsort sorts in ascending order -> access is backwards
idx = np.argsort(values)[::-1]
values = values[idx]
self.U = scipy.sparse.csc_matrix(u_vectors[:,idx])
# compute S
tmp_val = np.sqrt(values)
l = len(idx)
self.S = scipy.sparse.spdiags(tmp_val, 0, l, l,format='csc')
# and the inverse of it
S_inv = scipy.sparse.spdiags(1.0/tmp_val, 0, l, l,format='csc')
# compute V from it
self.V = self.U.transpose() * self.data
self.V = S_inv * self.V
def chebyshev_polynomials(adj, k):
"""Calculate Chebyshev polynomials up to order k. Return a list of sparse matrices (tuple representation)."""
print("Calculating Chebyshev polynomials up to order {}...".format(k))
adj_normalized = normalize_adj(adj)
laplacian = sp.eye(adj.shape[0]) - adj_normalized
largest_eigval, _ = eigsh(laplacian, 1, which='LM')
#https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.linalg.eigsh.html
# sp.eye(adj.shape[0]) 单位矩阵
scaled_laplacian = (2. / largest_eigval[0]) * laplacian - sp.eye(
adj.shape[0])
t_k = list()
t_k.append(sp.eye(adj.shape[0]))
t_k.append(scaled_laplacian)
def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):
s_lap = sp.csr_matrix(scaled_lap, copy=True)
return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two
for i in range(2, k + 1):
t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))
return sparse_to_tuple(t_k)
def chebyshev_polynomials(adj, k):
"""Calculate Chebyshev polynomials up to order k. Return a list of sparse matrices (tuple representation).
Detail: scaled laplacian = 2 / \lambda_1 * (I - D^(-1/2)AD^(-1/2)) - I"""
print("Calculating Chebyshev polynomials up to order {}...".format(k))
adj_normalized = normalize_adj(adj)
laplacian = sp.eye(adj.shape[0]) - adj_normalized
largest_eigval, _ = eigsh(laplacian, 1, which='LM')
scaled_laplacian = (2. / largest_eigval[0]) * laplacian - sp.eye(
adj.shape[0])
t_k = list()
t_k.append(sp.eye(adj.shape[0]))
t_k.append(scaled_laplacian)
def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):
"""Detail: Chebyshev recurrence: T_n = 2 * x * T_{n-1} - T_{n-2}"""
s_lap = sp.csr_matrix(scaled_lap, copy=True)
return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two
for i in range(2, k + 1):
t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))
return sparse_to_tuple(t_k)
def chebyshev_polynomials(adj, k,st=False):
"""Calculate Chebyshev polynomials up to order k. Return a list of sparse matrices (tuple representation)."""
#print("Calculating Chebyshev polynomials up to order {}...".format(k))
adj_normalized = normalize_adj(adj)
laplacian = sp.eye(adj.shape[0]) - adj_normalized
largest_eigval, _ = eigsh(laplacian, 1, which='LM')
scaled_laplacian = (2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0])
t_k = list()
t_k.append(sp.eye(adj.shape[0]))
t_k.append(scaled_laplacian)
def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):
s_lap = sp.csr_matrix(scaled_lap, copy=True)
return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two
for i in range(2, k+1):
t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))
if st==False:
return sparse_to_tuple(t_k)
else:
return t_k
def get_E_Ising_exact(g, h, J, L):
H = get_H_Ising(g, h, J, L)
e = arp.eigsh(H,k=1,which='SA',return_eigenvectors=False)
return(e)
def generate_graph_features(glycan, libr=None):
"""compute graph features of glycan\n
| Arguments:
| :-
| glycan (string): glycan in IUPAC-condensed format
| libr (list): library of monosaccharides; if you have one use it, otherwise a comprehensive lib will be used\n
| Returns:
| :-
| Returns a pandas dataframe with different graph features as columns and glycan as row
"""
if libr is None:
libr = lib
g = glycan_to_nxGraph(glycan, libr=libr)
#nbr of different node features:
nbr_node_types = len(set(nx.get_node_attributes(g, "labels")))
#adjacency matrix:
A = nx.to_numpy_matrix(g)
N = A.shape[0]
diameter = nx.algorithms.distance_measures.diameter(g)
deg = np.array([np.sum(A[i, :]) for i in range(N)])
dens = np.sum(deg) / 2
avgDeg = np.mean(deg)
varDeg = np.var(deg)
maxDeg = np.max(deg)
nbrDeg4 = np.sum(deg > 3)
branching = np.sum(deg > 2)
nbrLeaves = np.sum(deg == 1)
deg_to_leaves = np.array([np.sum(A[:, deg == 1]) for i in range(N)])
max_deg_leaves = np.max(deg_to_leaves)
mean_deg_leaves = np.mean(deg_to_leaves)
deg_assort = nx.degree_assortativity_coefficient(g)
betweeness_centr = np.array(
pd.DataFrame(nx.betweenness_centrality(g), index=[0]).iloc[0, :])
betweeness = np.mean(betweeness_centr)
betwVar = np.var(betweeness_centr)
betwMax = np.max(betweeness_centr)
betwMin = np.min(betweeness_centr)
eigen = np.array(
pd.DataFrame(nx.katz_centrality_numpy(g), index=[0]).iloc[0, :])
eigenMax = np.max(eigen)
eigenMin = np.min(eigen)
eigenAvg = np.mean(eigen)
eigenVar = np.var(eigen)
close = np.array(
pd.DataFrame(nx.closeness_centrality(g), index=[0]).iloc[0, :])
closeMax = np.max(close)
closeMin = np.min(close)
closeAvg = np.mean(close)
closeVar = np.var(close)
flow = np.array(
pd.DataFrame(nx.current_flow_betweenness_centrality(g),
index=[0]).iloc[0, :])
flowMax = np.max(flow)
flowMin = np.min(flow)
flowAvg = np.mean(flow)
flowVar = np.var(flow)
flow_edge = np.array(
pd.DataFrame(nx.edge_current_flow_betweenness_centrality(g),
index=[0]).iloc[0, :])
flow_edgeMax = np.max(flow_edge)
flow_edgeMin = np.min(flow_edge)
flow_edgeAvg = np.mean(flow_edge)
flow_edgeVar = np.var(flow_edge)
load = np.array(pd.DataFrame(nx.load_centrality(g), index=[0]).iloc[0, :])
loadMax = np.max(load)
loadMin = np.min(load)
loadAvg = np.mean(load)
loadVar = np.var(load)
harm = np.array(
pd.DataFrame(nx.harmonic_centrality(g), index=[0]).iloc[0, :])
harmMax = np.max(harm)
harmMin = np.min(harm)
harmAvg = np.mean(harm)
harmVar = np.var(harm)
secorder = np.array(
pd.DataFrame(nx.second_order_centrality(g), index=[0]).iloc[0, :])
secorderMax = np.max(secorder)
secorderMin = np.min(secorder)
secorderAvg = np.mean(secorder)
secorderVar = np.var(secorder)
x = np.array([len(nx.k_corona(g, k).nodes()) for k in range(N)])
size_corona = x[x > 0][-1]
k_corona = np.where(x == x[x > 0][-1])[0][-1]
x = np.array([len(nx.k_core(g, k).nodes()) for k in range(N)])
size_core = x[x > 0][-1]
k_core = np.where(x == x[x > 0][-1])[0][-1]
M = ((A + np.diag(np.ones(N))).T / (deg + 1)).T
eigval, vec = eigsh(M, 2, which='LM')
egap = 1 - eigval[0]
distr = np.abs(vec[:, -1])
distr = distr / sum(distr)
entropyStation = np.sum(distr * np.log(distr))
features = np.array([
diameter, branching, nbrLeaves, avgDeg, varDeg, maxDeg, nbrDeg4,
max_deg_leaves, mean_deg_leaves, deg_assort, betweeness, betwVar,
betwMax, eigenMax, eigenMin, eigenAvg, eigenVar, closeMax, closeMin,
closeAvg, closeVar, flowMax, flowAvg, flowVar, flow_edgeMax,
flow_edgeMin, flow_edgeAvg, flow_edgeVar, loadMax, loadAvg, loadVar,
harmMax, harmMin, harmAvg, harmVar, secorderMax, secorderMin,
secorderAvg, secorderVar, size_corona, size_core, nbr_node_types, egap,
entropyStation, N, dens
])
col_names = [
'diameter', 'branching', 'nbrLeaves', 'avgDeg', 'varDeg', 'maxDeg',
'nbrDeg4', 'max_deg_leaves', 'mean_deg_leaves', 'deg_assort',
'betweeness', 'betwVar', 'betwMax', 'eigenMax', 'eigenMin', 'eigenAvg',
'eigenVar', 'closeMax', 'closeMin', 'closeAvg', 'closeVar', 'flowMax',
'flowAvg', 'flowVar', 'flow_edgeMax', 'flow_edgeMin', 'flow_edgeAvg',
'flow_edgeVar', 'loadMax', 'loadAvg', 'loadVar', 'harmMax', 'harmMin',
'harmAvg', 'harmVar', 'secorderMax', 'secorderMin', 'secorderAvg',
'secorderVar', 'size_corona', 'size_core', 'nbr_node_types', 'egap',
'entropyStation', 'N', 'dens'
]
feat_dic = {col_names[k]: features[k] for k in range(len(features))}
return pd.DataFrame(feat_dic, index=[glycan])
def get_E_XXZ_exact(g,J,L):
H = get_H_XXZ(g, J, L)
e = arp.eigsh(H,k=1,which='SA',return_eigenvectors=False)
return(e)
def rmsd(n: int, coord1: np.ndarray,
coord2: np.ndarray) -> Tuple[float, np.ndarray]:
"""Calculate the least square rmsd in Angstrom for two
coordinate sets coord1(n,3) and coord2(n,3) using a method based on
quaternions."""
from kallisto.units import Bohr
# copy original coordinates
x = np.zeros(shape=(n, 3), dtype=np.float64)
y = np.zeros(shape=(n, 3), dtype=np.float64)
x[0:n, :] = coord1[0:n, :]
y[0:n, :] = coord2[0:n, :]
# calculate the barycenters, centroidal coordinates, and the norms
x_norm = 0.0
y_norm = 0.0
x_center = np.zeros(shape=(3, ), dtype=np.float64)
y_center = np.zeros(shape=(3, ), dtype=np.float64)
xi = np.zeros(shape=(n, ), dtype=np.float64)
yi = np.zeros(shape=(n, ), dtype=np.float64)
for i in range(3):
for j in range(n):
xi[j] = x[j, i] * Bohr
yi[j] = y[j, i] * Bohr
x_center[i] = np.sum(xi) / float(n)
y_center[i] = np.sum(yi) / float(n)
xi[:] = xi[:] - x_center[i]
yi[:] = yi[:] - y_center[i]
x[:, i] = xi[:]
y[:, i] = yi[:]
x_norm += np.dot(xi, xi)
y_norm += np.dot(yi, yi)
# calculate the R matrix
rmat = np.zeros(shape=(3, 3), dtype=np.float64)
for i in range(3):
for j in range(3):
rmat[i, j] = np.dot(x[:, i], y[:, j])
# calculate the S matrix (quaternions)
# use fac = -1 instead of u.T below
fac = -1
smat = np.zeros(shape=(4, 4), dtype=np.float64)
smat[0, 0] = rmat[0, 0] + rmat[1, 1] + rmat[2, 2]
smat[1, 0] = fac * (rmat[1, 2] - rmat[2, 1])
smat[2, 0] = fac * (rmat[2, 0] - rmat[0, 2])
smat[3, 0] = fac * (rmat[0, 1] - rmat[1, 0])
smat[0, 1] = smat[1, 0]
smat[1, 1] = rmat[0, 0] - rmat[1, 1] - rmat[2, 2]
smat[2, 1] = rmat[0, 1] + rmat[1, 0]
smat[3, 1] = rmat[0, 2] + rmat[2, 0]
smat[0, 2] = smat[2, 0]
smat[1, 2] = smat[2, 1]
smat[2, 2] = -rmat[0, 0] + rmat[1, 1] - rmat[2, 2]
smat[3, 2] = rmat[1, 2] + rmat[2, 1]
smat[0, 3] = smat[3, 0]
smat[1, 3] = smat[3, 1]
smat[2, 3] = smat[3, 2]
smat[3, 3] = -rmat[0, 0] - rmat[1, 1] + rmat[2, 2]
# calculate largest eigenvalue and eigenvector
eigenval, eigenvec = eigsh(smat, 1, which="LA")
eigenvec = eigenvec.squeeze()
# convert quaternion eigenvec to rotation matrix U
u = rotationMatrix(eigenvec)
# root mean squared deviation
error = np.sqrt(
np.maximum(
0.0,
((x_norm + y_norm) - 2 * eigenval) / float(n),
))
return error, u
saver.restore(sess, args.resume)
print("Model restored.")
# writer
writer = tf.summary.FileWriter(make_dir(args.logdir), sess.graph)
# training and eval
for epoch in range(args.maxiter):
data_tuple = (train_set.X, train_set.Y)
noise = np.zeros(model.n_weights)
if epoch % args.frequence == 0:
# eval matrix
covariance, _ = eval_Cov(sess, one_loader(), model)
l2norm_cov = np.linalg.norm(covariance, ord='fro')
trnorm_cov = np.sqrt(covariance.trace())
ecov, vcov = eigsh(covariance, args.lead, which='LM')
summary = sess.run(matrix_summary_merged,
feed_dict={
_l2norm_cov: l2norm_cov,
_trnorm_cov: trnorm_cov,
_ecov: ecov
})
writer.add_summary(summary, epoch)
noise = np.matmul(vcov,
np.random.normal(0, np.sqrt(np.abs(ecov))))
# training step
loss, acc = train(sess, [data_tuple], model, args.lr,
args.keep_prob, noise)
summary = sess.run(train_summary_merged,
feed_dict={
def lmax(L, normalized=True):
"""Upper-bound on the spectrum."""
if normalized:
return 2
else:
return eigsh(L, k=1, which='LM', return_eigenvectors=False)[0]
writer = tf.summary.FileWriter(make_dir(args.logdir), sess.graph)
# training and eval
for epoch in range(args.maxiter):
data_tuple = (train_set.X, train_set.Y)
# update matrix every ** iters
if epoch % args.frequence == 0:
# eval matrix
hessian = eval_Hess(sess, [data_tuple], model)
covariance, grad_mean = eval_Cov(sess, one_loader(), model)
l2norm_hess = np.linalg.norm(hessian, ord='fro')
l2norm_cov = np.linalg.norm(covariance, ord='fro')
trnorm_hess = np.sqrt(hessian.trace())
trnorm_cov = np.sqrt(covariance.trace())
hessian/=l2norm_hess; covariance/=l2norm_cov
ehess, vhess = eigsh(hessian, args.lead, which='LM')
ecov, vcov = eigsh(covariance, args.lead, which='LM')
summary = sess.run(matrix_summary_merged, feed_dict={
_grad: grad_mean,
_l2norm_hess: l2norm_hess,
_l2norm_cov: l2norm_cov,
_trnorm_hess: trnorm_hess,
_trnorm_cov: trnorm_cov,
_ehess: ehess,
_ecov: ecov,
_vhess: vhess,
_vcov: vcov})
writer.add_summary(summary, epoch)
ehessBar = ehess / np.sum(ehess) * np.square(trnorm_cov)
noise = np.matmul(vhess, np.random.normal(0, np.sqrt(np.abs(ehessBar))))
def eigs_np(indices, values, dense_shape):
A_sp = sp.coo_matrix((values, indices.T), shape=dense_shape)
return eigsh(A_sp, n, which="LM")[0]
def maxeig_normalize(mx):
"""Normalize sparse matrix"""
maxeig = eigsh(mx, 1, which='LA')[0][0]
mx /= maxeig
return mx
def buildbasis(self):
self.A = np.load(
'/home/hyf/MobileTrafficPrediction/src/models/kegra/wight_matrix_lb_weekly_4070_2.npy'
)
#self.A = np.load('/home/hyf/MobileTrafficPrediction/src/models/kegra/wight_matrix_lb_weekly_4070.npy')
if self.filter == 'localpool':
print('using local...')
#self.A = normalize_adj(self.A)
adj = sp.coo_matrix(self.A)
print('building diags..')
d = sp.diags(np.power(np.array(adj.sum(1)), -0.5).flatten(), 0)
print('normalizing..')
a_norm = adj.dot(d).transpose().dot(d)
print('csr to array..')
self.A = a_norm.toarray()
#discard far neighbor(those with larger weight)
#self.A[np.where(self.A < 0.9)] = 0
#self.A = np.load('wight_matrix_lb_weekly_4070.npy')
self.A = tf.convert_to_tensor(self.A, dtype='float32')
self.basis.append(self.A)
elif self.filter == 'chebyshev':
print('using chebyshev...')
#L = normalized_laplacian(self.A)
adj = sp.coo_matrix(self.A)
d = sp.diags(np.power(np.array(adj.sum(1)), -0.5).flatten(), 0)
a_norm = adj.dot(d).transpose().dot(d)
laplacian = sp.eye(adj.shape[0]) - a_norm
#L_scaled = rescale_laplacian(L)
try:
print(
'calculating largest eigenvalue of normalized graph laplacian...'
)
largest_eigval = eigsh(laplacian,
1,
which='LM',
return_eigenvectors=False)[0]
except ArpackNoConvergence:
print(
'Eigenvalue calculation did not converge! Using largest_eigval = 2 instead.'
)
largest_eigval = 2
X = (2. / largest_eigval) * laplacian - sp.eye(
laplacian.shape[0]) #L_SCALED
#T_k = chebyshev_polynomial(L_scaled, MAX_DEGREE)
print('calculating chebyshev polynomials up to order {}...'.format(
MAX_DEGREE))
T_k = list()
T_k.append(sp.eye(X.shape[0]).tocsr())
T_k.append(X)
def chebyshev_recurrence(T_k_1, T_k_2, X):
X_ = sp.csr_matrix(X, copy=True)
return 2 * X_.dot(T_k_1) - T_k_2
for i in range(2, MAX_DEGREE + 1):
T_k.append(chebyshev_recurrence(T_k[-1], T_k[-2], X))
self.support = MAX_DEGREE + 1
self.basis = [
tf.convert_to_tensor(i.toarray(), dtype='float32') for i in T_k
]
def bregman_func(A_in,
En_in,
method=5,
mu=0.001,
lbd=3.,
maxIter=100,
tol=1E-4):
# Open the A matrix file
if isinstance(A_in, str):
A = scipy.io.mmread(A_in).astype(np.double)
else:
A = A_in
Nstruc, Ncorr = A.shape
if isinstance(En_in, str):
En = np.loadtxt(En_in).astype(np.double)
else:
En = En_in
# print(A, En, En.shape)
assert Nstruc == En.shape[0]
ecis = np.zeros(Ncorr)
if method <= 2:
# FPC requires that max eigenvector of A.A^T <=1
rescale_factor = eigsh(A.dot(A.T),
3,
which='LM',
return_eigenvectors=False)[-1]
rescale_factor = np.sqrt(rescale_factor)
A = A / rescale_factor
En = En / rescale_factor
tau = min(1.999, -1.665 * float(Nstruc) / float(Ncorr) + 2.665)
# print("FPC step size tau =", tau)
# print("method=", method)
# print("mu=", mu)
# print("lambda=", lbd)
# Values in Fortan are passed by reference, so we need to convert the types
# and then pass by reference
if (method in (1, 3, 5)) and scipy.sparse.issparse(A):
A = A.todense()
# Now scale the mu parameter by Nstruc for convenience
mu2 = mu * Nstruc
if method == 1:
ecis = bregman.bregmanfpc(maxIter, tol, tau, mu, A, En)
elif method == 2:
ecis = bregman.sparsebregmanfpc(maxIter, tol, tau, mu, A, En)
elif method == 3:
ecis = bregman.splitbregman(maxIter, tol, tau, mu, A, En)
elif method == 4:
ecis = bregman.sparsesplitbregman(maxIter, tol, tau, 1 / mu, A, En)
elif method == 5:
# right preconditioning
ecis = bregman.bregmanrprecond(maxIter, A, En, 1 / mu, lbd, tol)
elif method == 6:
# sparse right preconditioning
print(" WARNING: DO NOT USE; NOT IMPLEMENTED YET")
ecis = bregman.sparsebregmanrprecond(A, En, 1 / mu, lbd)
else:
raise ValueError("Unknown bregman method %d", method)
return ecis
def ED_2D(n,m,h): J = 1 row = np.array(range(2**(n*m))) l = [bin(x)[2:].rjust(n*m, '0') for x in range(2**(n*m))] b = np.array([np.array(map(int, i)) for i in l]) d = np.array([np.array(map(int, i)) for i in l]) onlyone1 = [] for i in range((n*m)): onlyone1.append(b[2**i]) onlyone1 = np.asarray(onlyone1) ########################################################### '''Sort Tags''' T = [] for i in range(2**(n*m)): T.append(calculateTag(b[i])) Tsorted = np.asarray(qsort(T)) #for i in range(len(T)): # print T[i], Tsorted[i] Tindex = sorted(range(len(T)), key=lambda k: T[k]) #print Tindex #print Tindex[4] #print sorted(range(len(Tsorted)), key=lambda k: Tsorted[k]) ########################################################### data = [] data1 = [] data2 = [] data3 = [] rowcol = [] abc1 = np.zeros(((n*m)-1), dtype=np.double) abc2 = np.zeros(((n*m)-1), dtype=np.double) v = [] f = [] off_row = [] off_col = [] off_data = [] for i in range(2**(n*m)): '''Diagonal''' '''horizontal bonds''' v1 = 0 v2 = 0 for j in range(n): for k in range(m-1): if b[i,k+j*m] == b[i,k+1+j*m]: v1 +=1 else: v1 -=1 data1.append(-J*v1) '''vertical bonds''' for j in range((n-1)*m): if b[i,j] == b[i,j+m]: v2 += 1 else: v2 -= 1 data2.append(-J*v2) '''Off Diagonal''' for j in range(n*m): off_col.append(Tindex[binary_search(Tsorted,calculateTag(np.bitwise_xor(d[i],onlyone1[j])))]) #print d[i], onlyone1[j], np.bitwise_xor(d[i],onlyone1[j]), 'index:', Tindex[binary_search(Tsorted,calculateTag(np.bitwise_xor(d[i],onlyone1[j])))] off_row.append(i) off_data.append(-h) for i in range(len(data1)): data3.append(data1[i] + data2[i]) for i in range(len(data3)): if data3[i] != 0: data.append(data3[i]) rowcol.append(i) Diagonal = sparse.csr_matrix((data,(rowcol,rowcol)), dtype=np.double).toarray() Off_Diagonal = sparse.csr_matrix((off_data, (off_row,off_col)), dtype=np.double).toarray() ########################################################## '''Diagonalize Full Hamiltonian''' #print Off_Diagonal Ham = Diagonal + Off_Diagonal #print Ham vals, vecs = arp.eigsh(Ham, k=1, which='SA') return vals[0],vecs
D[i][i] = g.vs.degree()[i]
D_I = np.zeros((g.vcount(), g.vcount()))
for i in range(0, g.vcount()):
if g.vs.degree()[i] == 1:
D_I[i][i] = 0
else:
D_I[i][i] = 1.0 / (g.vs.degree()[i] - 1)
D_ = np.zeros((g.vcount(), g.vcount()))
for i in range(0, g.vcount()):
if g.vs.degree()[i] == 0:
D_[i][i] = 0
else:
D_[i][i] = 1.0 / (g.vs.degree()[i])
I = np.identity(g.vcount())
Z = np.zeros((g.vcount(), g.vcount()))
M = np.bmat([[0.5 * np.dot(np.dot(A, D_I), np.subtract(I, D_)), 0.5 * I],
[0.5 * I, 0.5 * np.dot(np.dot(A, D_I), np.subtract(I, D_))]])
#eigva, eigvec = tf.self_adjoint_eig(M)
#eigva, eigvec = np.linalg.eig(M)
#eigva, eigvec = eigh(M, eigvals=(size(M,1)-100,size(M,1)-1))
with tf.Session() as sess:
#The eigsh function with 'LA' return largest eigs but in ascenting order!!!
eigva_result, eigvec_result = eigsh(M, 100, which='LA')
#eigva_result, eigvec_result = sess.run([eigva,eigvec])
print eigva_result
np.savetxt(outfile, eigvec_result[:g.vcount(), 0:100][:, ::-1])
