senoquant 1.0.0b1__py3-none-any.whl

senoquant/tabs/segmentation/stardist_onnx_utils/_csbdeep/csbdeep/models/config.py

@@ -0,0 +1,254 @@
+from __future__ import print_function, unicode_literals, absolute_import, division
+from six.moves import range, zip, map, reduce, filter
+from six import string_types
+
+import numpy as np
+import argparse
+import warnings
+
+from packaging.version import Version
+
+from ..utils.tf import keras_import, BACKEND as K
+keras = keras_import()
+
+from ..utils import _raise, axes_check_and_normalize, axes_dict, backend_channels_last
+
+
+class BaseConfig(argparse.Namespace):
+
+    def __init__(self, axes='YX', n_channel_in=1, n_channel_out=1, allow_new_parameters=False, **kwargs):
+
+        # parse and check axes
+        axes = axes_check_and_normalize(axes)
+        ax = axes_dict(axes)
+        ax = {a: (ax[a] is not None) for a in ax}
+
+        (ax['X'] and ax['Y']) or _raise(ValueError('lateral axes X and Y must be present.'))
+        # not (ax['Z'] and ax['T']) or _raise(ValueError('using Z and T axes together not supported.'))
+
+        axes.startswith('S') or (not ax['S']) or _raise(ValueError('sample axis S must be first.'))
+        axes = axes.replace('S','') # remove sample axis if it exists
+
+        n_dim = len(axes.replace('C',''))
+
+        # TODO: Config not independent of backend. Problem?
+        # could move things around during train/predict as an alternative... good idea?
+        # otherwise, users can choose axes of input image anyhow, so doesn't matter if model is fixed to something else
+        if backend_channels_last():
+            if ax['C']:
+                axes[-1] == 'C' or _raise(ValueError('channel axis must be last for backend (%s).' % K.backend()))
+            else:
+                axes += 'C'
+        else:
+            if ax['C']:
+                axes[0] == 'C' or _raise(ValueError('channel axis must be first for backend (%s).' % K.backend()))
+            else:
+                axes = 'C'+axes
+
+        self.n_dim                  = n_dim
+        self.axes                   = axes
+        self.n_channel_in           = int(max(1,n_channel_in))
+        self.n_channel_out          = int(max(1,n_channel_out))
+
+        self.train_checkpoint       = 'weights_best.h5'
+        self.train_checkpoint_last  = 'weights_last.h5'
+        self.train_checkpoint_epoch = 'weights_now.h5'
+
+        self.update_parameters(allow_new_parameters, **kwargs)
+
+
+    def is_valid(self, return_invalid=False):
+        return (True, tuple()) if return_invalid else True
+
+
+    def update_parameters(self, allow_new=False, **kwargs):
+        if not allow_new:
+            attr_new = []
+            for k in kwargs:
+                try:
+                    getattr(self, k)
+                except AttributeError:
+                    attr_new.append(k)
+            if len(attr_new) > 0:
+                raise AttributeError("Not allowed to add new parameters (%s)" % ', '.join(attr_new))
+        for k in kwargs:
+            setattr(self, k, kwargs[k])
+
+    @classmethod
+    def update_loaded_config(cls, config):
+        """Called by model to update loaded config dictionary before config object is created
+
+        Can be used to modify or introduce/delete parameters, e.g. to ensure
+        backwards compatibility after new parameters have been introduced.
+
+        Parameters
+        ----------
+        config : dict
+            dictionary of config parameters loaded from file
+
+        Returns
+        -------
+        updated_config: dict
+            an updated version of the config parameter dictionary
+        """
+        return config
+
+
+
+class Config(BaseConfig):
+    """Default configuration for a CARE model.
+
+    This configuration is meant to be used with :class:`CARE`
+    and related models (e.g., :class:`IsotropicCARE`).
+
+    Parameters
+    ----------
+    axes : str
+        Axes of the neural network (channel axis optional).
+    n_channel_in : int
+        Number of channels of given input image.
+    n_channel_out : int
+        Number of channels of predicted output image.
+    probabilistic : bool
+        Probabilistic prediction of per-pixel Laplace distributions or
+        typical regression of per-pixel scalar values.
+    allow_new_parameters : bool
+        Allow adding new configuration attributes (i.e. not listed below).
+    kwargs : dict
+        Overwrite (or add) configuration attributes (see below).
+
+    Example
+    -------
+    >>> config = Config('YX', probabilistic=True, unet_n_depth=3)
+
+    Attributes
+    ----------
+    n_dim : int
+        Dimensionality of input images (2 or 3).
+    unet_residual : bool
+        Parameter `residual` of :func:`csbdeep.nets.common_unet`. Default: ``n_channel_in == n_channel_out``
+    unet_n_depth : int
+        Parameter `n_depth` of :func:`csbdeep.nets.common_unet`. Default: ``2``
+    unet_kern_size : int
+        Parameter `kern_size` of :func:`csbdeep.nets.common_unet`. Default: ``5 if n_dim==2 else 3``
+    unet_n_first : int
+        Parameter `n_first` of :func:`csbdeep.nets.common_unet`. Default: ``32``
+    unet_last_activation : str
+        Parameter `last_activation` of :func:`csbdeep.nets.common_unet`. Default: ``linear``
+    train_loss : str
+        Name of training loss. Default: ``'laplace' if probabilistic else 'mae'``
+    train_epochs : int
+        Number of training epochs. Default: ``100``
+    train_steps_per_epoch : int
+        Number of parameter update steps per epoch. Default: ``400``
+    train_learning_rate : float
+        Learning rate for training. Default: ``0.0004``
+    train_batch_size : int
+        Batch size for training. Default: ``16``
+    train_tensorboard : bool
+        Enable TensorBoard for monitoring training progress. Default: ``True``
+    train_checkpoint : str
+        Name of checkpoint file for model weights (only best are saved); set to ``None`` to disable. Default: ``weights_best.h5``
+    train_reduce_lr : dict
+        Parameter :class:`dict` of ReduceLROnPlateau_ callback; set to ``None`` to disable. Default: ``{'factor': 0.5, 'patience': 10, 'min_delta': 0}``
+
+        .. _ReduceLROnPlateau: https://keras.io/callbacks/#reducelronplateau
+    """
+
+    def __init__(self, axes='YX', n_channel_in=1, n_channel_out=1, probabilistic=False, allow_new_parameters=False, **kwargs):
+        """See class docstring."""
+
+        super(Config, self).__init__(axes, n_channel_in, n_channel_out)
+        not ('Z' in self.axes and 'T' in self.axes) or _raise(ValueError('using Z and T axes together not supported.'))
+
+        self.probabilistic         = bool(probabilistic)
+
+        # default config (can be overwritten by kwargs below)
+        self.unet_residual         = self.n_channel_in == self.n_channel_out
+        self.unet_n_depth          = 2
+        self.unet_kern_size        = 5 if self.n_dim==2 else 3
+        self.unet_n_first          = 32
+        self.unet_last_activation  = 'linear'
+        if backend_channels_last():
+            self.unet_input_shape  = self.n_dim*(None,) + (self.n_channel_in,)
+        else:
+            self.unet_input_shape  = (self.n_channel_in,) + self.n_dim*(None,)
+
+        self.train_loss            = 'laplace' if self.probabilistic else 'mae'
+        self.train_epochs          = 100
+        self.train_steps_per_epoch = 400
+        self.train_learning_rate   = 0.0004
+        self.train_batch_size      = 16
+        self.train_tensorboard     = True
+
+        # the parameter 'min_delta' was called 'epsilon' for keras<=2.1.5
+        # keras.__version__ was removed in tensorflow 2.13.0
+        min_delta_key = 'epsilon' if Version(getattr(keras, '__version__', '9.9.9'))<=Version('2.1.5') else 'min_delta'
+        self.train_reduce_lr       = {'factor': 0.5, 'patience': 10, min_delta_key: 0}
+
+        # disallow setting 'n_dim' manually
+        try:
+            del kwargs['n_dim']
+            # warnings.warn("ignoring parameter 'n_dim'")
+        except:
+            pass
+
+        self.update_parameters(allow_new_parameters, **kwargs)
+
+
+    def is_valid(self, return_invalid=False):
+        """Check if configuration is valid.
+
+        Returns
+        -------
+        bool
+            Flag that indicates whether the current configuration values are valid.
+        """
+        def _is_int(v,low=None,high=None):
+            return (
+                isinstance(v,int) and
+                (True if low is None else low <= v) and
+                (True if high is None else v <= high)
+            )
+
+        ok = {}
+        ok['n_dim'] = self.n_dim in (2,3)
+        try:
+            axes_check_and_normalize(self.axes,self.n_dim+1,disallowed='S')
+            ok['axes'] = True
+        except:
+            ok['axes'] = False
+        ok['n_channel_in']  = _is_int(self.n_channel_in,1)
+        ok['n_channel_out'] = _is_int(self.n_channel_out,1)
+        ok['probabilistic'] = isinstance(self.probabilistic,bool)
+
+        ok['unet_residual'] = (
+            isinstance(self.unet_residual,bool) and
+            (not self.unet_residual or (self.n_channel_in==self.n_channel_out))
+        )
+        ok['unet_n_depth']         = _is_int(self.unet_n_depth,1)
+        ok['unet_kern_size']       = _is_int(self.unet_kern_size,1)
+        ok['unet_n_first']         = _is_int(self.unet_n_first,1)
+        ok['unet_last_activation'] = self.unet_last_activation in ('linear','relu')
+        ok['unet_input_shape'] = (
+                isinstance(self.unet_input_shape,(list,tuple))
+            and len(self.unet_input_shape) == self.n_dim+1
+            and self.unet_input_shape[-1] == self.n_channel_in
+            # and all((d is None or (_is_int(d) and d%(2**self.unet_n_depth)==0) for d in self.unet_input_shape[:-1]))
+        )
+        ok['train_loss'] = (
+            (    self.probabilistic and self.train_loss == 'laplace'   ) or
+            (not self.probabilistic and self.train_loss in ('mse','mae'))
+        )
+        ok['train_epochs']          = _is_int(self.train_epochs,1)
+        ok['train_steps_per_epoch'] = _is_int(self.train_steps_per_epoch,1)
+        ok['train_learning_rate']   = np.isscalar(self.train_learning_rate) and self.train_learning_rate > 0
+        ok['train_batch_size']      = _is_int(self.train_batch_size,1)
+        ok['train_tensorboard']     = isinstance(self.train_tensorboard,bool)
+        ok['train_checkpoint']      = self.train_checkpoint is None or isinstance(self.train_checkpoint,string_types)
+        ok['train_reduce_lr']       = self.train_reduce_lr  is None or isinstance(self.train_reduce_lr,dict)
+
+        if return_invalid:
+            return all(ok.values()), tuple(k for (k,v) in ok.items() if not v)
+        else:
+            return all(ok.values())

