def test_check_symmetric():
arr_sym = np.array([[0, 1], [1, 2]])
arr_bad = np.ones(2)
arr_asym = np.array([[0, 2], [0, 2]])
test_arrays = {'dense': arr_asym,
'dok': sp.dok_matrix(arr_asym),
'csr': sp.csr_matrix(arr_asym),
'csc': sp.csc_matrix(arr_asym),
'coo': sp.coo_matrix(arr_asym),
'lil': sp.lil_matrix(arr_asym),
'bsr': sp.bsr_matrix(arr_asym)}
# check error for bad inputs
assert_raises(ValueError, check_symmetric, arr_bad)
# check that asymmetric arrays are properly symmetrized
for arr_format, arr in test_arrays.items():
# Check for warnings and errors
assert_warns(UserWarning, check_symmetric, arr)
assert_raises(ValueError, check_symmetric, arr, raise_exception=True)
output = check_symmetric(arr, raise_warning=False)
if sp.issparse(output):
assert_equal(output.format, arr_format)
assert_array_equal(output.toarray(), arr_sym)
else:
assert_array_equal(output, arr_sym)
def test_check_symmetric():
arr_sym = np.array([[0, 1], [1, 2]])
arr_bad = np.ones(2)
arr_asym = np.array([[0, 2], [0, 2]])
test_arrays = {
'dense': arr_asym,
'dok': sp.dok_matrix(arr_asym),
'csr': sp.csr_matrix(arr_asym),
'csc': sp.csc_matrix(arr_asym),
'coo': sp.coo_matrix(arr_asym),
'lil': sp.lil_matrix(arr_asym),
'bsr': sp.bsr_matrix(arr_asym)
}
# check error for bad inputs
with pytest.raises(ValueError):
check_symmetric(arr_bad)
# check that asymmetric arrays are properly symmetrized
for arr_format, arr in test_arrays.items():
# Check for warnings and errors
with pytest.warns(UserWarning):
check_symmetric(arr)
with pytest.raises(ValueError):
check_symmetric(arr, raise_exception=True)
output = check_symmetric(arr, raise_warning=False)
if sp.issparse(output):
assert output.format == arr_format
assert_array_equal(output.toarray(), arr_sym)
else:
assert_array_equal(output, arr_sym)
def spectral_embedding(adjacency, norm_laplacian=True):
adjacency = check_symmetric(adjacency)
n_nodes = adjacency.shape[0]
laplacian, dd = csgraph_laplacian(adjacency,
normed=norm_laplacian,
return_diag=True)
return np.linalg.pinv(laplacian.todense())
def _spectral_clustering(self):
affinity_matrix_ = check_symmetric(self.affinity_matrix_)
random_state = check_random_state(self.random_state)
laplacian = sparse.csgraph.laplacian(affinity_matrix_, normed=True)
_, vec = sparse.linalg.eigsh(sparse.identity(laplacian.shape[0]) - laplacian,
k=self.n_clusters, sigma=None, which='LA')
embedding = normalize(vec)
_, self.labels_, _ = cluster.k_means(embedding, self.n_clusters,
random_state=random_state, n_init=self.n_init)
def spectral_clustering(affinity, n_clusters, norm_laplacian=True, random_state=None, n_init=20):
"""Spectral clustering.
This is a simplified version of spectral_clustering in sklearn.
"""
affinity = check_symmetric(affinity)
random_state = check_random_state(random_state)
laplacian = sparse.csgraph.laplacian(affinity, normed=norm_laplacian)
_, vec = sparse.linalg.eigsh(sparse.identity(laplacian.shape[0]) - laplacian, k=n_clusters, sigma=None, which='LA')
embedding = normalize(vec)
_, labels, _ = cluster.k_means(embedding, n_clusters, random_state=random_state, n_init=n_init)
return labels
def mds_3d_view(dissimilarities, metric=True, n_components=2, init=None,
max_iter=300, verbose=0, eps=1e-3, random_state=None):
dissimilarities = check_symmetric(dissimilarities, raise_exception=True)
n_samples = dissimilarities.shape[0]
random_state = check_random_state(random_state)
sim_flat = ((1 - np.tri(n_samples)) * dissimilarities).ravel()
sim_flat_w = sim_flat[sim_flat != 0]
if init is None:
# Randomly choose initial configuration
X = random_state.rand(n_samples * n_components)
X = X.reshape((n_samples, n_components))
else:
# overrides the parameter p
n_components = init.shape[1]
if n_samples != init.shape[0]:
raise ValueError("init matrix should be of shape (%d, %d)" %
(n_samples, n_components))
X = init
old_stress = None
ir = IsotonicRegression()
for it in range(max_iter):
# Compute distance and monotonic regression
dis = euclidean_distances(X)
disparities = dissimilarities
# Compute stress
stress = ((dis.ravel() - disparities.ravel()) ** 2).sum() / 2
# Update X using the Guttman transform
dis[dis == 0] = 1e-5
ratio = disparities / dis
B = - ratio
B[np.arange(len(B)), np.arange(len(B))] += ratio.sum(axis=1)
X = 1. / n_samples * np.dot(B, X)
dis = np.sqrt((X ** 2).sum(axis=1)).sum()
if verbose >= 2:
print('it: %d, stress %s' % (it, stress))
if old_stress is not None:
if(old_stress - stress / dis) < eps:
if verbose:
print('breaking at iteration %d with stress %s' % (it,
stress))
break
old_stress = stress / dis
return X, stress, it + 1
def spectral_clustering(affinity_matrix_, n_clusters, k, seed=1, n_init=20):
affinity_matrix_ = check_symmetric(affinity_matrix_)
random_state = check_random_state(seed)
laplacian = sparse.csgraph.laplacian(affinity_matrix_, normed=True)
_, vec = sparse.linalg.eigsh(sparse.identity(laplacian.shape[0]) -
laplacian,
k=k,
sigma=None,
which='LA')
embedding = normalize(vec)
_, labels_, _ = cluster.k_means(embedding,
n_clusters,
random_state=seed,
n_init=n_init)
return labels_
def similarity_matrix(G, sim=None, par=None, symmetric=True):
if sim == None:
raise ValueError('Specify similarity measure!')
if par == None:
raise ValueError('Specify parameter(s) of similarity measure!')
n = G.number_of_nodes()
pos = nx.get_node_attributes(G, 'pos')
pos = np.reshape([pos[i] for i in range(n)], (n, len(pos[0])))
if sim == 'euclidean' or sim == 'minkowski':
A = squareform(pdist(pos, sim))
elif sim == 'knn':
A = skn.kneighbors_graph(pos,
par,
mode='connectivity',
metric='minkowski',
p=2,
metric_params=None,
n_jobs=-1)
A = A.todense()
elif sim == 'radius':
A = skn.radius_neighbors_graph(pos,
par,
mode='connectivity',
metric='minkowski',
p=2,
metric_params=None,
n_jobs=-1)
A = A.todense()
elif sim == 'rbf':
gamma_ = par
A = rbf_kernel(pos, gamma=gamma_)
if symmetric == True:
A = check_symmetric(A)
for i in range(n):
for j in range(n):
if np.abs(A[i, j]) > 0:
G.add_edge(i, j, weight=A[i, j])
return G
def spectral_embedding(adjacency,
n_components=8,
eigen_solver=None,
random_state=None,
eigen_tol=0.0,
norm_laplacian=True,
drop_first=True):
adjacency = check_symmetric(adjacency)
eigen_solver = 'arpack'
norm_laplacian = False
random_state = check_random_state(random_state)
n_nodes = adjacency.shape[0]
if not _graph_is_connected(adjacency):
warnings.warn("Graph is not fully connected, spectral embedding"
" may not work as expected.")
laplacian, dd = csgraph_laplacian(adjacency,
normed=norm_laplacian,
return_diag=True)
if (eigen_solver == 'arpack' or eigen_solver != 'lobpcg' and
(not sparse.isspmatrix(laplacian) or n_nodes < 5 * n_components)):
# print("[INFILE] eigen_solver : ", eigen_solver, "norm_laplacian:", norm_laplacian)
laplacian = _set_diag(laplacian, 1, norm_laplacian)
try:
laplacian *= -1
v0 = random_state.uniform(-1, 1, laplacian.shape[0])
lambdas, diffusion_map = eigsh(laplacian,
k=n_components,
sigma=1.0,
which='LM',
tol=eigen_tol,
v0=v0)
embedding = diffusion_map.T[n_components::-1]
if norm_laplacian:
embedding = embedding / dd
except RuntimeError:
eigen_solver = "lobpcg"
laplacian *= -1
embedding = _deterministic_vector_sign_flip(embedding)
return embedding[:n_components].T
def spectral_hg_partitioning(hg,
n_clusters,
assign_labels='kmeans',
n_components=None,
random_state=None,
n_init=10):
"""
:param hg: instance of HyperG
:param n_clusters: int,
:param assign_labels: str, {'kmeans', 'discretize'}, default: 'kmeans'
:param n_components: int, number of eigen vectors to use for the spectral embedding
:param random_state: int or None (default)
:param n_init: int, number of time the k-means algorithm will be run
with different centroid seeds.
:return: numpy array, shape = (n_samples,), labels of each point
"""
assert isinstance(hg, HyperG)
assert n_clusters <= hg.num_nodes()
random_state = check_random_state(random_state)
if n_components is None:
n_components = n_clusters
L = hg.laplacian().toarray()
L = check_symmetric(L)
eigenval, eigenvec = eigh(L)
embeddings = eigenvec[:, :n_components]
if assign_labels == 'kmeans':
_, labels, _ = k_means(embeddings,
n_clusters,
random_state=random_state,
n_init=n_init)
else:
labels = discretize(embeddings, random_state=random_state)
return labels
def sammon(dissimilarity_matrix, n_components,
init, l_rate, decay, base_rate,
max_iter, verbose, eps, sensitivity, random_state):
dissimilarity_matrix = check_array(dissimilarity_matrix)
dissimilarity_matrix = check_symmetric(
dissimilarity_matrix, raise_exception=True)
random_state = check_random_state(random_state)
n_samples = dissimilarity_matrix.shape[0]
if init is None:
# Randomly choose initial configuration
X = random_state.rand(n_samples * n_components)
X = X.reshape((n_samples, n_components))
X -= np.mean(X, axis=0)
X *= np.mean(dissimilarity_matrix)
else:
n_components = init.shape[1]
if n_samples != init.shape[0]:
raise ValueError("init matrix should be of shape (%d, %d)" %
(n_samples, n_components))
X = init
if hasattr(init, '__array__'):
init = np.asarray(init).copy()
pos, stress, n_iter_ = _sammon(
dissimilarity_matrix,
X,
sensitivity=sensitivity,
random_state=random_state,
max_iter=max_iter,
base_rate=base_rate,
verbose=verbose,
l_rate=l_rate,
decay=decay,
eps=eps)
return pos, stress, n_iter_
def detect_change_points(path, groundEvent, nodeImportance, alpha_pg, flag1,
flag2, s, kernel_fun):
"""Use the spectral clustering implemented in sklearn (Mode: fully connected )
(only two parameters to tune : alpha, k)
Parameters
----------
path: the path of the sequence networks
groundEvent:ground event information
nodeImportance:
alpha_pg: skip probability for pageRank
flag1: for construct the network(True : original; False : supplement )
flag2: for construct the probability distribution(True: pageRank
or leaderRank; False: normalized Rank)
s:the delay delta
kernel_fun: used for adjacency/affinity matrix computation.
Returns
----------
"""
print "step 1"
get_prvalue_sequence(path, alpha_pg, flag1, flag2)
print "Step 2"
numSnapshots = len(prScore)
numNodes = len(prScore[0])
print "there are totally %d snapshots,each snapshot has %d nodes" \
% (numSnapshots, numNodes)
temp_alpha = 0.0
temp_k = 0
temp_f = 0.0
distance_array = distance.pdist(
np.reshape(np.array(prScore), (numSnapshots, numNodes)), kernel_fun)
for alpha in range(1, 101, 1):
alpha = alpha / 100.0
func = partial(tmp, alpha)
condensed_similarity = map(func, distance_array)
adjacentM = distance.squareform(condensed_similarity)
adjacentM = check_symmetric(adjacentM)
if not _graph_is_connected(adjacentM):
print "not fully connected alpha: ", alpha
warnings.warn("Graph is not fully connected.")
graph_weighted = nx.from_numpy_matrix(adjacentM)
Lcc, p = largestConnectedComponent(adjacentM, graph_weighted)
if len(Lcc) < 1.0 * numSnapshots:
print "connected nodes: ", len(Lcc)
continue
else:
print "connected nodes: ", len(Lcc)
else:
graph_weighted = nx.from_numpy_matrix(adjacentM)
Lcc, p = largestConnectedComponent(adjacentM, graph_weighted)
print "connected nodes: ", len(Lcc)
best_k = -1
best_score = -np.inf
for index, k in enumerate((2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)):
if k >= numSnapshots:
break
try:
score = 0.0
for i in range(10):
model = SpectralClustering(n_clusters=k,
assign_labels='discretize',
affinity='precomputed',
random_state=1).fit(adjacentM)
assigments = model.labels_
smallkEigVector = spectral_embedding(np.array(adjacentM),
n_components=k,
eigen_solver=None,
random_state=None,
eigen_tol=0.0,
norm_laplacian=True,
drop_first=False)
score += metrics.silhouette_score(
np.reshape(np.array(smallkEigVector),
(numSnapshots, k)), assigments)
score = score / 10.0
if score > best_score:
best_score = score
best_k = k
except Exception, e:
print "except, ", e
model = SpectralClustering(n_clusters=best_k,
assign_labels='discretize',
affinity='precomputed',
random_state=1).fit(adjacentM)
best_assigments = model.labels_
try:
p_c = predictResult(best_assigments)
precision, recall, fvalue, fpr = Evaluation(p_c,
groundEvent,
s,
numSnapshots,
K=best_k,
alpha=alpha)
if fvalue > temp_f:
temp_f = fvalue
temp_alpha = alpha
temp_k = best_k
except:
print "no changes detected"
def _smacof_single(dissimilarities,
metric=True,
n_components=2,
init=None,
max_iter=300,
verbose=0,
eps=1e-3,
random_state=None,
history=None):
"""Computes multidimensional scaling using SMACOF algorithm
Parameters
----------
dissimilarities : ndarray, shape (n_samples, n_samples)
Pairwise dissimilarities between the points. Must be symmetric.
metric : boolean, optional, default: True
Compute metric or nonmetric SMACOF algorithm.
n_components : int, optional, default: 2
Number of dimensions in which to immerse the dissimilarities. If an
``init`` array is provided, this option is overridden and the shape of
``init`` is used to determine the dimensionality of the embedding
space.
init : ndarray, shape (n_samples, n_components), optional, default: None
Starting configuration of the embedding to initialize the algorithm. By
default, the algorithm is initialized with a randomly chosen array.
max_iter : int, optional, default: 300
Maximum number of iterations of the SMACOF algorithm for a single run.
verbose : int, optional, default: 0
Level of verbosity.
eps : float, optional, default: 1e-3
Relative tolerance with respect to stress at which to declare
convergence.
random_state : int, RandomState instance or None, optional, default: None
The generator used to initialize the centers. If int, random_state is
the seed used by the random number generator; If RandomState instance,
random_state is the random number generator; If None, the random number
generator is the RandomState instance used by `np.random`.
Returns
-------
X : ndarray, shape (n_samples, n_components)
Coordinates of the points in a ``n_components``-space.
stress : float
The final value of the stress (sum of squared distance of the
disparities and the distances for all constrained points).
n_iter : int
The number of iterations corresponding to the best stress.
"""
dissimilarities = check_symmetric(dissimilarities, raise_exception=True)
n_samples = dissimilarities.shape[0]
random_state = check_random_state(random_state)
sim_flat = ((1 - np.tri(n_samples)) * dissimilarities).ravel()
sim_flat_w = sim_flat[sim_flat != 0]
if init is None:
# Randomly choose initial configuration
X = random_state.rand(n_samples * n_components)
X = X.reshape((n_samples, n_components))
else:
# overrides the parameter p
n_components = init.shape[1]
if n_samples != init.shape[0]:
raise ValueError("init matrix should be of shape (%d, %d)" %
(n_samples, n_components))
X = init
old_stress = None
ir = IsotonicRegression()
for it in range(max_iter):
# Compute distance and monotonic regression
dis = euclidean_distances(X)
if metric:
disparities = dissimilarities
else:
dis_flat = dis.ravel()
# dissimilarities with 0 are considered as missing values
dis_flat_w = dis_flat[sim_flat != 0]
# Compute the disparities using a monotonic regression
disparities_flat = ir.fit_transform(sim_flat_w, dis_flat_w)
disparities = dis_flat.copy()
disparities[sim_flat != 0] = disparities_flat
disparities = disparities.reshape((n_samples, n_samples))
disparities *= np.sqrt(
(n_samples * (n_samples - 1) / 2) / (disparities**2).sum())
# Compute stress
stress = ((dis.ravel() - disparities.ravel())**2).sum() / 2
# Update X using the Guttman transform
dis[dis == 0] = 1e-5
ratio = disparities / dis
B = -ratio
B[np.arange(len(B)), np.arange(len(B))] += ratio.sum(axis=1)
X = 1. / n_samples * np.dot(B, X)
dis = np.sqrt((X**2).sum(axis=1)).sum()
if history is not None:
history.epoch(it, 0, stress, X)
if verbose >= 2:
print('it: %d, stress %s' % (it, stress))
if old_stress is not None:
if (old_stress - stress / dis) < eps:
if verbose:
print('breaking at iteration %d with stress %s' %
(it, stress))
break
old_stress = stress / dis
return X, stress, it + 1
def _smacof_with_anchors_single(config, similarities, metric=True, n_components=2, init=None,
max_iter=300, verbose=0, eps=1e-3, random_state=None, estimated_dist_weights=None):
"""
Computes multidimensional scaling using SMACOF algorithm
Parameters
----------
config : Config object
configuration object for anchor-tag deployment parameters
similarities: symmetric ndarray, shape [n * n]
similarities between the points
metric: boolean, optional, default: True
compute metric or nonmetric SMACOF algorithm
n_components: int, optional, default: 2
number of dimension in which to immerse the similarities
overwritten if initial array is provided.
init: {None or ndarray}, optional
if None, randomly chooses the initial configuration
if ndarray, initialize the SMACOF algorithm with this array
max_iter: int, optional, default: 300
Maximum number of iterations of the SMACOF algorithm for a single run
verbose: int, optional, default: 0
level of verbosity
eps: float, optional, default: 1e-6
relative tolerance w.r.t stress to declare converge
random_state: integer or numpy.RandomState, optional
The generator used to initialize the centers. If an integer is
given, it fixes the seed. Defaults to the global numpy random
number generator.
Returns
-------
X: ndarray (n_samples, n_components), float
coordinates of the n_samples points in a n_components-space
stress_: float
The final value of the stress (sum of squared distance of the
disparities and the distances for all constrained points)
n_iter : int
Number of iterations run
last_positions: ndarray [X1,...,Xn]
An array of computed Xs.
"""
NO_OF_TAGS, NO_OF_ANCHORS = config.no_of_tags, config.no_of_anchors
similarities = check_symmetric(similarities, raise_exception=True)
n_samples = similarities.shape[0]
random_state = check_random_state(random_state)
sim_flat = ((1 - np.tri(n_samples)) * similarities).ravel()
sim_flat_w = sim_flat[sim_flat != 0]
if init is None:
# Randomly choose initial configuration
X = random_state.rand(n_samples * n_components)
X = X.reshape((n_samples, n_components))
# uncomment the following if weight matrix W is not hollow
#X[:-2] = Xa
else:
# overrides the parameter p
n_components = init.shape[1]
if n_samples != init.shape[0]:
raise ValueError("init matrix should be of shape (%d, %d)" %
(n_samples, n_components))
X = init
old_stress = None
ir = IsotonicRegression()
# setup weight matrix
if getattr(config, 'weights', None) is not None:
weights = config.weights
else:
weights = np.ones((n_samples, n_samples))
if getattr(config, 'missingdata', None):
weights[-NO_OF_TAGS:, -NO_OF_TAGS:] = 0
if estimated_dist_weights is not None:
weights[-NO_OF_TAGS:, -NO_OF_TAGS:] = estimated_dist_weights
diag = np.arange(n_samples)
weights[diag, diag] = 0
last_n_configs = []
Xa = config.anchors
for it in range(max_iter):
# Compute distance and monotonic regression
dis = euclidean_distances(X)
if metric:
disparities = similarities
else:
dis_flat = dis.ravel()
# similarities with 0 are considered as missing values
dis_flat_w = dis_flat[sim_flat != 0]
# Compute the disparities using a monotonic regression
disparities_flat = ir.fit_transform(sim_flat_w, dis_flat_w)
disparities = dis_flat.copy()
disparities[sim_flat != 0] = disparities_flat
disparities = disparities.reshape((n_samples, n_samples))
disparities *= np.sqrt((n_samples * (n_samples - 1) / 2) /
(disparities ** 2).sum())
# Compute stress
stress = (weights.ravel()*(dis.ravel() - disparities.ravel()) ** 2).sum() / 2
#stress = ((dis[:-NO_OF_TAGS, -NO_OF_TAGS:].ravel() - disparities[:-NO_OF_TAGS, -NO_OF_TAGS:].ravel()) ** 2).sum()
# Update X using the Guttman transform
dis[dis == 0] = 1e5
ratio = weights*disparities / dis
B = - ratio
B[diag, diag] = 0
B[diag, diag] = -B.sum(axis=1)
# Apply update to only tag configuration since anchor config is already known
V = - weights
V[diag, diag] += weights.sum(axis=1)
# V_inv = np.linalg.pinv(V)
V12 = V[-NO_OF_TAGS:, :-NO_OF_TAGS]
B11 = B[-NO_OF_TAGS:, -NO_OF_TAGS:]
Zu = X[-NO_OF_TAGS:]
B12 = B[-NO_OF_TAGS:, :-NO_OF_TAGS]
V11_inv = np.linalg.inv(V[-NO_OF_TAGS:, -NO_OF_TAGS:])
Xu = V11_inv.dot(B11.dot(Zu) + (B12 - V12).dot(Xa))
# merge known anchors config with new tags config
X = np.concatenate((Xa, Xu))
last_n_configs.append(X)
#X = (1/n_samples)*B.dot(X)
#dis = np.sqrt((X ** 2).sum(axis=1)).sum()
dis = (weights*dis**2).sum() / 2
if verbose >= 2:
print('it: %d, stress %s' % (it, stress))
if old_stress is not None:
if(old_stress - stress / dis) < eps:
if verbose:
print('breaking at iteration %d with stress %s' % (it,
stress))
break
old_stress = stress / dis
return X, stress, it + 1, np.array(last_n_configs)
def _smacof_with_anchors_single(config,
similarities,
metric=True,
n_components=2,
init=None,
max_iter=300,
verbose=0,
eps=1e-3,
random_state=None,
estimated_dist_weights=None):
"""
Computes multidimensional scaling using SMACOF algorithm
Parameters
----------
config : Config object
configuration object for anchor-tag deployment parameters
similarities: symmetric ndarray, shape [n * n]
similarities between the points
metric: boolean, optional, default: True
compute metric or nonmetric SMACOF algorithm
n_components: int, optional, default: 2
number of dimension in which to immerse the similarities
overwritten if initial array is provided.
init: {None or ndarray}, optional
if None, randomly chooses the initial configuration
if ndarray, initialize the SMACOF algorithm with this array
max_iter: int, optional, default: 300
Maximum number of iterations of the SMACOF algorithm for a single run
verbose: int, optional, default: 0
level of verbosity
eps: float, optional, default: 1e-6
relative tolerance w.r.t stress to declare converge
random_state: integer or numpy.RandomState, optional
The generator used to initialize the centers. If an integer is
given, it fixes the seed. Defaults to the global numpy random
number generator.
Returns
-------
X: ndarray (n_samples, n_components), float
coordinates of the n_samples points in a n_components-space
stress_: float
The final value of the stress (sum of squared distance of the
disparities and the distances for all constrained points)
n_iter : int
Number of iterations run
last_positions: ndarray [X1,...,Xn]
An array of computed Xs.
"""
NO_OF_TAGS, NO_OF_ANCHORS = config.no_of_tags, config.no_of_anchors
similarities = check_symmetric(similarities, raise_exception=True)
n_samples = similarities.shape[0]
random_state = check_random_state(random_state)
sim_flat = ((1 - np.tri(n_samples)) * similarities).ravel()
sim_flat_w = sim_flat[sim_flat != 0]
if init is None:
# Randomly choose initial configuration
X = random_state.rand(n_samples * n_components)
X = X.reshape((n_samples, n_components))
# uncomment the following if weight matrix W is not hollow
#X[:-2] = Xa
else:
# overrides the parameter p
n_components = init.shape[1]
if n_samples != init.shape[0]:
raise ValueError("init matrix should be of shape (%d, %d)" %
(n_samples, n_components))
X = init
old_stress = None
ir = IsotonicRegression()
# setup weight matrix
if getattr(config, 'weights', None) is not None:
weights = config.weights
else:
weights = np.ones((n_samples, n_samples))
if getattr(config, 'missingdata', None):
weights[-NO_OF_TAGS:, -NO_OF_TAGS:] = 0
if estimated_dist_weights is not None:
weights[-NO_OF_TAGS:, -NO_OF_TAGS:] = estimated_dist_weights
diag = np.arange(n_samples)
weights[diag, diag] = 0
last_n_configs = []
Xa = config.anchors
for it in range(max_iter):
# Compute distance and monotonic regression
dis = euclidean_distances(X)
if metric:
disparities = similarities
else:
dis_flat = dis.ravel()
# similarities with 0 are considered as missing values
dis_flat_w = dis_flat[sim_flat != 0]
# Compute the disparities using a monotonic regression
disparities_flat = ir.fit_transform(sim_flat_w, dis_flat_w)
disparities = dis_flat.copy()
disparities[sim_flat != 0] = disparities_flat
disparities = disparities.reshape((n_samples, n_samples))
disparities *= np.sqrt(
(n_samples * (n_samples - 1) / 2) / (disparities**2).sum())
# Compute stress
stress = (weights.ravel() *
(dis.ravel() - disparities.ravel())**2).sum() / 2
#stress = ((dis[:-NO_OF_TAGS, -NO_OF_TAGS:].ravel() - disparities[:-NO_OF_TAGS, -NO_OF_TAGS:].ravel()) ** 2).sum()
# Update X using the Guttman transform
dis[dis == 0] = 1e5
ratio = weights * disparities / dis
B = -ratio
B[diag, diag] = 0
B[diag, diag] = -B.sum(axis=1)
# Apply update to only tag configuration since anchor config is already known
V = -weights
V[diag, diag] += weights.sum(axis=1)
# V_inv = np.linalg.pinv(V)
V12 = V[-NO_OF_TAGS:, :-NO_OF_TAGS]
B11 = B[-NO_OF_TAGS:, -NO_OF_TAGS:]
Zu = X[-NO_OF_TAGS:]
B12 = B[-NO_OF_TAGS:, :-NO_OF_TAGS]
V11_inv = np.linalg.inv(V[-NO_OF_TAGS:, -NO_OF_TAGS:])
Xu = V11_inv.dot(B11.dot(Zu) + (B12 - V12).dot(Xa))
# merge known anchors config with new tags config
X = np.concatenate((Xa, Xu))
last_n_configs.append(X)
#X = (1/n_samples)*B.dot(X)
#dis = np.sqrt((X ** 2).sum(axis=1)).sum()
dis = (weights * dis**2).sum() / 2
if verbose >= 2:
print('it: %d, stress %s' % (it, stress))
if old_stress is not None:
if (old_stress - stress / dis) < eps:
if verbose:
print('breaking at iteration %d with stress %s' %
(it, stress))
break
old_stress = stress / dis
return X, stress, it + 1, np.array(last_n_configs)
def _smacof_single(dissimilarities1,
dissimilarities2,
p,
weights1=None,
weights2=None,
metric=True,
n_components=2,
init1=None,
init2=None,
max_iter=300,
verbose=0,
eps=1e-3,
random_state1=None,
random_state2=None):
"""
Computes multidimensional scaling using SMACOF algorithm
Parameters
----------
dissimilarities : ndarray, shape (n_samples, n_samples)
Pairwise dissimilarities between the points. Must be symmetric.
metric : boolean, optional, default: True
Compute metric or nonmetric SMACOF algorithm.
n_components : int, optional, default: 2
Number of dimensions in which to immerse the dissimilarities. If an
``init`` array is provided, this option is overridden and the shape of
``init`` is used to determine the dimensionality of the embedding
space.
init : ndarray, shape (n_samples, n_components), optional, default: None
Starting configuration of the embedding to initialize the algorithm. By
default, the algorithm is initialized with a randomly chosen array.
max_iter : int, optional, default: 300
Maximum number of iterations of the SMACOF algorithm for a single run.
verbose : int, optional, default: 0
Level of verbosity.
eps : float, optional, default: 1e-3
Relative tolerance with respect to stress at which to declare
convergence.
random_state : integer or numpy.RandomState, optional
The generator used to initialize the centers. If an integer is
given, it fixes the seed. Defaults to the global numpy random
number generator.
Returns
-------
X : ndarray, shape (n_samples, n_components)
Coordinates of the points in a ``n_components``-space.
stress : float
The final value of the stress (sum of squared distance of the
disparities and the distances for all constrained points).
n_iter : int
The number of iterations corresponding to the best stress.
"""
dissimilarities1 = check_symmetric(dissimilarities1, raise_exception=True)
dissimilarities2 = check_symmetric(dissimilarities2, raise_exception=True)
if dissimilarities1.shape != dissimilarities2.shape:
print("Error. Distance matrices have different shapes.")
sys.exit("Error. Distance matrices have different shapes.")
n_samples = dissimilarities1.shape[0]
X1, sim_flat1, sim_flat_w1 = initialize(dissimilarities1, random_state1,
init1, n_samples, n_components)
X2, sim_flat2, sim_flat_w2 = initialize(dissimilarities2, random_state2,
init2, n_samples, n_components)
#Default: equal weights
if weights1 is None:
weights1 = np.ones((n_samples, n_samples))
if weights2 is None:
weights2 = np.ones(n_samples)
# Disparity-specific weights (V in Borg)
V1 = np.zeros((n_samples, n_samples))
for i in range(n_samples):
diagonal = 0
for j in range(n_samples):
V1[i, j] = -weights1[i, j]
diagonal += weights1[i, j]
V1[i, i] = diagonal
# Locus-specific weights
V2 = np.zeros((n_samples, n_samples))
for i, weight in enumerate(weights2):
V2[i, i] = weight * p * n_samples
inv_V = moore_penrose(V1 + V2)
old_stress = None
ir = IsotonicRegression()
for it in range(max_iter):
# Compute distance and monotonic regression
dis1 = euclidean_distances(X1)
dis2 = euclidean_distances(X2)
if metric:
disparities1 = dissimilarities1
disparities2 = dissimilarities2
else:
disparities1 = nonmetric_disparities1(dis1, sim_flat1, n_samples)
disparities2 = nonmetric_disparities2(dis2, sim_flat2, n_samples)
# Compute stress
stress = ((dis1.ravel() - disparities1.ravel())**2).sum() + (
(dis2.ravel() - disparities2.ravel())**2
).sum() + n_samples * p * ssd(
X1, X2
) #multiply by n_samples to make ssd term comparable in magnitude to embedding error terms
# Update X1 using the Guttman transform
X1 = guttman(X1, X2, disparities1, inv_V, V2, dis1)
# Update X2 using the Guttman transform
X2 = guttman(X2, X1, disparities2, inv_V, V2, dis2)
# Test stress
dis1 = np.sqrt((X1**2).sum(axis=1)).sum()
dis2 = np.sqrt((X2**2).sum(axis=1)).sum()
dis = np.mean((dis1, dis2))
if verbose >= 2:
print('it: %d, stress %s' % (it, stress))
if old_stress is not None:
if np.abs(old_stress - stress / dis) < eps:
if verbose:
print('breaking at iteration %d with stress %s' %
(it, stress))
break
old_stress = stress / dis
return X1, X2, stress, it + 1
def my_spectral_embedding(adjacency,
n_components=8,
eigen_solver=None,
random_state=None,
eigen_tol=0.0,
norm_laplacian=False,
drop_first=True):
"""Project the sample on the first eigenvectors of the graph Laplacian.
The adjacency matrix is used to compute a normalized graph Laplacian
whose spectrum (especially the eigenvectors associated to the
smallest eigenvalues) has an interpretation in terms of minimal
number of cuts necessary to split the graph into comparably sized
components.
This embedding can also 'work' even if the ``adjacency`` variable is
not strictly the adjacency matrix of a graph but more generally
an affinity or similarity matrix between samples (for instance the
heat kernel of a euclidean distance matrix or a k-NN matrix).
However care must taken to always make the affinity matrix symmetric
so that the eigenvector decomposition works as expected.
Note : Laplacian Eigenmaps is the actual algorithm implemented here.
Read more in the :ref:`User Guide <spectral_embedding>`.
Parameters
----------
adjacency : array-like or sparse matrix, shape: (n_samples, n_samples)
The adjacency matrix of the graph to embed.
n_components : integer, optional, default 8
The dimension of the projection subspace.
eigen_solver : {None, 'arpack', 'lobpcg', or 'amg'}, default None
The eigenvalue decomposition strategy to use. AMG requires pyamg
to be installed. It can be faster on very large, sparse problems,
but may also lead to instabilities.
random_state : int, RandomState instance or None, optional, default: None
A pseudo random number generator used for the initialization of the
lobpcg eigenvectors decomposition. If int, random_state is the seed
used by the random number generator; If RandomState instance,
random_state is the random number generator; If None, the random number
generator is the RandomState instance used by `np.random`. Used when
``solver`` == 'amg'.
eigen_tol : float, optional, default=0.0
Stopping criterion for eigendecomposition of the Laplacian matrix
when using arpack eigen_solver.
norm_laplacian : bool, optional, default=True
If True, then compute normalized Laplacian.
drop_first : bool, optional, default=True
Whether to drop the first eigenvector. For spectral embedding, this
should be True as the first eigenvector should be constant vector for
connected graph, but for spectral clustering, this should be kept as
False to retain the first eigenvector.
Returns
-------
embedding : array, shape=(n_samples, n_components)
The reduced samples.
Notes
-----
Spectral Embedding (Laplacian Eigenmaps) is most useful when the graph
has one connected component. If there graph has many components, the first
few eigenvectors will simply uncover the connected components of the graph.
References
----------
* https://en.wikipedia.org/wiki/LOBPCG
* Toward the Optimal Preconditioned Eigensolver: Locally Optimal
Block Preconditioned Conjugate Gradient Method
Andrew V. Knyazev
http://dx.doi.org/10.1137%2FS1064827500366124
"""
import warnings
import numpy as np
from scipy import sparse
from scipy.linalg import eigh
from scipy.sparse.linalg import eigsh, lobpcg
from sklearn.base import BaseEstimator
from sklearn.externals import six
from sklearn.utils import check_random_state, check_array, check_symmetric
from sklearn.utils.extmath import _deterministic_vector_sign_flip
from sklearn.metrics.pairwise import rbf_kernel
from sklearn.neighbors import kneighbors_graph
adjacency = check_symmetric(adjacency)
try:
from pyamg import smoothed_aggregation_solver
except ImportError:
if eigen_solver == "amg":
raise ValueError("The eigen_solver was set to 'amg', but pyamg is "
"not available.")
if eigen_solver is None:
eigen_solver = 'arpack'
elif eigen_solver not in ('arpack', 'lobpcg', 'amg'):
raise ValueError("Unknown value for eigen_solver: '%s'."
"Should be 'amg', 'arpack', or 'lobpcg'" %
eigen_solver)
random_state = check_random_state(random_state)
n_nodes = adjacency.shape[0]
# Whether to drop the first eigenvector
if drop_first:
n_components = n_components + 1
if not _graph_is_connected(adjacency):
warnings.warn("Graph is not fully connected, spectral embedding"
" may not work as expected.")
laplacian, dd = sparse.csgraph.laplacian(adjacency,
normed=norm_laplacian,
return_diag=True)
if (eigen_solver == 'arpack' or eigen_solver != 'lobpcg' and
(not sparse.isspmatrix(laplacian) or n_nodes < 5 * n_components)):
# lobpcg used with eigen_solver='amg' has bugs for low number of nodes
# for details see the source code in scipy:
# https://github.com/scipy/scipy/blob/v0.11.0/scipy/sparse/linalg/eigen
# /lobpcg/lobpcg.py#L237
# or matlab:
# http://www.mathworks.com/matlabcentral/fileexchange/48-lobpcg-m
laplacian = _set_diag(laplacian, 1, norm_laplacian)
# Here we'll use shift-invert mode for fast eigenvalues
# (see http://docs.scipy.org/doc/scipy/reference/tutorial/arpack.html
# for a short explanation of what this means)
# Because the normalized Laplacian has eigenvalues between 0 and 2,
# I - L has eigenvalues between -1 and 1. ARPACK is most efficient
# when finding eigenvalues of largest magnitude (keyword which='LM')
# and when these eigenvalues are very large compared to the rest.
# For very large, very sparse graphs, I - L can have many, many
# eigenvalues very near 1.0. This leads to slow convergence. So
# instead, we'll use ARPACK's shift-invert mode, asking for the
# eigenvalues near 1.0. This effectively spreads-out the spectrum
# near 1.0 and leads to much faster convergence: potentially an
# orders-of-magnitude speedup over simply using keyword which='LA'
# in standard mode.
try:
# We are computing the opposite of the laplacian inplace so as
# to spare a memory allocation of a possibly very large array
laplacian *= -1
v0 = random_state.uniform(-1, 1, laplacian.shape[0])
lambdas, diffusion_map = eigsh(laplacian,
k=n_components,
sigma=1.0,
which='LM',
tol=eigen_tol,
v0=v0)
embedding = diffusion_map.T[n_components::-1] * dd
except RuntimeError:
# When submatrices are exactly singular, an LU decomposition
# in arpack fails. We fallback to lobpcg
eigen_solver = "lobpcg"
# Revert the laplacian to its opposite to have lobpcg work
laplacian *= -1
if eigen_solver == 'amg':
# Use AMG to get a preconditioner and speed up the eigenvalue
# problem.
if not sparse.issparse(laplacian):
warnings.warn("AMG works better for sparse matrices")
# lobpcg needs double precision floats
laplacian = check_array(laplacian,
dtype=np.float64,
accept_sparse=True)
laplacian = _set_diag(laplacian, 1, norm_laplacian)
ml = smoothed_aggregation_solver(check_array(laplacian, 'csr'))
M = ml.aspreconditioner()
X = random_state.rand(laplacian.shape[0], n_components + 1)
X[:, 0] = dd.ravel()
lambdas, diffusion_map = lobpcg(laplacian,
X,
M=M,
tol=1.e-12,
largest=False)
embedding = diffusion_map.T * dd
if embedding.shape[0] == 1:
raise ValueError
elif eigen_solver == "lobpcg":
# lobpcg needs double precision floats
laplacian = check_array(laplacian,
dtype=np.float64,
accept_sparse=True)
if n_nodes < 5 * n_components + 1:
# see note above under arpack why lobpcg has problems with small
# number of nodes
# lobpcg will fallback to eigh, so we short circuit it
if sparse.isspmatrix(laplacian):
laplacian = laplacian.toarray()
lambdas, diffusion_map = eigh(laplacian)
embedding = diffusion_map.T[:n_components] * dd
else:
laplacian = _set_diag(laplacian, 1, norm_laplacian)
# We increase the number of eigenvectors requested, as lobpcg
# doesn't behave well in low dimension
X = random_state.rand(laplacian.shape[0], n_components + 1)
X[:, 0] = dd.ravel()
lambdas, diffusion_map = lobpcg(laplacian,
X,
tol=1e-15,
largest=False,
maxiter=2000)
embedding = diffusion_map.T[:n_components] * dd
if embedding.shape[0] == 1:
raise ValueError
embedding = _deterministic_vector_sign_flip(embedding)
if drop_first:
vectors = embedding[1:n_components].T
else:
vectors = embedding[:n_components].T
return (lambdas, vectors)
import os
# Get the student/postcode/OA data from the flat file
def readstudentdata():
cur_path = os.path.dirname(__file__)
new_path = os.path.relpath('..\\studentsByOA.csv', cur_path)
return pd.read_csv(new_path)
inData = pd.read_csv("distancematrix.csv", header=0, index_col="oa11")
# the real distance matrix is asymmetric - mds requires a symmetric one
# use this function to create a symmetric version
# it averages the matrix with its transpose
symmMatrix = utils.check_symmetric(inData.as_matrix())
mds = manifold.MDS(n_components=2,
max_iter=3000,
eps=1e-4,
random_state=None,
dissimilarity="precomputed",
n_jobs=1,
metric=True)
coords = mds.fit(symmMatrix).embedding_
oldData = readstudentdata()
oldData = oldData.set_index("oa11")
coordsDF = pd.DataFrame(data=coords, index=inData.index.values)
oldData.loc[:, "fakex"] = pd.Series(coordsDF.loc[:, 0],
index=inData.index.values)
def _smacof_single_p(similarities,
n_uq,
metric=True,
n_components=2,
init=None,
max_iter=300,
verbose=0,
eps=1e-3,
random_state=None):
"""
Computes multidimensional scaling using SMACOF algorithm.
Parameters
----------
n_uq
similarities: symmetric ndarray, shape [n * n]
similarities between the points
metric: boolean, optional, default: True
compute metric or nonmetric SMACOF algorithm
n_components: int, optional, default: 2
number of dimension in which to immerse the similarities
overwritten if initial array is provided.
init: {None or ndarray}, optional
if None, randomly chooses the initial configuration
if ndarray, initialize the SMACOF algorithm with this array
max_iter: int, optional, default: 300
Maximum number of iterations of the SMACOF algorithm for a single run
verbose: int, optional, default: 0
level of verbosity
eps: float, optional, default: 1e-6
relative tolerance w.r.t stress to declare converge
random_state: integer or numpy.RandomState, optional
The generator used to initialize the centers. If an integer is
given, it fixes the seed. Defaults to the global numpy random
number generator.
Returns
-------
X: ndarray (n_samples, n_components), float
coordinates of the n_samples points in a n_components-space
stress_: float
The final value of the stress (sum of squared distance of the
disparities and the distances for all constrained points)
n_iter : int
Number of iterations run.
"""
similarities = check_symmetric(similarities, raise_exception=True)
n_samples = similarities.shape[0]
random_state = check_random_state(random_state)
W = np.ones((n_samples, n_samples))
W[:n_uq, :n_uq] = 0.0
W[n_uq:, n_uq:] = 0.0
V = -W
V[np.arange(len(V)), np.arange(len(V))] = W.sum(axis=1)
e = np.ones((n_samples, 1))
Vp = np.linalg.inv(V + np.dot(e, e.T) / n_samples) - \
np.dot(e, e.T) / n_samples
sim_flat = similarities.ravel()
sim_flat_w = sim_flat[sim_flat != 0]
if init is None:
# Randomly choose initial configuration
X = random_state.rand(n_samples * n_components)
X = X.reshape((n_samples, n_components))
else:
# overrides the parameter p
n_components = init.shape[1]
if n_samples != init.shape[0]:
raise ValueError("init matrix should be of shape (%d, %d)" %
(n_samples, n_components))
X = init
old_stress = None
ir = IsotonicRegression()
for it in range(max_iter):
# Compute distance and monotonic regression
dis = euclidean_distances(X)
if metric:
disparities = similarities
else:
dis_flat = dis.ravel()
# similarities with 0 are considered as missing values
dis_flat_w = dis_flat[sim_flat != 0]
# Compute the disparities using a monotonic regression
disparities_flat = ir.fit_transform(sim_flat_w, dis_flat_w)
disparities = dis_flat.copy()
disparities[sim_flat != 0] = disparities_flat
disparities = disparities.reshape((n_samples, n_samples))
disparities *= np.sqrt(
(n_samples * (n_samples - 1) / 2) / (disparities**2).sum())
disparities[similarities == 0] = 0
# Compute stress
_stress = (W.ravel() * ((dis.ravel() - disparities.ravel())**2)).sum()
_stress /= 2
# Update X using the Guttman transform
dis[dis == 0] = 1e-5
ratio = disparities / dis
_B = -W * ratio
_B[np.arange(len(_B)), np.arange(len(_B))] += (W * ratio).sum(axis=1)
X = np.dot(Vp, np.dot(_B, X))
dis = np.sqrt((X**2).sum(axis=1)).sum()
if verbose >= 2:
print('it: %d, stress %s' % (it, _stress))
if old_stress is not None:
if (old_stress - _stress / dis) < eps:
if verbose:
print(f'breaking at iteration {it} with stress {_stress}')
break
old_stress = _stress / dis
return X, _stress, it + 1
def _smacof_single_p(similarities, n_uq, metric=True, n_components=2, init=None,
max_iter=300, verbose=0, eps=1e-3, random_state=None):
"""
Computes multidimensional scaling using SMACOF algorithm
Parameters
----------
n_uq
similarities: symmetric ndarray, shape [n * n]
similarities between the points
metric: boolean, optional, default: True
compute metric or nonmetric SMACOF algorithm
n_components: int, optional, default: 2
number of dimension in which to immerse the similarities
overwritten if initial array is provided.
init: {None or ndarray}, optional
if None, randomly chooses the initial configuration
if ndarray, initialize the SMACOF algorithm with this array
max_iter: int, optional, default: 300
Maximum number of iterations of the SMACOF algorithm for a single run
verbose: int, optional, default: 0
level of verbosity
eps: float, optional, default: 1e-6
relative tolerance w.r.t stress to declare converge
random_state: integer or numpy.RandomState, optional
The generator used to initialize the centers. If an integer is
given, it fixes the seed. Defaults to the global numpy random
number generator.
Returns
-------
X: ndarray (n_samples, n_components), float
coordinates of the n_samples points in a n_components-space
stress_: float
The final value of the stress (sum of squared distance of the
disparities and the distances for all constrained points)
n_iter : int
Number of iterations run.
"""
similarities = check_symmetric(similarities, raise_exception=True)
n_samples = similarities.shape[0]
random_state = check_random_state(random_state)
W = np.ones((n_samples, n_samples))
W[:n_uq, :n_uq] = 0.0
W[n_uq:, n_uq:] = 0.0
# W[np.arange(len(W)), np.arange(len(W))] = 0.0
V = -W
V[np.arange(len(V)), np.arange(len(V))] = W.sum(axis=1)
e = np.ones((n_samples, 1))
Vp = np.linalg.inv(V + np.dot(e, e.T)/n_samples) - np.dot(e, e.T)/n_samples
# Vp = np.linalg.pinv(V)
# sim_flat = ((1 - np.tri(n_samples)) * similarities).ravel()
sim_flat = similarities.ravel()
sim_flat_w = sim_flat[sim_flat != 0]
if init is None:
# Randomly choose initial configuration
X = random_state.rand(n_samples * n_components)
X = X.reshape((n_samples, n_components))
else:
# overrides the parameter p
n_components = init.shape[1]
if n_samples != init.shape[0]:
raise ValueError("init matrix should be of shape (%d, %d)" %
(n_samples, n_components))
X = init
old_stress = None
ir = IsotonicRegression()
for it in range(max_iter):
# Compute distance and monotonic regression
dis = euclidean_distances(X)
if metric:
disparities = similarities
else:
# dis_flat = dis.ravel()
# # similarities with 0 are considered as missing values
# dis_flat_w = dis_flat[sim_flat != 0]
# # Compute the disparities using a monotonic regression
# disparities_flat = ir.fit_transform(sim_flat_w, dis_flat_w)
# disparities = dis_flat.copy()
# disparities[sim_flat != 0] = disparities_flat
# disparities = disparities.reshape((n_samples, n_samples))
# disparities *= np.sqrt((n_samples * (n_samples - 1) / 2) /
# (disparities ** 2).sum())
dis_flat = dis.ravel()
# similarities with 0 are considered as missing values
dis_flat_w = dis_flat[sim_flat != 0]
# Compute the disparities using a monotonic regression
disparities_flat = ir.fit_transform(sim_flat_w, dis_flat_w)
disparities = dis_flat.copy()
disparities[sim_flat != 0] = disparities_flat
disparities = disparities.reshape((n_samples, n_samples))
disparities *= np.sqrt((n_samples * (n_samples - 1) / 2) / (disparities ** 2).sum())
disparities[similarities==0] = 0
# Compute stress
# stress = ((dis.ravel() - disparities.ravel()) ** 2).sum() / 2
_stress = (W.ravel()*((dis.ravel() - disparities.ravel()) ** 2)).sum() / 2
# Update X using the Guttman transform
# dis[dis == 0] = 1e-5
# ratio = disparities / dis
# B = - ratio
# B[np.arange(len(B)), np.arange(len(B))] += ratio.sum(axis=1)
# X = 1. / n_samples * np.dot(B, X)
# print (1. / n_samples * np.dot(B, X))[:5].T
dis[dis == 0] = 1e-5
ratio = disparities / dis
_B = - W*ratio
_B[np.arange(len(_B)), np.arange(len(_B))] += (W*ratio).sum(axis=1)
X = np.dot(Vp, np.dot(_B, X))
# print X[:5].T
dis = np.sqrt((X ** 2).sum(axis=1)).sum()
if verbose >= 2:
print('it: %d, stress %s' % (it, _stress))
if old_stress is not None:
if(old_stress - _stress / dis) < eps:
if verbose:
print('breaking at iteration %d with stress %s' % (it,
_stress))
break
old_stress = _stress / dis
return X, _stress, it + 1
def spectral_embedding(self,
adjacency,
n_components=8,
eigen_solver=None,
random_state=None,
eigen_tol=0.0,
drop_first=True):
"""
see original at https://github.com/scikit-learn/scikit-learn/blob/14031f6/sklearn/manifold/spectral_embedding_.py#L133
custermize1: return lambdas with the embedded matrix.
custermize2: norm_laplacian is always True
"""
norm_laplacian = True
adjacency = check_symmetric(adjacency)
try:
from pyamg import smoothed_aggregation_solver
except ImportError:
if eigen_solver == "amg":
raise ValueError(
"The eigen_solver was set to 'amg', but pyamg is "
"not available.")
if eigen_solver is None:
eigen_solver = 'arpack'
elif eigen_solver not in ('arpack', 'lobpcg', 'amg'):
raise ValueError("Unknown value for eigen_solver: '%s'."
"Should be 'amg', 'arpack', or 'lobpcg'" %
eigen_solver)
random_state = check_random_state(random_state)
n_nodes = adjacency.shape[0]
# Whether to drop the first eigenvector
if drop_first:
n_components = n_components + 1
if not _graph_is_connected(adjacency):
warnings.warn("Graph is not fully connected, spectral embedding"
" may not work as expected.")
laplacian, dd = graph_laplacian(adjacency,
normed=norm_laplacian,
return_diag=True)
if (eigen_solver == 'arpack' or eigen_solver != 'lobpcg' and
(not sparse.isspmatrix(laplacian) or n_nodes < 5 * n_components)):
# lobpcg used with eigen_solver='amg' has bugs for low number of nodes
# for details see the source code in scipy:
# https://github.com/scipy/scipy/blob/v0.11.0/scipy/sparse/linalg/eigen
# /lobpcg/lobpcg.py#L237
# or matlab:
# http://www.mathworks.com/matlabcentral/fileexchange/48-lobpcg-m
laplacian = _set_diag(laplacian, 1, norm_laplacian)
# Here we'll use shift-invert mode for fast eigenvalues
# (see http://docs.scipy.org/doc/scipy/reference/tutorial/arpack.html
# for a short explanation of what this means)
# Because the normalized Laplacian has eigenvalues between 0 and 2,
# I - L has eigenvalues between -1 and 1. ARPACK is most efficient
# when finding eigenvalues of largest magnitude (keyword which='LM')
# and when these eigenvalues are very large compared to the rest.
# For very large, very sparse graphs, I - L can have many, many
# eigenvalues very near 1.0. This leads to slow convergence. So
# instead, we'll use ARPACK's shift-invert mode, asking for the
# eigenvalues near 1.0. This effectively spreads-out the spectrum
# near 1.0 and leads to much faster convergence: potentially an
# orders-of-magnitude speedup over simply using keyword which='LA'
# in standard mode.
try:
# We are computing the opposite of the laplacian inplace so as
# to spare a memory allocation of a possibly very large array
laplacian *= -1
lambdas, diffusion_map = eigsh(laplacian,
k=n_components,
sigma=1.0,
which='LM',
tol=eigen_tol)
embedding = diffusion_map.T[n_components::-1] * dd
except RuntimeError:
# When submatrices are exactly singular, an LU decomposition
# in arpack fails. We fallback to lobpcg
eigen_solver = "lobpcg"
# Revert the laplacian to its opposite to have lobpcg work
laplacian *= -1
if eigen_solver == 'amg':
# Use AMG to get a preconditioner and speed up the eigenvalue
# problem.
if not sparse.issparse(laplacian):
warnings.warn("AMG works better for sparse matrices")
# lobpcg needs double precision floats
laplacian = check_array(laplacian,
dtype=np.float64,
accept_sparse=True)
laplacian = _set_diag(laplacian, 1, norm_laplacian)
ml = smoothed_aggregation_solver(check_array(laplacian, 'csr'))
M = ml.aspreconditioner()
X = random_state.rand(laplacian.shape[0], n_components + 1)
X[:, 0] = dd.ravel()
lambdas, diffusion_map = lobpcg(laplacian,
X,
M=M,
tol=1.e-12,
largest=False)
embedding = diffusion_map.T * dd
if embedding.shape[0] == 1:
raise ValueError
elif eigen_solver == "lobpcg":
# lobpcg needs double precision floats
laplacian = check_array(laplacian,
dtype=np.float64,
accept_sparse=True)
if n_nodes < 5 * n_components + 1:
# see note above under arpack why lobpcg has problems with small
# number of nodes
# lobpcg will fallback to eigh, so we short circuit it
if sparse.isspmatrix(laplacian):
laplacian = laplacian.toarray()
lambdas, diffusion_map = eigh(laplacian)
embedding = diffusion_map.T[:n_components] * dd
else:
laplacian = _set_diag(laplacian, 1, norm_laplacian)
# We increase the number of eigenvectors requested, as lobpcg
# doesn't behave well in low dimension
X = random_state.rand(laplacian.shape[0], n_components + 1)
X[:, 0] = dd.ravel()
lambdas, diffusion_map = lobpcg(laplacian,
X,
tol=1e-15,
largest=False,
maxiter=2000)
embedding = diffusion_map.T[:n_components] * dd
if embedding.shape[0] == 1:
raise ValueError
embedding = _deterministic_vector_sign_flip(embedding)
if drop_first:
return embedding[1:n_components].T, lambdas
else:
return embedding[:n_components].T, lambdas
