def myIsomap(X,y):
t1 = clock()
n_neighbors = 30
clf = manifold.Isomap(n_neighbors, n_components=2)
clf.fit(X)
newRep = clf.transform(X)
t2 = clock()
return t2-t1
def dimensionality_reduce(X, y):
logging.info("Computing Isomap embedding")
t0 = time()
X_iso = manifold.Isomap(n_neighbors, n_components=2).fit_transform(X)
#print("Done.")
plot_embedding_2d(
X_iso, y,
"Isomap projection of the doc2vec (time %.2fs)" % (time() - t0))
def run_isomap(*data):
x, y = data
for n in [4, 3, 2, 1]:
print("-" * 50)
isomap = manifold.Isomap(n_components=n)
print("训练模型")
isomap.fit(x)
print("重构误差：", (n, str(isomap.reconstruction_error())))
def test_pipeline():
# check that Isomap works fine as a transformer in a Pipeline
iris = datasets.load_iris()
clf = pipeline.Pipeline([('isomap', manifold.Isomap()),
('neighbors_clf',
neighbors.KNeighborsClassifier())])
clf.fit(iris.data, iris.target)
assert_lower(.7, clf.score(iris.data, iris.target))
def trainAndSaveIsomap(self, filename="isomap_model"):
all_xs, all_ys = self.getXY("xs", "ys")
im = manifold.Isomap(self.knn, self.isomap_dimension, n_jobs=-1)
im = im.fit(all_xs)
pickle.dump(im, open(filename, "wb"))
return im
def run_all_methods_for_some_dimensions(target_dim, exp_images, exp_labels,
n_samples, initial_dim):
methods_l = [
('MDS (proposed)',
multidimensional.mds.MDS(target_dim,
point_filter,
radius_update,
starting_radius=starting_radius,
radius_barrier=radius_barrier,
max_turns=max_turns,
explore_dim_percent=explore_dim_percent,
keep_history=False,
history_color=None,
history_path=None,
dissimilarities='euclidean')),
('Truncated SVD', decomposition.TruncatedSVD(n_components=target_dim)),
('LLE',
manifold.LocallyLinearEmbedding(method_n_comp,
target_dim,
eigen_solver='auto',
method='standard',
n_jobs=8)),
('Isomap', manifold.Isomap(method_n_comp, target_dim)),
('ModifiedLLE',
manifold.LocallyLinearEmbedding(method_n_comp,
target_dim,
eigen_solver='auto',
method='modified',
n_jobs=8)),
('SpectralEmbedding',
manifold.SpectralEmbedding(n_components=target_dim,
n_neighbors=method_n_comp,
n_jobs=8)),
# ('tSNE',
# manifold.TSNE(n_components=target_dim,
# init='pca', random_state=0)),
('LTSA',
manifold.LocallyLinearEmbedding(method_n_comp,
target_dim,
eigen_solver='auto',
method='ltsa',
n_jobs=8)),
('MDS SMACOF',
manifold.MDS(n_components=target_dim,
n_init=1,
max_iter=max_turns,
verbose=2,
dissimilarity='euclidean')),
]
results = {}
for m_name, m_func in methods_l:
res = safe_run_experiment(target_dim, exp_images, exp_labels,
n_samples, initial_dim, m_name, m_func)
results[m_name] = res
return results
def isomap(X, **kargs):
# import matplotlib.cm as cm
n_neighbors = 10
n_components = 2
y = kargs.get('y', None)
# ulabels = labels = y = kargs.get('y', None)
# n_labels = X.shape[0]
# if labels is not None:
# ulabels = set(labels)
# n_labels = len(ulabels)
t0 = time()
X_proj = Y = manifold.Isomap(n_neighbors, n_components).fit_transform(X)
t1 = time()
print("Isomap: %.2g sec" % (t1 - t0))
outputdir = kargs.get('outputdir', os.path.join(os.getcwd(), 'plot'))
if not os.path.exists(outputdir): os.makedirs(outputdir) # base directory
plot_mode = kargs.get('graph_mode', 'seaborn')
fpath = os.path.join(TestDir, name_image_file(
descriptor='isomap', **kargs)) # kargs: seq_ptype, d2v_method
if plot_mode.startswith('s'):
scatter2(X_proj, y)
plt.savefig(fpath, dpi=300)
else:
# [params] colors
n_points = X.shape[0]
colors = itertools.cycle(cm.rainbow(np.linspace(0, 1, n_points)))
# for i, c in enumerate(itertools.cycle(cm.rainbow(np.linspace(0, 1, n_points)))):
# for i, c in enumerate(itertools.cycle(["r", "b", "g"])):
lcmap = {
0: 'g',
1: 'b',
2: 'r',
}
colors = (lcmap[l] for l in y) # loop through y
fig = plt.figure(figsize=(15, 8))
ax = fig.add_subplot(257)
plt.scatter(X_proj[:, 0],
X_proj[:, 1],
c=next(colors),
cmap=plt.cm.Spectral) #
plt.title("Isomap (%.2g sec)" % (t1 - t0))
ax.xaxis.set_major_formatter(NullFormatter())
ax.yaxis.set_major_formatter(NullFormatter())
plt.axis('tight')
plt.savefig(fpath, dpi=300)
plt.close()
return X_proj
def dimensionality_analysis_plot(df_orig,
labels=[],
method="PCA",
n_components=2,
n_neighbors=10,
figsize=(7, 7),
font_scale=2,
return_df=False):
# Define valid methods
valid_methods = [
"PCA",
"T-SNE",
"Isomap",
"MDS",
"SE",
"LLE",
"Modified LLE",
]
if method not in valid_methods:
print(method, "not a valid method. Available methods:\n",
valid_methods)
# Load libraries
from sklearn import manifold
from functools import partial
LLE = partial(manifold.LocallyLinearEmbedding,
n_neighbors,
n_components,
eigen_solver='auto')
# Extract data from method
if method == "PCA":
Y = PCA_analysis(df_orig, n_components)
elif method == "T-SNE":
model = manifold.TSNE(n_components=n_components,
init='pca',
random_state=0)
Y = model.fit_transform(df_orig)
elif method == "LLE":
model = LLE(method='standard')
Y = model.fit_transform(df_orig)
elif method == "Modified LLE":
model = LLE(method='modified')
Y = model.fit_transform(df_orig)
elif method == "Isomap":
model = manifold.Isomap(n_neighbors, n_components)
Y = model.fit_transform(df_orig)
elif method == "MDS":
model = manifold.MDS(n_components, max_iter=100, n_init=1)
Y = model.fit_transform(df_orig)
elif method == "SE":
model = manifold.SpectralEmbedding(n_components=n_components,
n_neighbors=n_neighbors)
Y = model.fit_transform(df_orig)
#Plot
plot_scatter_labels(Y, method, labels)
def isomap(self, n_components=2, solver='auto'):
print('Calculating isomap....\n')
t = time.time()
iso = manifold.Isomap(n_neighbors=self.n_neighbors,
n_components=n_components,
eigen_solver=solver)
iso_array = iso.fit_transform(self.X)
#plot2D(iso_array,self.y,'isomap','Isomap: 1078 cells with 10 subtypes',time.time() - t)
return iso_array
def isomap_projection():
print("Computing Isomap projection")
t0 = time()
X_iso = manifold.Isomap(n_neighbors, n_components=2).fit_transform(X)
print("Done.")
plot_embedding(X_iso,
"Isomap projection of the digits (time %.2fs)" %
(time() - t0))
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 isomap(input,finaldim):
from sklearn import manifold
import numpy
if isinstance(input,numpy.ndarray)==False:
input= input.todense()
im= manifold.Isomap(n_neighbors=max(3,int(input.shape[0]/160)), n_components=finaldim, n_jobs=-1)
trans=im.fit_transform(input)
# return trans,np.asarray(np.asmatrix(input)*np.asmatrix(trans))
return [],trans
def _make_datasets():
high_data, color \
= datasets.samples_generator.make_swiss_roll(n_samples=300,
random_state=1)
isomap = manifold.Isomap(n_neighbors=12, n_components=2)
low_data = isomap.fit_transform(high_data)
return high_data, low_data
def test_get_feature_names_out():
"""Check get_feature_names_out for Isomap."""
X, y = make_blobs(random_state=0, n_features=4)
n_components = 2
iso = manifold.Isomap(n_components=n_components)
iso.fit_transform(X)
names = iso.get_feature_names_out()
assert_array_equal([f"isomap{i}" for i in range(n_components)], names)
def test_isomap_raise_error_when_neighbor_and_radius_both_set():
# Isomap.fit_transform must raise a ValueError if
# radius and n_neighbors are provided.
X, _ = datasets.load_digits(return_X_y=True)
isomap = manifold.Isomap(n_neighbors=3, radius=5.5)
msg = "Both n_neighbors and radius are provided"
with pytest.raises(ValueError, match=msg):
isomap.fit_transform(X)
def getIsomapGdist(data, num_neigh):
# need to do this because reticulate stupidly converts integers to floats, and then complains about it
num_neigh = int(num_neigh)
embedding = manifold.Isomap(n_neighbors=num_neigh)
embedding.fit_transform(data)
gdist = embedding.dist_matrix_
return gdist
def isomap1(data, n, k):
X = data.T
isomap = manifold.Isomap(n_neighbors=k,
n_components=n,
eigen_solver='auto',
path_method='FW',
neighbors_algorithm='auto')
isomap.fit(X)
X_r = isomap.fit_transform(X)
return X_r
def __init__(self, data, control_points, parent):
super(ISO, self).__init__(data, control_points, parent)
self.name = "ISO"
try:
self.w = PopupSlider(
'Enter number of neighbors to consider (default is 4):')
self.w.exec_()
num = int(self.w.slider_value)
if num == '':
num = 4
try:
iso = manifold.Isomap(n_neighbors=int(num), out_dim=2)
except:
iso = manifold.Isomap(n_neighbors=int(num), n_components=2)
iso.fit(data)
self.embedding = np.array(iso.transform(data))
except:
msg = "It seems like the embedding algorithm did not converge with the given parameter setting"
QMessageBox.about(parent, "Embedding error", msg)
def test_sparse_input():
X = sparse_rand(100, 3, density=0.1, format='csr')
# Should not error
for eigen_solver in eigen_solvers:
for path_method in path_methods:
clf = manifold.Isomap(n_components=2,
eigen_solver=eigen_solver,
path_method=path_method)
clf.fit(X)
def computeEmbedding(weights, embed_type):
if embed_type == 'mds':
mds = manifold.MDS(2, max_iter=100, n_init=1)
Y = mds.fit_transform(weights)
elif embed_type == 'tsne':
tsne = manifold.TSNE(n_components=2, init='pca', random_state=0)
Y = tsne.fit_transform(weights)
elif embed_type == 'isomap':
Y = manifold.Isomap(kNeiborSize, 2).fit_transform(weights)
elif embed_type == 'spectral':
se = manifold.SpectralEmbedding(n_components=2,
n_neighbors=kNeiborSize)
Y = se.fit_transform(weights)
elif embed_type == 'pca':
Y = PCA(n_components=2).fit_transform(weights)
else:
Y = manifold.Isomap(kNeiborSize, 2).fit_transform(weights)
pos = zip(Y[:, 0], Y[:, 1])
return pos
def test_Isomap(*data):
"""
测试等度量映射降维
"""
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 compute_geodesic_coordinates(self, euclid_coords):
"""Use the isomap algorithm (Tenenbaum et al., 2000, Science) to convert euclidean coordinates to geodesic.
:return:
"""
iso = manifold.Isomap(n_neighbors=4, path_method='FW')
iso.fit(euclid_coords)
geo_coords = iso.transform(euclid_coords)
geo_coords = pd.DataFrame(geo_coords, columns=['GeoX', 'GeoY'])
return geo_coords
def isomap(X, dim=2, n_neighbors=30, **kargs):
'''Isomap projection of the dataset'''
print("Computing Isomap embedding")
try:
isomap = manifold.Isomap(n_neighbors, n_components=dim)
X_iso = isomap.fit_transform(X)
print("Done.")
return isomap, X_iso, "Isomap projection of the features"
except Exception as e:
traceback.print_exc()
def test_isomap_fit_precomputed_radius_graph():
# Isomap.fit_transform must yield similar result when using
# a precomputed distance matrix.
X, y = datasets.make_s_curve(200, random_state=0)
radius = 10
g = neighbors.radius_neighbors_graph(X, radius=radius, mode="distance")
isomap = manifold.Isomap(n_neighbors=None,
radius=radius,
metric="precomputed")
isomap.fit(g)
precomputed_result = isomap.embedding_
isomap = manifold.Isomap(n_neighbors=None,
radius=radius,
metric="minkowski")
result = isomap.fit_transform(X)
assert_allclose(precomputed_result, result)
def plot_tsne(epoch, data1, mname):
if not os.path.isdir('./results/' + mname):
os.mkdir('./results/' + mname)
data = []
for i in range(1500):
image = data1[i]
# image = binary.findGoldMask(image)
data.append(image.flatten())
class_list = np.load('./data/test_namelist.npy')
data_binary = np.array(data)
class_list = np.array(class_list) + 1
##Binary
# starting manifold embedding
n_neighbors = 25
n_components = 2
SNR = 0.05
colors_jet = ['k', 'r', 'g', 'b', 'y']
method = 't-SNE'
t0 = time()
Y = manifold.TSNE(n_components=n_components).fit_transform(data_binary)
print(Y.shape)
np.savetxt('./results/'+ mname + "/epoch_%d_denoise_SNR_%f_images_%s_%dNN_%d_component_eigs" % (epoch, SNR, method, n_neighbors, n_components), Y)
t1 = time()
print(" t-SNE: %.2g sec" % (t1 - t0))
fig = plt.figure(figsize=(15, 15))
ax = fig.gca()
for i in range(1, 6): # because the list id is from 1,five conformations
index = np.where(class_list == i)[0]
plt.scatter(Y[index, 0], Y[index, 1], label="state %d" % i, color=colors_jet[i - 1], s=30)
plt.title(" t-SNE (%.2g sec)" % (t1 - t0))
plt.savefig(
"./results/"+ mname + "/epoch_%d_denoise_SNR_%f_images_%s_%dNN_%d_component.png" % (epoch, SNR, method, n_neighbors, n_components))
plt.close()
method = 'ISOMAP'
t0 = time()
Y = manifold.Isomap(n_neighbors=n_neighbors, n_components=n_components).fit_transform(data_binary)
print(np.shape(Y))
np.savetxt('./results/'+ mname + '/epoch_%d_denoise_SNR_%f_images_%s_%dNN_%d_component_eigs' % (epoch, SNR, method, n_neighbors, n_components), Y)
t1 = time()
print("Isomap: %.2g sec" % (t1 - t0))
fig = plt.figure(figsize=(15, 15))
ax = fig.gca()
# plt.scatter(Y[:, 0], Y[:, 1], cmap=plt.cm.Spectral)
for i in range(1, 6): # because the list id is from 1,five conformations
index = np.where(class_list == i)[0]
plt.scatter(Y[index, 0], Y[index, 1], label="state %d" % i, color=colors_jet[i - 1], s=30)
plt.title("Isomap (%.2g sec)" % (t1 - t0))
plt.savefig(
"./results/"+ mname + "/epoch_%d_denoise_SNR_%f_images_%s_%dNN_%d_component.png" % (
epoch, SNR, method, n_neighbors, n_components))
plt.close()
def cross_validation_with_and_without_manifold(X, y, n_neighbors, n_components, k):
# Split indexes according to Kfold with k = 10
kf = KFold(n_splits=k)
# initialize scores lists
scores = []
scores2 = []
for train_index, test_index in kf.split(X):
kernel = GraphKernel(kernel={"name": "shortest_path", "with_labels": False}, normalize=True)
# split train and test of K-fold
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]
# Calculate the kernel matrix.
K_train = kernel.fit_transform(X_train)
K_test = kernel.transform(X_test)
# Initialise an SVM and fit.
clf = svm.SVC(kernel='precomputed', C=4)
clf.fit(K_train, y_train)
# Predict and test.
y_pred = clf.predict(K_test)
# Calculate accuracy of classification.
acc = accuracy_score(y_test, y_pred)
scores.append(acc)
# Compute distance matrix
D_train = compute_distance_matrix(K_train)
D_test = compute_distance_matrix(K_test)
# Initialize Isomap embedding object, embed train and test data
embedding = manifold.Isomap(n_neighbors, n_components, metric="precomputed")
E_train = embedding.fit_transform(D_train)
E_test = embedding.transform(D_test)
# initialize second svm (not necessary? search documentation)
clf2 = svm.SVC(kernel='linear', C=4)
clf2.fit(E_train, y_train)
# Predict and test.
y_pred = clf2.predict(E_test)
# Calculate accuracy of classification.
acc = accuracy_score(y_test, y_pred)
scores2.append(acc)
for i, _ in enumerate(scores):
scores[i] = scores[i] * 100
for i, _ in enumerate(scores2):
scores2[i] = scores2[i] * 100
return scores, scores2
def isomap(data, labels, new_dimension):
print "isomap..."
if hasattr(data, "toarray"):
data = data.toarray()
start = time.time()
iso = manifold.Isomap(n_components=new_dimension)
reduced = iso.fit_transform(data)
end = time.time()
return (reduced, end-start)
def plot_isomap(X, y, n_neighbors):
"""
Isomap projection of the digits dataset
"""
print("Computing Isomap embedding")
t0 = time()
X_iso = manifold.Isomap(n_neighbors, n_components=2).fit_transform(X)
print("Done.")
plot_embedding(X_iso, y,
"Isomap projection of the digits (time %.2fs)" %
(time() - t0))
def plot(self, dim_reduction_strategy='PCA', kernel='linear'):
"""
Plot the result of the fiting
"""
whole_space = np.append(self._training_set._ip_feature_array, self._testing_set._ip_feature_array, axis=0)
whole_target = np.append(self._training_set._target, self._testing_set._target, axis=0)
if dim_reduction_strategy == 'PCA':
# change randomizedPCA to PCA
# dim_reducer = decomposition.RandomizedPCA(n_components=2)
dim_reducer = decomposition.PCA(n_components=2)
elif dim_reduction_strategy == 'Isomap':
n_neighbors = 30
dim_reducer = manifold.Isomap(n_neighbors, n_components=2)
elif dim_reduction_strategy == 'MDS':
dim_reducer = manifold.MDS(n_components=2, n_init=1, max_iter=100)
dim_reducer.fit(whole_space)
reduced_train_spc = dim_reducer.transform(self._training_set._ip_feature_array)
reduced_test_spc = dim_reducer.transform(self._testing_set._ip_feature_array)
reduced_whole_space = np.append(reduced_train_spc, reduced_test_spc, axis=0)
clf = svm.SVC(kernel=str(kernel), gamma=10)
clf.fit(reduced_train_spc, self._training_set._target)
pl.figure(0)
pl.clf()
pl.scatter(reduced_whole_space[:, 0], reduced_whole_space[:, 1], c=whole_target, zorder=10, cmap=pl.cm.Paired)
# Circle out the test data
pl.scatter(reduced_test_spc[:, 0], reduced_test_spc[:, 1],
s=80, facecolors='none', zorder=10)
pl.axis('tight')
x_min = reduced_whole_space[:, 0].min()
x_max = reduced_whole_space[:, 0].max()
y_min = reduced_whole_space[:, 1].min()
y_max = reduced_whole_space[:, 1].max()
XX, YY = np.mgrid[x_min:x_max:200j, y_min:y_max:200j]
Z = clf.decision_function(np.c_[XX.ravel(), YY.ravel()])
# Put the result into a color plot
Z = Z.reshape(XX.shape)
pl.pcolormesh(XX, YY, Z > 0, cmap=pl.cm.Paired)
pl.contour(XX, YY, Z, colors=['k', 'k', 'k'],
linestyles=['--', '-', '--'],
levels=[-.5, 0, .5])
norm_mode = (self._training_set._normalisation_data and "individual" or "sparse")
pl.title("Norm: " + norm_mode + ", Kernel:" + kernel + ", Dimension reduced by " + dim_reduction_strategy)
pl.show()
def test_pipeline(n_neighbors, radius):
# 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(n_neighbors=n_neighbors, radius=radius)),
("clf", neighbors.KNeighborsClassifier()),
])
clf.fit(X, y)
assert 0.9 < clf.score(X, y)
