PixMClass 0.1.0__tar.gz

PixMClass-0.1.0/LICENSE.txt

@@ -0,0 +1,174 @@
+Apache License
+                    Version 2.0, January 2004
+                 http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction,
+and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by
+the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all
+other entities that control, are controlled by, or are under common
+control with that entity. For the purposes of this definition,
+"control" means (i) the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or
+otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity
+exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation
+source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical
+transformation or translation of a Source form, including but
+not limited to compiled object code, generated documentation,
+and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or
+Object form, made available under the License, as indicated by a
+copyright notice that is included in or attached to the work
+(an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object
+form, that is based on (or derived from) the Work and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship. For the purposes
+of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of,
+the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including
+the original version of the Work and any modifications or additions
+to that Work or Derivative Works thereof, that is intentionally
+submitted to Licensor for inclusion in the Work by the copyright owner
+or by an individual or Legal Entity authorized to submit on behalf of
+the copyright owner. For the purposes of this definition, "submitted"
+means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems,
+and issue tracking systems that are managed by, or on behalf of, the
+Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise
+designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity
+on behalf of whom a Contribution has been received by Licensor and
+subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the
+Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+(except as stated in this section) patent license to make, have made,
+use, offer to sell, sell, import, and otherwise transfer the Work,
+where such license applies only to those patent claims licensable
+by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s)
+with the Work to which such Contribution(s) was submitted. If You
+institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work
+or a Contribution incorporated within the Work constitutes direct
+or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate
+as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+Work or Derivative Works thereof in any medium, with or without
+modifications, and in Source or Object form, provided that You
+meet the following conditions:
+
+(a) You must give any other recipients of the Work or
+   Derivative Works a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices
+   stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works
+   that You distribute, all copyright, patent, trademark, and
+   attribution notices from the Source form of the Work,
+   excluding those notices that do not pertain to any part of
+   the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its
+   distribution, then any Derivative Works that You distribute must
+   include a readable copy of the attribution notices contained
+   within such NOTICE file, excluding those notices that do not
+   pertain to any part of the Derivative Works, in at least one
+   of the following places: within a NOTICE text file distributed
+   as part of the Derivative Works; within the Source form or
+   documentation, if provided along with the Derivative Works; or,
+   within a display generated by the Derivative Works, if and
+   wherever such third-party notices normally appear. The contents
+   of the NOTICE file are for informational purposes only and
+   do not modify the License. You may add Your own attribution
+   notices within Derivative Works that You distribute, alongside
+   or as an addendum to the NOTICE text from the Work, provided
+   that such additional attribution notices cannot be construed
+   as modifying the License.
+
+You may add Your own copyright statement to Your modifications and
+may provide additional or different license terms and conditions
+for use, reproduction, or distribution of Your modifications, or
+for any such Derivative Works as a whole, provided Your use,
+reproduction, and distribution of the Work otherwise complies with
+the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+any Contribution intentionally submitted for inclusion in the Work
+by You to the Licensor shall be under the terms and conditions of
+this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify
+the terms of any separate license agreement you may have executed
+with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+names, trademarks, service marks, or product names of the Licensor,
+except as required for reasonable and customary use in describing the
+origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+agreed to in writing, Licensor provides the Work (and each
+Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied, including, without limitation, any warranties or conditions
+of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any
+risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+whether in tort (including negligence), contract, or otherwise,
+unless required by applicable law (such as deliberate and grossly
+negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special,
+incidental, or consequential damages of any character arising as a
+result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all
+other commercial damages or losses), even if such Contributor
+has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+the Work or Derivative Works thereof, You may choose to offer,
+and charge a fee for, acceptance of support, warranty, indemnity,
+or other liability obligations and/or rights consistent with this
+License. However, in accepting such obligations, You may act only
+on Your own behalf and on Your sole responsibility, not on behalf
+of any other Contributor, and only if You agree to indemnify,
+defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason
+of your accepting any such warranty or additional liability.

PixMClass-0.1.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: PixMClass
+Version: 0.1.0
+Summary: Multiclass pixel classification
+Home-page: https://github.com/jeanollion/pix_mclass
+Download-URL: https://github.com/jeanollion/pix_mclass/releases/download/v0.1.0/pix_mclass-0.1.0.tar.gz
+Author: Jean Ollion
+Author-email: jean.ollion@polytechnique.org
+Keywords: Segmentation,Classification,Microscopy,Cell
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: tensorflow>=2.7.1
+Requires-Dist: dataset_iterator>=0.4.0
+Requires-Dist: elasticdeform
+
+# Multiclass pixel classifier
+Deep learning segmentation method with very low annotation requirement.
+
+Similar to [Ilastik pixel classification](https://www.ilastik.org/documentation/pixelclassification/pixelclassification) procedure, but based on a deep neural network.
+
+Described and used in the work [Near-infrared co-illumination of fluorescent proteins reduces photobleaching and phototoxicity](https://doi.org/10.1038/s41587-023-01893-7). Please cite this work when using this method. 
+
+Docuementation: see this [tutorial](https://github.com/jeanollion/bacmman/wiki/Train-and-use-PixMClass)

PixMClass-0.1.0/PixMClass.egg-info/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: PixMClass
+Version: 0.1.0
+Summary: Multiclass pixel classification
+Home-page: https://github.com/jeanollion/pix_mclass
+Download-URL: https://github.com/jeanollion/pix_mclass/releases/download/v0.1.0/pix_mclass-0.1.0.tar.gz
+Author: Jean Ollion
+Author-email: jean.ollion@polytechnique.org
+Keywords: Segmentation,Classification,Microscopy,Cell
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: tensorflow>=2.7.1
+Requires-Dist: dataset_iterator>=0.4.0
+Requires-Dist: elasticdeform
+
+# Multiclass pixel classifier
+Deep learning segmentation method with very low annotation requirement.
+
+Similar to [Ilastik pixel classification](https://www.ilastik.org/documentation/pixelclassification/pixelclassification) procedure, but based on a deep neural network.
+
+Described and used in the work [Near-infrared co-illumination of fluorescent proteins reduces photobleaching and phototoxicity](https://doi.org/10.1038/s41587-023-01893-7). Please cite this work when using this method. 
+
+Docuementation: see this [tutorial](https://github.com/jeanollion/bacmman/wiki/Train-and-use-PixMClass)

PixMClass-0.1.0/PixMClass.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE.txt
+README.md
+setup.py
+PixMClass.egg-info/PKG-INFO
+PixMClass.egg-info/SOURCES.txt
+PixMClass.egg-info/dependency_links.txt
+PixMClass.egg-info/requires.txt
+PixMClass.egg-info/top_level.txt
+pix_mclass/__init__.py
+pix_mclass/callbacks.py
+pix_mclass/losses.py
+pix_mclass/training.py
+pix_mclass/unet.py
+pix_mclass/utils.py

PixMClass-0.1.0/PixMClass.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

PixMClass-0.1.0/PixMClass.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy
+scipy
+tensorflow>=2.7.1
+dataset_iterator>=0.4.0
+elasticdeform

PixMClass-0.1.0/PixMClass.egg-info/top_level.txt

@@ -0,0 +1 @@
+pix_mclass

PixMClass-0.1.0/README.md

@@ -0,0 +1,8 @@
+# Multiclass pixel classifier
+Deep learning segmentation method with very low annotation requirement.
+
+Similar to [Ilastik pixel classification](https://www.ilastik.org/documentation/pixelclassification/pixelclassification) procedure, but based on a deep neural network.
+
+Described and used in the work [Near-infrared co-illumination of fluorescent proteins reduces photobleaching and phototoxicity](https://doi.org/10.1038/s41587-023-01893-7). Please cite this work when using this method. 
+
+Docuementation: see this [tutorial](https://github.com/jeanollion/bacmman/wiki/Train-and-use-PixMClass)

PixMClass-0.1.0/pix_mclass/__init__.py

@@ -0,0 +1,3 @@
+name="pix_mclass"
+from .unet import get_unet
+from .callbacks import *

PixMClass-0.1.0/pix_mclass/callbacks.py

@@ -0,0 +1,68 @@
+from math import cos, pi
+from tensorflow.keras.callbacks import Callback
+from tensorflow.keras import backend
+import csv
+import os
+
+class StopOnLR(Callback):
+    def __init__( self, min_lr, **kwargs, ):
+        super().__init__()
+        self.min_lr = min_lr
+
+    def on_epoch_end(self, epoch, logs={}):
+        lr = backend.get_value(self.model.optimizer.lr)
+        if(lr <= self.min_lr):
+            self.model.stop_training = True
+
+class EpsilonCosineDecayCallback(Callback):
+    """Reduce optimizer epsilon parameter.
+    Args:
+      factor: factor by which epsilon will be reduced.
+        `new_epsilon = epsilon * factor`.
+      period: number of epochs after which epsilon will be reduced.
+      verbose: int. 0: quiet, 1: update messages.
+      min_epsilon: lower bound on the learning rate.
+    """
+
+    def __init__(self, decay_steps:int, start_epsilon=1, min_epsilon=1e-2, start_step:int=0, verbose=1):
+        super(EpsilonCosineDecayCallback, self).__init__()
+        self.step_counter = start_step
+        self.start_epsilon = start_epsilon
+        self.decay_steps=decay_steps
+        self.alpha=min_epsilon / start_epsilon
+        self.verbose = verbose
+
+    def on_train_batch_begin(self, batch, logs=None):
+        epsilon = self._decayed_epsilon(self.step_counter)
+        self.model.optimizer.epsilon = epsilon
+
+    def on_train_batch_end(self, batch, logs=None):
+        self.step_counter +=1
+        if logs is not None:
+            logs['epsilon'] = self.model.optimizer.epsilon
+
+    def _decayed_epsilon(self, step):
+        step = min(step, self.decay_steps)
+        cosine_decay = 0.5 * (1 + cos(pi * step / self.decay_steps))
+        decayed = (1 - self.alpha) * cosine_decay + self.alpha
+        return self.start_epsilon * decayed
+
+class LogsCallback(Callback):
+    def __init__(self, filepath, start_epoch=0):
+        super().__init__()
+        self.filepath = filepath
+        self.start_epoch=start_epoch
+
+    def on_epoch_end(self, epoch, logs=None):
+        if logs is not None:
+            epoch += self.start_epoch
+            losses = list(logs.values())
+            losses.insert(0, epoch)
+            filepath = self.filepath.format(epoch=epoch + 1, **logs)
+            with open(filepath, "a") as file_object:
+                writer = csv.writer(file_object, delimiter=';',  quotechar='"', quoting=csv.QUOTE_MINIMAL)
+                if os.path.getsize(filepath) == 0: # write header only if file is empty
+                    headers = list(logs.keys())
+                    headers.insert(0, "epoch")
+                    writer.writerow(headers)
+                writer.writerow(losses)

PixMClass-0.1.0/pix_mclass/losses.py

@@ -0,0 +1,55 @@
+import tensorflow as tf
+import tensorflow.keras.backend as K
+import numpy as np
+import dataset_iterator.helpers as dih
+
+def get_class_weights(dataset, channel_keyword:str="classes"):
+    histo, vmin, bins = dih.get_histogram(dataset, channel_keyword, bins=None, bin_size=1, return_min_and_bin_size=True)
+    histo = histo.astype(np.float64)
+    if vmin == 0: # remove non-annotated pixels
+        histo = histo[1:]
+    sum = np.sum(histo)
+    #print(f"histo: {histo} sum: {sum}, vmin: {vmin}")
+    return sum / histo
+
+def weighted_sparse_categorical_crossentropy(weights, dtype='float32', **cce_kwargs):
+    weights_cast = np.array(weights).astype(dtype)
+    cce = tf.keras.losses.SparseCategoricalCrossentropy(**cce_kwargs)
+    wfun = get_category_sample_weights_fun(weights_cast, dtype=dtype)
+    def loss_func(true, pred):
+        true, wm = tf.split(true, 2, axis=-1)
+        weights = wfun(true) * wm[...,0]
+        return cce(true, pred, sample_weight=weights)
+    return loss_func
+
+def get_category_sample_weights_fun(weights_list, axis=-1, sparse=True, dtype='float32'):
+    weights_list_cast = np.array(weights_list).astype(dtype)
+    class_indices = np.array([i for i in range(len(weights_list_cast))]).astype(dtype)
+    def weight_fun(true):
+        if sparse:
+            class_selectors = K.squeeze(true, axis=axis)
+        else:
+            class_selectors = K.argmax(true, axis=axis)
+
+        #considering weights are ordered by class, for each class
+        #true(1) if the class index is equal to the weight index
+        class_selectors = [K.equal(i, class_selectors) for i in class_indices]
+
+        #casting boolean to float for calculations
+        #each tensor in the list contains 1 where ground true class is equal to its index
+        #if you sum all these, you will get a tensor full of ones.
+        class_selectors = [tf.cast(x, dtype) for x in class_selectors]
+
+        #for each of the selections above, multiply their respective weight
+        weights = [sel * w for sel, w in zip(class_selectors, weights_list_cast)]
+
+        #sums all the selections
+        #result is a tensor with the respective weight for each element in predictions
+        weight_multiplier = weights[0]
+        for i in range(1, len(weights)):
+            weight_multiplier = weight_multiplier + weights[i]
+
+        #make sure your original_loss_func only collapses the class axis
+        #you need the other axes intact to multiply the weights tensor
+        return weight_multiplier
+    return weight_fun

PixMClass-0.1.0/pix_mclass/training.py

@@ -0,0 +1,75 @@
+import numpy as np
+from dataset_iterator import MultiChannelIterator
+from dataset_iterator import extract_tile_random_zoom_function
+from dataset_iterator.image_data_generator import data_generator_to_channel_postprocessing_fun
+from .utils import ensure_multiplicity
+def get_iterator(
+    dataset, scaling_data_generator, illumination_data_generator=None,
+    input_channel_keywords="raw", class_keyword:str="classes", train_group_keyword:str=None,
+    batch_size:int=16, step_number:int=0,
+    tiling_parameters:dict = None,
+    elasticdeform_parameters=None,
+    dtype="float32", shuffle:bool=True ):
+
+    """Training Iterator.
+
+    Parameters
+    ----------
+    dataset : either string or DatasetIO object
+        if a string: path to .h5 file containing
+    train_group_keyword : str or list of stf
+        keyword contained in the path of the training dataset, in order to exclude the evaluation dataset
+    scaling_data_generator : ImageDataGenerator or list of ImageDataGenerator (one per channel)
+        applied to each channel before elastic deform and tiling, only on channel image and not on classes.
+        should only modify intensity and not deform the image as they will not be applied on class image
+    illumination_data_generator : ImageDataGenerator or list of ImageDataGenerator (one per channel)
+        applied to each channel after elastic deform and tiling, only on channel image and not on classes.
+        should only modify intensity and not deform the image as they will not be applied on class image
+    step_number : int
+
+    Returns
+    -------
+    iterator of tiled images
+
+    """
+
+    extract_tiles_fun = None if tiling_parameters is None else extract_tile_random_zoom_function(**tiling_parameters)
+
+    if isinstance(input_channel_keywords, (list, tuple)):
+        channel_keywords = list(input_channel_keywords)
+        channel_keywords.append(class_keyword)
+        n_inputs = len(input_channel_keywords)
+    else:
+        channel_keywords = [input_channel_keywords, class_keyword]
+        n_inputs = 1
+    input_channels = list(range(n_inputs))
+    scaling_data_generator = ensure_multiplicity(n_inputs, scaling_data_generator)
+    if isinstance(scaling_data_generator, tuple):
+        scaling_data_generator = [scaling_data_generator]
+    scaling_data_generator.append(None) # classes
+    if illumination_data_generator is not None:
+        pp_fun = data_generator_to_channel_postprocessing_fun(illumination_data_generator, input_channels)
+    else:
+        pp_fun = None
+    zero = np.zeros(shape=1, dtype=dtype)[0]
+    one = np.ones(shape=1, dtype=dtype)[0]
+    iterator_params = dict(dataset=dataset,
+                           channel_keywords=channel_keywords,
+                           input_channels = input_channels,
+                           output_channels = [n_inputs],
+                           mask_channels=[n_inputs],
+                           group_keyword = train_group_keyword,
+                           weight_map_functions = [lambda batch: np.where(batch==0, zero, one)],  # to avoid unlabeled data be mixed with label 0
+                           output_postprocessing_functions = [lambda batch : np.where(batch>0, batch-one, zero)],  # labels must be in range [0, nlabels-1]
+                           extract_tile_function = extract_tiles_fun,
+                           image_data_generators = scaling_data_generator,
+                           perform_data_augmentation=True,
+                           elasticdeform_parameters=elasticdeform_parameters,
+                           channels_postprocessing_function=pp_fun,
+                           batch_size=batch_size,
+                           incomplete_last_batch_mode="CONSTANT_SIZE",
+                           shuffle=shuffle, step_number=step_number,
+                           dtype=dtype)
+
+    train_it = MultiChannelIterator(**iterator_params)
+    return train_it

PixMClass-0.1.0/pix_mclass/unet.py

@@ -0,0 +1,92 @@
+from tensorflow.keras.layers import Conv2D, Conv3D, Input, MaxPool2D, Conv2DTranspose, Concatenate
+from tensorflow.keras.models import Model
+import keras.backend as K
+import tensorflow as tf
+
+ENCODER_SETTINGS = [
+    [ # l1 = 128 -> 64
+        {"filters":32},
+        {"filters":32, "downscale":2, "maxpool":False}
+    ],
+    [  # l2 64 -> 32
+        {"filters":32},
+        {"filters":32, "downscale":2,"maxpool":False}
+    ],
+    [ # l3: 32->16
+        {"filters":64, "kernel_size":5},
+        {"filters":64},
+        {"filters":64, "downscale":2,"maxpool":False},
+    ],
+    [ # l4: 16 -> 8
+        {"filters":128, "kernel_size":5},
+        {"filters":128},
+        {"filters":256, "downscale":2,"maxpool":False}
+    ]
+]
+FEATURE_SETTINGS = [
+    {"filters":256, "kernel_size":5},
+    {"filters":256},
+]
+
+DECODER_SETTINGS = [
+    {"filters":32},
+    {"filters":32},
+    {"filters":64},
+    {"filters":128}
+]
+
+def get_unet(n_classes, n_input_channels=1, encoder_settings = ENCODER_SETTINGS, feature_settings= FEATURE_SETTINGS, decoder_settings=DECODER_SETTINGS, skip_sg=False, skip_omit=None, name = "unet", input_name = "unet_input"):
+    assert len(encoder_settings)==len(decoder_settings), "encoder and decoder must have same depth"
+    input = Input(shape = (None, None, n_input_channels), name=input_name)
+    if skip_sg==True:
+        skip_sg = [i for i in range(len(ENCODER_SETTINGS))]
+    elif skip_sg==False or skip_sg is None:
+        skip_sg = []
+    elif isinstance(skip_sg, int):
+        skip_sg = [skip_sg]
+    assert isinstance(skip_sg, (list, tuple)), "invalid argument: skip_sg should be either bool, None, int or tuple/list of int"
+    if skip_omit is None:
+        skip_omit = []
+    elif isinstance(skip_omit, int):
+        skip_omit = [skip_omit]
+    assert isinstance(skip_omit, (list, tuple)), "invalid argument: skip_omit should be either None, int or tuple/list of int"
+    residuals = []
+    downsample_size = []
+    for d, parameters in enumerate(encoder_settings):
+        down, residual, down_size = downsampling_block(input if d==0 else down, parameters, d, name)
+        if d in skip_sg:
+            residual = K.stop_gradient(residual)
+        residuals.append(residual)
+        downsample_size.append(down_size)
+    up = downsampling_block(down, feature_settings, len(encoder_settings), name)
+    for d in range(len(decoder_settings)-1, -1, -1):
+        up=upsampling_block(up, None if d in skip_omit else residuals[d], decoder_settings[d], downsample_size[d], d, name)
+
+    output = Conv2D(n_classes, kernel_size=3, padding='same', activation="softmax", name=f"{name}/output")(up)
+    return Model(input, output, name=name)
+
+def downsampling_block(input, parameters, l_idx, name):
+    convolutions = [input]
+    for i, params in enumerate(parameters):
+        downsample = params.get("downscale", 1)
+        maxpool = params.get("maxpool", False)
+        assert downsample == 1 or i == len(parameters)-1, "downscale > 1 must be last convolution"
+        conv = Conv2D(filters=params["filters"], kernel_size=params.get("kernel_size", 3), padding='same', activation=params.get("activation", "relu"), strides = 1 if maxpool else downsample, name=f"{name}/encoder/{l_idx}/conv_{i}")(convolutions[-1])
+        convolutions.append(conv)
+        if downsample>1 and maxpool:
+            mp = MaxPool2D(pool_size = downsample, name=f"{name}/encoder/{l_idx}/mp_{i}")(convolutions[-1])
+            convolutions.append(mp)
+    downsample = parameters[-1].get("downscale", 1)
+    if downsample>1:
+        return convolutions[-1], convolutions[-2], downsample
+    else:
+        return convolutions[-1]
+
+def upsampling_block(input, residual, params, stride, l_idx, name):
+    up = Conv2DTranspose(params["filters"], kernel_size=params.get("up_kernel_size", 4), strides=stride, padding='same', activation=params.get("activation", "relu"), name=f"{name}/decoder/{l_idx}/upConv")(input)
+    if residual is not None:
+        concat = Concatenate(axis=-1, name = f"{name}/decoder/{l_idx}/concat")([residual, up])
+    else:
+        concat = up
+    conv = Conv2D(filters=params["filters"], kernel_size=params.get("kernel_size", 3), padding='same', activation=params.get("activation", "relu"), name=f"{name}/decoder/{l_idx}/conv1")(concat)
+    return Conv2D(filters=params["filters"] if l_idx==0 else params["filters"]//2, kernel_size=params.get("kernel_size", 3), padding='same', activation=params.get("activation", "relu"), name=f"{name}/decoder/{l_idx}/conv2")(conv)

PixMClass-0.1.0/pix_mclass/utils.py

@@ -0,0 +1,17 @@
+import numpy as np
+
+def ensure_multiplicity(n, object):
+    if object is None:
+        return [None] * n
+    if not isinstance(object, (list, tuple)):
+        object = [object]
+    if len(object)>1 and len(object)!=n:
+        raise ValueError("length should be either 1 either {}".format(n))
+    if n>1 and len(object)==1:
+        object = object*n
+    elif n==0:
+        return []
+    return object
+
+def is_list(l):
+    return isinstance(l, (list, tuple, np.ndarray))

PixMClass-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

PixMClass-0.1.0/setup.py

@@ -0,0 +1,28 @@
+import setuptools
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="PixMClass",
+    version="0.1.0",
+    author="Jean Ollion",
+    author_email="jean.ollion@polytechnique.org",
+    description="Multiclass pixel classification",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/jeanollion/pix_mclass",
+    download_url='https://github.com/jeanollion/pix_mclass/releases/download/v0.1.0/pix_mclass-0.1.0.tar.gz',
+    packages=setuptools.find_packages(),
+    keywords = ['Segmentation', 'Classification', 'Microscopy', 'Cell'],
+    classifiers=[
+        'Development Status :: 4 - Beta',
+        'Intended Audience :: Science/Research',
+        'Topic :: Scientific/Engineering :: Artificial Intelligence',
+        'Topic :: Scientific/Engineering :: Image Processing',
+        'License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)',
+        'Programming Language :: Python :: 3',
+    ],
+    python_requires='>=3',
+    install_requires=['numpy', 'scipy', 'tensorflow>=2.7.1', 'dataset_iterator>=0.4.0', 'elasticdeform']
+)