senoquant 1.0.0b1__py3-none-any.whl

senoquant/tabs/segmentation/stardist_onnx_utils/_csbdeep/csbdeep/internals/nets.py

@@ -0,0 +1,165 @@
+from __future__ import print_function, unicode_literals, absolute_import, division
+from six.moves import range, zip, map, reduce, filter
+
+from ..utils.tf import keras_import
+Input, Conv2D, Conv3D, Activation, Lambda, Add, Concatenate = keras_import('layers', 'Input', 'Conv2D', 'Conv3D', 'Activation', 'Lambda', 'Add', 'Concatenate')
+Model = keras_import('models', 'Model')
+from .blocks import unet_block
+import re
+
+from ..utils import _raise, backend_channels_last
+import numpy as np
+
+
+def custom_unet(input_shape,
+                last_activation,
+                n_depth=2,
+                n_filter_base=16,
+                kernel_size=(3,3,3),
+                n_conv_per_depth=2,
+                activation="relu",
+                batch_norm=False,
+                dropout=0.0,
+                pool_size=(2,2,2),
+                n_channel_out=1,
+                residual=False,
+                prob_out=False,
+                eps_scale=1e-3):
+    """ TODO """
+
+    if last_activation is None:
+        raise ValueError("last activation has to be given (e.g. 'sigmoid', 'relu')!")
+
+    all((s % 2 == 1 for s in kernel_size)) or _raise(ValueError('kernel size should be odd in all dimensions.'))
+
+    channel_axis = -1 if backend_channels_last() else 1
+
+    n_dim = len(kernel_size)
+    conv = Conv2D if n_dim==2 else Conv3D
+
+    input = Input(input_shape, name = "input")
+    unet = unet_block(n_depth, n_filter_base, kernel_size,
+                      activation=activation, dropout=dropout, batch_norm=batch_norm,
+                      n_conv_per_depth=n_conv_per_depth, pool=pool_size)(input)
+
+    final = conv(n_channel_out, (1,)*n_dim, activation='linear')(unet)
+    if residual:
+        if not (n_channel_out == input_shape[-1] if backend_channels_last() else n_channel_out == input_shape[0]):
+            raise ValueError("number of input and output channels must be the same for a residual net.")
+        final = Add()([final, input])
+    final = Activation(activation=last_activation)(final)
+
+    if prob_out:
+        scale = conv(n_channel_out, (1,)*n_dim, activation='softplus')(unet)
+        scale = Lambda(lambda x: x+np.float32(eps_scale))(scale)
+        final = Concatenate(axis=channel_axis)([final,scale])
+
+    return Model(inputs=input, outputs=final)
+
+
+
+def common_unet(n_dim=2, n_depth=1, kern_size=3, n_first=16, n_channel_out=1, residual=True, prob_out=False, last_activation='linear'):
+    """Construct a common CARE neural net based on U-Net [1]_ and residual learning [2]_ to be used for image restoration/enhancement.
+
+    Parameters
+    ----------
+    n_dim : int
+        number of image dimensions (2 or 3)
+    n_depth : int
+        number of resolution levels of U-Net architecture
+    kern_size : int
+        size of convolution filter in all image dimensions
+    n_first : int
+        number of convolution filters for first U-Net resolution level (value is doubled after each downsampling operation)
+    n_channel_out : int
+        number of channels of the predicted output image
+    residual : bool
+        if True, model will internally predict the residual w.r.t. the input (typically better)
+        requires number of input and output image channels to be equal
+    prob_out : bool
+        standard regression (False) or probabilistic prediction (True)
+        if True, model will predict two values for each input pixel (mean and positive scale value)
+    last_activation : str
+        name of activation function for the final output layer
+
+    Returns
+    -------
+    function
+        Function to construct the network, which takes as argument the shape of the input image
+
+    Example
+    -------
+    >>> model = common_unet(2, 1,3,16, 1, True, False)(input_shape)
+
+    References
+    ----------
+    .. [1] Olaf Ronneberger, Philipp Fischer, Thomas Brox, *U-Net: Convolutional Networks for Biomedical Image Segmentation*, MICCAI 2015
+    .. [2] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun. *Deep Residual Learning for Image Recognition*, CVPR 2016
+    """
+    def _build_this(input_shape):
+        return custom_unet(input_shape, last_activation, n_depth, n_first, (kern_size,)*n_dim, pool_size=(2,)*n_dim, n_channel_out=n_channel_out, residual=residual, prob_out=prob_out)
+    return _build_this
+
+
+
+modelname = re.compile(r"^(?P<model>resunet|unet)(?P<n_dim>\d)(?P<prob_out>p)?_(?P<n_depth>\d+)_(?P<kern_size>\d+)_(?P<n_first>\d+)(_(?P<n_channel_out>\d+)out)?(_(?P<last_activation>.+)-last)?$")
+def common_unet_by_name(model):
+    r"""Shorthand notation for equivalent use of :func:`common_unet`.
+
+    Parameters
+    ----------
+    model : str
+        define model to be created via string, which is parsed as a regular expression:
+        `^(?P<model>resunet|unet)(?P<n_dim>\d)(?P<prob_out>p)?_(?P<n_depth>\d+)_(?P<kern_size>\d+)_(?P<n_first>\d+)(_(?P<n_channel_out>\d+)out)?(_(?P<last_activation>.+)-last)?$`
+
+    Returns
+    -------
+    function
+        Calls :func:`common_unet` with the respective parameters.
+
+    Raises
+    ------
+    ValueError
+        If argument `model` is not a valid string according to the regular expression.
+
+    Example
+    -------
+    >>> model = common_unet_by_name('resunet2_1_3_16_1out')(input_shape)
+    >>> # equivalent to: model = common_unet(2, 1,3,16, 1, True, False)(input_shape)
+
+    Todo
+    ----
+    Backslashes in docstring for regexp not rendered correctly.
+
+    """
+    m = modelname.fullmatch(model)
+    if m is None:
+        raise ValueError("model name '%s' unknown, must follow pattern '%s'" % (model, modelname.pattern))
+    # from pprint import pprint
+    # pprint(m.groupdict())
+    options = {k:int(m.group(k)) for k in ['n_depth','n_first','kern_size']}
+    options['prob_out'] = m.group('prob_out') is not None
+    options['residual'] = {'unet': False, 'resunet': True}[m.group('model')]
+    options['n_dim'] = int(m.group('n_dim'))
+    options['n_channel_out'] = 1 if m.group('n_channel_out') is None else int(m.group('n_channel_out'))
+    if m.group('last_activation') is not None:
+        options['last_activation'] = m.group('last_activation')
+
+    return common_unet(**options)
+
+
+
+def receptive_field_unet(n_depth, kern_size, pool_size=2, n_dim=2, img_size=1024):
+    """Receptive field for U-Net model (pre/post for each dimension)."""
+    x = np.zeros((1,)+(img_size,)*n_dim+(1,))
+    mid = tuple([s//2 for s in x.shape[1:-1]])
+    x[(slice(None),) + mid + (slice(None),)] = 1
+    model = custom_unet (
+        x.shape[1:],
+        n_depth=n_depth, kernel_size=[kern_size]*n_dim, pool_size=[pool_size]*n_dim,
+        n_filter_base=8, activation='linear', last_activation='linear',
+    )
+    y  = model.predict(x)[0,...,0]
+    y0 = model.predict(0*x)[0,...,0]
+    ind = np.where(np.abs(y-y0)>0)
+    return [(m-np.min(i),np.max(i)-m) for (m,i) in zip(mid,ind)]

senoquant/tabs/segmentation/stardist_onnx_utils/_csbdeep/csbdeep/internals/predict.py

@@ -0,0 +1,467 @@
+from __future__ import print_function, unicode_literals, absolute_import, division
+from six.moves import range, zip, map, reduce, filter
+
+from tqdm import tqdm
+from ..utils import _raise, consume, move_channel_for_backend, backend_channels_last, axes_check_and_normalize, axes_dict
+import warnings
+import numpy as np
+
+
+
+def to_tensor(x,channel=None,single_sample=True):
+    if single_sample:
+        x = x[np.newaxis]
+        if channel is not None and channel >= 0:
+            channel += 1
+    if channel is None:
+        x, channel = np.expand_dims(x,-1), -1
+    return move_channel_for_backend(x,channel)
+
+
+
+def from_tensor(x,channel=-1,single_sample=True):
+    return np.moveaxis((x[0] if single_sample else x), (-1 if backend_channels_last() else 1), channel)
+
+
+
+def tensor_num_channels(x):
+    return x.shape[-1 if backend_channels_last() else 1]
+
+
+
+def predict_direct(keras_model,x,axes_in,axes_out=None,**kwargs):
+    """TODO."""
+    if axes_out is None:
+        axes_out = axes_in
+    kwargs.setdefault('verbose', 0)
+    ax_in, ax_out = axes_dict(axes_in), axes_dict(axes_out)
+    channel_in, channel_out = ax_in['C'], ax_out['C']
+    single_sample = ax_in['S'] is None
+    len(axes_in) == x.ndim or _raise(ValueError())
+    x = to_tensor(x,channel=channel_in,single_sample=single_sample)
+    pred = from_tensor(keras_model.predict(x,**kwargs),channel=channel_out,single_sample=single_sample)
+    len(axes_out) == pred.ndim or _raise(ValueError())
+    return pred
+
+
+
+def predict_tiled(keras_model,x,n_tiles,block_sizes,tile_overlaps,axes_in,axes_out=None,pbar=None,**kwargs):
+    """TODO."""
+
+    if all(t==1 for t in n_tiles):
+        pred = predict_direct(keras_model,x,axes_in,axes_out,**kwargs)
+        if pbar is not None:
+            pbar.update()
+        return pred
+
+    ###
+
+    if axes_out is None:
+        axes_out = axes_in
+    axes_in, axes_out = axes_check_and_normalize(axes_in,x.ndim), axes_check_and_normalize(axes_out)
+    assert 'S' not in axes_in
+    assert 'C' in axes_in and 'C' in axes_out
+    ax_in, ax_out = axes_dict(axes_in), axes_dict(axes_out)
+    channel_in, channel_out = ax_in['C'], ax_out['C']
+
+    assert set(axes_out).issubset(set(axes_in))
+    axes_lost = set(axes_in).difference(set(axes_out))
+
+    def _to_axes_out(seq,elem):
+        # assumption: prediction size is same as input size along all axes, except for channel (and lost axes)
+        assert len(seq) == len(axes_in)
+        # 1. re-order 'seq' from axes_in to axes_out semantics
+        seq = [seq[ax_in[a]] for a in axes_out]
+        # 2. replace value at channel position with 'elem'
+        seq[ax_out['C']] = elem
+        return tuple(seq)
+
+    ###
+
+    assert x.ndim == len(n_tiles) == len(block_sizes)
+    assert n_tiles[channel_in] == 1
+    assert all(n_tiles[ax_in[a]] == 1 for a in axes_lost)
+    assert all(np.isscalar(t) and 1<=t and int(t)==t for t in n_tiles)
+
+    # first axis > 1
+    axis = next(i for i,t in enumerate(n_tiles) if t>1)
+
+    block_size = block_sizes[axis]
+    tile_overlap = tile_overlaps[axis]
+    n_block_overlap = int(np.ceil(1.* tile_overlap / block_size))
+
+    # print(f"axis={axis},n_tiles={n_tiles[axis]},block_size={block_size},tile_overlap={tile_overlap},n_block_overlap={n_block_overlap}")
+
+    n_tiles_remaining = list(n_tiles)
+    n_tiles_remaining[axis] = 1
+
+    dst = None
+    for tile, s_src, s_dst in tile_iterator_1d(x,axis=axis,n_tiles=n_tiles[axis],block_size=block_size,n_block_overlap=n_block_overlap):
+
+        pred = predict_tiled(keras_model,tile,n_tiles_remaining,block_sizes,tile_overlaps,axes_in,axes_out,pbar=pbar,**kwargs)
+
+        # if any(t>1 for t in n_tiles_remaining):
+        #     pred = predict_tiled(keras_model,tile,n_tiles_remaining,block_sizes,tile_overlaps,axes_in,axes_out,pbar=pbar,**kwargs)
+        # else:
+        #     # tmp
+        #     pred = tile
+        #     if pbar is not None:
+        #         pbar.update()
+
+        if dst is None:
+            dst_shape = _to_axes_out(x.shape, pred.shape[channel_out])
+            dst = np.empty(dst_shape, dtype=x.dtype)
+
+        s_src = _to_axes_out(s_src, slice(None))
+        s_dst = _to_axes_out(s_dst, slice(None))
+
+        dst[s_dst] = pred[s_src]
+
+    return dst
+
+
+
+class Tile(object):
+    def __init__(self, n, size, overlap, prev):
+        self.n = int(n)
+        self.size = int(size)
+        self.overlap = int(overlap)
+        if self.n < self.size:
+            assert prev is None
+            # print("Truncating tile size from %d to %d." % (self.size, self.n))
+            self.size = self.n
+            self.overlap = 0
+        assert self.size > 2*self.overlap
+        # assert self.n >= self.size
+        if prev is not None:
+            assert not prev.at_end, "Previous tile already at end"
+        self.prev = prev
+        self.read_slice = self._read_slice
+        self.write_slice = self._write_slice
+
+    @property
+    def at_begin(self):
+        return self.prev is None
+
+    @property
+    def at_end(self):
+        return self.read_slice.stop == self.n
+
+    @property
+    def _read_slice(self):
+        if self.at_begin:
+            start, stop = 0, self.size
+        else:
+            prev_read_slice = self.prev.read_slice
+            start = prev_read_slice.stop - 2*self.overlap
+            stop  = start + self.size
+            shift = min(0, self.n - stop)
+            start, stop = start + shift, stop + shift
+            assert start > prev_read_slice.start
+        assert start >= 0 and stop <= self.n
+        return slice(start, stop)
+
+    @property
+    def _write_slice(self):
+        if self.at_begin:
+            if self.at_end:
+                return slice(0, self.n)
+            else:
+                return slice(0, self.size - 1*self.overlap)
+        elif self.at_end:
+            s = self.prev.write_slice.stop
+            return slice(s, self.n)
+        else:
+            s = self.prev.write_slice.stop
+            return slice(s, s + self.size - 2*self.overlap)
+
+    def __repr__(self):
+        s = np.array(list(' '*self.n))
+        s[self.read_slice]  = '-'
+        s[self.write_slice] = 'x' if (self.at_begin or self.at_end) else 'o'
+        return ''.join(s)
+
+
+
+class Tiling(object):
+    def __init__(self, n, size, overlap):
+        self.n = n
+        self.size = size
+        self.overlap = overlap
+        tiles = [Tile(prev=None, **self.__dict__)]
+        while not tiles[-1].at_end:
+            tiles.append(Tile(prev=tiles[-1], **self.__dict__))
+        self.tiles = tiles
+
+    def __len__(self):
+        return len(self.tiles)
+
+    def __repr__(self):
+        return '\n'.join('{i:3}. {t}'.format(i=i,t=t) for i,t in enumerate(self.tiles,1))
+
+    def slice_generator(self, block_size=1):
+        def scale(sl):
+            return slice(block_size * sl.start, block_size * sl.stop)
+        def crop_slice(read, write):
+            stop = write.stop - read.stop
+            return slice(write.start - read.start, stop if stop < 0 else None)
+        for t in self.tiles:
+            read, write = scale(t.read_slice), scale(t.write_slice)
+            yield read, write, crop_slice(read, write)
+
+    @staticmethod
+    def for_n_tiles(n, n_tiles, overlap):
+        smallest_size = 2*overlap + 1
+        tile_size = smallest_size # start with smallest posible tile_size
+        while len(Tiling(n, tile_size, overlap)) > n_tiles:
+            tile_size += 1
+        if tile_size == smallest_size:
+            return Tiling(n, tile_size, overlap)
+        candidates = (
+            Tiling(n, tile_size-1, overlap),
+            Tiling(n, tile_size,   overlap),
+        )
+        diffs = [np.abs(len(c) - n_tiles) for c in candidates]
+        return candidates[np.argmin(diffs)]
+
+
+
+def total_n_tiles(x,n_tiles,block_sizes,n_block_overlaps,guarantee='size'):
+    assert x.ndim == len(n_tiles) == len(block_sizes) == len(n_block_overlaps)
+    assert guarantee in ('size', 'n_tiles')
+    n_tiles_used = 1
+    for n, n_tile, block_size, n_block_overlap in zip(x.shape, n_tiles, block_sizes, n_block_overlaps):
+        assert n % block_size == 0
+        n_blocks = n // block_size
+        if guarantee == 'size':
+            n_tiles_used *= len(Tiling.for_n_tiles(n_blocks, n_tile, n_block_overlap))
+        elif guarantee == 'n_tiles':
+            n_tiles_used *= n_tile
+    return n_tiles_used
+
+
+
+def tile_iterator_1d(x,axis,n_tiles,block_size,n_block_overlap,guarantee='size'):
+    """Tile iterator for one dimension of array x.
+
+    Parameters
+    ----------
+    x : numpy.ndarray
+        Input array
+    axis : int
+        Axis which sould be tiled, all other axis not tiled
+    n_tiles : int
+        Targeted number of tiles for axis of x (see guarantee below)
+    block_size : int
+        Axis of x is assumed to be evenly divisible by block_size
+        All tiles are aligned with the block_size
+    n_block_overlap : int
+        Tiles will overlap at least this many blocks (see guarantee below)
+    guarantee : str
+        Can be either 'size' or 'n_tiles':
+        'size':    The size of all tiles is guaranteed to be the same,
+                   but the number of tiles can be different and the
+                   amount of overlap can be larger than requested.
+        'n_tiles': The size of tiles can be different at the beginning and end,
+                   but the number of tiles is guarantee to be the one requested.
+                   The mount of overlap is also exactly as requested.
+
+
+    """
+    n = x.shape[axis]
+
+    n % block_size == 0 or _raise(ValueError("'x' must be evenly divisible by 'block_size' along 'axis'"))
+    n_blocks = n // block_size
+
+    guarantee in ('size', 'n_tiles') or _raise(ValueError("guarantee must be either 'size' or 'n_tiles'"))
+
+    if guarantee == 'size':
+        tiling = Tiling.for_n_tiles(n_blocks, n_tiles, n_block_overlap)
+
+        def ndim_slices(t):
+            sl = [slice(None)] * x.ndim
+            sl[axis] = t
+            return tuple(sl)
+
+        for read, write, crop in tiling.slice_generator(block_size):
+            tile_in   = read  # src in input image     / tile
+            tile_out  = write # dst in output image    / s_dst
+            tile_crop = crop  # crop of src for output / s_src
+            yield x[ndim_slices(tile_in)], ndim_slices(tile_crop), ndim_slices(tile_out)
+
+    elif guarantee == 'n_tiles':
+        n_tiles_valid = int(np.clip(n_tiles,1,n_blocks))
+        if n_tiles != n_tiles_valid:
+            warnings.warn("invalid value (%d) for 'n_tiles', changing to %d" % (n_tiles,n_tiles_valid))
+            n_tiles = n_tiles_valid
+
+        s = n_blocks // n_tiles # tile size
+        r = n_blocks %  n_tiles # blocks remainder
+        assert n_tiles * s + r == n_blocks
+
+        # list of sizes for each tile
+        tile_sizes = s*np.ones(n_tiles,int)
+        # distribute remaining blocks to tiles at beginning and end
+        if r > 0:
+            tile_sizes[:r//2]      += 1
+            tile_sizes[-(r-r//2):] += 1
+
+        # n_block_overlap = int(np.ceil(92 / block_size))
+        # n_block_overlap -= 1
+        # print(n_block_overlap)
+
+        # (pre,post) offsets for each tile
+        off = [(n_block_overlap if i > 0 else 0, n_block_overlap if i < n_tiles-1 else 0) for i in range(n_tiles)]
+
+        # tile_starts = np.concatenate(([0],np.cumsum(tile_sizes[:-1])))
+        # print([(_st-_pre,_st+_sz+_post) for (_st,_sz,(_pre,_post)) in zip(tile_starts,tile_sizes,off)])
+
+        def to_slice(t):
+            sl = [slice(None)] * x.ndim
+            sl[axis] = slice(
+                t[0]*block_size,
+                t[1]*block_size if t[1]!=0 else None)
+            return tuple(sl)
+
+        start = 0
+        for i in range(n_tiles):
+            off_pre, off_post = off[i]
+
+            # tile starts before block 0 -> adjust off_pre
+            if start-off_pre < 0:
+                off_pre = start
+            # tile end after last block -> adjust off_post
+            if start+tile_sizes[i]+off_post > n_blocks:
+                off_post = n_blocks-start-tile_sizes[i]
+
+            tile_in   = (start-off_pre,start+tile_sizes[i]+off_post)  # src in input image     / tile
+            tile_out  = (start,start+tile_sizes[i])                   # dst in output image    / s_dst
+            tile_crop = (off_pre,-off_post)                           # crop of src for output / s_src
+
+            yield x[to_slice(tile_in)], to_slice(tile_crop), to_slice(tile_out)
+            start += tile_sizes[i]
+
+    else:
+        assert False
+
+
+
+def tile_iterator(x,n_tiles,block_sizes,n_block_overlaps,guarantee='size'):
+    """Tile iterator for n-d arrays.
+
+    Yields block-aligned tiles (`block_sizes`) that have at least
+    a certain amount of overlapping blocks (`n_block_overlaps`)
+    with their neighbors. Also yields slices that allow to map each
+    tile back to the original array x.
+
+    Notes
+    -----
+    - Tiles will not go beyond the array boundary (i.e. no padding).
+      This means the shape of x must be evenly divisible by the respective block_size.
+    - It is not guaranteed that all tiles have the same size if guarantee is not 'size'.
+
+    Parameters
+    ----------
+    x : numpy.ndarray
+        Input array.
+    n_tiles : int or sequence of ints
+        Number of tiles for each dimension of x.
+    block_sizes : int or sequence of ints
+        Block sizes for each dimension of x.
+        The shape of x is assumed to be evenly divisible by block_sizes.
+        All tiles are aligned with block_sizes.
+    n_block_overlaps : int or sequence of ints
+        Tiles will at least overlap this many blocks in each dimension.
+    guarantee : str
+        Can be either 'size' or 'n_tiles':
+        'size':    The size of all tiles is guaranteed to be the same,
+                   but the number of tiles can be different and the
+                   amount of overlap can be larger than requested.
+        'n_tiles': The size of tiles can be different at the beginning and end,
+                   but the number of tiles is guarantee to be the one requested.
+                   The mount of overlap is also exactly as requested.
+
+    Example
+    -------
+
+    Duplicate an array tile-by-tile:
+
+    >>> x = np.array(...)
+    >>> y = np.empty_like(x)
+    >>>
+    >>> for tile,s_src,s_dst in tile_iterator(x, n_tiles, block_sizes, n_block_overlaps):
+    >>>     y[s_dst] = tile[s_src]
+    >>>
+    >>> np.allclose(x,y)
+    True
+
+    """
+    if np.isscalar(n_tiles): n_tiles = (n_tiles,)*x.ndim
+    if np.isscalar(block_sizes): block_sizes = (block_sizes,)*x.ndim
+    if np.isscalar(n_block_overlaps): n_block_overlaps = (n_block_overlaps,)*x.ndim
+
+    assert x.ndim == len(n_tiles) == len(block_sizes) == len(n_block_overlaps)
+
+    def _accumulate(tile_in,axis,src,dst):
+        for tile, s_src, s_dst in tile_iterator_1d(tile_in, axis, n_tiles[axis], block_sizes[axis], n_block_overlaps[axis], guarantee):
+            src[axis] = s_src[axis]
+            dst[axis] = s_dst[axis]
+            if axis+1 == tile_in.ndim:
+                # remove None and negative slicing
+                src = [slice(s.start, size if s.stop is None else (s.stop if s.stop >= 0 else size + s.stop)) for s,size in zip(src,tile.shape)]
+                yield tile, tuple(src), tuple(dst)
+            else:
+                # yield from _accumulate(tile, axis+1, src, dst)
+                for entry in  _accumulate(tile, axis+1, src, dst):
+                    yield entry
+
+    return _accumulate(x, 0, [None]*x.ndim, [None]*x.ndim)
+
+
+
+def tile_overlap(n_depth, kern_size, pool_size=2):
+    rf = {(1, 3, 1):    6, (1, 5, 1):   12, (1, 7, 1):   18,
+          (2, 3, 1):   10, (2, 5, 1):   20, (2, 7, 1):   30,
+          (3, 3, 1):   14, (3, 5, 1):   28, (3, 7, 1):   42,
+          (4, 3, 1):   18, (4, 5, 1):   36, (4, 7, 1):   54,
+          (5, 3, 1):   22, (5, 5, 1):   44, (5, 7, 1):   66,
+          #
+          (1, 3, 2):    9, (1, 5, 2):   17, (1, 7, 2):   25,
+          (2, 3, 2):   22, (2, 5, 2):   43, (2, 7, 2):   62,
+          (3, 3, 2):   46, (3, 5, 2):   92, (3, 7, 2):  138,
+          (4, 3, 2):   94, (4, 5, 2):  188, (4, 7, 2):  282,
+          (5, 3, 2):  190, (5, 5, 2):  380, (5, 7, 2):  570,
+          #
+          (1, 3, 4):   14, (1, 5, 4):   27, (1, 7, 4):   38,
+          (2, 3, 4):   58, (2, 5, 4):  116, (2, 7, 4):  158,
+          (3, 3, 4):  234, (3, 5, 4):  468, (3, 7, 4):  638,
+          (4, 3, 4):  938, (4, 5, 4): 1876, (4, 7, 4): 2558}
+    try:
+        return rf[n_depth, kern_size, pool_size]
+    except KeyError:
+        raise ValueError('tile_overlap value for n_depth=%d, kern_size=%d, pool_size=%d not available.' % (n_depth, kern_size, pool_size))
+
+
+
+class Progress(object):
+    def __init__(self, total, thr=1):
+        self.pbar = None
+        self.total = total
+        self.thr = thr
+    @property
+    def total(self):
+        return self._total
+    @total.setter
+    def total(self, total):
+        self.close()
+        self._total = total
+    def update(self):
+        if self.total > self.thr:
+            if self.pbar is None:
+                self.pbar = tqdm(total=self.total)
+            self.pbar.update()
+            self.pbar.refresh()
+    def close(self):
+        if self.pbar is not None:
+            self.pbar.close()
+        self.pbar = None

senoquant/tabs/segmentation/stardist_onnx_utils/_csbdeep/csbdeep/internals/probability.py

@@ -0,0 +1,67 @@
+from __future__ import print_function, unicode_literals, absolute_import, division
+from six.moves import range, zip, map, reduce, filter
+
+
+from ..utils import _raise, consume
+import warnings
+import numpy as np
+from scipy.stats import laplace
+
+
+class ProbabilisticPrediction(object):
+    """Laplace distribution (independently per pixel)."""
+
+    def __init__(self, loc, scale):
+        loc.shape == scale.shape or _raise(ValueError())
+        #
+        self._loc     = loc
+        self._scale   = scale
+        # expose methods from laplace object
+        _laplace      = laplace(loc=self._loc,scale=self._scale)
+        self.rvs      = _laplace.rvs
+        self.pdf      = _laplace.pdf
+        self.logpdf   = _laplace.logpdf
+        self.cdf      = _laplace.cdf
+        self.logcdf   = _laplace.logcdf
+        self.sf       = _laplace.sf
+        self.logsf    = _laplace.logsf
+        self.ppf      = _laplace.ppf
+        self.isf      = _laplace.isf
+        self.moment   = _laplace.moment
+        self.stats    = _laplace.stats
+        self.entropy  = _laplace.entropy
+        self.expect   = _laplace.expect
+        self.median   = _laplace.median
+        self.mean     = _laplace.mean
+        self.var      = _laplace.var
+        self.std      = _laplace.std
+        self.interval = _laplace.interval
+
+    def __getitem__(self, indices):
+        return ProbabilisticPrediction(loc=self._loc[indices],scale=self._scale[indices])
+
+    def __len__(self):
+        return len(self._loc)
+
+    @property
+    def shape(self):
+        return self._loc.shape
+
+    @property
+    def ndim(self):
+        return self._loc.ndim
+
+    @property
+    def size(self):
+        return self._loc.size
+
+    def scale(self):
+        return self._scale
+
+    def sampling_generator(self,n=None):
+        if n is None:
+            while True:
+                yield self.rvs()
+        else:
+            for i in range(n):
+                yield self.rvs()