我们从Python开源项目中，提取了以下15个代码示例，用于说明如何使用sklearn.manifold.Isomap()。
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)
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)
def outofsample_extensions(method='linear-regression'): # Load the data and init seeds train_data, train_labels, test_data, test_labels = load_mnist() np.random.seed(1) sklearn.utils.check_random_state(1) n_train_samples = 5000 # Learn a new space using Isomap isomap = Isomap(n_components=10, n_neighbors=20) train_data_isomap = np.float32(isomap.fit_transform(train_data[:n_train_samples, :])) if method == 'linear-regression': # Use linear regression to provide baseline out-of-sample extensions proj = LinearRegression() proj.fit(np.float64(train_data[:n_train_samples, :]), np.float64(train_data_isomap)) acc = evaluate_svm(proj.predict(train_data[:n_train_samples, :]), train_labels[:n_train_samples], proj.predict(test_data), test_labels) elif method == 'c-ISOMAP-10d' or method == 'c-ISOMAP-20d': # Use the SEF to provide out-of-sample extensions if method == 'c-ISOMAP-10d': proj = LinearSEF(train_data.shape[1], output_dimensionality=10) proj.cuda() else: proj = LinearSEF(train_data.shape[1], output_dimensionality=20) proj.cuda() loss = proj.fit(data=train_data[:n_train_samples, :], target_data=train_data_isomap, target='copy', epochs=50, batch_size=128, verbose=True, learning_rate=0.001, regularizer_weight=1) acc = evaluate_svm(proj.transform(train_data[:n_train_samples, :]), train_labels[:n_train_samples], proj.transform(test_data), test_labels) print("Method: ", method, " Test accuracy: ", 100 * acc, " %")
def outofsample_extensions(method='kernel-regression'): # Load the data and init seeds train_data, train_labels, test_data, test_labels = load_mnist() np.random.seed(1) sklearn.utils.check_random_state(1) n_train_samples = 5000 # Learn a new space using Isomap isomap = Isomap(n_components=10, n_neighbors=20) train_data_isomap = np.float32(isomap.fit_transform(train_data[:n_train_samples, :])) sigma = mean_data_distance(np.float32(train_data[:n_train_samples, :])) if method == 'kernel-regression': # Use kernel regression to provide baseline out-of-sample extensions proj = KernelRidge(kernel='rbf', gamma=(1.0 / sigma ** 2)) proj.fit(np.float64(train_data[:n_train_samples, :]), np.float64(train_data_isomap)) acc = evaluate_svm(proj.predict(train_data[:n_train_samples, :]), train_labels[:n_train_samples], proj.predict(test_data), test_labels) elif method == 'cK-ISOMAP-10d' or method == 'cK-ISOMAP-20d': # Use the SEF to provide out-of-sample extensions if method == 'cK-ISOMAP-10d': dims = 10 else: dims = 20 proj = KernelSEF(train_data[:n_train_samples], train_data.shape[1], output_dimensionality=dims) proj.cuda() loss = proj.fit(data=train_data[:n_train_samples, :], target_data=train_data_isomap, target='copy', epochs=100, batch_size=128, verbose=True, learning_rate=0.00001, regularizer_weight=0.001) acc = evaluate_svm(proj.transform(train_data[:n_train_samples, :]), train_labels[:n_train_samples], proj.transform(test_data), test_labels) print("Method: ", method, " Test accuracy: ", 100 * acc, " %")
def outofsample_extensions(method=None, dataset=None): np.random.seed(1) sklearn.utils.check_random_state(1) train_data, train_labels, test_data, test_labels = dataset_loader(dataset, seed=1) # Learn a new space using Isomap isomap = Isomap(n_components=10, n_neighbors=20) train_data_isomap = np.float32(isomap.fit_transform(train_data)) if method == 'linear-regression': from sklearn.preprocessing import StandardScaler std = StandardScaler() train_data = std.fit_transform(train_data) test_data = std.transform(test_data) # Use linear regression to provide baseline out-of-sample extensions proj = LinearRegression() proj.fit(np.float64(train_data), np.float64(train_data_isomap)) acc = evaluate_svm(proj.predict(train_data), train_labels, proj.predict(test_data), test_labels) elif method == 'c-ISOMAP-10d' or method == 'c-ISOMAP-20d': # Use the SEF to provide out-of-sample extensions if method == 'c-ISOMAP-10d': proj = LinearSEF(train_data.shape[1], output_dimensionality=10) proj.cuda() else: proj = LinearSEF(train_data.shape[1], output_dimensionality=20) proj.cuda() loss = proj.fit(data=train_data, target_data=train_data_isomap, target='copy', epochs=50, batch_size=1024, verbose=False, learning_rate=0.001, regularizer_weight=1) acc = evaluate_svm(proj.transform(train_data), train_labels, proj.transform(test_data), test_labels) print("Method: ", method, " Test accuracy: ", 100 * acc, " %")
def outofsample_extensions(method=None, dataset=None): np.random.seed(1) sklearn.utils.check_random_state(1) train_data, train_labels, test_data, test_labels = dataset_loader(dataset, seed=1) # Learn a new space using Isomap isomap = Isomap(n_components=10, n_neighbors=20) train_data_isomap = np.float32(isomap.fit_transform(train_data)) sigma = mean_data_distance(np.float32(train_data)) if method == 'kernel-regression': # Use kernel regression to provide baseline out-of-sample extensions proj = KernelRidge(kernel='rbf', gamma=(1.0 / sigma ** 2)) proj.fit(np.float64(train_data), np.float64(train_data_isomap)) acc = evaluate_svm(proj.predict(train_data), train_labels, proj.predict(test_data), test_labels) elif method == 'cK-ISOMAP-10d' or method == 'cK-ISOMAP-20d': # Use the SEF to provide out-of-sample extensions if method == 'cK-ISOMAP-10d': dims = 10 else: dims = 20 proj = KernelSEF(train_data, train_data.shape[1], output_dimensionality=dims) proj.cuda() loss = proj.fit(data=train_data, target_data=train_data_isomap, target='copy', epochs=100, batch_size=256, verbose=True, learning_rate=0.00001, regularizer_weight=0.001) acc = evaluate_svm(proj.transform(train_data), train_labels, proj.transform(test_data), test_labels) print("Method: ", method, " Test accuracy: ", 100 * acc, " %")
def do_embedding(self, event=None): converted = self.parent.converted if converted is None: #self.conversion.convert_frames() self.parent.converted = np.load(self.parent.output_folder+'/converted.npy') #FIXME For debugging converted = self.parent.converted method_ind = self.method.currentIndex() print('Doing %s' % self.method.currentText()) if method_ind == 0: self.embedder = manifold.SpectralEmbedding(n_components=4, n_jobs=-1) elif method_ind == 1: self.embedder = manifold.Isomap(n_components=4, n_jobs=-1) elif method_ind == 2: self.embedder = manifold.LocallyLinearEmbedding(n_components=4, n_jobs=-1, n_neighbors=20, method='modified') elif method_ind == 3: self.embedder = manifold.LocallyLinearEmbedding(n_components=4, n_jobs=-1, n_neighbors=20, method='hessian', eigen_solver='dense') elif method_ind == 4: self.embedder = manifold.MDS(n_components=4, n_jobs=-1) elif method_ind == 5: self.embedder = manifold.TSNE(n_components=3, init='pca') self.embedder.fit(converted) self.embed = self.embedder.embedding_ self.embed_plot = self.embed self.gen_hist() self.plot_embedding() if not self.embedded: self.add_classes_frame() self.embedded = True
def test_Isomap(*data): ''' test Isomap method :param data: train_data, train_value :return: None ''' X,y=data for n in [4,3,2,1]: isomap=manifold.Isomap(n_components=n) isomap.fit(X) print('reconstruction_error(n_components=%d) : %s'% (n, isomap.reconstruction_error()))
def plot_Isomap_k(*data): ''' test the performance with different n_neighbors and reduce to 2-D :param data: train_data, train_value :return: None ''' X,y=data Ks=[1,5,25,y.size-1] fig=plt.figure() for i, k in enumerate(Ks): isomap=manifold.Isomap(n_components=2,n_neighbors=k) X_r=isomap.fit_transform(X) ax=fig.add_subplot(2,2,i+1) colors=((1,0,0),(0,1,0),(0,0,1),(0.5,0.5,0),(0,0.5,0.5),(0.5,0,0.5), (0.4,0.6,0),(0.6,0.4,0),(0,0.6,0.4),(0.5,0.3,0.2),) for label ,color in zip( np.unique(y),colors): position=y==label ax.scatter(X_r[position,0],X_r[position,1],label="target= {0}" .format(label),color=color) ax.set_xlabel("X[0]") ax.set_ylabel("X[1]") ax.legend(loc="best") ax.set_title("k={0}".format(k)) plt.suptitle("Isomap") plt.show()
def plot_Isomap_k_d1(*data): ''' test the performance with different n_neighbors and reduce to 1-D :param data: train_data, train_value :return: None ''' X,y=data Ks=[1,5,25,y.size-1] fig=plt.figure() for i, k in enumerate(Ks): isomap=manifold.Isomap(n_components=1,n_neighbors=k) X_r=isomap.fit_transform(X) ax=fig.add_subplot(2,2,i+1) colors=((1,0,0),(0,1,0),(0,0,1),(0.5,0.5,0),(0,0.5,0.5),(0.5,0,0.5), (0.4,0.6,0),(0.6,0.4,0),(0,0.6,0.4),(0.5,0.3,0.2),) for label ,color in zip( np.unique(y),colors): position=y==label ax.scatter(X_r[position],np.zeros_like(X_r[position]), label="target= {0}".format(label),color=color) ax.set_xlabel("X") ax.set_ylabel("Y") ax.legend(loc="best") ax.set_title("k={0}".format(k)) plt.suptitle("Isomap") plt.show()
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())
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))
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)
def init_UI(self): self.vbox = QtWidgets.QVBoxLayout(self) #label = QtWidgets.QLabel('Spectral manifold embedding', self) #self.vbox.addWidget(label) self.method = QtWidgets.QComboBox(self) self.vbox.addWidget(self.method) self.method.addItem('Spectral Embedding') self.method.addItem('Isomap') self.method.addItem('Modified LLE') self.method.addItem('Hessian LLE') self.method.addItem('Multi-dimensional Scaling') self.method.addItem('t-Stochastic Neighbor Embedding') hbox = QtWidgets.QHBoxLayout() self.vbox.addLayout(hbox) button = QtWidgets.QPushButton('Embed', self) button.clicked.connect(self.do_embedding) hbox.addWidget(button) self.track_flag = QtWidgets.QCheckBox('Draw ROI', self) self.track_flag.setChecked(False) self.track_flag.stateChanged.connect(self.track_flag_changed) hbox.addWidget(self.track_flag) hbox.addStretch(1) hbox = QtWidgets.QHBoxLayout() self.vbox.addLayout(hbox) label = QtWidgets.QLabel('X-axis:', self) hbox.addWidget(label) self.x_axis_num = QtWidgets.QLineEdit('0', self) self.x_axis_num.setFixedWidth(24) self.x_axis_num.editingFinished.connect(self.gen_hist) hbox.addWidget(self.x_axis_num) label = QtWidgets.QLabel('Y-axis:', self) hbox.addWidget(label) self.y_axis_num = QtWidgets.QLineEdit('1', self) self.y_axis_num.setFixedWidth(24) self.y_axis_num.editingFinished.connect(self.gen_hist) hbox.addWidget(self.y_axis_num) hbox.addStretch(1) self.vbox.addStretch(1)
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. 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) # Return new Isomap features logger.info("Isomap Feature Count : %d", ifeatures.shape[1]) return ifeatures # # Function create_tsne_features #
