本文整理汇总了Python中sandbox.util.Parameter.Parameter.checkSymmetric方法的典型用法代码示例。如果您正苦于以下问题：Python Parameter.checkSymmetric方法的具体用法？Python Parameter.checkSymmetric怎么用？Python Parameter.checkSymmetric使用的例子？那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类sandbox.util.Parameter.Parameter的用法示例。
在下文中一共展示了Parameter.checkSymmetric方法的2个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: eigenAdd2
# 需要导入模块: from sandbox.util.Parameter import Parameter [as 别名]
# 或者: from sandbox.util.Parameter.Parameter import checkSymmetric [as 别名]
#.........这里部分代码省略.........
#Get first k eigenvectors/values of A^*A
omega, Q = Util.indEig(omega, Q, numpy.flipud(numpy.argsort(omega))[0:k])
QY1 = Q.conj().T.dot(Y1)
Y1bar = Y1 - Q.dot(QY1)
P1bar, sigma1Bar, Q1bar = Util.safeSvd(Y1bar)
inds = numpy.arange(sigma1Bar.shape[0])[numpy.abs(sigma1Bar)>EigenUpdater.tol]
P1bar, sigma1Bar, Q1bar = Util.indSvd(P1bar, sigma1Bar, Q1bar, inds)
# checks on SVD decomposition of Y1bar
if __debug__:
Parameter.checkArray(QY1, softCheck=True, arrayInfo="QY1 in eigenAdd2()")
Parameter.checkArray(Y1bar, softCheck=True, arrayInfo="Y1bar in eigenAdd2()")
Parameter.checkArray(P1bar, softCheck=True, arrayInfo="P1bar in eigenAdd2()")
if not Parameter.checkOrthogonal(P1bar, tol=EigenUpdater.tol, softCheck=True, arrayInfo="P1bar in eigenAdd2()", investigate=True):
print ("corresponding sigma: ", sigma1Bar)
Parameter.checkArray(sigma1Bar, softCheck=True, arrayInfo="sigma1Bar in eigenAdd2()")
Parameter.checkArray(Q1bar, softCheck=True, arrayInfo="Q1bar in eigenAdd2()")
if not Parameter.checkOrthogonal(Q1bar, tol=EigenUpdater.tol, softCheck=True, arrayInfo="Q1bar in eigenAdd2()"):
print ("corresponding sigma: ", sigma1Bar)
del Y1bar
P1barY2 = P1bar.conj().T.dot(Y2)
QY2 = Q.conj().T.dot(Y2)
Y2bar = Y2 - Q.dot(QY2) - P1bar.dot(P1barY2)
P2bar, sigma2Bar, Q2bar = Util.safeSvd(Y2bar)
inds = numpy.arange(sigma2Bar.shape[0])[numpy.abs(sigma2Bar)>EigenUpdater.tol]
P2bar, sigma2Bar, Q2bar = Util.indSvd(P2bar, sigma2Bar, Q2bar, inds)
# checks on SVD decomposition of Y1bar
if __debug__:
Parameter.checkArray(P1barY2, softCheck=True, arrayInfo="P1barY2 in eigenAdd2()")
Parameter.checkArray(QY2, softCheck=True, arrayInfo="QY2 in eigenAdd2()")
Parameter.checkArray(Y2bar, softCheck=True, arrayInfo="Y2bar in eigenAdd2()")
Parameter.checkArray(P2bar, softCheck=True, arrayInfo="P2bar in eigenAdd2()")
Parameter.checkOrthogonal(P2bar, tol=EigenUpdater.tol, softCheck=True, arrayInfo="P2bar in eigenAdd2()")
Parameter.checkArray(sigma2Bar, softCheck=True, arrayInfo="sigma2Bar in eigenAdd2()")
Parameter.checkArray(Q2bar, softCheck=True, arrayInfo="Q2bar in eigenAdd2()")
Parameter.checkOrthogonal(Q2bar, tol=EigenUpdater.tol, softCheck=True, arrayInfo="Q2bar in eigenAdd2()")
del Y2bar
r = omega.shape[0]
p = Y1.shape[1]
p1 = sigma1Bar.shape[0]
p2 = sigma2Bar.shape[0]
D = numpy.c_[Q, P1bar, P2bar]
del P1bar
del P2bar
# rem: A*s = A.dot(diag(s)) ; A*s[:,new] = diag(s).dot(A)
DStarY1 = numpy.r_[QY1, sigma1Bar[:,numpy.newaxis] * Q1bar.conj().T, numpy.zeros((p2, p))]
DStarY2 = numpy.r_[QY2, P1barY2, sigma2Bar[:,numpy.newaxis] * Q2bar.conj().T]
DStarY1Y2StarD = DStarY1.dot(DStarY2.conj().T)
del DStarY1
del DStarY2
r = omega.shape[0]
F = numpy.zeros((r+p1+p2, r+p1+p2))
F[range(r),range(r)] = omega
F = F + DStarY1Y2StarD + DStarY1Y2StarD.conj().T
#A check to make sure DFD^T is AA_k + Y1Y2 + Y2Y1
#assert numpy.linalg.norm(D.dot(F).dot(D.T) - Q.dot(numpy.diag(omega).dot(Q.T)) - Y1.dot(Y2.T) - Y2.dot(Y1.T)) < 10**-6
# checks on F
if __debug__:
#Parameter.checkArray(DStarY1, softCheck=True, arrayInfo="DStarY1 in eigenAdd2()")
#Parameter.checkArray(DStarY2, softCheck=True, arrayInfo="DStarY2 in eigenAdd2()")
Parameter.checkArray(DStarY1Y2StarD, softCheck=True, arrayInfo="DStarY1Y2StarD in eigenAdd2()")
Parameter.checkArray(F, softCheck=True, arrayInfo="F in eigenAdd2()")
Parameter.checkSymmetric(F, tol=EigenUpdater.tol, softCheck=True, arrayInfo="F in eigenAdd2()")
pi, H = scipy.linalg.eigh(F)
# remove too small eigenvalues
pi, H = Util.indEig(pi, H, numpy.arange(pi.shape[0])[numpy.abs(pi)>EigenUpdater.tol])
# keep greatest eigenvalues
#pi, H = Util.indEig(pi, H, numpy.flipud(numpy.argsort(pi))[:min(k,pi.shape[0])])
V = D.dot(H)
if __debug__:
if not Parameter.checkOrthogonal(D, tol=EigenUpdater.tol, softCheck=True, investigate=True, arrayInfo="D in eigenAdd2()"):
print("pi:\n", pi)
if not Parameter.checkOrthogonal(H, tol=EigenUpdater.tol, softCheck=True, investigate=True, arrayInfo="H in eigenAdd2()"):
print("pi:\n", pi)
if ProfileUtils.memory() > 10**9:
ProfileUtils.memDisplay(locals())
#logging.debug("</ eigenAdd2 >")
if debug:
return pi, V, D, DStarY1Y2StarD + DStarY1Y2StarD.conj().T
else:
return pi, V示例2: clusterFromIterator
# 需要导入模块: from sandbox.util.Parameter import Parameter [as 别名]
# 或者: from sandbox.util.Parameter.Parameter import checkSymmetric [as 别名]
def clusterFromIterator(self, graphListIterator, verbose=False):
"""
Find a set of clusters for the graphs given by the iterator. If verbose
is true the each iteration is timed and bounded the results are returned
as lists.
The difference between a weight matrix and the previous one should be
positive.
"""
clustersList = []
decompositionTimeList = []
kMeansTimeList = []
boundList = []
sinThetaList = []
i = 0
for subW in graphListIterator:
if __debug__:
Parameter.checkSymmetric(subW)
if self.logStep and i % self.logStep == 0:
logging.debug("Graph index: " + str(i))
logging.debug("Clustering graph of size " + str(subW.shape))
if self.alg!="efficientNystrom":
ABBA = GraphUtils.shiftLaplacian(subW)
# --- Eigen value decomposition ---
startTime = time.time()
if self.alg=="IASC":
if i % self.T != 0:
omega, Q = self.approxUpdateEig(subW, ABBA, omega, Q)
if self.computeBound:
inds = numpy.flipud(numpy.argsort(omega))
Q = Q[:, inds]
omega = omega[inds]
bounds = self.pertBound(omega, Q, omegaKbot, AKbot, self.k2)
#boundList.append([i, bounds[0], bounds[1]])
#Now use accurate values of norm of R and delta
rank = Util.rank(ABBA.todense())
gamma, U = scipy.sparse.linalg.eigsh(ABBA, rank-1, which="LM", ncv = ABBA.shape[0])
#logging.debug("gamma=" + str(gamma))
bounds2 = self.realBound(omega, Q, gamma, AKbot, self.k2)
boundList.append([bounds[0], bounds[1], bounds2[0], bounds2[1]])
else:
logging.debug("Computing exact eigenvectors")
self.storeInformation(subW, ABBA)
if self.computeBound:
#omega, Q = scipy.sparse.linalg.eigsh(ABBA, min(self.k2*2, ABBA.shape[0]-1), which="LM", ncv = min(10*self.k2, ABBA.shape[0]))
rank = Util.rank(ABBA.todense())
omega, Q = scipy.sparse.linalg.eigsh(ABBA, rank-1, which="LM", ncv = ABBA.shape[0])
inds = numpy.flipud(numpy.argsort(omega))
omegaKbot = omega[inds[self.k2:]]
QKbot = Q[:, inds[self.k2:]]
AKbot = (QKbot*omegaKbot).dot(QKbot.T)
omegaSort = numpy.flipud(numpy.sort(omega))
boundList.append([0]*4)
else:
omega, Q = scipy.sparse.linalg.eigsh(ABBA, min(self.k2, ABBA.shape[0]-1), which="LM", ncv = min(10*self.k2, ABBA.shape[0]))
elif self.alg == "nystrom":
omega, Q = Nystrom.eigpsd(ABBA, self.k3)
elif self.alg == "exact":
omega, Q = scipy.sparse.linalg.eigsh(ABBA, min(self.k1, ABBA.shape[0]-1), which="LM", ncv = min(15*self.k1, ABBA.shape[0]))
elif self.alg == "efficientNystrom":
omega, Q = EfficientNystrom.eigWeight(subW, self.k2, self.k1)
elif self.alg == "randomisedSvd":
Q, omega, R = RandomisedSVD.svd(ABBA, self.k4)
else:
raise ValueError("Invalid Algorithm: " + str(self.alg))
if self.computeSinTheta:
omegaExact, QExact = scipy.linalg.eigh(ABBA.todense())
inds = numpy.flipud(numpy.argsort(omegaExact))
QExactKbot = QExact[:, inds[self.k1:]]
inds = numpy.flipud(numpy.argsort(omega))
QApproxK = Q[:,inds[:self.k1]]
sinThetaList.append(scipy.linalg.norm(QExactKbot.T.dot(QApproxK)))
decompositionTimeList.append(time.time()-startTime)
if self.alg=="IASC":
self.storeInformation(subW, ABBA)
# --- Kmeans ---
startTime = time.time()
inds = numpy.flipud(numpy.argsort(omega))
standardiser = Standardiser()
#For some very strange reason we get an overflow when computing the
#norm of the rows of Q even though its elements are bounded by 1.
#We'll ignore it for now
try:
V = standardiser.normaliseArray(Q[:, inds[0:self.k1]].real.T).T
except FloatingPointError as e:
logging.warn("FloatingPointError: " + str(e))
V = VqUtils.whiten(V)
#.........这里部分代码省略.........