biomedisa 24.8.11__py3-none-any.whl → 25.6.1__py3-none-any.whl

biomedisa/deeplearning.py

@@ -1,7 +1,7 @@
 #!/usr/bin/python3
 ##########################################################################
 ##                                                                      ##
-##  Copyright (c) 2019-2024 Philipp Lösel. All rights reserved.         ##
+##  Copyright (c) 2019-2025 Philipp Lösel. All rights reserved.         ##
 ##                                                                      ##
 ##  This file is part of the open source project biomedisa.             ##
 ##                                                                      ##
@@ -77,7 +77,8 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
     z_patch=64, y_patch=64, x_patch=64, path_to_logfile=None, img_id=None, label_id=None,
     remote=False, queue=0, username=None, shortfilename=None, dice_loss=False,
     acwe=False, acwe_alpha=1.0, acwe_smooth=1, acwe_steps=3, clean=None, fill=None,
-    separation=False, mask=None, refinement=False):
+    separation=False, mask=None, refinement=False, ignore_mask=False, mixed_precision=False,
+    slicer=False, path_to_data=None):
 
     # create biomedisa
     bm = Biomedisa()
@@ -91,6 +92,7 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
     key_copy = tuple(locals().keys())
     for arg in key_copy:
         bm.__dict__[arg] = locals()[arg]
+    bm.path_to_data = bm.path_to_images
 
     # normalization
     bm.normalize = 1 if bm.normalization else 0
@@ -214,10 +216,16 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
 
     if bm.predict:
 
-        # get meta data
-        hf = h5py.File(bm.path_to_model, 'r')
-        meta = hf.get('meta')
-        configuration = meta.get('configuration')
+        # load model
+        try:
+            hf = h5py.File(bm.path_to_model, 'r')
+            meta = hf.get('meta')
+            configuration = meta.get('configuration')
+            bm.allLabels = np.array(meta.get('labels'))
+        except:
+            raise RuntimeError("Invalid model.")
+
+        # get configuration
         channels, bm.x_scale, bm.y_scale, bm.z_scale, bm.normalize, mu, sig = np.array(configuration)[:]
         channels, bm.x_scale, bm.y_scale, bm.z_scale, bm.normalize, mu, sig = int(channels), int(bm.x_scale), \
                                 int(bm.y_scale), int(bm.z_scale), int(bm.normalize), float(mu), float(sig)
@@ -225,7 +233,6 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
             normalization_parameters = np.array(meta['normalization'], dtype=float)
         else:
             normalization_parameters = np.array([[mu],[sig]])
-        bm.allLabels = np.array(meta.get('labels'))
         if 'patch_normalization' in meta:
             bm.patch_normalization = bool(meta['patch_normalization'][()])
         if 'scaling' in meta:
@@ -506,6 +513,12 @@ if __name__ == '__main__':
                         help='Save data in formats like NRRD or TIFF using --extension=".nrrd"')
     parser.add_argument('-ptm','--path_to_model', type=str, metavar='PATH', default=None,
                         help='Specify the model location for training')
+    parser.add_argument('-im','--ignore_mask', action='store_true', default=False,
+                        help='Use a binary mask in the second channel of the label file to define ignored (0) and considered (1) areas during training')
+    parser.add_argument('-mp','--mixed_precision', action='store_true', default=False,
+                        help='Use mixed precision in model')
+    parser.add_argument('--slicer', action='store_true', default=False,
+                        help='Required for starting Biomedisa from 3D Slicer')
     bm = parser.parse_args()
     bm.success = True
 
@@ -543,6 +556,12 @@ if __name__ == '__main__':
         bm.django_env = False
 
     kwargs = vars(bm)
+    bm.path_to_data = bm.path_to_images
+
+    # verify model
+    if bm.predict and os.path.splitext(bm.path)[1] != '.h5':
+        bm = _error_(bm, "Invalid model.")
+        raise RuntimeError("Invalid model.")
 
     # train or predict segmentation
     try:
