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
