def __init__(self, indim, outdim, normfac, fl=400, fs=80, fftl=512, fbsize=400): self.indim = indim self.outdim = outdim self.fl = fl self.fs = fs self.fftl = fftl self.fbsize = fbsize self.normfac = {'input' : {'mean' : cuda.to_gpu(normfac['input']['mean']), 'std' : cupy.fmax(cuda.to_gpu(normfac['input']['std']), 1.0E-6)}, 'output' : {'mean' : cuda.to_gpu(normfac['output']['mean']), 'std' : cupy.fmax(cuda.to_gpu(normfac['output']['std']), 1.0E-6)}} super(Model, self).__init__() with self.init_scope(): self.lx1 = L.NStepBiLSTM(1, self.indim, self.indim//2, 0.0) self.lx2 = L.Convolution2D(1, self.indim, (5, self.indim), (1, 1), (2, 0)) self.ly1 = L.NStepLSTM(3, self.fbsize+self.indim, 256, 0.0) self.ly2 = L.Linear(256, self.outdim)
def _lossP(self, A, P): floor = 1.0E-6 inum = cupy.array(1.0j, cupy.complex64) loss = (self.alpha * (1 - cupy.cos(P['y'] - P['x']))).mean() grad = self._overlapadd( cupy.fft.irfft(self.alpha * cupy.sin(P['y'] - P['x']) / cupy.fmax( A['x'], floor) * cupy.exp(inum * (P['x'] - 0.5 * cupy.pi))) * self.norm) return loss, grad
for epoch in range(ngen): train_x, train_y = shuffle(train_x, train_y, random_state=random_state) for gen in range(n_batches): cp.cuda.Device(0).use() valid_y = cp.array(valid_y) network.gen_ind(population) network.conv_to_cp() start = gen * batch_size_ev end = start + batch_size_ev for i in range(start, end): train_x_cp = cp.array(train_x[i]) train_y_cp = cp.array(train_y[i]) y = cp.matmul(train_x_cp, network.W) + network.b y = cp.exp(y) y = y / (cp.sum(y, axis=1)[:, cp.newaxis]) y = cp.fmax(nan_, y) network.cost += -cp.sum(train_y_cp * cp.log(y), axis=1) network.cost /= batch_size_ev network.selection() network.update_path(quantile) valid_y = cp.asnumpy(valid_y) #cp.cuda.Device(1).use() y = cp.matmul(valid_x_cp, network.W_top) + network.b_top y = cp.exp(y) / cp.sum(cp.exp(y), axis=1)[:, cp.newaxis] y = cp.fmax(1e-10, y) valid_cost = cp.mean(-cp.sum(valid_y_cp * cp.log(y), axis=1)) y = cp.asnumpy(y) pred_y = np.argmax(y, 1).astype('int32') f1 = f1_score(np.argmax(valid_y, 1).astype('int32'), pred_y.astype('int32'),
def relu_(x): return cp.fmax(x, 0)
for i in range(start, end): train_x_cp = cp.array(train_x[i]) train_y_cp = cp.array(train_y[i]) y = relu_(cp.matmul(train_x_cp, dense1.W) + dense1.b) y = relu_(cp.matmul(y, W2) + b2) y = relu_(cp.matmul(y, W3) + b3) y = relu_(cp.matmul(y, W4) + b4) y = relu_(cp.matmul(y, W5) + b5) y = relu_(cp.matmul(y, W6) + b6) y = relu_(cp.matmul(y, W7) + b7) y = relu_(cp.matmul(y, W8) + b8) y = relu_(cp.matmul(y, W9) + b9) y = cp.matmul(y, W10) + b10 y = cp.exp(y) / cp.sum(cp.exp(y), axis=1)[:, cp.newaxis] y = cp.fmax(1e-10, y) dense1.cost += -cp.sum(train_y_cp*cp.log(y), axis=1) dense1.cost /= batch_size_ev dense1.selection() dense1.update_path(quantile) W1 = cp.array(dense1.W_top) b1 = cp.array(dense1.b_top) valid_x_cp = cp.array(valid_x) valid_y_cp = cp.array(valid_y) valid_y = cp.asnumpy(valid_y) y = relu_(cp.matmul(valid_x_cp, W1) + b1) y = relu_(cp.matmul(y, W2) + b2) y = relu_(cp.matmul(y, W3) + b3) y = relu_(cp.matmul(y, W4) + b4)
def cross_correlate_masked(arr1, arr2, m1, m2, mode="full", axes=(-2, -1), overlap_ratio=0.3): """ Masked normalized cross-correlation between arrays. Parameters ---------- arr1 : ndarray First array. arr2 : ndarray Seconds array. The dimensions of `arr2` along axes that are not transformed should be equal to that of `arr1`. m1 : ndarray Mask of `arr1`. The mask should evaluate to `True` (or 1) on valid pixels. `m1` should have the same shape as `arr1`. m2 : ndarray Mask of `arr2`. The mask should evaluate to `True` (or 1) on valid pixels. `m2` should have the same shape as `arr2`. mode : {'full', 'same'}, optional 'full': This returns the convolution at each point of overlap. At the end-points of the convolution, the signals do not overlap completely, and boundary effects may be seen. 'same': The output is the same size as `arr1`, centered with respect to the `‘full’` output. Boundary effects are less prominent. axes : tuple of ints, optional Axes along which to compute the cross-correlation. overlap_ratio : float, optional Minimum allowed overlap ratio between images. The correlation for translations corresponding with an overlap ratio lower than this threshold will be ignored. A lower `overlap_ratio` leads to smaller maximum translation, while a higher `overlap_ratio` leads to greater robustness against spurious matches due to small overlap between masked images. Returns ------- out : ndarray Masked normalized cross-correlation. Raises ------ ValueError : if correlation `mode` is not valid, or array dimensions along non-transformation axes are not equal. References ---------- .. [1] Dirk Padfield. Masked Object Registration in the Fourier Domain. IEEE Transactions on Image Processing, vol. 21(5), pp. 2706-2718 (2012). :DOI:`10.1109/TIP.2011.2181402` .. [2] D. Padfield. "Masked FFT registration". In Proc. Computer Vision and Pattern Recognition, pp. 2918-2925 (2010). :DOI:`10.1109/CVPR.2010.5540032` """ if mode not in {"full", "same"}: raise ValueError("Correlation mode {} is not valid.".format(mode)) if arr1.dtype.kind == "c" or arr2.dtype.kind == "c": raise ValueError("complex-valued arr1, arr2 are not supported") fixed_image = cp.asarray(arr1, dtype=np.float) fixed_mask = cp.asarray(m1, dtype=np.bool) moving_image = cp.asarray(arr2, dtype=np.float) moving_mask = cp.asarray(m2, dtype=np.bool) eps = np.finfo(np.float).eps # Array dimensions along non-transformation axes should be equal. all_axes = set(range(fixed_image.ndim)) for axis in all_axes - set(axes): if fixed_image.shape[axis] != moving_image.shape[axis]: raise ValueError( "Array shapes along non-transformation axes should be " "equal, but dimensions along axis {a} are not".format(a=axis)) # Determine final size along transformation axes # Note that it might be faster to compute Fourier transform in a slightly # larger shape (`fast_shape`). Then, after all fourier transforms are done, # we slice back to`final_shape` using `final_slice`. final_shape = list(arr1.shape) for axis in axes: final_shape[axis] = (fixed_image.shape[axis] + moving_image.shape[axis] - 1) final_shape = tuple(final_shape) final_slice = tuple([slice(0, int(sz)) for sz in final_shape]) # Extent transform axes to the next fast length (i.e. multiple of 3, 5, or # 7) fast_shape = tuple([next_fast_len(final_shape[ax]) for ax in axes]) # We use numpy.fft or the new scipy.fft because they allow leaving the # transform axes unchanged which was not possible with scipy.fftpack's # fftn/ifftn in older versions of SciPy. # E.g. arr shape (2, 3, 7), transform along axes (0, 1) with shape (4, 4) # results in arr_fft shape (4, 4, 7) fft = partial(fftmodule.fftn, s=fast_shape, axes=axes) ifft = partial(fftmodule.ifftn, s=fast_shape, axes=axes) fixed_image[cp.logical_not(fixed_mask)] = 0.0 moving_image[cp.logical_not(moving_mask)] = 0.0 # N-dimensional analog to rotation by 180deg is flip over all relevant axes. # See [1] for discussion. rotated_moving_image = _flip(moving_image, axes=axes) rotated_moving_mask = _flip(moving_mask, axes=axes) fixed_fft = fft(fixed_image) rotated_moving_fft = fft(rotated_moving_image) fixed_mask_fft = fft(fixed_mask) rotated_moving_mask_fft = fft(rotated_moving_mask) # Calculate overlap of masks at every point in the convolution. # Locations with high overlap should not be taken into account. number_overlap_masked_px = cp.real( ifft(rotated_moving_mask_fft * fixed_mask_fft)) number_overlap_masked_px[:] = cp.around(number_overlap_masked_px) number_overlap_masked_px[:] = cp.fmax(number_overlap_masked_px, eps) masked_correlated_fixed_fft = ifft(rotated_moving_mask_fft * fixed_fft) masked_correlated_rotated_moving_fft = ifft(fixed_mask_fft * rotated_moving_fft) numerator = ifft(rotated_moving_fft * fixed_fft) numerator -= (masked_correlated_fixed_fft * masked_correlated_rotated_moving_fft / number_overlap_masked_px) fixed_squared_fft = fft(cp.square(fixed_image)) fixed_denom = ifft(rotated_moving_mask_fft * fixed_squared_fft) fixed_denom -= (cp.square(masked_correlated_fixed_fft) / number_overlap_masked_px) fixed_denom[:] = cp.fmax(fixed_denom, 0.0) rotated_moving_squared_fft = fft(cp.square(rotated_moving_image)) moving_denom = ifft(fixed_mask_fft * rotated_moving_squared_fft) moving_denom -= (cp.square(masked_correlated_rotated_moving_fft) / number_overlap_masked_px) moving_denom[:] = cp.fmax(moving_denom, 0.0) denom = cp.sqrt(fixed_denom * moving_denom) # Slice back to expected convolution shape. numerator = numerator[final_slice] denom = denom[final_slice] number_overlap_masked_px = number_overlap_masked_px[final_slice] if mode == "same": _centering = partial(_centered, newshape=fixed_image.shape, axes=axes) denom = _centering(denom) numerator = _centering(numerator) number_overlap_masked_px = _centering(number_overlap_masked_px) # Pixels where `denom` is very small will introduce large # numbers after division. To get around this problem, # we zero-out problematic pixels. tol = 1e3 * eps * cp.max(cp.abs(denom), axis=axes, keepdims=True) nonzero_indices = denom > tol # TODO: grlee77: Added a cast to real here. # probably it should be real earlier? numerator = numerator.real denom = denom.real out = cp.zeros_like(denom) out[nonzero_indices] = numerator[nonzero_indices] / denom[nonzero_indices] cp.clip(out, a_min=-1, a_max=1, out=out) # Apply overlap ratio threshold number_px_threshold = overlap_ratio * cp.max( number_overlap_masked_px, axis=axes, keepdims=True) out[number_overlap_masked_px < number_px_threshold] = 0.0 return out