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 }