biapy 3.3.6__tar.gz → 3.3.7__tar.gz

{biapy-3.3.6/biapy.egg-info → biapy-3.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biapy
-Version: 3.3.6
+Version: 3.3.7
 Summary: BiaPy: Bioimage analysis pipelines in Python
 Home-page: https://github.com/BiaPyX/BiaPy
 Author: BiaPy Contributors

{biapy-3.3.6 → biapy-3.3.7}/biapy/_biapy.py

@@ -219,12 +219,23 @@ class BiaPy():
         # Check if BiaPy has been run so some of the variables have been created
         if not self.workflow.model_prepared:
             raise ValueError("You need first to call prepare_model(), train(), test() or run_job() functions so the model can be built")
-        if 'test_input' in bmz_cfg and bmz_cfg['test_input'] is None and self.workflow.bmz_test_input is None:
-            raise ValueError("No bmz_cfg['test_input'] available. You can: 1) provide it using bmz_config['test_input'] "
-                "or run the training phase, by calling train() or run_job() functions.")
-        if 'test_output' in bmz_cfg and bmz_cfg['test_output'] is None and self.workflow.bmz_test_output is None:
-            raise ValueError("No bmz_cfg['test_output'] available. You can: 1) provide it using bmz_config['test_output'] "
-                "or run the training phase, by calling train() or run_job() functions.")
+        error = False
+        if self.workflow.bmz_test_input is None:
+            if 'test_input' not in bmz_cfg:
+                error = True
+            elif bmz_cfg['test_input'] is None:
+                error = True
+            if error:
+                raise ValueError("No bmz_cfg['test_input'] available. You can: 1) provide it using bmz_config['test_input'] "
+                    "or run the training phase, by calling train() or run_job() functions.")
+        if self.workflow.bmz_test_output is None:
+            if 'test_output' not in bmz_cfg:
+                error = True
+            elif bmz_cfg['test_output'] is None:
+                error = True
+            if error:
+                raise ValueError("No bmz_cfg['test_output'] available. You can: 1) provide it using bmz_config['test_output'] "
+                    "or run the training phase, by calling train() or run_job() functions.")
 
         # Check BMZ dictionary keys and values 
         if bmz_cfg['description'] == "":

{biapy-3.3.6 → biapy-3.3.7}/biapy/config/config.py

@@ -24,7 +24,7 @@ class Config:
         # Do not set it as its value will be calculated based in --gpu input arg
         _C.SYSTEM.NUM_GPUS = 0
 
-        # Math seed
+        # Math seed to generate random numbers. Used to ensure reproducibility in the results. 
         _C.SYSTEM.SEED = 0
         # Pin CPU memory in DataLoader for more efficient (sometimes) transfer to GPU.
         _C.SYSTEM.PIN_MEM = True
@@ -322,7 +322,7 @@ class Config:
         # Test data resolution. Need to be provided in (z,y,x) order. Only applies when _C.PROBLEM.TYPE = 'DETECTION' now.
         _C.DATA.TEST.RESOLUTION = (-1,)
         # Whether to apply argmax to the predicted images 
-        _C.DATA.TEST.ARGMAX_TO_OUTPUT = False
+        _C.DATA.TEST.ARGMAX_TO_OUTPUT = True
 
         # Validation
         _C.DATA.VAL = CN()
@@ -407,7 +407,8 @@ class Config:
         # “no change” and 0.5 denotes “half of the axis size”.
         _C.AUGMENTOR.SHIFT_RANGE = (0.1, 0.2)
         # How to fill up the new values created with affine transformations (rotations, shear, shift and zoom).
-        # Same meaning as in skimage (and numpy.pad()): 'constant', 'edge', 'symmetric', 'reflect' and 'wrap'
+        # Same meaning as in scipy: 'reflect', grid-'mirror', 'constant', 'grid-constant', 'nearest', 'mirror', 
+        # 'grid-wrap' and 'wrap'. 
         _C.AUGMENTOR.AFFINE_MODE = 'constant'
         # Make vertical flips
         _C.AUGMENTOR.VFLIP = False

{biapy-3.3.6 → biapy-3.3.7}/biapy/data/data_2D_manipulation.py

@@ -685,10 +685,10 @@ def merge_data_with_overlap(data, original_shape, data_mask=None, overlap=(0,0),
 
     merged_data = np.zeros((original_shape), dtype=np.float32)
     if data_mask is not None:
-        merged_data_mask = np.zeros((original_shape), dtype=np.float32)
+        merged_data_mask = np.zeros((original_shape[:-1]+(data_mask.shape[-1],)), dtype=np.float32)
         data_mask = data_mask[:, padding[0]:data_mask.shape[1]-padding[0], padding[1]:data_mask.shape[2]-padding[1]]
 
-    ov_map_counter = np.zeros(original_shape, dtype=np.int32)
+    ov_map_counter = np.zeros(original_shape[:-1]+(1,), dtype=np.int32)
     if out_dir is not None:
         crop_grid = np.zeros(original_shape[1:], dtype=np.int32)
 

{biapy-3.3.6 → biapy-3.3.7}/biapy/data/data_3D_manipulation.py

@@ -616,7 +616,7 @@ def merge_3D_data_with_overlap(data, orig_vol_shape, data_mask=None, overlap=(0,
                               padding[1]:data_mask.shape[2]-padding[1],
                               padding[2]:data_mask.shape[3]-padding[2], :]
         merged_data_mask = np.zeros(orig_vol_shape[:3]+(data_mask.shape[-1],), dtype=np.float32)
-    ov_map_counter = np.zeros((orig_vol_shape), dtype=np.uint16)
+    ov_map_counter = np.zeros((orig_vol_shape[:-1]+(1,)), dtype=np.uint16)
 
     # Calculate overlapping variables
     overlap_z = 1 if overlap[0] == 0 else 1-overlap[0]

{biapy-3.3.6 → biapy-3.3.7}/biapy/data/generators/augmentors.py

@@ -3,10 +3,11 @@ import random
 import math
 import numpy as np
 from PIL import Image
-from skimage.transform import resize, rotate
+from skimage.transform import resize
 from skimage.draw import line
 from scipy.ndimage.measurements import label
 from scipy.ndimage.morphology import binary_dilation
+from scipy.ndimage import rotate
 
 
 def cutout(img, mask, channels, z_size, nb_iterations=(1,3), size=(0.2,0.4), cval=0, res_relation=(1,1), apply_to_mask=False):
@@ -1500,7 +1501,7 @@ def resize_img(img, shape):
     return resize(img, shape, order=1, mode='reflect', clip=True, preserve_range=True, anti_aliasing=True) 
 
 
-def rotation(img, mask=None, angles=[], mode="reflect", mask_type='as_mask'):
+def rotation(img, mask=None, heat=None, angles=[], mode="reflect", mask_type='as_mask'):
     """
     Apply a rotation to input ``image`` and ``mask`` (if provided). 
 
@@ -1512,12 +1513,15 @@ def rotation(img, mask=None, angles=[], mode="reflect", mask_type='as_mask'):
     mask : 3D/4D Numpy array, optional
         Mask to rotate. E.g. ``(y, x, channels)`` for ``2D`` or  ``(z, y, x, channels)`` for ``3D``.
 
+    heat : 3D/4D Numpy array, optional
+        Heatmap (float mask) to rotate. E.g. ``(y, x, channels)`` for ``2D`` or  ``(z, y, x, channels)`` for ``3D``.
+
     angles : List of ints, optional
         List of angles to choose the rotation to be made. E.g. [90,180,360].
 
     mode : str, optional
-        How to fill up the new values created. Options: ``constant``, ``edge``, ``symmetric``, 
-        ``reflect`` and ``wrap``.
+        How to fill up the new values created. Options: ``reflect``, ``grid-mirror``,
+        ``constant``, ``grid-constant``, ``nearest``, ``mirror``, ``grid-wrap``, ``wrap``.
 
     mask_type : str, optional
         How ``mask`` is going to be treated. Options: ``as_mask``, ``as_image``. With ``as_mask`` 
@@ -1530,6 +1534,10 @@ def rotation(img, mask=None, angles=[], mode="reflect", mask_type='as_mask'):
 
     mask : 3D/4D Numpy array, optional
         Rotated mask. E.g. ``(y, x, channels)`` for ``2D`` or  ``(z, y, x, channels)`` for ``3D``.
+    
+    heat : 3D/4D Numpy array, optional
+        Rotated heatmap. Returned if ``mask`` is provided. E.g. ``(y, x, channels)`` for ``2D`` or  
+        ``(z, y, x, channels)`` for ``3D``.
     """
 
     if len(angles) == 0:
@@ -1542,8 +1550,15 @@ def rotation(img, mask=None, angles=[], mode="reflect", mask_type='as_mask'):
     else:
         raise ValueError("Not a list/tuple provided in 'angles'")
 
-    mask_order = 0 if mask_type == 'as_mask' else 1
+    img = rotate(img, angle=angle, mode=mode, reshape=False)
+
+    if mask is not None:
+        mask_order = 0 if mask_type == 'as_mask' else 1
+        mask = rotate(mask, angle=angle, order=mask_order, mode=mode, reshape=False)
+    if heat is not None:
+        heat = rotate(heat, angle=angle, mode=mode, reshape=False)
     if mask is None:
-        return rotate(img, angle, mode=mode)
+        return img
     else:
-        return rotate(img, angle, mode=mode), rotate(mask.astype(np.float32), angle, order=mask_order, mode=mode)
+        return img, mask, heat
+            

{biapy-3.3.6 → biapy-3.3.7}/biapy/data/generators/pair_base_data_generator.py

@@ -314,7 +314,7 @@ class PairBaseDataGenerator(Dataset, metaclass=ABCMeta):
         data must be the same on each epoch). Valid when ``random_crops_in_DA`` is set.
 
     n_classes : int, optional
-        Number of classes. If ``> 1`` one-hot encoding will be done on the ground truth.
+        Number of classes. 
 
     extra_data_factor : int, optional
         Factor to multiply the batches yielded in a epoch. It acts as if ``X`` and ``Y``` where concatenated
@@ -358,7 +358,7 @@ class PairBaseDataGenerator(Dataset, metaclass=ABCMeta):
     normalizeY : str, optional
         Whether Y is going to be normalized or not. Options: ``as_mask``, ``as_image``. With ``as_image`` the image will be 
         treated as another image and not as a mask (for normalization and interpolation).
-
+    
     instance_problem : bool, optional
         Advice the class that the workflow is of instance segmentation to divide the labels by channels.
     
@@ -473,9 +473,8 @@ class PairBaseDataGenerator(Dataset, metaclass=ABCMeta):
                 self.Y = Y
             self.length = len(self.X)
         
-        self.first_no_bin_channel = -1
-        self.div_Y_on_load_bin_channels = False
-        self.div_Y_on_load_no_bin_channels = False
+        self.channel_info = {}
+        self.no_bin_channel_found = False
         self.shape = shape
 
         # X data analysis
@@ -538,30 +537,41 @@ class PairBaseDataGenerator(Dataset, metaclass=ABCMeta):
 
         # Y data analysis
         if self.Y_provided:
-            found = False
             # Loop over a few masks to ensure foreground class is present to decide normalization
             n_samples = len(self.data_mask_path) if not in_memory else len(self.Y)
+            self.channels_to_analize = -1
+            analized = False
+            print("Checking which channel of the mask needs normalization . . .")
             for i in range(n_samples):
                 _, mask = self.load_sample(i)
                 if self.normalizeY == 'as_mask':
-                    # Store wheter all channels of the gt are binary or not (i.e. distance transform channel)
-                    if not found and (mask.dtype is np.dtype(np.float32) or mask.dtype is np.dtype(np.float64)) and instance_problem:
-                        for j in range(mask.shape[-1]):
-                            if len(np.unique(mask[...,j])) > 2:
-                                self.first_no_bin_channel = j
-                                found = True
-                                break
-
-                    # If found high values divide masks
-                    if self.first_no_bin_channel != -1:
-                        if self.first_no_bin_channel != 0:
-                            if np.max(mask[...,:self.first_no_bin_channel]) > 30: self.div_Y_on_load_bin_channels = True
-                            if np.max(mask[...,self.first_no_bin_channel:]) > 30: self.div_Y_on_load_no_bin_channels = True
+                    # Store which channels are binary or not (e.g. distance transform channel is not binary)
+                    if not analized:
+                        if n_classes > 2 and instance_problem:
+                            self.channels_to_analize = mask.shape[-1]-1  
+                            self.channel_info[self.channels_to_analize] = {'type': 'classes'}
+                            self.channel_info[self.channels_to_analize]['div'] = False
                         else:
-                            if np.max(mask) > 30: self.div_Y_on_load_bin_channels = True
-                            if np.max(mask) > 30: self.div_Y_on_load_no_bin_channels = True 
-                    else:
-                        if np.max(mask) > 30: self.div_Y_on_load_bin_channels = True 
+                            self.channels_to_analize = mask.shape[-1]
+                        analized = True
+
+                    for j in range(self.channels_to_analize):
+                        if j not in self.channel_info:
+                            self.channel_info[j] = {'type': 'bin'}
+                            self.channel_info[j]['div'] = False
+
+                        if instance_problem:
+                            if len(np.unique(mask[...,j])) > 2:
+                                self.channel_info[j]['type'] = 'no_bin'
+                                self.no_bin_channel_found = True  
+                            if np.max(mask[...,j]) > 30:
+                                self.channel_info[j]['div'] = True
+                        else: # In semantic seg, maybe the mask are in 255
+                            if np.max(mask[...,j]) > n_classes:
+                                self.channel_info[j]['div'] = True
+
+            if self.channels_to_analize == -1: 
+                self.channels_to_analize = mask.shape[-1]  
             self.Y_channels = mask.shape[-1]
             self.Y_dtype = mask.dtype
             del mask
@@ -777,12 +787,9 @@ class PairBaseDataGenerator(Dataset, metaclass=ABCMeta):
         # Choose the data source
         idx = _idx % self.length
         if self.in_memory:
-            img = self.X[idx]
-            img = np.squeeze(img)
-
+            img = np.squeeze(self.X[idx].copy())
             if self.Y_provided:
-                mask = self.Y[idx]
-                mask = np.squeeze(mask)
+                mask = np.squeeze(self.Y[idx].copy())
         else:
             if self.data_paths[idx].endswith('.npy'):
                 img = np.load(os.path.join(self.paths[0], self.data_paths[idx]))
@@ -795,15 +802,17 @@ class PairBaseDataGenerator(Dataset, metaclass=ABCMeta):
             img = np.squeeze(img)
             if self.Y_provided:
                 mask = np.squeeze(mask)
-        
-        img = self.norm_X(img)
 
         if self.Y_provided:
-            mask = self.norm_Y(mask)
             img, mask = self.ensure_shape(img, mask)
-            return img, mask
         else:
             img = self.ensure_shape(img, None)
+
+        img = self.norm_X(img)
+        if self.Y_provided:
+            mask = self.norm_Y(mask)
+            return img, mask
+        else:
             return img, np.zeros(img.shape, dtype=np.float32)
 
     def norm_X(self, img):
@@ -843,19 +852,12 @@ class PairBaseDataGenerator(Dataset, metaclass=ABCMeta):
         mask : 3D/4D Numpy array
             Y element normalized. E.g. ``(y, x, channels)`` in ``2D`` and ``(z, y, x, channels)`` in ``3D``.
         """
-        # Y normalization  
+        # Y normalization
         if self.X_norm['type'] != "none":
-            if self.normalizeY == 'as_mask' and self.Y_provided:  
-                if self.first_no_bin_channel != -1:
-                    if self.div_Y_on_load_bin_channels:
-                        mask[...,:self.first_no_bin_channel] = mask[...,:self.first_no_bin_channel]/255
-                    if self.div_Y_on_load_no_bin_channels:
-                        if self.first_no_bin_channel != 0:
-                            mask[...,self.first_no_bin_channel:] = mask[...,self.first_no_bin_channel:]/255
-                        else:
-                            mask = mask/255
-                else:
-                    if self.div_Y_on_load_bin_channels: mask = mask/255
+            if self.normalizeY == 'as_mask' and self.Y_provided: 
+                for j in range(self.channels_to_analize):
+                    if self.channel_info[j]['div']:
+                        mask[...,j] = mask[...,j]/255
             elif self.normalizeY == 'as_image' and self.Y_provided: 
                 if self.X_norm['type'] == 'div':
                     mask, _ = norm_range01(mask)
@@ -965,20 +967,26 @@ class PairBaseDataGenerator(Dataset, metaclass=ABCMeta):
             Transformed image mask. E.g. ``(y, x, channels)`` in ``2D`` or ``(y, x, z, channels)`` in ``3D``.
         """
         # Split heatmaps from masks
-        if self.first_no_bin_channel != -1:
-            if self.first_no_bin_channel != 0:
-                heat = mask[...,self.first_no_bin_channel:]
-                mask = mask[...,:self.first_no_bin_channel]
+        heat = None
+        if self.no_bin_channel_found:
+            heat = []
+            new_mask = []
+            for j in range(mask.shape[-1]):
+                if self.channel_info[j]['type'] == "no_bin":
+                    heat.append(np.expand_dims(mask[...,j],-1))
+                else:
+                    new_mask.append(np.expand_dims(mask[...,j],-1))
+                        
+            heat = np.concatenate(heat, axis=-1)
+            if len(new_mask) == 0:
+                mask = np.zeros(mask.shape) # Fake mask   
             else:
-                heat = mask
-                mask = np.zeros(mask.shape) # Fake mask
+                mask = np.concatenate(new_mask, axis=-1)
+            del new_mask
+
             o_heat_shape = heat.shape
-            o_mask_shape = mask.shape
             if self.ndim == 3:
                 heat = heat.reshape(heat.shape[:(self.ndim-1)]+(heat.shape[2]*heat.shape[3],))
-            heat = HeatmapsOnImage(heat, shape=heat.shape, min_value=0.0, max_value=np.max(heat)+sys.float_info.epsilon)
-        else:
-            heat = None
 
         # Save shape
         o_img_shape = image.shape
@@ -994,11 +1002,13 @@ class PairBaseDataGenerator(Dataset, metaclass=ABCMeta):
 
         # Apply random rotations
         if self.rand_rot and random.uniform(0, 1) < self.da_prob:
-            image, mask = rotation(image, mask, angles=self.rnd_rot_range, mode=self.affine_mode, mask_type=self.normalizeY)
+            image, mask, heat = rotation(image, mask, heat=heat, angles=self.rnd_rot_range, mode=self.affine_mode, 
+                mask_type=self.normalizeY)
 
         # Apply square rotations
         if self.rotation90 and random.uniform(0, 1) < self.da_prob:
-            image, mask = rotation(image, mask, angles=[90, 180, 270], mode=self.affine_mode, mask_type=self.normalizeY)
+            image, mask, heat = rotation(image, mask, heat=heat, angles=[90, 180, 270], mode=self.affine_mode, 
+                mask_type=self.normalizeY)
 
         # Reshape 3D volumes to 2D image type with multiple channels to pass through imgaug lib
         if self.ndim == 3:
@@ -1007,6 +1017,9 @@ class PairBaseDataGenerator(Dataset, metaclass=ABCMeta):
             if e_im is not None: e_im = e_im.reshape(e_im.shape[:2]+(e_im.shape[2]*e_im.shape[3],))
             if e_mask is not None: e_mask = e_mask.reshape(e_mask.shape[:2]+(e_mask.shape[2]*e_mask.shape[3],))
             #if e_heat is not None: e_heat = e_heat.reshape(e_heat.shape[:2]+(e_heat.shape[2]*e_heat.shape[3],))
+        # Convert heatmap into imgaug object
+        if heat is not None:
+            heat = HeatmapsOnImage(heat, shape=heat.shape, min_value=0.0, max_value=np.max(heat)+sys.float_info.epsilon)
 
         # Apply cutout
         if self.cutout and random.uniform(0, 1) < self.da_prob:
@@ -1091,14 +1104,21 @@ class PairBaseDataGenerator(Dataset, metaclass=ABCMeta):
         mask = mask.reshape(o_mask_shape)
 
         # Merge heatmaps and masks again
-        if self.first_no_bin_channel != -1:
+        if self.no_bin_channel_found:
             heat = heat_out.get_arr()
             if self.ndim == 3:
                 heat = heat.reshape(o_heat_shape)
-            if self.first_no_bin_channel != 0:
-                mask = np.concatenate((mask,heat),axis=-1)
-            else:
-                mask = heat
+
+            new_mask = []
+            hi, mi = 0, 0
+            for j in range(len(self.channel_info)):
+                if self.channel_info[j]['type'] == "no_bin":
+                    new_mask.append(np.expand_dims(heat[...,hi],-1))
+                    hi += 1
+                else:
+                    new_mask.append(np.expand_dims(mask[...,mi],-1))
+                    mi += 1
+            mask = np.concatenate(new_mask, axis=-1)
 
         return image, mask
 

{biapy-3.3.6 → biapy-3.3.7}/biapy/data/generators/single_base_data_generator.py

@@ -376,8 +376,7 @@ class SingleBaseDataGenerator(Dataset, metaclass=ABCMeta):
         """
         # Choose the data source
         if self.in_memory:
-            img = self.X[idx]
-            img = np.squeeze(img)
+            img = np.squeeze(self.X[idx].copy())
             img_class = self.Y[idx] if self.ptype == "classification" else 0
         else:
             sample_id = self.all_samples[idx]

{biapy-3.3.6 → biapy-3.3.7}/biapy/data/post_processing/post_processing.py

@@ -33,6 +33,7 @@ from biapy.utils.util import pad_and_reflect, save_tif
 from biapy.data.pre_processing import normalize
 from biapy.data.data_3D_manipulation import crop_3D_data_with_overlap
 from biapy.data.pre_processing import reduce_dtype
+from biapy.utils.misc import to_numpy_format, to_pytorch_format
 
 def boundary_refinement_watershed(X, Y_pred, erode=True, save_marks_dir=None):
     """Apply watershed to the given predictions with the goal of refine the boundaries of the artifacts.
@@ -489,7 +490,7 @@ def calculate_z_filtering(data, mf_size=5):
 
     return out_data 
 
-def ensemble8_2d_predictions(o_img, pred_func, batch_size_value=1):
+def ensemble8_2d_predictions(o_img, pred_func, axis_order_back, axis_order, device, batch_size_value=1):
     """
     Outputs the mean prediction of a given image generating its 8 possible rotations and flips.
 
@@ -501,6 +502,15 @@ def ensemble8_2d_predictions(o_img, pred_func, batch_size_value=1):
     pred_func : function
         Function to make predictions.
 
+    axis_order_back : tuple
+        Axis order to convert from tensor to numpy. E.g. ``(0,3,1,2)``.
+    
+    axis_order : tuple 
+        Axis order to convert from numpy to tensor. E.g. ``(0,3,1,2)``. 
+
+    device : Torch device
+        Device used. 
+
     batch_size_value : int, optional
         Batch size value.
 
@@ -567,9 +577,12 @@ def ensemble8_2d_predictions(o_img, pred_func, batch_size_value=1):
             r_aux = pred_func(total_img[i*batch_size_value:top])
 
         # Take just the last output of the network in case it returns more than one output
+        channel_split = None
         if isinstance(r_aux, list):
-            r_aux = np.array(r_aux[-1])
-
+            channel_split = r_aux[0].shape[1]
+            r_aux = np.concatenate([to_numpy_format(r_aux[0], axis_order_back),to_numpy_format(r_aux[1], axis_order_back)],axis=-1)
+        else:
+            r_aux = to_numpy_format(r_aux, axis_order_back)
         _decoded_aug_img.append(r_aux)
     _decoded_aug_img = np.concatenate(_decoded_aug_img)
 
@@ -611,10 +624,16 @@ def ensemble8_2d_predictions(o_img, pred_func, batch_size_value=1):
         else:
             out[i] = out_img[i,:,abs(pad_to_square):]
 
-    return np.mean(out, axis=0)
+    out = np.expand_dims(np.mean(out, axis=0),0)
+    out = to_pytorch_format(out, axis_order, device)
+
+    if channel_split is not None:
+        return [out[:,:channel_split],out[:,channel_split:]]
+    else:
+        return out
 
 
-def ensemble16_3d_predictions(vol, pred_func, batch_size_value=1):
+def ensemble16_3d_predictions(vol, pred_func, axis_order_back, axis_order, device, batch_size_value=1):
     """
     Outputs the mean prediction of a given image generating its 16 possible rotations and flips.
 
@@ -625,6 +644,15 @@ def ensemble16_3d_predictions(vol, pred_func, batch_size_value=1):
 
     pred_func : function
         Function to make predictions.
+        
+    axis_order_back : tuple
+        Axis order to convert from tensor to numpy. E.g. ``(0,3,1,2,4)``.
+    
+    axis_order : tuple 
+        Axis order to convert from numpy to tensor. E.g. ``(0,3,1,2,4)``. 
+
+    device : Torch device
+        Device used. 
 
     batch_size_value : int, optional
         Batch size value.
@@ -703,8 +731,12 @@ def ensemble16_3d_predictions(vol, pred_func, batch_size_value=1):
             r_aux = pred_func(total_vol[i*batch_size_value:top])
 
         # Take just the last output of the network in case it returns more than one output
+        channel_split = None
         if isinstance(r_aux, list):
-            r_aux = np.array(r_aux[-1])
+            channel_split = r_aux[0].shape[1]
+            r_aux = np.concatenate([to_numpy_format(r_aux[0], axis_order_back),to_numpy_format(r_aux[1], axis_order_back)],axis=-1)
+        else:
+            r_aux = to_numpy_format(r_aux, axis_order_back)
 
         if r_aux.ndim == 4:
             r_aux = np.expand_dims(r_aux, 0)
@@ -759,7 +791,13 @@ def ensemble16_3d_predictions(vol, pred_func, batch_size_value=1):
         else:
             out[i] = out_vols[i,:,abs(pad_to_square):,:,:]
 
-    return np.mean(out, axis=0)
+    out = np.expand_dims(np.mean(out, axis=0),0)
+    out = to_pytorch_format(out, axis_order, device)
+
+    if channel_split is not None:
+        return [out[:,:channel_split],out[:,channel_split:]]
+    else:
+        return out
 
 
 def create_th_plot(ths, y_list, th_name="TH_BINARY_MASK", chart_dir=None, per_sample=True, ideal_value=None):

{biapy-3.3.6 → biapy-3.3.7}/biapy/data/pre_processing.py

@@ -48,11 +48,32 @@ def create_instance_channels(cfg, data_type='train'):
     print("Creating Y_{} channels . . .".format(data_type))
     if isinstance(Y, list):
         for i in tqdm(range(len(Y))):
-            Y[i] = labels_into_channels(Y[i], mode=cfg.PROBLEM.INSTANCE_SEG.DATA_CHANNELS, save_dir=getattr(cfg.PATHS, tag+'_INSTANCE_CHANNELS_CHECK'),
-                          fb_mode=cfg.PROBLEM.INSTANCE_SEG.DATA_CONTOUR_MODE)
+            if cfg.MODEL.N_CLASSES > 2:
+                if Y[i].shape[-1] != 2:
+                    raise ValueError("In instance segmentation, when 'MODEL.N_CLASSES' are more than 2 labels need to have two channels, "
+                        "e.g. (256,256,2), containing the instance segmentation map (first channel) and classification map (second channel).")
+                else:
+                    class_channel = np.expand_dims(Y[i,...,1].copy(),-1)
+                    Y[i] = labels_into_channels(Y[i], mode=cfg.PROBLEM.INSTANCE_SEG.DATA_CHANNELS, save_dir=getattr(cfg.PATHS, tag+'_INSTANCE_CHANNELS_CHECK'),
+                        fb_mode=cfg.PROBLEM.INSTANCE_SEG.DATA_CONTOUR_MODE)
+                    Y[i] = np.concatenate([Y[i],class_channel],axis=-1)
+            else:
+                Y[i] = labels_into_channels(Y[i], mode=cfg.PROBLEM.INSTANCE_SEG.DATA_CHANNELS, save_dir=getattr(cfg.PATHS, tag+'_INSTANCE_CHANNELS_CHECK'),
+                    fb_mode=cfg.PROBLEM.INSTANCE_SEG.DATA_CONTOUR_MODE)
     else:
-        Y = labels_into_channels(Y, mode=cfg.PROBLEM.INSTANCE_SEG.DATA_CHANNELS, save_dir=getattr(cfg.PATHS, tag+'_INSTANCE_CHANNELS_CHECK'),
-                   fb_mode=cfg.PROBLEM.INSTANCE_SEG.DATA_CONTOUR_MODE)
+        if cfg.MODEL.N_CLASSES > 2:
+            if Y.shape[-1] != 2:
+                raise ValueError("In instance segmentation, when 'MODEL.N_CLASSES' are more than 2 labels need to have two channels, "
+                    "e.g. (256,256,2), containing the instance segmentation map (first channel) and classification map (second channel).")
+            else:
+                class_channel = np.expand_dims(Y[...,1].copy(),-1)
+                Y = labels_into_channels(Y, mode=cfg.PROBLEM.INSTANCE_SEG.DATA_CHANNELS, save_dir=getattr(cfg.PATHS, tag+'_INSTANCE_CHANNELS_CHECK'),
+                    fb_mode=cfg.PROBLEM.INSTANCE_SEG.DATA_CONTOUR_MODE)
+                Y = np.concatenate([Y, class_channel], axis=-1)
+        else:
+            Y = labels_into_channels(Y, mode=cfg.PROBLEM.INSTANCE_SEG.DATA_CHANNELS, save_dir=getattr(cfg.PATHS, tag+'_INSTANCE_CHANNELS_CHECK'),
+                fb_mode=cfg.PROBLEM.INSTANCE_SEG.DATA_CONTOUR_MODE)
+    
     save_tif(Y, data_dir=getattr(cfg.DATA, tag).INSTANCE_CHANNELS_MASK_DIR, filenames=filenames, verbose=cfg.TEST.VERBOSE)
     X, _, _, filenames = f_name(getattr(cfg.DATA, tag).PATH, return_filenames=True)
     print("Creating X_{} channels . . .".format(data_type))