def cross_validation_error(self): error_per_lambda = xp.zeros(len(self._lambda_vals)) for i in range(len(self._lambda_vals)): lambduh = self._lambda_vals[i] if self._logging: print('lambduh = {} ({} of {})'.format(lambduh, i + 1, num_lambda)) error_per_fold = xp.zeros(self._n_folds) for j in range(self._n_folds): fold_size = int(self._n / self._n_folds) indicies = xp.array(range(0, self._n)) fold_indicies = ((indicies >= fold_size * j) & (indicies <= fold_size * (j + 1))) x_train = self._x[fold_indicies == True] y_train = self._y[fold_indicies == True] x_test = self._x[fold_indicies == False] y_test = self._y[fold_indicies == False] y_train = y_train.reshape((len(y_train), 1)) y_test = y_test.reshape((len(y_test), 1)) y_train = xp.ravel(y_train) y_test = xp.ravel(y_test) svm = SVM(self._kernel, self._kernel_params, lambduh, self._max_iter, self._classification_strategy) svm.fit(x_train, y_train) error_per_fold[j] = svm.compute_misclassification_error( x_test, y_test) error_per_lambda[i] = xp.mean(error_per_fold) return error_per_lambda.tolist()
def append(arr, values, axis=None): # this code is basically copied from numpy/lib/function_base.py's append arr = array(arr) if axis is None: if ndim(arr) != 1: arr = _cp.ravel(arr) values = _cp.ravel(array(values)) axis = ndim(arr) - 1 return concatenate((arr, values), axis=axis)
def getConnectionMatrix(self) -> csr_matrix: distances = cupy.ravel(cupy.fromDlpack(self.D.to_dlpack())) indices = cupy.ravel(cupy.fromDlpack(self.I.to_dlpack())) n_samples = indices.shape[0] n_nonzero = n_samples * self.nneighbors rowptr = cupy.arange(0, n_nonzero + 1, self.nneighbors) knn_graph = cupyx.scipy.sparse.csr_matrix((distances, indices, rowptr), shape=(n_samples, n_samples)) print(f"Completed KNN, sparse graph shape = {knn_graph.shape}") return knn_graph
def inject_error(weight, mask0, mask1, num_bits=32): if num_bits == 32: dtype = cp.uint32 ftype = cp.float32 shape = weight.shape weight_flatten = cp.ravel(weight).view(dtype) mask0, mask0_bit = mask0 mask1, mask1_bit = mask1 zero = cp.zeros(1, dtype=dtype) if (mask0.__len__() is not 0) or (mask1.__len__() is not 0): for b in range(num_bits): fault = cp.full(weight_flatten.size, 2**b, dtype=dtype) bit_loc0 = cp.where(mask0_bit == b, mask0, zero).nonzero()[0] bit_loc1 = cp.where(mask1_bit == b, mask1, zero).nonzero()[0] uniform0 = cp.zeros(weight_flatten.size, dtype=dtype) uniform1 = cp.zeros(weight_flatten.size, dtype=dtype) # Inject bit error if bit_loc0.__len__() > 0: cp.put(uniform0, mask0[bit_loc0], fault) cp.put(uniform1, mask1[bit_loc1], fault) # Stuck at 0 not_mask0 = cp.invert(uniform0) weight_flatten = cp.bitwise_and(weight_flatten, not_mask0) # Stuck at 1 weight_flatten = cp.bitwise_or(weight_flatten, uniform1) weight_float = weight_flatten.view(ftype) return cp.reshape(weight_float, shape) else: return weight
def _build_laplacian(data, spacing, mask, beta, multichannel): l_x, l_y, l_z = data.shape[:3] edges = _make_graph_edges_3d(l_x, l_y, l_z) weights = _compute_weights_3d(data, spacing, beta=beta, eps=1.e-10, multichannel=multichannel) assert weights.dtype == data.dtype if mask is not None: # Remove edges of the graph connected to masked nodes, as well # as corresponding weights of the edges. mask0 = cp.concatenate([mask[..., :-1].ravel(), mask[:, :-1].ravel(), mask[:-1].ravel()]) mask1 = cp.concatenate([mask[..., 1:].ravel(), mask[:, 1:].ravel(), mask[1:].ravel()]) ind_mask = cp.logical_and(mask0, mask1) edges, weights = edges[:, ind_mask], weights[ind_mask] # Reassign edges labels to 0, 1, ... edges_number - 1 _, inv_idx = cp.unique(edges, return_inverse=True) edges = inv_idx.reshape(edges.shape) # Build the sparse linear system pixel_nb = l_x * l_y * l_z i_indices = edges.ravel() j_indices = edges[::-1].ravel() data = cp.concatenate((weights, weights)) lap = sparse.coo_matrix((data, (i_indices, j_indices)), shape=(pixel_nb, pixel_nb)) # need CSR instead of COO for indexing used later in _build_linear_system lap = lap.tocsr() lap.setdiag(-cp.ravel(lap.sum(axis=0))) return lap
def setdiff1d(ar1, ar2, assume_unique=False): """Find the set difference of two arrays. It returns unique values in `ar1` that are not in `ar2`. Parameters ---------- ar1 : cupy.ndarray Input array ar2 : cupy.ndarray Input array for comparision assume_unique : bool By default, False, i.e. input arrays are not unique. If True, input arrays are assumed to be unique. This can speed up the calculation. Returns ------- setdiff1d : cupy.ndarray Returns a 1D array of values in `ar1` that are not in `ar2`. It always returns a sorted output for unsorted input only if `assume_unique=False`. See Also -------- numpy.setdiff1d """ if assume_unique: ar1 = cupy.ravel(ar1) else: ar1 = cupy.unique(ar1) ar2 = cupy.unique(ar2) return ar1[in1d(ar1, ar2, assume_unique=True, invert=True)]
def forward(self, a_prev: cp.array, training=True) -> cp.array: """ :param a_prev - ND tensor with shape (n, ..., channels) :output - 1D tensor with shape (n, 1) ------------------------------------------------------------------------ n - number of examples in batch """ self._shape = a_prev.shape return cp.ravel(a_prev).reshape(a_prev.shape[0], -1)
def ECP(error_weight, orig_weight, set_map): orig_shape = error_weight.shape error_weight, orig_weight = cp.ravel(error_weight.view( cp.uint32)), cp.ravel(orig_weight.view(cp.uint32)) shape = (int(error_weight.__len__() / 16), 16) # Reshape 64 bit in one row error_weight, orig_weight = cp.reshape(error_weight, shape), cp.reshape( orig_weight, shape) # Calculate stuck bits stuck_bits = cp.bitwise_xor(error_weight, orig_weight) stuck_bits_sum = cp.sum(stuck_bits, axis=1) error = cp.concatenate(cp.in1d(stuck_bits_sum, set_map).nonzero()) if error.__len__() == 0: return cp.reshape(error_weight, orig_shape).view(cp.float32) else: error_weight[error, :] = orig_weight[error, :] return cp.reshape(error_weight, orig_shape).view(cp.float32)
def wiener(im, mysize=None, noise=None): """ Perform a Wiener filter on an N-dimensional array. Apply a Wiener filter to the N-dimensional array `im`. Parameters ---------- im : ndarray An N-dimensional array. mysize : int or array_like, optional A scalar or an N-length list giving the size of the Wiener filter window in each dimension. Elements of mysize should be odd. If mysize is a scalar, then this scalar is used as the size in each dimension. noise : float, optional The noise-power to use. If None, then noise is estimated as the average of the local variance of the input. Returns ------- out : ndarray Wiener filtered result with the same shape as `im`. """ im = asarray(im) if mysize is None: mysize = [3] * im.ndim mysize = np.asarray(mysize) if mysize.shape == (): mysize = cp.repeat(mysize.item(), im.ndim) mysize = np.asarray(mysize) # Estimate the local mean lMean = correlate(im, ones(mysize), "same") / prod(mysize, axis=0) # Estimate the local variance lVar = ( correlate(im ** 2, ones(mysize), "same") / prod(mysize, axis=0) - lMean ** 2 ) # Estimate the noise power if needed. if noise is None: noise = mean(ravel(lVar), axis=0) res = im - lMean res *= 1 - noise / lVar res += lMean out = where(lVar < noise, lMean, res) return out
def ssb_kernel(processed4D, real_calibration, aperture, voltage, chunks=12): data_size = np.asarray(processed4D.shape) processed4D = np.reshape( processed4D, (data_size[0], data_size[1], data_size[2] * data_size[3])) wavelength = wavelength_pm(voltage) cutoff = aperture / (1000 * wavelength) four_y = cp.fft.fftshift(cp.fft.fftfreq(data_size[0], real_calibration)) four_x = cp.fft.fftshift(cp.fft.fftfreq(data_size[1], real_calibration)) Four_X, Four_Y = cp.meshgrid(four_x, four_y) FourXY = cp.sqrt((Four_Y**2) + (Four_X**2)) yy, xx = cp.mgrid[0:data_size[0], 0:data_size[1]] rsize = cp.zeros((np.size(yy), 2), dtype=int) rsize[:, 0] = cp.ravel(yy) rsize[:, 1] = cp.ravel(xx) left_imGPU, rightimGPU = lobe_calc(processed4D, Four_Y, Four_X, FourXY, rsize, cutoff, chunks) left_image = cp.asnumpy(cp.fft.ifft2(left_imGPU)) rightimage = cp.asnumpy(cp.fft.ifft2(rightimGPU)) del four_y, four_x, Four_X, Four_Y, FourXY, yy, xx, rsize, left_imGPU, rightimGPU return left_image, rightimage
def wiener(im, mysize=None, noise=None): """ Perform a Wiener filter on an N-dimensional array. Apply a Wiener filter to the N-dimensional array `im`. Parameters ---------- im : ndarray An N-dimensional array. mysize : int or array_like, optional A scalar or an N-length list giving the size of the Wiener filter window in each dimension. Elements of mysize should be odd. If mysize is a scalar, then this scalar is used as the size in each dimension. noise : float, optional The noise-power to use. If None, then noise is estimated as the average of the local variance of the input. Returns ------- out : ndarray Wiener filtered result with the same shape as `im`. """ im = cp.asarray(im) if mysize is None: mysize = [3] * im.ndim mysize = np.asarray(mysize) if mysize.shape == (): mysize = cp.repeat(mysize.item(), im.ndim) mysize = np.asarray(mysize) lprod = cp.prod(mysize, axis=0) lMean = correlate(im, cp.ones(mysize), "same") lVar = correlate(im**2, cp.ones(mysize), "same") lMean, lVar = _wiener_prep_kernel(lMean, lVar, lprod) # Estimate the noise power if needed. if noise is None: noise = cp.mean(cp.ravel(lVar), axis=0) return _wiener_post_kernel(im, lMean, lVar, noise)
def go_cupy(signal, gpuR, gpuW): """ Run demodulation on the GPU First store the reference and window data on the GPU using the init_gpu() function. The object returned are required for this function. Returns: - A (M, N) numpy array (np.float64) buffer for the average of the convolution result along the second dimension of the signal data. This can be considered as the demodulation result for each demodulation channel. """ N, k = signal.shape M = gpuR.shape[0] gpuS = cp.asarray(signal) results = np.zeros((M, N)) for i in range(M): buffer = cp.multiply(gpuS, gpuR[i,:]) buffer = cp.ravel(buffer) buffer = cp.convolve(buffer, gpuW, mode='same') buffer = cp.reshape(buffer, signal.shape) buffer = cp.mean(buffer, axis=1) results[i,:] = cp.asnumpy(buffer) return results
# However, it's a good opportunity to get familiar with the API source_df: cudf.DataFrame = cudf.read_csv( '/att/nobackup/tpmaxwel/data/fashion-mnist-csv/fashion_train.csv') data = source_df.loc[:, source_df.columns[:-1]] target = source_df[source_df.columns[-1]] n_neighbors = 5 # fit model model = NearestNeighbors(n_neighbors=5) model.fit(data) # get nearest neighbors dist_mlarr, ind_mlarr = model.kneighbors(data, return_distance=True) # create sparse matrix distances = cupy.ravel(cupy.fromDlpack(dist_mlarr.to_dlpack())) indices = cupy.ravel(cupy.fromDlpack(ind_mlarr.to_dlpack())) print( f"Computed KNN graph, distances shape = {distances.shape}, indices shape = {indices.shape}, distances[0:5]= {distances[0:5]}, indices[0:5]= {indices[0:5]}" ) n_samples = indices.shape[0] n_nonzero = n_samples * n_neighbors rowptr = cupy.arange(0, n_nonzero + 1, n_neighbors) knn_graph = cupyx.scipy.sparse.csr_matrix((distances, indices, rowptr), shape=(n_samples, n_samples)) print(f"Completed KNN, graph shape = {knn_graph.shape}") reducer = cuml.UMAP(n_neighbors=15, n_components=3, n_epochs=500,
def weighted_mode(a, w, *, axis=0): """Returns an array of the weighted modal (most common) value in a If there is more than one such value, only the first is returned. The bin-count for the modal bins is also returned. This is an extension of the algorithm in scipy.stats.mode. Parameters ---------- a : array_like n-dimensional array of which to find mode(s). w : array_like n-dimensional array of weights for each value axis : int, optional Axis along which to operate. Default is 0, i.e. the first axis. Returns ------- vals : ndarray Array of modal values. score : ndarray Array of weighted counts for each mode. Examples -------- >>> from sklearn.utils.extmath import weighted_mode >>> x = [4, 1, 4, 2, 4, 2] >>> weights = [1, 1, 1, 1, 1, 1] >>> weighted_mode(x, weights) (array([4.]), array([3.])) The value 4 appears three times: with uniform weights, the result is simply the mode of the distribution. >>> weights = [1, 3, 0.5, 1.5, 1, 2] # deweight the 4's >>> weighted_mode(x, weights) (array([2.]), array([3.5])) The value 2 has the highest score: it appears twice with weights of 1.5 and 2: the sum of these is 3.5. See Also -------- scipy.stats.mode """ if axis is None: a = np.ravel(a) w = np.ravel(w) axis = 0 else: a = np.asarray(a) w = np.asarray(w) if a.shape != w.shape: w = np.full(a.shape, w, dtype=w.dtype) scores = np.unique(np.ravel(a)) # get ALL unique values testshape = list(a.shape) testshape[axis] = 1 oldmostfreq = np.zeros(testshape) oldcounts = np.zeros(testshape) for score in scores: template = np.zeros(a.shape) ind = (a == score) template[ind] = w[ind] counts = np.expand_dims(np.sum(template, axis), axis) mostfrequent = np.where(counts > oldcounts, score, oldmostfreq) oldcounts = np.maximum(counts, oldcounts) oldmostfreq = mostfrequent return mostfrequent, oldcounts
def _inner_prod(self, x, y): return cp.real(cp.dot(cp.conj(cp.ravel(x)), cp.ravel(y)))
def _inner_prod(self, x, y): return cp.dot(cp.ravel(x), cp.ravel(y))
def backward_pool(dA, A_previous, stride, f, mode = "max"): ''' A backward pool step Parameters ---------- dA : cp.array(examples, 1 + (height - f) / stride, 1 + (width - f) / stride, depth) Cost derivative from l+1 layer. A_previous : cp.array(examples, height, width, depth) Output image from the l-1 layer. stride : int Stride parameter. f : int Square filter dimension. mode : string, optional Filter type. The default is "max". Returns ------- dA_prev : cp.array(examples, height, width, depth) Cost derivative from the current layer. ''' m, n_H_prev, n_W_prev, n_C_prev = A_previous.shape m, n_H, n_W, n_C = dA.shape dA = cp.ravel(cp.transpose(dA, (1, 2, 0, 3))) dA_prev = cp.zeros((f**2, dA.size)) A_previous = cp.reshape(cp.transpose(A_previous, (0, 3, 1, 2)), (m*n_C_prev, 1, n_H_prev, n_W_prev)) A_prev = Utils.image_to_column(A_previous, (f, f), stride) if mode == "max": mask = cp.argmax(A_prev, axis=0).flatten() dA_prev[mask, cp.linspace(0, dA.size-1, dA.size, dtype=int)] = dA elif mode == "mean": dA_prev[:, cp.linspace(0, dA.size-1, dA.size, dtype=int)] = 1. / dA_prev.shape[0] * dA dA_prev = cp.reshape(dA_prev, (n_H_prev, n_W_prev, m, n_C_prev)) dA_prev = cp.transpose(dA_prev, (2, 0, 1, 3)) ''' Intuitive way (Really not optimized) for i in range(m): a_prev = A_previous[i, :, :, :] for h in range(n_H): vert_start = h*stride vert_end = h*stride + f for w in range(n_W): horiz_start = w*stride horiz_end = w*stride + f for c in range(n_C): if mode == "max": a_prev_slice = a_prev[vert_start:vert_end, horiz_start:horiz_end, c] mask = (a_prev_slice == cp.max(a_prev_slice)) dA_prev[i, vert_start: vert_end, horiz_start: horiz_end, c] += mask*dA[i,h,w,c] elif mode == "mean": dA_prev[i, vert_start: vert_end, horiz_start: horiz_end, c] += dA[i,h,w,c] * cp.ones((f, f))/f**2 ''' return dA_prev
def set(self, vect, name, value): """Takes in a vector and returns the subset indexed by name.""" idxs, _ = self.idxs_and_shapes[name] vect[idxs] = np.ravel(value)
def forward(self, prev_arr): # Conv, pooling 이 끝난 데이터(n차원)을 입력받아서 1차원으로 변환한다. self.prev_shape = prev_arr.shape return np.ravel(prev_arr).reshape(prev_arr.shape[0], -1)
if (types=='all'): histogram.append(list(spacinginfo[0])) allspacings=spacinginfo[1] elif (types=='median'): spacinghistograms=spacinginfo else: #Creating histogram data spacinghistograms=spacinginfo x = range(len(spacinginfo)) x_coord = cp.repeat(x, len(spacinginfo[0])) cp.cuda.Stream.null.synchronize() spacing_array = cp.array(spacinginfo) cp.cuda.Stream.null.synchronize() allhists = cp.ravel(spacing_array) cp.cuda.Stream.null.synchronize() #Saving data to excel spreadsheet for batching workbook = xlsxwriter.Workbook('Frech_Christian_cupyprobdensitydata.xlsx') worksheet = workbook.add_worksheet() bold = workbook.add_format({'bold'=True}) col = findIndex(upperlimit,upperlimit_list) worksheet.write(0, col, upperlimit, bold) for row in range(len(stdevvalues)): worksheet.write((row+1), col, allhists[row]) # Create a figure for plotting the data as a 3D histogram. fig, ax = plt.subplots(1,1)