def test_resizer(axes): rng = np.random.RandomState(42) resizer = PadAndCropResizer() checker = NoResizer() for _ in range(50): imdims = list(rng.randint(20,40,size=len(axes))) div_by = list(rng.randint(1,20,size=len(axes))) u = np.empty(imdims,np.float32) if any(s%div_n!=0 for s, div_n in zip(imdims, div_by)): with pytest.raises(ValueError): checker.before(u, axes, div_by) v = resizer.before(u, axes, div_by) assert all ( s_v >= s_u and s_v%div_n==0 for s_u, s_v, div_n in zip(u.shape, v.shape, div_by) ) w = resizer.after(v, axes) assert u.shape == w.shape d = rng.choice(len(axes)) _axes = axes.replace(axes[d],'') _u = np.take(u,0,axis=d) _v = np.take(v,0,axis=d) _w = resizer.after(_v, _axes) assert _u.shape == _w.shape
def predict(self, img, axes, resizer=PadAndCropResizer(), n_tiles=None): """ Apply the network to sofar unseen data. This method expects the raw data, i.e. not normalized. During prediction the mean and standard deviation, stored with the model (during data generation), are used for normalization. Parameters ---------- img : array(floats) The raw images. axes : String Axes of the image ('YX'). resizer : class(Resizer), optional(default=PadAndCropResizer()) n_tiles : tuple(int) Number of tiles to tile the image into, if it is too large for memory. Returns ------- image : array(float) The restored image. """ mean, std = float(self.config.mean), float(self.config.std) normalized = self.__normalize__(img, mean, std) pred = self._predict_mean_and_scale(normalized, axes=axes, normalizer=None, resizer=resizer, n_tiles=n_tiles)[0] return self.__denormalize__(pred, mean, std)
def predict(self, img, axes, resizer=PadAndCropResizer(), n_tiles=None): """ Apply the network to sofar unseen data. This method expects the raw data, i.e. not normalized. During prediction the mean and standard deviation, stored with the model (during data generation), are used for normalization. Parameters ---------- img : array(floats) The raw images. axes : String Axes of the image ('YX'). resizer : class(Resizer), optional(default=PadAndCropResizer()) n_tiles : tuple(int) Number of tiles to tile the image into, if it is too large for memory. Returns ------- image : array(float) The restored image. """ means = np.array([float(mean) for mean in self.config.means], ndmin=len(img.shape), dtype=np.float32) stds = np.array([float(std) for std in self.config.stds], ndmin=len(img.shape), dtype=np.float32) if img.dtype != np.float32: print( 'The input image is of type {} and will be casted to float32 for prediction.' .format(img.dtype)) img = img.astype(np.float32) new_axes = axes new_n_tiles = n_tiles if 'C' in axes: new_axes = axes.replace('C', '') + 'C' if n_tiles: new_n_tiles = tuple( [n_tiles[axes.index(c)] for c in axes if c != 'C']) + (n_tiles[axes.index('C')], ) normalized = self.__normalize__( np.moveaxis(img, axes.index('C'), -1), means, stds) else: normalized = self.__normalize__(img[..., np.newaxis], means, stds) normalized = normalized[..., 0] pred = self._predict_mean_and_scale(normalized, axes=new_axes, normalizer=None, resizer=resizer, n_tiles=new_n_tiles)[0] pred = self.__denormalize__(pred, means, stds) if 'C' in axes: pred = np.moveaxis(pred, -1, axes.index('C')) return pred
def predict(self, img, axes, resizer=PadAndCropResizer(), n_tiles=None): """ Apply the network to so far unseen data. Parameters ---------- img : array(floats) of images axes : String Axes of the image ('YX'). resizer : class(Resizer), optional(default=PadAndCropResizer()) n_tiles : tuple(int) Number of tiles to tile the image into, if it is too large for memory. Returns ------- image : array(float) The restored image. """ if img.dtype != np.float32: print( 'The input image is of type {} and will be casted to float32 for prediction.' .format(img.dtype)) img = img.astype(np.float32) new_axes = axes normalized = img[..., np.newaxis] normalized = normalized[..., 0] pred = \ self._predict_mean_and_scale(normalized, axes=new_axes, normalizer=None, resizer=resizer, n_tiles=n_tiles)[0] return pred
def predict(self, img, axes, resizer=PadAndCropResizer(), n_tiles=None): """ Apply the network to so far unseen data. Parameters ---------- img : array(floats) of images axes : String Axes of the image ('YX'). resizer : class(Resizer), optional(default=PadAndCropResizer()) n_tiles : tuple(int) Number of tiles to tile the image into, if it is too large for memory. Returns ------- image : array(float) The restored image. """ means = np.array([float(mean) for mean in self.config.means], ndmin=len(img.shape), dtype=np.float32) stds = np.array([float(std) for std in self.config.stds], ndmin=len(img.shape), dtype=np.float32) if img.dtype != np.float32: print( 'The input image is of type {} and will be casted to float32 for prediction.' .format(img.dtype)) img = img.astype(np.float32) # new_axes = axes new_axes = axes if 'C' in axes: new_axes = axes.replace('C', '') + 'C' normalized = self.__normalize__( np.moveaxis(img, axes.index('C'), -1), means, stds) else: normalized = self.__normalize__(img[..., np.newaxis], means, stds) normalized = normalized[..., 0] pred_full = self._predict_mean_and_scale(normalized, axes=new_axes, normalizer=None, resizer=resizer, n_tiles=n_tiles)[0] pred_denoised = self.__denormalize__(pred_full[..., :1], means, stds) pred = np.concatenate([pred_denoised, pred_full[..., 1:]], axis=-1) if 'C' in axes: pred = np.moveaxis(pred, -1, axes.index('C')) return pred
def predict(self, img, resizer=PadAndCropResizer(), **predict_kwargs): """Predict. Parameters ---------- img : :class:`numpy.ndarray` Input image resizer : :class:`csbdeep.data.Resizer` or None If necessary, input image is resized to enable neural network prediction and result is (possibly) resized to yield original image size. Returns ------- (:class:`numpy.ndarray`,:class:`numpy.ndarray`) Returns the tuple (`prob`, `dist`) of per-pixel object probabilities and star-convex polygon distances. """ if resizer is None: resizer = NoResizer() isinstance(resizer, Resizer) or _raise(ValueError()) img.ndim in (2, 3) or _raise(ValueError()) x = img if x.ndim == 2: x = np.expand_dims(x, (-1 if backend_channels_last() else 0)) channel = x.ndim - 1 if backend_channels_last() else 0 axes = 'YXC' if backend_channels_last() else 'CYX' self.config.n_channel_in == x.shape[channel] or _raise(ValueError()) # resize: make divisible by power of 2 to allow downsampling steps in unet axes_div_by = tuple(2**self.config.unet_n_depth if a != 'C' else 1 for a in axes) x = resizer.before(x, axes, axes_div_by) if backend_channels_last(): sh = x.shape[:-1] + (1, ) else: sh = (1, ) + x.shape[1:] dummy = np.empty((1, ) + sh, np.float32) prob, dist = self.keras_model.predict([np.expand_dims(x, 0), dummy], **predict_kwargs) prob, dist = prob[0], dist[0] prob = resizer.after(prob, axes) dist = resizer.after(dist, axes) prob = np.take(prob, 0, axis=channel) dist = np.moveaxis(dist, channel, -1) return prob, dist
def norm_and_predict(x, axes): nonorm = NoNormalizer() resizer = PadAndCropResizer() restored = model.predict(x, axes, subsample, nonorm, resizer) return restored