def helperGetLikeChangeGPU(t): t = cp.array(t) start = time.time() tt = t.item() struc_index = cp.where(ts == t)[0][0].item() if float(t) in taos: change_a_t, change_b_t = getLikeChangeGPU(hic_dist_tao, row_tao, col_tao, struc_t, changea, changeb, tt, struc_index, n_max, n_min) else: lower = taos[taos - tt < 0] upper = taos[taos - tt > 0] a1 = lower[cp.argmin(cp.abs(lower - tt))] a2 = upper[cp.argmin(cp.abs(upper - tt))] w2 = (tt - a1) / cp.abs(a1 - a2) w1 = (a2 - tt) / cp.abs(a1 - a2) changea1, changeb1 = getLikeChangeGPU(hic_dist_tao, row_tao, col_tao, struc_t, changea, changeb, a1.item(), struc_index, n_max, n_min) changea2, changeb2 = getLikeChangeGPU(hic_dist_tao, row_tao, col_tao, struc_t, changea, changeb, a2.item(), struc_index, n_max, n_min) change_a_t = w1 * changea1 + w2 * changea2 change_b_t = w1 * changeb1 + w2 * changeb2 change_t = change_a_t + change_b_t print("indiv", str(start - time.time())) return cp.asnumpy(change_t)
def nn_gpu(ref, query): import cupy with open(cu_file) as f: kernel = cupy.RawKernel(f.read(), "cuComputeDistanceGlobal") ref_nb, ref_dim = ref.shape query_nb, query_dim = query.shape assert ref_dim == query_dim dim = ref_dim ref = ref.transpose(1, 0) query = query.transpose(1, 0) ref = cupy.ascontiguousarray(ref) query = cupy.ascontiguousarray(query) dist = cupy.empty((ref_nb, query_nb), dtype=cupy.float32) BLOCK_DIM = 16 grid = ( int(math.ceil(query_nb / BLOCK_DIM)), int(math.ceil(ref_nb / BLOCK_DIM)), 1, ) block = (16, 16, 1) args = (ref, ref_nb, query, query_nb, dim, dist) shared_mem = BLOCK_DIM * BLOCK_DIM + BLOCK_DIM * BLOCK_DIM + 5 kernel(grid, block, args=args, shared_mem=shared_mem) indices = cupy.argmin(dist, axis=0) return indices
def fit_custom(X, n_clusters, max_iter): assert X.ndim == 2 n_samples = len(X) pred = cupy.zeros(n_samples) initial_indexes = cupy.random.choice(n_samples, n_clusters, replace=False) centers = X[initial_indexes] for _ in range(max_iter): distances = var_kernel(X[:, None, 0], X[:, None, 1], centers[None, :, 1], centers[None, :, 0]) new_pred = cupy.argmin(distances, axis=1) if cupy.all(new_pred == pred): break pred = new_pred i = cupy.arange(n_clusters) mask = pred == i[:, None] sums = sum_kernel(X, mask[:, :, None], axis=1) counts = count_kernel(mask, axis=1).reshape((n_clusters, 1)) centers = sums / counts return centers, pred
def test_transform(nrows, ncols, nclusters, n_parts, input_type, cluster): client = None try: client = Client(cluster) from cuml.dask.cluster import KMeans as cumlKMeans from cuml.dask.datasets import make_blobs X, y = make_blobs(n_samples=int(nrows), n_features=ncols, centers=nclusters, n_parts=n_parts, cluster_std=0.01, shuffle=False, random_state=10) y = y.astype('int64') wait(X) if input_type == "dataframe": X_train = to_dask_cudf(X) y_train = to_dask_cudf(y) labels = cp.squeeze(y_train.compute().to_pandas().values) elif input_type == "array": X_train, y_train = X, y labels = cp.squeeze(y_train.compute()) cumlModel = cumlKMeans(init="k-means||", n_clusters=nclusters, random_state=10) cumlModel.fit(X_train) xformed = cumlModel.transform(X_train).compute() if input_type == "dataframe": xformed = cp.array(xformed if len(xformed.shape) == 1 else xformed.as_gpu_matrix()) if nclusters == 1: # series shape is (nrows,) not (nrows, 1) but both are valid # and equivalent for this test assert xformed.shape in [(nrows, nclusters), (nrows,)] else: assert xformed.shape == (nrows, nclusters) # The argmin of the transformed values should be equal to the labels # reshape is a quick manner of dealing with (nrows,) is not (nrows, 1) xformed_labels = cp.argmin(xformed.reshape((int(nrows), int(nclusters))), axis=1) assert sk_adjusted_rand_score(cp.asnumpy(labels), cp.asnumpy(xformed_labels)) finally: client.close()
def predict(self, Xtest, use_gpu=False): """Predict using the linear model Let :math:`B^k` be the basis vectors of class :math:`k`, and :math:`x` be the RCDT sapce feature vector of an input, the NS method performs classification by .. math:: arg\min_k \| B^k (B^k)^T x - x\|^2 Parameters ---------- Xtest : array-like, shape (n_samples, n_rows, n_columns) Image data for testing. use_gpu: boolean flag; IF TRUE, use gpu for calculations default = False. Returns ------- ndarray of shape (n_samples,) Predicted target values per element in Xtest. """ # calculate the RCDT using parallel CPUs print('\nCalculating RCDTs for testing images ...') Xrcdt = self.rcdt_parallel(Xtest) # vectorize RCDT matrix X = Xrcdt.reshape([Xrcdt.shape[0], -1]) # import cupy for using GPU if use_gpu: import cupy as cp X = cp.array(X) # find nearest subspace for each test sample print('Finding nearest subspace for each test sample ...') D = [] for class_idx in range(self.num_classes): basis = self.subspaces[class_idx] basis = basis[:self.len_subspace, :] if use_gpu: D.append( cp.linalg.norm(cp.matmul(cp.matmul(X, cp.array(basis).T), cp.array(basis)) - X, axis=1)) else: proj = X @ basis.T # (n_samples, n_basis) projR = proj @ basis # (n_samples, n_features) D.append(LA.norm(projR - X, axis=1)) if use_gpu: preds = cp.argmin(cp.stack(D, axis=0), axis=0) return cp.asnumpy(preds) else: D = np.stack(D, axis=0) preds = np.argmin(D, axis=0) return preds
def test_iamin(self): x = self._make_random_vector() ref = cupy.argmin(cupy.absolute(x.real) + cupy.absolute(x.imag)) out = self._make_out('i') res = cublas.iamin(x, out=out) self._check_pointer(res, out) # Note: iamin returns 1-based index cupy.testing.assert_array_equal(res - 1, ref)
def min_col(cover, active_rows, active_cols): """ :return: (column, count) tuple such that column contains the least number of 1s compared to other columns. """ counts = col_counts(cover, active_rows) argmin = active_cols[int(cp.argmin(counts[active_cols]))] return argmin, counts[argmin]
def getGlobalBestPath(particlesN,globalBestCost): # zrownoleglic jak będzie na gpu particles = cupy.asarray(particlesN) shortestPathIndex = cupy.argmin(particles[:,BEST]) cost = particles[shortestPathIndex, BEST] if cost < globalBestCost: return int(shortestPathIndex) else: return -1
def test_transform(nrows, ncols, nclusters, n_parts, cluster): client = None try: client = Client(cluster) from cuml.dask.cluster import KMeans as cumlKMeans from cuml.dask.datasets import make_blobs X_cudf, y = make_blobs(nrows, ncols, nclusters, n_parts, cluster_std=0.01, verbose=False, shuffle=False, random_state=10) wait(X_cudf) cumlModel = cumlKMeans(verbose=0, init="k-means||", n_clusters=nclusters, random_state=10) cumlModel.fit(X_cudf) labels = np.squeeze(y.compute().to_pandas().values) xformed = cumlModel.transform(X_cudf).compute() if nclusters == 1: # series shape is (nrows,) not (nrows, 1) but both are valid # and equivalent for this test assert xformed.shape in [(nrows, nclusters), (nrows, )] else: assert xformed.shape == (nrows, nclusters) xformed = cp.array(xformed if len(xformed.shape) == 1 else xformed.as_gpu_matrix()) # The argmin of the transformed values should be equal to the labels # reshape is a quick manner of dealing with (nrows,) is not (nrows, 1) xformed_labels = cp.argmin(xformed.reshape( (int(nrows), int(nclusters))), axis=1) assert adjusted_rand_score(labels, cp.squeeze(xformed_labels.get())) finally: client.close()
def my_kmedoids(image_data, K, threshold=0): """ This is the cuda implementation of my_kmedoids. Requires cuda to function properly. """ N = image_data.shape[0] p = image_data.shape[1] medoids = np.zeros((K, p)) _, medoids = my_kmeans(image_data, K) medoids = cp.asarray(medoids) medoids_old = cp.zeros(medoids.shape) medoids_new = deepcopy(medoids) error = cp.linalg.norm(medoids_new - medoids_old) image_data = cp.asarray(image_data) labels = cp.zeros(N) DisMat = cp.zeros((N, K)) iter_ct = 0 while error > threshold: iter_ct += 1 #print('K-medoids iteration {}'.format(iter_ct)) medoids_old = deepcopy(medoids_new) for i in range(K): # assign image_data points to closest centroids DisMat[:, i] = cp.linalg.norm(image_data - medoids_new[i], axis=1) labels = cp.argmin(DisMat, axis=1) for i in range(K): cluster = image_data[labels == i] DMC = sum(cp.linalg.norm(cluster - medoids_new[i], axis=1)) DMP = cp.zeros(cluster.shape[0]) if cluster.shape[0] == 0: medoids_new[i] = medoids_old[i] else: for j in range(cluster.shape[0]): DMP[j] = cp.sum(cp.linalg.norm(cluster - cluster[j], axis=1)) small_cost_idx = cp.argmin(DMP) if DMP[small_cost_idx] < DMC: medoids_new[i] = cluster[small_cost_idx] error = cp.linalg.norm(medoids_new - medoids_old) return cp.asnumpy(labels.astype(int)), cp.asnumpy(medoids)
def likelihoodlossGPU(hic_dist_tao, row_tao, col_tao, struc_t, ts, taos, n_max, n_min): start = time.time() change = cp.zeros(struc_t.shape) changea = cp.zeros(struc_t.shape) changeb = cp.zeros(struc_t.shape) print("timea:", time.time() - start) for t in ts: start = time.time() tt = t.item() struc_index = cp.where(ts == t)[0][0].item() if float(t) in taos: changea[struc_index], changeb[struc_index] = getLikeChangeGPU( hic_dist_tao, row_tao, col_tao, struc_t, changea, changeb, tt, struc_index, n_max, n_min) else: lower = taos[taos - tt < 0] upper = taos[taos - tt > 0] a1 = lower[cp.argmin(cp.abs(lower - tt))] a2 = upper[cp.argmin(cp.abs(upper - tt))] w2 = (tt - a1) / cp.abs(a1 - a2) w1 = (a2 - tt) / cp.abs(a1 - a2) #print(a1,a2,w1,w2) changea1, changeb1 = getLikeChangeGPU(hic_dist_tao, row_tao, col_tao, struc_t, changea, changeb, a1.item(), struc_index, n_max, n_min) changea2, changeb2 = getLikeChangeGPU(hic_dist_tao, row_tao, col_tao, struc_t, changea, changeb, a2.item(), struc_index, n_max, n_min) changea[struc_index] += w1 * changea1 + w2 * changea2 changeb[struc_index] += w1 * changeb1 + w2 * changeb2 #print("timeb", str(time.time()-start)) change = changea + changeb return -change
def ts_argmin(x, window): if window > len(x): return cp.full(len(x), cp.nan) # 将nan及-inf填充为inf x = cp.where(cp.isinf(x) | cp.isnan(x), cp.inf, x) prefix = cp.full(window - 1, cp.nan) x_rolling_array = cp_rolling_window(x, window) result = cp.argmin(x_rolling_array, axis=1) # 找到window中全为-inf的情况,填充为nan result = result.astype(float) result = cp.where(cp.isinf(x_rolling_array).all(axis=1), cp.nan, result) result += 1 return cp.concatenate((prefix, result))
def test(self): test_mean = np.mean(self.testset, axis=1) y = self.__project(self.testset, test_mean) pred = [] for i in range(y.shape[1]): tmp = np.sum(np.square((np.expand_dims(y[:, i], axis=1) - self.trainset_project)), axis=0) min_i = np.argmin(tmp, axis=0) pred.append(self.trainlabel[min_i]) pred = np.asarray(pred) # print(pred) acc = np.sum((pred == self.testslabel)) / len(pred) print("accuracy: ", acc) return pred, acc
def predict(self, Xtest, use_gpu=False): """Predict using the linear model Parameters ---------- Xtest : array-like, shape (n_samples, n_columns) 1D data for testing. use_gpu: boolean flag; IF TRUE, use gpu for calculations default = False. Returns ------- ndarray of shape (n_samples,) Predicted target values per sample in Xtest. """ # calculate the CDT using parallel CPUs print('\nCalculating CDTs for testing samples ...') X = self.cdt_parallel(Xtest) # import cupy for using GPU if use_gpu: import cupy as cp X = cp.array(X) # find nearest subspace for each test sample print('Finding nearest subspace for each test sample ...') D = [] for class_idx in range(self.num_classes): basis = self.subspaces[class_idx] basis = basis[:self.len_subspace,:] if use_gpu: D.append(cp.linalg.norm(cp.matmul(cp.matmul(X, cp.array(basis).T), cp.array(basis)) -X, axis=1)) else: proj = X @ basis.T # (n_samples, n_basis) projR = proj @ basis # (n_samples, n_features) D.append(LA.norm(projR - X, axis=1)) if use_gpu: preds = cp.argmin(cp.stack(D, axis=0), axis=0) return cp.asnumpy(preds) else: D = np.stack(D, axis=0) preds = np.argmin(D, axis=0) return preds
def calc_boundary_avoidance_v(self): distance_from_bounds = cp.abs( cp.vstack( (self.state[:, 0] - self.x_min, self.state[:, 0] - self.x_max, self.state[:, 1] - self.y_min, self.state[:, 1] - self.y_max)).T) closest_bound_inds = cp.argmin(distance_from_bounds, axis=1) min_distance_to_bound = cp.min(distance_from_bounds, axis=1) bound_changes = (cp.ones( (2, self.n_obj)) / min_distance_to_bound).T * ( (-1)**(closest_bound_inds.reshape(-1, 1) % 2)) bound_changes[:, 0] = bound_changes[:, 0] * (closest_bound_inds < 2) bound_changes[:, 1] = bound_changes[:, 1] * (closest_bound_inds >= 2) close_to_bound = min_distance_to_bound < self.bound_threshold return close_to_bound, bound_changes
def PDcalculate(x, y, data2): lon1 = x lat1 = y lon1 = cp.asarray(lon1) lat1 = cp.asarray(lat1) lon2 = data2["CLUSTERLONGITUDE"] lat2 = data2["CLUSTERLATITUDE"] lon3 = lon2.values lat3 = lat2.values lon4 = cp.asarray(lon3) lat4 = cp.asarray(lat3) shortdistance = geodistance_cp(lon1, lat1, lon4, lat4) indexmin = cp.argmin(shortdistance) indexmin = cp.int(indexmin) targetcID = data2.at[indexmin, "CLUSTERID"] mindistance = cp.int(cp.min(shortdistance)) return mindistance, targetcID
def predict(self, X): """Predict using the linear model Parameters ---------- X : array-like, sparse matrix, shape (n_samples, n_proj, n_angles)) Returns ------- ndarray of shape (n_samples,) Predicted target values per element in X. """ X = X.reshape([X.shape[0], -1]) D = [] for class_idx in range(self.num_classes): basis = self.subspaces[class_idx] basis = basis[:self.len_subspace, :] if __GPU__: D.append( cp.linalg.norm(cp.matmul(cp.matmul(X, cp.array(basis).T), cp.array(basis)) - X, axis=1)) #basis = cp.array(basis) #proj = cp.matmul(X,basis.T) #projR = cp.matmul(proj,basis) #D.append(cp.linalg.norm(projR - X, axis=1)) else: proj = X @ basis.T # (n_samples, n_basis) projR = proj @ basis # (n_samples, n_features) D.append(LA.norm(projR - X, axis=1)) if __GPU__: preds = cp.argmin(cp.stack(D, axis=0), axis=0) #D = cp.stack(D, axis=0) # (num_classes, n_samples) #preds = cp.argmin(D, axis=0) # n_samples return cp.asnumpy(preds) else: D = np.stack(D, axis=0) preds = np.argmin(D, axis=0) return preds
def predict(self, X): """Predict using the linear model Parameters ---------- X : array-like, sparse matrix, shape (n_samples, n_proj, n_angles)) Returns ------- ndarray of shape (n_samples,) Predicted target values per element in X. """ if self.use_gpu: import cupy as cp X = X.reshape([X.shape[0], -1]) #X = np.transpose(X,(0,2,1)).reshape(X.shape[0],-1) print('Len basis: {}'.format(self.len_subspace)) D = [] for class_idx in range(self.num_classes): basis = self.subspaces[class_idx] basis = basis[:self.len_subspace, :] if self.use_gpu: D.append( cp.linalg.norm(cp.matmul(cp.matmul(X, cp.array(basis).T), cp.array(basis)) - X, axis=1)) else: proj = X @ basis.T # (n_samples, n_basis) projR = proj @ basis # (n_samples, n_features) D.append(LA.norm(projR - X, axis=1)) if self.use_gpu: preds = cp.argmin(cp.stack(D, axis=0), axis=0) self.preds_label = [self.label[i] for i in cp.asnumpy(preds)] return self.preds_label else: D = np.stack(D, axis=0) preds = np.argmin(D, axis=0) self.preds_label = [self.label[i] for i in preds] return self.preds_label
def test_cuda(self): import cupy as cp # tranform numpy.ndarray to cupy.core.core.ndarray self.pca_vector = cp.asarray(self.pca_vector) self.testset = cp.asarray(self.testset) self.trainset_project = cp.asarray(self.trainset_project) self.testslabel = cp.asarray(self.testslabel) self.trainlabel = cp.asarray(self.trainlabel) def project(set, mean): y = cp.matmul(self.pca_vector.transpose(), set.transpose() - mean) return y s = time.time() test_mean = cp.mean(self.testset, axis=1) y = project(self.testset, test_mean) pred = [] for i in range(y.shape[1]): tmp = y[:, i].reshape((y.shape[0], 1)) tmp = tmp - self.trainset_project tmp = cp.sum(cp.square(tmp), axis=0).flatten() min_i = cp.argmin(tmp, axis=0) pred.append(self.trainlabel[min_i]) pred = cp.asarray(pred) # print(pred) acc = cp.sum((pred == self.testslabel)) / len(pred) print("accuracy: ", acc) e = time.time() tim = e - s print("Total time of PAC_ORL test: ", tim) self.pca_vector = cp.asnumpy(self.pca_vector) self.testset = cp.asnumpy(self.testset) self.trainset_project = cp.asnumpy(self.trainset_project) self.testslabel = cp.asnumpy(self.testslabel) self.trainlabel = cp.asnumpy(self.trainlabel) return pred, acc
def evaluate_chunks( results: [cp.ndarray, cp.ndarray, cp.ndarray], # closest triangle, distance, projection all_pts: cp.ndarray = None, vertices: cp.ndarray = None, edges: cp.ndarray = None, edge_norms: cp.ndarray = None, edge_normssq: cp.ndarray = None, normals: cp.ndarray = None, norms: cp.ndarray = None, normssq: cp.ndarray = None, zero_tensor: cp.ndarray = None, one_tensor: cp.ndarray = None, tris: cp.ndarray = None, vertex_normals: cp.ndarray = None, bounding_box: dict = None, chunk_size: int = None, num_verts: int = None) -> None: # # Expand vertex normals if non empty if vertex_normals is not None: vertex_normals = vertex_normals[tris] vertex_normals = cp.tile(cp.expand_dims(vertex_normals, axis=2), (1, 1, chunk_size, 1)) # begin = time.time() # # Load and extend the batch num_chunks = all_pts.shape[0] // chunk_size for i in range(num_chunks): # # Get subset of the query points start_index = i * chunk_size end_index = (i + 1) * chunk_size pts = all_pts[start_index:end_index, :] # # Match the dimensions to those assumed above. # REPEATED REPEATED # [triangle_index, vert_index, querypoint_index, coordinates] pts = cp.tile(cp.expand_dims(pts, axis=(0, 1)), (num_verts, 3, 1, 1)) # # Compute the differences between # vertices on each triangle and the # points of interest # # [triangle_index, vert_index, querypoint_index, coordinates] # =================== # [:,0,:,:] = p - p1 # [:,1,:,:] = p - p2 # [:,2,:,:] = p - p3 diff_vectors = pts - vertices # # Compute alpha, beta, gamma barycentric = cp.empty(diff_vectors.shape) # # gamma = u x (p - p1) barycentric[:, 2, :, :] = cp.cross(edges[:, 0, :, :], diff_vectors[:, 0, :, :]) # beta = (p - p1) x v barycentric[:, 1, :, :] = cp.cross(diff_vectors[:, 0, :, :], edges[:, 1, :, :]) # alpha = w x (p - p2) barycentric[:, 0, :, :] = cp.cross(edges[:, 2, :, :], diff_vectors[:, 1, :, :]) barycentric = cp.divide( cp.sum(cp.multiply(barycentric, normals), axis=3), normssq) # # Test conditions less_than_one = cp.less_equal(barycentric, one_tensor) more_than_zero = cp.greater_equal(barycentric, zero_tensor) # # if 0 <= gamma and gamma <= 1 # and 0 <= beta and beta <= 1 # and 0 <= alpha and alpha <= 1: cond1 = cp.logical_and(less_than_one, more_than_zero) # # if gamma <= 0: cond2 = cp.logical_not(more_than_zero[:, 2, :]) cond2 = cp.tile(cp.expand_dims(cond2, axis=1), (1, 3, 1)) # # if beta <= 0: cond3 = cp.logical_not(more_than_zero[:, 1, :]) cond3 = cp.tile(cp.expand_dims(cond3, axis=1), (1, 3, 1)) # # if alpha <= 0: cond4 = cp.logical_not(more_than_zero[:, 0, :]) cond4 = cp.tile(cp.expand_dims(cond4, axis=1), (1, 3, 1)) # # Get the projections for each case xi = cp.empty(barycentric.shape) barycentric_ext = cp.tile(cp.expand_dims(barycentric, axis=3), (1, 1, 1, 3)) proj = cp.sum(cp.multiply(barycentric_ext, vertices), axis=1) # # if 0 <= gamma and gamma <= 1 # and 0 <= beta and beta <= 1 # and 0 <= alpha and alpha <= 1: xi[cond1] = barycentric[cond1] # # if gamma <= 0: # x = p - p1 # u = p2 - p1 # a = p1 # b = p2 t2 = cp.divide( # # u.dot(x) cp.sum(cp.multiply(edges[:, 0, :, :], diff_vectors[:, 0, :, :]), axis=2), edge_normssq[:, 0]) xi2 = cp.zeros((t2.shape[0], 3, t2.shape[1])) xi2[:, 0, :] = -t2 + 1 xi2[:, 1, :] = t2 # t2 = cp.tile(cp.expand_dims(t2, axis=2), (1, 1, 3)) lz = cp.less(t2, cp.zeros(t2.shape)) go = cp.greater(t2, cp.ones(t2.shape)) proj2 = vertices[:, 0, :, :] + cp.multiply(t2, edges[:, 0, :, :]) proj2[lz] = vertices[:, 0, :, :][lz] proj2[go] = vertices[:, 1, :, :][go] # xi[cond2] = xi2[cond2] proj[cp.swapaxes(cond2, 1, 2)] = proj2[cp.swapaxes(cond2, 1, 2)] # # if beta <= 0: # x = p - p1 # v = p3 - p1 # a = p1 # b = p3 t3 = cp.divide( # # v.dot(x) cp.sum(cp.multiply(edges[:, 1, :, :], diff_vectors[:, 0, :, :]), axis=2), edge_normssq[:, 1]) xi3 = cp.zeros((t3.shape[0], 3, t3.shape[1])) xi3[:, 0, :] = -t3 + 1 xi3[:, 2, :] = t3 # t3 = cp.tile(cp.expand_dims(t3, axis=2), (1, 1, 3)) lz = cp.less(t3, cp.zeros(t3.shape)) go = cp.greater(t3, cp.ones(t3.shape)) proj3 = vertices[:, 0, :, :] + cp.multiply(t3, edges[:, 1, :, :]) proj3[lz] = vertices[:, 0, :, :][lz] proj3[go] = vertices[:, 2, :, :][go] # xi[cond3] = xi3[cond3] proj[cp.swapaxes(cond3, 1, 2)] = proj3[cp.swapaxes(cond3, 1, 2)] # # if alpha <= 0: # y = p - p2 # w = p3 - p2 # a = p2 # b = p3 t4 = cp.divide( # # w.dot(y) cp.sum(cp.multiply(edges[:, 2, :, :], diff_vectors[:, 1, :, :]), axis=2), edge_normssq[:, 2]) xi4 = cp.zeros((t4.shape[0], 3, t4.shape[1])) xi4[:, 1, :] = -t4 + 1 xi4[:, 2, :] = t4 # t4 = cp.tile(cp.expand_dims(t4, axis=2), (1, 1, 3)) lz = cp.less(t4, cp.zeros(t4.shape)) go = cp.greater(t4, cp.ones(t4.shape)) proj4 = vertices[:, 1, :, :] + cp.multiply(t4, edges[:, 2, :, :]) proj4[lz] = vertices[:, 1, :, :][lz] proj4[go] = vertices[:, 2, :, :][go] # xi[cond4] = xi4[cond4] proj[cp.swapaxes(cond4, 1, 2)] = proj4[cp.swapaxes(cond4, 1, 2)] vec_to_point = pts[:, 0, :, :] - proj distances = cp.linalg.norm(vec_to_point, axis=2) # n = "\n" # print(f"{pts[:,0,:,:]=}") # print(f"{proj=}") # print(f"{pts[:,0,:,:] - proj=}") # print(f"{distances=}") min_distances = cp.min(distances, axis=0) closest_triangles = cp.argmin(distances, axis=0) projections = proj[closest_triangles, np.arange(chunk_size), :] # # Distinguish close triangles is_close = cp.isclose(distances, min_distances) # # Determine sign signed_normal = normals[:, 0, :, :] if vertex_normals is not None: signed_normal = cp.sum(vertex_normals.transpose() * xi.transpose(), axis=2).transpose() is_negative = cp.less_equal( cp.sum(cp.multiply(vec_to_point, signed_normal), axis=2), 0.) # # Combine is_close_and_negative = cp.logical_and(is_close, is_negative) # # Determine if inside is_inside = cp.all(cp.logical_or(is_close_and_negative, cp.logical_not(is_close)), axis=0) # # Overwrite the signs of points # that are outside of the box if bounding_box is not None: # # Extract rotation_matrix = cp.asarray(bounding_box['rotation_matrix']) translation_vector = cp.asarray(bounding_box['translation_vector']) size = cp.asarray(bounding_box['size']) # # Transform transformed_pts = cp.dot( all_pts[start_index:end_index, :] - translation_vector, rotation_matrix) # # Determine if outside bbox inside_bbox = cp.all(cp.logical_and( cp.less_equal(0., transformed_pts), cp.less_equal(transformed_pts, size)), axis=1) # # Treat points outside bbox as # being outside of lumen print(f"{inside_bbox=}") is_inside = cp.logical_and(is_inside, inside_bbox) # # Apply sign to indicate whether the distance is # inside or outside the mesh. min_distances[is_inside] = -1 * min_distances[is_inside] # # Emplace results # [triangle_index, vert_index, querypoint_index, coordinates] results[0][start_index:end_index] = closest_triangles results[1][start_index:end_index] = min_distances results[2][start_index:end_index, :] = projections
#gammaの計算 if(i+1==int(iteration)+int(additional_iteration)): if(memory_transfer_flag==1): cp_dens_pre = cp.asarray(cp_dens_pre, dtype=cp.complex64)#numpy配列 ⇒ cupy配列に変換 rdens_in=cp_sup*cp.absolute(cp_dens_pre) rdens_out=-(cp_sup-1.0)*cp.absolute(cp_dens_pre) if(memory_transfer_flag==1): cp_dens_pre = cp.asnumpy(cp_dens_pre)#cupy配列 ⇒ numpy配列に変換 rdens_in_sum=cp.sum(rdens_in, axis=(1,2)) rdens_out_sum=cp.sum(rdens_out, axis=(1,2)) gamma = rdens_out_sum / ((OS_ratio - 1.0 ) * rdens_in_sum) n_min_gamma=cp.argmin(gamma) min_gamma=cp.min(gamma) #重心の計算 if(i+1==int(iteration)+int(additional_iteration)): if(memory_transfer_flag==1): cp_dens_pre = cp.asarray(cp_dens_pre, dtype=cp.complex64)#numpy配列 ⇒ cupy配列に変換 R_dens=cp_dens_pre if(memory_transfer_flag==1): cp_dens_pre = cp.asnumpy(cp_dens_pre)#cupy配列 ⇒ numpy配列に変換 R_dens = cp.asnumpy(R_dens) cp_sup = cp.asnumpy(cp_sup) R_dens.real=R_dens.real*cp_sup if(DFPR_flag == 1):
def pred_drs(Q_input, Q1_LUT, Q2_LUT, Q3_LUT, args, nan_th=np.inf): """ 観測Qから d: 物体距離 r: 物体反射率 s: 霧の消滅係数 を推定する. 各推定値の範囲はargs参照 Parameters ========== Q_input: cp.array([row*col, 3]) 観測値Q1, Q2, Q3 Q1_LUT: cp.array(args.sigma_size) sとQ1の対応を保持したLookup table Q2_LUT, Q3_LUT: cp.array([args.dist_size, args.ref_size, args.sigma_size]) それぞれdrsとQ2, drsとQ3の対応を保持したLookup table args: Namespace LUTを作るのに用いた設定 (引数) Returns ======= drs_pred: np.array([row*col, 3]) 推定したdrs """ drs_pred = cp.zeros(Q_input.shape) intensity_defogged = cp.zeros(Q_input.shape[0]) Q_pred = cp.zeros(Q_input.shape) Q_error = cp.zeros(Q_input.shape) for i, (Q1_obs, Q2_obs, Q3_obs) in enumerate(tqdm(Q_input)): s_error = (Q1_LUT - Q1_obs)**2 s_index = cp.argmin(s_error) drs_pred[i, 2] = index2value(s_index, args.sigma_max, args.sigma_min, args.sigma_size) Q_pred[i, 0] = Q1_LUT[s_index] Q_error[i, 0] = s_error[s_index] Q2Q3_obs = cp.array([Q2_obs, Q3_obs]) Q2Q3_LUT = cp.stack([Q2_LUT[:, :, s_index], Q3_LUT[:, :, s_index]], axis=2).reshape(args.dist_size * args.ref_size, -1) dr_error_vec = (Q2Q3_LUT - Q2Q3_obs)**2 dr_error = cp.sum(dr_error_vec, axis=1) if dr_error.min() < nan_th: dr_index = cp.argmin(dr_error) d_index = dr_index // args.ref_size r_index = dr_index % args.ref_size Q_error[i, 1], Q_error[i, 2] = dr_error_vec[dr_index] drs_pred[i, 0] = index2value(d_index, args.dist_max * args.scene_scale, args.dist_min * args.scene_scale, args.dist_size) drs_pred[i, 1] = index2value(r_index, args.ref_max, args.ref_min, args.ref_size) Q_pred[i, 1] = Q2Q3_LUT[dr_index][0] Q_pred[i, 2] = Q2Q3_LUT[dr_index][1] intensity_defogged[i] = Q2_LUT[d_index, r_index, 0] + Q3_LUT[d_index, r_index, 0] else: drs_pred[i, 0] = nan_th drs_pred[i, 1] = nan_th Q_pred[i, 1] = nan_th Q_pred[i, 2] = nan_th intensity_defogged[i] = nan_th return cp.asnumpy(drs_pred), cp.asnumpy(intensity_defogged), cp.asnumpy( Q_pred), cp.asnumpy(Q_error)
def const_reverse_LUT(Q1_LUT, Q2_LUT, Q3_LUT, args, Q1_max=250, Q1_min=0, Q1_size=25, Q2_max=3000, Q2_min=0, Q2_size=60, Q3_max=2000, Q3_min=0, Q3_size=40, nan_th=np.inf): RevLUT = cp.zeros([Q1_size, Q2_size, Q3_size, 4]) Q2Q3_vec = cp.array([[ int(index2value(Q2_index, Q2_max, Q2_min, Q2_size)), int(index2value(Q3_index, Q3_max, Q3_min, Q3_size)) ] for Q2_index in tqdm(range(Q2_size)) for Q3_index in range(Q3_size)]) for Q1 in tqdm(range(Q1_size)): s_error = (Q1_LUT - index2value(Q1, Q1_max, Q1_min, Q1_size))**2 s_index = cp.argmin(s_error) RevLUT[Q1, :, :, 2] = index2value(s_index, args.sigma_max, args.sigma_min, args.sigma_size) Q2Q3_LUT = cp.stack([Q2_LUT[:, :, s_index], Q3_LUT[:, :, s_index]], axis=2).reshape(args.dist_size * args.ref_size, -1) for Q2Q3_real_scale in Q2Q3_vec: Q2_revlut_scale = value2index(Q2Q3_real_scale[0], Q2_max, Q2_min, Q2_size) Q3_revlut_scale = value2index(Q2Q3_real_scale[1], Q3_max, Q3_min, Q3_size) dr_error_vec = (Q2Q3_LUT - Q2Q3_real_scale)**2 dr_error = cp.sum(dr_error_vec, axis=1) if dr_error.min() < nan_th: dr_index = cp.argmin(dr_error) d_index = dr_index // args.ref_size r_index = dr_index % args.ref_size RevLUT[Q1, Q2_revlut_scale, Q3_revlut_scale, 0] = index2value(d_index, args.dist_max * args.scene_scale, args.dist_min * args.scene_scale, args.dist_size) RevLUT[Q1, Q2_revlut_scale, Q3_revlut_scale, 1] = index2value(r_index, args.ref_max, args.ref_min, args.ref_size) RevLUT[Q1, Q2_revlut_scale, Q3_revlut_scale, 3] = Q2_LUT[d_index, r_index, 0] + Q3_LUT[d_index, r_index, 0] else: RevLUT[Q1, Q2_revlut_scale, Q3_revlut_scale, 0] = cp.nan RevLUT[Q1, Q2_revlut_scale, Q3_revlut_scale, 1] = cp.nan RevLUT[Q1, Q2_revlut_scale, Q3_revlut_scale, 3] = cp.nan return cp.asnumpy(RevLUT)
kmeans = KMeans(n_clusters=k).fit(X_train) print("done.") clst_label = [] clst_data = [] for i in np.unique(kmeans.labels_): idx = np.where(kmeans.labels_ == i)[0] clst_label.append(y_train[idx]) clst_data.append(X_train[idx]) # Predict with Nearest Neighbor temp_time = [] correct = 0 for i, te in enumerate(X_test): print("test # %d" % i) start_time = time.clock() target_clst = cp.asnumpy(cp.argmin(cp.linalg.norm(cp.array(kmeans.cluster_centers_-X_test[i]), axis=1))) nearest = cp.asnumpy(cp.argmin(cp.linalg.norm(cp.array(clst_data[target_clst]-X_test[i]), axis=1))) pred = clst_label[target_clst][nearest] end_time = time.clock() temp_time.append(end_time-start_time) correct += (y_test[i, 0] == pred) times.append(np.mean(temp_time)) times[-1] = times[-1]/times[0] accuracies.append(correct*100/X_test.shape[0]) print('Accuracy: %.3f %%' % (correct*100/X_test.shape[0])) print('Estimation Time: %.10f sec' % np.mean(temp_time)) accuracies = [np.round(a, decimals=1) for a in accuracies] times = [np.round(t, decimals=10) for t in times] print('Accuracies: [%s %%]' % ','.join(map(str, accuracies))) print('Estimation Time / Estimation Time without Clustering: [%s %%]' % ','.join(map(str, times)))
def kmeans_sampling(X, k, round_values=True, detailed=False, random_state=0): """ Adapted from : https://github.com/slundberg/shap/blob/9411b68e8057a6c6f3621765b89b24d82bee13d4/shap/utils/_legacy.py Summarize a dataset (X) using weighted k-means. Parameters ---------- X : cuDF or Pandas DataFrame/Series, numpy arrays or cuda_array_interface compliant device array. Data to be summarized, shape (n_samples, n_features) k : int Number of means to use for approximation. round_values : bool; default=True For all i, round the ith dimension of each mean sample to match the nearest value from X[:,i]. This ensures discrete features always get a valid value. detailed: bool; default=False To return details of group names and cluster labels of all data points random_state: int; default=0 Sets the random state. Returns ------- summary : Summary of the data, shape (k, n_features) group_names : Names of the features labels : Cluster labels of the data points in the original dataset, shape (n_samples, 1) """ output_dtype = get_supported_input_type(X) _output_dtype_str = determine_array_type(X) cuml.internals.set_api_output_type(_output_dtype_str) if output_dtype is None: raise TypeError(f"Type of input {type(X)} is not supported. Supported \ dtypes: cuDF DataFrame, cuDF Series, cupy, numba,\ numpy, pandas DataFrame, pandas Series") if "DataFrame" in str(output_dtype): group_names = X.columns X = cp.array(X.values, copy=False) if "Series" in str(output_dtype): group_names = X.name X = cp.array(X.values.reshape(-1, 1), copy=False) else: # it's either numpy, cupy or numba X = cp.array(X, copy=False) try: # more than one column group_names = [str(i) for i in range(X.shape[1])] except IndexError: # one column X = X.reshape(-1, 1) group_names = ['0'] # in case there are any missing values in data impute them imp = SimpleImputer(missing_values=cp.nan, strategy='mean', output_type=_output_dtype_str) X = imp.fit_transform(X) kmeans = KMeans(n_clusters=k, random_state=random_state, output_type=_output_dtype_str).fit(X) if round_values: for i in range(k): for j in range(X.shape[1]): xj = X[:, j].toarray().flatten() if issparse( X) else X[:, j] # sparse support courtesy of @PrimozGodec ind = cp.argmin(cp.abs(xj - kmeans.cluster_centers_[i, j])) kmeans.cluster_centers_[i, j] = X[ind, j] summary = kmeans.cluster_centers_ labels = kmeans.labels_ if detailed: return summary, group_names, labels else: return summary
def threshold_minimum(image=None, nbins=256, max_iter=10000, *, hist=None): """Return threshold value based on minimum method. The histogram of the input ``image`` is computed if not provided and smoothed until there are only two maxima. Then the minimum in between is the threshold value. Either image or hist must be provided. In case hist is given, the actual histogram of the image is ignored. Parameters ---------- image : (M, N) ndarray, optional Input image. nbins : int, optional Number of bins used to calculate histogram. This value is ignored for integer arrays. max_iter : int, optional Maximum number of iterations to smooth the histogram. hist : array, or 2-tuple of arrays, optional Histogram to determine the threshold from and a corresponding array of bin center intensities. Alternatively, only the histogram can be passed. Returns ------- threshold : float Upper threshold value. All pixels with an intensity higher than this value are assumed to be foreground. Raises ------ RuntimeError If unable to find two local maxima in the histogram or if the smoothing takes more than 1e4 iterations. References ---------- .. [1] C. A. Glasbey, "An analysis of histogram-based thresholding algorithms," CVGIP: Graphical Models and Image Processing, vol. 55, pp. 532-537, 1993. .. [2] Prewitt, JMS & Mendelsohn, ML (1966), "The analysis of cell images", Annals of the New York Academy of Sciences 128: 1035-1053 :DOI:`10.1111/j.1749-6632.1965.tb11715.x` Examples -------- >>> from skimage.data import camera >>> image = camera() >>> thresh = threshold_minimum(image) >>> binary = image > thresh """ def find_local_maxima_idx(hist): # We can't use scipy.signal.argrelmax # as it fails on plateaus maximum_idxs = list() direction = 1 # TODO: better to transfer hist back to cpu? hist = cp.asnumpy(hist) # device synchronize for i in range(hist.shape[0] - 1): if direction > 0: if hist[i + 1] < hist[i]: direction = -1 maximum_idxs.append(i) else: if hist[i + 1] > hist[i]: direction = 1 return maximum_idxs counts, bin_centers = _validate_image_histogram(image, hist, nbins) smooth_hist = counts.astype(cp.float64, copy=False) for counter in range(max_iter): smooth_hist = ndi.uniform_filter1d(smooth_hist, 3) maximum_idxs = find_local_maxima_idx(smooth_hist) if len(maximum_idxs) < 3: break if len(maximum_idxs) != 2: raise RuntimeError('Unable to find two maxima in histogram') elif counter == max_iter - 1: raise RuntimeError('Maximum iteration reached for histogram' 'smoothing') # Find lowest point between the maxima threshold_idx = cp.argmin(smooth_hist[maximum_idxs[0]:maximum_idxs[1] + 1]) return bin_centers[maximum_idxs[0] + int(threshold_idx)]
return Array._new( np.asarray(np.argmax(x._array, axis=axis, keepdims=keepdims))) def argmin(x: Array, /, *, axis: Optional[int] = None, keepdims: bool = False) -> Array: """ Array API compatible wrapper for :py:func:`np.argmin <numpy.argmin>`. See its docstring for more information. """ return Array._new( np.asarray(np.argmin(x._array, axis=axis, keepdims=keepdims))) def nonzero(x: Array, /) -> Tuple[Array, ...]: """ Array API compatible wrapper for :py:func:`np.nonzero <numpy.nonzero>`. See its docstring for more information. """ return tuple(Array._new(i) for i in np.nonzero(x._array)) def where(condition: Array, x1: Array, x2: Array, /) -> Array: """ Array API compatible wrapper for :py:func:`np.where <numpy.where>`.
def reconstruct_alt(imgs, discs, hres_size, row, n_iters=1, o_f_init=None, del_1=1000, del_2=1, round_values=True, plot_per_frame=False, show_interval=None, subtract_bg=False, out_path=None): """The main reconstruction algorithm. Adapted from Tian et. al.""" # Put input images on GPU, estimate background noise imgs = [cp.array(img) for img in imgs] bgs = get_bg(imgs) if subtract_bg else cp.zeros(len(imgs)) IMAGESIZE = imgs[0].shape[0] CUTOFF_FREQ_px = get_cutoff(row) FRAMES = len(imgs) orig = IMAGESIZE // 2 - 1 # Low-res origin lres_size = (IMAGESIZE, IMAGESIZE) m1, n1 = lres_size m, n = hres_size losses = [] # Reconstruction Loss convs = [] # Inverse Convergence index # Initial high-res guess if lres_size == hres_size: # Initialize with ones # Use old algorithm F = lambda x: cp.fft.fftshift(cp.fft.fft2(x)) Ft = lambda x: cp.fft.ifft2(cp.fft.ifftshift(x)) o = cp.ones(hres_size) o_f = F(o) elif o_f_init is not None: # Initialize with given initialization F = lambda x: cp.fft.fftshift(cp.fft.fft2(cp.fft.ifftshift(x))) Ft = lambda x: cp.fft.fftshift(cp.fft.ifft2(cp.fft.ifftshift(x))) o = cp.zeros_like(o_f_init) o_f = o_f_init else: # Intialize with resized first frame from imgs F = lambda x: cp.fft.fftshift(cp.fft.fft2(cp.fft.ifftshift(x))) Ft = lambda x: cp.fft.fftshift(cp.fft.ifft2(cp.fft.ifftshift(x))) o = cp.sqrt( cp.array(cv2.resize(cp.asnumpy(imgs[0] - bgs[0]), hres_size))) o_f = Ft(o) # Pupil Function p = cp.zeros(lres_size) p = cp.array(cv2.circle(cp.asnumpy(p), (orig, orig), CUTOFF_FREQ_px, 1, -1)) ctf = p.copy() # Ideal Pupil, for filtering later on # Main Loop log = tqdm( total=n_iters, desc=f'Starting...', bar_format= '{percentage:3.0f}% [{elapsed}<{remaining} ({rate_inv_fmt})]{bar}{desc}', leave=False, ascii=True) for j in range(n_iters): conv = [] # Convergence Index for i in range(FRAMES): if discs[i] == 0: # Empty frame continue # Get k0x, k0y and hence, shifting values k0x, k0y = discs[i] # Construct auxillary functions for the set of LEDs (= 1, here) if hres_size == lres_size: shift_x, shift_y = [ -round(k0x - orig), -round(k0y - orig) ] if round_values else [-(k0x - orig), -(k0y - orig)] if not round_values: o_f_i = FourierShift2D(o_f, [shift_x, shift_y]) # O_i(k - k_m) else: o_f_i = cp.roll(o_f, int(shift_y), axis=0) o_f_i = cp.roll(o_f_i, int(shift_x), axis=1) yl, xl = 0, 0 # To reduce code later on else: # Output size larger than individual frames _orig = hres_size[0] // 2 - 1 del_x, del_y = k0x - orig, k0y - orig x, y = round(_orig - del_x), round(_orig - del_y) yl = int(y - m1 // 2) xl = int(x - n1 // 2) assert xl > 0 and yl > 0, 'Both should be > 0' o_f_i = o_f[yl:yl + n1, xl:xl + m1].copy() psi_k = o_f_i * p * ctf #DEBUG: REPLACE * ctf with * p # Plot outputs after each frame, for debugging if plot_per_frame: o_i = Ft(o_f_i * p) plt.figure(figsize=(10, 2)) plt.subplot(161) plt.imshow(cp.asnumpy(correct(abs(o_i)))) plt.title(f'$I_{{l}}({i})$') opts() #DEBUG plt.subplot(162) plt.imshow( cp.asnumpy( cv2.convertScaleAbs( cp.asnumpy(20 * cp.log(1 + abs(o_f_i * p)))))) plt.title(f'$S_{{l}}({i})$') opts() #DEBUG # Impose intensity constraint and update auxillary function psi_r = F(psi_k) #DEBUG: CHANGE BACK TO F # Low-res estimate obtained from our reconstruction I_l = abs(psi_r) if lres_size != hres_size else abs(psi_r) # Subtract background noise and clip values to avoid NaN I_hat = cp.clip(imgs[i] - bgs[i], a_min=0) phi_r = cp.sqrt(I_hat / (cp.abs(psi_r)**2)) * psi_r phi_k = Ft(phi_r) #DEBUG: CHANGE BACK TO Ft # Update object and pupil estimates if hres_size == lres_size: if not round_values: p_i = FourierShift2D(p, [-shift_x, -shift_y]) # P_i(k+k_m) else: p_i = cp.roll(p, int(-shift_y), axis=0) p_i = cp.roll(p_i, int(-shift_x), axis=1) if not round_values: phi_k_i = FourierShift2D( phi_k, [-shift_x, -shift_y]) # Phi_m_i(k+k_m) else: phi_k_i = cp.roll(phi_k, int(-shift_y), axis=0) phi_k_i = cp.roll(phi_k_i, int(-shift_x), axis=1) else: # Output size larger than individual frames p_i = p.copy() phi_k_i = phi_k.copy() ## O_{i+1}(k) temp = o_f[yl:yl + n1, xl:xl + m1].copy() + ( cp.abs(p_i) * cp.conj(p_i) * (phi_k_i - o_f[yl:yl + n1, xl:xl + m1].copy() * p_i) ) / \ ( cp.abs(p).max() * (cp.abs(p_i) ** 2 + del_1) ) ## P_{i+1}(k) p = p + ( cp.abs(o_f_i) * cp.conj(o_f_i) * (phi_k - o_f_i * p) ) / \ ( cp.abs(o_f[yl:yl + n1, xl:xl + m1].copy()).max() * (cp.abs(o_f_i) ** 2 + del_2) ) o_f[yl:yl + n1, xl:xl + m1] = temp.copy() ###### Using F here instead of Ft to get upright image o = F(o_f) if lres_size != hres_size else Ft(o_f) ###### if plot_per_frame: plt.subplot(163) plt.imshow(cp.asnumpy(cp.mod(ctf * cp.angle(p), 2 * cp.pi))) plt.title(f'P({i})') opts() #DEBUG plt.subplot(164) plt.imshow(cp.asnumpy(correct(abs(o)))) plt.title(f'$I_{{h}}({i})$') opts() #DEBUG plt.subplot(165) plt.imshow(cp.asnumpy(correct(cp.angle(o)))) plt.title(f'$\\theta(I_{{h}}({i}))$') opts() #DEBUG plt.subplot(166) plt.imshow(cp.asnumpy(show(cp.asnumpy(o_f)))) plt.title(f'$S_{{h}}({i})$') opts() plt.show() #DEBUG c = inv_conv_idx(I_l, imgs[i]) conv.append(c) if not plot_per_frame and (show_interval is not None and j % show_interval == 0): o_i = Ft(o_f_i * p) #DEBUG plt.figure(figsize=(10, 2)) plt.subplot(161) plt.imshow(cp.asnumpy(correct(abs(o_i)))) plt.title(f'$I_{{l}}({i})$') opts() #DEBUG plt.subplot(162) plt.imshow( cp.asnumpy( cv2.convertScaleAbs( cp.asnumpy(20 * cp.log(1 + abs(o_f_i * p)))))) plt.title(f'$S_{{l}}({i})$') opts() #DEBUG plt.subplot(163) plt.imshow(cp.asnumpy(cp.mod(ctf * cp.angle(p), 2 * cp.pi))) plt.title(f'P({i})') opts() #DEBUG plt.subplot(164) plt.imshow(cp.asnumpy(correct(abs(o)))) plt.title(f'$I_{{h}}({i})$') opts() #DEBUG plt.subplot(165) plt.imshow(cp.asnumpy(correct(cp.angle(o)))) plt.title(f'$\\theta(I_{{h}}({i}))$') opts() #DEBUG plt.subplot(166) plt.imshow( cp.asnumpy( cv2.convertScaleAbs(cp.asnumpy(20 * cp.log(1 + abs(o_f)))))) plt.title(f'$S_{{h}}({i})$') opts() plt.show() #DEBUG loss = metric_norm(imgs, o_f_i, p) losses.append(loss) conv = float(sum(conv) / len(conv)) convs.append(conv) log.set_description_str( f'[Iteration {j + 1}] Convergence Loss: {cp.asnumpy(conv):e}') log.update(1) scale = 7 plt.figure(figsize=(3 * scale, 4 * scale)) plt.subplot(421) plt.plot(cp.asnumpy(cp.arange(len(losses))), cp.asnumpy(cp.clip(cp.array(losses), a_min=None, a_max=1e4)), 'b-') plt.title('Loss Curve') plt.ylabel('Loss Value') plt.xlabel('Iteration') plt.subplot(422) plt.plot(cp.asnumpy(cp.arange(len(convs))), cp.asnumpy(cp.clip(cp.array(convs), a_min=None, a_max=1e14)), 'b-') plt.title('Convergence Index Curve') plt.ylabel('Convergence Index') plt.xlabel('Iteration') amp = cp.array(cv2.resize( read_tiff(row.AMPLITUDE.values[0])[0], hres_size)) phase = cp.array(cv2.resize(read_tiff(row.PHASE.values[0])[0], hres_size)) plt.subplot(434) plt.title(f'amplitude (Scaled up from {lres_size})') plt.imshow(cp.asnumpy(to_uint8(amp))) opts() plt.subplot(435) plt.title(f'phase (Scaled up from {lres_size})') plt.imshow(cp.asnumpy(to_uint8(phase))) plt.subplot(436) rec = abs(cp.sqrt(amp) * cp.exp(1j * phase)) plt.title(f'Ground Truth (Scaled up from {lres_size})') plt.imshow(cp.asnumpy(to_uint8(rec))) plt.subplot(437) plt.title('Reconstruction Amplitude') amp = abs(o) if lres_size == hres_size: amp = correct(amp) plt.imshow(cp.asnumpy(to_uint8((amp)))) plt.subplot(438) plt.title('Reconstruction Phase') phase = cp.angle(o) if lres_size == hres_size: phase = correct(phase) plt.imshow(cp.asnumpy(to_uint8(phase))) plt.subplot(439) plt.title('Reconstructed Image') rec = abs(cp.sqrt(amp) * cp.exp(1j * phase)) plt.imshow(cp.asnumpy(to_uint8(rec))) plt.subplot(427) plt.title(f'Recovered Pupil') p_show = cp.mod(ctf * cp.angle(p), 2 * cp.pi) p_show = (p_show / p_show.max() * 255).astype(np.uint8) plt.imshow(cp.asnumpy(p_show), cmap='nipy_spectral') plt.subplot(428) plt.title(f'Raw frames\' mean (Scaled up from {lres_size})') plt.imshow(cv2.resize(cp.asnumpy(cp.array(imgs).mean(axis=0)), hres_size)) if out_path is None: plt.show() else: plt.savefig(out_path, bbox_inches='tight') plt.close('all') # Ignore early noise and print where the error is lowest if n_iters > 10: it = cp.argmin(cp.array(convs[10:])) + 11 if out_path is not None: print(f'Convergence index lowest at {it}th iteration.') else: it = cp.argmin(cp.array(convs)) + 1 if out_path is not None: print(f'Convergence index lowest at {it}th iteration.') if lres_size == hres_size: o = correct(o) return o, p, it
def qmf(hk): """ Return high-pass qmf filter from low-pass Parameters ---------- hk : array_like Coefficients of high-pass filter. """ N = len(hk) - 1 asgn = [{0: 1, 1: -1}[k % 2] for k in range(N + 1)] return hk[::-1] * cp.array(asgn) """ Return (x, phi, psi) at dyadic points ``K/2**J`` from filter coefficients. Parameters ---------- hk : array_like Coefficients of low-pass filter. J : int, optional Values will be computed at grid points ``K/2**J``. Default is 7. Returns ------- x : ndarray The dyadic points ``K/2**J`` for ``K=0...N * (2**J)-1`` where ``len(hk) = len(gk) = N+1``. phi : ndarray The scaling function ``phi(x)`` at `x`: ``phi(x) = sum(hk * phi(2x-k))``, where k is from 0 to N. psi : ndarray, optional The wavelet function ``psi(x)`` at `x`: ``phi(x) = sum(gk * phi(2x-k))``, where k is from 0 to N. `psi` is only returned if `gk` is not None. Notes ----- The algorithm uses the vector cascade algorithm described by Strang and Nguyen in "Wavelets and Filter Banks". It builds a dictionary of values and slices for quick reuse. Then inserts vectors into final vector at the end. """ N = len(hk) - 1 if (J > 30 - cp.log2(N + 1)): raise ValueError("Too many levels.") if (J < 1): raise ValueError("Too few levels.") # construct matrices needed nn, kk = cp.ogrid[:N, :N] s2 = cp.sqrt(2) # append a zero so that take works thk = cp.r_[hk, 0] gk = qmf(hk) tgk = cp.r_[gk, 0] indx1 = cp.clip(2 * nn - kk, -1, N + 1) indx2 = cp.clip(2 * nn - kk + 1, -1, N + 1) m = cp.zeros((2, 2, N, N), 'd') m[0, 0] = cp.take(thk, indx1, 0) m[0, 1] = cp.take(thk, indx2, 0) m[1, 0] = cp.take(tgk, indx1, 0) m[1, 1] = cp.take(tgk, indx2, 0) m *= s2 # construct the grid of points x = cp.arange(0, N * (1 << J), dtype=float) / (1 << J) phi = 0 * x psi = 0 * x # find phi0, and phi1 lam, v = eig(m[0, 0]) ind = cp.argmin(cp.absolute(lam - 1)) # a dictionary with a binary representation of the # evaluation points x < 1 -- i.e. position is 0.xxxx v = cp.real(v[:, ind]) # need scaling function to integrate to 1 so find # eigenvector normalized to sum(v,axis=0)=1 sm = cp.sum(v) if sm < 0: # need scaling function to integrate to 1 v = -v sm = -sm bitdic = {'0': v / sm} bitdic['1'] = cp.dot(m[0, 1], bitdic['0']) step = 1 << J phi[::step] = bitdic['0'] phi[(1 << (J - 1))::step] = bitdic['1'] psi[::step] = cp.dot(m[1, 0], bitdic['0']) psi[(1 << (J - 1))::step] = cp.dot(m[1, 1], bitdic['0']) # descend down the levels inserting more and more values # into bitdic -- store the values in the correct location once we # have computed them -- stored in the dictionary # for quicker use later. prevkeys = ['1'] for level in range(2, J + 1): newkeys = ['%d%s' % (xx, yy) for xx in [0, 1] for yy in prevkeys] fac = 1 << (J - level) for key in newkeys: # convert key to number num = 0 for pos in range(level): if key[pos] == '1': num += (1 << (level - 1 - pos)) pastphi = bitdic[key[1:]] ii = int(key[0]) temp = cp.dot(m[0, ii], pastphi) bitdic[key] = temp phi[num * fac::step] = temp psi[num * fac::step] = cp.dot(m[1, ii], pastphi) prevkeys = newkeys return x, phi, psi
def nn_naive(ref, query): dist = ((ref[None, :, :] - query[:, None, :])**2).sum(axis=2) # indices of ref for each query point indices = cupy.argmin(dist, axis=1) return indices