本文整理汇总了Python中sklearn.manifold.Isomap方法的典型用法代码示例。如果您正苦于以下问题:Python manifold.Isomap方法的具体用法?Python manifold.Isomap怎么用?Python manifold.Isomap使用的例子?那么, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类sklearn.manifold
的用法示例。
在下文中一共展示了manifold.Isomap方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: learn_manifold
# 需要导入模块: from sklearn import manifold [as 别名]
# 或者: from sklearn.manifold import Isomap [as 别名]
def learn_manifold(manifold_type, feats, n_components=2):
if manifold_type == 'tsne':
feats_fitted = manifold.TSNE(n_components=n_components, random_state=0).fit_transform(feats)
elif manifold_type == 'isomap':
feats_fitted = manifold.Isomap(n_components=n_components).fit_transform(feats)
elif manifold_type == 'mds':
feats_fitted = manifold.MDS(n_components=n_components).fit_transform(feats)
elif manifold_type == 'spectral':
feats_fitted = manifold.SpectralEmbedding(n_components=n_components).fit_transform(feats)
else:
raise Exception('wrong maniford type!')
# methods = ['standard', 'ltsa', 'hessian', 'modified']
# feats_fitted = manifold.LocallyLinearEmbedding(n_components=n_components, method=methods[0]).fit_transform(pred)
return feats_fitted
示例2: test_skl
# 需要导入模块: from sklearn import manifold [as 别名]
# 或者: from sklearn.manifold import Isomap [as 别名]
def test_skl(self):
tt = nx.generators.complete_graph(25)
ndim = 3
skle = nodevectors.SKLearnEmbedder(
manifold.Isomap,
n_components=ndim,
n_neighbors=3)
skle.fit(tt)
res_v = skle.predict(9)
self.assertTrue(len(res_v) == ndim)
# Test save/load
fname = 'test_saving'
try:
skle.save(fname)
g2v_l = nodevectors.SKLearnEmbedder.load(fname + '.zip')
res_l = g2v_l.predict(9)
self.assertTrue(len(res_l) == ndim)
np.testing.assert_array_almost_equal(res_l, res_v)
finally:
os.remove(fname + '.zip')
示例3: isomap
# 需要导入模块: from sklearn import manifold [as 别名]
# 或者: from sklearn.manifold import Isomap [as 别名]
def isomap(features, n_components=2):
"""
Returns the embedded points for Isomap.
Parameters
----------
features: numpy.ndarray
contains the input feature vectors.
n_components: int
number of components to transform the features into
Returns
-------
embedding: numpy.ndarray
x,y(z) points that the feature vectors have been transformed into
"""
embedding = Isomap(n_components=n_components, n_jobs=-1).fit_transform(features)
return embedding
示例4: test_isomap_simple_grid
# 需要导入模块: from sklearn import manifold [as 别名]
# 或者: from sklearn.manifold import Isomap [as 别名]
def test_isomap_simple_grid():
# Isomap should preserve distances when all neighbors are used
N_per_side = 5
Npts = N_per_side ** 2
n_neighbors = Npts - 1
# grid of equidistant points in 2D, n_components = n_dim
X = np.array(list(product(range(N_per_side), repeat=2)))
# distances from each point to all others
G = neighbors.kneighbors_graph(X, n_neighbors,
mode='distance').toarray()
for eigen_solver in eigen_solvers:
for path_method in path_methods:
clf = manifold.Isomap(n_neighbors=n_neighbors, n_components=2,
eigen_solver=eigen_solver,
path_method=path_method)
clf.fit(X)
G_iso = neighbors.kneighbors_graph(clf.embedding_,
n_neighbors,
mode='distance').toarray()
assert_array_almost_equal(G, G_iso)
示例5: test_transform
# 需要导入模块: from sklearn import manifold [as 别名]
# 或者: from sklearn.manifold import Isomap [as 别名]
def test_transform():
n_samples = 200
n_components = 10
noise_scale = 0.01
# Create S-curve dataset
X, y = datasets.samples_generator.make_s_curve(n_samples, random_state=0)
# Compute isomap embedding
iso = manifold.Isomap(n_components, 2)
X_iso = iso.fit_transform(X)
# Re-embed a noisy version of the points
rng = np.random.RandomState(0)
noise = noise_scale * rng.randn(*X.shape)
X_iso2 = iso.transform(X + noise)
# Make sure the rms error on re-embedding is comparable to noise_scale
assert_less(np.sqrt(np.mean((X_iso - X_iso2) ** 2)), 2 * noise_scale)
示例6: compute_reduced_space
# 需要导入模块: from sklearn import manifold [as 别名]
# 或者: from sklearn.manifold import Isomap [as 别名]
def compute_reduced_space(self):
model = None
model_data = np.asarray([dic_slice.im_M.flatten() for dic_slice in self.slices])
if self.param_model.method == 'pca':
# PCA
model = decomposition.PCA(n_components=self.param_model.k_pca)
self.fitted_data = model.fit_transform(model_data)
if self.param_model.method == 'isomap':
# ISOMAP
n_neighbors = self.param_model.n_neighbors_iso
n_components = int(model_data.shape[0] * self.param_model.n_compo_iso)
model = manifold.Isomap(n_neighbors=n_neighbors, n_components=n_components)
self.fitted_data = model.fit_transform(model_data)
# save model after bing fitted to data
self.fitted_model = model
# ------------------------------------------------------------------------------------------------------------------
示例7: test_isomap_reconstruction_error
# 需要导入模块: from sklearn import manifold [as 别名]
# 或者: from sklearn.manifold import Isomap [as 别名]
def test_isomap_reconstruction_error():
# Same setup as in test_isomap_simple_grid, with an added dimension
N_per_side = 5
Npts = N_per_side ** 2
n_neighbors = Npts - 1
# grid of equidistant points in 2D, n_components = n_dim
X = np.array(list(product(range(N_per_side), repeat=2)))
# add noise in a third dimension
rng = np.random.RandomState(0)
noise = 0.1 * rng.randn(Npts, 1)
X = np.concatenate((X, noise), 1)
# compute input kernel
G = neighbors.kneighbors_graph(X, n_neighbors,
mode='distance').toarray()
centerer = preprocessing.KernelCenterer()
K = centerer.fit_transform(-0.5 * G ** 2)
for eigen_solver in eigen_solvers:
for path_method in path_methods:
clf = manifold.Isomap(n_neighbors=n_neighbors, n_components=2,
eigen_solver=eigen_solver,
path_method=path_method)
clf.fit(X)
# compute output kernel
G_iso = neighbors.kneighbors_graph(clf.embedding_,
n_neighbors,
mode='distance').toarray()
K_iso = centerer.fit_transform(-0.5 * G_iso ** 2)
# make sure error agrees
reconstruction_error = np.linalg.norm(K - K_iso) / Npts
assert_almost_equal(reconstruction_error,
clf.reconstruction_error())
示例8: test_pipeline
# 需要导入模块: from sklearn import manifold [as 别名]
# 或者: from sklearn.manifold import Isomap [as 别名]
def test_pipeline():
# check that Isomap works fine as a transformer in a Pipeline
# only checks that no error is raised.
# TODO check that it actually does something useful
X, y = datasets.make_blobs(random_state=0)
clf = pipeline.Pipeline(
[('isomap', manifold.Isomap()),
('clf', neighbors.KNeighborsClassifier())])
clf.fit(X, y)
assert_less(.9, clf.score(X, y))
示例9: test_isomap_clone_bug
# 需要导入模块: from sklearn import manifold [as 别名]
# 或者: from sklearn.manifold import Isomap [as 别名]
def test_isomap_clone_bug():
# regression test for bug reported in #6062
model = manifold.Isomap()
for n_neighbors in [10, 15, 20]:
model.set_params(n_neighbors=n_neighbors)
model.fit(np.random.rand(50, 2))
assert_equal(model.nbrs_.n_neighbors,
n_neighbors)
示例10: __init__
# 需要导入模块: from sklearn import manifold [as 别名]
# 或者: from sklearn.manifold import Isomap [as 别名]
def __init__(self, param_model=None, param_data=None, param=None):
self.param_model = param_model if param_model is not None else ParamModel()
self.param_data = param_data if param_data is not None else ParamData()
self.param = param if param is not None else Param()
self.slices = [] # list of Slice() : Model dictionary
self.mean_image = None
self.intensities = None
self.fitted_model = None # PCA or Isomap model
self.fitted_data = None
# ------------------------------------------------------------------------------------------------------------------
# FUNCTIONS USED TO COMPUTE THE MODEL
# ------------------------------------------------------------------------------------------------------------------
示例11: test_isomap_with_sklearn
# 需要导入模块: from sklearn import manifold [as 别名]
# 或者: from sklearn.manifold import Isomap [as 别名]
def test_isomap_with_sklearn():
N = 10
X, color = datasets.samples_generator.make_s_curve(N, random_state=0)
n_components = 2
n_neighbors = 3
knn = NearestNeighbors(n_neighbors + 1).fit(X)
# Assign the geometry matrix to get the same answer since sklearn using k-neighbors instead of radius-neighbors
g = geom.Geometry(X)
g.set_adjacency_matrix(knn.kneighbors_graph(X, mode = 'distance'))
# test Isomap with sklearn
sk_Y_iso = manifold.Isomap(n_neighbors, n_components, eigen_solver = 'arpack').fit_transform(X)
mm_Y_iso = iso.isomap(g, n_components)
assert(_check_with_col_sign_flipping(sk_Y_iso, mm_Y_iso, 0.05))
示例12: test_isomap_simple_grid
# 需要导入模块: from sklearn import manifold [as 别名]
# 或者: from sklearn.manifold import Isomap [as 别名]
def test_isomap_simple_grid():
# Isomap should preserve distances when all neighbors are used
N_per_side = 5
Npts = N_per_side ** 2
radius = 10
# grid of equidistant points in 2D, n_components = n_dim
X = np.array(list(product(range(N_per_side), repeat=2)))
# distances from each point to all others
G = squareform(pdist(X))
g = geom.Geometry(adjacency_kwds = {'radius':radius})
for eigen_solver in EIGEN_SOLVERS:
clf = iso.Isomap(n_components = 2, eigen_solver = eigen_solver, geom=g)
clf.fit(X)
G_iso = squareform(pdist(clf.embedding_))
assert_array_almost_equal(G, G_iso)
示例13: test_objectmapper
# 需要导入模块: from sklearn import manifold [as 别名]
# 或者: from sklearn.manifold import Isomap [as 别名]
def test_objectmapper(self):
df = pdml.ModelFrame([])
self.assertIs(df.manifold.LocallyLinearEmbedding,
manifold.LocallyLinearEmbedding)
self.assertIs(df.manifold.Isomap, manifold.Isomap)
self.assertIs(df.manifold.MDS, manifold.MDS)
self.assertIs(df.manifold.SpectralEmbedding, manifold.SpectralEmbedding)
self.assertIs(df.manifold.TSNE, manifold.TSNE)
示例14: see_iso_map
# 需要导入模块: from sklearn import manifold [as 别名]
# 或者: from sklearn.manifold import Isomap [as 别名]
def see_iso_map(bottlenecks, labels, suptitle=None):
"""
:param bottlenecks:
:param labels:
:param suptitle: String to add as plot suptitles
:return: Nothing, will just plot a scatter plot to show the distribution of our data after dimensionality reduction.
"""
n_samples, n_features = bottlenecks.shape
n_neighbors = 25
n_components = 2
start_index_outlier = np.where(labels == 1)[0][0]
alpha_inlier = 0.25
B_iso = manifold.Isomap(n_neighbors, n_components).fit_transform(bottlenecks)
B_pca = decomposition.TruncatedSVD(n_components=2).fit_transform(bottlenecks)
B_lle = manifold.LocallyLinearEmbedding(n_neighbors, n_components, method='standard').fit_transform(bottlenecks)
B_spec = manifold.SpectralEmbedding(n_components=n_components, random_state=42,
eigen_solver='arpack').fit_transform(bottlenecks)
plt.figure()
plt.subplot(221)
plt.scatter(B_iso[:start_index_outlier, 0], B_iso[:start_index_outlier, 1], marker='o', c='b', alpha=alpha_inlier)
plt.scatter(B_iso[start_index_outlier:, 0], B_iso[start_index_outlier:, 1], marker='^', c='k')
plt.title("Isomap projection")
plt.subplot(222)
inlier_scatter = plt.scatter(B_lle[:start_index_outlier, 0], B_lle[:start_index_outlier, 1], marker='o', c='b',
alpha=alpha_inlier)
outlier_scatter = plt.scatter(B_lle[start_index_outlier:, 0], B_lle[start_index_outlier:, 1], marker='^', c='k')
plt.legend([inlier_scatter, outlier_scatter], ['Inliers', 'Outliers'], loc='lower left')
plt.title("Locally Linear Embedding")
plt.subplot(223)
plt.scatter(B_pca[:start_index_outlier, 0], B_pca[:start_index_outlier, 1], marker='o', c='b', alpha=alpha_inlier)
plt.scatter(B_pca[start_index_outlier:, 0], B_pca[start_index_outlier:, 1], marker='^', c='k')
plt.title("Principal Components projection")
plt.subplot(224)
plt.scatter(B_spec[:start_index_outlier, 0], B_spec[:start_index_outlier, 1], marker='o', c='b', alpha=alpha_inlier)
plt.scatter(B_spec[start_index_outlier:, 0], B_spec[start_index_outlier:, 1], marker='^', c='k')
plt.title("Spectral embedding")
if suptitle:
plt.suptitle(suptitle)
示例15: create_isomap_features
# 需要导入模块: from sklearn import manifold [as 别名]
# 或者: from sklearn.manifold import Isomap [as 别名]
def create_isomap_features(features, model):
r"""Create Isomap features.
Parameters
----------
features : numpy array
The input features.
model : alphapy.Model
The model object with the Isomap parameters.
Returns
-------
ifeatures : numpy array
The Isomap features.
inames : list
The Isomap feature names.
Notes
-----
Isomaps are very memory-intensive. Your process will be killed
if you run out of memory.
References
----------
You can find more information on Principal Component Analysis here [ISO]_.
.. [ISO] http://scikit-learn.org/stable/modules/manifold.html#isomap
"""
logger.info("Creating Isomap Features")
# Extract model parameters
iso_components = model.specs['iso_components']
iso_neighbors = model.specs['iso_neighbors']
n_jobs = model.specs['n_jobs']
# Log model parameters
logger.info("Isomap Components : %d", iso_components)
logger.info("Isomap Neighbors : %d", iso_neighbors)
# Generate Isomap features
model = Isomap(n_neighbors=iso_neighbors, n_components=iso_components,
n_jobs=n_jobs)
ifeatures = model.fit_transform(features)
inames = [USEP.join(['isomap', str(i+1)]) for i in range(iso_components)]
# Return new Isomap features
logger.info("Isomap Feature Count : %d", ifeatures.shape[1])
return ifeatures, inames
#
# Function create_tsne_features
#