senoquant/tabs/segmentation/stardist_onnx_utils/_csbdeep/csbdeep/models/pretrained.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from __future__ import print_function, unicode_literals, absolute_import, division
+
+from collections import OrderedDict
+from warnings import warn
+from ..utils import _raise
+from ..utils.six import Path
+
+from packaging.version import Version
+from ..utils.tf import keras_import, v_keras
+get_file = keras_import('utils', 'get_file')
+
+
+_MODELS = {}
+_ALIASES = {}
+
+
+def clear_models_and_aliases(*cls):
+    if len(cls) == 0:
+        _MODELS.clear()
+        _ALIASES.clear()
+    else:
+        for c in cls:
+            if c in _MODELS:  del _MODELS[c]
+            if c in _ALIASES: del _ALIASES[c]
+
+
+def register_model(cls, key, url, hash):
+    """ Example: 
+    
+    register_model(StarDist2D,   'my_great_model', 'https://github.com/stardist/stardist-models/releases/download/v0.1/python_2D_versatile_fluo.zip', md5sum_as_astring)
+
+    """
+    # key must be a valid file/folder name in the file system
+    models = _MODELS.setdefault(cls,OrderedDict())
+    key not in models or warn("re-registering model '%s' (was already registered for '%s')" % (key, cls.__name__))
+    models[key] = dict(url=url, hash=hash)
+
+
+def register_aliases(cls, key, *names):
+    # aliases can be arbitrary strings
+    if len(names) == 0: return
+    models = _MODELS.get(cls,{})
+    key in models or _raise(ValueError("model '%s' is not registered for '%s'" % (key, cls.__name__)))
+    aliases = _ALIASES.setdefault(cls,OrderedDict())
+    for name in names:
+        aliases.get(name,key) == key or warn("alias '%s' was previously registered with model '%s' for '%s'" % (name, aliases[name], cls.__name__))
+        aliases[name] = key
+
+
+def get_registered_models(cls, return_aliases=True, verbose=False):
+    models = _MODELS.get(cls,{})
+    aliases = _ALIASES.get(cls,{})
+    model_keys = tuple(models.keys())
+    model_aliases = {key: tuple(name for name in aliases if aliases[name] == key) for key in models}
+    if verbose:
+        # this code is very messy and should be refactored...
+        _n = len(models)
+        _str_model  = 'model' if _n == 1 else 'models'
+        _str_is_are = 'is' if _n == 1 else 'are'
+        _str_colon  = ':' if _n > 0 else ''
+        print("There {is_are} {n} registered {model_s} for '{clazz}'{c}".format(
+              n=_n, clazz=cls.__name__, is_are=_str_is_are, model_s=_str_model, c=_str_colon))
+        if _n > 0:
+            print()
+            _maxkeylen = 2 + max(len(key) for key in models)
+            print("Name{s}Alias(es)".format(s=' '*(_maxkeylen-4+3)))
+            print("────{s}─────────".format(s=' '*(_maxkeylen-4+3)))
+            for key in models:
+                _aliases = '   '
+                _m = len(model_aliases[key])
+                if _m > 0:
+                    _aliases += "'%s'" % "', '".join(model_aliases[key])
+                else:
+                    _aliases += "None"
+                _key = ("{s:%d}"%_maxkeylen).format(s="'%s'"%key)
+                print("{key}{aliases}".format(key=_key, aliases=_aliases))
+    return ((model_keys, model_aliases) if return_aliases else model_keys)
+
+
+def get_model_details(cls, key_or_alias, verbose=False):
+    models = _MODELS.get(cls,{})
+    if key_or_alias in models:
+        key = key_or_alias
+        alias = None
+    else:
+        aliases = _ALIASES.get(cls,{})
+        alias = key_or_alias
+        alias in aliases or _raise(ValueError("'%s' is neither a key or alias for '%s'" % (alias, cls.__name__)))
+        key = aliases[alias]
+    if verbose:
+        print("Found model '{model}'{alias_str} for '{clazz}'.".format(
+        model=key, clazz=cls.__name__, alias_str=('' if alias is None else " with alias '%s'" % alias)))
+    return key, alias, models[key]
+
+
+def get_model_folder(cls, key_or_alias):
+    key, alias, m = get_model_details(cls, key_or_alias)
+    target = str(Path('models') / cls.__name__ / key)
+    path = Path(get_file(fname=key+'.zip', origin=m['url'], file_hash=m['hash'],
+                         cache_subdir=target, extract=True))
+    if v_keras >= Version("3.6.0"):
+        path_folder = path
+        suffix = "_extracted"
+        if path_folder.is_dir() and path_folder.name.endswith(suffix) and len(path_folder.name) > len(suffix):
+            path_folder = path_folder.with_name(path_folder.name[:-len(suffix)])
+            if not path_folder.exists():
+                path_folder.symlink_to(path.relative_to(path.parent))
+    else:
+        path_folder = path.parent
+    assert path_folder.exists()
+    return path_folder
+
+
+def get_model_instance(cls, key_or_alias):
+    path = get_model_folder(cls, key_or_alias)
+    model = cls(config=None, name=path.stem, basedir=path.parent)
+    model.basedir = None # make read-only
+    return model

