def fit(self, X): n, d = X.shape k = self.k self.mu = np.mean(X, 0) X = X - self.mu # Randomly initial Z, W z = np.random.randn(n * k) w = np.random.randn(k * d) squared_term = (np.dot(z.reshape(n, k), w.reshape(k, d)) - X)**2 f = np.sum(np.sqrt(squared_term + self.epsilon)) for i in range(50): f_old = f z = find_min(self._fun_obj_z, z, 10, False, w, X, k) w = find_min(self._fun_obj_w, w, 10, False, z, X, k) # f = np.sum(np.dot(z.reshape(n,k),w.reshape(k,d))-X) squared_term = (np.dot(z.reshape(n, k), w.reshape(k, d)) - X)**2 f = np.sum(np.sqrt(squared_term + self.epsilon)) print('Iteration {:2d}, loss = {}'.format(i, f)) if f_old - f < 1e-4: break self.W = w.reshape(k, d) return self
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 Graham(points, show, save): # on definit une variable global essentiel pour pouvoir choisir notre "pivot" # avec lequel on pour voir faire nos calculs d'angles pour faire le balayages de Graham global point_pivot p0 = find_min(points) # notre point_pivot est essentiel pour faire le scan de Graham # on a choisi d'utiliser le point le plus bas. On fait tous les calculs par rapport à celui-ci # on l'a choisi car on sait que ce point sera toujours dans l'enveloppe convexe !! point_pivot = points[points.index(p0)] trie_points = quicksort(points) del trie_points[trie_points.index(p0)] # hull est la liste contenant les points de l'enveloppe convexe hull = [p0, trie_points[0]] for s in trie_points[1:]: while determinant(hull[-2], hull[-1], s) <= 0: del hull[-1] if len(hull) < 2: break hull.append(s) return hull
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 Shamos_bis(E): n = len(E) if n < 4: return polar_quicksort(E, find_min(E)) else: E1, E2 = Division(E) return Fusion(Shamos_bis(E1), Shamos_bis(E2))
def Jarvis(points, show, save): # on prend le point le plus en bas pour trier on sait qu'il sera # forcement dans l'enveloppe convexe # la fonction pour trouver le min est en O(n) a = find_min(points) # fonction index tres pratiquep our recuperer la postition #d'un element dans une liste index = points.index(a) l = index # la liste de l'enveloppe convexe result = [] result.append(a) while (True): q = (l + 1) % len(points) for i in range(len(points)): if i == l: continue #si c'est colinéaire, on prend le point le plus loin d = determinant(points[l], points[i], points[q]) if d > 0 or (d == 0 and distance(points[i], points[l]) > distance( points[q], points[l])): #print("on rentre dans la boucle") q = i l = q if l == index: break result.append(points[q]) return result
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_components, n_neighbours): n = X.shape[0] k = self.k numNeighbours = self.numNeighbours # find the distances to every other point euclD = utils.euclidean_dist_squared(X, X) euclD = np.sqrt(euclD) knnD = np.zeros((n, n)) # get the KNN of point i for i in range(n): # finds numNeighbours smallest distances from obj_i # +1 because it will always select itself as (distance of 0), and distances are non-negative minIndexes = np.argsort(euclD[i])[:numNeighbours + 1] for index in minIndexes: # add distances of KNN_i to the distance matrix knnD[i, index] = euclD[i, index] D = np.zeros((n, n)) # get distance of every other path using only KNN for i in range(n): for j in range(n): if i != j: D[i, j] = utils.dijkstra(knnD, i, j) Z = AlternativePCA(k).fit(X).compress(X) z = find_min(self._fun_obj_z, Z.flatten(), 500, False, D) Z = z.reshape(n, k) return Z
def compress(self, X): n, d = X.shape k = self.k X = X - self.mu # We didn't enforce that W was orthogonal so we need to optimize to find Z z = np.zeros(n * k) z = find_min(self._fun_obj_z, z, 100, False, self.W.flatten(), X, k) Z = z.reshape(n, 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
from utils import find_max from utils import find_min numbers = [12, 89, 78, 45, 34, 19, 6, 9, 56, 2] max_num = find_max(numbers) minimum = find_min(numbers) print(max_num) print(minimum)
from utils import find_min numbers = [ 10, 3, 6, 2, 1000, 23, 56, 111111, 23, 45, 78, 7, 7, 5, 7, 8, 7, 5, 4 ] min = find_min(numbers) print(min)
import utils numbers = [245,512,51] maximum = utils.find_max(numbers) minimum = utils.find_min(numbers) ave = utils.average(numbers) print(ave)