def _polypow(x, n): if n == 0: return 1 if n == 1: return x if n % 2 == 0: return _polypow(cupy.convolve(x, x), n // 2) return cupy.convolve(x, _polypow(cupy.convolve(x, x), (n - 1) // 2))
def _cross_entropy(image, threshold, bins=_DEFAULT_ENTROPY_BINS): """Compute cross-entropy between distributions above and below a threshold. Parameters ---------- image : array The input array of values. threshold : float The value dividing the foreground and background in ``image``. bins : int or array of float, optional The number of bins or the bin edges. (Any valid value to the ``bins`` argument of ``cp.histogram`` will work here.) For an exact calculation, each unique value should have its own bin. The default value for bins ensures exact handling of uint8 images: ``bins=256`` results in aliasing problems due to bin width not being equal to 1. Returns ------- nu : float The cross-entropy target value as defined in [1]_. Notes ----- See Li and Lee, 1993 [1]_; this is the objective function ``threshold_li`` minimizes. This function can be improved but this implementation most closely matches equation 8 in [1]_ and equations 1-3 in [2]_. References ---------- .. [1] Li C.H. and Lee C.K. (1993) "Minimum Cross Entropy Thresholding" Pattern Recognition, 26(4): 617-625 :DOI:`10.1016/0031-3203(93)90115-D` .. [2] Li C.H. and Tam P.K.S. (1998) "An Iterative Algorithm for Minimum Cross Entropy Thresholding" Pattern Recognition Letters, 18(8): 771-776 :DOI:`10.1016/S0167-8655(98)00057-9` """ bins = cp.asarray(bins) # required for _DEFAULT_ENTROPY_BINS tuple try: # use CuPy's implementation when available histogram, bin_edges = cp.histogram(image, bins=bins, density=True) except TypeError: histogram, bin_edges = cnp.histogram(image, bins=bins, density=True) try: # use CuPy's implementation when available bin_centers = cp.convolve(bin_edges, [0.5, 0.5], mode="valid") except AttributeError: bin_centers = cnp.convolve(bin_edges, [0.5, 0.5], mode="valid") t = cp.flatnonzero(bin_centers > threshold)[0] m0a = cp.sum(histogram[:t]) # 0th moment, background m0b = cp.sum(histogram[t:]) m1a = cp.sum(histogram[:t] * bin_centers[:t]) # 1st moment, background m1b = cp.sum(histogram[t:] * bin_centers[t:]) mua = m1a / m0a # mean value, background mub = m1b / m0b nu = -m1a * cp.log(mua) - m1b * cp.log(mub) return nu
def smooth_curve(x): """損失関数のグラフを滑らかにするために用いる 参考:http://glowingpython.blogspot.jp/2012/02/convolution-with-numpy.html """ window_len = 11 s = np.r_[x[window_len - 1:0:-1], x, x[-1:-window_len:-1]] w = np.kaiser(window_len, 2) y = np.convolve(w / w.sum(), s, mode='valid') return y[5:len(y) - 5]
def polymul(a1, a2): """Computes the product of two polynomials. Args: a1 (scalar, cupy.ndarray or cupy.poly1d): first input polynomial. a2 (scalar, cupy.ndarray or cupy.poly1d): second input polynomial. Returns: cupy.ndarray or cupy.poly1d: The product of the inputs. .. seealso:: :func:`numpy.polymul` """ a1 = cupy.trim_zeros(a1, trim='f') a2 = cupy.trim_zeros(a2, trim='f') if a1.size == 0: a1 = cupy.array([0.], a1.dtype) if a2.size == 0: a2 = cupy.array([0.], a2.dtype) return cupy.convolve(a1, a2)
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
def time_convolve(self, size1, size2, mode): np.convolve(self.x1, self.x2, mode=mode)
def firfilter(b, x, axis=-1, zi=None): """ Filter data along one-dimension with an FIR filter. Filter a data sequence, `x`, using a digital filter. This works for many fundamental data types (including Object type). Please note, cuSignal doesn't support IIR filters presently, and this implementation is optimized for large filtering operations (and inherently depends on fftconvolve) Parameters ---------- b : array_like The numerator coefficient vector in a 1-D sequence. x : array_like An N-dimensional input array. axis : int, optional The axis of the input data array along which to apply the linear filter. The filter is applied to each subarray along this axis. Default is -1. zi : array_like, optional Initial conditions for the filter delays. It is a vector (or array of vectors for an N-dimensional input) of length ``max(len(a), len(b)) - 1``. If `zi` is None or is not given then initial rest is assumed. See `lfiltic` for more information. Returns ------- y : array The output of the digital filter. zf : array, optional If `zi` is None, this is not returned, otherwise, `zf` holds the final filter delay values. """ b = cp.asarray(b) if b.ndim != 1: raise ValueError('object of too small depth for desired array') if x.ndim == 0: raise ValueError('x must be at least 1-D') inputs = [b, x] if zi is not None: # _linear_filter does not broadcast zi, but does do expansion of # singleton dims. zi = cp.asarray(zi) if zi.ndim != x.ndim: raise ValueError('object of too small depth for desired array') expected_shape = list(x.shape) expected_shape[axis] = b.shape[0] - 1 expected_shape = tuple(expected_shape) # check the trivial case where zi is the right shape first if zi.shape != expected_shape: strides = zi.ndim * [None] if axis < 0: axis += zi.ndim for k in range(zi.ndim): if k == axis and zi.shape[k] == expected_shape[k]: strides[k] = zi.strides[k] elif k != axis and zi.shape[k] == expected_shape[k]: strides[k] = zi.strides[k] elif k != axis and zi.shape[k] == 1: strides[k] = 0 else: raise ValueError('Unexpected shape for zi: expected ' '%s, found %s.' % (expected_shape, zi.shape)) zi = cp.lib.stride_tricks.as_strided(zi, expected_shape, strides) inputs.append(zi) dtype = cp.result_type(*inputs) if dtype.char not in 'fdgFDGO': raise NotImplementedError("input type '%s' not supported" % dtype) b = cp.array(b, dtype=dtype) x = cp.array(x, dtype=dtype, copy=False) out_full = cp.apply_along_axis(lambda y: cp.convolve(b, y), axis, x) ind = out_full.ndim * [slice(None)] if zi is not None: ind[axis] = slice(zi.shape[axis]) out_full[tuple(ind)] += zi ind[axis] = slice(out_full.shape[axis] - len(b) + 1) out = out_full[tuple(ind)] if zi is None: return out else: ind[axis] = slice(out_full.shape[axis] - len(b) + 1, None) zf = out_full[tuple(ind)] return out, zf