def compress(self, X):
n = X.shape[0]
# nearest_neighbours = np.zeros((n, self.nn))
# Compute Euclidean distances
D = utils.euclidean_dist_squared(X, X)
D = np.sqrt(D)
# If two points are disconnected (distance is Inf)
# then set their distance to the maximum
# distance in the graph, to encourage them to be far apart.
adjacency_matrix = np.zeros((n, n))
nearest_neighbours = self.knn(X)
for i, j in enumerate(nearest_neighbours):
for neighbour in j:
adjacency_matrix[i, neighbour] = D[i, neighbour]
adjacency_matrix[neighbour, i] = D[neighbour, i]
dijkstra = utils.dijkstra(adjacency_matrix)
dijkstra[np.isinf(dijkstra)] = dijkstra[~np.isinf(dijkstra)].max()
# Initialize low-dimensional representation with PCA
Z = PCA(self.k).fit(X).compress(X)
# Solve for the minimizer
z = find_min(self._fun_obj_z, Z.flatten(), 500, False, dijkstra)
Z = z.reshape(n, self.k)
return Z
def compress(self, X):
n = X.shape[0]
k = self.k
K = self.K
# Compute Euclidean distances
D = utils.euclidean_dist_squared(X, X)
D = np.sqrt(D)
nbrs = np.argsort(D, axis=1)[:, 1:K + 1]
G = np.zeros((n, n))
for i in range(n):
for j in nbrs[i]:
G[i, j] = D[i, j]
G[j, i] = D[j, i]
D = utils.dijkstra(G)
D[D == np.inf] = -np.inf
max = np.max(D)
D[D == -np.inf] = max
# Initialize low-dimensional representation with PCA
Z = PCA(k).fit(X).compress(X)
# Solve for the minimizer
z = find_min(self._fun_obj_z, Z.flatten(), 500, False, D)
Z = z.reshape(n, k)
return Z
def compress(self, X):
n = X.shape[0]
# Compute Euclidean distances
D = utils.euclidean_dist_squared(X, X)
D = np.sqrt(D)
# Construct nearest neighbour graph
G = np.zeros([n, n])
for i in range(n):
neighbours = np.argsort(D[i])[:self.nn + 1]
for j in neighbours:
G[i, j] = D[i, j]
G[j, i] = D[j, i]
# Compute ISOMAP distances
D = utils.dijkstra(G)
# If two points are disconnected (distance is Inf)
# then set their distance to the maximum
# distance in the graph, to encourage them to be far apart.
D[np.isinf(D)] = D[~np.isinf(D)].max()
# Initialize low-dimensional representation with PCA
Z = PCA(self.k).fit(X).compress(X)
# Solve for the minimizer
z = find_min(self._fun_obj_z, Z.flatten(), 500, False, D)
Z = z.reshape(n, self.k)
return Z
def compress(self, X):
n = X.shape[0]
k = self.k
# Compute Euclidean distances
D = utils.euclidean_dist_squared(X, X)
D = np.sqrt(D)
# Initialize low-dimensional representation with PCA
Z = PCA(k).fit(X).compress(X)
# Solve for the minimizer
z = find_min(self._fun_obj_z, Z.flatten(), 500, False, D)
Z = z.reshape(n, k)
return Z