senoquant/tabs/segmentation/stardist_onnx_utils/_csbdeep/csbdeep/scripts/care_predict.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python
+
+from __future__ import print_function, unicode_literals, absolute_import, division
+
+import argparse
+import sys
+from pprint import pprint
+
+import numpy as np
+from tqdm import tqdm
+
+from csbdeep.io import save_tiff_imagej_compatible
+from csbdeep.utils import _raise, axes_check_and_normalize
+from csbdeep.utils.six import Path
+
+
+def str2bool(v):
+    if v.lower() in ('yes', 'true', 't', 'y', '1'):
+        return True
+    elif v.lower() in ('no', 'false', 'f', 'n', '0'):
+        return False
+    else:
+        raise argparse.ArgumentTypeError('Boolean value expected.')
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    parser.add_argument('--quiet',            metavar='', type=str2bool, required=False,  const=True, nargs='?', default=False,                                            help="don't show status messages")
+    parser.add_argument('--gpu-memory-limit', metavar='', type=float,    required=False,                         default=None,                                             help="limit GPU memory to this fraction (0...1)")
+
+    data = parser.add_argument_group("input")
+    data.add_argument('--input-dir',          metavar='', type=str,      required=False,                         default=None,                                             help="path to folder with input images")
+    data.add_argument('--input-pattern',      metavar='', type=str,      required=False,                         default='*.tif*',                                         help="glob-style file name pattern of input images")
+    data.add_argument('--input-axes',         metavar='', type=str,      required=False,                         default=None,                                             help="axes string of input images")
+    data.add_argument('--norm-pmin',          metavar='', type=float,    required=False,                         default=2,                                                help="'pmin' for PercentileNormalizer")
+    data.add_argument('--norm-pmax',          metavar='', type=float,    required=False,                         default=99.8,                                             help="'pmax' for PercentileNormalizer")
+    data.add_argument('--norm-undo',          metavar='', type=str2bool, required=False,  const=True, nargs='?', default=True,                                             help="'do_after' for PercentileNormalizer")
+    data.add_argument('--n-tiles',            metavar='', type=int,      required=False,              nargs='+', default=None,                                             help="number of tiles for prediction")
+
+    model = parser.add_argument_group("model")
+    model.add_argument('--model-basedir',     metavar='', type=str,      required=False,                         default=None,                                             help="path to folder that contains CARE model")
+    model.add_argument('--model-name',        metavar='', type=str,      required=False,                         default=None,                                             help="name of CARE model")
+    model.add_argument('--model-weights',     metavar='', type=str,      required=False,                         default=None,                                             help="specific name of weights file to load (located in model folder)")
+
+    output = parser.add_argument_group("output")
+    output.add_argument('--output-dir',       metavar='', type=str,      required=False,                         default=None,                                             help="path to folder where restored images will be saved")
+    output.add_argument('--output-name',      metavar='', type=str,      required=False,                         default='{model_name}/{file_path}/{file_name}{file_ext}', help="name pattern of restored image (special tokens: {file_path}, {file_name}, {file_ext}, {model_name}, {model_weights})")
+    output.add_argument('--output-dtype',     metavar='', type=str,      required=False,                         default='float32',                                        help="data type of the saved tiff file")
+    output.add_argument('--imagej-tiff',      metavar='', type=str2bool, required=False,  const=True, nargs='?', default=True,                                             help="save restored image as ImageJ-compatible TIFF file")
+    output.add_argument('--dry-run',          metavar='', type=str2bool, required=False,  const=True, nargs='?', default=False,                                            help="don't save restored images")
+
+    return parser, parser.parse_args()
+
+
+def main():
+    if not ('__file__' in locals() or '__file__' in globals()):
+        print('running interactively, exiting.')
+        sys.exit(0)
+
+    # parse arguments
+    parser, args = parse_args()
+    args_dict = vars(args)
+
+    # exit and show help if no arguments provided at all
+    if len(sys.argv) == 1:
+        parser.print_help()
+        sys.exit(0)
+
+    # check for required arguments manually (because of argparse issue)
+    required = ('--input-dir','--input-axes', '--norm-pmin', '--norm-pmax', '--model-basedir', '--model-name', '--output-dir')
+    for r in required:
+        dest = r[2:].replace('-','_')
+        if args_dict[dest] is None:
+            parser.print_usage(file=sys.stderr)
+            print("%s: error: the following arguments are required: %s" % (parser.prog,r), file=sys.stderr)
+            sys.exit(1)
+
+    # show effective arguments (including defaults)
+    if not args.quiet:
+        print('Arguments')
+        print('---------')
+        pprint(args_dict)
+        print()
+        sys.stdout.flush()
+
+    # logging function
+    log = (lambda *a,**k: None) if args.quiet else tqdm.write
+
+    # get list of input files and exit if there are none
+    file_list = list(Path(args.input_dir).glob(args.input_pattern))
+    if len(file_list) == 0:
+        log("No files to process in '%s' with pattern '%s'." % (args.input_dir,args.input_pattern))
+        sys.exit(0)
+
+    # delay imports after checking to all required arguments are provided
+    from tifffile import imread
+    try:
+        from tifffile import imwrite as imsave
+    except ImportError:
+        from tifffile import imsave
+    from csbdeep.utils.tf import BACKEND as K
+    from csbdeep.models import CARE
+    from csbdeep.data import PercentileNormalizer
+    sys.stdout.flush()
+    sys.stderr.flush()
+
+    # limit gpu memory
+    if args.gpu_memory_limit is not None:
+        from csbdeep.utils.tf import limit_gpu_memory
+        limit_gpu_memory(args.gpu_memory_limit)
+
+    # create CARE model and load weights, create normalizer
+    K.clear_session()
+    model = CARE(config=None, name=args.model_name, basedir=args.model_basedir)
+    if args.model_weights is not None:
+        print("Loading network weights from '%s'." % args.model_weights)
+        model.load_weights(args.model_weights)
+    normalizer = PercentileNormalizer(pmin=args.norm_pmin, pmax=args.norm_pmax, do_after=args.norm_undo)
+
+    n_tiles = args.n_tiles
+    if n_tiles is not None and len(n_tiles)==1:
+        n_tiles = n_tiles[0]
+
+    processed = []
+
+    # process all files
+    for file_in in tqdm(file_list, disable=args.quiet or (n_tiles is not None and np.prod(n_tiles)>1)):
+        # construct output file name
+        file_out = Path(args.output_dir) / args.output_name.format (
+            file_path = str(file_in.relative_to(args.input_dir).parent),
+            file_name = file_in.stem, file_ext = file_in.suffix,
+            model_name = args.model_name, model_weights = Path(args.model_weights).stem if args.model_weights is not None else None
+        )
+
+        # checks
+        (file_in.suffix.lower()  in ('.tif','.tiff') and
+         file_out.suffix.lower() in ('.tif','.tiff')) or _raise(ValueError('only tiff files supported.'))
+
+        # load and predict restored image
+        img = imread(str(file_in))
+        restored = model.predict(img, axes=args.input_axes, normalizer=normalizer, n_tiles=n_tiles)
+
+        # restored image could be multi-channel even if input image is not
+        axes_out = axes_check_and_normalize(args.input_axes)
+        if restored.ndim > img.ndim:
+            assert restored.ndim == img.ndim + 1
+            assert 'C' not in axes_out
+            axes_out += 'C'
+
+        # convert data type (if necessary)
+        restored = restored.astype(np.dtype(args.output_dtype), copy=False)
+
+        # save to disk
+        if not args.dry_run:
+            file_out.parent.mkdir(parents=True, exist_ok=True)
+            if args.imagej_tiff:
+                save_tiff_imagej_compatible(str(file_out), restored, axes_out)
+            else:
+                imsave(str(file_out), restored)
+
+        processed.append((file_in,file_out))
+
+
+    # print summary of processed files
+    if not args.quiet:
+        sys.stdout.flush()
+        sys.stderr.flush()
+        n_processed   = len(processed)
+        len_processed = len(str(n_processed))
+        log('Finished processing %d %s' % (n_processed, 'files' if n_processed > 1 else 'file'))
+        log('-' * (26+len_processed if n_processed > 1 else 26))
+        for i,(file_in,file_out) in enumerate(processed):
+            len_file = max(len(str(file_in)),len(str(file_out)))
+            log(('{:>%d}. in : {:>%d}'%(len_processed,len_file)).format(1+i,str(file_in)))
+            log(('{:>%d}  out: {:>%d}'%(len_processed,len_file)).format('',str(file_out)))
+
+
+if __name__ == '__main__':
+    main()

senoquant/tabs/segmentation/stardist_onnx_utils/_csbdeep/csbdeep/utils/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import print_function, unicode_literals, absolute_import, division
+
+from .plot_utils import *
+from .utils import *
+from .utils import _raise