def nonlin_evo(psiP2, psiP1, psi0, psiM1, psiM2, c0, c2, c4, V, p, dt, spin_f): # Calculate densities: n = abs(psiP2) ** 2 + abs(psiP1) ** 2 + abs(psi0) ** 2 + abs(psiM1) ** 2 + abs(psiM2) ** 2 A00 = 1 / cp.sqrt(5) * (psi0 ** 2 - 2 * psiP1 * psiM1 + 2 * psiP2 * psiM2) fz = 2 * (abs(psiP2) ** 2 - abs(psiM2) ** 2) + abs(psiP1) ** 2 - abs(psiM1) ** 2 # Evolve spin-singlet term -c4*(n^2-|alpha|^2) S = cp.sqrt(n ** 2 - abs(A00) ** 2) S = cp.nan_to_num(S) cosT = cp.cos(c4 * S * dt) sinT = cp.sin(c4 * S * dt) / S sinT[S == 0] = 0 # Corrects division by 0 Wfn = [psiP2 * cosT + 1j * (n * psiP2 - A00 * cp.conj(psiM2)) * sinT, psiP1 * cosT + 1j * (n * psiP1 + A00 * cp.conj(psiM1)) * sinT, psi0 * cosT + 1j * (n * psi0 - A00 * cp.conj(psi0)) * sinT, psiM1 * cosT + 1j * (n * psiM1 + A00 * cp.conj(psiP1)) * sinT, psiM2 * cosT + 1j * (n * psiM2 - A00 * cp.conj(psiP2)) * sinT] # Calculate spin vectors fp = cp.sqrt(6) * (Wfn[1] * cp.conj(Wfn[2]) + Wfn[2] * cp.conj(Wfn[3])) + 2 * (Wfn[3] * cp.conj(Wfn[4]) + Wfn[0] * cp.conj(Wfn[1])) F = cp.sqrt(fz ** 2 + abs(fp) ** 2) # Calculate cos, sin and Qfactor terms: C1, S1 = cp.cos(c2 * F * dt), cp.sin(c2 * F * dt) C2, S2 = cp.cos(2 * c2 * F * dt), cp.sin(2 * c2 * F * dt) Qfactor = 1j * (-4 / 3 * S1 + 1 / 6 * S2) Q2factor = (-5 / 4 + 4 / 3 * C1 - 1 / 12 * C2) Q3factor = 1j * (1 / 3 * S1 - 1 / 6 * S2) Q4factor = (1 / 4 - 1 / 3 * C1 + 1 / 12 * C2) fzQ = cp.nan_to_num(fz / F) fpQ = cp.nan_to_num(fp / F) Qpsi = calc_Qpsi(fzQ, fpQ, Wfn) Q2psi = calc_Qpsi(fzQ, fpQ, Qpsi) Q3psi = calc_Qpsi(fzQ, fpQ, Q2psi) Q4psi = calc_Qpsi(fzQ, fpQ, Q3psi) # Evolve spin term c2 * F^2 for ii in range(len(Wfn)): Wfn[ii] += Qfactor * Qpsi[ii] + Q2factor * Q2psi[ii] + Q3factor * Q3psi[ii] + Q4factor * Q4psi[ii] # Evolve (c0+c4)*n^2 + (V + pm)*n: for ii in range(len(Wfn)): mF = spin_f - ii Wfn[ii] *= cp.exp(-1j * dt * ((c0 + c4) * n + V + p * mF)) return Wfn
def em(collection: list, p_wt: cp.ndarray, p_td: cp.ndarray) -> (cp.ndarray, cp.ndarray): # P(Wi|Tk) p_wt_devisor = cp.zeros(p_wt.shape[1], dtype=float) # (TOPIC_SIZE,) p_wt_devidend = cp.zeros(p_wt.shape, dtype=float) # (51253, TOPIC_SIZE) for i_prime in tqdm(range(p_wt.shape[0]), desc='EM_P(Wi|Tk)'): # C(Wi', dj) -> dj(D word = str(i_prime) c_wd = np.zeros((1, len(collection)), dtype=int) for j in range(len(collection)): c_wd[0][j] = collection[j][word] # P(Tk|Wi', dj) -> dj(D p_twd_devisor = cp.dot(p_wt[i_prime], p_td.T) p_twd_devidend = p_wt[i_prime] * p_td p_twd = cp.nan_to_num(p_twd_devidend.T / p_twd_devisor).T # C(Wi', dj) * P(Tk|Wi', dj) -> dj(D sum_cp_d = cp.dot(c_wd, p_twd)[0] p_wt_devidend[i_prime] = sum_cp_d p_wt_devisor += sum_cp_d new_wt = p_wt_devidend / p_wt_devisor # P(Tk|dj) p_td_devisor = cp.zeros(len(collection), dtype=float) # (18461,) p_td_devidend = cp.zeros(p_td.shape, dtype=float) # (18461, TOPIC_SIZE) for j in tqdm(range(p_td.shape[0]), desc='EM_P(Tk|dj)'): # C(Wi', dj) -> i=1~|V| c_wd = cp.zeros((1, p_wt.shape[0]), dtype=int) for key, value in collection[j].items(): c_wd[0][int(key)] = value p_td_devisor[j] += value # P(Tk|Wi', dj) -> i=1~|V| p_twd_devisor = cp.dot(p_wt, p_td[j]) p_twd_devidend = p_wt * p_td[j] p_twd = cp.nan_to_num(p_twd_devidend.T / p_twd_devisor).T # C(Wi', dj) * P(Tk|Wi', dj) -> i=1~|V| sum_cp_v = cp.dot(c_wd, p_twd)[0] p_td_devidend[j] = sum_cp_v new_td = (p_td_devidend.T / p_td_devisor).T return new_wt, new_td
def confusion_matrix(client, y_true, y_pred, normalize=None, sample_weight=None): from cuml.dask.common.input_utils import DistributedDataHandler unique_classes = cp.unique(y_true.map_blocks(lambda x: cp.unique(x)).compute()) nclasses = len(unique_classes) ddh = DistributedDataHandler.create([y_true, y_pred]) cms = client.compute( [ client.submit( local_cm, part, unique_classes, sample_weight, workers=[worker] ) for worker, part in ddh.gpu_futures ], sync=True, ) cm = cp.zeros((nclasses, nclasses)) for i in cms: cm += i with np.errstate(all="ignore"): if normalize == "true": cm = cm / cm.sum(axis=1, keepdims=True) elif normalize == "pred": cm = cm / cm.sum(axis=0, keepdims=True) elif normalize == "all": cm = cm / cm.sum() cm = cp.nan_to_num(cm) return cm
def local_cm(y_y_pred, unique_labels, sample_weight): y_true, y_pred = y_y_pred labels = unique_labels n_labels = labels.size # Assume labels are monotonically increasing for now. # intersect y_pred, y_true with labels, eliminate items not in labels ind = cp.logical_and(y_pred < n_labels, y_true < n_labels) y_pred = y_pred[ind] y_true = y_true[ind] if sample_weight is None: sample_weight = cp.ones(y_true.shape[0], dtype=np.int64) else: sample_weight = cp.asarray(sample_weight) sample_weight = sample_weight[ind] cm = cp.sparse.coo_matrix( (sample_weight, (y_true, y_pred)), shape=(n_labels, n_labels), dtype=cp.float32, ).toarray() return cp.nan_to_num(cm)
def __lioness_loop(self): """ Description: Initialize instance of Lioness class and load data. Outputs: self.total_lioness_network: An edge-by-sample matrix containing sample-specific networks. """ for i in self.indexes: print("Running LIONESS for sample %d:" % (i+1)) idx = [x for x in range(self.n_conditions) if x != i] # all samples except i with Timer("Computing coexpression network:"): if self.computing=='gpu': import cupy as cp correlation_matrix = cp.corrcoef(self.expression_matrix[:, idx]) if cp.isnan(correlation_matrix).any(): cp.fill_diagonal(correlation_matrix, 1) correlation_matrix = cp.nan_to_num(correlation_matrix) correlation_matrix=cp.asnumpy(correlation_matrix) else: correlation_matrix = np.corrcoef(self.expression_matrix[:, idx]) if np.isnan(correlation_matrix).any(): np.fill_diagonal(correlation_matrix, 1) correlation_matrix = np.nan_to_num(correlation_matrix) with Timer("Normalizing networks:"): correlation_matrix_orig = correlation_matrix # save matrix before normalization correlation_matrix = self._normalize_network(correlation_matrix) with Timer("Inferring LIONESS network:"): if self.motif_matrix is not None: del correlation_matrix_orig subset_panda_network = self.panda_loop(correlation_matrix, np.copy(self.motif_matrix), np.copy(self.ppi_matrix),self.computing) else: del correlation_matrix subset_panda_network = correlation_matrix_orig lioness_network = self.n_conditions * (self.network - subset_panda_network) + subset_panda_network with Timer("Saving LIONESS network %d to %s using %s format:" % (i+1, self.save_dir, self.save_fmt)): path = os.path.join(self.save_dir, "lioness.%d.%s" % (i+1, self.save_fmt)) if self.save_fmt == 'txt': np.savetxt(path, lioness_network) elif self.save_fmt == 'npy': np.save(path, lioness_network) elif self.save_fmt == 'mat': from scipy.io import savemat savemat(path, {'PredNet': lioness_network}) else: print("Unknown format %s! Use npy format instead." % self.save_fmt) np.save(path, lioness_network) if i == 0: self.total_lioness_network = np.fromstring(np.transpose(lioness_network).tostring(),dtype=lioness_network.dtype) else: self.total_lioness_network=np.column_stack((self.total_lioness_network ,np.fromstring(np.transpose(lioness_network).tostring(),dtype=lioness_network.dtype))) return self.total_lioness_network
def calc_grad_and_update_embeddings(self, embeddings, target_embeddings, is_test, learn_rate, relations_matrix_transpose): # 着目ノードのベクトルと,その内部情報を元に算出した着目ノードの想定ベクトルとの差 original_minus_target = embeddings - target_embeddings # 着目ノードを継承クラスや呼び出しメソッドとして内部で使っているノードのベクトルと, # そのノードの想定ベクトルとの差の和 original_minus_target_be_used = -relations_matrix_transpose.dot( original_minus_target) original_minus_target_all = original_minus_target + original_minus_target_be_used norm_original_minus_target_all = cp.linalg.norm( original_minus_target_all, axis=1).reshape( (original_minus_target_all.shape[0], 1)) if is_test: embeddings[self.model.num_of_train_nodes:] \ -= learn_rate * cp.nan_to_num(original_minus_target_all / norm_original_minus_target_all)[self.model.num_of_train_nodes:] else: embeddings -= learn_rate * cp.nan_to_num( original_minus_target_all / norm_original_minus_target_all)
def compute_dA(self, A, Y, lamb_coord, lamb_noobj): """Compute dA for the softmax layer. Args: A (np.array): predicted labels Y (np.array): true labels Returns: np.array: dA """ dA = np.zeros_like(Y) dA[:, :, :, 0] = 2*(A[:, :, :, 0]-Y[:, :, :, 0]) * \ (Y[:, :, :, 0] + (1-Y[:, :, :, 0])*lamb_noobj) dA[:, :, :, 1] = lamb_coord*2*Y[:, :, :, 0] * \ (A[:, :, :, 1]-Y[:, :, :, 1]) dA[:, :, :, 2] = lamb_coord*2*Y[:, :, :, 0] * \ (A[:, :, :, 2]-Y[:, :, :, 2]) dA[:, :, :, 3] = lamb_coord * Y[:, :, :, 0] * cp.nan_to_num( (cp.sqrt(A[:, :, :, 3]) - cp.sqrt(Y[:, :, :, 3])) / cp.sqrt(A[:, :, :, 3])) dA[:, :, :, 4] = lamb_coord * Y[:, :, :, 0] * cp.nan_to_num( (cp.sqrt(A[:, :, :, 4]) - cp.sqrt(Y[:, :, :, 4])) / cp.sqrt(A[:, :, :, 4])) return dA
def renorm_magnetisation(target_mag, Wfn): np2 = abs(Wfn[0]) ** 2 np1 = abs(Wfn[1]) ** 2 n0 = abs(Wfn[2]) ** 2 nm1 = abs(Wfn[3]) ** 2 nm2 = abs(Wfn[4]) ** 2 N = np2 + np1 + n0 + nm1 + nm2 r = (np2 + nm2) / (np1 + nm1) # Ratio of outer component populations to inner populations # Correction factors: r1 = 1 + r * (target_mag * N - 2 * (np2 - nm2) - (np1 - nm1)) / (2 * (2 * r + 1) * np2) r5 = 1 - r * (target_mag * N - 2 * (np2 - nm2) - (np1 - nm1)) / (2 * (2 * r + 1) * nm2) r2 = 1 + r * (target_mag * N - 2 * (np2 - nm2) - (np1 - nm1)) / (2 * (2 * r + 1) * np1) r4 = 1 - r * (target_mag * N - 2 * (np2 - nm2) - (np1 - nm1)) / (2 * (2 * r + 1) * nm1) # Update renorm factors: r1 = cp.sqrt(r1 / N) r2 = cp.sqrt(r2 / N) r3 = cp.sqrt(1 / N) r4 = cp.sqrt(r4 / N) r5 = cp.sqrt(r5 / N) r1 = cp.nan_to_num(r1) r2 = cp.nan_to_num(r2) r4 = cp.nan_to_num(r4) r5 = cp.nan_to_num(r5) # Renormalise spinor components: Wfn[0] *= r1 Wfn[1] *= r2 Wfn[2] *= r3 Wfn[3] *= r4 Wfn[4] *= r5
def calc_spin_dens(wfn_plus, wfn_0, wfn_minus, dt, c2): """Calculates various quantities such as spin vectors, sin and cosine terms and the atomic density.""" spin_perp = cp.sqrt(2.) * (cp.conj(wfn_plus) * wfn_0 + cp.conj(wfn_0) * wfn_minus) spin_z = cp.abs(wfn_plus)**2 - cp.abs(wfn_minus)**2 F = cp.sqrt(cp.abs(spin_z)**2 + cp.abs(spin_perp)**2) # Magnitude of spin vector cos_term = cp.cos(c2 * F * dt) sin_term = 1j * cp.sin(c2 * F * dt) / F sin_term = cp.nan_to_num(sin_term) # Corrects division by 0 density = cp.abs(wfn_minus)**2 + cp.abs(wfn_0)**2 + cp.abs(wfn_plus)**2 return spin_perp, spin_z, cos_term, sin_term, density
def log_likelihood(collection: list, p_wt: cp.ndarray, p_td: cp.ndarray) -> float: likelihood = 0. for i in tqdm(range(p_wt.shape[0]), desc='Log_like'): # C(Wi', dj) -> dj(D word = str(i) c_wd = cp.zeros(len(collection), dtype=int) for j in range(len(collection)): c_wd[j] = collection[j][word] # P(Wi|Tk)P(Tk|dj) -> k=1~K sum_pp_k = cp.dot(p_wt[i], p_td.T) likelihood += cp.dot(c_wd, cp.nan_to_num(cp.log(sum_pp_k))) return likelihood
def _local_cm(inputs, labels, use_sample_weight): if use_sample_weight: y_true, y_pred, sample_weight = inputs else: y_true, y_pred = inputs sample_weight = cp.ones(y_true.shape[0], dtype=y_true.dtype) y_true, _ = make_monotonic(y_true, labels, copy=True) y_pred, _ = make_monotonic(y_pred, labels, copy=True) n_labels = labels.size # intersect y_pred, y_true with labels, eliminate items not in labels ind = cp.logical_and(y_pred < n_labels, y_true < n_labels) y_pred = y_pred[ind] y_true = y_true[ind] sample_weight = sample_weight[ind] cm = cupyx.scipy.sparse.coo_matrix((sample_weight, (y_true, y_pred)), shape=(n_labels, n_labels), dtype=cp.float64).toarray() return cp.nan_to_num(cm)
def ndwi(data, bands, factor=1.0, vtype='int16', device='CPU') -> np.array: """ GPU Support :param data: xarray or numpy array object in the form (c, h, w) :param bands: number of the original bands of the raster :param factor: factor used for toa imagery :return: new band with SI calculated """ # 8 and 4 band imagery: NDWI := factor * (Green - NIR1) / (Green + NIR1) GREEN, NIR1 = bands.index('Green'), bands.index('NIR1') ndwi = factor * ((data[GREEN, :, :] - data[NIR1, :, :]) / (data[GREEN, :, :] + data[NIR1, :, :])) if device == 'CPU': ndwi = ndwi.expand_dims(dim="band", axis=0).fillna(0).astype(vtype) elif device == 'GPU': ndwi = cp.nan_to_num(cp.expand_dims(ndwi, 0)) else: raise RuntimeError("{} device not supported".format(device)) return ndwi, "NDWI"
def fdi(data, bands, factor=1.0, vtype='int16', device='CPU') -> np.array: """ GPU Support :param data: xarray or numpy array object in the form (c, h, w) :param bands: number of the original bands of the raster :param factor: factor used for toa imagery :return: new band with FDI calculated """ # 8 band imagery: FDI := NIR2 - (RedEdge + Blue) # 4 band imagery: FDI := NIR1 - (Red + Blue) NIR = bands.index('NIR2') if 'NIR2' in bands else bands.index('NIR1') RED = bands.index('RedEdge') if 'RedEdge' in bands else bands.index('Red') BLUE = bands.index('Blue') fdi = data[NIR, :, :] - (data[RED, :, :] + data[BLUE, :, :]) if device == 'CPU': fdi = fdi.expand_dims(dim="band", axis=0).fillna(0).astype(vtype) elif device == 'GPU': fdi = cp.nan_to_num(cp.expand_dims(fdi, 0)) else: raise RuntimeError("{} device not supported".format(device)) return fdi, "FDI"
def si(data, bands, factor=1.0, vtype='int16', device='CPU') -> np.array: """ GPU Support :param data: xarray or numpy array object in the form (c, h, w) :param bands: number of the original bands of the raster :param factor: factor used for toa imagery :return: new band with SI calculated """ # 8 and 4 band imagery: # SI := ((factor - Blue) * (factor - Green) * (factor - Red)) ** (1.0 / 3) BLUE, GREEN = bands.index('Blue'), bands.index('Green') RED = bands.index('Red') si = ((factor - data[BLUE, :, :]) * (factor - data[GREEN, :, :]) * (factor - data[RED, :, :]))**(1.0 / 3.0) if device == 'CPU': si = si.expand_dims(dim="band", axis=0).fillna(0).astype(vtype) elif device == 'GPU': si = cp.nan_to_num(cp.expand_dims(si, 0)) else: raise RuntimeError("{} device not supported".format(device)) return si, "SI"
def confusion_matrix(y_true, y_pred, labels=None, sample_weight=None, normalize=None) -> CumlArray: """Compute confusion matrix to evaluate the accuracy of a classification. Parameters ---------- y_true : array-like (device or host) shape = (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like (device or host) shape = (n_samples,) or (n_samples, n_outputs) Estimated target values. labels : array-like (device or host) shape = (n_classes,), optional List of labels to index the matrix. This may be used to reorder or select a subset of labels. If None is given, those that appear at least once in y_true or y_pred are used in sorted order. sample_weight : array-like (device or host) shape = (n_samples,), optional Sample weights. normalize : string in [‘true’, ‘pred’, ‘all’] Normalizes confusion matrix over the true (rows), predicted (columns) conditions or all the population. If None, confusion matrix will not be normalized. Returns ------- C : array-like (device or host) shape = (n_classes, n_classes) Confusion matrix. """ y_true, n_rows, n_cols, dtype = \ input_to_cuml_array(y_true, check_dtype=[cp.int32, cp.int64]) y_pred, _, _, _ = \ input_to_cuml_array(y_pred, check_dtype=dtype, check_rows=n_rows, check_cols=n_cols) if labels is None: labels = sorted_unique_labels(y_true, y_pred) n_labels = len(labels) else: labels, n_labels, _, _ = \ input_to_cupy_array(labels, check_dtype=dtype, check_cols=1) if sample_weight is None: sample_weight = cp.ones(n_rows, dtype=dtype) else: sample_weight, _, _, _ = \ input_to_cupy_array(sample_weight, check_dtype=[cp.float32, cp.float64, cp.int32, cp.int64], check_rows=n_rows, check_cols=n_cols) if normalize not in ['true', 'pred', 'all', None]: msg = "normalize must be one of " \ f"{{'true', 'pred', 'all', None}}, got {normalize}." raise ValueError(msg) with using_output_type("cupy"): y_true, _ = make_monotonic(y_true, labels, copy=True) y_pred, _ = make_monotonic(y_pred, labels, copy=True) # intersect y_pred, y_true with labels, eliminate items not in labels ind = cp.logical_and(y_pred < n_labels, y_true < n_labels) y_pred = y_pred[ind] y_true = y_true[ind] sample_weight = sample_weight[ind] cm = cupyx.scipy.sparse.coo_matrix((sample_weight, (y_true, y_pred)), shape=(n_labels, n_labels), dtype=np.float64).toarray() # Choose the accumulator dtype to always have high precision if sample_weight.dtype.kind in {'i', 'u', 'b'}: cm = cm.astype(np.int64) with np.errstate(all='ignore'): if normalize == 'true': cm = cp.divide(cm, cm.sum(axis=1, keepdims=True)) elif normalize == 'pred': cm = cp.divide(cm, cm.sum(axis=0, keepdims=True)) elif normalize == 'all': cm = cp.divide(cm, cm.sum()) cm = cp.nan_to_num(cm) return cm
def affine_transform(image, rmatrix, order=3, scale=1.0, image_center=None, recenter=False, missing=0.0, use_scipy=False, use_cupyx=False): """ Rotates, shifts and scales an image. Will use `skimage.transform.warp` unless scikit-image can't be imported then it will use`scipy.ndimage.affine_transform`. Parameters ---------- image : `numpy.ndarray` 2D image to be rotated. rmatrix : `numpy.ndarray` that is 2x2 Linear transformation rotation matrix. order : `int` 0-5, optional Interpolation order to be used, defaults to 3. When using scikit-image this parameter is passed into `skimage.transform.warp` (e.g., 3 corresponds to bi-cubic interpolation). When using scipy it is passed into `scipy.ndimage.affine_transform` where it controls the order of the spline. scale : `float` A scale factor for the image with the default being no scaling. image_center : tuple, optional The point in the image to rotate around (axis of rotation). Defaults to the center of the array. recenter : `bool` or array-like, optional Move the axis of rotation to the center of the array or recenter coords. Defaults to `True` i.e., recenter to the center of the array. missing : `float`, optional The value to replace any missing data after the transformation. use_scipy : `bool`, optional Force use of `scipy.ndimage.affine_transform`. Will set all "NaNs" in image to zero before doing the transform. Defaults to `False`, unless scikit-image can't be imported. Returns ------- `numpy.ndarray`: New rotated, scaled and translated image. Notes ----- This algorithm uses an affine transformation as opposed to a polynomial geometrical transformation, which by default is `skimage.transform.warp`. One can specify using `scipy.ndimage.affine_transform` as an alternative affine transformation. The two transformations use different algorithms and thus do not give identical output. When using `skimage.transform.warp` with order >= 4 or using `scipy.ndimage.affine_transform` at all, "NaN" values will be replaced with zero prior to rotation. No attempt is made to retain the "NaN" values. Input arrays with integer data are cast to float 64 and can be re-cast using `numpy.ndarray.astype` if desired. In the case of `skimage.transform.warp`, the image is normalized to [0, 1] before passing it to the function. It is later rescaled back to the original range. Although this function is analogous to the IDL's ``rot`` function, it does not use the same algorithm as the IDL ``rot`` function. IDL's ``rot`` calls the `POLY_2D <https://www.harrisgeospatial.com/docs/poly_2d.html>`__ method to calculate the inverse mapping of original to target pixel coordinates. This is a polynomial geometrical transformation. Then optionally it uses a bicubic convolution interpolation algorithm to map the original to target pixel values. """ rmatrix = rmatrix / scale array_center = (np.array(image.shape)[::-1] - 1) / 2.0 # Make sure the image center is an array and is where it's supposed to be if image_center is not None: image_center = np.asanyarray(image_center) else: image_center = array_center # Determine center of rotation based on use (or not) of the recenter keyword if recenter: rot_center = array_center else: rot_center = image_center displacement = np.dot(rmatrix, rot_center) shift = image_center - displacement if not use_scipy: try: import skimage.transform except ImportError: warnings.warn( "scikit-image could not be imported. Image rotation will use scipy", ImportWarning) use_scipy = True if use_cupyx: try: import cupyx import cupy except ImportError: warnings.warn( "cupyx could not be imported. Image rotation will use scipy", ImportWarning) use_scipy = True if np.any(np.isnan(image)): warnings.warn("Setting NaNs to 0 for SciPy rotation.", SunpyUserWarning) # Transform the image using the scipy affine transform rotated_image = cupyx.scipy.scipy.ndimage.affine_transform( cupy.nan_to_num(cupy.asarray(image)).T, rmatrix, offset=shift, order=order, mode='constant', cval=missing).T return rotated_image.asnumpy() if use_scipy: if np.any(np.isnan(image)): warnings.warn("Setting NaNs to 0 for SciPy rotation.", SunpyUserWarning) # Transform the image using the scipy affine transform rotated_image = scipy.ndimage.interpolation.affine_transform( np.nan_to_num(image).T, rmatrix, offset=shift, order=order, mode='constant', cval=missing).T else: # Make the rotation matrix 3x3 to include translation of the image skmatrix = np.zeros((3, 3)) skmatrix[:2, :2] = rmatrix skmatrix[2, 2] = 1.0 skmatrix[:2, 2] = shift tform = skimage.transform.AffineTransform(skmatrix) if issubclass(image.dtype.type, numbers.Integral): warnings.warn("Integer input data has been cast to float64.", SunpyUserWarning) adjusted_image = image.astype(np.float64) else: adjusted_image = image.copy() if np.any(np.isnan(adjusted_image)) and order >= 4: warnings.warn( "Setting NaNs to 0 for higher-order scikit-image rotation.", SunpyUserWarning) adjusted_image = np.nan_to_num(adjusted_image) # Scale image to range [0, 1] if it is valid (not made up entirely of NaNs) is_nan_image = np.all(np.isnan(adjusted_image)) if is_nan_image: adjusted_missing = missing else: im_min = np.nanmin(adjusted_image) adjusted_image -= im_min im_max = np.nanmax(adjusted_image) if im_max > 0: adjusted_image /= im_max adjusted_missing = (missing - im_min) / im_max else: # The input array is all one value (aside from NaNs), so no scaling is needed adjusted_missing = missing - im_min rotated_image = skimage.transform.warp(adjusted_image, tform, order=order, mode='constant', cval=adjusted_missing) # Convert the image back to its original range if it is valid if not is_nan_image: if im_max > 0: rotated_image *= im_max rotated_image += im_min return rotated_image
def cosine_similarity(X, Y): K = 1.0 - cp.asarray(pairwise_distances(X, Y, metric='cosine')) return cp.nan_to_num(K, copy=False)
def nanmean(a, *args, **kwargs): """ For cupy v0.6.0 compatibility """ return cp.sum(cp.nan_to_num(a), *args, **kwargs) / cp.sum( ~cp.isnan(a), *args, **kwargs )