def black_tophat( input, size=None, footprint=None, structure=None, output=None, mode='reflect', cval=0.0, origin=0, ): """ Multidimensional black tophat filter. Args: input (cupy.ndarray): The input array. size (tuple of ints): Shape of a flat and full structuring element used for the black tophat. Optional if ``footprint`` or ``structure`` is provided. footprint (array of ints): Positions of non-infinite elements of a flat structuring element used for the black tophat. Non-zero values give the set of neighbors of the center over which opening is chosen. structure (array of ints): Structuring element used for the black tophat. ``structure`` may be a non-flat structuring element. output (cupy.ndarray, dtype or None): The array in which to place the output. mode (str): The array borders are handled according to the given mode (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``, ``'wrap'``). Default is ``'reflect'``. cval (scalar): Value to fill past edges of input if mode is ``constant``. Default is ``0.0``. origin (scalar or tuple of scalar): The origin parameter controls the placement of the filter, relative to the center of the current element of the input. Default of 0 is equivalent to ``(0,)*input.ndim``. Returns: cupy.ndarry : Result of the filter of ``input`` with ``structure``. .. seealso:: :func:`scipy.ndimage.black_tophat` """ if (size is not None) and (footprint is not None): warnings.warn( 'ignoring size because footprint is set', UserWarning, stacklevel=2 ) tmp = grey_dilation( input, size, footprint, structure, None, mode, cval, origin ) tmp = grey_erosion( tmp, size, footprint, structure, output, mode, cval, origin ) if input.dtype == numpy.bool_ and tmp.dtype == numpy.bool_: cupy.bitwise_xor(tmp, input, out=tmp) else: cupy.subtract(tmp, input, out=tmp) return tmp
def transform(self, X): """[summary]. Args: X (cupy.ndarray): [description]. Returns: cupy.ndarray: [description]. """ check_is_fitted(self, "class_means_") # TODO(smly): # X = column_or_1d(X, warn=True) # Label encoding if necessary if self._label_encoding_uniques is not None: X = self._label_encoding_uniques.get_indexer(X.to_pandas()) X = cupy.asarray(X) missing_mask = cupy.isnan(X) encode_mask = cupy.invert(missing_mask) unseen_mask = cupy.bitwise_xor( cupy.isin(X, self.classes_, invert=True), missing_mask) X = X.copy() X[unseen_mask] = cupy.max(self.classes_) indices = _get_index_cupy(self.classes_, X[encode_mask]) _classes_index_list = cupy.searchsorted(self.lut_[:, 0], self.classes_) encoded_values = cupy.zeros(X.shape[0], dtype=cupy.float32) encoded_values[encode_mask] = cupy.take( self.lut_[:, 1], cupy.take(_classes_index_list, indices)) encoded_values[unseen_mask] = self.default_unseen_ return encoded_values
def int_value_noise_3d(x, y, z, seed): x = x.astype(int) y = y.astype(int) z = z.astype(int) c = (__BN_X_NOISE_GEN * x) + (__BN_Y_NOISE_GEN * y) + ( __BN_Z_NOISE_GEN * z) + __BN_SEED_NOISE_GEN * seed c = cp.bitwise_and(c, 0x7fffffff) c = cp.bitwise_xor(cp.right_shift(c, 13), c) c = cp.bitwise_and((c * (c * c * 60493 + 19990303) + 1376312589), 0x7fffffff) return c
def bitwise_xor(x1: Array, x2: Array, /) -> Array: """ Array API compatible wrapper for :py:func:`np.bitwise_xor <numpy.bitwise_xor>`. See its docstring for more information. """ if (x1.dtype not in _integer_or_boolean_dtypes or x2.dtype not in _integer_or_boolean_dtypes): raise TypeError( "Only integer or boolean dtypes are allowed in bitwise_xor") # Call result type here just to raise on disallowed type combinations _result_type(x1.dtype, x2.dtype) x1, x2 = Array._normalize_two_args(x1, x2) return Array._new(np.bitwise_xor(x1._array, x2._array))
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 gradient_noise_3d(fx, fy, fz, ix, iy, iz, seed): vi = (__BN_X_NOISE_GEN * ix) + (__BN_Y_NOISE_GEN * iy) + ( __BN_Z_NOISE_GEN * iz) + __BN_SEED_NOISE_GEN * seed vi = cp.bitwise_and(vi, 0xffffffff) vi = cp.bitwise_xor(vi, cp.right_shift(vi, __BN_SHIFT_NOISE_GEN)) vi = cp.bitwise_and(vi, 0xff) vi_l2 = cp.left_shift(vi, 2) xvGrad = g_randomVectors[vi_l2] yvGrad = g_randomVectors[vi_l2 + 1] zvGrad = g_randomVectors[vi_l2 + 2] xvPoint = fx - ix yvPoint = fy - iy zvPoint = fz - iz return ((xvGrad * xvPoint) + (yvGrad * yvPoint) + (zvGrad * zvPoint)) * 2.12
s = time.time() Wb = _preprocess()(Wb, Wb.shape[0], cupy.zeros((Wb.shape[0], Wb.shape[1]//32)).astype("int32"), size=Wb.shape[1] ) preprocess_time += time.time()-s s = time.time() xb = _preprocess_vec()(xb, cupy.zeros((xb.shape[0]//32)).astype("int32"), size=xb.shape[0] ) preprocess_vec_time += time.time()-s s = time.time() yb = cupy.invert(cupy.bitwise_xor(Wb, xb)) xnor_time += time.time()-s s = time.time() yb = _popcount()(yb, axis=1) popcount_time += time.time()-s print "binarize_time: {0}".format(binarize_time) print "preprocess_time: {0}".format(preprocess_time) print "preprocess_vec_time: {0}".format(preprocess_vec_time) print "xnor_time: {0}".format(xnor_time) print "popcount_time: {0}".format(popcount_time) binarize_log.append(binarize_time) preprocess_log.append(preprocess_time) preprocess_vec_log.append(preprocess_vec_time)
def __rxor__(self, other): return cupy.bitwise_xor(other, self)
def __xor__(self, other): return cupy.bitwise_xor(self, other)
s = time.time() Wb = _preprocess()(Wb, Wb.shape[0], cupy.zeros((Wb.shape[0], Wb.shape[1] // 32)).astype("int32"), size=Wb.shape[1]) preprocess_time += time.time() - s s = time.time() xb = _preprocess_vec()(xb, cupy.zeros( (xb.shape[0] // 32)).astype("int32"), size=xb.shape[0]) preprocess_vec_time += time.time() - s s = time.time() yb = cupy.invert(cupy.bitwise_xor(Wb, xb)) xnor_time += time.time() - s s = time.time() yb = _popcount()(yb, axis=1) popcount_time += time.time() - s print "binarize_time: {0}".format(binarize_time) print "preprocess_time: {0}".format(preprocess_time) print "preprocess_vec_time: {0}".format(preprocess_vec_time) print "xnor_time: {0}".format(xnor_time) print "popcount_time: {0}".format(popcount_time) binarize_log.append(binarize_time) preprocess_log.append(preprocess_time) preprocess_vec_log.append(preprocess_vec_time)