def reduce(data, reduction, n_neighbors=30, min_dist=0.0, n_components=10, random_state=1111, affinity_reduc='nearest_neighbors', metric_r='cosine', output_metric='euclidean'):
"""Reduce dimemnsion of beta maps.
"""
gc.collect()
if reduction=="umap":
data_reduced = umap.UMAP(n_neighbors=n_neighbors, min_dist=min_dist, n_components=n_components, random_state=random_state, metric=metric_r, output_metric=output_metric).fit_transform(data)
standard_embedding = umap.UMAP(n_neighbors=n_neighbors, min_dist=min_dist, n_components=2, random_state=random_state, metric=metric_r, output_metric=output_metric).fit_transform(data)
elif reduction=="pca":
data_reduced = PCA(n_components=n_components, random_state=random_state).fit_transform(data)
standard_embedding = PCA(n_components=2, random_state=random_state).fit_transform(data)
elif reduction=="ica":
data_reduced = FastICA(n_components=n_components, random_state=random_state).fit_transform(data)
standard_embedding = FastICA(n_components=2, random_state=random_state).fit_transform(data)
elif reduction=="isomap":
data_reduced = manifold.Isomap(n_components=n_components, n_neighbors=n_neighbors, n_jobs=-1).fit_transform(data)
standard_embedding = manifold.Isomap(n_components=2, n_neighbors=n_neighbors, n_jobs=-1).fit_transform(data)
elif reduction=="mds":
data_reduced = manifold.MDS(n_components=n_components, random_state=random_state, n_jobs=-1).fit_transform(data)
standard_embedding = manifold.MDS(n_components=2, random_state=random_state, n_jobs=-1).fit_transform(data)
elif reduction=="sp-emb":
data_reduced = manifold.SpectralEmbedding(n_components=n_components, random_state=random_state, n_neighbors=n_neighbors, n_jobs=-1).fit_transform(data)
standard_embedding = manifold.SpectralEmbedding(n_components=2, random_state=random_state, n_neighbors=n_neighbors, n_jobs=-1, affinity=affinity_reduc).fit_transform(data)
else:
data_reduced = data
return data_reduced, standard_embedding
def build_embedding(path, embedding=None):
"""
Build the desired embedding and save to specified path.
Available embeddings :
* Interaction Matrix
* t-SNE (unused)
* Spectral Embedding
* Locally Linear Embedding
* Non-negative Matrix Factorisation
* Factor Analysis
"""
if embedding == 'spectral':
mat = np.load(path)
u_spectral = manifold.SpectralEmbedding(n_components=64, random_state=0, n_jobs=8).fit_transform(mat)
i_spectral = manifold.SpectralEmbedding(n_components=64, random_state=0, n_jobs=8).fit_transform(mat.T)
return u_spectral, i_spectral
elif embedding == 'lle':
mat = np.load(path)
u_lle = manifold.LocallyLinearEmbedding(n_components=64, random_state=0, n_jobs=8).fit_transform(mat)
i_lle = manifold.LocallyLinearEmbedding(n_components=64, random_state=0, n_jobs=8).fit_transform(mat.T)
return u_lle, i_lle
elif embedding == 'fa':
mat = np.load(path)
u_fa = decomposition.FactorAnalysis(n_components=64, random_state=0).fit_transform(mat)
i_fa = decomposition.FactorAnalysis(n_components=64, random_state=0).fit_transform(mat.T)
return u_fa, i_fa
elif embedding == 'nmf':
mat = np.load(path)
u_nmf = decomposition.NMF(n_components=64, random_state=0).fit_transform(mat)
i_nmf = decomposition.NMF(n_components=64, random_state=0).fit_transform(mat.T)
return u_nmf, i_nmf
def hc_embedding(G, pre_weighting='RA1', embedding=None, angular='EA'):
"""
Computes a hyperbolic coalescent embedding of a given graph.
Args:
G: networkx.Graph
pre_weighting: str, Determines the features that are passed to the dimensionality reduction method.
embedding: Object, An embedding model that implements the fit_transform method (like sklearn.manifold.SpectralEmbedding).
angular: str, Determines the method used to create the angular coordinates for the final embedding.
Returns: numpy.ndarray
(N, 2) array that contains the spatial (x, y) coordinates of the embedded network.
"""
weight_func = getattr(pre_weights, f'{pre_weighting}_weights')
embedding_model = embedding or manifold.SpectralEmbedding()
angular_func = getattr(angular_coords, f'{angular}_coords')
weights = weight_func(G)
embedded_weights = embedding_model.fit_transform(weights)
coords = angular_func(embedded_weights)
beta = 1 / (pl_exponent_fit.get_pl_exponent(G) - 1)
radii = radial_coord.radial_coord_deg(G, beta)
coords = coords * radii[..., None]
return {node: coord for node, coord in zip(G.nodes, coords)}
def NDR(data,method,dim,n_neighbors=100):
if method == 'standard_LLE':
embedding = manifold.LocallyLinearEmbedding(n_neighbors=n_neighbors,n_components=dim,\
method='standard').fit_transform(data)
elif method == 'hessian_LLE':
embedding = manifold.LocallyLinearEmbedding(n_neighbors=235,n_components=dim,\
method='hessian',eigen_solver='dense').fit_transform(data)
elif method == 'ltsa_LLE':
embedding = manifold.LocallyLinearEmbedding(n_neighbors=n_neighbors, n_components=dim,\
method='ltsa',eigen_solver='dense').fit_transform(data)
elif method == 'modified_LLE':
embedding = manifold.LocallyLinearEmbedding(n_neighbors=n_neighbors, n_components=dim,\
method='modified',eigen_solver='dense').fit_transform(data)
elif method == 'IsoMap':
embedding = manifold.Isomap(n_neighbors=n_neighbors, n_components=dim)\
.fit_transform(data)
elif method == 't-SNE':
embedding = manifold.TSNE(n_components=dim, init='pca', random_state=0,method='exact')\
.fit_transform(data)
elif method == 'MDS':
embedding = manifold.MDS(n_components=dim, max_iter=100, n_init=1).fit_transform(data)
elif method == 'Spectral_Embedding':
embedding = manifold.SpectralEmbedding(n_components=dim,n_neighbors=n_neighbors)\
.fit_transform(data)
elif method == 'UMAP':
embedding = umap.UMAP(n_components=dim,n_neighbors=n_neighbors).fit_transform(data)
elif method == 'PCA':
embedding = PCA(n_components=dim,svd_solver= 'auto').fit_transform(data)
elif method == 'Diffusion_Map':
mydmap = diffusion_map.DiffusionMap.from_sklearn(n_evecs=dim)
embedding = mydmap.fit_transform(data)
return(embedding)
def GMMpipeline(matrix, upper_bound, pca_components, spectral_emb_coeff, n_neighbors):
'''
This function clusters the input matrix using the GaussianMixture algorithm (gaussian mixture model)
The number of clusters is found by running the algorithm for n_components = 2 to upper_bound
and chosing the model which minimized the BIC.
Returns the labels for each observation.
:type upper_bound: int
:param upper_bound: max number of clusters
:type matrix: numpy matrix
'''
if (len(matrix) < upper_bound + 1):
print("\n\tWARNING: Not enough samples (less than the minimum %i) to run GaussianMixture." % (upper_bound))
print("\t Only one cluster is returned.\n")
return [0] * len(matrix)
pca = decomposition.PCA(n_components=pca_components, whiten=True)
Embedding = manifold.SpectralEmbedding(n_components=spectral_emb_coeff,
affinity='nearest_neighbors',
gamma=None, random_state=0,
n_neighbors=n_neighbors)
GaussianMixture = mix.GaussianMixture(n_components=upper_bound, covariance_type='full', \
random_state=1, max_iter=1000, n_init=1)
clf = Pipeline([('pca', pca), ('gmm', GaussianMixture)])
clf.fit(matrix)
return clf
def main(cosim):
dense = cosim.matrix.todense()
affinity = 0.5 * dense + 0.5 * dense.T
distance = np.maximum(1.0 - affinity, 0)
for nc in NUM_COMPONENTS:
algs = [
('isomap', manifold.Isomap(nc)),
#('TSNE', manifold.TSNE(nc, metric='precomputed')),
('spectral', manifold.SpectralEmbedding(nc,
affinity='precomputed')),
('MDS', manifold.MDS(nc, dissimilarity='precomputed')),
]
print
print
print '=' * 80
print 'Results for all algorithms with %d components' % nc
print '=' * 80
print
for name, alg in algs:
M = distance
if name in ('spectral', ): M = affinity
embedding = alg.fit_transform(M)
evaluator = Evaluator(cosim, embedding)
print
print 'results for', name, 'rank', nc, ':'
evaluator.evaluate()
def spectral():
print("Spectral embedding is selected")
embedder = manifold.SpectralEmbedding(n_components = n_components,
random_state = 0,
eigen_solver = "arpack",
n_neighbors = n_neighbors)
return embedder
def decompose(dataset):
X = dataset["data"]
y = dataset["targets"]
t0 = time()
X_decomposed = decomposition.TruncatedSVD(n_components=2).fit_transform(X)
#X_decomposed = discriminant_analysis.LinearDiscriminantAnalysis(n_components=2).fit_transform(X, y)
tsne = manifold.TSNE(n_components=2, init='pca', random_state=0)
X_decomposed = tsne.fit_transform(X)
embedder = manifold.SpectralEmbedding(n_components=2,
random_state=0,
eigen_solver="arpack")
X_decomposed = embedder.fit_transform(X)
clf = manifold.MDS(n_components=2, n_init=1, max_iter=100)
X_decomposed = clf.fit_transform(X)
plot_embedding(
X_decomposed, y,
"Principal Components projection of the digits (time %.2fs)" %
(time() - t0))
return X_decomposed
def PreprocessingICA(self,
PCA_coefficients,
MNE_coefficients,
N_neighbors,
whiten=True):
"""
:type MNE_coefficients: int
:type PCA_coefficients: int
:param MNE_coefficients: number of coefficnents for mns projection
:param PCA_coefficients: number of n_coefficients for PCA transform
:param N_neighbors: number of neighbors for embedding
"""
self.MNE_coefficients = MNE_coefficients
self.PCA_coefficients = PCA_coefficients
self.N_neighbors = N_neighbors
self.pca = decomposition.FastICA(n_components=self.PCA_coefficients,
algorithm='parallel',
whiten=whiten,
fun='logcosh',
fun_args=None,
max_iter=200,
tol=0.0001,
w_init=None,
random_state=0)
self.Embedding = manifold.SpectralEmbedding(
n_components=self.MNE_coefficients,
affinity='nearest_neighbors',
gamma=None,
random_state=11,
n_neighbors=self.N_neighbors)
self.X_pca = self.pca.fit_transform(self.Waves_Coefficients)
self.X_red = self.Embedding.fit_transform(self.X_pca)
return self.X_red
def __init__(self, source):
min_max_scaler = preprocessing.MinMaxScaler()
data_source = min_max_scaler.fit_transform(source)
se = manifold.SpectralEmbedding(n_components=2,
random_state=0,
eigen_solver='arpack')
self.return_data = se.fit_transform(data_source)
def investigateOptimalAlgorithms(kmerId, kmerCount):
plot.setLibrary('bokeh')
plots = {}
params = {'n_components':N_PCA_COMPONENTS, 'random_state':42}
algos = (
('PCA', decomposition.PCA(**params)),
('LLE', manifold.LocallyLinearEmbedding(method='standard', **params)),
('LTSA', manifold.LocallyLinearEmbedding(method='ltsa', **params)),
('Hessian LLE', manifold.LocallyLinearEmbedding(method='hessian',
n_neighbors=10, **params)),
('Modified LLE', manifold.LocallyLinearEmbedding(method='modified',
**params)),
('tSNE', manifold.TSNE(**params)),
('Isomap', manifold.Isomap(n_components=N_PCA_COMPONENTS)),
('MDS', manifold.MDS(**params)),
('SE', manifold.SpectralEmbedding(**params)))
## Visualise data and manually determine which algorithm will be good
for i, (name, algo) in enumerate(algos, 1):
com = _getComponents(algo, kmerCount)
com = pd.DataFrame(com, columns=PCA_DATA_COL_NAMES)
kmerDf = pd.concat([kmerId, com], axis=1)
dataset = hv.Dataset(kmerDf, PCA_DATA_COL_NAMES)
scatter = dataset.to(hv.Scatter, PCA_DATA_COL_NAMES)
scatter.opts(opts.Scatter(size=10, show_legend=True))
plots[name] = scatter
plots = hv.HoloMap(plots, kdims='algo')
plots = plots.collate()
return plots
def analyse_mode(properties, mode):
mode = float(mode)
if mode == 0:
pca = PCA(n_components=2)
pos = pca.fit_transform(properties)
elif mode == 1:
model = TSNE(n_components=2, random_state=0)
np.set_printoptions(suppress=True)
pos = model.fit_transform(properties)
elif mode == 2:
clf = manifold.Isomap(n_components=2)
pos = clf.fit_transform(properties)
elif mode == 3:
hasher = ensemble.RandomTreesEmbedding(n_estimators=200,
random_state=0,
max_depth=5)
x_transformed = hasher.fit_transform(properties)
pca = decomposition.TruncatedSVD(n_components=2)
pos = pca.fit_transform(x_transformed)
else:
clf = manifold.SpectralEmbedding(n_components=2,
random_state=0,
eigen_solver="arpack")
pos = clf.fit_transform(properties)
return pos
def transform(self):
"""compute transformations of LP solutions into 2-dimensional space"""
# df = pd.DataFrame(self.nodelist, columns = ['LPsol'])
df = self.df["LPsol"].apply(pd.Series).fillna(value=0)
if self.transformation == "tsne":
mf = manifold.TSNE(n_components=2)
elif self.transformation == "lle":
mf = manifold.LocallyLinearEmbedding(n_components=2)
elif self.transformation == "ltsa":
mf = manifold.LocallyLinearEmbedding(n_components=2, method="ltsa")
elif self.transformation == "spectral":
mf = manifold.SpectralEmbedding(n_components=2)
else:
mf = manifold.MDS(n_components=2)
if self.verbose:
print("transforming LP solutions", end="...")
start = time()
start = time()
xy = mf.fit_transform(df)
if self.verbose:
print(f"✔, time: {time()-start:.2f} seconds")
try:
self.stress = mf.stress_ # not available with all transformations
except:
print(
"no stress information available for {self.transformation} transformation"
)
self.df["x"] = xy[:, 0]
self.df["y"] = xy[:, 1]
def spectralEmbed(self, k, n_neighbors=10):
from sklearn import manifold
se = manifold.SpectralEmbedding(n_components=k,
n_neighbors=n_neighbors)
Yse = se.fit_transform(self.tdm)
print(len(Yse))
return Yse
def classifier_choice(method='tsne', neighbors=30, dimensions=2):
if method in "tsne":
return TSNE(n_components=dimensions, perplexity=30, verbose=1)
elif method in "pca":
return decomposition.TruncatedSVD(n_components=dimensions)
elif method in "isomap":
return manifold.Isomap(n_neighbors=neighbors, n_components=dimensions)
elif method in "lle":
return manifold.LocallyLinearEmbedding(n_neighbors=neighbors,
n_components=dimensions,
method='standard')
elif method in "mlle":
return manifold.LocallyLinearEmbedding(n_neighbors=neighbors,
n_components=dimensions,
method='modified')
elif method in "hlle":
return manifold.LocallyLinearEmbedding(n_neighbors=neighbors,
n_components=dimensions,
method='hessian')
elif method in "ltsa":
return manifold.LocallyLinearEmbedding(n_neighbors=neighbors,
n_components=dimensions,
method='ltsa')
elif method in "mds":
return manifold.MDS(n_components=dimensions, n_init=1, max_iter=100)
elif method in "trees":
trees = ensemble.RandomTreesEmbedding(n_estimators=200, max_depth=5)
pca = decomposition.TruncatedSVD(n_components=dimensions)
return Pipeline([('Random Tree Embedder', trees), ('PCA', pca)])
elif method in "spectral":
return manifold.SpectralEmbedding(n_components=dimensions,
eigen_solver="arpack")
else:
print('Please use valid method')
def dimensionReduction(self, vector, method, ratio=0.5):
import numpy as np
vector = np.array(vector)
print(vector.shape)
print(len(vector))
# 如果是0.x，则是比率
if ratio < 1:
originDim = vector.shape[1]
reducedDim = int(originDim * ratio)
# 如果不是，则就是具体多少维了
else:
reducedDim = int(ratio)
if reducedDim > vector.shape[0]:
reducedDim = vector.shape[0]
if method == 'pca':
from sklearn.decomposition import PCA
pca = PCA(n_components=reducedDim)
pca.fit(vector)
reducedVector = pca.transform(vector)
elif method == 'lle':
from sklearn import manifold
reducedVector = manifold.LocallyLinearEmbedding(
n_neighbors=reducedDim // 2,
n_components=reducedDim,
method='standard').fit_transform(vector)
elif method == 'kpca':
from sklearn.decomposition import KernelPCA
#pca = KernelPCA(kernel='cosine',n_components=reducedDim)
pca = KernelPCA(kernel='rbf', n_components=reducedDim)
pca.fit(vector)
reducedVector = pca.transform(vector)
elif method == 'svd':
from sklearn.decomposition import TruncatedSVD
svd = TruncatedSVD(n_components=reducedDim,
n_iter=7,
random_state=42)
svd.fit(vector)
# svd贡献率
print(svd.explained_variance_ratio_)
reducedVector = svd.transform(vector)
elif method == 'iso':
from sklearn import manifold
isomap = manifold.Isomap(n_components=reducedDim,
n_neighbors=reducedDim // 2)
reducedVector = isomap.fit_transform(vector)
elif method == 'tsne':
from sklearn import manifold
tsne = manifold.TSNE(n_components=reducedDim,
learning_rate=100,
random_state=42,
method='exact')
reducedVector = tsne.fit_transform(vector)
elif method == 'spe':
from sklearn import manifold
embedding = manifold.SpectralEmbedding(n_components=reducedDim,
random_state=42)
reducedVector = embedding.fit_transform(vector)
print('after dim cut:', reducedVector.shape[1])
return reducedVector
def PreprocessingPCA(self,
PCA_coefficients,
MNE_coefficients,
N_neighbors,
whiten=True):
"""
:type MNE_coefficients: int
:type PCA_coefficients: int
:param MNE_coefficients: number of coefficnents for mns projection
:param PCA_coefficients: number of n_coefficients for PCA transform
:param N_neighbors: number of neighbors for embedding
"""
self.MNE_coefficients = MNE_coefficients
self.PCA_coefficients = PCA_coefficients
self.N_neighbors = N_neighbors
self.pca = decomposition.PCA(n_components=self.PCA_coefficients,
whiten=whiten)
# self.pca = decomposition.SparsePCA(n_components=self.PCA_coefficients, random_state=0)
self.Embedding = manifold.SpectralEmbedding(
n_components=self.MNE_coefficients,
affinity='nearest_neighbors',
gamma=None,
random_state=0,
n_neighbors=self.N_neighbors)
self.X_pca = self.pca.fit_transform(self.Waves_Coefficients)
self.X_red = self.Embedding.fit_transform(self.X_pca)
return self.X_red
def manifoldLearningTransform(X,
n_components=2,
n_neighbors=10,
name='SE',
eigen_solver='auto'):
LLE = partial(manifold.LocallyLinearEmbedding,
n_neighbors,
n_components,
eigen_solver=eigen_solver)
methods = OrderedDict()
methods['LLE'] = LLE(method='standard')
methods['LTSA'] = LLE(method='ltsa')
methods['Hessian LLE'] = LLE(method='hessian')
methods['Modified LLE'] = LLE(method='modified')
methods['Isomap'] = manifold.Isomap(n_neighbors, n_components)
methods['MDS'] = manifold.MDS(n_components, max_iter=100, n_init=1)
methods['SE'] = manifold.SpectralEmbedding(n_components=n_components,
n_neighbors=n_neighbors)
methods['t-SNE'] = manifold.TSNE(n_components=n_components,
init='pca',
random_state=0)
for i, (label, method) in enumerate(methods.items()):
#print(label,method)
if name == label:
return method.fit_transform(X)
assert (0)
def PreprocessingRBM(self, components, MNE_coefficients, N_neighbors):
"""
:type MNE_coefficients: int
:param MNE_coefficients: number of coefficnents for mns projection
:param N_neighbors: number of neighbors for embedding
"""
self.MNE_coefficients = MNE_coefficients
self.N_neighbors = N_neighbors
self.rbm = neural_network.BernoulliRBM(n_components=components,
learning_rate=0.05,
batch_size=10,
n_iter=100,
verbose=0,
random_state=0)
self.Embedding = manifold.SpectralEmbedding(
n_components=self.MNE_coefficients,
affinity='nearest_neighbors',
gamma=None,
random_state=0,
n_neighbors=self.N_neighbors)
self.X_rbm = self.rbm.fit_transform(self.Waves_Coefficients)
self.X_red = self.Embedding.fit_transform(self.X_rbm)
return self.X_red
def apply_lens(df, lens='pca', dist='euclidean', n_dim=2, **kwargs):
"""
input: N x F dataframe of observations
output: N x n_dim image of input data under lens function
"""
if n_dim != 2:
raise 'error: image of data set must be two-dimensional'
if dist not in ['euclidean', 'correlation']:
raise 'error: only euclidean and correlation distance metrics are supported'
if lens == 'pca' and dist != 'euclidean':
raise 'error: PCA requires the use of euclidean distance metric'
if lens == 'pca':
df_lens = pd.DataFrame(
decomposition.PCA(n_components=n_dim, **kwargs).fit_transform(df),
df.index)
elif lens == 'mds':
D = metrics.pairwise.pairwise_distances(df, metric=dist)
df_lens = pd.DataFrame(
manifold.MDS(n_components=n_dim, **kwargs).fit_transform(D),
df.index)
elif lens == 'neighbor':
D = metrics.pairwise.pairwise_distances(df, metric=dist)
df_lens = pd.DataFrame(
manifold.SpectralEmbedding(n_components=n_dim,
**kwargs).fit_transform(D), df.index)
else:
raise 'error: only PCA, MDS, neighborhood lenses are supported'
return df_lens
def get_tensor_embedding(tensor,
method="tsne",
n_dims=2,
n_neigh=30,
**meth_args):
"""
Return a embedding of a tensor (in a lower dimensional space, e.g. t-SNE)
Args:
tensor: Tensor to be embedded
method: Method used for embedding, options are: tsne, standard, ltsa, hessian, modified, isomap, mds,
spectral, umap
n_dims: dimensions to embed the data into
n_neigh: Neighbour parameter to kind of determin the embedding (see t-SNE for more information)
**meth_args: Further arguments which can be passed to the embedding method
Returns:
The embedded tensor
"""
from sklearn import manifold
import umap
linears = ['standard', 'ltsa', 'hessian', 'modified']
if method in linears:
loclin = manifold.LocallyLinearEmbedding(n_neigh,
n_dims,
method=method,
**meth_args)
emb_data = loclin.fit_transform(tensor)
elif method == "isomap":
iso = manifold.Isomap(n_neigh, n_dims, **meth_args)
emb_data = iso.fit_transform(tensor)
elif method == "mds":
mds = manifold.MDS(n_dims, **meth_args)
emb_data = mds.fit_transform(tensor)
elif method == "spectral":
se = manifold.SpectralEmbedding(n_components=n_dims,
n_neighbors=n_neigh,
**meth_args)
emb_data = se.fit_transform(tensor)
elif method == "tsne":
tsne = manifold.TSNE(n_components=n_dims,
perplexity=n_neigh,
**meth_args)
emb_data = tsne.fit_transform(tensor)
elif method == "umap":
um = umap.UMAP(n_components=n_dims, n_neighbors=n_neigh, **meth_args)
emb_data = um.fit_transform(tensor)
else:
emb_data = tensor
return emb_data
def NDR(data,method,dim,n_neighbors=100):
if method == 'standard_LLE':
embedding = manifold.LocallyLinearEmbedding(n_neighbors=n_neighbors,n_components=dim,\
method='standard').fit_transform(data)
elif method == 'hessian_LLE':
embedding = manifold.LocallyLinearEmbedding(n_neighbors=235,n_components=dim,\
method='hessian').fit_transform(data)
elif method == 'ltsa_LLE':
embedding = manifold.LocallyLinearEmbedding(n_neighbors=n_neighbors, n_components=dim,\
method='ltsa').fit_transform(data)
elif method == 'modified_LLE':
embedding = manifold.LocallyLinearEmbedding(n_neighbors=n_neighbors, n_components=dim,\
method='modified').fit_transform(data)
elif method == 'Isomap':
embedding = manifold.Isomap(n_neighbors=n_neighbors, n_components=dim)\
.fit_transform(data)
elif method == 't-SNE':
embedding = manifold.TSNE(n_components=dim, init='pca', random_state=0,method='exact')\
.fit_transform(data)
elif method == 'MDS':
embedding = manifold.MDS(n_components=dim, max_iter=100, n_init=1).fit_transform(data)
elif method == 'Spectral_Embedding':
embedding = manifold.SpectralEmbedding(n_components=dim,n_neighbors=n_neighbors)\
.fit_transform(data)
elif method == 'UMAP':
embedding = umap.UMAP(n_components=dim,n_neighbors=n_neighbors).fit_transform(data)
elif method == 'PCA':
embedding = decomposition.PCA(n_components=dim).fit_transform(data)
return(embedding)
def preform_methods(X, data_name, nsamples, n_components, n_neighbors):
LLE = partial(manifold.LocallyLinearEmbedding,
n_neighbors,
n_components,
eigen_solver='auto')
methods = OrderedDict()
methods['LLE'] = LLE(method='standard')
methods['LE'] = manifold.SpectralEmbedding(n_components=n_components,
n_neighbors=n_neighbors)
methods['Isomap'] = manifold.Isomap(n_neighbors=n_neighbors,
n_components=n_components)
methods['MDS'] = manifold.MDS(n_components=n_components,
max_iter=100,
n_init=1)
k_methods = dict()
k_methods["K_Isomap"] = drm.k_isomap
k_methods["K_LLE"] = drm.k_lle
k_methods["K_LE"] = drm.k_le
k_methods["K_MDS"] = drm.k_mds
for label, method in methods.items():
Y_conv = method.fit_transform(X)
kstr = "K_" + label
Y_k = k_methods[kstr](X, n_components, n_neighbors)
curve_data, area, cname = quality_curve(X, Y_conv, n_neighbors, 'r',
False)
curve_data2, area2, _ = quality_curve(X, Y_k, n_neighbors, 'r', False)
draw_curve(curve_data, area, curve_data2, area2, cname, label,
data_name, n_neighbors)
def PreprocessingSparsePCA(self, PCA_coefficients, MNE_coefficients, N_neighbors):
"""
:type MNE_coefficients: int
:type PCA_coefficients: int
:param MNE_coefficients: number of coefficnents for mns projection
:param PCA_coefficients: number of n_coefficients for PCA transform
:param N_neighbors: number of neighbors for embedding
"""
self.MNE_coefficients = MNE_coefficients
self.PCA_coefficients = PCA_coefficients
self.N_neighbors = N_neighbors
self.pca = decomposition.SparsePCA(n_components=self.PCA_coefficients,
alpha=0.5, ridge_alpha=0.01, max_iter=1000,
tol=1e-06, method='lars',
n_jobs=-1, U_init=None,
V_init=None, verbose=False,
random_state=0)
self.Embedding = manifold.SpectralEmbedding(n_components=self.MNE_coefficients,
affinity='nearest_neighbors',
gamma=None, random_state=0,
n_neighbors=self.N_neighbors)
self.X_pca = self.pca.fit_transform(self.Waves_Coefficients)
self.X_red = self.Embedding.fit_transform(self.X_pca)
return self.X_red
def createHashTag(features, n_hash, n_neis):
print("features:", features.shape)
lapVecs = manifold.SpectralEmbedding(n_components=n_hash, n_neighbors=n_neis).fit_transform(features)
hashbool = lapVecs >= 0
hashtags = hashbool.astype(np.int32)
print("hashtags:", hashtags)
return hashtags
def manifold_learning_transformations(self, X, method, n_components=3):
# Perform Locally Linear Embedding Manifold learning
n_neighbors = 10
trans_data = {}
if method == "Modified LLE":
trans_data = manifold.LocallyLinearEmbedding(
n_neighbors, n_components=n_components,
method="modified").fit_transform(X)
elif method == "LLE":
trans_data = manifold.LocallyLinearEmbedding(
n_neighbors, n_components=n_components,
method="standard").fit_transform(X)
elif method == "mds":
trans_data = manifold.MDS(
n_components=n_components).fit_transform(X)
elif method == "se":
trans_data = manifold.SpectralEmbedding(
n_components=n_components,
n_neighbors=n_neighbors).fit_transform(X)
elif method == "tsne":
trans_data["tsne"] = manifold.TSNE(n_components=n_components,
init='pca',
random_state=0).fit_transform(X)
return trans_data
def perform(self):
spem = skm.SpectralEmbedding(n_components=self.n_components,
affinity=self.affinity,
random_state=self.random_state,
n_neighbors=self.n_neighbors)
transform = spem.fit_transform(self.data)
return transform
def decomposit(X, n_component, mode='pca'):
"""
created by Shaoming, Wang
集成了目前较为流行的降维算法
:param X: 需要降维的多维array
:param n_component: 需要划分成几个部分
:param mode: 选用的降维方法，默认pca降维
:return:
x_result ： 划分后的结果， 是一个降维后的array
"""
if mode == 'pca':
x_result = PCA(n_components=n_component).fit_transform(X)
elif mode == 'mds':
clf = manifold.MDS(n_components=n_component, n_init=1, max_iter=100)
x_result = clf.fit_transform(X)
elif mode == 'spectral':
x_result = manifold.SpectralEmbedding(
n_components=n_component, random_state=0,
eigen_solver='arpack').fit_transform(X)
elif mode == 'tsne':
x_result = manifold.TSNE(n_components=n_component,
init='pca',
random_state=0).fit_transform(X)
return x_result
def spec_phase_plot(df,ptitle,c,sh,lab):
N = 11
se = manifold.SpectralEmbedding(n_components=1,n_neighbors=5)
Y = se.fit_transform(np.mean(scale_df(df).values.reshape(scale_df(df).values.shape[0],-1, 3), axis=2).T)
tpts = [i*2 for i in range(1,Y.shape[0]+1)]
cts = [(i-12)%22 for i in tpts]
newcts= []
ymeans = []
for i in set(cts):
newcts.append(i%22)
ymeans.append(np.mean(Y[[(i%22)==j for j in cts]]))
ymeans = ymeans-np.min(ymeans)
ymeans = list(ymeans/np.max(ymeans))
newcts = list(np.roll(scale_polar(newcts),sh))
ax = plt.subplot(111, polar=True)
ax.set_theta_offset(0.5*np.pi)
ax.set_theta_direction(-1)
ax.set_rlabel_position(245)
ax.set_xticks(np.pi/180. * np.linspace(0, 360, N, endpoint=False))
ax.set_xticklabels([str(i)+' hrs' for i in range(0,2*N+1,2)])
ax.plot(newcts+[newcts[0]],ymeans+[ymeans[0]],color=c,label=lab)
ax.set_rmax(1.0)
plt.title(ptitle, y=1.08, fontsize=16)
plt.legend(frameon=True,framealpha=1.0)
plt.tight_layout()
def embed(Z, ztop, ndim=3):
bsize = ztop.shape[0]
nsamples = ztop.shape[1]
dim = ztop.shape[2]
ztop = ztop.reshape(bsize * nsamples, dim)
Z_all = numpy.concatenate((ztop, Z), axis=0)
# PCA
Z_all_pca = decomposition.PCA(n_components=ndim).fit_transform(Z_all)
ztop_pca = Z_all_pca[0:bsize * nsamples].reshape(bsize, nsamples, ndim)
Z_pca = Z_all_pca[bsize * nsamples:]
ztop_only_pca = decomposition.PCA(n_components=3).fit_transform(ztop)
# Spectral
Z_all_laplacian = manifold.SpectralEmbedding(
n_components=ndim).fit_transform(Z_all)
ztop_laplacian = Z_all_laplacian[0:bsize * nsamples].reshape(
bsize, nsamples, ndim)
Z_laplacian = Z_all_laplacian[bsize * nsamples:]
ztop_only_laplacian = manifold.SpectralEmbedding(
n_components=3).fit_transform(ztop)
# Isomap
Z_all_isomap = manifold.Isomap(n_components=ndim).fit_transform(Z_all)
ztop_isomap = Z_all_isomap[0:bsize * nsamples].reshape(
bsize, nsamples, ndim)
Z_isomap = Z_all_isomap[bsize * nsamples:]
ztop_only_isomap = manifold.Isomap(n_components=3).fit_transform(ztop)
# TSNE
'''
Z_all_tsne = TSNE(n_components=2).fit_transform(Z_all)
ztop_tsne = Z_all_tsne[0:bsize*nsamples].reshape(bsize, nsamples, 2)
Z_tsne = Z_all_tsne[bsize*nsamples:]
'''
# Z_tsne, ztop_tsne = None, None
return {
'Z_pca': Z_pca,
'ztop_pca': ztop_pca,
'Z_laplacian': Z_laplacian,
'ztop_laplacian': ztop_laplacian,
'Z_isomap': Z_isomap,
'ztop_isomap': ztop_isomap,
'ztop_only_pca': ztop_only_pca,
'ztop_only_laplacian': ztop_only_laplacian,
'ztop_only_isomap': ztop_only_isomap
}
