def preprocess_data(x, y): x = np.swapaxes(x, 0, 1) y = np.swapaxes(y, 0, 1) x = np.array(x) y = np.array(y) return x, y
def deskew(data, angle, dx, dz, rotate=True, return_resolution=True, out=None): """ Args: data (ndarray): 3-D array to apply deskew angle (float): angle between the objective and coverslip, in degree dx (float): X resolution dz (float): Z resolution rotate (bool, optional): rotate and crop the output return_resolution (bool, optional): return deskewed X/Z resolution out (ndarray, optional): array to store the result """ angle = radians(angle) # shift along X axis, in pixels shift = dz * cos(angle) / dx logger.debug(f"layer shift: {shift:.04f} px") # estimate new size nw, nv, nu = data.shape nz, ny, nx = nw, nv, nu + ceil(shift * (nw - 1)) # upload texture ch = ChannelFormatDescriptor(32, 0, 0, 0, runtime.cudaChannelFormatKindFloat) arr = CUDAarray(ch, nu, nw) res = ResourceDescriptor(runtime.cudaResourceTypeArray, cuArr=arr) address_mode = (runtime.cudaAddressModeBorder, runtime.cudaAddressModeBorder) tex = TextureDescriptor(address_mode, runtime.cudaFilterModeLinear, runtime.cudaReadModeElementType) # transpose data = np.swapaxes(data, 0, 1) data = np.ascontiguousarray(data) data_in = data.astype(np.float32) data_out = cp.empty((ny, nz, nx), np.float32) for i, layer in enumerate(data_in): arr.copy_from(layer) # TODO use stream texobj = TextureObject(res, tex) kernels["shear_kernel"]( (ceil(nx / 16), ceil(nz / 16)), (16, 16), (data_out[i, ...], texobj, nx, nz, nu, np.float32(shift)), ) data_out = cp.swapaxes(data_out, 0, 1) data_out = cp.asnumpy(data_out) data_out = data_out.astype(data.dtype) if return_resolution: # new resolution dz *= sin(angle) return data_out, (dz, dx) else: return data_out
def dot_adjoint_0(B, G, A_ndim, B_ndim): # The adjoint of the operator # A |--> np.dot(A, B) if B_ndim == 0 or B_ndim == 1 or A_ndim == 0: contract_num = max(0, B_ndim - (A_ndim != 0)) return ocp.tensordot(G, B, contract_num) else: return ocp.tensordot(G, ocp.swapaxes(B, -1, -2), B_ndim - 1)
def next_batch(self, batch_size, reshuffle_after_pass=True, swapaxes=False): if self.n < batch_size: raise ValueError('Batch size can be at most the dataset size') actual_batch_size = min(batch_size, self.n - self.batch_start) if actual_batch_size < batch_size: if reshuffle_after_pass: self.cur_order = np.random.permutation(self.n) self.batch_start = 0 batch_end = self.batch_start + batch_size batch_xs = self.xs[self.cur_order[self.batch_start:batch_end], ...] batch_ys = self.ys[self.cur_order[self.batch_start:batch_end], ...] self.batch_start += batch_size if swapaxes: batch_xs = np.swapaxes(batch_xs, 0, 1) batch_ys = np.swapaxes(batch_ys, 0, 1) return batch_xs, batch_ys
def apply_unitary_transformation_to_density_matrices_cupy( unitary: cupy.ndarray, density_matrices: cupy.ndarray ): dim1, dim2 = unitary.shape num_states, dim3, dim4 = density_matrices.shape assert dim1 == dim2 == dim3 == dim4 # unitary U[i,k] D[nwf,k,l] -> B[i,nwf,l] mat_b = tensordot(unitary, density_matrices, axes=[[1], [1]]) # B[i,nwf,k] U'[k,l] -> ret[i,nwf,l] ret = tensordot(mat_b, transpose(conj(unitary)), axes=[[2], [0]]) return swapaxes(ret, axis1=0, axis2=1)
def apply_isometry_to_density_matrices_cupy( isometry: cupy.ndarray, density_matrices: cupy.ndarray ): outdim, dim1 = isometry.shape num_states, dim2, dim3 = density_matrices.shape assert dim1 == dim2 == dim3 # unitary U[i,k] D[nwf,k,l] -> B[i,nwf,l] mat_b = tensordot(isometry, density_matrices, axes=[[1], [1]]) # B[i,nwf,k] U'[k,l] -> ret[i,nwf,l] ret = tensordot(mat_b, transpose(conj(isometry)), axes=[[2], [0]]) return swapaxes(ret, axis1=0, axis2=1)
def ycbcr2rgb(self, y=None, cb=None, cr=None): """colorspacetransformation from y,cb,cr to rgb input: y,cb,cr values saved as lists channels = true for rgb arrays, false for pil image return: rgb image as PIL.Image""" if(args.verbose): print("Performing colorspace transformation from YCbCr to RGB") ycbcr = np.array((y,cb,cr)) if args.numba: rgb = numba_ycbcr2rgb(self.backtrafo_table, ycbcr) else: ycbcr[1] -= 128 ycbcr[2] -= 128 rgb = self.backtrafo_table @ ycbcr rgb = np.rint(rgb).astype(np.int16) rgb = rgb.reshape(3, self.height_e, self.width_e) rgb = np.clip(rgb, 0, 255) # bring axes in correct order rgb = np.swapaxes(rgb, 0,2) rgb = np.swapaxes(rgb, 0,1) if args.cupy: rgb_img = Image.fromarray(np.asnumpy(rgb).astype(np.uint8),'RGB') else: rgb_img = Image.fromarray(rgb.astype(np.uint8),'RGB') crop_recomb = self.cropping_back(rgb_img) r = np.array(crop_recomb.getchannel('R')).flatten().astype(np.int16) g = np.array(crop_recomb.getchannel('G')).flatten().astype(np.int16) b = np.array(crop_recomb.getchannel('B')).flatten().astype(np.int16) rgb_out = np.concatenate((np.array([r]), np.array([g]), np.array([b]))) if(args.debug): crop_recomb.save(os.path.join(inputpath, args.output, "debug", infilename + "_rücktrafo.png")) return crop_recomb, rgb_out
def dot_product_normalized_trans(self, coef_vector, norms): product = np.zeros(self.num_cols) loc = 0 for i in range(len(self.files)): with cp.cuda.Device(self.gpu_list[i % self.num_gpus]): norm_gpu = cp.asarray(norms) coef = cp.asarray(coef_vector) matrix_part = cp.load(self.files[i]) matrix_part = matrix_part / norm_gpu matrix_part = cp.swapaxes(matrix_part, 0, 1) n = matrix_part.shape[1] prod = cp.matmul(matrix_part, coef[loc:loc + n]) loc = loc + n product = product + prod.get() return product
def find_prob(measured_qubits, sub_state, states): # Make sure measured qubit numbers are in ascending order qubits = measured_qubits qubits.sort() # Make a copy of given states in order not to alter them a = states.copy() d1, d2 = a.shape # d1 = number of circuit runs, d2 = 2 ** N N = int(rint(log2(d2))) # Reshape to rank-(N+1) tensor a = a.reshape([d1] + [2] * N) # K = number of measured qubits, M = number of qubits not measured K = len(qubits) M = N - K # Reorder qubit number axes for i in range(K): a = swapaxes(a, i + 1, qubits[i] + 1) # Flatten arrays for 2 groups of qubits a = a.reshape([d1] + [2**K] + [2**M]) # Broadcast multiply coefficients a = swapaxes(a, 0, 1) a = multiply(a.T, sub_state).T # Sum over coefficients a = a.sum(axis=0) a = abs(a)**2 a = a.sum(axis=1) # Return probability of measuring a substate for all circuit runs return a
def dot_adjoint_1(A, G, A_ndim, B_ndim): # The adjoint of the operator # B |--> np.dot(A, B) needs_transpose = B_ndim > 1 and A_ndim != 0 swap = ((lambda x: ocp.swapaxes(x, -1, -2)) if needs_transpose else (lambda x: x)) # noqa: E501 if A_ndim == 0 or A_ndim == 1 or B_ndim == 0: contract_num = max(0, A_ndim - (B_ndim != 0)) return swap(ocp.tensordot(G, A, contract_num)) else: return swap( ocp.tensordot( G, A, [ range(-A_ndim - B_ndim + 2, -B_ndim + 1), range(A_ndim - 1), ], # noqa: E501 ))
def test_rgb2luv_brucelindbloom(self): """ Test the RGB->Lab conversion by comparing to the calculator on the authoritative Bruce Lindbloom [website](http://brucelindbloom.com/index.html?ColorCalculator.html). """ # Obtained with D65 white point, sRGB model and gamma # ftm: off gt_for_colbars = cp.asarray([ [100, 0, 0], [97.1393, 7.7056, 106.7866], [91.1132, -70.4773, -15.2042], [87.7347, -83.0776, 107.3985], [60.3242, 84.0714, -108.6834], [53.2408, 175.0151, 37.7564], [32.2970, -9.4054, -130.3423], [0, 0, 0]]).T # ftm: on gt_array = cp.swapaxes(gt_for_colbars.reshape(3, 4, 2), 0, 2) assert_array_almost_equal(rgb2luv(self.colbars_array), gt_array, decimal=2)
def test_rgb2lab_brucelindbloom(self): """ Test the RGB->Lab conversion by comparing to the calculator on the authoritative Bruce Lindbloom [website](http://brucelindbloom.com/index.html?ColorCalculator.html). """ # Obtained with D65 white point, sRGB model and gamma # ftm: off gt_for_colbars = cp.asarray([ [100, 0, 0], [97.1393, -21.5537, 94.4780], [91.1132, -48.0875, -14.1312], [87.7347, -86.1827, 83.1793], [60.3242, 98.2343, -60.8249], [53.2408, 80.0925, 67.2032], [32.2970, 79.1875, -107.8602], [0, 0, 0]]).T # ftm: on gt_array = cp.swapaxes(gt_for_colbars.reshape(3, 4, 2), 0, 2) assert_array_almost_equal(rgb2lab(self.colbars_array), gt_array, decimal=2)
def transform(self, images): """ Parameters ---------- images: np.ndarray | Color / grayscale images of shape | (n_images, height, width, n_channels) or | (n_images, height, width) Returns ------- X: np.ndarray A set of feature vectors of shape (n_images, n_features) where :code:`n_features` is determined by the hyperparameters """ images = self.process_input(images) # images.shape == (n_images, n_channels, y, x) N = images.shape[0] filters_l1 = components_to_filters( self.pca_l1.components_, n_channels=images.shape[1], filter_shape=self.filter_shape_l1, ) filters_l2 = components_to_filters(self.pca_l2.components_, n_channels=1, filter_shape=self.filter_shape_l2) filters_l3 = components_to_filters(self.pca_l3.components_, n_channels=1, filter_shape=self.filter_shape_l3) if gpu_enabled(): images = to_gpu(images) filters_l1 = to_gpu(filters_l1) filters_l2 = to_gpu(filters_l2) filters_l3 = to_gpu(filters_l3) images = convolution_2d(images.astype('float32'), filters_l1, stride=self.step_shape_l1).data print("Memory: {}Mb".format(memory_profiler.memory_usage())) images = images.reshape(-1, *images.shape[2:4]) images = convolution_2d( images.reshape( images.shape[0], 1, images.shape[1], images.shape[2]).astype('float32'), # 1 channel images filters_l2, stride=self.step_shape_l2).data print("Memory: {}Mb".format(memory_profiler.memory_usage())) images = images.reshape(N, self.n_l1_output * self.n_l2_output, images.shape[2], images.shape[3]) images = xp.swapaxes(images, 0, 1) print(images.shape) # L1*L2.shape == (L1*L2, n_images, y, x) # iterate over each L1*L2 output X = [] for maps in images: n_images, h, w = maps.shape #print(type(maps)) #print(type(filters_l3)) maps = convolution_2d( maps.reshape(n_images, 1, h, w).astype('float32'), # 1 channel images filters_l3, stride=self.step_shape_l3).data # maps.shape == (n_images, L1*L2*L3, y, x) right here maps = binarize(maps) maps = binary_to_decimal(maps) # maps.shape == (n_images, y, x) t1 = timeit.default_timer() x = self.histogram(maps) t2 = timeit.default_timer() hist_time = t2 - t1 print("hist_time: %f" % hist_time) # x is a set of feature vectors. # The shape of x is (n_images, vector length) X.append(x) # concatenate over L1 X = xp.hstack(X) if gpu_enabled(): X = to_cpu(X) X = X.astype(np.float32) print("Memory: {}Mb".format(memory_profiler.memory_usage())) # The shape of X is (n_images, L1 * vector length) return X
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
def test_swapaxes_failure(self): a = testing.shaped_arange((2, 3, 4)) with self.assertRaises(ValueError): cupy.swapaxes(a, 3, 0)
def eig_special_3d(S, full=False): """Eigensolution for symmetric real 3-by-3 matrices. Arguments: S: array-like A floating point array with shape ``(6, ...)`` containing structure tensor. Use float64 to avoid numerical errors. When using lower precision, ensure that the values of S are not very small/large. Pass cupy.ndarray to avoid copying S. full: bool, optional A flag indicating that all three eigenvalues should be returned. Returns: val: cupy.ndarray An array with shape ``(3, ...)`` containing sorted eigenvalues vec: cupy.ndarray An array with shape ``(3, ...)`` containing eigenvector corresponding to the smallest eigenvalue. If full, vec has shape ``(3, 3, ...)`` and contains all three eigenvectors. More: An analytic solution of eigenvalue problem for real symmetric matrix, using an affine transformation and a trigonometric solution of third order polynomial. See https://en.wikipedia.org/wiki/Eigenvalue_algorithm which refers to Smith's algorithm https://dl.acm.org/citation.cfm?id=366316. Authors: [email protected], 2019; [email protected], 2019-2020 """ S = np.asarray(S) # Check data type. Must be floating point. if not np.issubdtype(S.dtype, np.floating): raise ValueError('S must be floating point type.') # Flatten S. input_shape = S.shape S = S.reshape(6, -1) # Create v vector. v = np.array([[2 * np.pi / 3], [4 * np.pi / 3]], dtype=S.dtype) # Computing eigenvalues. # Allocate vec and val. We will use them for intermediate computations as well. if full: val = np.empty((3, ) + S.shape[1:], dtype=S.dtype) vec = np.empty((9, ) + S.shape[1:], dtype=S.dtype) tmp = np.empty((4, ) + S.shape[1:], dtype=S.dtype) B03 = val B36 = vec[:3] else: val = np.empty((3, ) + S.shape[1:], dtype=S.dtype) vec = np.empty((3, ) + S.shape[1:], dtype=S.dtype) tmp = np.empty((4, ) + S.shape[1:], dtype=S.dtype) B03 = val B36 = vec # Views for B. B0 = B03[0] B1 = B03[1] B2 = B03[2] B3 = B36[0] B4 = B36[1] B5 = B36[2] # Compute q, mean of diagonal. We need to use q multiple times later. # Using np.mean has precision issues. q = np.add(S[0], S[1], out=tmp[0]) q += S[2] q /= 3 # Compute S minus q. Insert it directly into B where it'll stay. Sq = np.subtract(S[:3], q, out=B03) # Compute s, off-diagonal elements. Store in part of B not yet used. s = np.sum(np.multiply(S[3:], S[3:], out=B36), axis=0, out=tmp[1]) s *= 2 # Compute p. p = np.sum(np.multiply(Sq, Sq, out=B36), axis=0, out=tmp[2]) del Sq # Last use of Sq. p += s p *= 1 / 6 np.sqrt(p, out=p) # Compute inverse p, while avoiding 0 division. # Reuse s allocation and delete s to ensure we don't efter it's been reused. p_inv = s del s non_zero_p_mask = p == 0 np.divide(1, p, out=p_inv) p_inv[non_zero_p_mask] = 0 # Compute B. First part is already filled. B03 *= p_inv np.multiply(S[3:], p_inv, out=B36) # Compute d, determinant of B. d = np.prod(B03, axis=0, out=tmp[3]) # Reuse allocation for p_inv and delete variable. d_tmp = p_inv del p_inv # Computation of d. np.multiply(B2, B3, d_tmp) d_tmp *= B3 d -= d_tmp np.multiply(B4, B4, out=d_tmp) d_tmp *= B1 d -= d_tmp np.prod(B36, axis=0, out=d_tmp) d_tmp *= 2 d += d_tmp np.multiply(B5, B5, out=d_tmp) d_tmp *= B0 d -= d_tmp d *= 0.5 # Ensure -1 <= d/2 <= 1. np.clip(d, -1, 1, out=d) # Compute phi. Beware that we reuse d variable! phi = d del d phi = np.arccos(phi, out=phi) phi /= 3 # Compute val, ordered eigenvalues. Resuing B allocation. del B03, B36, B0, B1, B2, B3, B4, B5 np.add(v, phi[np.newaxis], out=val[:2]) val[2] = phi np.cos(val, out=val) p *= 2 val *= p val += q # Remove all variable using tmp allocation. del q del p del phi del d_tmp # Computing eigenvectors -- either only one or all three. if full: l = val vec = vec.reshape(3, 3, -1) vec_tmp = tmp[:3] else: l = val[0] vec_tmp = tmp[2] # Compute vec. The tmp variable can be reused. # u = S[4] * S[5] - (S[2] - l) * S[3] u = np.subtract(S[2], l, out=vec[0]) np.multiply(u, S[3], out=u) u_tmp = np.multiply(S[4], S[5], out=tmp[3]) np.subtract(u_tmp, u, out=u) # Put values of u into vector 2 aswell. # v = S[3] * S[5] - (S[1] - l) * S[4] v = np.subtract(S[1], l, out=vec_tmp) np.multiply(v, S[4], out=v) v_tmp = np.multiply(S[3], S[5], out=tmp[3]) np.subtract(v_tmp, v, out=v) # w = S[3] * S[4] - (S[0] - l) * S[5] w = np.subtract(S[0], l, out=vec[2]) np.multiply(w, S[5], out=w) w_tmp = np.multiply(S[3], S[4], out=tmp[3]) np.subtract(w_tmp, w, out=w) vec[1] = u np.multiply(u, v, out=vec[0]) u = vec[1] np.multiply(u, w, out=vec[1]) np.multiply(v, w, out=vec[2]) # Remove u, v, w and l variables. del u del v del w del l # Normalizing -- depends on number of vectors. if full: # vec is [x1 x2 x3, y1 y2 y3, z1 z2 z3] l = np.sum(np.square(vec), axis=0, out=vec_tmp)[:, np.newaxis] vec = np.swapaxes(vec, 0, 1) else: # vec is [x1 y1 z1] = v1 l = np.sum(np.square(vec, out=tmp[:3]), axis=0, out=vec_tmp) cp.rsqrt(l, out=l) vec *= l return val.reshape(val.shape[:-1] + input_shape[1:]), vec.reshape(vec.shape[:-1] + input_shape[1:])
class TestColorconv(TestCase): img_rgb = cp.asarray(data.colorwheel()) img_grayscale = cp.asarray(data.camera()) # ftm: off img_rgba = cp.array([[[0, 0.5, 1, 0], [0, 0.5, 1, 1], [0, 0.5, 1, 0.5]]]).astype(float) colbars = cp.array([[1, 1, 0, 0, 1, 1, 0, 0], [1, 1, 1, 1, 0, 0, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0]]).astype(float) colbars_array = cp.swapaxes(colbars.reshape(3, 4, 2), 0, 2) colbars_point75 = colbars * 0.75 colbars_point75_array = cp.swapaxes(colbars_point75.reshape(3, 4, 2), 0, 2) xyz_array = cp.asarray([[[0.4124, 0.21260, 0.01930]], # red [[0, 0, 0]], # black [[.9505, 1., 1.089]], # white [[.1805, .0722, .9505]], # blue [[.07719, .15438, .02573]], # green ]) lab_array = cp.asarray([[[53.233, 80.109, 67.220]], # red [[0., 0., 0.]], # black [[100.0, 0.005, -0.010]], # white [[32.303, 79.197, -107.864]], # blue [[46.229, -51.7, 49.898]], # green ]) luv_array = cp.asarray([[[53.233, 175.053, 37.751]], # red [[0., 0., 0.]], # black [[100., 0.001, -0.017]], # white [[32.303, -9.400, -130.358]], # blue [[46.228, -43.774, 56.589]], # green ]) # ftm: on # RGBA to RGB def test_rgba2rgb_conversion(self): rgba = self.img_rgba rgb = rgba2rgb(rgba) # ftm: off expected = cp.asarray([[[1, 1, 1], [0, 0.5, 1], [0.5, 0.75, 1]]]).astype(float) # ftm: on self.assertEqual(rgb.shape, expected.shape) assert_array_almost_equal(rgb, expected) def test_rgba2rgb_error_grayscale(self): self.assertRaises(ValueError, rgba2rgb, self.img_grayscale) def test_rgba2rgb_error_rgb(self): self.assertRaises(ValueError, rgba2rgb, self.img_rgb) def test_rgba2rgb_dtype(self): rgba = self.img_rgba.astype("float64") rgba32 = img_as_float32(rgba) assert rgba2rgb(rgba).dtype == rgba.dtype assert rgba2rgb(rgba32).dtype == rgba32.dtype # RGB to HSV def test_rgb2hsv_conversion(self): rgb = img_as_float(self.img_rgb)[::16, ::16] hsv = rgb2hsv(rgb).reshape(-1, 3) # ground truth from colorsys gt = np.asarray([colorsys.rgb_to_hsv(pt[0], pt[1], pt[2]) for pt in cp.asnumpy(rgb).reshape(-1, 3)]) assert_array_almost_equal(hsv, gt) def test_rgb2hsv_error_grayscale(self): self.assertRaises(ValueError, rgb2hsv, self.img_grayscale) def test_rgb2hsv_dtype(self): rgb = img_as_float(self.img_rgb) rgb32 = img_as_float32(self.img_rgb) assert rgb2hsv(rgb).dtype == rgb.dtype assert rgb2hsv(rgb32).dtype == rgb32.dtype # HSV to RGB def test_hsv2rgb_conversion(self): rgb = self.img_rgb.astype("float32")[::16, ::16] # create HSV image with colorsys hsv = cp.asarray( [ colorsys.rgb_to_hsv(pt[0], pt[1], pt[2]) for pt in rgb.reshape(-1, 3).get() ] ).reshape(rgb.shape) # convert back to RGB and compare with original. # relative precision for RGB -> HSV roundtrip is about 1e-6 assert_array_almost_equal(rgb, hsv2rgb(hsv), decimal=4) def test_hsv2rgb_error_grayscale(self): self.assertRaises(ValueError, hsv2rgb, self.img_grayscale) def test_hsv2rgb_dtype(self): rgb = self.img_rgb.astype("float32")[::16, ::16] # create HSV image with colorsys hsv = cp.asarray( [ colorsys.rgb_to_hsv(pt[0], pt[1], pt[2]) for pt in rgb.reshape(-1, 3).get() ], dtype="float64", ).reshape(rgb.shape) hsv32 = hsv.astype("float32") assert hsv2rgb(hsv).dtype == hsv.dtype assert hsv2rgb(hsv32).dtype == hsv32.dtype # RGB to XYZ def test_rgb2xyz_conversion(self): # ftm: off gt = cp.asarray([[[0.950456, 1. , 1.088754], # noqa [0.538003, 0.787329, 1.06942 ], # noqa [0.592876, 0.28484 , 0.969561], # noqa [0.180423, 0.072169, 0.950227]], # noqa [[0.770033, 0.927831, 0.138527], # noqa [0.35758 , 0.71516 , 0.119193], # noqa [0.412453, 0.212671, 0.019334], # noqa [0. , 0. , 0. ]]]) # noqa # ftm: on assert_array_almost_equal(rgb2xyz(self.colbars_array), gt) # stop repeating the "raises" checks for all other functions that are # implemented with color._convert() def test_rgb2xyz_error_grayscale(self): self.assertRaises(ValueError, rgb2xyz, self.img_grayscale) def test_rgb2xyz_dtype(self): img = self.colbars_array img32 = img.astype('float32') assert rgb2xyz(img).dtype == img.dtype assert rgb2xyz(img32).dtype == img32.dtype # XYZ to RGB def test_xyz2rgb_conversion(self): assert_array_almost_equal(xyz2rgb(rgb2xyz(self.colbars_array)), self.colbars_array) def test_xyz2rgb_dtype(self): img = rgb2xyz(self.colbars_array) img32 = img.astype('float32') assert xyz2rgb(img).dtype == img.dtype assert xyz2rgb(img32).dtype == img32.dtype # RGB<->XYZ roundtrip on another image def test_xyz_rgb_roundtrip(self): img_rgb = img_as_float(self.img_rgb) assert_array_almost_equal(xyz2rgb(rgb2xyz(img_rgb)), img_rgb) # RGB<->HED roundtrip with ubyte image def test_hed_rgb_roundtrip(self): img_rgb = img_as_ubyte(self.img_rgb) new = img_as_ubyte(hed2rgb(rgb2hed(img_rgb))) assert_array_equal(new, img_rgb) # RGB<->HED roundtrip with float image def test_hed_rgb_float_roundtrip(self): img_rgb = img_as_float(self.img_rgb) assert_array_almost_equal(hed2rgb(rgb2hed(img_rgb)), img_rgb) # RGB<->HDX roundtrip with ubyte image def test_hdx_rgb_roundtrip(self): from cucim.skimage.color.colorconv import hdx_from_rgb, rgb_from_hdx img_rgb = self.img_rgb conv = combine_stains(separate_stains(img_rgb, hdx_from_rgb), rgb_from_hdx) assert_array_equal(img_as_ubyte(conv), img_rgb) # RGB<->HDX roundtrip with float image def test_hdx_rgb_roundtrip_float(self): from cucim.skimage.color.colorconv import hdx_from_rgb, rgb_from_hdx img_rgb = img_as_float(self.img_rgb) conv = combine_stains(separate_stains(img_rgb, hdx_from_rgb), rgb_from_hdx) assert_array_almost_equal(conv, img_rgb) # RGB to RGB CIE def test_rgb2rgbcie_conversion(self): # ftm: off gt = cp.asarray([[[ 0.1488856 , 0.18288098, 0.19277574], # noqa [ 0.01163224, 0.16649536, 0.18948516], # noqa [ 0.12259182, 0.03308008, 0.17298223], # noqa [-0.01466154, 0.01669446, 0.16969164]], # noqa [[ 0.16354714, 0.16618652, 0.0230841 ], # noqa [ 0.02629378, 0.1498009 , 0.01979351], # noqa [ 0.13725336, 0.01638562, 0.00329059], # noqa [ 0. , 0. , 0. ]]]) # noqa # ftm: on assert_array_almost_equal(rgb2rgbcie(self.colbars_array), gt) def test_rgb2rgbcie_dtype(self): img = self.colbars_array.astype('float64') img32 = img.astype('float32') assert rgb2rgbcie(img).dtype == img.dtype assert rgb2rgbcie(img32).dtype == img32.dtype # RGB CIE to RGB def test_rgbcie2rgb_conversion(self): # only roundtrip test, we checked rgb2rgbcie above already assert_array_almost_equal(rgbcie2rgb(rgb2rgbcie(self.colbars_array)), self.colbars_array) def test_rgbcie2rgb_dtype(self): img = rgb2rgbcie(self.colbars_array).astype('float64') img32 = img.astype('float32') assert rgbcie2rgb(img).dtype == img.dtype assert rgbcie2rgb(img32).dtype == img32.dtype def test_convert_colorspace(self): colspaces = ['HSV', 'RGB CIE', 'XYZ', 'YCbCr', 'YPbPr', 'YDbDr'] colfuncs_from = [ hsv2rgb, rgbcie2rgb, xyz2rgb, ycbcr2rgb, ypbpr2rgb, ydbdr2rgb ] colfuncs_to = [ rgb2hsv, rgb2rgbcie, rgb2xyz, rgb2ycbcr, rgb2ypbpr, rgb2ydbdr ] assert_array_almost_equal( convert_colorspace(self.colbars_array, 'RGB', 'RGB'), self.colbars_array) for i, space in enumerate(colspaces): # print(f"space={space}") gt = colfuncs_from[i](self.colbars_array) assert_array_almost_equal( convert_colorspace(self.colbars_array, space, 'RGB'), gt) gt = colfuncs_to[i](self.colbars_array) assert_array_almost_equal( convert_colorspace(self.colbars_array, 'RGB', space), gt) self.assertRaises(ValueError, convert_colorspace, self.colbars_array, 'nokey', 'XYZ') self.assertRaises(ValueError, convert_colorspace, self.colbars_array, 'RGB', 'nokey') def test_rgb2gray(self): x = cp.asarray([1, 1, 1]).reshape((1, 1, 3)).astype(float) g = rgb2gray(x) assert_array_almost_equal(g, 1) assert_array_equal(g.shape, (1, 1)) def test_rgb2gray_contiguous(self): x = cp.random.rand(10, 10, 3) assert rgb2gray(x).flags["C_CONTIGUOUS"] assert rgb2gray(x[:5, :5]).flags["C_CONTIGUOUS"] def test_rgb2gray_alpha(self): x = cp.random.rand(10, 10, 4) with expected_warnings(['Non RGB image conversion']): assert rgb2gray(x).ndim == 2 def test_rgb2gray_on_gray(self): with expected_warnings(['The behavior of rgb2gray will change']): rgb2gray(cp.random.rand(5, 5)) def test_rgb2gray_dtype(self): img = cp.random.rand(10, 10, 3).astype('float64') img32 = img.astype('float32') assert rgb2gray(img).dtype == img.dtype assert rgb2gray(img32).dtype == img32.dtype # test matrices for xyz2lab and lab2xyz generated using # http://www.easyrgb.com/index.php?X=CALC # Note: easyrgb website displays xyz*100 def test_xyz2lab(self): assert_array_almost_equal(xyz2lab(self.xyz_array), self.lab_array, decimal=3) # Test the conversion with the rest of the illuminants. for i in ["d50", "d55", "d65", "d75"]: for obs in ["2", "10"]: fname = "color/tests/data/lab_array_{0}_{1}.npy".format(i, obs) lab_array_i_obs = np.load(fetch(fname)) assert_array_almost_equal(lab_array_i_obs, xyz2lab(self.xyz_array, i, obs), decimal=2) for i in ["a", "e"]: fname = "color/tests/data/lab_array_{0}_2.npy".format(i) lab_array_i_obs = np.load(fetch(fname)) assert_array_almost_equal(lab_array_i_obs, xyz2lab(self.xyz_array, i, "2"), decimal=2) def test_xyz2lab_dtype(self): img = self.xyz_array.astype('float64') img32 = img.astype('float32') assert xyz2lab(img).dtype == img.dtype assert xyz2lab(img32).dtype == img32.dtype def test_lab2xyz(self): assert_array_almost_equal(lab2xyz(self.lab_array), self.xyz_array, decimal=3) # Test the conversion with the rest of the illuminants. for i in ["d50", "d55", "d65", "d75"]: for obs in ["2", "10"]: fname = "color/tests/data/lab_array_{0}_{1}.npy".format(i, obs) lab_array_i_obs = cp.array(np.load(fetch(fname))) assert_array_almost_equal(lab2xyz(lab_array_i_obs, i, obs), self.xyz_array, decimal=3) for i in ["a", "e"]: fname = "lab_array_{0}_2.npy".format(i) lab_array_i_obs = cp.array( np.load(fetch('color/tests/data/' + fname))) assert_array_almost_equal(lab2xyz(lab_array_i_obs, i, "2"), self.xyz_array, decimal=3) # And we include a call to test the exception handling in the code. try: lab2xyz(lab_array_i_obs, "Nai", "2") # Not an illuminant except ValueError: pass try: lab2xyz(lab_array_i_obs, "d50", "42") # Not a degree except ValueError: pass def test_lab2xyz_dtype(self): img = self.lab_array.astype('float64') img32 = img.astype('float32') assert lab2xyz(img).dtype == img.dtype assert lab2xyz(img32).dtype == img32.dtype def test_rgb2lab_brucelindbloom(self): """ Test the RGB->Lab conversion by comparing to the calculator on the authoritative Bruce Lindbloom [website](http://brucelindbloom.com/index.html?ColorCalculator.html). """ # Obtained with D65 white point, sRGB model and gamma # ftm: off gt_for_colbars = cp.asarray([ [100, 0, 0], [97.1393, -21.5537, 94.4780], [91.1132, -48.0875, -14.1312], [87.7347, -86.1827, 83.1793], [60.3242, 98.2343, -60.8249], [53.2408, 80.0925, 67.2032], [32.2970, 79.1875, -107.8602], [0, 0, 0]]).T # ftm: on gt_array = cp.swapaxes(gt_for_colbars.reshape(3, 4, 2), 0, 2) assert_array_almost_equal(rgb2lab(self.colbars_array), gt_array, decimal=2) def test_lab_rgb_roundtrip(self): img_rgb = img_as_float(self.img_rgb) assert_array_almost_equal(lab2rgb(rgb2lab(img_rgb)), img_rgb) def test_rgb2lab_dtype(self): img = self.colbars_array.astype('float64') img32 = img.astype('float32') assert rgb2lab(img).dtype == img.dtype assert rgb2lab(img32).dtype == img32.dtype def test_lab2rgb_dtype(self): img = self.lab_array.astype('float64') img32 = img.astype('float32') assert lab2rgb(img).dtype == img.dtype assert lab2rgb(img32).dtype == img32.dtype # test matrices for xyz2luv and luv2xyz generated using # http://www.easyrgb.com/index.php?X=CALC # Note: easyrgb website displays xyz*100 def test_xyz2luv(self): assert_array_almost_equal(xyz2luv(self.xyz_array), self.luv_array, decimal=3) # Test the conversion with the rest of the illuminants. for i in ["d50", "d55", "d65", "d75"]: for obs in ["2", "10"]: fname = "color/tests/data/luv_array_{0}_{1}.npy".format(i, obs) luv_array_i_obs = cp.array(np.load(fetch(fname))) assert_array_almost_equal(luv_array_i_obs, xyz2luv(self.xyz_array, i, obs), decimal=2) for i in ["a", "e"]: fname = "color/tests/data/luv_array_{0}_2.npy".format(i) luv_array_i_obs = cp.array(np.load(fetch(fname))) assert_array_almost_equal(luv_array_i_obs, xyz2luv(self.xyz_array, i, "2"), decimal=2) def test_xyz2luv_dtype(self): img = self.xyz_array.astype('float64') img32 = img.astype('float32') assert xyz2luv(img).dtype == img.dtype assert xyz2luv(img32).dtype == img32.dtype def test_luv2xyz(self): assert_array_almost_equal(luv2xyz(self.luv_array), self.xyz_array, decimal=3) # Test the conversion with the rest of the illuminants. for i in ["d50", "d55", "d65", "d75"]: for obs in ["2", "10"]: fname = "color/tests/data/luv_array_{0}_{1}.npy".format(i, obs) luv_array_i_obs = cp.array(np.load(fetch(fname))) assert_array_almost_equal(luv2xyz(luv_array_i_obs, i, obs), self.xyz_array, decimal=3) for i in ["a", "e"]: fname = "color/tests/data/luv_array_{0}_2.npy".format(i) luv_array_i_obs = cp.array(np.load(fetch(fname))) assert_array_almost_equal(luv2xyz(luv_array_i_obs, i, "2"), self.xyz_array, decimal=3) def test_luv2xyz_dtype(self): img = self.luv_array.astype('float64') img32 = img.astype('float32') assert luv2xyz(img).dtype == img.dtype assert luv2xyz(img32).dtype == img32.dtype def test_rgb2luv_brucelindbloom(self): """ Test the RGB->Lab conversion by comparing to the calculator on the authoritative Bruce Lindbloom [website](http://brucelindbloom.com/index.html?ColorCalculator.html). """ # Obtained with D65 white point, sRGB model and gamma # ftm: off gt_for_colbars = cp.asarray([ [100, 0, 0], [97.1393, 7.7056, 106.7866], [91.1132, -70.4773, -15.2042], [87.7347, -83.0776, 107.3985], [60.3242, 84.0714, -108.6834], [53.2408, 175.0151, 37.7564], [32.2970, -9.4054, -130.3423], [0, 0, 0]]).T # ftm: on gt_array = cp.swapaxes(gt_for_colbars.reshape(3, 4, 2), 0, 2) assert_array_almost_equal(rgb2luv(self.colbars_array), gt_array, decimal=2) def test_rgb2luv_dtype(self): img = self.colbars_array.astype('float64') img32 = img.astype('float32') assert rgb2luv(img).dtype == img.dtype assert rgb2luv(img32).dtype == img32.dtype def test_luv2rgb_dtype(self): img = self.luv_array.astype('float64') img32 = img.astype('float32') assert luv2rgb(img).dtype == img.dtype assert luv2rgb(img32).dtype == img32.dtype def test_luv_rgb_roundtrip(self): img_rgb = img_as_float(self.img_rgb) assert_array_almost_equal(luv2rgb(rgb2luv(img_rgb)), img_rgb) def test_lab_rgb_outlier(self): lab_array = np.ones((3, 1, 3)) lab_array[0] = [50, -12, 85] lab_array[1] = [50, 12, -85] lab_array[2] = [90, -4, -47] lab_array = cp.asarray(lab_array) # ftm: off rgb_array = cp.asarray([[[0.501, 0.481, 0]], [[0, 0.482, 1.]], [[0.578, 0.914, 1.]], ]) # ftm: on assert_array_almost_equal(lab2rgb(lab_array), rgb_array, decimal=3) def test_lab_full_gamut(self): a, b = cp.meshgrid(cp.arange(-100, 100), cp.arange(-100, 100)) L = cp.ones(a.shape) lab = cp.dstack((L, a, b)) for value in [0, 10, 20]: lab[:, :, 0] = value with expected_warnings(['Color data out of range']): lab2xyz(lab) def test_lab_lch_roundtrip(self): rgb = img_as_float(self.img_rgb) lab = rgb2lab(rgb) lab2 = lch2lab(lab2lch(lab)) assert_array_almost_equal(lab2, lab) def test_rgb_lch_roundtrip(self): rgb = img_as_float(self.img_rgb) lab = rgb2lab(rgb) lch = lab2lch(lab) lab2 = lch2lab(lch) rgb2 = lab2rgb(lab2) assert_array_almost_equal(rgb, rgb2) def test_lab_lch_0d(self): lab0 = self._get_lab0() lch0 = lab2lch(lab0) lch2 = lab2lch(lab0[None, None, :]) assert_array_almost_equal(lch0, lch2[0, 0, :]) def test_lab_lch_1d(self): lab0 = self._get_lab0() lch0 = lab2lch(lab0) lch1 = lab2lch(lab0[None, :]) assert_array_almost_equal(lch0, lch1[0, :]) def test_lab_lch_3d(self): lab0 = self._get_lab0() lch0 = lab2lch(lab0) lch3 = lab2lch(lab0[None, None, None, :]) assert_array_almost_equal(lch0, lch3[0, 0, 0, :]) def _get_lab0(self): rgb = img_as_float(self.img_rgb[:1, :1, :]) return rgb2lab(rgb)[0, 0, :] def test_yuv(self): rgb = cp.asarray([[[1.0, 1.0, 1.0]]]) assert_array_almost_equal(rgb2yuv(rgb), cp.asarray([[[1, 0, 0]]])) assert_array_almost_equal(rgb2yiq(rgb), cp.asarray([[[1, 0, 0]]])) assert_array_almost_equal(rgb2ypbpr(rgb), cp.asarray([[[1, 0, 0]]])) assert_array_almost_equal( rgb2ycbcr(rgb), cp.asarray([[[235, 128, 128]]]) ) assert_array_almost_equal(rgb2ydbdr(rgb), cp.asarray([[[1, 0, 0]]])) rgb = cp.asarray([[[0.0, 1.0, 0.0]]]) assert_array_almost_equal( rgb2yuv(rgb), cp.asarray([[[0.587, -0.28886916, -0.51496512]]]) ) assert_array_almost_equal( rgb2yiq(rgb), cp.asarray([[[0.587, -0.27455667, -0.52273617]]]) ) assert_array_almost_equal( rgb2ypbpr(rgb), cp.asarray([[[0.587, -0.331264, -0.418688]]]) ) assert_array_almost_equal( rgb2ycbcr(rgb), cp.asarray([[[144.553, 53.797, 34.214]]]) ) assert_array_almost_equal( rgb2ydbdr(rgb), cp.asarray([[[0.587, -0.883, 1.116]]]) ) def test_yuv_roundtrip(self): img_rgb = img_as_float(self.img_rgb)[::16, ::16] assert_array_almost_equal(yuv2rgb(rgb2yuv(img_rgb)), img_rgb) assert_array_almost_equal(yiq2rgb(rgb2yiq(img_rgb)), img_rgb) assert_array_almost_equal(ypbpr2rgb(rgb2ypbpr(img_rgb)), img_rgb) assert_array_almost_equal(ycbcr2rgb(rgb2ycbcr(img_rgb)), img_rgb) assert_array_almost_equal(ydbdr2rgb(rgb2ydbdr(img_rgb)), img_rgb) def test_rgb2yuv_dtype(self): img = self.colbars_array.astype('float64') img32 = img.astype('float32') assert rgb2yuv(img).dtype == img.dtype assert rgb2yuv(img32).dtype == img32.dtype def test_yuv2rgb_dtype(self): img = rgb2yuv(self.colbars_array).astype('float64') img32 = img.astype('float32') assert yuv2rgb(img).dtype == img.dtype assert yuv2rgb(img32).dtype == img32.dtype def test_rgb2yiq_conversion(self): rgb = img_as_float(self.img_rgb)[::16, ::16] yiq = rgb2yiq(rgb).reshape(-1, 3) gt = np.asarray([colorsys.rgb_to_yiq(pt[0], pt[1], pt[2]) for pt in cp.asnumpy(rgb).reshape(-1, 3)] ) assert_array_almost_equal(yiq, gt, decimal=2)
r3 = np.sum((z3 - mul(W3, a2) - b3) * (z3 - mul(W3, a2) - b3)) loss = common.cross_entropy_with_softmax(y_train, z3) obj = loss + np.trace(mul(z3 - mul(W3, a2) - b3, np.transpose(u))) obj = obj + rho / 2 * r1 + rho / 2 * r2 + rho / 2 * r3 obj = obj + rho / 2 * np.sum( (a1 - common.relu(z1) + v1) * (a1 - common.relu(z1) + v1)) + rho / 2 * np.sum( (a2 - common.relu(z2) + v2) * (a2 - common.relu(z2) + v2)) return obj mnist = mnist() # initialization x_train = mnist.train.xs y_train = mnist.train.ys x_train = np.swapaxes(x_train, 0, 1) y_train = np.swapaxes(y_train, 0, 1) x_train = np.array(x_train) y_train = np.array(y_train) x_test = mnist.test.xs y_test = mnist.test.ys x_test = np.swapaxes(x_test, 0, 1) y_test = np.swapaxes(y_test, 0, 1) x_test = np.array(x_test) y_test = np.array(y_test) num_of_neurons = 1000 ITER = 10000 index = 0 W1, b1, z1, a1, W2, b2, z2, a2, W3, b3, z3 = Net(x_train, y_train, num_of_neurons)
def apply(gate, states, global_phase=False): # A shorthand for the original states a = states # d1 = number of circuit runs with noise, d2 = 2 ** N = dimension of state vector d1, d2 = states.shape N = int(rint(log2(d2))) # A copy of state a, to be flipped by qubit-wise Pauli operations b = copy(a) # print("d1 = ", d1) # print("d2 = ", d2) # print("N = ", N) # Reshape to rank-(N+1) tensor b = b.reshape([d1] + [2] * N) for k in range(len(gate[0])): basis = gate[0][k] q = gate[1][k] if basis == identity: pass if basis == x: b = roll(b, 1, q + 1) if basis == y: b = roll(b, 1, q + 1) b = swapaxes(b, 0, q + 1) b[0] *= -1j b[1] *= 1j b = swapaxes(b, 0, q + 1) if basis == s_phi: phi = array(gate[3][k]) b = roll(b, 1, q + 1) b = swapaxes(b, 0, q + 1) b = swapaxes(b, N, q + 1) phase1 = cos(phi) + 1j * sin(phi) phase2 = cos(phi) - 1j * sin(phi) b[0] = multiply(phase2, b[0]) b[1] = multiply(phase1, b[1]) b = swapaxes(b, N, q + 1) b = swapaxes(b, 0, q + 1) if basis == z: b = swapaxes(b, 0, q + 1) b[1] *= -1 b = swapaxes(b, 0, q + 1) b = b.reshape(d1, d2) angles = array(gate[2][0]) states = (cos(angles / 2) * a.T - 1j * sin(angles / 2) * b.T).T # Remove global phase (may be awkward if first amplitude is close to zero) if global_phase == False: pass return states
def compute_gradients_gpu(u, v, lr, batch_size, num_negs, dimensions, indices, negatives): """ This function computes and applies the gradient updates for the batch os samples, applying them inside the function then returning the final values that the embedding should be set too. :param u: the embedding values for the words we are computing gradients for (batch_size, dimensions) :param v: the embedding values for the positive sample + negatives samples (1 + num_negs, dimensions) :param lr: learning rate :param batch_size: size of the current batch, may vary from regular batch_size because of last remaining samples that can't fit into an entire batch_size in an epoch :param num_negs: number of negative samples for each positive sample :param dimensions: dimensions of the embedding :param indices: the indices of all the u values (batch_size) :param negatives: the indices of all the v values (batch_size, 1 + num_negs) :return: Returns the values that the embedding of the samples and negatives should be set too as well as the loss Once again, calculation was adapted from R. Řehůřek and P. Sojka RaRe-Technologies: Software Framework for Topic Modelling with Large Corpora https://github.com/RaRe-Technologies/gensim """ u = cp.asarray(u) v = cp.asarray(v) u_orig = u v_orig = v u = u.T[cp.newaxis, :, :] v = cp.swapaxes(cp.swapaxes(v, 1, 2), 0, 2) norm_u = cp.linalg.norm(u, axis=1) norm_v = cp.linalg.norm(v, axis=1) distances = cp.linalg.norm(u - v, axis=1) alpha = 1 - norm_u**2 beta = 1 - norm_v**2 gamma = 1 + 2 * ((distances**2) / (alpha * beta)) poincare_distances = cp.arccosh(gamma) exp_negative_distances = cp.exp(-poincare_distances) sum = cp.sum(exp_negative_distances, axis=0) distances_squared = distances**2 c = (4 / (alpha * beta * cp.sqrt(gamma**2 - 1)))[:, cp.newaxis, :] u_coeff = ((distances_squared + alpha) / alpha)[:, cp.newaxis, :] distance_gradient_u = (u_coeff * u - v) distance_gradient_u *= c v_coeffs = ((distances_squared + beta) / beta)[:, cp.newaxis, :] distance_gradients_v = (v_coeffs * v - u) distance_gradients_v *= c gradients_v = -exp_negative_distances[:, cp.newaxis, :] * distance_gradients_v gradients_v /= sum gradients_v[0] += distance_gradients_v[0] gradients_v[0] += lr * 2 * v[0] gradients_u = -exp_negative_distances[:, cp.newaxis, :] * distance_gradient_u gradients_u /= sum gradient_u = cp.sum(gradients_u, axis=0) gradient_u += distance_gradient_u[0] u_update = (lr * (alpha**2) / 4 * gradient_u).T handle_duplicates(u_update, indices) v_updates = cp.swapaxes( cp.swapaxes((lr * (beta**2)[:, cp.newaxis, :] / 4 * gradients_v), 0, 2), 1, 2) v_updates = cp.reshape(v_updates, (batch_size * (num_negs + 1), dimensions)) handle_duplicates(v_updates, np.ravel(negatives)) u_orig -= u_update v_orig = cp.reshape(v_orig, (batch_size * (num_negs + 1), dimensions)) v_orig -= v_updates u_norms = cp.linalg.norm(u_orig, axis=1) v_norms = cp.linalg.norm(v_orig, axis=1) u_orig = (u_norms >= 1 - epsilon)[:, cp.newaxis] * ( u_orig / u_norms[:, cp.newaxis] - cp.sign(u_orig) * 0.00001) + ( u_norms < 1 - epsilon)[:, cp.newaxis] * u_orig v_orig = (v_norms >= 1 - epsilon)[:, cp.newaxis] * ( v_orig / v_norms[:, cp.newaxis] - cp.sign(v_orig) * 0.00001) + ( v_norms < 1 - epsilon)[:, cp.newaxis] * v_orig loss = cp.sum(-cp.log(exp_negative_distances[0] / sum), axis=0) return u_orig, v_orig, loss
def transform(self, images): """ Parameters ---------- images: np.ndarray | Color / grayscale images of shape | (n_images, height, width, n_channels) or | (n_images, height, width) Returns ------- X: np.ndarray A set of feature vectors of shape (n_images, n_features) where :code:`n_features` is determined by the hyperparameters """ images = self.process_input(images) # images.shape == (n_images, n_channels, y, x) filters_l1 = components_to_filters( self.pca_l1.components_, n_channels=images.shape[1], filter_shape=self.filter_shape_l1, ) filters_l2 = components_to_filters( self.pca_l2.components_, n_channels=1, filter_shape=self.filter_shape_l2 ) if gpu_enabled(): images = to_gpu(images) filters_l1 = to_gpu(filters_l1) filters_l2 = to_gpu(filters_l2) images = convolution_2d( images, filters_l1, stride=self.step_shape_l1 ).data images = xp.swapaxes(images, 0, 1) # L1.shape == (L1, n_images, y, x) # iterate over each L1 output X = [] for maps in images: n_images, h, w = maps.shape maps = convolution_2d( maps.reshape(n_images, 1, h, w), # 1 channel images filters_l2, stride=self.step_shape_l2 ).data # maps.shape == (n_images, L2, y, x) right here maps = binarize(maps) maps = binary_to_decimal(maps) # maps.shape == (n_images, y, x) x = self.histogram(maps) # x is a set of feature vectors. # The shape of x is (n_images, vector length) #JCG comment: histogram length is pow(2, L2), i.e. the range #of integers that can be represented by the binarized outputs of #L2 filters so we normally have shape (n_images, 256) X.append(x) #JCG comment: X contains L1 elements of shape (n_images, 256) # concatenate over L1 X = xp.hstack(X) #JCG comment: now X contains n_images elements of shape (L1*256) if gpu_enabled(): X = to_cpu(X) X = X.astype(np.float64) # The shape of X is (n_images, L1 * vector length) return X
def display(a): surf = pygame.surfarray.make_surface( cp.asnumpy( upsample((cp.flip(cp.flip(cp.swapaxes(a, 0, 1), 1), 0) * 255)))) disp.blit(surf, (0, 0))
def transform(self, images): """ Parameters ---------- image: np.ndarray | Color / grayscale image of shape | (height, width, n_channels) or | (height, width) Returns ------- X: np.ndarray A set of feature vectors of shape (n_images, n_features) where :code:`n_features` is determined by the hyperparameters NB: It is necessary to call the fit function first, to set the filters. """ #images.shape == (1, h, w[, n_channels]) images = self.process_input(images) #Now images.shape == (1, n_channels=1, y, x) #Retrieve the layer 1 filters filters_l1 = pcanet.components_to_filters( self.pca_l1.components_, n_channels=images.shape[1], filter_shape=self.filter_shape_l1, ) #Retrieve the layer 2 filters filters_l2 = pcanet.components_to_filters( self.pca_l2.components_, n_channels=1, filter_shape=self.filter_shape_l2) if gpu_enabled(): images = to_gpu(images) filters_l1 = to_gpu(filters_l1) filters_l2 = to_gpu(filters_l2) #Apply the layer 1 filters l1output = convolution_2d(images, filters_l1, stride=self.step_shape_l1, pad=1).data #The l1 output has shape (n_images, L1, y, x), swap axes l1output = xp.swapaxes(l1output, 0, 1) # Now l1output.shape == (L1, n_images, y, x) # iterate over each L1 output, applying L2 filters l2output = [] for maps in l1output: n_images, h, w = maps.shape l2maps = convolution_2d( maps.reshape(n_images, 1, h, w), # 1 channel images filters_l2, stride=self.step_shape_l2, pad=1).data # l2maps.shape == (n_images, L2, y, x) # Apply sigmoid and sum over the L2 channels Z = np.zeros((n_images, *l2maps.shape[2:])) for chan in range(l2maps.shape[1]): Z += pow(2, 8 - chan) * ( expit(self.alpha * np.abs(l2maps[:, chan, ...])) - self.S0) l2output.append(Z) #JCG comment: l2output contains L1 elements of shape (n_images, h, w) if gpu_enabled(): l2output = to_cpu(l2output) return images, l1output, l2output
async def test_blocked_cholesky(): logger.debug("Block size=", block_size, " and total array size=", n) assert not n % block_size logger.debug("Random number generate..") np.random.seed(10) # Construct input data a = np.random.rand(n, n) a = a @ a.T logger.debug("Random number generate done..") logger.debug("Copy a to a1..") # Copy and layout input a1 = a.copy() logger.debug("Copying done..") logger.debug("Shaping starts..") a1 = a1.reshape(n // block_size, block_size, n // block_size, block_size).swapaxes(1,2) logger.debug("Shaping done..") logger.debug("Allocate memory..") for i in range(num_tests): global gpu_arrs gpu_arrs = [] for d in range(num_gpus): row_size = n // (block_size * num_gpus) if d < ((n / block_size) % num_gpus): row_size += 1 if row_size > 0: allocate_gpu_memory(d, row_size, n, block_size) logger.debug("Allocate memory done..") set_gpu_memory_from_cpu(a1, num_gpus) for i in range(len(gpu_arrs)): logger.debug("Device ", i, " arrays are on ", gpu_arrs[i].device); logger.debug("Calculate starts..") start = time.perf_counter() # Call Parla Cholesky result and wait for completion await cholesky_blocked_inplace(a1.shape, num_gpus) end = time.perf_counter() print(end - start, "seconds") logger.debug("Calculate done..") for i in range(len(gpu_arrs)): logger.debug("Device ", i, " arrays are on ", gpu_arrs[i].device); for d in range(len(gpu_arrs)): logger.debug("Device:", d, " swap array..") gpu_arrs[d] = cp.swapaxes(gpu_arrs[d], 2, 1) logger.debug("Device:", d, " swap done..") cpu_arrs = np.empty([n // block_size, block_size, n // block_size, block_size], dtype=float) for r_num in range(n // block_size): dev_id = r_num % num_gpus local_id = r_num // num_gpus cpu_arrs[r_num] = cp.asnumpy(gpu_arrs[dev_id][local_id]) cpu_arrs = cpu_arrs.reshape(n, n) print("Truth", linalg.cholesky(a).T) # Check result computed_L = np.tril(cpu_arrs) print("Soln", computed_L) error = np.max(np.absolute(a-computed_L @ computed_L.T)) print("Error", error) assert(error < 1E-8) del gpu_arrs
def matrix_transpose(x: Array, /) -> Array: if x.ndim < 2: raise ValueError( "x must be at least 2-dimensional for matrix_transpose") return Array._new(np.swapaxes(x._array, -1, -2))
def transform(self, images): """ Parameters ---------- images: np.ndarray | Color / grayscale images of shape | (n_images, height, width, n_channels) or | (n_images, height, width) Returns ------- X: np.ndarray A set of feature vectors of shape (n_images, n_features) where :code:`n_features` is determined by the hyperparameters """ print("Shape of the data passed to transform") print(images.shape) images = self.process_input(images) # images.shape == (n_images, n_channels, y, x) filters_l1 = components_to_filters( self.pca_l1.components_, n_channels=images.shape[1], filter_shape=self.filter_shape_l1, ) filters_l2 = components_to_filters(self.pca_l2.components_, n_channels=1, filter_shape=self.filter_shape_l2) print("Filters in layer 2") print(filters_l2) if gpu_enabled(): images = to_gpu(images) filters_l1 = to_gpu(filters_l1) filters_l2 = to_gpu(filters_l2) images = convolution_2d(images, filters_l1, stride=self.step_shape_l1).data images = xp.swapaxes(images, 0, 1) # L1.shape == (L1, n_images, y, x) # iterate over each L1 output X = [] for maps in images: n_images, h, w = maps.shape maps = convolution_2d( maps.reshape(n_images, 1, h, w), # 1 channel images filters_l2, stride=self.step_shape_l2).data # maps.shape == (n_images, L2, y, x) right here maps = binarize(maps) maps = binary_to_decimal(maps) # maps.shape == (n_images, y, x) x = self.histogram(maps) # x is a set of feature vectors. # The shape of x is (n_images, vector length) X.append(x) # concatenate over L1 X = xp.hstack(X) if gpu_enabled(): X = to_cpu(X) X = X.astype(np.float64) # The shape of X is (n_images, L1 * vector length) return X
def remove_global_phase(states): gp = exp(-1j * angle(states[0])) c = swapaxes(states, 0, 1) states = multiply(gp.T, c).T return states