@@ -561,5 +580,5 @@ if __name__ == '__main__':
         bm = _error_(bm, 'GPU out of memory. Reduce your batch size')
     except Exception as e:
         print(traceback.format_exc())
-        bm = _error_(bm, e)
+        bm = _error_(bm, str(e))
 

biomedisa/features/DataGenerator.py

@@ -1,6 +1,6 @@
 ##########################################################################
 ##                                                                      ##
-##  Copyright (c) 2019-2024 Philipp Lösel. All rights reserved.         ##
+##  Copyright (c) 2019-2025 Philipp Lösel. All rights reserved.         ##
 ##                                                                      ##
 ##  This file is part of the open source project biomedisa.             ##
 ##                                                                      ##
@@ -26,11 +26,11 @@
 ##                                                                      ##
 ##########################################################################
 
+from biomedisa.features.biomedisa_helper import welford_mean_std
 import numpy as np
 import tensorflow as tf
 import numba
 import random
-import scipy
 
 def get_random_rotation_matrix(batch_size):
     angle_xy = np.random.uniform(0, 2. * np.pi, batch_size)
@@ -80,7 +80,6 @@ def rotate_img_patch(src,trg,k,l,m,cos_a,sin_a,z_patch,y_patch,x_patch,imageHeig
                 trg[z-k,y-l,x-m] = val
     return trg
 
-
 @numba.jit(nopython=True)#parallel=True
 def rotate_img_patch_3d(src,trg,k,l,m,rm_xx,rm_xy,rm_xz,rm_yx,rm_yy,rm_yz,rm_zx,rm_zy,rm_zz,z_patch,y_patch,x_patch,imageVertStride,imageDepth,imageHeight,imageWidth):
     #return rotate_label_patch_3d(src,trg,k,l,m,rm_xx,rm_xy,rm_xz,rm_yx,rm_yy,rm_yz,rm_zx,rm_zy,rm_zz,z_patch,y_patch,x_patch,imageVertStride,imageDepth,imageHeight,imageWidth)
@@ -175,34 +174,11 @@ def rotate_label_patch_3d(src,trg,k,l,m,rm_xx,rm_xy,rm_xz,rm_yx,rm_yy,rm_yz,rm_z
                 trg[z-k,y-l,x-m] = src[idx_src_z,idx_src_y,idx_src_x]
     return trg
 
-def random_rotation_3d(image, max_angle=180):
-    """ Randomly rotate an image by a random angle (-max_angle, max_angle).
-
-    Arguments:
-    max_angle: `float`. The maximum rotation angle.
-
-    Returns:
-    batch of rotated 3D images
-    """
-
-    # rotate along x-axis
-    angle = random.uniform(-max_angle, max_angle)
-    image2 = scipy.ndimage.rotate(image, angle, mode='nearest', axes=(0, 1), reshape=False)
-
-    # rotate along y-axis
-    angle = random.uniform(-max_angle, max_angle)
-    image3 = scipy.ndimage.rotate(image2, angle, mode='nearest', axes=(0, 2), reshape=False)
-
-    # rotate along z-axis
-    angle = random.uniform(-max_angle, max_angle)
-    image_rot = scipy.ndimage.rotate(image3, angle, mode='nearest', axes=(1, 2), reshape=False)
-
-    return image_rot
-
 class DataGenerator(tf.keras.utils.Sequence):
     'Generates data for Keras'
-    def __init__(self, img, label, list_IDs_fg, list_IDs_bg, shuffle, train, classification, batch_size=32, dim=(32,32,32),
-                 dim_img=(32,32,32), n_classes=10, n_channels=1, augment=(False,False,False,False,0,False), patch_normalization=False, separation=False):
+    def __init__(self, img, label, list_IDs_fg, list_IDs_bg, shuffle, train, batch_size=32, dim=(32,32,32),
+                 dim_img=(32,32,32), n_classes=10, n_channels=1, augment=(False,False,False,False,0,False),
+                 patch_normalization=False, separation=False, ignore_mask=False):
         'Initialization'
         self.dim = dim
         self.dim_img = dim_img
@@ -216,10 +192,10 @@ class DataGenerator(tf.keras.utils.Sequence):
         self.shuffle = shuffle
         self.augment = augment
         self.train = train
-        self.classification = classification
         self.on_epoch_end()
         self.patch_normalization = patch_normalization
         self.separation = separation
+        self.ignore_mask = ignore_mask
 
     def __len__(self):
         'Denotes the number of batches per epoch'
@@ -276,12 +252,12 @@ class DataGenerator(tf.keras.utils.Sequence):
     def __data_generation(self, list_IDs_temp):
         'Generates data containing batch_size samples' # X : (n_samples, *dim, n_channels)
 
-        # Initialization
+        # number of label channels
+        label_channels = 2 if self.ignore_mask else 1
+
+        # allocate memory
         X = np.empty((self.batch_size, *self.dim, self.n_channels), dtype=np.float32)
-        if self.classification:
-            y = np.empty((self.batch_size, 1), dtype=np.int32)
-        else:
-            y = np.empty((self.batch_size, *self.dim, 1), dtype=np.int32)
+        y = np.empty((self.batch_size, *self.dim, label_channels), dtype=np.int32)
 
         # get augmentation parameter
         flip_x, flip_y, flip_z, swapaxes, rotate, rotate3d = self.augment
@@ -306,119 +282,92 @@ class DataGenerator(tf.keras.utils.Sequence):
             m = rest % self.dim_img[2]
 
             # get patch
-            if self.classification:
-                tmp_X = self.img[k:k+self.dim[0],l:l+self.dim[1],m:m+self.dim[2]]
-                tmp_y = self.label[k,l,m]
-
-                # augmentation
-                if self.train:
-
-                    # rotate in 3D
-                    if rotate:
-                        tmp_X = random_rotation_3d(tmp_X, max_angle=rotate)
-
-                    # flip patch along axes
-                    v = np.random.randint(n_aug+1)
-                    if np.any([flip_x, flip_y, flip_z]) and v>0:
-                        flip = flips[v-1]
-                        tmp_X = np.flip(tmp_X, flip)
-
-                    # swap axes
-                    if swapaxes:
-                        v = np.random.randint(4)
-                        if v==1:
-                            tmp_X = np.swapaxes(tmp_X,0,1)
-                        elif v==2:
-                            tmp_X = np.swapaxes(tmp_X,0,2)
-                        elif v==3:
-                            tmp_X = np.swapaxes(tmp_X,1,2)
-
-                # assign to batch
-                X[i,:,:,:,0] = tmp_X
-                y[i,0] = tmp_y
-
-            else:
-                # get patch
-                tmp_X = self.img[k:k+self.dim[0],l:l+self.dim[1],m:m+self.dim[2]]
-                tmp_y = self.label[k:k+self.dim[0],l:l+self.dim[1],m:m+self.dim[2]]
-
-                # center label gets value 1
-                if self.separation:
-                    centerLabel = tmp_y[self.dim[0]//2,self.dim[1]//2,self.dim[2]//2]
-                    tmp_y = tmp_y.copy()
-                    tmp_y[tmp_y!=centerLabel]=0
-                    tmp_y[tmp_y==centerLabel]=1
-
-                # augmentation
-                if self.train:
-
-                    # rotate in xy plane
-                    if rotate:
-                        tmp_X = np.empty((*self.dim, self.n_channels), dtype=np.float32)
-                        tmp_y = np.empty(self.dim, dtype=np.int32)
-                        cos_a = cos_angle[i]
-                        sin_a = sin_angle[i]
-                        for c in range(self.n_channels):
-                            tmp_X[:,:,:,c] = rotate_img_patch(self.img[:,:,:,c],tmp_X[:,:,:,c],k,l,m,cos_a,sin_a,
-                                self.dim[0],self.dim[1],self.dim[2],
-                                self.dim_img[1],self.dim_img[2])
-                        tmp_y = rotate_label_patch(self.label,tmp_y,k,l,m,cos_a,sin_a,
+            tmp_X = self.img[k:k+self.dim[0],l:l+self.dim[1],m:m+self.dim[2]]
+            tmp_y = self.label[k:k+self.dim[0],l:l+self.dim[1],m:m+self.dim[2]]
+
+            # center label gets value 1
+            if self.separation:
+                centerLabel = tmp_y[self.dim[0]//2,self.dim[1]//2,self.dim[2]//2]
+                tmp_y = tmp_y.copy()
+                tmp_y[tmp_y!=centerLabel]=0
+                tmp_y[tmp_y==centerLabel]=1
+
+            # augmentation
+            if self.train:
+
+                # rotate in xy plane
+                if rotate:
+                    tmp_X = np.empty((*self.dim, self.n_channels), dtype=np.float32)
+                    tmp_y = np.empty((*self.dim, label_channels), dtype=np.int32)
+                    cos_a = cos_angle[i]
+                    sin_a = sin_angle[i]
+                    for ch in range(self.n_channels):
+                        tmp_X[...,ch] = rotate_img_patch(self.img[...,ch],tmp_X[...,ch],k,l,m,cos_a,sin_a,
+                            self.dim[0],self.dim[1],self.dim[2],
+                            self.dim_img[1],self.dim_img[2])
+                    for ch in range(label_channels):
+                        tmp_y[...,ch] = rotate_label_patch(self.label[...,ch],tmp_y[...,ch],k,l,m,cos_a,sin_a,
                             self.dim[0],self.dim[1],self.dim[2],
                             self.dim_img[1],self.dim_img[2])
-                    
-                    # rotate through a random 3d angle, uniformly distributed on a sphere.
-                    if rotate3d:
-                        tmp_X = np.empty((*self.dim, self.n_channels), dtype=np.float32)
-                        tmp_y = np.empty(self.dim, dtype=np.int32)
-                        rm_xx = rot_mtx[i, 0, 0]
-                        rm_xy = rot_mtx[i, 0, 1]
-                        rm_xz = rot_mtx[i, 0, 2]
-                        rm_yx = rot_mtx[i, 1, 0]
-                        rm_yy = rot_mtx[i, 1, 1]
-                        rm_yz = rot_mtx[i, 1, 2]
-                        rm_zx = rot_mtx[i, 2, 0]
-                        rm_zy = rot_mtx[i, 2, 1]
-                        rm_zz = rot_mtx[i, 2, 2]
-                        for c in range(self.n_channels):
-                            tmp_X[:,:,:,c] = rotate_img_patch_3d(self.img[:,:,:,c],tmp_X[:,:,:,c],k,l,m,
-                                rm_xx,rm_xy,rm_xz,rm_yx,rm_yy,rm_yz,rm_zx,rm_zy,rm_zz,
-                                self.dim[0],self.dim[1],self.dim[2],
-                                256, self.dim_img[0],self.dim_img[1],self.dim_img[2])
-                        tmp_y = rotate_label_patch_3d(self.label,tmp_y,k,l,m,
+
+                # rotate through a random 3d angle, uniformly distributed on a sphere.
+                if rotate3d:
+                    tmp_X = np.empty((*self.dim, self.n_channels), dtype=np.float32)
+                    tmp_y = np.empty((*self.dim, label_channels), dtype=np.int32)
+                    rm_xx = rot_mtx[i, 0, 0]
+                    rm_xy = rot_mtx[i, 0, 1]
+                    rm_xz = rot_mtx[i, 0, 2]
+                    rm_yx = rot_mtx[i, 1, 0]
+                    rm_yy = rot_mtx[i, 1, 1]
+                    rm_yz = rot_mtx[i, 1, 2]
+                    rm_zx = rot_mtx[i, 2, 0]
+                    rm_zy = rot_mtx[i, 2, 1]
+                    rm_zz = rot_mtx[i, 2, 2]
+                    for ch in range(self.n_channels):
+                        tmp_X[...,ch] = rotate_img_patch_3d(self.img[...,ch],tmp_X[...,ch],k,l,m,
+                            rm_xx,rm_xy,rm_xz,rm_yx,rm_yy,rm_yz,rm_zx,rm_zy,rm_zz,
+                            self.dim[0],self.dim[1],self.dim[2],
+                            256, self.dim_img[0],self.dim_img[1],self.dim_img[2])
+                    for ch in range(label_channels):
+                        tmp_y[...,ch] = rotate_label_patch_3d(self.label[...,ch],tmp_y[...,ch],k,l,m,
                             rm_xx,rm_xy,rm_xz,rm_yx,rm_yy,rm_yz,rm_zx,rm_zy,rm_zz,
                             self.dim[0],self.dim[1],self.dim[2],
                             256, self.dim_img[0],self.dim_img[1],self.dim_img[2])
 
-                    # flip patch along axes
-                    v = np.random.randint(n_aug+1)
-                    if np.any([flip_x, flip_y, flip_z]) and v>0:
-                        flip = flips[v-1]
-                        tmp_X = np.flip(tmp_X, flip)
-                        tmp_y = np.flip(tmp_y, flip)
-
-                    # swap axes
-                    if swapaxes:
-                        v = np.random.randint(4)
-                        if v==1:
-                            tmp_X = np.swapaxes(tmp_X,0,1)
-                            tmp_y = np.swapaxes(tmp_y,0,1)
-                        elif v==2:
-                            tmp_X = np.swapaxes(tmp_X,0,2)
-                            tmp_y = np.swapaxes(tmp_y,0,2)
-                        elif v==3:
-                            tmp_X = np.swapaxes(tmp_X,1,2)
-                            tmp_y = np.swapaxes(tmp_y,1,2)
-
-                # patch normalization
-                if self.patch_normalization:
-                    tmp_X = tmp_X.copy().astype(np.float32)
-                    for c in range(self.n_channels):
-                        tmp_X[:,:,:,c] -= np.mean(tmp_X[:,:,:,c])
-                        tmp_X[:,:,:,c] /= max(np.std(tmp_X[:,:,:,c]), 1e-6)
-
-                # assign to batch
-                X[i] = tmp_X
-                y[i,:,:,:,0] = tmp_y
-
-        return X, tf.keras.utils.to_categorical(y, num_classes=self.n_classes)
+                # flip patch along axes
+                v = np.random.randint(n_aug+1)
+                if np.any([flip_x, flip_y, flip_z]) and v>0:
+                    flip = flips[v-1]
+                    tmp_X = np.flip(tmp_X, flip)
+                    tmp_y = np.flip(tmp_y, flip)
+
+                # swap axes
+                if swapaxes:
+                    v = np.random.randint(4)
+                    if v==1:
+                        tmp_X = np.swapaxes(tmp_X,0,1)
+                        tmp_y = np.swapaxes(tmp_y,0,1)
+                    elif v==2:
+                        tmp_X = np.swapaxes(tmp_X,0,2)
+                        tmp_y = np.swapaxes(tmp_y,0,2)
+                    elif v==3:
+                        tmp_X = np.swapaxes(tmp_X,1,2)
+                        tmp_y = np.swapaxes(tmp_y,1,2)
+
+            # patch normalization
+            if self.patch_normalization:
+                tmp_X = tmp_X.copy().astype(np.float32)
+                for ch in range(self.n_channels):
+                    mean, std = welford_mean_std(tmp_X[...,ch])
+                    tmp_X[...,ch] -= mean
+                    tmp_X[...,ch] /= max(std, 1e-6)
+
+            # assign to batch
+            X[i] = tmp_X
+            y[i] = tmp_y
+
+        if self.ignore_mask:
+            return X, y
+        else:
+            return X, tf.keras.utils.to_categorical(y, num_classes=self.n_classes)
 

biomedisa/features/PredictDataGenerator.py

@@ -1,6 +1,6 @@
 ##########################################################################
 ##                                                                      ##
-##  Copyright (c) 2019-2024 Philipp Lösel. All rights reserved.         ##
+##  Copyright (c) 2019-2025 Philipp Lösel. All rights reserved.         ##
 ##                                                                      ##
 ##  This file is part of the open source project biomedisa.             ##
 ##                                                                      ##
@@ -26,6 +26,7 @@
 ##                                                                      ##
 ##########################################################################
 
+from biomedisa.features.biomedisa_helper import welford_mean_std
 import numpy as np
 import tensorflow as tf
 
@@ -77,10 +78,11 @@ class PredictDataGenerator(tf.keras.utils.Sequence):
             # get patch
             tmp_X = self.img[k:k+self.dim[0],l:l+self.dim[1],m:m+self.dim[2]]
             if self.patch_normalization:
-                tmp_X = np.copy(tmp_X, order='C')
-                for c in range(self.n_channels):
-                    tmp_X[:,:,:,c] -= np.mean(tmp_X[:,:,:,c])
-                    tmp_X[:,:,:,c] /= max(np.std(tmp_X[:,:,:,c]), 1e-6)
+                tmp_X = tmp_X.copy().astype(np.float32)
+                for ch in range(self.n_channels):
+                    mean, std = welford_mean_std(tmp_X[...,ch])
+                    tmp_X[...,ch] -= mean
+                    tmp_X[...,ch] /= max(std, 1e-6)
             X[i] = tmp_X
 
         return X

biomedisa/features/biomedisa_helper.py

@@ -52,6 +52,19 @@ def silent_remove(filename):
     except OSError:
         pass
 
+# calculate mean and standard deviation using Welford's algorithm
+@numba.jit(nopython=True)
+def welford_mean_std(arr):
+    mean, m2, count = 0.0, 0.0, 0
+    for x in arr.ravel():
+        count += 1
+        delta = x - mean
+        mean += delta / count
+        delta2 = x - mean
+        m2 += delta * delta2  # Running sum of squared differences
+    std_dev = np.sqrt(m2 / count) if count > 1 else 0.0  # Population std deviation
+    return mean, std_dev
+
 # determine all values and their count from an array
 def unique(arr, return_counts=False):
     try:
@@ -408,14 +421,21 @@ def load_data(path_to_data, process='None', return_extension=False):
     else:
         return data, header
 
-def _error_(bm, message):
+def _error_(bm, message, level=1):
     if bm.django_env:
         from biomedisa.features.django_env import create_error_object
         create_error_object(message, bm.remote, bm.queue, bm.img_id)
         with open(bm.path_to_logfile, 'a') as logfile:
             print('%s %s %s %s' %(time.ctime(), bm.username, bm.shortfilename, message), file=logfile)
-    print('Error:', message)
-    bm.success = False
+    elif bm.slicer and bm.path_to_data:
+        error_path = os.path.dirname(bm.path_to_data) + '/biomedisa-error.txt'
+        with open(error_path, 'w') as file:
+            file.write(message)
+    if level==0:
+        print('Warning:', message)
+    elif level==1:
+        print('Error:', message)
+        bm.success = False
     return bm
 
 def pre_processing(bm):
@@ -613,7 +633,10 @@ def _get_platform(bm):
     if cl and bm.platform is None:
         for vendor in ['NVIDIA', 'Intel', 'AMD', 'Apple']:
             for dev, device_type in [('GPU',cl.device_type.GPU),('CPU',cl.device_type.CPU)]:
-                all_platforms = cl.get_platforms()
+                try:
+                    all_platforms = cl.get_platforms()
+                except:
+                    all_platforms = []
                 my_devices = []
                 for p in all_platforms:
                     if p.get_devices(device_type=device_type) and vendor in p.name:
@@ -634,7 +657,10 @@ def _get_platform(bm):
     elif cl and len(bm.platform.split('_')) == 3:
         plat, vendor, dev = bm.platform.split('_')
         device_type=cl.device_type.GPU if dev=='GPU' else cl.device_type.CPU
-        all_platforms = cl.get_platforms()
+        try:
+            all_platforms = cl.get_platforms()
+        except:
+            all_platforms = []
         my_devices = []
         for p in all_platforms:
             if p.get_devices(device_type=device_type) and vendor in p.name:

biomedisa/features/crop_helper.py

@@ -1,6 +1,6 @@
 ##########################################################################
 ##                                                                      ##
-##  Copyright (c) 2019-2024 Philipp Lösel. All rights reserved.         ##
+##  Copyright (c) 2019-2025 Philipp Lösel. All rights reserved.         ##
 ##                                                                      ##
 ##  This file is part of the open source project biomedisa.             ##
 ##                                                                      ##
@@ -28,7 +28,8 @@
 
 import os
 from biomedisa.features.keras_helper import read_img_list
-from biomedisa.features.biomedisa_helper import img_resize, load_data, save_data, set_labels_to_zero
+from biomedisa.features.biomedisa_helper import (img_resize,
+    load_data, save_data, set_labels_to_zero, welford_mean_std)
 from tensorflow.python.framework.errors_impl import ResourceExhaustedError
 from tensorflow.keras.applications import DenseNet121, densenet
 from tensorflow.keras.optimizers import Adam
@@ -161,7 +162,7 @@ def load_cropping_training_data(normalize, img_list, label_list, x_scale, y_scal
             # normalize first validation image
             if normalize and np.any(normalization_parameters):
                 for c in range(channels):
-                    mean, std = np.mean(img[:,:,:,c]), np.std(img[:,:,:,c])
+                    mean, std = welford_mean_std(img[:,:,:,c])
                     img[:,:,:,c] = (img[:,:,:,c] - mean) / std
                     img[:,:,:,c] = img[:,:,:,c] * normalization_parameters[1,c] + normalization_parameters[0,c]
 
@@ -170,8 +171,7 @@ def load_cropping_training_data(normalize, img_list, label_list, x_scale, y_scal
                 normalization_parameters = np.zeros((2,channels))
                 if normalize:
                     for c in range(channels):
-                        normalization_parameters[0,c] = np.mean(img[:,:,:,c])
-                        normalization_parameters[1,c] = np.std(img[:,:,:,c])
+                        normalization_parameters[:,c] = welford_mean_std(img[:,:,:,c])
 
             # loop over list of images
             if any(img_list) or type(img_in) is list:
@@ -223,7 +223,7 @@ def load_cropping_training_data(normalize, img_list, label_list, x_scale, y_scal
                         next_img[:,:,:,c] -= np.amin(next_img[:,:,:,c])
                         next_img[:,:,:,c] /= np.amax(next_img[:,:,:,c])
                         if normalize:
-                            mean, std = np.mean(next_img[:,:,:,c]), np.std(next_img[:,:,:,c])
+                            mean, std = welford_mean_std(next_img[:,:,:,c])
                             next_img[:,:,:,c] = (next_img[:,:,:,c] - mean) / std
                             next_img[:,:,:,c] = next_img[:,:,:,c] * normalization_parameters[1,c] + normalization_parameters[0,c]
                     img = np.append(img, next_img, axis=0)
@@ -391,7 +391,7 @@ def load_data_to_crop(path_to_img, channels, x_scale, y_scale, z_scale,
         img[:,:,:,c] -= np.amin(img[:,:,:,c])
         img[:,:,:,c] /= np.amax(img[:,:,:,c])
         if normalize:
-            mean, std = np.mean(img[:,:,:,c]), np.std(img[:,:,:,c])
+            mean, std = welford_mean_std(img[:,:,:,c])
             img[:,:,:,c] = (img[:,:,:,c] - mean) / std
             img[:,:,:,c] = img[:,:,:,c] * normalization_parameters[1,c] + normalization_parameters[0,c]
     img[img<0] = 0