diff --git a/.gitignore b/.gitignore
index 616f591..305bab6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,7 +11,6 @@ dist/
 docs/build/
 examples/**/models/
 
-*.png
 *.npz
 *.npy
 *.tif*
diff --git a/LICENSE.txt b/LICENSE.txt
index f002eb1..a6aaf3d 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,8 +1,8 @@
-License for Noise2Seg
+License for DenoiSeg
 
 BSD 3-Clause License
 
-Copyright (c) 2019 JugLab
+Copyright (c) 2020 JugLab
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
diff --git a/README.md b/README.md
index 1713c38..9cb16c7 100644
--- a/README.md
+++ b/README.md
@@ -1,35 +1,93 @@
-# DenoiSeg
-Microscopy image analysis often requires the segmentation of objects, but training data for such a task is hard to obtain.
-Here we propose DenoiSeg, a new method that can be trained end-to-end on only a few annotated ground truth segmentations. 
-We achieve this by extending Noise2Void, a self-supervised denoising scheme that can be trained on noisy images, to also predict dense 3-class segmentations. 
-The reason for the success of our method is that segmentation can profit from denoising especially when performed within the same network jointly.
-The network becomes a denoising expert by seeing all available raw data, while  co-learning to segment even if only a few segmentation labels are available.
-This hypothesis is additionally fueled by our observation that the best segmentation results on high quality (virtually noise free) raw data are performed when moderate amounts of synthetic noise are added. 
-This renders the denoising-task non-trivial and unleashes the co-learning effect.
-We believe that DenoiSeg offers a viable way to circumvent the tremendous hunger for high quality training data and effectively enables few-shot learning of dense segmentations.
-
-## How to run
-### Conda-Env
-You can either install the necessary packages into a conda-env with the setup.py file by typing `pip install .` 
-from within this cloned git-repo or you use a singularity container.
-
-### Build Singularity Container
-1. Install Singularity
-2. `sudo singularity build noise2seg.sim singularity/noise2seg.Singularity`
-
-### Run Singularity Container
-Now you can run a jupyter-server with this container:
-`singularity run --nv -B singularity/user:/run/user -B ./:/notebooks singularity/noise2seg.simg`
-
-### Run Singularity Headless
-1. Install PyInquirer
-2. `python3 run_noise2seg.py`
-
-For the headless to work you have to set following parameters in the file `run_noise2seg.py`:
-```
-singularity_path = "/projects/Noise2Seg/singularity/"
-base_dir = "/projects/Noise2Seg"
-gitrepo_path = join(base_dir, 'Noise2Seg')
-base_path_data = join(base_dir, "data")
-base_path_exp = join(base_dir, "experiments")
+![Teaser: DenoiSeg](resources/teaser.png)
+# DenoiSeg: Joint Denoising and Segmentation
+Tim-Oliver Buchholz<sup>\*,1,2</sup>, Mangal Prakash<sup>\*,1,2,</sup>, Alexander Krull<sup>1,2,3</sup>,
+and Florian Jug<sup>1,2,^</sup>
+
+<sup>1</sup> Max Planck Institute of Molecular Cell Biology and Genetics, Dresden, Germany <br />
+<sup>2</sup> Center for Systems Biology, Dresden, Germany <br />
+<sup>3</sup> Max Planck Institute for Physics of Complex Systems, Dresden, Germany <br />
+<sup>^</sup> <code>jug@mpi-cbg.de</code> <br />
+<sup>*</sup> Equal contribution (alphabetical order).
+
+Microscopy image analysis often requires the segmentation of objects, 
+but training data for this task is typically scarce and hard to obtain.
+Here we propose DenoiSeg, a new method that can be trained end-to-end 
+on only a few annotated ground truth segmentations. 
+We achieve this by extending [Noise2Void](https://github.com/juglab/n2v), 
+a self-supervised denoising scheme that can be trained on noisy images alone, 
+to also predict dense 3-class segmentations. The reason for the success 
+of our method is that segmentation can profit from denoising, especially 
+when performed jointly within the same network. The network becomes a 
+denoising expert by seeing all available raw data, while  co-learning to 
+segment, even if only a few segmentation labels are available. This 
+hypothesis is additionally fueled by our observation that the best 
+segmentation results on high quality (very low noise) raw data are obtained 
+when moderate amounts of synthetic noise are added. This renders the 
+denoising-task non-trivial and unleashes the desired co-learning effect.
+We believe that DenoiSeg offers a viable way to circumvent the tremendous 
+hunger for high quality training data and effectively enables few-shot learning 
+of dense segmentations.
+
+Paper: [https://arxiv.org/abs/2005.02987](https://arxiv.org/abs/2005.02987)
+
+## Installation
+This implementation requires [Tensorflow](https://www.tensorflow.org/install/).
+We have tested DenoiSeg on LinuxMint 19  using python 3.6 and 3.7 and tensorflow-gpu 1.15.
+
+#### If you start from scratch...
+We recommend using [miniconda](https://docs.conda.io/en/latest/miniconda.html).
+If you do not yet have a strong opinion, just use it too!
+
+After installing Miniconda, the following lines might are likely the easiest way to get Tensorflow and CuDNN installed on your machine (_Note:_ Macs are not supported, and if you sit on a Windows machine all this might also require some modifications.):
+
 ```
+$ conda create -n 'denoiSeg' python=3.7
+$ source activate denoiSeg
+$ conda install tensorflow-gpu=1.15 keras=2.2.5
+$ pip install jupyter
+$ conda install nb_conda
+```
+
+Note: it is very important that the version of keras be 2.2.4 or 2.2.5, hence the explicit installation above.
+Once this is done (or you had tensorflow et al. installed already), you can install DenoiSeg with one of the following two options:
+
+#### Option 1: PIP (current stable release) 
+```
+$ pip install denoiseg
+```
+
+#### Option 2: Git-Clone and install from sources (current master-branch version)
+This option is ideal if you want to edit the code. Clone the repository:
+
+```
+$ git clone https://github.com/juglab/DenoiSeg.git
+```
+Change into its directory and install it:
+
+```
+$ cd DenoiSeg
+$ pip install -e .
+```
+You are now ready to run DenoiSeg.
+
+## How to use it?
+Have a look at our jupyter notebook:
+* [Example: DSB2018](https://github.com/juglab/DenoiSeg/tree/master/examples/DenoiSeg_2D/DSB2018_DenoiSeg_Example.ipynb)
+* [Example: Fly Wing](https://github.com/juglab/DenoiSeg/tree/master/examples/DenoiSeg_2D/FlyWing_DenoiSeg_Example.ipynb)
+* [Example: Mouse Nuclei](https://github.com/juglab/DenoiSeg/tree/master/examples/DenoiSeg_2D/MouseNuclei_DenoiSeg_Example.ipynb)
+
+## How to cite:
+```
+@inproceedings{BuchholzPrakash2020DenoiSeg,
+  title={DenoiSeg: Joint Denoising and Segmentation},
+  author={Tim-Oliver Buchholz and Mangal Prakash and Alexander Krull and Florian Jug},
+  year={2020}
+}
+```
+
+## Reproducibility
+The current release and master is a refactored version of the code used for the paper. 
+This refactored version produces the same number as reported in the paper, but if you
+wish to use the exact code used in the paper, please continue [here](scripts/reproducibility/README.md).
+
+Further results (qualitative and quantitative) can be found on the [wiki](https://github.com/juglab/DenoiSeg/wiki).
diff --git a/noise2seg/__init__.py b/denoiseg/__init__.py
similarity index 100%
rename from noise2seg/__init__.py
rename to denoiseg/__init__.py
diff --git a/noise2seg/internals/N2S_DataWrapper.py b/denoiseg/internals/DenoiSeg_DataWrapper.py
similarity index 99%
rename from noise2seg/internals/N2S_DataWrapper.py
rename to denoiseg/internals/DenoiSeg_DataWrapper.py
index 8260916..232aaaf 100644
--- a/noise2seg/internals/N2S_DataWrapper.py
+++ b/denoiseg/internals/DenoiSeg_DataWrapper.py
@@ -2,7 +2,7 @@
 
 import numpy as np
 
-class N2S_DataWrapper(Sequence):
+class DenoiSeg_DataWrapper(Sequence):
     def __init__(self, X, n2v_Y, seg_Y, batch_size, perc_pix, shape, value_manipulation):
         assert X.shape[0] == n2v_Y.shape[0]
         assert X.shape[0] == seg_Y.shape[0]
diff --git a/noise2seg/internals/__init__.py b/denoiseg/internals/__init__.py
similarity index 100%
rename from noise2seg/internals/__init__.py
rename to denoiseg/internals/__init__.py
diff --git a/noise2seg/internals/losses.py b/denoiseg/internals/losses.py
similarity index 79%
rename from noise2seg/internals/losses.py
rename to denoiseg/internals/losses.py
index 4c008db..ebd931b 100755
--- a/noise2seg/internals/losses.py
+++ b/denoiseg/internals/losses.py
@@ -29,25 +29,25 @@ def seg_crossentropy(class_targets, y_pred):
     return seg_crossentropy
 
 
-def loss_noise2seg(alpha=0.5, relative_weights=[1.0, 1.0, 5.0]):
+def loss_denoiseg(alpha=0.5, relative_weights=[1.0, 1.0, 5.0]):
     """
-    Calculate noise2seg loss which is a weighted sum of segmentation- and
+    Calculate DenoiSeg loss which is a weighted sum of segmentation- and
     noise2void-loss
 
     :param lambda_: relative weighting, 0 means denoising, 1 means segmentation; (Default: 0.5)
     :param relative_weights: Segmentation class weights (background, foreground, border); (Default: [1.0, 1.0, 5.0])
-    :return: noise2seg loss
+    :return: DenoiSeg loss
     """
-    denoise_loss = noise2seg_denoise_loss(weight=alpha)
-    seg_loss = noise2seg_seg_loss(weight=(1 - alpha), relative_weights=relative_weights)
+    denoise_loss = denoiseg_denoise_loss(weight=alpha)
+    seg_loss = denoiseg_seg_loss(weight=(1 - alpha), relative_weights=relative_weights)
 
-    def noise2seg(y_true, y_pred):
+    def denoiseg(y_true, y_pred):
         return seg_loss(y_true, y_pred) + denoise_loss(y_true, y_pred)
 
-    return noise2seg
+    return denoiseg
 
 
-def noise2seg_seg_loss(weight=0.5, relative_weights=[1.0, 1.0, 5.0]):
+def denoiseg_seg_loss(weight=0.5, relative_weights=[1.0, 1.0, 5.0]):
     class_weights = tf.constant([relative_weights])
 
     def seg_loss(y_true, y_pred):
@@ -69,7 +69,7 @@ def seg_loss(y_true, y_pred):
     return seg_loss
 
 
-def noise2seg_denoise_loss(weight=0.5):
+def denoiseg_denoise_loss(weight=0.5):
     n2v_mse_loss = n2v_loss()
 
     def denoise_loss(y_true, y_pred):
@@ -80,10 +80,3 @@ def denoise_loss(y_true, y_pred):
         return weight * n2v_mse_loss(tf.concat([target, mask], axis=channel_axis), denoised)
 
     return denoise_loss
-
-def seg_denoise_ratio_monitor():
-
-    def seg_denoise_ratio(y_true, y_pred):
-        return tf.reduce_mean(tf.reduce_sum(y_true[...,2:], axis=-1)[:,0,0])
-
-    return seg_denoise_ratio
diff --git a/denoiseg/models/__init__.py b/denoiseg/models/__init__.py
new file mode 100755
index 0000000..b242b51
--- /dev/null
+++ b/denoiseg/models/__init__.py
@@ -0,0 +1,4 @@
+# imports
+
+from .denoiseg_config import DenoiSegConfig
+from .denoiseg_standard import DenoiSeg
diff --git a/noise2seg/models/n2s_config.py b/denoiseg/models/denoiseg_config.py
similarity index 93%
rename from noise2seg/models/n2s_config.py
rename to denoiseg/models/denoiseg_config.py
index 97c41b6..b5c5d83 100755
--- a/noise2seg/models/n2s_config.py
+++ b/denoiseg/models/denoiseg_config.py
@@ -7,10 +7,10 @@
 
 
 # This class is a adapted version of csbdeep.models.config.py.
-class Noise2SegConfig(argparse.Namespace):
+class DenoiSegConfig(argparse.Namespace):
     """
-    Default configuration for a trainable segmentation (Noise2Seg) model.
-    This class is meant to be used with :class:`Noise2Seg`.
+    Default configuration for a trainable segmentation (DenoiSeg) model.
+    This class is meant to be used with :class:`DenoiSeg`.
 
     Parameters
     ----------
@@ -21,7 +21,7 @@ class Noise2SegConfig(argparse.Namespace):
 
     Example
     -------
-    >>> n2s_config = Noise2SegConfig(X, unet_n_depth=3)
+    >>> denoiseg_config = DenoiSegConfig(X, unet_n_depth=3)
 
     Attributes
     ----------
@@ -52,7 +52,7 @@ class Noise2SegConfig(argparse.Namespace):
     train_reduce_lr : dict
         Parameter :class:`dict` of ReduceLROnPlateau_ callback; set to ``None`` to disable. Default: ``{'monitor': 'val_seg_loss', 'factor': 0.5, 'patience': 10}``
     train_loss : str
-        Switch between seg- or noise2seg-loss; Default: ``noise2seg``
+        Switch between seg- or denoiseg-loss; Default: ``denoiseg``
     n2v_perc_pix : float
         Percentage of pixel to manipulate per patch. Default: ``1.5``
     n2v_patch_shape : tuple
@@ -61,7 +61,7 @@ class Noise2SegConfig(argparse.Namespace):
         Noise2Void pixel value manipulator. Default: ``uniform_withCP``
     n2v_neighborhood_radius : int
         Neighborhood radius for n2v_old manipulator. Default: ``5``
-    n2s_alpha : float
+    denoiseg_alpha : float
         Factor modulating the contribution of denoising and segmentation. alpha * denoising + (1-alpha) * segmentation: Default: ``0.5``
 
         .. _ReduceLROnPlateau: https://keras.io/callbacks/#reducelronplateau
@@ -117,7 +117,7 @@ def __init__(self, X, **kwargs):
             # fixed parameters
             self.n_channel_in = 1
             self.n_channel_out = 4
-            self.train_loss = 'noise2seg'
+            self.train_loss = 'denoiseg'
 
             # default config (can be overwritten by kwargs below)
 
@@ -141,13 +141,13 @@ def __init__(self, X, **kwargs):
             self.train_checkpoint = 'weights_best.h5'
             self.train_checkpoint_last  = 'weights_last.h5'
             self.train_checkpoint_epoch = 'weights_now.h5'
-            self.train_reduce_lr = {'monitor': 'val_seg_loss', 'factor': 0.5, 'patience': 10}
+            self.train_reduce_lr = {'monitor': 'val_loss', 'factor': 0.5, 'patience': 10}
             self.batch_norm = True
             self.n2v_perc_pix = 1.5
             self.n2v_patch_shape = (64, 64) if self.n_dim == 2 else (64, 64, 64)
             self.n2v_manipulator = 'uniform_withCP'
             self.n2v_neighborhood_radius = 5
-            self.n2s_alpha = 0.5
+            self.denoiseg_alpha = 0.5
 
         # disallow setting 'probabilistic' manually
         try:
@@ -189,7 +189,7 @@ def _is_int(v, low=None, high=None):
         ok['n_channel_in'] = _is_int(self.n_channel_in, 1)
         ok['n_channel_out'] = _is_int(self.n_channel_out, 4)
         ok['train_loss'] = (
-            (self.train_loss in ('seg', 'noise2seg'))
+            (self.train_loss in ('seg', 'denoiseg'))
         )
         ok['unet_n_depth'] = _is_int(self.unet_n_depth, 1)
         ok['relative_weights'] = isinstance(self.relative_weights, list) and len(self.relative_weights) == 3 and all(
@@ -223,7 +223,7 @@ def _is_int(v, low=None, high=None):
         ok['n2v_manipulator'] = self.n2v_manipulator in ['normal_withoutCP', 'uniform_withCP', 'normal_additive',
                                                          'normal_fitted', 'identity']
         ok['n2v_neighborhood_radius'] = _is_int(self.n2v_neighborhood_radius, 0)
-        ok['n2s_alpha'] = isinstance(self.n2s_alpha, float) and self.n2s_alpha >= 0.0
+        ok['denoiseg_alpha'] = isinstance(self.denoiseg_alpha, float) and self.denoiseg_alpha >= 0.0 and self.denoiseg_alpha <= 1.0
 
         if return_invalid:
             return all(ok.values()), tuple(k for (k, v) in ok.items() if not v)
diff --git a/noise2seg/models/n2s_standard.py b/denoiseg/models/denoiseg_standard.py
similarity index 74%
rename from noise2seg/models/n2s_standard.py
rename to denoiseg/models/denoiseg_standard.py
index bd8e04d..ac96fb9 100755
--- a/noise2seg/models/n2s_standard.py
+++ b/denoiseg/models/denoiseg_standard.py
@@ -14,21 +14,21 @@
 from scipy import ndimage
 from six import string_types
 
-from noise2seg.models import Noise2SegConfig
-from noise2seg.utils.compute_precision_threshold import isnotebook, compute_labels
-from ..internals.N2S_DataWrapper import N2S_DataWrapper
-from noise2seg.internals.losses import loss_noise2seg, noise2seg_denoise_loss, noise2seg_seg_loss, seg_denoise_ratio_monitor
+from denoiseg.models import DenoiSegConfig
+from denoiseg.utils.compute_precision_threshold import isnotebook, compute_labels
+from ..internals.DenoiSeg_DataWrapper import DenoiSeg_DataWrapper
+from denoiseg.internals.losses import loss_denoiseg, denoiseg_denoise_loss, denoiseg_seg_loss
 from n2v.utils.n2v_utils import pm_identity, pm_normal_additive, pm_normal_fitted, pm_normal_withoutCP, pm_uniform_withCP
 from tqdm import tqdm, tqdm_notebook
 
 
-class Noise2Seg(CARE):
+class DenoiSeg(CARE):
     """The training scheme to train a standard 3-class segmentation network.
         Uses a convolutional neural network created by :func:`csbdeep.internals.nets.custom_unet`.
         Parameters
         ----------
-        config : :class:`voidseg.models.seg_config` or None
-            Valid configuration of Seg network (see :func:`SegConfig.is_valid`).
+        config : :class:`denoiseg.models.denoiseg_config` or None
+            Valid configuration of Seg network (see :func:`denoiseg_config.is_valid`).
             Will be saved to disk as JSON (``config.json``).
             If set to ``None``, will be loaded from disk (must exist).
         name : str or None
@@ -44,10 +44,10 @@ class Noise2Seg(CARE):
             Illegal arguments, including invalid configuration.
         Example
         -------
-        >>> model = Noise2Seg(config, 'my_model')
+        >>> model = DenoiSeg(config, 'my_model')
         Attributes
         ----------
-        config : :class:`voidseg.models.seg_config`
+        config : :class:`denoiseg.models.denoiseg_config`
             Configuration of Seg trainable CARE network, as provided during instantiation.
         keras_model : `Keras model <https://keras.io/getting-started/functional-api-guide/>`_
             Keras neural network model.
@@ -59,7 +59,7 @@ class Noise2Seg(CARE):
 
     def __init__(self, config, name=None, basedir='.'):
         """See class docstring"""
-        config is None or isinstance(config, Noise2SegConfig) or _raise(ValueError('Invalid configuration: %s' % str(config)))
+        config is None or isinstance(config, DenoiSegConfig) or _raise(ValueError('Invalid configuration: %s' % str(config)))
         if config is not None and not config.is_valid():
             invalid_attr = config.is_valid(True)[1]
             raise ValueError('Invalid configuration attributes: ' + ', '.join(invalid_attr))
@@ -178,13 +178,13 @@ def train(self, X, Y, validation_data, epochs=None, steps_per_epoch=None):
 
         # Here we prepare the Noise2Void data. Our input is the noisy data X and as target we take X concatenated with
         # a masking channel. The N2V_DataWrapper will take care of the pixel masking and manipulating.
-        training_data = N2S_DataWrapper(X=X,
-                                        n2v_Y=np.concatenate((X, np.zeros(X.shape, dtype=X.dtype)), axis=axes.index('C')),
-                                        seg_Y=Y,
-                                        batch_size=self.config.train_batch_size,
-                                        perc_pix=self.config.n2v_perc_pix,
-                                        shape=self.config.n2v_patch_shape,
-                                        value_manipulation=manipulator)
+        training_data = DenoiSeg_DataWrapper(X=X,
+                                             n2v_Y=np.concatenate((X, np.zeros(X.shape, dtype=X.dtype)), axis=axes.index('C')),
+                                             seg_Y=Y,
+                                             batch_size=self.config.train_batch_size,
+                                             perc_pix=self.config.n2v_perc_pix,
+                                             shape=self.config.n2v_patch_shape,
+                                             value_manipulation=manipulator)
 
         # validation_Y is also validation_X plus a concatenated masking channel.
         # To speed things up, we precompute the masking vo the validation data.
@@ -197,14 +197,6 @@ def train(self, X, Y, validation_data, epochs=None, steps_per_epoch=None):
 
         validation_Y = np.concatenate((validation_Y, validation_data[1]), axis=-1)
 
-        # Add alpha-scheduling
-        cross_point = self.config.n2s_alpha
-        def scheduling(epoch):
-            return np.clip(1 - epoch/(self.config.train_epochs - 1) * 0.5/cross_point, 0, 1)
-
-        alphaScheduling = AlphaScheduling(self.alpha, scheduling)
-        self.callbacks.append(alphaScheduling)
-
         history = self.keras_model.fit_generator(generator=training_data, validation_data=(validation_X, validation_Y),
                                                  epochs=epochs, steps_per_epoch=steps_per_epoch,
                                                  callbacks=self.callbacks, verbose=1)
@@ -259,6 +251,80 @@ def prepare_for_training(self, optimizer=None, **kwargs):
                 from csbdeep.utils.tf import CARETensorBoard
 
                 class SegTensorBoard(CARETensorBoard):
+                    def set_model(self, model):
+                        self.model = model
+                        self.sess = K.get_session()
+                        tf_sums = []
+
+                        if self.compute_histograms and self.freq and self.merged is None:
+                            for layer in self.model.layers:
+                                for weight in layer.weights:
+                                    tf_sums.append(tf.compat.v1.summary.histogram(weight.name, weight))
+
+                                if hasattr(layer, 'output'):
+                                    tf_sums.append(tf.compat.v1.summary.histogram('{}_out'.format(layer.name),
+                                                                        layer.output))
+
+                        def _gt_shape(output_shape):
+                            return list(output_shape[:-1]) + [1]
+
+                        self.gt_outputs = [K.placeholder(shape=_gt_shape(K.int_shape(x))) for x in self.model.outputs]
+
+                        n_inputs, n_outputs = len(self.model.inputs), len(self.model.outputs)
+                        image_for_inputs = np.arange(
+                            n_inputs) if self.image_for_inputs is None else self.image_for_inputs
+                        image_for_outputs = np.arange(
+                            n_outputs) if self.image_for_outputs is None else self.image_for_outputs
+
+                        input_slices = (slice(None),) if self.input_slices is None else self.input_slices
+                        output_slices = (slice(None),) if self.output_slices is None else self.output_slices
+                        if isinstance(input_slices[0], slice):  # apply same slices to all inputs
+                            input_slices = [input_slices] * len(image_for_inputs)
+                        if isinstance(output_slices[0], slice):  # apply same slices to all outputs
+                            output_slices = [output_slices] * len(image_for_outputs)
+                        len(input_slices) == len(image_for_inputs) or _raise(ValueError())
+                        len(output_slices) == len(image_for_outputs) or _raise(ValueError())
+
+                        def _name(prefix, layer, i, n, show_layer_names=False):
+                            return '{prefix}{i}{name}'.format(
+                                prefix=prefix,
+                                i=(i if n > 1 else ''),
+                                name='' if (layer is None or not show_layer_names) else '_' + ''.join(
+                                    layer.name.split(':')[:-1]),
+                            )
+
+                        # inputs
+                        for i, sl in zip(image_for_inputs, input_slices):
+                            layer_name = _name('net_input', self.model.inputs[i], i, n_inputs)
+                            input_layer = self.model.inputs[i][tuple(sl)]
+                            tf_sums.append(tf.compat.v1.summary.image(layer_name, input_layer, max_outputs=self.n_images))
+
+                        # outputs
+                        for i, sl in zip(image_for_outputs, output_slices):
+                            # target
+                            output_layer = self.gt_outputs[i][tuple(sl)]
+                            layer_name = _name('net_target', self.model.outputs[i], i, n_outputs)
+                            tf_sums.append(tf.compat.v1.summary.image(layer_name, output_layer, max_outputs=self.n_images))
+                            # prediction
+                            denoised_layer = self.model.outputs[i][..., :1][tuple(sl)]
+                            foreground_layer = self.model.outputs[i][..., 2:3][tuple(sl)]
+                            foreground_layer = K.cast(K.greater(foreground_layer, 0.5), tf.float32)
+
+                            denoised_name = _name('net_output_denoised', self.model.outputs[i], i, n_outputs)
+                            foreground_name = _name('net_output_foreground_threshold.5', self.model.outputs[i], i, n_outputs)
+                            tf_sums.append(tf.compat.v1.summary.image(denoised_name, denoised_layer, max_outputs=self.n_images))
+                            tf_sums.append(tf.compat.v1.summary.image(foreground_name, foreground_layer, max_outputs=self.n_images))
+
+                        with tf.name_scope('merged'):
+                            self.merged = tf.compat.v1.summary.merge(tf_sums)
+
+                        with tf.name_scope('summary_writer'):
+                            if self.write_graph:
+                                self.writer = tf.compat.v1.summary.FileWriter(self.log_dir,
+                                                                    self.sess.graph)
+                            else:
+                                self.writer = tf.compat.v1.summary.FileWriter(self.log_dir)
+
                     def on_epoch_end(self, epoch, logs=None):
                         logs = logs or {}
 
@@ -273,9 +339,7 @@ def on_epoch_end(self, epoch, logs=None):
                                     val_data += self.validation_data[-1:]
                                 else:
                                     val_data = list(v[:self.n_images] for v in self.validation_data)
-                                # GIT issue 20: We need to remove the masking component from the validation data to prevent crash.
-                                end_index = (val_data[1].shape)[-1] // 2
-                                val_data[1] = val_data[1][..., :end_index]
+                                val_data[1] = val_data[1][..., 3:4]
                                 feed_dict = dict(zip(tensors, val_data))
                                 result = self.sess.run([self.merged], feed_dict=feed_dict)
                                 summary_str = result[0]
@@ -425,19 +489,17 @@ def prepare_model(self, model, optimizer, loss):
         if self.config.train_loss == 'seg':
             loss_standard = eval('loss_seg(relative_weights=%s)' % self.config.relative_weights)
             _metrics = [loss_standard]
-        elif self.config.train_loss == 'noise2seg':
-            loss_standard = eval('loss_noise2seg(alpha={}, relative_weights={})'.format(
-                self.config.n2s_alpha,
+        elif self.config.train_loss == 'denoiseg':
+            loss_standard = eval('loss_denoiseg(alpha={}, relative_weights={})'.format(
+                self.config.denoiseg_alpha,
                 self.config.relative_weights))
-            seg_metric = eval('noise2seg_seg_loss(weight={}, relative_weights={})'.format(1-self.config.n2s_alpha,
+            seg_metric = eval('denoiseg_seg_loss(weight={}, relative_weights={})'.format(1-self.config.denoiseg_alpha,
                                                                                           self.config.relative_weights))
-            denoise_metric = eval('noise2seg_denoise_loss(weight={})'.format(self.config.n2s_alpha))
+            denoise_metric = eval('denoiseg_denoise_loss(weight={})'.format(self.config.denoiseg_alpha))
             _metrics = [loss_standard, seg_metric, denoise_metric]
         else:
             _raise('Unknown Loss!')
 
-        seg_denoise_ratio = seg_denoise_ratio_monitor()
-        _metrics.append(seg_denoise_ratio)
         callbacks = [TerminateOnNaN()]
 
         # compile model
@@ -474,4 +536,4 @@ def _set_logdir(self):
 
     @property
     def _config_class(self):
-        return Noise2SegConfig
+        return DenoiSegConfig
diff --git a/noise2seg/utils/__init__.py b/denoiseg/utils/__init__.py
similarity index 100%
rename from noise2seg/utils/__init__.py
rename to denoiseg/utils/__init__.py
diff --git a/noise2seg/utils/compute_precision_threshold.py b/denoiseg/utils/compute_precision_threshold.py
similarity index 100%
rename from noise2seg/utils/compute_precision_threshold.py
rename to denoiseg/utils/compute_precision_threshold.py
diff --git a/noise2seg/utils/misc_utils.py b/denoiseg/utils/misc_utils.py
similarity index 100%
rename from noise2seg/utils/misc_utils.py
rename to denoiseg/utils/misc_utils.py
diff --git a/noise2seg/utils/seg_utils.py b/denoiseg/utils/seg_utils.py
similarity index 100%
rename from noise2seg/utils/seg_utils.py
rename to denoiseg/utils/seg_utils.py
diff --git a/denoiseg/version.py b/denoiseg/version.py
new file mode 100755
index 0000000..7fd229a
--- /dev/null
+++ b/denoiseg/version.py
@@ -0,0 +1 @@
+__version__ = '0.2.0'
diff --git a/examples/DenoiSeg_2D/DSB2018_DenoiSeg_Example.ipynb b/examples/DenoiSeg_2D/DSB2018_DenoiSeg_Example.ipynb
new file mode 100644
index 0000000..ae74257
--- /dev/null
+++ b/examples/DenoiSeg_2D/DSB2018_DenoiSeg_Example.ipynb
@@ -0,0 +1,57147 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# DenoiSeg Example: DSB 2018\n",
+    "This is an example notebook which illustrates how DenoiSeg should be trained. In this notebook we use a refined version of the Kaggle 2018 Data Science Bowl (DSB 2018) dataset. We already split the data into train and test images. From the train images we then extracted 3800 training and 670 validation patches of size 128x128. The test set contains 50 images. \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using TensorFlow backend.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Here we are just importing some libraries which are needed to run this notebook.\n",
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "from scipy import ndimage\n",
+    "\n",
+    "from denoiseg.models import DenoiSeg, DenoiSegConfig\n",
+    "from denoiseg.utils.misc_utils import combine_train_test_data, shuffle_train_data, augment_data\n",
+    "from denoiseg.utils.seg_utils import *\n",
+    "from denoiseg.utils.compute_precision_threshold import measure_precision\n",
+    "\n",
+    "from csbdeep.utils import plot_history\n",
+    "\n",
+    "import urllib\n",
+    "import os\n",
+    "import zipfile"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Downloading and  Data Loading\n",
+    "We created three versions of this dataset by adding Gaussian noise with zero mean and standard deviations 10 and 20. The dataset are marked with the suffixes n0, n10 and n20 accordingly.\n",
+    "\n",
+    "In the next cell you can choose which `noise_level` you would like to investigate."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Choose the noise level you would like to look at:\n",
+    "# Values: 'n0', 'n10', 'n20'\n",
+    "noise_level = 'n10'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# create a folder for our data\n",
+    "if not os.path.isdir('./data'):\n",
+    "    os.mkdir('data')\n",
+    "    \n",
+    "if noise_level == 'n0':\n",
+    "    link = 'https://owncloud.mpi-cbg.de/index.php/s/1WXxLSqbK0ZIxF5/download'\n",
+    "elif noise_level == 'n10':\n",
+    "    link = 'https://owncloud.mpi-cbg.de/index.php/s/dRc1AHcaH8mqeh7/download'\n",
+    "elif noise_level == 'n20':\n",
+    "    link = 'https://owncloud.mpi-cbg.de/index.php/s/hy6xSq82kCoqqSH/download'\n",
+    "else:\n",
+    "    print('This noise level does not exist for this dataset.')\n",
+    "\n",
+    "# check if data has been downloaded already\n",
+    "zipPath=\"data/DSB2018_{}.zip\".format(noise_level)\n",
+    "if not os.path.exists(zipPath):\n",
+    "    #download and unzip data\n",
+    "    data = urllib.request.urlretrieve(link, zipPath)\n",
+    "    with zipfile.ZipFile(zipPath, 'r') as zip_ref:\n",
+    "        zip_ref.extractall(\"data\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Loading of the training images\n",
+    "trainval_data =  np.load('data/DSB2018_{}/train/train_data.npz'.format(noise_level))\n",
+    "train_images = trainval_data['X_train'].astype(np.float32)\n",
+    "train_masks = trainval_data['Y_train']\n",
+    "val_images = trainval_data['X_val'].astype(np.float32)\n",
+    "val_masks = trainval_data['Y_val']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape of train_images: (3800, 128, 128)\n",
+      "Shape of train_masks:  (3800, 128, 128)\n",
+      "Shape of val_images:   (670, 128, 128)\n",
+      "Shape of val_masks:    (670, 128, 128)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Shape of train_images: {}\".format(train_images.shape))\n",
+    "print(\"Shape of train_masks:  {}\".format(train_masks.shape))\n",
+    "print(\"Shape of val_images:   {}\".format(val_images.shape))\n",
+    "print(\"Shape of val_masks:    {}\".format(val_masks.shape))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Small Amounts of Annotated Training Data\n",
+    "With DenoiSeg we present a solution to train deep neural networks if only few annotated ground truth segmentations are available. We simulate such a scenary by zeroing out all but a fraction of the available training data. In the next cell you can specify the percentage of training images for which ground truth annotations are available."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set the percentage of annotated training images.\n",
+    "# Values: 0.0 (no annotated images) to 100.0 (all images get annotations)\n",
+    "percentage_of_annotated_training_images = 0.5\n",
+    "assert percentage_of_annotated_training_images >= 0.0 and percentage_of_annotated_training_images <=100.0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Raw image size after augmentation (30400, 128, 128)\n",
+      "Mask size after augmentation (30400, 128, 128)\n",
+      "Shape of X:     (30400, 128, 128, 1)\n",
+      "Shape of Y:     (30400, 128, 128, 3)\n",
+      "Shape of X_val: (670, 128, 128, 1)\n",
+      "Shape of Y_val: (670, 128, 128, 3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Seed to shuffle training data (annotated GT and raw image pairs).\n",
+    "seed = 1 \n",
+    "\n",
+    "# First we shuffle the training images to remove any bias.\n",
+    "X_shuffled, Y_shuffled = shuffle_train_data(train_images, train_masks, random_seed=seed)\n",
+    "# Here we zero out all training images which are not part of the \n",
+    "# selected percentage.\n",
+    "X_frac, Y_frac = zero_out_train_data(X_shuffled, Y_shuffled, fraction = percentage_of_annotated_training_images)\n",
+    "\n",
+    "# Now we apply data augmentation to the training patches:\n",
+    "# Rotate four times by 90 degree and add flipped versions.\n",
+    "X, Y_train_masks = augment_data(X_frac, Y_frac)\n",
+    "X_val, Y_val_masks = val_images, val_masks\n",
+    "\n",
+    "# Here we add the channel dimension to our input images.\n",
+    "# Dimensionality for training has to be 'SYXC' (Sample, Y-Dimension, X-Dimension, Channel)\n",
+    "X = X[...,np.newaxis]\n",
+    "Y = convert_to_oneHot(Y_train_masks)\n",
+    "X_val = X_val[...,np.newaxis]\n",
+    "Y_val = convert_to_oneHot(Y_val_masks)\n",
+    "print(\"Shape of X:     {}\".format(X.shape))\n",
+    "print(\"Shape of Y:     {}\".format(Y.shape))\n",
+    "print(\"Shape of X_val: {}\".format(X_val.shape))\n",
+    "print(\"Shape of Y_val: {}\".format(Y_val.shape))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next we look at a single sample. In the first column we show the input image, in the second column the background segmentation, in the third column the foreground segmentation and in the last column the border segmentation.\n",
+    "\n",
+    "With the parameter `sample` you can choose different training patches. You will notice that not all of them have a segmentation ground truth."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABGoAAAERCAYAAAAjakGjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAgAElEQVR4nOy9e7QkWVbe99vnnIjIzHtvvbunu+lmWjC8kTzAEiBh7JEN4iEhQMsYGQTmIcughSy8QAhYgMcwkhFGS0iyDX4AI4QYGITAGAuDADMgEEJYDEgwIGaGbnroV3VV31e+IuKc7T/2icjs21W3a2rq0dV9fmvlqnxGRpyIOHXjy29/W1SVQqFQKBQKhUKhUCgUCoXC3cfd7RUoFAqFQqFQKBQKhUKhUCgYRagpFAqFQqFQKBQKhUKhUHiZUISaQqFQKBQKhUKhUCgUCoWXCUWoKRQKhUKhUCgUCoVCoVB4mVCEmkKhUCgUCoVCoVAoFAqFlwlFqCkUCoVCoVAoFAqFQqFQeJlQhJp7DBFREXldvv9dIvKNN/Lem/iezxeRn77Z9TxluZ8oIr97q5dbKNyLiMhjIvJJd3s9bhci8kUi8i9u9WdF5NE8v4X3bQ1ftNw3isj338pl3gnel3EuFLYpc9LNf1ZEPltEnhCRYxH5qJtfy3uLMv8UXk6UOezmPnu7/q7aWv4bROQ9t2PZr2Re9UJNPqGX+T/Wp0XkzSKye7fX60ZQ1S9T1W95X5dzrZNTVf+xqv7p93XZJ1HVX1TVD7nVyy0UXg6IyFeIyK+JyFpE3nybv+umhdhCofDqoMxJd5RvB75CVXdV9dfv9soUCq8EyhxWeDXzqhdqMp+hqrvA64GPAr7uLq9PoVC4N3kSeBPwPXd7RQp3j9v1i1ShcBOUOenO8Vrgt27mgyLib9VKlPmn8AqjzGH3GLfB7fyqndOKULOFqj4N/BQm2AAgIl8rIu8SkSMR+W0R+eyt1x4XkY/J9z8/K7EfkR9/qYj82MnvEJGPy84dv/XcZ4vIb+b7Hysi/1JE9kXkKRH5n0Skvtb6ZvfPm7Ye//X8mSdF5EtOvPfPiMivi8hhtua+cevlX8j/7mdn0Z84aY8TkT8pIv9aRA7yv39y67WfF5FvEZFfyuP00yJy6Trr/ALrW3Y0/XUR+U0RmYvId4vIa0TkJ/OyfkZEzm+9/4fz+B2IyC8M451fuygi/1fexn8tIm86sQ0fKiL/XESuisjvish/fq11LBRuFlX9p6r6Y8CV9+Jjr8/H/4GI/JCITIYXROS/EpF35mP2x0Xkofz8cM7+Rj5nP/daCxaRLxGRd4jI8yLyUyLy2q3XVES+TER+L883/7OIyInvfsfW3PfR+fkPy+f8voj8loj8ua3PXMzreSgivwp84In1ue45+FKfvQ5fkue7p0Tkq7eWdeo8KiIfsbUez4jI119j7CoReYuI/IiI1CIyFZF/mMfyHSLyNdeYy/6G2Fw+F5EgIn8uj9F+HrMPOzH+r9t6PM7nwzwpIl8lIs/mbfji93GsCq9Cypx0++ckEWlE5BjwefvfdQPr9WYR+U4R+WciMgf+lIg8lOebyyLy+yLy32y9v8w/hVclZQ572fxd1YjId+TXnsz3m/zaMGf8DRF5GvjePGe9OY/TbwN//MR6nzbfvVFE/omIfL+IHAJfdAPr/cpEVV/VN+Ax4JPy/YeBfwv8va3XPwd4CBO1PheYAw/m174P+Kp8/38D3gV8+dZr/+11vvNdwCdvPf5h4Gvz/Y8BPh4IwKPAO4Cv3HqvAq/L998MvCnf/1TgGeAjgR3gB0689w3AH83b8cfyez8rv/Zofm/Y+p4vAv5Fvn8BeB74grxe/0V+fDG//vN5mz4YmObH33qdbX8D8J4T4/8rwGuA9wOeBf4N5myaAD8H/Hdb7/8SYA9ogO8A3r712g/m2wz4cOCJrW3YyY+/OG/DRwHPAR9+t4/Bcnvl3bBff958A+97DPjVPMdcyOf7l+XX/pN8jH50Pt7/AfALW58dz+/rLPszgXcCH5aP+W8AfvnE538COAe8P3AZ+NT82ucAf4j9xyrA67Bfi6u8zK8H6ryOR8CH5M/9IPDWfL59ZF7GDZ2Dp332Gtv2aF7/t+T3/9G8/sNcft15NM8fTwFfleeYPeDj8mtvBL4fm8f+b2yO9fm1bwXeBpzH/q/4TV48l70deCR//oOx/y8+OY/b1+Sxq6+1/3jhfP4GoAe+OX/204EFcP69HatyKzfVMidd61zhFs5JJ7f/BtbrzcAB8AnY32Uz4P8Dvim//wOAdwOfkt9f5p9ye1XfKHPY3f676pux67X7gfuAXwa+Jb82zBl/O4/rFJuzfjHvg0eAf0ees7A577T57o1AB3xWfu/0bh9/d+24v9srcLdv+YQ+zieFAj8LnDvl/W8HPjPf/1Lgx/P9dwB/CfjB/Phx4KOvs4w3Ad+T7+9h/5m+9jrv/UrgR7ceX0+o+R62xBHsP+nrTjiYyPF38/3h5LyeUPMFwK+e+Py/BL4o3/954Bu2XvsrwP9zne99Ay/+4+Lztx7/CPCdW4//KvBj11nWubzeZ7FfsjryxLY1zsM2fC7wiyc+/7+yJQKVW7ndqhvv3R8Uf3Hr8bcB35XvfzfwbVuv7eZj/NH8+KX+oPhJ4Eu3Hjvsj+3Xbn3+P9x6/a1sBOOfAv7aNZb5icDTgNt67i3Yf6rDOfihW6/9rRs5B1/qs9dYj2HO2n7/twHffZ33j/MoJjT/+nXe90bgx7ELor8PyNZr4x8R+fFfusZc9iVbj78ReOuJ8f9D4A3X2n+8+EJpyQvn5Gcx8em9GqtyKzfVMidtvXZb5qST23/aeuX7bwa+b+u1jwP+4MTyvg743ny/zD/l9qq+lTlsfO2u/F2F/SD/6VuvfQrwWL7/BqAFJluvv5ssUuXHf5mNUPNS890b2RLQXs23UvpkfJaq7mEH2ocCY9mOiHyhiLw929H2MUVyeP1twCeKyIPYCfFW4BNE5FFMPHj7db7vB4A/ny1jfx74N6r6eP6+DxaRnxAr7znETqprlhGd4CFMVR14fPtFsZKr/zdbzA6AL7vB5Q7LfvzEc49jDpiBp7fuL7DJ70Z5Zuv+8hqPd8FquEXkW8VK0Q6xyRhsO+7D1OTtMdi+/1rg44b9mPfl5wMPvBfrWSjcNGLlfMf59vlbL13v3HnBeaeqx5j1d/u8O43XAn9v63i/iv2KcyPn7SPYf8oneQh4QlXT1nPDXHCtc3B73jjtHHypz16Pk+8fLMynzaPX27aBj8dch9+q+S+GzMk59glezPZzJ/dfyq/f6P67oqr91uNh/9zsWBUKL6DMSbdlTrqR9Ro4+TfKQyfW5esxt/G4vOt89lrPlfmn8IqnzGF37u8qXnwtuP0awGVVXZ3crlPW+7T57uR6vGopQs0Wqvo27FeFbwfIdYf/O/AVWJnPOcy6Jfn978ROwr+KKX+H2An6lzHFMp38jvy538YO2E8DPg8Tbga+E/gd4INU9Qx24MqLFvJinsImgYH3P/H6D2C/FD+iqmeB79parnI6T2In1Tbvj/06cyf5PMx2+EmYEPZofl4we16PWYIHtsfjCeBtqnpu67arql9++1e7UABV/bR8zO2q6j++gY+84LwTkR3gIjd+3j0B/Ncnjvmpqv7yDX72WrXMTwKPiMj2/x3DXDCcg9ebh047B1/qs9fj5PufzPdPm0efwGy21+Ongf8B+FkR2f6j4SmuP78MbM+lJ/ef5M8M+2+BlTsM3KhofLNjVSi8gDIn3ZY56UbWa2B7vngC+P0T67Knqp+eXy/zT6FwgjKH3dG/q05eC26/Bi++ljztuvSl5rtrLe9VSRFqXsx3AJ8sIv8BVqOn2MGOWJjaR554/9swIedt+fHPn3h8PX4A+GvAf4Rl1AzsAYfAsYh8KHCjQsJbgS8SkQ8XkRlme9tmD7iqqisR+VhM9Bi4DCSuf/Hyz4APFpHPEwuo+1wsA+YnbnDdbhV7wBpTv2fYr+QAqGoE/inwRhGZ5bH7wq3P/gS2DV8gFhJaicgfl61wvULhfSWfHxPMYedFZCI3n1b/FuCLReT12X33t4B/paqP5def4XTB4buAr5NNwPlZEfmcG/zu/wP4ahH5GDFel4Xrf4X9gf81+Rx6A/AZWMnnyXPww4H/cmuZ1z0Hb+Cz1+Mb8/s/AqvR/qH8/Gnz6E8AD4rIV4qF4+2JyMdtL1RVvw2bo39WNsHob8XG87yIvB82z5/GW4E/IyL/qYhUWCbOGqvrBnNcfl52Cn4q8B/fwPZea6670bEqvAopc9Idn5MGrrte13n/rwJHYmGc0zwvfKSIDAGcZf4pvCopc9jL5u+qtwDfICL35b+LvgnL9Lse23PWw5ipYeCl5rtCpgg1J1DVy1gQ8Ddl58vfwfJYnsGClX7pxEfehl0U/MJ1Hl+Pt2D/Mf6cqj639fxXYyLKEebm+aFrfPZa6/2TmMj0c1go1c+deMtfAb5ZRI6wk+utW59dAH8T+CUxC9rHn1j2FeDPYv/RX8FC6f7sifW+E3wf5kT6Q+C3sVCrbb4Cc9o8DfwjbIzXAKp6BPxp4C9gCvDTbEKvCoVbxTdg5XpfC/zFfP8bbmZBqvozWM7Aj2C/THwgdvwOvBH4h/mcfVEHM1X9UewY/0Gx8p9/h7n4buS7fxibE34Am4t+DLigqi32B8SnYYF1/wvwhar6O/mjX4HZfJ/G3Infu7XMlzoHr/vZU3gbNt/9LPDtqvrT+fnrzqN5PT45b8fTwO8Bf+oaY/Atebt/RkQuYEF67wF+H/gZ4J+Q55droaq/ix0D/wAbq88APiOPIZhQ/xnAYFV+UZfAU7iZsSq8Oilz0p2dk4Zlv9R6nXx/xP7Oej02xzyHXdidzW8p80/h1UqZw14ef1e9Cfg1LMj832KNX950zSUY/z12zfb7mFP5H22t90vNd4WMqBZnUeGViYj8beABVS2/9hQKhVuKiHw58BdU9YZ+iS4UCoVbRZl/CoVC4ZVPcdQUXjGIyIeKyB/LlsKPxbpy/ejdXq9CoXDvIyIPisgniIgTkQ/BHIZlfikUCredMv8UCoXCq4+brfErFF6O7GHlTg9hpWp/B/g/7+oaFQqFVwo11vbyj2DlAj+IWZQLhULhdlPmn0KhUHiVUUqfCoVCoVAoFAqFQqFQKBReJpTSp0KhUCgUCoVCoVAoFAqFlwlFqCkUCoVCoVAoFAqFQqFQeJlwakbNJ37m/6gSlWreo07oJx6/TlSHa1CFBP25hvZMwK8V1yUW91f0U2F6JeJXCURQD4v7AutzwuGHd+zeN+c/+4C387rJM3z85HF+q72fXzl+HQ/WB7ym2ucoTlmkhj2/pJLIM91ZVqkCYObXfPT0MQAu92fwkthzS1ZaMU8NP/7cR/Erjz2KPDFl+oxQzRW/xtZnGcEJKhAnplG51tY7LHoA1AlxFuh2PWGRCMcd1eVj2D+kf91DrO6riZWACNU8Ir0S5j2I0J0JSITqoKXfqzh6uGJ6JbL7e/t09+2wulijgzSmIAqTyy3SJ44enZIqYfpcDwr9jkMS+FWimvdUzx6TZjX9mYbkhVQ5lpcC7Z5QHylhlagPI65TujMeFSEsIhIVnJC80M/yMtuERJA+ocGhDiQqouCXEYmJVHvUC92eB6A6iqCAgAqoF9uOvH9TECTZU/3UESsb8zDv8YsWRJg/skM3E1YXHa5T9p6IAKRK8KtEvd+SGk8/9dQHLf5wDcGhXkiTCg2CW0dIioaNxhingeOH8tgKSNpsDwrNYaQ6zvtXBPV2W14MqIO9x1dIVPq9Kh8TCQRi7QjznurqgtXDZzh6uGLn6Z7Js8s8bkJqPMkLrlcQ6HYCqRbaHUdYJXbes6I7U3H0/hUkcHGz72MFGqDdE1INYQmuhbBQfKfURwlJEBsbW79Mtuxdh2+VapGQXnG9koJtUz9zJC+EVcJ19hpJ+fmf/lq5yTniZUF6+oNuWY3mpzz0+lu1qPeKn3ry7XflewuFbW7m+L+Vx6574Pfu6bnok93n3PJ68Ts1N9ytua9QuBGudR7czmP2n6cfvqfnIri189Ew/ndqnrjT31conMbJ+edax+WNvOdmud58dKpQI8nO/xQcKoADDUKqPBITQrKLzpjfq/kiOd8AE3QQu8gfbkAlkajCfqpZaYWT/F3qWGnFSgONBhyJRapZpYqJ616wfp36UaBZpYqjNOGwm5BaT4i2XmDCQqoEiW4jNmShQXJGj1YOkm2HRM3bk1fWO8Q5UuVMkFAgqS1TBLxAwm5qF+wkxbd2oazBmaCzSMSJECvB94r0Np44ZxfwqIlbbIQk1MQjbSpSHez+sO5JcRF8a98Fef8EE6MQsX3m7F8kb7sIGkD81nd4saGpHA6IjUODrStANexOAZw998J12exb1ymShnF3SB3y+/NwrvO2+3ysqIIzwUVd3gdJEVVi7UlT2+7hO4XNdw3r4qLa0Kftm47H57BvBCU2AQ2C74YxcyC23+39tj62HYpWHolKWNp7hnVBN8LPeLj7PEbD+A//qokyXWOijusYBS71NjbJ20Crh5TEjq+0Ob/s2MzP6fB9QpLN+kgEh75ApCkUCoVCoVAoFAqFwr3DqUKNW5vjYn0u2AUnILVdXPpVIiw6pE9Ux32+yFXC2oO40dGgwuggkATSOWJ07PkVi9Twy4sPolPPzLVEhMM05an2HPvdjEcmV5m5in8/v59FX/PBu8+y61eAiTT7ccZT3TnecfQAq1gx72qeuHweuVpRHQnVQlEHsYH1nsNNBd/aenUzhyQlzM1x0p6pcJ1S769xawhekCyyaOWR6YT2XGB13jG7HPErZf6ACQt+FfFdwrd2uZ5qj4vKzlMdkpT+zIRwtKb6w6us/8glFq+pqa72hHnH+kJDbBzVccSvE5PHrqDekaoLqBdcVGLj6d9vJ4sCGxHM9RAWML3cUR2uWd0/pZs6VmdNEQkrE0xSEBNVnKCi6ESItdBNhfpYqY8i3a6nb4R6bk6M1XlPrCEF+57mQHBdQjERyNwkQjczd0dYZNEu2fKkTawvNqwvBMLCBLJYm8i1+6QpaLERJJprKE4d8/sDk4PE5HKLW/Wwblm+7iyL+z3NfqJaJFx2r4R5B6rEqUlIYWnCRFjEfLypuU26aMKKCG7dI31i+UBDu+M4+9gKt+xZvWYKQHNljfQpC3GJ0EW0qeguTPGryNl3tqTaE3cq/LzDxUh3piJOXP4OG+vkbdxiBXESUG9juDorLB5M1AeO5nk7LlMFsQYNuiXMCC4oceJwLew+2eHbhGsTceKJE3ufOiE2ti/rw0RYRBOshHxOJvv+QVgqFO4hbvSXiuJUujHel19+hs+WsS4UCreKG5lPbucv2IXCvciN/j9czpUb471xdp18z51whZ0u1ERFNRFWjKUVkN0XQVDvNq4BByTBdYoXcx2kvHT15ihwvRKOHavjhve050eHzMy17PkVlVh5ipeEk5QdM4Hd0OJFWafAcZwwkY6ayMR1VBJZ9DXPr6ZcPdqhO66pWruQTfkC2Q0OC7XSE8lul+0SmcE9kRorG5JecTEhXUIrT9qbmptjcOqojkKQZGeFJEVFSLUbHS2SFHFCjDVEJVVudIPoMHYwuo102oylOeaW2HovG5cQ2Hjak5AqP4oFbus9m8/o+NnBpeFsuEmV7atUQd8ILgj9BFKdnUKiVjYVHf1kcLCY8NJn0WB0UImQvMPV2fHT2fKHkiQA6XV0hAxjIVGplrYPYuPwC8ElHZ064xhnEYaURbHscjKXiuKXPan29DOPXyWkT3ls7ZjU2o9jEBsbs1SZ+NTPwujEkT7hKk+qPLHxeaA0CyXmkPKr/kX7InkQzUKKF1aXKnPKjDsjizhNFmpqSCG7sFA0QZza+TUcZ6my88yEGROFBrcQZDdOtXXcYc4qFRsbilBTKBQKhUKhUCgUCvcMpws1bTJB4iCSak97vs7lLlhOSm15GBrMnUIyR0OYR9bnK7uAjlslLyvYfRyWq4ZfeM0HcrZZ8eDskA+cXeYDmmeYp4ZFajjrlziURaw5ihM+bPYUThK/dvgoy1TzwLk1FbDS55inhi56njvYRd+9Q9MKrs0ZIFOhek6pjxOaL5arwx7XK9VQshPtojwctaQmsL5Q4ddKOO7wqx637OguzGgfmJlTYT6UoCi7j83NtbBbm4jQJagc6z1z2qi3C3bXK3o+oDKxrJHOMkVk4iFnxrioaBAW739mzBpRZ2PnOqU6TtmVpC8QgYaL99jUJqwA1XzzXhK4lNAoYwmN6xW/FsLayqS6maObDu4MG7v2rDlDmn1TA44f8GgQ2jMm8NQH5gDppyZ6TIa8G49l5LhAvd9TH0TmDzXEWqiWuSSns+2tDiJaO7rdQJhHpk8t6c41rC5VhGXEJ3OJ1EduFNIkKtIlZB3BC/2ON8fKWgnLnvD8gvaBPY4fCjQHielziltHXBvp92r6iTfnVErMHzARJaxtG48eqXOGj5WUjUIYmItlN9Dumlg1E7FjSEycDIuIqJJCTcJykbod4eB1gl8KO09ZuZdbC+qV9iz0U0iThHQbJw0KqwsmZFWHJtatzptDy+xUdu5VeT+mZJ/pJ0LMTi4Tiaq8PltiYAG4e3XYhdO52f1xvV84CsatPM6Ls+b2cCfGtfy6evOUX7BvLe/LcV5yTW4fJ+eh2znGP/Xk28s+vEFu1lVW3GincyuO8ztxzpwq1HR7lV1U55IRt0726/yQXVO5UbgZQ02zeANDYGp2U6giKQsXLVzZ32U1s2yas9WSeWq43J/huW4PLwkvifesznHcNczOmuOmzhaQX1y+FoDH15f4nflr+P1nL9IdNEyWOT9G7DuqYwvZ9W3aZJwER/QmiqBQzXv7jBMkJpqrnWWzzIKJHZ3ZUCQpYaHjfbASJ9HsuEhKtUpoUuojl0WMjXvGBAol1Rbsqzng11Yq/yOQGslBwOYYGQQmDUJymDDQKq5NaO3sIjyLMmEezdESbLl+mbZyhoQYsoPE52yTYKG33Y4QJ+buGMSCQVyLEyEmcq5PXkcP3a6YkyM7cdKwLuSyqJAzVtRl545uXEuVA2eCi+b8FpyglR/HKjYed3Fv45bpt8u4Aq6NuZzLtt9FE6VwJhpWOZBXsxNlCP8dMntUTIiRaN8HUGX3jrmtdHx+2KZhX8jm6Ty+uSxMBsHEwoFjLfiluY+6HSFV4FshBbVyp0pRb24aHbNoTMyRmMuiku0L1WE7oV4ly8rxeb+vGV1HrstZO5kwjy9Y30KhUCgUCoVCoVAovLw5VahZXvKElaPaB+kSYW65F66N9Ls17bkaDXYR65cJv+ppz03oZs4yQzqly84Q120ya1wL8akp+7s1XfRMfMcHTc/wjvlDPDa/wOv2LnN/dcS/f/5+rh7O2K3WPDzZZ9evWaaa73vPn2DZV8zbiv39HZrfnVL34DrL+0iNiTS7T1p2jkS1C3mgPRNIwVwRrofqsMvlJR6/aPFPP0984DxHH7hnJSZdBLWQ3+qoRdYd/fkpsfF0Z6sxJ8R1SvPcEuki4WBFmtWsLk3AmbhQH/aE/TXr+6f050J2v2yF+ebcl27mkAjTZ1ZjXkq/U7G8v7aSmVpoDsxpknJeULVO+HXEH7fWvWi3BhHC4cpKfipPnFZ0e3l3Vyai9I2wuiisLqntR6+QxbTq0Man3bPVlJ4xLFo9rC8MwbtCPzUHkMsBySkIsYJ+Zi4cv0qEk2JUFCR6NJdEqRO6XVu/6jjSzzztuV1zq+QORhLVlukAacbj1DpYWUZSmgSkTUyftbI6dSbOJbayerx9XzXP3a9yBzPXWZcl15mTbBC5rAtXoN/1VlaWhRwkl3GhuDaSKsf6nNDPzJnkIkyuKrER1hcw99QK0h7EWUIrBa+oy6Jc75BeqPcd0kO3Z/lJQwA0YuLb9OkV/SzQng2EVSIcb7qZ+bWVe8WJByd2TLabEq3ChvLL3N3ndoz9pzz0+uL4oBzX9yLFsfTy4GbHv/yCfTrluL43uJPOmsK12T5XbqXbuOzLe++4PlWoaQ6s/W9qwuh6SN668MTGyjD8yi5SXZdQ7/ArBU24HNpbH6eti3HF9eZ6aedC6gOLdpff6jxJHfvrKUdrE2/+oDrP1YMdunnFuw8usd/OaKNnHQOXj3bpe0fsPWle4VsTElwWa3Rh4bLWxsjyPrrJxhHheqU5yF2FJn68OE91QC6eARFmT63RIPR7NbFxOei1wnvLYIHsWFFFem+Cyl6D9MnaUWMXzakSk2MU6yTUK2GdxrIaDeYKCUtzmEyuYiG5E9s11vkohzO7TQtsdSaA+LWNr+WtNGOXKFEl7jZoEFYXNm3BUyV0WUiIjZUukV0pEs3toQH6nZxtkz/nVF6QceM6GYWbWMPyoqM5UOoDC0V2vW1XP7E21TpkvzB0b7LOUuSOXKjtO0lYKVoXkWMdRQrLYXH0UxP+wjxuOiINnbb8xpXjV1YaNbh7tAnmAPNb3ZyGTli561U3DbhWaa5aO3pzlCl+HYkTz/qMzx3BNudInOYcGOrcscqe7/YU14PkcRi6XHU7SqryuDo1G08uX5Io9n5v6+TXuYwvDceN4lol5ZydsLSAYd8l+oknVdZO3K/MJaZOiDs17NQ3MBUUCoVCoVAoFAqFQuHlwKlCzeSZJeodcWpvczGZk2TXj511wn5PeH5J3GtIE0+Y94RjZWgN7VdDu6hcElM5XO9pz7hcyuFZHezwG4uH7W0CB0cznEv0Vyb4lfBUc5bL9S4xOjQKaV6N5ULhyOOXjCGwYWkZLUN3p+FifH3WLqgn+xG/StQHLSrC6jUNEqF+PpIaT3d2j/rqivr3niQ+cj/Hr53RN+ZAAQjBymhQpT5cI13ETytS5VlfqHCtMmn77MLpkeSJuCwmCK5NhGPMAeGEvrYckrC0C+7w9ByCY/HI7ljCJLppvz0E06qD6rjDLTvaSzP6xtGe8bnjj5U89VNPt+M4fNRb96CnEt1MWLzGynDixNpQq+Ryngjkkpy+GlwmYgJCtBIfC7g1V9SwD2IDi5mJCpPnEt50KlYXgrmNenlBGdEgJsVJ7pBUSefSDwsAACAASURBVC6PMueMU6gO17jDJTqtSU2gO1PnUi0TMibP2fEo6kZHUvIOGnN/+XmHNhYGnKaefuZGYalaRKRX+h1vpVU58Hh5wZxg06cjcVqZY2WZcDHR7ThWF4T60HKKhm3vdqxb1rivcrByfzblluA29tXC3End2bRplR4UVyW0d2gv0AvSmVjmEMIC3DqHX3dKvd+DQD/1uC5Z2V6vSEzoTqCfCs0Vxc3XSNuj3rN6aEas3Y3PCK9Cbqe6Xn5BfCH3yi8Y9zJ3YoyL8+P2civHt5xzN0Y5lm8ft2Ns77Vfxe9Fboezpuy3a1PceLef23ns3U4X2qlCTaq95X0crCxo96KVm7hWx/KR2Djcbk2aWFZL2s0OhuwKqOZWiuHXCXE5RDcpfsXoZghzIT5X4zrL8Oh2E/1EcUsrA0pXGzqXS22SheCKmpvCLwS/tvDWapFyaYvkIF7LcpEEdc5Mcb0F8K4vNhakO3XZmWFtntUJ7YUJcef9zKGwTITl0HFISY3LHZiEuFMhnTd1CWszjQir18yQqPg2WVeiytHWDj1XjYISuQtVNc9lNlFJ3tGfn47dtURzxooIeBNrwirRzRzH71dTzwN+NRm7KrleR3eIBqHbsRKvFCxLZv6AI1XkMidGkQbB8m88tl6tkCYJAiQVHLl1tM/73ZvI41dCvW/L18CYUTOUm1WLhOuddV+K5l7SYCVIKIRFQuqc5YO5rcj5O3Z0etK0MneRM7GoObJ9nGqXBTN7qwZHEogud2Rq7NglO2CGfJtUZadKspKk5Dci0tD2eghq9m0iBWF9vsL1yu6TJoBJsrGLjc/72dxJKQjrs0KcgnQ2GLEZysqEfkfRaYLsnKFzpChInZA64a8IYblJ/u12wFVQLbJIOMmCizBuv/Q2xkNXrfWlhvZ8bce92jHpV1sWoMJ1uR1/jBSM8kfH7aeM8SuPsk9vH2WOvv2UMX5lUITj20cRrm4/9/oYv6RQ49qIO1jA3ox2d4rvlOooomqtmVPt6GeVlQfVQrvn6BtBw8ZdEJYgy2gOAxg76wy5LGEJqFAdW7bM6pKj39m0LQ5X8wX5EJw7hK524Fu7VYvE9LmObjewPuNwWUhyQxtlsdIZMDfK6ry5KYayLFE/dkRa73ja3cDkINFc7W0M+sT6fEOcbnJl+mlAKnPCkCCsIv00sLwY8J3S7EfrkJXLjfqZEBZKWCl+bSJCddTh+kQ/q6yr0qzadOkZtpm8LetEfdixPjth+RqhW3jrULU0sWDIXInZAdTuZNdKZeJKv7MRuzToKNKoy2VAzgQGUUgzhUqhF1RNjBEFrSHVip7p0P2KyXND5ksWfXIos+siYSFj6ZCK0NU5ZNhb56uwjPR4cwmpoM5cUNLnzJbKEyeBfurHLlbVkdVfDfvBtYM4lbNxGgsTjr3DLy1XaRTCGgv6rXLr85iDnau5jXFscomSAElxayVOhdUZz2Q/Mnl6Tb8TxhbZmkvZJJljq59Ae9ZKm6Qzm1KaKCmB1JBmCTftSSsPvUfavAPqhA8J10JY5LbdAfqZ4mroD03YihO3acudzx3XCak3Qc9FZXXeE3NGU1grk2fX+PWJfu2FQqFQKBQKhUKhUHjZcqpQg0BqPKtHL6BeqBbJSi9mHlETNTS3SIaNMON68ItNi2P10J6rxrDcVJG765jAYp2DTAyIE/tekjltXNwSZlpza4TVJgsEchCvF7ug75XJ1Th29xk3dN6hIqSJJ3lh+lzODJk566Rz0OegW0e9jkyuWLvpfubxDug2Tp2hW5NfZR0lWllTP/Ggys5TLS4qftmTGo9MA5IE38rYlak+6AmLnvbcpq02uWvPcCEuKXf+qR3rPSFMhdQIYamce2fMQgPW4ajddImyDJZNd6IxWyaLIeqVOFHi7uYC3i08biWkWk0gqxTxCXUOUXPO4GB9Plm2SutQr6wuKq4Tc0hhuTPdjgX+1kcR1yb6adjkA3WWY4NYeLCGnGPkzd3k11bKEycB3atpzwTLuVknC9o9spDg5X0BdcL0Sm/jlQU815m4l7zgvMDYhh0TyNrcIrxXmoM4inkSlTOP2+c1OLRyqLcOW9MrlsGUKkeszaVUHZtLrNvzpHwWSYJqbvtE1ASz9X09NIl6tyUPAV0UtHf4vY7JtCUlISWhPZ9IjcOP3cvsuBIdhMlc/laZu8ivUg5w1rEdfKjNIWbbmki1N+dR4YYpvwLeOu7VXzAKhcIrkzK/Fwo3R/n//NZxr7s8CneOU4UazS6U9ozHRXMzpMrR71quR1hZWG6sBN9Zxx9J1iq5WlreyNAeuZ9IvhjP4aq5DXJ9FEd3wOq8p59uXC5htclCkaRUc3NiVMcW4ju0gO5mLgfqOsIiUh332fmQBZBkgceoomFiOa7zNnfKqU38OWrRytMFR1j2hP0V3fkp3cUKSc7cJEM+zHDFnbNdhm5WGgTplXp/ba6QPiHRBCpJDtdad6TUCL5L+EVH/+CEbseZgNBnp03OsxlaTycP/Y7k8iLH5PlIc2XN+nxDt+vwaxMN4sRll0VWLobVzA81l/UgSqoVv9ujCVQFlh7XQ5pYRo14K1XToTxtuSmXQoBowk2/q4RjE9XAulJ1M0esrbTJRx0dPkMobnXco0FY3F9b+dfCyrnijolYoubm6meefmoOLUmCxwKXUcy15XNJGjpmJrncdUo943FlY5DHluzYUQgLE6pSZU6V6dO5U5R3pJCDh1ulWvRjSV2qzInTRHNqdXt+bPctObvHiTlzAPBKmPY8fHGfeVtzuJgQgxJDYmdnxYNnDrk832G5rmG3pw8et/ZWGjWeiFkEjbpx8nTg2oSLJtTgQKNkwc7h2xwEXmXXTqFQKBQKhUKhUCgU7glOFWr6HY9EmDzfQ9LxV36f2xOP+Sliv/C7LtHs525GMogxdjEcFnYBHVaOmMUVNwbTmjMg1kIKjvpwKEfKy3JD15+cMxIcrjfHhjlr0uhCiVNHqmrrxhRzR6o2opUnBUec+tx22xwogxMl7lRWPtIlYuWI983MobBIY2tv16o5M+aWVRIWJv60Zy3fpjrsUS8sH5hZl555ny/unYlFSTfdkKaB5N3oiqGyi/0mOzeOHrZOW82RjXuzb66JvhHWZz2pmhCrTYgtCm5tzpT2jCc2QrsnxAl0u+awCXOxNtWNdSOK863dXyndHmhlrintTfyiTiSvHD+qSC/4hYkmQ7mReixbRnJ2TXYHuQjdnidO3Ci+Ta5GXFS6vco6N61sny8uhRzya524ujM1/dREO9crdafjfmjP1SAwe84EPnK7776x9uBhmRBv4suQhzQIHEP77TjNglabM4Uu5BDmpXV9qvJ+Uy/EqRCnNa614zvWWXR0wxiYcNPtCbGx0icNOfRZFLfw9FF4LF3Eh0hdR5yPpFqYLxrevbpIvw5o5/CzHtf0xPkUbcldoLKrqoFu18rEYi34SqmG0qsIfh2RLtk4dSbQaLNVKlUoFAqFQqFQKBQKhXuC0zNqKguS9QuzB2h2HkgcamryTXV83neWRTMIIi4mC3RVcIO7ITpivVmOJHDriF8HXAfVMuHX+WLTWV5H8tBPBDz0TqyiRc1l4PpNC2f1AgH8etOGmZRQH3LpUnaqiIDaxbc6sRbYipWRBCFO3FgiQ8pCTVR0EJZyDouKWOmSglv3pNo6LVl2iVlvVPJQDe2kc7CtihvbZm/n0qhAt2cdlqpFFlmWJhIMjo6xb3b+jGQhLWEtsePEBJlU2c1txZTo8F2Da0NAvYLfuqKPeaVDQryaYLN21AfV1jbkzlGJTW6KH44Ja9sdKxnbb4sCScdSOb9KUFuLcL+GaplDfRs3unAszyeZQyQp3W5F8tA8by2oTbywHB5bgbyN2fmjsnGTDO6TfseELMnb2Dcyttb2AmGx+cxQ6iZJoWPM8hn2m+Us5W1tIE6VVCla27iEIwvwSa5Cp0LT9DinuJBInSP2ATpnHbZ2E1UVWVaaO21tSvw254FtqyQbH/WDSCq4fPy6PIbJgzgpQk2hUCgUCoVCoVAo3EOcKtTEyoSN7myFWyeqwxZmFWnPjx10mv3EZL8lzgKpNoHCpUQ/M+eMShhFhLE8KFmOTKqF9qynmttz/czR7bJp56xDCZQ5ZpoD6y7U7rrxArafOhb3OcISJvtxfN4vI36drL34ToNb9YRlZ+sRBNdFSCa8aBBSFUgetHG5Y5QFI8dGqObJ2jRn5097NpACTK72uDYxeXadhaqERDeWc5mjAxODvIylWuqFat4RjjtEJ8RGxpIncwQJk+c0dx7K3Z7m0USaicuuIis3s7Be66zVnanop47VJaGfQKrJgbcmoCwfjqizDBe8IlVClx6/cMS9iJv16JWGsBRSpdbNqREU8HMr3XIt5lya6ChWhBVMrlgLaddj311BHJ1Q9u/yfmurXh1bl67ZZcVFpT62z213rep2HOuzwpkneur9jpi7ig0OpH7XW6ldBJ82eUnrcz7nz9iB0J618N9YweyZRDXvUF9t9k2bOPfOlXVxqhwuKmF/DcHh2gq3joTDFakOaO7yVC187g5Wb5VqbUQanDmWUEiNopVCE3FBURVmk5am6rl89Qxx4Uwgq5R+VdEtK6qFw63NkuZXwvRyIqyU6jjmbl6WhQRYSHXjmFRCdeystC4I1TwSIrkFeil9KtxZ7nbd9Xv7/SW34r2jjFfhXuNOHrN3e/57NVDGuHAvcjeyabbnvvd2Hizn2Y1xO/fr6WHCDDk1gkSXhYiNm0adtax2bSQ1HqptJ4KM5SP2RBZqcutjFxVNg2Mm53/4ocxJXxCrYdk3uYQlCjLdBOWqg1QL2ua2yTmrxNwr5pYhOHuuT0hMeaOGBSgkGcWZIX9GVHNZC4TVxhEiScdOTrG2blTVsrNAYW/j4VfJxJ/t0pscRDx8p/SKdBa2q+JyO2WlqwMqQj1P47hJVFxMiMrY5hphLMex12z9UzCRxkKZN2KKekUncVwmPocFi9+EFzuFCNKBiLmpYjPsA9m4O2TLlZOX53ImS/LZaVNtuk0Ntz7vN9fbuGggl5uZ28V1Om7D2PJb834Uv7Vv8nEkg5hn+UipIZfFWYtvE+DMWTIIZGwFTA9OML/s7DiY1basLma3lcetemSxwqWaRE3wJhLGiRvbom+PhyRBtyws6tW6WeXXY3RIpcyqDkTt/dnJpJ2z1t0do0vM9VYiFpbmKkpR8EHGYzV5MZGosueHsSMLhKnySNFpCoVCoVAoFAqFQuGe4VShpj4a+mnbP+pNrJlc7cYOOCTozjWQcheaLo33JQphGcf8GhULiY1Tx/GDFWGtNM/HsZOUb5Xpczkzph4UBoXaroRTtd1O2wQaF2Hn6WRulMacOG6dy1Emtnmi1snHRBkF72jPmwIR5n12KVhmTliYO8XKsZSwckwut4Tnl8QzDXESqA8jyQvdnqc9M3S8snBjv4pMHruCVoF4djq+1u/V9NNANc+dkGaebm/HRCYno9PItYnqOFE/OydNAotHdnIpUI1fJ8Ii4o576qPtMiUL/XVdIqzBRUfSXCoToD9jAo0svJXt+FzGkwJ4JZ7rIQnxsMaR3SETRauETHtcUDjT0iehPa7wx47p09a9q99V+hkcP2x1cKImEqVK6aeKBivLkU6YXhb8mlHsW521kGq/VvxKqQ46cwXtWbjy5IptXrdbESceDdDsR6RPhEUPIqzP16NgaJ2d0lguRWvlVb5xoxtpOZngWqXOLavjxNPtzsb95NqEdJV1/Jp6+ks17UfsMX0uMnl6jj9aEfaVNKuJjad9dEI/heoYwlKojkygWl3K3bHURC5deuLKE6mIZx2VTzhRYp1wxx63FtLExsW3Jl75pYk0rh9KwjzSJ5r9jn4axhBqRHKHMLFjZIk5hJocNL0stU+FwmkMv4Lci06R8otXofDy4Frn4qvxF+x7cR4tFF5pXOs8vFm38b04L93L677NqUKN6yxsNTYmkJDzLqRLOLKLILebdj3QmyNCgKFdslrWsIURy1ZAsLfXXNRNlx7sYnm0AAzOmNH9Qu5aZHctO8TElVRZyKvleiTr6OSyKJDdJjg3OirG1t05EHnojDSINKJWriUx5+/kTkxIzgFJSvLWhlqDIJ1u3BopQcruHYC8DZLyOPQJnVnQroXOyljm5TS3/1bLOJGYnSWyuVnujn3v6CwhO35yQLNtcxZlQg6UbXMbKWfODxIwdHKKFl6LAw1mHxIVcz0lxVUJwW1cOmMGDKRaNx2xxISeVCtpksArCWeaRXZN+WifTTXQWQ4NYGLa6EzJ+04sGHjs8NTH3JLaytrIGTHS8wLXk/RpbEst0XJb1OX9NxxTSfP25uykLh/jzsSzVLnxuIqN2PKijMExokNmjAmGxLwuMpSbydg1S7rNedWvA/N1TVKxsqdhvw6dooZjMW1n1ORuTzg0bu3v3EnLRc25SDkzaGAIAS8UCoVCoVAoFAqFwj3BqUJNddSRGs/6bI13+eIwl+AkwOUgXStXseDSOHFjPgtiGSEuKpPBwVA7VITmMCFxyC8xwSE21r67PlbCOuFXdsHt+iyUJHMJHD9c5y49FrLbXF2zvtCwfsDBPtQHSqotqyMsowUEVx4Nzi7uHVRDQHK+SK/3+5xZErPLIpBy6dbqvhp3thqFANdZqZGzChnLrllH/NyuxruHzttYjcHL1io5LCIpCN2eZckMrc0RaHL3qeMHAwisLl6wVtbzTTaOeqGf+rFNdD+xYOH6OI9V0ixOYfkotbXhJli5lzbJxJ9OTIyZJhMe1i6XpinaZFfH3Jlwc2xdlpK3gNvpoTlGFg+l0d00Oq6CmjBUJyQkSGKlPL11ijp+tEd6Yfcxj+tMgPIra7ve7jmWlxrL41npWAYXKxkFucEZlUiwU5FyxyXLAYokccTK4deCayN941mfC/h17kj23Aq36mgvmUupPupwfUL6OotP1l7dXFdCnDokws4z5gpbX5zQ7Vo3qvo44dZKtyPEqXU1A4hTEyGrQ0cKSr9nTh+3dqMYmFY184MKnUXcpEfuzwrNH06p5jKKbLEBROinVm41BBer8+M4AYgK1VFuSz+147w6aHF9oj3fEEtGTaFwQ9zLzpo7QRmXQmHD9X6pfV/Ok1fKr8C3izIuhcK1ud68876cMyf/Jirn3wu5E+Pykhk1lj9iQklqvGWxAFo5YuNeIFyQNIfxmrMFwA+/8meXzOh4iEN+ywvzToayJtnqUjR0ERped51unsvlVABhCX58bZNZg2p20ORW2QKuz6IFg6NhkycjacjfMffMICK5TreybWxcRtcOgyNERreOehCvSMforBjKnNQNjqTsOhpyeBJjx6Khi5KNlQUSD8+NTo08fhpAkVEgAzbOF5XszpGN2+JExgwOs/NkUUUDqLOyJXMEycbhIUqq0/hRyJ8XG0sJCReU1MlmG52C19Fxo96ECOu4lY+NvM+THwSxXDqkW46qfD/WbpN/NBw3421wbQ1uLyv1Gh1S2S2lXkiSXTxDRzJVpEtIpeM+9uuUnTMmrqWcEWMZM7oZ1+GYHN0wWfiB3KmJUazxa6GvhdQ7nKTR6UMyAVCiuXLsuMjjsn22Ss5yyueTeiE2WYzMotOYnbPVIKxQKBQKhUKhUCgUCi9vTm/PnQWQyZWOVDuWl+rxYjc2jm4mzJ7pmT69yEGtlv0SG8tq8V0iPL8EoD8/RZ3glxGpTeRxrVIdWMeotjLng2917P4TJ9Y1yrdZVMkX6jtPdaiDbi8QK+HokYbmMHLhNw6JOxXdmQrXWp4L+aI8ZWdGv+tRsa44rkv4eYcGR7dXWfegVY8Ga0PuV0pY9nS7gW7Hj6LJkMUT5qYsuC6iTljd1yAR6v0WrRztmWBdmVZ+HFMN5pBQYSxJEYVq3uOy6wgBv0yk2rG64G1c1taliiRIDw6lumqdrbrdQGyEdtcRm3xBL1sOl16Q1lE9n3NlzlguEHGTgiuznqrp6Z6eEeZC92BLaCL9fo1bO/zShKvujJKClQxRJVwTEac4UfrOo51DvOJcIonVvWmVS+J6yzRqz5ljJl7okOOARMfkqrL3B2vW5yuWFx3TK4nJ1dbGTIR+Zk6ioU338myNehPPfJtwbUSSUg/ldNNArJ2FEmdnVJyEUdyRpKzua6ycKJpgKH3Oy3n+COlm+DOVZb4ct/R7Ne3ZYOJN7rblemWyr/Qr8veAX5njKE5sV1bHjm43oQ+uSFHQzuGOA+FY8MceXZuKooDvh8+Qc3tMeAyLRKqF9Z7DtzB5PqKB0U0kEVbnPbEJlmnTKVAhMWRRsDhqCneW8uvLnaOMdaHw0txKt9ztcNK8kijOxELh2twOh8rtcNK8EniluIFeQqjZ/BSvYmVGm2Bha7Fsob5+zAsBxi5HKTnLhUkJaRPihjKnIT9F0NptZZAwvi4hZ2/0OZg4qQUMi7k9AAuMFRMnYi1o49HKbS5MHaiYKDI4MIblW8tih9QesltCFAi2PrES3NrcFSRAbV1cp9ZNSHL+iYJ6N3a5MrdJdvjMo4kAuWxpyLextuFb+SVqYoT6F5a4oFb6JHETrmzuJFAdgpMj7G4JENHKcFxvrctTncuZcv4MYqUyqtlJlLCw29bRizfBQoHO2UfWzlw1LlcyzZKVTeXyJh821ifnlURCkxDVjgfxCXVu426CsROVLD1+KWNrbtclC79dW+cmcuculzZZNfb57JKJil/mTmTZPdPPHGGV8AsdnTjJg9RCtxdwvR+PZ1EFHXKNdFy27kzRaWX7WR1pGlCx401iFj40l/flMR/OpO1cGURzeZgQ134sBRtKm6x0TjaOsiG7u7cuVr61lud+FRF1uGjtw4fv9NjxaK4dj+8Yhckhu4a+BNQUCoVCoVAoFAqFwr3EqUJNu+fHvJlqnpj9wRFaefrdmjCPNNhr7YXJeLHponXOiVNPnIDrGty6J+wvUO/pLs1yx6jcSriqc3ciGUOFLbfGskHCPFJfWSBdpL1/l9g42j1vbobLa9qzNXHiWavDPTgd113yRW0/88TGjSU4gF1kN4JGIVUV6mTMjHFdZd2ccuch15l7xreWA+LXkfWFmliLCVfJOgelXM6UvKDnAvVBz/TdV9Dg0WlNagJxVlEfdpCUNPEmDuUL75RdRpIUQeh3PH6V2HnXIXGvYfmgdSsKi5jzgcCvI37Rovc39BMx98Uaps8nkgfXevqZsD6vuT12Fmd6QYKJbdILfuXQTlAXcK0NUtg3caI+tMfr84k0S8zumyNibaadS3if6HtP33lC1eMaZXnUoKuA7PSEOtItwwvKb4aSqunjHr+yTKFqnpAuUh3mUrtogpg/7nGLNe44QHC0F6akSqgPetsvRyvUe9r7prR7nvkDnslVYfLsir4P1kq7FvqJuYnUwfRqMlfUOpdBpUHQEfqJJz5yhlQJ7Z4JTN2us05cV9uclaSs75vQ7vksxGguRcptykcxM4tECeqnq81jtddcC74TUmX7Z3BYuQ7CWqkWlk9UX1mRpoFulsVEsVyksIq4dcSteguwBtb37+RjJ+bcpPV4jBUKhcLNUH4ZLxRe/ItsOS/uHPfqr+GFwu3i5PxTzpE7x5106Zze9Sk7QQYhZUBUSd7lrkP2XMrCSzW34Fu/zE4LhwX5NtbyOAVzZ7jI6JZx3sJth842/cSWNXTB6feslfbgGhmcLSj4NlEfZmdBzrwZOjWpM9eJxLTJfcn0U4fWMpYg+TaZW0bMrVEtzEGTahOFquOIX/a4tkdiBYiF/Ea1AFcnFug7dGtKStqbkqYV/U6VRSjB9Q7prXTMHmvO01GLOBkyaxIgQtxr0NrKxDTA+kIYS2/6qSfV07EEaAyr9WyVBckm4kdMnNGhdClf9KvTHFJrQoOF8ZJdLCYiaLCL/a7zOKe4HC6dkkNECVVEVYjRIc5ae4cqEqpI10RUHG7pkU7wK8ylk50fvrXjbH1pkjN8cjZLVORMTZoMdhXodzypktwRyqHnTZzz60glMLlqQb/q7T2+1c2+X9kY+XXaOJdypI/l/Ng6uVVExOHXOjpThhwY8n5x60SNiZnJ5XK0BJDzYiZWdiZJIIJrxcrQqq0smm5wE9mBWR1jYtxax7we9cL6ftvG+ihZtk/tkPyZOA30O1UORdbRdSQxH/eVHztyFQqFQqFQKBQKhULh5c+pQo1fJQtQPZPdCDkslwRpkl0f6zSKBt1M8GslLBP++RZJie78lDRxaGgsOHZqLa19m/DLRH3QWulQEIh2Id2eqYgTN4b1Lh6akDw0+1ZKFJZ2USpqZSE7T7ZjS2XXJvw6Ehu7oK+Oe9y6t/IsZ4HBWjlW55ux7XJYKmcei1mAsovwydocCv1OIBx3+HmLrDqIEXd+gquF6rhDorK8rwZg9szagmiTkirP6sFdul3H6rzDdTnbJAtJQ3nWkMlTHfVIVPod6/pk5WOwur/B5Y5Rq0sVxw85JleU2eWe9flAP3WEVe6UFKx0p5+4PMZDCZXtTx1ab0+jleD01gErVUBQ1Cl+HaiOTLBJHuaPKGmiY8vubl4jVWIya0nJoQohJJqqY7muib23Vt5VYjptqUMkJaGrAv75gF8I9ZGtU6rs32qe6HYcxw9UuVTMHCW+hW5vCIpOoLC4ZMKD6zxRYX3WEdbK7ruOCfuJ5lln5Wu1x0Vz6gxUhy1u2RN369HBhIDm8Oh+asdcfZTwXcK3bgwzVhHixI9hxdVxhxwo3c4OKdj6ohCjCZv9WVNa/LGVjvlVDqjuc0jw/8/emzXJkVxZmt/VxczcwyMCQCaZWWTVVPXLvI1I/4v5zf0jRqQf5qVHZkq6FhbJXADE4ouZqeqdh6tqHiC7UCwySQKZekRCgIzF3UzNPJB6/NzvlKth42e7D+7+KRGOifmLWCvaIU+O41eO+Ayv/+9H8mFg+eVowOezcHkTubyye8Cv1zSS1Fru9x4jQwAAIABJREFUvB8+gC53df0l9bnPBn9O+nOsdU8MdP3Y9MfwU3qS5o/Tn8Kq6f9mdP2Y9afwU3qS5j+nH4JV89dc848aNc3YmN5l3Kq26QtWES1ZGd7XyIsY/BRspGPdB2PSZAPdaoDw/OKBKyPGBaEEB40dUxM3LivuKZn54m3EqDUYFalJDGGDw5ahbrjFIhJSrqmCdBNg54nPK/60GgsmOfw81JNkS12oc5ZWqO1PrQbbn8xE0hhgDDZWkpU8makyPCSsRjkgo41LlcpMgTrisuj2IS+4IQ2QXIIgXnCr1V5fkxF2HZphMb4zYyftzDTbwLarbo1PLl2vhf2MJYf8Iqw3jsvPrTLbrbK1C1nNOluKqcFxJQuyYsaOKJoVVdCd4Fwh+EIujtNlwPvC/ubCsgRKdpwvkbMOpDmgizNcUdTaxAThaLDc5a4ygXJjszTDqd2IEJ+UcMlMg2xjZlKwmuxVt9TNZkqINS6Fkij1vtLoKARLMwVXG6DYxpfic62QH30dlZPKJrreujaW5zbeUDxmXLLjb9XoblX8s0OKMLyTD1rMXAJ/gXhU4yqFCg6eLbWWd367L0QtWROPEC4FjQ5UGZ5yTYoZ/DhcGoT7RfrH2WurcZm6urq6urq6urq6urq6Pg993KgJZgTsf3WiRM/yeqBU3sf4LjF8c6TsI3kfCaeMX4Q8OtKN4OeAFGW+d9sIErV6WqXxacQqv6vSzpMnYXybCM8L692ADo74nEDZTB8pFcJaN6F5lG3sB9y1hrnAcudJkzC8n3GPJzR4iIF4nAzOmq7wY/VC2gmuNjvl0ZFHYQgOKYVyM1IGT3heQJXzLw+UKOz/+QgOnv/hgDoIF7fBkgHi2ZqJWouUm7ON7qhSRmvmWW/sUsTHta69s8mkrJRRmG894VK4+W1mvXGsN4JfIJ4LbqlV5DRDpjZdBRv/mb61xMf+tyunn0c0eEt2rNcK6FLbotxK5RI1o8bGdkRBsQanjLVke184TDPvjzvm55HD6xNf3T7zzdOB8yWyHgdYHTI7XLERKxuRs+cdH83Qurx2dUzpymdZ91ejxsajCuFxtvGewbHeWjJrfLuCKnlfTTsvGyfJLRl3zjAFVDw5Ohh9hVJDONb00+CgKPE5UaKzdqfm9yQjLm9tZ4PdE+21ER8TQ1FOX4/kwZ7bz8Lw4JAE+9/YyNp6kK0ZfXhSpreF+c5eK+FsRkwexUDUtXK7NUyNj9lG36JHFIb3a32B2n01HF+MirX0VIVlb9Dqrq6/onqy5i+nH/Jdo66uH6v+kLRH/331w+g/k6zpa971U9J/Ju3R/33+0/THJGs+hf93/fjo0zmDE85f75GidazIEiRSlPRqIt0E8s7Vd/jr17LiLxZD2H3vtw2/pVYspTO+z1v1cd5F1kMgHhPj2wxiG9Y8efJo5o+o1rERG0NpjT5uLQxPVo+dB1eTBEJYC+6SCVGQ7CjRI4cJOc2wmvHDC0NHw3UUqaUfwrkQnwwmXPaDtVMFYf75nuKFcDLDJd2Pm/EktanIkim1oaduvK3W3Fvy5kXLEFg9NwUzHAQkla2NqnFzXDKILDeONFraA63nLbX5qiZNRKGidKxdSGB+HVAP4/etdYvKoampn/M1+XF5o+S9kve16cs3B8D+mN9NLFMmZ0dKHj9m5jnwq3f35GxpoPF2RlVYHkZYq/G0gMuW5MnxxfjXCuGsW8JIsphpVCHEae+ByXhAoaanBOY30RqQLpnihbxzMBfcCmX05MkSNGUU/Lmmb27sWkE1RAoQhPNd2D7XkjFSLAHlcrm2d2EjUerh8rPBqsYHO554soSLS5bMChf7GT+3+7+mz14Yan6xkbjGXWrcInUNoGPGy3IfbTFqW5erI3RuNsNGsm4spGY2hVPpMOGuT0afwj96PxX9Mf8z0tX1U9OfMnLQ9Z9T/73f1fW/1g8xktn1h+lzM44/atSEcyZPnvMXHr8oN7/O+NOKf7qQ73fMb0bS3lli5akQ5kx8XJDzWqughaEoGhzpEDdYsFtheFhwl4ScZkr01vBzToTfPpC/uCXdDuRRSFOtvVbYvU1mJLjaXiS2uY3fnShDQA4DeedJO4cc1RqRvOCSt7TFfsCfZiTlyvAw2Os1ffJihEsgnBP+eUGjbfjbiNblTSBH4dX/uODmxOnvbsmTWNNSNX/aCIqkBjMW8MI6vWjvaS0/WRm/T5AK85sb2/A/ZRu3mtjMFhtxKpu5UrIdex7suVsKpFQGyjZ6lWy95tpitPu+sO6E9WCjN+rBH5VwrlBdD+lW0dcLPigiShwSqsK6evIl4L+PlMVx8QYW9iGzzoH1yeOmhI+Zu5sLU0j8avEUWkrFVeAzVrNezCQKs/FkNLCNQbFK5e7UqvFQ7wdnKSUVrg1gawFHNbAc/lwssVUTMFvdeimUAHmwUTfJSjhb6uX8uq7POzPg3FK2VihZC25O+FDH9Lyt7/m1Pb6fjRHjzxm/FKZvcq0Mt+MOpzqeV5NWxVeuTQUHNyNPso14AaRd2KrMSxDyvvWat3uMWmderP0pFdgFsheWgz3vzeXDUbuurq6urq6urq6urq6uT1sfNWrWW6sUjufasgTkm8jyerSK7dEMlHjSbfymRIdIRHIBEdZXo22YGz8lV9PgzUg8euKSKJNnvjdujDvtWF6NLPe2SfUrSG3pCadsI1C3YUuOlMGxvt7V0ZRiqZBkG2t1riZznDFfVFl/+XNrBCpaTQkbD4pnO648WioGNdZOjo5wzvjzShnMrInPBR+Fsgto9BsXZjqV2qRkiY1t5KS2OEkqxhw5Wa03QNobF+fy86mOhklde39NV6xKqJv4Ei29NDxd2SQNeNtqyOOxgCrLncFvp+9XSpCaqKmpG2MDM7xVhqOy3Ajr3hq5SjDzJD9FCrUp6h5L7zxFg9weMsSCs1uAnB26OmRxFA2U1fPdEhCnlHOAJPijJ5xh+q4e+3o1xeDKyWnGnEs2DiUF4jEjGTM+orDcWMoqnAt+tURJyUI8m5Eyvw6ESyEcMyUGM3n2loiKp0I8GiwbrElKndh9nK15qYF81dm1DOdCeBbWfSDtrRHKLbrBmP1q5+FWM038JVGip0yetLf7u51PHsyMmh4K8TGZqafKchspg92PbXwLAQYjQoeTXf+0dzVBBogZQI2tFI6J4Zw281HFXiNdXZ+SPtVxgx/yHfNPJcnSUwBdXX+a/pKvoU/hHdyurq6/jv6Q0ae/5O+Iv1ZJwV/iHD+X37UfNWry1EZTSq1/VtIUmF9Vrow2SK7VVIsq6mszFKDeNpUt2SHFUiFWwe2QEggV4GsNTI6yH0g3nnVvbT6tiltS3bhyHaECG/VIN6G2SCXQgs9lGx1SV5MlwRIUx7/xlAi7b4tBdAM4rRDfmn5ozT7qjaHj54KsGeccRcy4KWsFIbfm6GTjSyoGW6Yeo3oDJ/tFcSrXlM0Lo6Z4S4agbOZFGpxt1tc6cnbJdnyDJVLiuVabL6XWTRs4WZ0QH5d6/cwciN+d0CmQd548WP15ux7DUdn/eib//chyJ9bu5e183NnV5ItSbmzcx52dVanfZMTXGSsVVKlNUoLg0Kxw9mgNP5GFeBTCCcanvB077sorstGta2U65dqK5eZ6j92Y6ZAHDNb7XBk9SXHY/ZUmgya7pAyzRXfUmwmnDsYHawbzx9XMxNudJajma6oFseMpUUijICq4xVNG+3y42PFom4SqZpPLalXZa8aJ1FE8NqaQFCVHIY+WignHZEkYgLtIjoIPDtWCS8XG3uox+Ysl3NJOzAysvCaJV0cwPinuvBKLMW2Wu7i9/rq6urq6urq6urq6uro+fX3UqIlPuQJ2a03xarXLqK8bUsWfC+GSbbyiqI0zlcLl6xszCmbFX3TbfPs5VyBrYL1x6N/fgsLhVwn1wvmrCck25rSp+gHLK2N0+FlRr6x7Z2mKY+WHONvAqoDuzLRwSRkeEunGDJq7f6p8GqnjJIMlM4Z3F3AOtwzkyQym+FyIDwt5Fzj/7W01F2xsykwe2wCHY20Lqk1Nbi2WXIlCeM5W5Txn3LxSdtEAwpU9s//NDMD556ONIJ0NXOubF+aMU+MqZ0SSwmDP7bGNet55ihfSjaN4QWVA1MaFJCvx9c7W7ZwBz3rjiEdl/02u3BzH+L4Qzsrxa896Ww2ADGWs1dxVOihkcO8DZV/w08VQOcVRiuAWgRXg2ioVTvXPsxkpy43DjYJfzEwJ51JHjaQaIZZ+Er2OezVjqwSpzWCAQhodjDDfe/Jg41wuWYvS5ZVnvtuRR0u9qBOcF+PGSB0taiN0WQkna9zKk6WWxvfrtv6N8+JmJWrZjmt4ttElv7I1eql3nH95sCTQKeGyXUyXzPQcMcbO+HbGP82k1zvyrlbd18arPDrWgyWi/Dnj5kz49gl3v2e5D/hTJpyMy6PBob7eK4MHHSiT3RPAxkPq6ur6X+uvVR/7p9TXdnV1ff76S7yr+6m8g93V1fVp64eoof6Pft98LhDfT0UfNWrcUtAgyOi2JprWKiPFRkTcamNG1NEjWTNSipkdk2M6p2qi1HGbpIivY0dBWG888ZiJjyvrfWTdeeJzwc2WtoDKTXFXUyWspcJkZatWhuvYECIUb2Mu/mSJhbSzxMrwuCJJWQ8BsFEhVJE5gy+WmqhjS24t+ONMujFTyUZS6nPUESdbJzOVUm1ucquNxIjWNMjzgiyrfTiHeGfJowD+uEApuDcD2V/TE1pqGmOsoZU6Y9QgyuqwkSpVcj1XY9WY2dHgzWCVz22cpnFl/aoMD6sxXAa3tVKdv3S15rxybIOisUF+BfUG+vWLoIMgouiLWiEDGdvP+4tY0ui5GS61scvXmvWmojiti+ocJdRxrvLhPaciG5C3qQGU82iJmfW2Pa9Son3uemz2uAZ9lq39yVJOZiIWb01MrIo7W0W8W2x0rgTZzCNr7bK/hwZwLmwQYEv0WK24k0KsZpUkM51cNuaN5GzXbnSEk9W+p73fquGlgJ9rxfeyImu+Pu/zaqN9o403tVE+Hex41bW2rq6urq6urq6urq6urq7PRR8ffRoNehufEgikfbQK7cFGeeIxkSbPejvWhhxwh8ESJ6sSi0F0dbi27LjKtkmTJRuGh0QZHKdfTPi5ML7PzPcGML7/xwvh4cz5b2/Jo2N6u0C5Jmvik21sKdRacG8skacVXxk5bk6QbTwL55jrz4azjQxND4DC+e9uK6TXNsfhXDf1+wG/FsZ3yUwGdx3P8bOla/xsiRqtm+MG9W1jUOUXh99b2/Vg6xgPH9aY+4vBa0s0iHIbs4kPmTJ4e7wom+GQJm+NPxdFin2twWl335mBVOrmvZkWw5OxT84/H2pCxaqy/VxIk5D2ZnJoVPSQcKFQFg+lzfeYWSKLMH+3Q4rUMSXZkjiSrenIrde18NXYC5dqNtXU0Hpro2vhlHFzIdQ6bpcKafJWk35nJpR6u15mTgiXL+qx1BGttLPkynqw88i3GVks3TO8t9ErlxyhwoBFYfdNwl8S/nlGh0CeKpfo4Uy52zG/juTJkYdWA68b28hXNpPBe0GDQ1IxMLITLl8OGwTZr2a6uKTk4ki7AOwrb0k/qNKWogy1vnx+FVjuPPH2q82gK1FYbwfi00L47plytyPvA/PrSBqjGYRZCc8Z13rBu7q6gD8twfLneIenJ2u6un5a+kszH/7Qx+jvYHd1/fT0Q7z+f8jfIX9MlfaPVR81ajQ4Szss1qhTxhcJhHJtk7HxkFrtrM0owJIqDdr7Ih0DNmrS0hLqra3HrYKUYlyZWBM6cx2BErbkTktU+NXGhDTIxpfRmjJRan21CNTNPaWCagHKdbRGnY0NbSmOXMdtWkVyuTYnaU3x4IQWT9keszY56QtmiXohezNvWk05ajDZHAXZGQS21O9pH60hyx5LtjUowxXKrCKUAfxcx9KSs2RKrXT2c7bv2VtFujVgGdumjGKQZX9l6TTeSjOaUJDWsJXkelIC6rSO5bR1k63NqY08SbKPFumwVE9dSyBXU6sEcElq7fqH91erW8+D/dnWpFTOS7pR1Kn9vIMyaB0DgnxT4CZRvCVU8uhxyUweUdlqz7dmp1TAFftcrchu11C93ZOWahJKAl+qOZlfpH585dkktXap0dn90RqfKrNGMltTV2PsqADhxX2YFJH6fV6QvdvWskGOKQU5XZDdANnb/elBC2g11loKq6urq6urq6urq6urq+vT10eNmqXWOQcv20Y0Pid2/zpTdoF0iIRLZqgclzx6hnczbk6sr3eoE4bvjlBg/XIPAv64IkXZZ2V9PXH8RbQN/6qknbXqxJMyvs827nS/Y3hY0aNYRbZYGgYAJ6w7x+WVJ54Ku+9Wq1TOStl7S2NMZuAMD4n4nIhPdiJl8HWz78hRWO6E4Um5+/+O1w26E7SNFY1+W5c2arXcWZvQujeGzO6bFZy1C9kD8CEMORdrkpoqW6eClcHgwJaiWM1Quo+wQjjZua63kbxzLAfH+JgZ3yaWV2GD5kIF8DYYLrDe2HpJNo7O9N2C5IK7JNL9iH4xMJ4K4ZhYbwPrrceflfFtgwoLlzCgQQknG60pUwU6ezNkjKliH+Ek+LOxaPyim2FlIzhmaqjA+YvKbGkprGQJotQMJSesB79xhBoQuni4fGHmVBmgeKUEM2byPl9NLrHPA5AFd3LEJ1fXpNZ/J2H3jRlHz78Y8Evk8C98YEymLw7ghPic8IvDXxzLrSPthPEhEx8Ty6tI8cL0zkaSljtLSMWnjN/Go4oBqAdH2vktdRWOGb8We02smfPfHkg7x/7XM5ILly8n1MP4YCwhPxe7325DXRcHzkFK5F1keTUwvlvZ/TaTDgYRzpOnTet1df3U9aklabq6un5a+tSSNF1dXT9dfWpJmq7f18cTNbVZCWfv0EsxHo27LOjoDeq6ClT2h6RSjQ3bFIvqVkO9pVGih9Xqrl1NyNiTXZ9T1Bp18BWOCmZexJZYqD9TDZMGim3pnRIdpbZPtWTKltRYs/28FxC3HVtLw9AaePx1d7ulaK6ncv2LXJ//5fdv59yYKk4pXNelJU1KtONjMzIEcXpNQbRz3dI1XNf25fG1r4lc4bEtmSO12WrJdn6pIEvBX6z9yK21GUlsVMnP1Kr1mohBcLV+WsOL5A824tTW3S3VpLkofrVmJkvo1PtDG2+nncOHn8vTdZ2bmbGlilxl2wyQpzqa5WzcCV+fpykqfkpoFsrqt+dSV9NdUSg14dSSTCVY9XfjASmCjNVgSgWple4usyWHJJdtnRuzhvjhPecqG0hyQVJN2viXya7KrVnz9Xo6Sy+JKuRa152qAVeNq8bEUS8wjZVLU793yXZCImh4cT92dXV1dXV1dXV1dXV1ffL6qFHjF93MFrcWwimZGTNG8s7SHGnnkNeR+Jzx58z564k8CuP7jFsKy89vDBp88OQorPuBeFZufm1PffuvM8ttZL63Ou5YG5OWO084GxQ27xq/xYydVGunx7eLwV5XjyjksaZkBoefjbkyXrJttlersLZNbCGeFsoQWA83+AX231mTT7of65hMfYz280Wv41vOxqriU7aNvwTblCdze3wQymBJGxsJUvLgyaOwe5sZ3qfNuGosmvXgSSOUn8XKyDHGSToILkE4ZfysBG9jUstdRBIMj2YW5KkZEo0CbA1SeXIcvw6Es2N4NyPBUUaPuyT2//NMPoykW+MKxaOtfcr8Hog3HCsgeBHyoKTbUg0DwV+M/RKflXhq4GFFxZnZU00FV2vJ48mMjXi0Yy/R4LuX1xXYvFpteDgX0uRqnbsdT9prTdQY5JhDdZBO1dBz4MfM128eebqMnM8D6+JYs5lNbfQMrDJbvbL/tvJ5boJdixuHy5ZmklTwWJKlDEJ8zgwPSrhkqNcvR8FFwa3K8JhQgeU+2D36fqUEx+VnE+GUGd5eKGOwpEvlKrk145IxelA4/mJEFG7+5YzkQjoM9hq6DZTBeDfDsRCfEukmsvzvPyPvzKjJO1uH9S6QBzOGOk2466euzyVJ01k1XV0/Lv05fn/8OX8/9HfHu7p+vPohWp1+97H+nL8rOqvmP2p9Sh8mIVCgVgCrWEWyFKsnpujGN1GxTbU6M1S0JVawRERSYb2xjWwbVfKL4mcb78ijgVtbLfemFhTR6+ZTshLmCuANdeM8CH6px/Yi1aMi5F2sxk1Go9/Au241Jom17TjKIEhxuGRA19ag02qjwZI7KgavBeORtM178b+TYniJeFGFpDWU4g2lUxQRubYHbVDZ66hVa95qMNnWPqReNqDu9nTNXFosJePq19QLZfT2XKqUnY1iUT40VEqw9Q9Hh3qrI78yfKxZyi2Cv0A4wfBo17CNYYGNs4nayJKtv51WM2zaurTzbJ8XvY5MlWj8Ig2VExMgj4ruMsTCtF/JybFevP3gUIhDYgyJJ0ZytqiNBqWIGUvWXGXtUCXXOneRmlp6mYyqh1cTLbq+YNY4+/52z33A9eF6324NWvW1VKKv59KSN/V65GjflysL6eVt79oYXuPq1NeC1GOpNfFt7bWlf1JN/nRGTVdXV1dXV1dXV1dX12ejjxo14Zi3zeBm0jhHGWzzOzwkwnHFnRbyYSTvAv5ccKtw/sKjDm7/eSHMpZo9jrMPlD08/yJY69OTjeDsv1lw54SbE+luIu094ZSRXFCJVhPeAMDP9nhlMBDv/rdLbZ/ydYRF0KMgazFTabQGIrJy/mrcRkSkWGrCLwV/Tmh0rIewpXLUKSXEjZsSnxL+km0kyztOf2OskP235tQcv47bWIrLejWL6mbZVbhu8Y54WpDziu7iVv2slYeCGF9G1Nan1S4bRJgK17WL57Ser8eYKM0AUeMBeZEPwM159Myvohk2ftoSIeNjIR6zGRLb6I7y+n/YJv/8hdQGMEu0uMXhLzC9U2PmfLeQbgJ5d51BCg+WgJpf+c3QUMeWpEk7txmA4VyIz2xGWwkw3zmWe9manFQg3xbkbuGrLx85DAu38cLTOvGP6Ut8KLy5PzL4TJDCsgb03YC4ytYZCy5ma7BKgkvWALYcHCHWhI/Wxi+q4THbOrol4y+e889H5nvH9E4I58J8K+RJGB/NZGntZuFozlgZHH7ODP92It2OXL4at+vTzJ3LFwO8GRgeE+GSyWeDdpfRA54yug0eLFkZH+yeSPsrNyk+WYKt3SfDg92TbfSt68etP/Rdhs8hqfFDzkz/qfopvnvT1dX1oT6V3wOfw+/vrq5PSX/oa+ZTeY1/TD9E4vaHOs//9m///bNYsx+DPp6oyaWO5zg0gsFATHlwNpLkhSBiMOGpNdZYOsYYIq6hZHCrMtZRHZeujA192aDkGselcTxegHlXS8g05kb7U2rKxVIE1dDJ18+R6vcG21yXZGZAa7CyTbMdgz8XKI4S6mPkuqMWpcSWznC1BcgMhfXgjY0zVP6KQilS24wwwybbmtgIlRkmzldYsZNtk90+8iRItnrxD5g4tVHI0hLXpERLpLi1bCyZPNnlbQ1GLTnSNu/qrJ0pFBsz8qdEHqwJyq2Cvqh1Dmd9waWBeMQSULVy25I+sjVvgbUZuaUQLlZd3dJIrf0qXMrWUgRsbU3Go5ErlyZwTSQloVwCT+eJlD0O5bxGNFvyJ7iCf9lHXa+HJFvXIs5qxtVGofxSkz9ZrX67YCN2L9IqpUKsjeFj1xGMb+NXu1m3NJPYWJyf61hXsBRMGQMar/fydt1q4ktK+15n6a4XX/fnUlM49rXwvFIGG516me4q4erItPu/3bNdXV1dXV1dXV1dXV1dn4c+btSck20Ip4CK20aEwjmz3Huef+kYHh3DY9g22cNzwV+U3bcrYKwMFUc4F9xcuP9/LtUcUdLdyOmrwYDEUsHBg42GUHQbJVKhbqATUtSOx11HPsiAmtlAaUZRsQaf2XbQjT+y+9UzZOX0X+4oQTazowwON2fG3zyRDyO4yTbl50weLUWUd47lzpMHMxfyaJv1p7+zY/RLA+5eDQd/EYZHZXqovJLoKNGRDp7ihXApSFLik63X/MVImoT53uFniE/VgDln8mTJlHC2pqa0s7RFG72KT9YeNH9pSZn1Lhg35f1aa8zd1sCEWtImnKyRKL67IMcLGl6BBKhclnVvSZrpnTFp5ntrAtt9Wyok10wXdUIejctTgq1DPBrjp6V0ymAGV5ocvijjNxc0epb7aEyfXTXAPqjhBo2wTmYUxWdBT4HT+cBxLJy+jKTk0bMnixk1TpSC4H1Bh4I7evxZKIuZjgb/FeKTjWyND3aPnL+o6/VgxkgahLRz5GHErZa8CqdMOGdrExuF4akaj20sypk5Fx5mcJAPAzk61p/vLFW16MYnasZXOBmjZrmLlGgNZWa0GFtp/PZIGSP61Z5wTMRvntD9aDyl+jiXN5Hl4LbxM79YYiwPssGbu348+mPfyficGCh/zWPs7xR1df1x+jG9g/0p6XP4nd3V9dfWH8tg+ZwYKH/NY/yc1unHoo8aNWUXKMFVRgvAla0hBca3SjyrJSPauEy6/rwoxOcaNWijNzc2bqJiRks8mlFRosPlAlk3HoefjV+T9n7jedgDf3icLR2SR4evJobUpp1mTmiwxMH6erfxW9x65cGknSVc3DqiwR5HVC1REd3GzTFGSmWl7Oy/S2RL1DSOi6WJasJGLA2R40CYC265niNY+sHNtnAlTnbudWxqvQ1mDjwvlrxJtusug/F//JoowZJNLbqk3pItrjYRaRC0Alc0SE1/6JauKV5ItyOyj9s4mcsGFnLpRUpDzYxySYmnck2+eKs7l9JSNjV9shjAubiXjJnWsiSkw0AZ3JZIgg8ZOSqVsZJAJyhRKaOi7po4KcUhojBlwpARUeYUmFMg+szhyyPPYYdKvJ5HEmtgWnUzkdB67GsFTtc2sy3xJTYO15Iq/lLwl+v9R7033cXOOd/0pM/KAAAgAElEQVQNlqQJdu8hQAY/X9etmZA2ulZh0JW15ABZLKWU7nfgBKmNZLobbKSvXrsSDbjs8pWf1BqzmunV1dXV1dXV1dXV1dXV9Xnoo0bNchvR0MDAH4JWh6fCq3+cr0wUV1uMBjN2xAkkZfzmBKWQbyfy6Dl/2fgoMBwL0zczZfSkycMMrpRt5CR8vxj/Zry1jX5wNsLzu9wNZ408y41jfyrEd2fbCDtHGjxltMalPAjzqwGA6ftMWDIuF3J0zHcel6xaPJwT8eFCmaJxVyZH2hnLpQRrCyoDrAeD1Gqd0CpRkSTEJ6l105aeWO9huQjnWdj/Rth/l62iuY7luKy4x7OZAfGWHIV4Mojx+Y1jJ7D759m+vrMNetp5xrcz/uFM2Q8GRk5lY5mUINuoVaqNUBtkdlWKClJHi/LkmV8bmyceC3625Id4UF/PrwKh48naseJTIo/OuEDRXAHJyvCckVolHc6ZVkFuZpdsxlXxcP5ZpERYDrI1PTW4cxrtfnILeA/zpJTbxP7VGe8LT29voNiImfeFw6szQ0g4Uc5r4OFpz9dvHvmvX/yK/2v6W74Jd5RjRBaDILcacr+amSFFGR5z5RWtUMA/g47exvpGT965bZwrPq+484qRoIXlyz3qhfhwQb3j+e/3ILKNQEkBvxS7r4aADm5Lw6w31ubk1nptYgU4zxkNwuXNaObYUwIH6+sdrXo977y1i1Wjqak9dkt/dX3++iHfwfg/f/Ff+zu0XV1df7L+2N8j/Z3Zrq6uH0Ivfwf9EGnj/jup61PSR42ajc9CZYqcjd3RGo3SLuCWglsyxftr+0xWSyM4WF9PWw01IsTnQhmF+dbGeHLlf7jc2oysSYlSQajRW1pB2RIF+cbVlIONnMSHBbdYg5NbCmUXybtI3vl6fAV/ESS7jX2S9ja64i+WRmjNUe287MORJtlYNGlvEN8yQPHUdMeLNqdsx5nHynNxIKuNP7nEluDRWlBEPec8ONKXt1tSqI0U+axM722MK73eo3VtWlX08mrE74KtjSriLTrhFjNKXGXTILIlfMiV4VMUt7QLTeX5tATGFfzb4Mjh2GrAXf3T23kUS7y052vMn5ZGUrGxsRJla3VSb2Zbmmy9hmdL97Q6ab+YObjcih0z9jPilfNxNMbLWhlDojinRJ9RFb57vmFZAyU5ni4j//P4hsfTRLkEJAtShHAUwhkQJccrq0eynV/+am/HcUoGr17MNENrpfbOgRP8+KEDIlkp0xUO7eprpnghT5YcytPeDJnlRQpNq0FV1y/vr+wZO3fQAuFobJr1rrKHKu8HrlDs9ph5bGNkdKOmq6urq6urq6urq6vrM9LHGTVrMfgq1jY0PCQ0tGSEkPaOoLbhb6kJv9goU4Oxnl8bG6ZVcE/fzOR94HLvyVHIO4ckSxKYmWCGzsZUKdexGJcMPpsnt410DI+Z8PaIxoC/DDZidBOZXxuzY/+bleFo/JcyKGUwQ2C9MfBx9MZasVEne560c8x3jjxBmq6V2csdpJ1u9dF5UNsEOzXw79kOtNRiHwqERRge64hVTc+00TGhmVHC/OW4jahIbmBgJRwTJTrmN+MGnjWei9SkjGd4MjOqwZb9xcbN2lhXq48uQRBphoCtZ2tjstpt3ZgmDbZszBMYHtfK3xlQD+uNsWpaRbirI0NuqaNuTkh1lCpNdr8M57KdfwlQbmx8a3zMrHvH5bUjXAS/KGkvLK/BzXbvaVBcKOj7AUkCQdGgiIBzhTEmLkvk+WlCi6DZcTqN/JO+5vw0IRdnRk2G4QGGJ91q5Eu253DJ7tnLvSNclN33gr/Y2JmLDsmQdrb2JQh+uTogw6ON26WbUF8LZoiF55U8BdaDjc+te2F6V9h9VwHB1YQ0g6psCSQVYaz3UK5V7O7xDHc70n7c1r6l3OIxEd9dbCQqei4/G8jhatZ0fb76c7278znxan4q6tei63PQD3mf9newPy31a9H1uejPkcp7mTbur4W/vvq1+A+MGr+aeREuZmqU0dWNbtqAqG41jkx8rGbI2JIyvqYyZBuZkQx5X6G+b21EJlyycTYGt5kGUNtuLr6mMywYUqLf+Csq1hqEwOXv7i2FknQbwdogt75CijFjYvp+oQTH8y/NcPCLGUTLvd82v2lnldB5J6x7CGfwF0vS5P2LUadDQoJWY0BQ53CLEB8tEdFGm9YDm9kjxbgiwzZiZOunwdIy3tnxpJ1DRkV92Jq0mgGAQjzrB9dKg5CdbCaSrWH9Wj2O+Fxs1KmO8PjF0jr+YlXPOgm77xN+zpy/HMiDEOY6jlNH2ta9MWzisdT1KluLURk9eR/w52xjWKEZGo0JZD8jokgRpvd2XFZfTk1rmTHRjjnvlORBbhLjtHJhsIrzSSEU1tWTk2NZAusS0IcBDQpjJi+e47KD54A/OgssaW0cy1bQhNoInku6sYNGKbY2l4yb7VyQ6wigFAhzwZ8LeXLbKJpk3QwtakV7O+9wsfUenrkyiuTKV7LHt9dZOBvHZr2P29fUCWU/UoLbRtrs3nHW0OWM+ZNuAmUwx8/Pylj4cEyw67PRT/kfpp+aukHT9Tmo36c/XvV/b7o+F/XN+49f/Rpf9fHRp7Xgal2xeoP1hlPZGm0snlGNlfOKrIn05YEyBPJkTBewtEKD86a9jSgN7xbbnBeFyZNGNo6MFBC1Tb6kZtyYGVEq38ZaoAy8ev5ZJMxqBlI1Nayqu1ZGxwqBTYp/uoBz8MvBAKyrPcZyMHMnniGN1mCUJkg3BtT1F0vQ5H0BZ4bQcLvgfSGtnlIcWTxFA/Fo69dAw+lGtzSHFJszimdBso2rSFFKaeBhS1TMNzZTZQBha2dSZ0aJtT5dK6g30LL7oPkZfQGWlWTpnLT3pDshNDDwUnBzogwTWYXh+zPu4UQev2C98fgGxx1qW9VkoOMGenZLRr27ApcnS0j5VCroVvAXS9K4dK1Xt58t27gb1WBS/2FTUZ4g7wrjbmU3Llz0xtbQKXilrI4CaAkwe+KzI0+KThmdHbI4/NGSOlpHvFzSLdmD2tiQW8pmcrnkcGvBzRm3ZihlG99rDWRuVsLJGDJ5sPvFZXCXFUkFP+ftOog3Q0yS4ud8rdKuHBlrTBOk1pY3rs3ldW1Ta2DgyUxOtzZjyda1tEr3fdhayYZnu7ca8Lirq6urq6urq6urq6vr89DHW59Gv7UTWZJAkVSQnMnTyHoXCaeMvyQIDnVh45GU2gaUBzMowo2vdddm2OCFHGxjj7IlZ0RbEgGW+wD3gf2vL7gls95ZI1M8FyRBeF4NMEwwno5awsOt2eaKClsawuDCsL7Zg8D+t5YAslplRzxpBb5aoqWcbcQIYL1V1gOkXyzcvjrx/LBDF09aPTk7S9SUuukeC6dfUFuFjAuTByUcIZzFALazrSUCy11l9Mw2UlUGWzu/6GY6ubVt8KuxcFaG98vGggFLEaXbaGyU1Fg7boMAE6yuu329cVLAGpv8nHFrQaOn3O/reJYZXlKvB9LMlsqqKeAGt3FbrL66tWU5lnvPciOMj+BXRQZX4bluS1lZBbed1803hfNrx+lrqSaafag4Lt/vuPgJl4QSlHi7IE5Z3o/XyIhCui2oKJy9GTpqY1N5hPhkhpu/mEkVn6zu3arX/caNKaOw3gTyVxG/mEnmL4XDP59Z7gfSTR3xy2WDHxsgW8h7g1W3tW7JM3UwPGXcuxX2kRL81v5ko242ukZR0o2l0cy0VMZHM3nyLmwtZOq1AqMNbGzHZdDsEhpXSjdDraur69NTTyh0dXX9NdXfse7q6vpU1JM0v6+PGzX1nfoGI7VNKQb69ULae2NrXKiNTDXxEq4tUSXas+Sxmgy1rluDpTDWvbNK5Fmvhk1ltMx3Bv91c8I9XeB+rLXPZhj4OVOy4oNUk0c3M8kt5fdOro2oIDB+e7GkyE1Ei1wbc9rzt+purL2pjMrh1Ylf3D3y/55G8uLRCg/WUmdYBIiFfF8gOfyzMUJ0UDhJNR6M+WIJEqmtPEJMBcrLWmrdAL92TtUw0XruxwVUq0FVk0OTR53fDBj2roJytZpmV96QJYwKeBvZsvSUWjqmjmFZsqmBhuvatjWpNd6ahbRzLDfClMQYNVrvj0lIeyHM1TgIdk/Ndy01VeHIsZpPD4nLq4H1TnGzrZdUfgxPlcAsllQapxURZU07SAJeDVI8ZkgOme1c20iV1rRKONcK7mRjSpIL56+sEl2SmXkl2LHPr2zMKA7C/reF8P0R9Q4NcTMGURvjapc/jwYaXm69NXt52dhE5STImq/QmHZc9X5oY2TNpGnQaX/O1cSr91MAVWtWC5eMuyT09UiqJk3ZXq/WHCX5mr7q6urq6urq6urq6urq+rT18dGnUhMb5+voU9451p9Z4sLSNBlZM+l+tBaotRCfDQ5bvG3MXVb8xTbH6RA3bod9LzayE8S4NCvEY8afMxAtnTNFECEcV/zFsbyy5Mh6O5Anx+lngfGpsPv1hfUusvxitA35JROOCXdJZshEMy40wPLaiL+txcjPyvzK8fgPxuHxC6w3ZiKUSdGxcDkP/ErvCSHjbuvmV4X1HK2mPAsUwVWmj40cWR10OArhZGZQHo17I0WZvs9mGI1mSvnZTJU01vYrBXVuu1TTW/v+5Ys9LhfI16al8LwavHb04IXh/ZUlpK5t9G1Mpwyy8Uxejhr5xdI2ZlgplzfB0i3Jjjeey9bY5FcIa6mNQzbe5nJBVhuX2v/WMz46/MUMiLSva72YaRKPmTw6lkO9Lq6e43fCeoD1XqvZ0dhDV57N8/sdAG4200dV6jXwtuYXIR6F+MzWXhWflHC5nmPaeaT4yoSxdWlNYgHQR63rD/OrQAmvNuNkuQ+UGOs9APFo57jehu0xXDLmjktKfM6oE07/cPfiBWY/e3njySOMDx4/F4b31jaVB7eZddTxJ2Cr8fbnTLoJXN7YGJ+vY3wOG1f0lwxOUNdrnz4n9XcSfvzqSZquz0n9fv3xqf870/W5qactfrzq1/bf18eNGrWNql+MUdLGVPLorwyYYomOHB1p7xjeW123lPjhY9XvK7U9xy1shk2JDo3X72vcFD/b+IoGoai3tEZRIFbDxcyjtIcwG/NFvdRGooJb7XOyZqSED/gtJbprI5JCqA1Iy+uCWwR9Fsqg4CypQSiU4pjnQAgF7+2/S21zoqZqJAturiMvwVIxbmWr51Znm/fG9vGXhKRCGUYLxryoRN+gxQh5cBX8W8y82jlKqmNONU3kHpOd6+BR2BqYLAUiaOPgtJRJ46sM1xQUoqhTq2JX6tda+5MQToUSX3BxKvOFVMfI8nVcKlzyFfJMNWqq2eKr2VCCfa0ESNU0CycDOv+uSXO9eMDs63NLPR/jAKmAW60O3Z9heK9mtgUbO3PJqrAbHJuCtS0VRff2cnCL4kTNNKsmT4nCeuvrGJSBnde9q4ZMHQnLSqrV8b6lmurrx8+FtPOsB7d9f7sh8wjrjdSRODGI91JwyW3rvJ1/S50lxa0Z9aH+rMGK3aCUygCScm2F6urq6urq6urq6urq6vo89HGjJmkd7TAArHqBZJXDNjIj6OBIfiQdPOtOmL7JhPcXdqMnHDznL4zFkSd3rXLOZtBosPGNMgjLwW2bTfWCRk98P1uyYB+s4vjW3Bw3G0w1vr/g70curyakQN5Hwjlz+NdCnjzrwSM64gdr5PHnhD8nA8NO3ka7nDVJzXeeEiE+VkNqVEvCnISLgzJZlEME0uotwUFNcijgFLdPlHPAv3UGEh5rAiTbGI+fa0InsqVgyuAR77Z2Hz+XbVOeJmG+c8SzgWuljsWkG1vr3XeJ8LRw+WrHeuMYR2PNaDWBdLRzXA81SROFeC7svl3IoyftDEw8PJTKN7mmoKa3CTfnjXkSj8UguWshR7dBn9XLBgH2F8Uf15qu8qS9Pe/Nv55xS2Z+Y7fb+Ji3eyE+Ze6fM8td4PSzmma6wO4bZXwLp18Iy6vC9FtPOMN6Z8wfnKWW/KXxgOr4W6r3rkI4KmFWdKEaOWxraEaLHftwtHu8BNlq1KGaSYutfdp71hvHerA/zYy58nva6NP4NtGq0AGC2t8vX0SkWPOW1Pu/DI4ymEEDagDgc7Ha9V2wlikvpNHat3a/uVj9/M6jQVjvBiQpu+8yw9sL/nlm/vqW9dbX1jXH9O0ZWdIP9Oui68+p/k7Cj189mdD1Oanfrz8u9X9juj5H9bTFj1Mv/33p1/bf18eNmsq2kKIbtLYxU1Qqz8M7CNRERt0sl4JLBT87S5G8aK6RjKViikJle6irAN3KZtGa9nAXS8PoTR2Bim5jtEhWS4+sxUC12fglUpSwFDQ4Mxm8IBWWS1bc2SDCGiZkqz6um/faJqVeyQN4jMGCWHOPACJKUffCqMF26K0Aq1YHSVFLfpRm1rA1DTmu/72BjmGDBwtQko2BuZr+ALa10spRQaSCbC2RkkcBvAGf9UUiJ8j2PSrYaJKvDJes+LVQkqMEtTXBTDoDR4MT3WrYadyacmX4WEroRfOUN/Nt46yUeq3qz7R6aePC2IianxyizhqVkuKyjWy5uY6OXSxpY+dY4daAWyqs+mRr5dZ6/3hrp2qcnZfSer1KvN6XL9e43euNG+MviVLHkEptaPJrXaOWcKl/umwNUdUrq9fczMCWQpNU25rg2oC1ysYlUi/bPdVMMHUYUwiguAr4trFCt2RLTy3rBp1uY27Wa/+xV3lXV1dXV1dXV1dXV1fXp6SPGjX+ZK1KeQrbOIcUJU9h20RakqZCapNxP9AdaWetN7u3aRuPMXCswVbdksg+WjrAQZiVeMyEY00v3Ab2c0bmfK19ro3HJVZ+y5s96oXdtwm/FNwlVwaLJz6tjN9n0iGSJm8b7aJM707IsqKvd+TJcX7jNwMpj8L8plB2BXdYwSnFFaaYCb6QsqMUR4gZVVjngKoQdglVIT9GZHE28pSE6btrkiYebdRneDR2iL9kXAUI23pkENlGVYb3CwDTt8J6CJy+ivhZGZ4N1uvXyrI5DITnjL8o640lXcYHRSorSJ2ZIc08kQzrnTUT+Yvt4NNkLUPqYHjMW/tRvonM97XFK0hl95Rq/AguF8Ipk3eONDkuXwTm1wfCyZ57OTgD3EaPuyTGt6uZC0umjJ7j38Q6GhRwCQ7/ZmknBJaDI+9g/1tl/02rroLxnZlbbgEE0t5GlQ6/zpZ+uWTS5Fnu6nhebowaIQ/2ZzgXXIbh0Uyk/W8MzDx/ORhv5qmOjLlqpgH+khmLst540iTEp0w8JfLoUaEyleDy5QAC4WgJqBwcqDJ9v24GErAl1Eq0tAy1ar4EIVysAWr3K+t5X19NxgU6DNWdqoZoNTXT5Fn/9oD6A8NDIj6u5L1Veae7EX7HqOrqgv5u+cf0Q76D19e5q+vfV38n9Q9TX6eurj+//tu//ff+WvuI2tr8EP9f09f5D9NHjRqN/oO0B9T0S5Rt5APq2MtiaQZLBNS0RuXN2LjJtbGmFKEMAQ2u1n5Xzkm5phlEK18juI3n0pg5qJkbeXSVAdNakQrqfUO8QH0M9WIYkwIaQz3mK/vDapJtVKmMBaIxaHwoxGhjI0WFUhw5t/UQxIGgiOg2AiUVPivU1EyqzJPGqWk8k2LnqfX8tjRK44uopY5kKbjJb6wUFdukt+Yo6nmRirUo2cFWCG4dV5MX17AlbcA2/NmOpySbJmqjaXaKcl3LF+vfrntLAF3PW7bK6e2+ad8q8uLn6/HVx1ePsW2SvgBL1/tite9vRpKvCSOrUTfzxa1mOrnVDCrnBb+6D9IyLmlNbumWsLHkjuJmu8aSKutnLds9Ykmtek22a3dNTElWGwOsKRhRRbnye2zd6jmLGU6toaylnMLF7uE01WtVTZg2snR9zN95gRZ7bvsmNpNPctkSS3m4vn66urq6urq6urq6urq6Pn191Kh5/t/2+FnZ/eYEIqw742z4IAyPifjugoYdaXTsfz0Tvz+S7yZK9NY4g8FyS/Q8/d1AaYZOVtbDztp1zgUV26CDpQPCOSNPShk8ZfSgagkKbMMbnxMahMubASmKvxREBeZ64ArrbaS8Gbb6azM/rHVnG20BxsfCcnA8/72wHgpySFCE9RhZvbKEQFn9VgGNALX6+earI0NIvH9/gyYHUSkU3MWjXimDJWrCGYbnwvhupQQhT8YQAchTrTSvUOPh0QC8JbpqdGVUrFZaiqLBNvX+UojHhDsn0u1AGaxdKRRLfyDC+eeDpTQ2UDOEizK+S6yHwPmN5+Y3K8O3R8J+oIyetAukvSc+G+Q4XAyoO32/GuR5yZYicQOuMlo+MJ/Uzmm9CUgx/gtqhsJ6Y8mscbHGr+l9rmM9rUK8tlFNBtwdH3QbSWv16c1kaU1VLltqprFnlntr85Ks5MmRdsL0LjO+Xc0sdLDcB/Jg3J1mLqI2gmXGX95qz61G/mpYuqUwZKUMjnmyNZeszG9skff/dkZFOP/NhBSrHG+18G4p27Ux9oxjuRVrKDtn0i6SI4zJarURMzTPXw6IQnzO17FB+MBo8w/JkkrRm8FaTcjlzm+8nK6urv+cehqmq6urq6urq+uqnob5y+mjRg3UpMlgG9XQNsulckBGD0UrVLWmEMTamFqiQFJBxFppJMpmkljDUOVuBEcRQQdQV1txSrmmXipLprFp2uesXYitQUeDs4314Eg7Y9S4VOum6141j4LoNRHkF7Uxolph7byxQxBBnCJeIVXuTCi4oOTFIVlY5kDODnFq7VCzQ9KLTXFDioSaGpGW5Kl/35JCbGkJ9UKxp8etVO6JHWOptd1+VRyQY63tVjMQ2kiYKCi68Xda4qXVOrfK6WaSvExcbPyhynZpI2sNLF2CAy8b+6U1PLmltj0VtgapxppB6vhTUlR0a+xqI2dtBKvVkbdrIw0AJGwgYKlpn+LtByyp1KIr8oLrYm1Vba3BkjrNtDAujCW+VADfmC6WCFN3NfMkV1pwsAezx24cmZqSacDtup5aR5SKt3SQv1h1uUtlM36s9ez6mpCsOJGrEaNXNpSKcYCkcpxEgaR2Tk6Q4jdGlP3AlSXk8n/wIu/q6urq6urq6urq6ur6ZPRRoyacCghcfj7iZrW0gHdbo8zlZxN+LkzfLZYaeL0n3RibJo+WCBneFsJ55fafIE+B+bXxbVBrOPJrIQVHnoTlxqq2XfI13WDjJWUUVIThYYairHcRRIjP2Ta7c65tOMEqkG8sqZD2wu2/Zqa3C+tNsFajwTbRvm7wh/cJKYFwNmNHRXHBDIU4JvbTwrMbSS7w6vWR+92Ff9Y3lOdI/vWO7GD45dGSH78ZjIlSocR+BQTWO8Flh1vD1ipUom30/bkgpVC8bd7zZE6DS4powZ9XJBfC4FjuA+cvHf6ihIvCnY1+HX41E97OXL6+qbBdNtPEki6WSBkeDKTMixGaPDnS3WQNRME4RP6sG7jWn8s2UqPRsR7C1WCq6Y7G22njZyVO5NESK/5SyDuPZMf4W2OuzD/bU0bj2sRjYffPD5RdZHk94bIQzrUGfqgtVEEINbVj66XVmNAPWC1QR4h2jvn2OraVBzvu+XVtJntfiM+F+LDgUiFPwcy9vbcxI7HkTxnsHhu+P9dxLsd62DHfOUvx5GZcQnzMIDB/MV5NOWC9DQyPifFf3oFzaAyU1zvWgydc1NJjqpTR1qKN9WlwsCZElXi0Sva8s+Y0f7bEj5szy6uB5d5Tghk1+9+uxMfVoMYqDA8dUNP1++pJka6urr+m+juyXV1dn4p6s1TXp6qPw4TnukGMziqtR79t0lG9Njg5S8IUuaZfGjMj7yOSPFrHTloTjW9cmaXgQkGyJUV0rqZAEIp310TI7xJR9co5SYdYm3wsnRDmYskPMT6MRVTYNu6iZlwY26ZsCSEpkE4BHIhTUvJclkgpDlSY18CzG+vKWb04wLp6tAjuZYIliVVH1yYiP+vGSVF/PY1mNLgEqrq1asUKDV7e7K7HnZVw0i0h0cwCWa0dS1JBwvXBpSgO2UaUcI0xZGvjF0tslMFtDKGSrZVqcz5qu1e6qbdKqdeiJlfK9OHJSL1vorOUj8uFUp2hjcfjZWPtQGUhRTP/2pq0pqqW6jFzpn60pI+39TUAUW22inbcfrFEjhljSqkGlstXxo4OjuxtPVoKCJWN7ZMHwbX2pMYGWgthlmuSq96rbdTIEkHgsx1froYTQ6QMgXwYyLsXa8aV36M1JaQK8oLxo76af/lFcqwUG32qiTZUUG8cHA3u+joFcH30qaurq6urq6urq6ur63PRR42a+LSQ94Hj18amQYZtXESy4ufaDhTdizpgeDnedP5qsg1zAg2QRqtNDsdEOGf801w3qYJfhHiyzee6D1eDoqZQVEBejHeIWsvU+cuAS0o8Ffy5ML1fiU+ePLrrWI0z1gnYhnd8uxj/pY27OAP0xu8iJSr5ppBnx9mHzbQ4vdtxkh1uyLgpU7xCEfLDgBShDFpHeewchwdLvgzP2UC0q5J3bjMk7Nxa4uWaXPFLYfz1E+l+x/f/xx4/w/67tLUptZaleCz4c8afVlgTfm4OhC1Qq6qOR2tTak1cebLRpeG5gELa+20M6mW7ExXiW6KwHGwkbf+b1YwtZxXQ8+u4jVQ5MUMjPi4M32fKEMAJPhlnJ92OV8Ax10RKupvIO0/au82oyrXeO8ytjp3rOE8dW9LEVkOuviZn9rb207ts1dpzYX4dmW99vUfq+Bew3EW77usVOt3GjjTAurfkTBlDrSovxKeVcLGqd6kspDw6AwEDw5Pxd9z/z96bLEtyZGl6/zmqamY+3CEGDDkxq8jmokQoLf0E3FF6wTXfhE/BV6HwAVq45r646Q27u7ozgcwEAhFxJ3cbVPUcLo6q2Q2UVCSQFQBi0F8kJBM3rpubq5k7oL//5/uTIA0O80Ww33uyQ7wKOH/mEc4Kf5Z1zWzoWZ8AACAASURBVDkZLDj3tN6Hj69jPNiN292mMkZGULJ7yM0CPxk3qJpUae9WE6mack3vv36Ob3RakqapqemH6l02fHz/mE1NTU0/RN//HHqXnyEtSdP0vuvtjBpVIOvGpslbWxEX4Gm8DIgXbksYEKCglYVSAa3iCSqEcLYWqLwrgFbtASK4MYOXWlnMbzTcqNuSM9AC2lUzSWrTkBQ4azUnavUxyZbKcVFtH6540yzJit13irQnLBew1qCJkAdF3gng1UDChUEjke2fE4EioX/lbESrU3AihDuD/7poaQc3GT8m7UuN+WKg4XreLLryW/LAEEfQYJvz/q4Aeju2saTJDB0PM2n8mC2psu/LaBdDIwPVzCBdOSm8GGtFgoN4QHqGn8xwk9IqZIkoRS4pGDMFgHCWMo5V/kQt68qoTVzx0iENAd1tRnhIGyB658sxkj3Om2lGYumr3Btbx0+yGkOrmSOl1SujpLg2TlJlxBiTx+4/PxbuUDETQYA/5/LPdoxqYiyDX1M5NmKUATEmkGi9PsZoQufKvbjBqavBZ++HkuApCS1aBI7JjuUIy3UH6aikXzYoNGWr5dbyTrTWtDLut7f3hh/N1MkDr0k1l62dSj0h+61CnVHMw64Ymow30zVNTU1NTU1NTU1NTU1N77X+KkyYxBgZQNnooyYaBO5+xvy8x/kzRn+j6B503bi6SeAWQXh5BgRIT3YGJD5n5MFhfObAiZEHRrjPCK+nUt+sWJ7tjRdSTCHxBmXN3TYywlnhsY26iLff48QID7bZz71BYTnRmmhB2ezmwdpwONum/uqfIpZLh/vfFdNpAeYnjPk5kA8C6gR8ZvgTIw8KdXZcngmX/9lqnk9fMjgCxz/ndbzGTQI3JuS+w3zF6B4E/mRpE/HGQQExwsliFGnvID2QDx2gwOGrCengMT315fkygihkYfj7BTxF5GOPfNkjHZ0ZP8nZ9RktMVQTFuFmhvTeNve9w/SEsX+R4U/WAoUy/iNMQGH51LUevotrMxPEmpEqELcmXO5/63D6DeHwNWH/kuAmMy6mJ5bY6e7immKiR5XWeSjn95CwXASkY0lmyQZA5kVAScw0KXBjIrvutdKao8KfCreomBjiGd3rGe5hLpBfgg7eANlPrP2Jk4JmoH9ttWFS0inKdk+lnYN01fjDVklekl5QwBd2Did7ze68ALAEWu4I58+NSdPdi113T/APtvbL0w4p1DQRkAb7+/RkB4qC7rUl28bnfh3Rc7M1qsWLDungyqgYlftdV3PzccNZ06erlqRpamr6JdS+qW5qanpf9P3/FmqfT03vu95q1ORDgDheq6MplfSCJ6gXaHDgaDXKIGA5Mvq7DJ4F6eiQdwx/5yw1UGC1tRGnvy3jU4sBi5dnw7rJ5Sjo7gVxb6ZCbT7yZ1k3ykqw9EhJy6C2GDlj23BUdHe5sGtslIfk0XnATIfsa92SjSD5c+HEZCA8AABDb6yiOTwQeDY4sASAZwJnYL4mcAL6G0vQ1JYpKWZEHmyMyxWW73rewJoIyiXhU1MWlATqGfEyrI1bdWRHyxqqM+YLRwGQsFyV0abOUjmV5xLuEyQwxl/tVvPDLYpwstGm86/6zXxQ2JhaqSKvzVu558K52cZrgK2xSTpGd1LoX4DuwUbdKqMmnAW5I9z/fgAn4PD1BCzlGvaM5eiMl5MKgPpB3kiBSCCEuwSeEpZnO0hgcJSVz6Jsr1mdVW+7SRCScYpyz1DXIx07uDmDYkbeh1JnbuwgfzKgb7zsADHTjbK9Dk7G9qEMMMrIlystZllX0DUnAytTqSJfnu+hZHXrEhjxyMXoKsmbWO7VobQ1lRYtoLCDpKSbmOy8Fei6R2NMCixXXbmXtrYr4/Io/MnWZ7n2rZ67qampqampqampqanpA9JbjZp48Bu3RDaArP2MQYOHmzP617BGnSNheKXwp4Txs4DcE4ZvPDhmG+kJtql1i6B/vdjGNgvidY/pqYebbQyne73AnWak4YgceOWSdDfGlaEkkMFj/HKwdEYZfbFUjRlJbs7gOSPvvG3sZ0taoEBxK3xYugKZjRXiq+tmmCPQ3W3rwVkKuNZaqryVGGF+BvBCePYfk8GLtUCTPda2HiUyhgxhbZ4CyuRQGUNCgdVyNECwBof5ytIm3b1YoqlWUDvbxCszKFrrEkrCJPe0jhW5WdD/ZUS6HHD6soM/A4dvoq0zAfMlIz63dqBwLs+dACkQYS1rJR2/kXBKA8NPgv5VRO4tGdXdZXS3xXBQBS8ZvGR0bKmeF//WWEfHPwh4jAARomfEg1Vpu4VBSdHd5LUCWzpG7hg8RvDdGfp8Z7Xrtbp8scYvCYwcCPMlo3NAONPaPhaPhByA4TXDj9YAJZ4Q7hNcFLhThHrG+NyMrP4mgZKgu8c6amTtYkDalTTMaImxvPPIwcDRrLARuMAYnwe4RXH46mwpIHSrkVhTQjXtpFzSOeWecLOuHCAiAs0RbknotVabM9LOYX7iy1pv7Ge7QED3agTFjOX6qhk1H5jexcx0S9A0NTW9K33/s+htny/tG+qmpqafQv8SM+ttnzktQdP0oevtiZp+S5twVIR7446Is2/208HDTRnD/QLSHdxiQOF4GQrPBGaUrKMktG721ROQAYALmNgMkrRjgxZfBABWDz0/cSUl04FnQbhbABhcNQ0OOTiw1iYeM0c42uY0d2wAXxdWs4mTbuBdNhPFWnuomB2WmPGjortXSNlg13RO/9qOU9km/a29rjqiZQaJYvdigThLdRAbMNaMHli9dkk/UFbsvroHYoJc7qCekY8d1BP621zSTGLJm8FGwvyUjXXSO6hY0sWqq4vB4YuZA4b2BrTdv5DVAKhJHk7ldZ4E4T6bUbP+DpCO1vTlRkt1WLLGeD+UN9YPRymmSmHL6GbuVLNv961d+/lpDzcF+IcFbmb4sVRVn7KZQHtXRotqykcRn+7Axx7S2fPlgQEBXLku9f5yhVG0XNr9s7ZDCSEPvAKbOVm6Sj2Dot0L3Z3VaT1mHNWWLhJaEzGPG8TcKHAzAC5V5zu71+PeHpcOlt6pAGcuTVtK5fd7WivU/VnAuYx5qRoguGNo5+09OCZo7xBL0xanYk4GMytJCguKrG2NFwYlS+g0fXj61/zHSFNTU9NPpbbZaWpq+qXUjOOmT0lvNWrkEeCUkxp3gxnUOeTBIe8c/CnBvXpA5xmUgv28t7YclM0wgLW+uI53iGMQKUgtpeIWQRoYuTfYLRTobw0Cm3qP3AMuOriO4UcbYfH3C0gC5mtn4ypiyZt1g00E9QYZdlxNkVJbvdimXDoDA1djQslAt2kg+LPVZOeOkfutMrq/k5KIsM1xdxehTDh/XlITxajxL0fIPkC6wSqXBeuoFi+WyFAiS+p8/RfIaQT//jfQw4DlqlvHlqo5pp6QHcFPlhZSx1taoiR2OBPmK7eeK9R4NKRA/yraKFbPxXAwRg8mgj9Zo1GF4dYabWsNUrgpA2QjRqQKXsoImremJI6KPFiaByhjOENtd7Lf3b02Q2S5dHA9I9zN4DmbSTMK/CkiXnZIO15TJaQKVcJy+ehWLQDianphNWq2BqflaONibhRQMTJy2NIwNo5nxpkPluQJ93YdcxlHqpXdxjKyMJMUY6iOZvkpG+h6bwZN7szky4Otb9o5u27dNi5VlXozdEIFIM8CNyXwnMpjS6Ktc5ZOmmaI60vNub1WCVyMSatGF0cgNs4OiAo/6G/4ZGhqampqampqampqamr6RfRWo6ZyM2paZPpyb+aH20Cqee+BL64Qr2yDPbxawGNCuuhK1bNtTN1UIKhTLokCWjfFUjg03X0GvxIslx5pYIzPHZQ99t9l451E27hLx0DhlCgR+ru8bawdkErqQ6lusi0VA8/IFrRA3DNcVPTfLTb28pn9RXcSyGyb/O7BgLy5cG1cVNCsiHuGXPDKo6kJIzNGgP7ezI7xdxeQfhsTcmOBMSuMO5IU6eCROg/3b34HZMX8ZCjNR5ZGoVAMmsKI4UWQO0ba9VguHNKuJInyxrCZnpgR092XeuerAMj3LvxZ0N2kdbQo3EfwmCD7YONm2dgsrgCkUUahOCuQYW1Sgc0kKwklXhTDnJEHM3SglqpykxY+UOG5FIbP+bf7rQocQLzoIIELo8XMouXokAZCd5LVvAGwppu21FcxwmoFu1p6JTwk+NHutbR3yD2VKm3C8DKBo2C5ClvrUrKWKCrja24W7F5EpINDPDj4WYpBQpiv/QqzPvx5BkXB+MUAgMzIypaacYtg/01EPDqcP/cIo/GWwlkQxs30sWN5M6BQTD0C0t6Ddh647JEHtnG4XFuuBN2dIh4tnbOyjLSOrFEbffpI9L6mZtqI1o/Xj12zT3Wdmpqampqa3qb3NTXzr/n39vv6mn5q/dg1+xTW6a1GDdcq5GyGx3KxVVpz1FKnzNCLgDzYqAiPCe7mbCMlvVs3obwYCNidI8AEKX+Xu22j7c4J7hSRe4fcA3Fvx7z4Y4K/mQFnfI54DAa1fTR+YokKLvXJsHpiMQOFBGsldC612Lkn+EmxnzNEFOq61UhiR+BEcJM1DZFam5UZJYp8RchDMbLEjodHo0Rutmaf5cpZvXMZxQrFSLEaZ4PPVjNpfr4DAMQDr2NVnMp5r4kMlGSIVX3P14R4NF4LJUIoIOR0KJXaDwBIbZysAJkpYzV8/O0M2fmVNUQxQ9kAtbV+ejVGal12qWAnANJZ8sgttg7+LHDnBOUA5W1siWNJsAQHghZYMWG+cGaWvbYESR643G+6mhUSgLQDwmgA6NqyRNACkN5GmRTb2JWW43DMwGyGkYQeEtx6D1SGTtr3yF25ByOs8rzwmDiqrZMfoBfORolGQe49ck+IO3vOizmDzwv4aQ91sKYx2cy7cLcg7XaIR/u5Hy11xVGM3+RLCsxvr6lCgiWwpaoCFZPOrrkv9364W5CHHrrj9R61NwatdeJNTU1NTU1NTU1NTU1NH4beatT0r6ONAnUMjmY21ArimmDxUzLWyNlDC69EDgPSMdiYjJh5EO4WMz2yQFF+zxPSgREeBOF2gXaM5dkAdZayOHxr55F7B/nMjIz6vPXx1UyohgaANVlSR0Igiq60Pi2XfjMdsiLvbbzEj7KO0NgTbWNaZkqVJqeeVvPHj4Wtwzb+s/suQx0Qjw5uFhy+npH2DvHoEB4y3JgQLwPSYVv24cUCN81meDkGYCmNqYxzhZoQERRzhrFcmEGzwZ0BChurJA32mOkZgTJt16sD3KjYvVLkngvI1owtCT3cHEqlOcGXlMvDbzuIo3Xcy59r5bexfcJJ4EdBOCWIZ6SjAYPdKEgHRgp2PMq1OrtcL0fgaK1h3e0CCQ7p4A2mnATx4BH3jO5eMLx+ZNyUVI6tiSI8GLsn7azeOjwUzks0E3F+2m/XUu3802Br/PofdhBvrV2kwO4bhQRguu7gZmC4zcg94+G/Pxb+kIGf1RO6G4P7Lpd2rPHLAZQHUFL405ZuqqbJ9NkA6Qj9jcBPW+V4fb1Km6kSL4OtmeqWhJLaCCbgZKmg+ZKgZKBiykBfGEMAkA5mhFpV+Vs/A5qafpTe5TcYj4/1KaRG/ta1+5cgik1NTZvaN9g/Xu0b7Kamd6N3CS5+fKxP4T33t5ZovIvyjfddbx99WgTE9Ci1UPkuUtgztgGnJcGpQpfCo+kLI8UDCloBtaQweK/jR0Dbaq5kAwPvXGk/0rWqOvfW6lOZJHW8RdXSCUhbzTUpjI+DMlKiVrdcW5/8yCvwFyWdAqa1hUdC3dyawVNNGI5q7UyumENl9KSaIAYQLjybo5labjK+jHprurJmJlo3/YCtJy0JRL6sg9j6OCAzwa1mlDGD4sFMmnihZpxlrFXf5RDr+qSdPY5TSRn1tk7pBLAr9d71Wudy7eraAAXuTMiB4Oc3UxlS2rYqW4XnvF2DXNaF7HWIg8GeBWuttmYC+3JvxAxiu1YGTi6jO1xYP2NCDgb+rc+xVYnbPVpH9Oo60yIQV3gzZUzKTYURQ3ZO8xNC7oF0sJRP/8p+b7m0Rq/h1tY87bbUV71nXczgmOEDI2e2JBSMq2QpLF6vr/gCMiZbL06PQNKiQLYsUN55gwz3Vt/up5rAQlkbuxddVuTOQYIljrS0slHars/jdeJHXJympqampqampqampqam91uk+i9v4v7n//X/0FonDQBQbGM4i40+UTErwqsJfJoQv7hEOvi17Wd87iDOxowsjVOf2UaEwl3hpJT67gp7XY0SbBvN3LuV2yGBsBx4NQtqbbifBP5kqQ8bJdlGh5SBw18W8JRt/KqzGmVSS2KkPeP8nLF/Ibj4jy+Rnh8xft4b5HUWY5yU106iK6+nbtLD2cyBeOBiGgDhIaN7vdjzhUfGSFn3NLg3R1MKqFa9rXXcFf4Nm9ESD4R4CSyXYiYQ2wgQCEAy48afrJ5b+rLRj7DRq1Inrgz4M9DfCjiZ4TS8jPB3M8ZfHRCPmymW1/py3caUiomCalrMlhaiaONT+dBDBrcCdiujpvJk3CyFGcNrm5iZGW5dF54FLgrSzqq0u/sIioL5ab8lpQDkwSC9uz+doMFhue7NnEsFtOsJD792mJ5bExYYCHdWvT4/A/KgSDszEf0DreNslO13/AkYXkmpC7cUlS9Q4MrXoaQrd6lWsX9/ZAxq76Pc2bm7xV63P8WSpGFMz7vVpKkGC0fF8N0CylJMS4d4FZB2jLhn9LcZ/ato9wKRVY93hP2fRvCUMP76gNwz/p//63//oOef5C//Y3ObfiH93N9UfKypkXe5jh/yGvGX/98H/Vn0v/D/1j6L3hP9VO+Dj/nb2ap/7dp9DGv0f8v/+UF/FgHt8+iX1M9V/f2xp0b+w5/+8V/92j6GNfqXPo/e3vrU0WocAMYFUbbNO2fYht0TsicEVxIRjEew4c3MyH1JvxBKygWAWCICBWirDmvCxqqQSyV22Qjb5pfWCmItaZf6GKAkSLJaAMEBqSuA4YG25EkdvyrGUz1XlMeQKmixeREJxmBZ2SilsYmTlpTEdlxgG5dSJuSg8EzgJUGGYGDjpGUErPzizq8tVYCZJgDW1yfeTJHK3bFUT6mJ9gp1CngzbZAJmgmyWIW3hGJ6KAF5S+VUvk4e7ZpRfnTRyzhVmU4rAOfK4zHjgZLCRbEmqm67FpxLOiYbnIVnASVa263kSIX7spkXQGnT8uX6FwCOmyzRhV0ZRyv3Sk1mPa79rtwddVrO3e7J+vdpR4iXth7qLD3kZiANCukVGgQKIB14ZQPVFBPlbcRshfyW56g/qMwhYkX0zkbjFrwBmLYUzcbQsVSWAiJQ79dzrU1rUKzXrJo0Fc683udpS+dACHDbYylm0JLWa9rU1NTU1NTU1NTU1NT0Yeiv1HPb5ru7tQ2fegJ1DPG2QaSsyDtGGhgcBwTPgAD+lI2RwYT9i2TjHAVo6xaBmwTdyxF5H7A86QAF/GiJlgp1paxrygZEoGQ8D3GE5ak1NPX3edukM618mTSUuu5cTY9tc5wGt3J31GFrzzkXvgd5cFTMf/cMuWP4swBS+S/G+yDFmuABgF1ppepenqGdh/t8wFrBPZfHd4x44csoECGcLTXUvZpAWfDw90eknhDOZsjc/b2tV3enpVIb66gLKdYmI3WKfC3wQ4IP5rhMXQ+kMjIVGf7BDIg0GAA4XoiZPo4Q7oHuDjh/0YE+6+DPguFVgpsNopx2dov4MVkN9cGBmODuEogJuTeIM8gYRZQ6q+wG0H97Ak0RcjGYUeU8QGTA5jlj+GqG9g7Lk6F6GKupYK1RlqYB2b2n4ta6aUtM2bXLHeH1/3QJjjZ6FPeM6QkjD4S0A+YninQUSx8RMP42W7LmYkbnFPM5QIUgXeEUORvjc/cOaW9V3+EMdPeyjuSFuwg3Z0zPB8RDWM2c3JtxNJztvscjnpKN3inCfYZ/WOyeJELeeTP9SpKmMpC6m2SNZcFBd4RYkmqWJhIosSVrDoONfJWWK14y8r5DuuyR9o8q3JuafoQ+5G8m3if9FOv473/97z7oVE1T09+ids+/G72LdfwYvsFuavpb1O79d6N3uY6POX4f23V5q1GzjuEU9gukJltQNpSPxjrc1uS08mccgEXBAmhtoikwWYism9IKBLY/tD53TbFY0oaBxUZQKNdkiz6C/urK0LHnqaNWutWE63ZsCaVm/FGtNYmuFdq5d8Xg0TJ6RKuBVJk0gLFqSBScxRIMVNIfuqWK6liK8nYK6gAVWDKjVImDSuKlI+TOjlFZP7m3x4gvho2v8Q6AnMKHDOfs3N2QLFkTHVQVyls6SbytQ2XWuGlL7ZAonIOZPPW6JNmuG29wW+ltpI1qsooA8bymOkgVYAYcG5eoriFtf0+q0EcV8JTtvGpzlxQYNS9bwogU5THlST22ES3dWrTS3pq50lA4Lk6B8oe7DHaKYYjGhumMMyN4HI2qZlwxiag2ZmGtrX+ccKm/+0bqptwfa6JFHx3b8bq2yvU1b81hnIytVEfGJDByb+kuHjMAhiMtRllhJ4Wa7hFogTjX91BTU1NTU1NTU1NTU1PTh6G3w4QLqHZ6HkBZEc7GFqnjObk33kY/WZ1xPBgfo4JmAWC5dOBsDVKAJVpyx8DTvZ3AuUBoHYFnRUiWakiDgx8z6KSYnna2ESdrCTp+NQGiZgwV1kxtE+IoVgWeClRWFDwz3OJKS1UG1LgySsDwKpVkkAMlRbiP0MDIvVsrkasZ4aYMzqXpxzPCScqIkbXv+M5DOmcjNAK4Yr5QYbpwVrgHgZ8y4t7Wan7S21qrrff0lK1avIwj5cH+zE9lHcVJlxnuckE+BdDM6A8Lro9n3DzskRPj4jCBSHGeOsTZIz8wMhTS2Vp0dwQJingwILGbbdSIE7AcGbgAKNt1C/cGYV6uyz1wF5H3Hnf/XY/uJNh/Pa38nTw4MxNmMwtOv7e2JH8WqxUvvJs82LWIl50ZZXMGL3ZOae8Q9wQKluYavovwtzPSdY+0d2bQRYGbMuAI42CJrHDWdVxuORLGL2xMTxnQMgIWLmdcHCZrdidFKgDlp1cnzNHj5uURWBh879b7F6jGWBljSvW+DgCCNXPdG2dJH41DSeA3qsmppLKkYyxXHvIsYPdiQXg9AcA6niceOH6d4Mds1d29w/nL0gIlZt74uxngYt7sPNLOWEASCOIY5Bi0GOPH97w1mTU1/QD90t9GfCwNR7/0OjY1fSz6uT8LPtZvzD/0z9Smpl9Sv9Tnwvf/m+hD/1z6WF7Hz6W3GjW1PcjGnFCSIgo3Y4XdVuYKPG/jKygV2QrInm2UpCZS1gQMypjJxqRBSVLwXHgkUcrvK0hpbROiXJgnnjaOzXrShelR0hXICmaFLsZLUSLjr3zvXMST5SlKesOObf+fYOkPY7CIpSpcTQZZAw8FRbocbOynJG/cLGvCxxqKsI5jrYmbei7ZAihS16CYQ5wASeV3ARvfASyy4RTaCZwTMCmYxZIoanEQyQyVkjrR8lwlXQOtUORH6Q8FpDZYLVtD0prMoM1k8bNVk1feD+UtESWeAO82dhCXYFF57bzY9ZFHbCF1Bn6uYz+cH7FzvDGM8sD2nPLIRSnXUMs1nK8J8YKQdrImWWQQoM8gAmJ2CC5jZfwqYVwCUmYQG+dGOi2m2PfuUdl4QTWp4uYM5Lqm22t8zFra7ndaR6DcrBBHSMduTYlZy1lpCCv14iu/SK0FipeSVIIZVnauBid+Yy0f1aK71vrU1NTU1NTU1NTU1NT0weitRk3qCS4Cw3dxMxyyGTPLdYf5uTO+y0mhKmu1MyWgu42AKtKut/TE0X6XZ1nrsvPOY7ny8KMg3CeknUPaMbq7Bf5mLm1GBI4BgBizI1qqR3pnSR+BcWRgG2g3Azwm26gGc5ooCroxAaKYnw2QjuBnG72qzVBpx8V0csgDr81NdcyLY01+ZLjF6oM4mmG0HBkSgPGpg1sUw+sMf87ovnmAdh75YMkRN5nzkPtyXmnbxLtJbOyLbBPuT2YUuNlSLxIY0ivSXkGRkO8DaJ/QHSMcC5bkMXQRqoSHcw/JDvnkASFoL2WMqbZUKcI9YXi5GTArMFgVCkJ3a5yaePRm3IwZ0jEeftshnBWX//lk7kupQEcSuNnuj+lZwHIg7F/YOhh/5TGXZ7R746IHHEE6h9zzCvMNJynMFTHz5WmP+YlH7gj9bYYDQ/qybotahfZAWC4JD7+D8WieLGZSJUZ3OePqOOLmbo+Hmz3CLiKEDMcCUcLDdwdAAHcRwUMEXQJx9tCbAIllRE7tGkln94o/GX/Ivx5BcwLcBcQz/L2xZ2rrmHTW6pUHXlufdt8l9H95wPn3lzj9ulvvF17sPg53CwBgftIV5o0ijIrDH06Q4LA86eFPCe52AncOUIfuNoLPEfnYIe89zp8Z3+fqv05w50e93U1N77k+9G9927dETU0ftj629/CH/pna1PQp62NJoHwsr+Pn1luNmv62JEIK96OOGLnZ6q/fSA+UFAlRQdcwACHjxjzi2qx8GzY4r59sNERL0qAmcapJo99LXVSOiLhtBEs6Wjk3yoAWVg5UIYNH7hhu2Zg4lEsqgqzeWelRkmPJBRxsqZYKA1YyLosGXhMWuWMzkpIduLY/paFAlQ/9VhPOZHXWVF9XeVHFAIsXNjYknY3ZoIM9rzdeDcoYz8aOoZU90vmM3ifcTT1i9FBhaOX/FIAuBECuqQ+sDVzGhsGaiFF61L5FJQHEKPBlS+FwKnXo3kF6t46ZISkYUuqnyzXzBfJMAM+WSkpX/XZNi1FW1wmqltYSu4ls7UpCaTEuESWrSgfKeTsg7RhpT0h7gXRiCSxW0JDArIjJQYSN3ZMZmRXBlciOs9fofbb0lRLYKXLQdeTJ2EA21ldH+zgKZN8BQyj3G5D3we73KADRanxVVe5QPnQlLbO93yTY2qdjWI1R4VEevgAAIABJREFUzoowlkpzb+NU/j5akmnwpUVLIB1DQm/Jr0XA5R6PB4/8qBa+qampqampqampqamp6f3WW42aw3+5gfQB05d75B1jvrTUiZ94HcWgXCusBRQN/AqUTWewNqcKyiWxTSXYUiWcBf3LGXkwzgYJEB4yKCuk89vYTVHauzcAxOHeUh7TtYOLinDSwgDp4M8ZbkoYv/SYrhkcbdPb32S4RZB2ZrgsF2Y++VFASeEfFqC0G/mzINxH5N4SH/N12F5rhjVbEdA9VACxbeLnS7Y6cL+zKuuSDDGzBmtlOQCE2dbn9KVDPBbIsAPyTteXCtjrNehvAS4nQBJDhHDoFlz2E/7y6hL5FMC7ZIZZZ0YEOYUmBpIlVtzZRm1yB/gRZoCkjUkkwcwvybye+3ztQQoMrzIoCWTnkQaHeHQIJ0H3agLnDCxA5xhuseryVFrBSIHhxQQl4PZ/2IEE2H8b13vFOD9YTRuDHm8jUOHBTMPwkKBMePhtByXg4usICYTpGWG5Ush1sqTUzHDHhMNhwhI97k8D8sKAEHIqqaXdDMeCcWdJpMNuhghjnAOIFLRPECHksTZI8QqE5ijgOWH81Q65Z/SvIkiA6Zk1kg2vSgqtGpO6gafTwSEPO1uX4hUpAcslI/VkLWpZ4UcBT1jvyXgMCA8R4Q8voNcXWD4/2D17Thi/GLBcMC7+MCPcTAgXlvo6feHfMIOampqampqampqampqa3m+9vZ67D4C3TSNmgR/JDJGHbCyV0qZUq68tkWGPrU02/mRjF+lgT1Wrm0kUKBXavGT4wgJRz+V3GHnn1mphjrq2KVlcZOPLkOra3qS0NeiI5/JctSWopnIKD0TMbLLacEuexOvBeDWLlnQHraNBbha4xZI00tmxgNIoVEeHSMGJVsYMlaSRdoy845Wz4042AqZEgCP4yTg+6WBGSdrZg3kxnkx9rRxp5aS4IeOwWzAljzkfbNSHFDK7N66jigKzQ/+SQdlMGrcA4WTGGkdLIuW+cnksueLGYvRI4dmUtIYyMF+bIeHKOknnLCnkCGnvkAfaUlTlmklJdoQCF7a0Tqk9L8krcY/SNQDcSawafGW+WLzJj1qaq7g0PgGcCJjY3C0CJDKmYrqEkNH3EcxqJkxZm1jYNASFCCNmh+XcQTMBkeFGghttzaQ2UnExIn2BWFd2UhK4uvZaWEc9rfeORoBjrdRmuEXh72RtHeMEONK18am+pzjZiF29qnp1hOwsxZOODlKan2xdFeoZvAhCeSM2o6apqampqampqampqenD0VuNmnzsANioEyVGnwE/JvjXI/Kxt9aeVNqIklglNtVxFoML+9vRWpX6I7RAYVfQblZAxLg1Y0K+7BC78jsBmAqXZPcybWBeLc9FhNzzmlbgZOdW0y9Wyc0bX6aM++SOQEII92YgrSMms42PnL/s4GZd/z4HtgptVWtAyoLxywFpKMaBWhPT2joFA+2agWWbd14y9OixHK0pihdFuFvgTgvi8z1S59HdmWmSB7I67ctoQOCTM4MqmxFBMyEPBhHe7Wf86vIOX91eYTz3ZtQwQCdnbJpuA+r6O4fDV2YCxQvAjUB/UwHAQNzzWgEOBfyY4R4WAzx7hu+4GA4Z6eAxPnPwo2L3wlIxee/LeBzZsToznziZkUNqIGJKguFVKgaOmufmCJwEnNT4QHteDRH/EBFePEAud9aklAQEoL9JkMCIR0svkRiEOtw6SFDITqEzY5EO3WHBxX7Cry7u8Fn/gNfLDlMOeHE6Ima31ppnJSyLA27Der+EB0Z3b/eQNSuZYZMHgptcAfkCbkqgmBE8ryNj1srkwIugfzVv76vf7DBfMi6+FgzfjMj7AOkYfpRtvKvAoykraM5gNWCxdB7zlxfrseZrh/EzxuHPGbvvIpDNNKvJIzeW+7ep6a/ol54b/tA5Cj/n+n3oa9XU9EP0S9znv/Tn4LvUT7l+H9M6NTW9Tb8kW+U//OkfP/j32s+xfh8z/+atRg1gCYLcb5t0cYz588O6+VNn5kDqgm2sz1YrbDU/hPnLo1VpV05G4bVIKNwYYB1xEmcmjhaWCxfYrtULM7qbxeqwfdnIewP6Hv9km9LcO1BW+JOdA5Wqb/GlSSdtvJF0cGuLD0cD/ZIArrfz4qxWJb7j1SCqr4EXRR91HV/yZzOprKaarAWqpEkMJOvhFsHuu8KLYUCDM35Ob+mT5ZKQdlbPDAKQ2BqaejHTRQBNZImaoAAr5tnjm4cjAKDrI7JnSGbETEAmUCRASoJmquNNWkwfA/BWQ6J7ELiXgnh06znI4JF3Njrjp1xGmawKOpy1mBe8pn3suplB42Y148aTjfAsZY1zMW5E4U4LpPfQ676kUgQYN1PEmp4c8JmZfCCU5I4xc6xBqYwNXcEMGg9Ir9B9KmAhQIWQMuNm2mHJzv43ORApPAuEjenjWcC1VWt9AwCQknZZilnTbYkff8qW1oJd09pCVkMs1uSkyIM33lDvQBnYvxD4c17fQ1LbwlJ9P2BlMOXL7o31hYWsACaEUUDfltGwaKYgSUk4MSEPDvpX3+VNTU1NTU1NTU1NTU1N74vevoVj2xzmgcFR4e9LmuLzYKmTk6ymSiopCk5qJonaZvL8uYcSYbjJZTSKoB7IgaCTJSnEGaOkjpDkwTbpnBRIutZw85yMj3I52PM6wJ8E3VevIVd7jL86wJ8zwn0l2doolPiy0Z4E8cjr8YyZY8aBG6MlfXouJo+NPc0XDBdtNCd3th77bxP8mNbRKn+KhavjkHYOemXV1AbsJeSBEE4J/bczlqc7xAtnpo945J4Rd4z5mrZEC8HAvwCoz4ASVAiazMxSp4BTpMXjVvbY72fs+whRQIRxL4y8MGgM4EhwE+DPpUo9K/jBxpzSDpAyCrX/S0T/l3ssXxwRD96u+85jufbGA/r6DHWM5bqHEqG7N+NGOlphxHXkyI3W2jQ+D8iB0L+WYuBlS10pQEsCv7wD7QekY2fJnkXgcwKJGRs8OOSdQ7z0JYGFFXSceyprbMbeci0GBRZAe0G3j0iLg0weooSYHW7HAfdTj4fTAMmEq6szOp8RswMR4J1VnZvzVGf46viRNXAtx3Kd2BJB7mEBxYx86KGebSSKAFKDV7vZ1in3lq5ZLhj9Tcbh66m8x0qjV0crSLtWfVM2I3O5CGbOuNo+Jut4n3/I6F9HaxDLZtQgCRBcMdYKzLmp6T1WS4g0NTX9kvoYv4ltamr6MPUxJ0SafpzezqhxlmLwoxky83Nr6+nuZW0JctG+yfejNfTkjrFcB7hJ4JKiK4wXV6C5eV9SKaUxOA1u23SeM9yYIKGOXNnokPT2GA0OYC4jJYzzc4+wZ7jpAtJb0iLtHfJugJsEPGf0NwnhxPAPZqYA3dowBRTeTE+YP9sDamwQdYR08KCk2L9IjxqQLPESj4y07+DPUuCwwUaslvwGr6eO/FCydE48HCyR4QnxwoMOtnFPPYGXMt4UbaxmeQIzyuIjwAgBGgQUGTR6qFcIAw+JMfepontQXbLhW4ab7XEcbWSHzUWw9qZY+T2WUInPDtZkBSAe3Xrdao24UjHYHCHunbViLca3IW8mgj8Xo07U6rgTFdPH4kccM/jVyQysXz1F7h2kM3PMXp+DlGYsTgpJCqpJrUWQDt5eR0lGxb3xgvy5cImCQhMhjgE6M2hyyJlwmh26fUTXJTif4TzwZD8icMb92BufhgVx8fAnhj8R+husXCTj0hD6O0V/q3CTGhB7dgU+7UvzUkn5ZALEGp+oQJEzjMO0ekDOeEyUBG5iuDkDirUS3X7JxtAkMJbBro2bCv+mJM3ABNmXGI/05Z4T4//I9l5ranqbfon/MGgGzY9TW6+mT0n1s6iN8Lw/auvV9Knp+59DbYTn/dGnsF5vNWoqLNiNGWnvMF85+EnRv0rlG36yKuBzXMc/xt8cEA/OUhVzNpAp2+9Z85FtfLnAe632GWvFN88JJAaq5aUkBEpqR9exKUsoLFeWRujuunUUpaZxOiZ4Bfz9Ap4TUKrEfW+AYi4jVrmM0KQrg7t2t8nAvwPBnwX+PkKKmQA1eGw8WLsTLzb+k/euVIvLChWu1dkQM3+Wg8Ny5HXUKO1KEmkw7glHgBaFPwMpGsBXBUABBFtduQJegckgtyhjMNF5RNlSE9zZhn94qfAjkIdyPWvFN8q411yhzJZaWq7Ceh3TYBDa3TmZgQCssODcEdJgQGLKqzu0jTeVY/AioFwMFC4g5ESg0wj0HeZnwzo+ZiBkA1SLY3C20TXODCTAjQk8GZdGe4MiwwFpKK1jIyBdMY0SmUkz2zpJZmgipCDwPsN7AbPgqhtt9EkYOTGic8iJ0Z8J3R1w/FNG6gnLhV0rccBwkxHuEtLeldEuBpEZUbmvwGOY8Vbr2B8Bt7W0ftX3lxQgMc8ZXNYuHv0GdRZL0ACAeLeya7SM9JWlR9qxmWjl+vZ3j0Df8r1xrqampqampqampqampqb3Vm+HCZfxI3+K4FTadQDwpY32iCcslw4kPXbfzHC308bdYIPHLtfeoMKj8Wf618nSCZ010/hTKiMztklPlz261zP6P0VMv73A/NSv4F6gNBQVA+n4pwwlIF5sLUf+JNj9JRrMmAnxuodydSoMYuyiIPduHZ2p9dwAkHcFQDybkRMvw7rZdVOGW8g2zB5wUwYntdpwEFywBFI4C3JHOH8e4JYyIuaMB+MnAc+61nRzMiNjOWxcEjcThr845J0iXhhIhxcyI6IXaC+Ig4Am+7k7MXBicDQmCxjwM2H3MsPNini0TXzaAUh2DpTsuYzZQ6uJFkoiZv+tAX/TzkF3Hu6cwFPE8b8p8s5j/Cz8swYwXmTjEwHQo18NHxKCP2WAgPz5E4CxVp8v1x7iFcphrXLPxXHwU4Y/FaOic+BiGt3/Nhh42ZkRFS9lHRtTr0BQaJeQL0u6RYHjccLT/YjbccAcPf7xn34HTQwKAs0E+dMOfiL4M+AmtVTYBPS32FJSJT0DtTE9DQz1G4umQqXdnCGeEa8Mspx6gp8Eh28s3jI/6e3eywouDKT5eW+JK1dSPK6adXUkqvBsyqiUBDKjzxO6B0F/k63enLGmoCpsu6nph+rn/Nao6YeprVfTp6x3maz5mL95/SnV1q3pU9dPkaz5/mdae5/9MH0KSZqqv5KoAbQ0OhkLxDb1uWOIsyRDZdR0Nw5e1YCmMxnI1NkG1QwRgZstGVE3m1ZTvbXhpMsBae/RfXsCvbqF/v4Cy5GRBtu49jcWx1E2Lkp3SpCeMV270r4EuEUQXp2RLwekQzA2SE+FG7KN8uiubGizJUp4FmulGshMjFg5IAxKtpnmbMwcTlaNVCuZAawAWCotU7kjpL2lgFwsz58VvCj8lNcaapIyGhR4NXMQFd0dIWbj20CMM0NCyEzQncDtMrIEIBJ4ppVFw4a0gZthDVNRDCarjLQviY8KFRZdq7DVmUGgROAs8PcLkBXpsIfUauwk8A8n8LFHvHCWoDknUOeQUWrcCygYwGrmmVFTLjKRtYmpwk2pQKQBou9xVMjOJZwT+BwhgwcCrwmrtCfk3TbSJX1JHWV7LLGCO6vknucAWRyGkHDsZtyOA3Jm8IsOHAnxeQIyof+OrcFp3tJCbhHwlFczMR2MK8SLruDrujYEG3EisfcBnJmbqSfEo90H4XZBugiIF84Ms7y5KHFvDVZusZYyG7kr7WHV/KKajKK1Uj33QH9fRqQ6Lum0LS21lZE3NTU1NTU1NTU1NTU1ve96q1FDGeu38TxlHL9OQDFrfG018sbdyDvG9JsLuHOCPyVLHTjbdIKMZWIJDmtrAgPLlcf07ArdfUb3coT0DnlgTL86wl/vAAX6WwHJZgwBJdkglgiRYOfDSeEKeDhfDliuOsQLZwkNAP1ttmrpnUfaubVxKveWgqntOGko9eGeDXzMADMAZjNJGAilVUqZgMA4/PG0jlZp7zA/7cFZ0d8YpyXcJ9to57p5BvLRl3EqO7/uJOtIDEegu9XS1MSQAKSDmvny4KDOQbyimwhuAbobhZ8UadhguySK+drBzYz+JsI7govGd5mveD2PdUyrGFnLJQMXbI1aiyANtj7xogOoW9NLVLgnWpuwoiAePdLzAC5pne4uov9OkPfeTCndjA04QrzqAQX23y7Ipcpa2c4lB0uMxL3dotOzDrkj7L9ZwIvg6p8Sck9YLhh8JMwzrYkamgh0ZugXgl9f3+GfvnkG3Aa8GJ/gBV+DFgYlgp/N8Ov/7MEz4fhVYRSxXQNrPNuSVwb4LamsOYOiIO091G98meqJcBRosHvMRYV7bWky/+qEvL/CcmR0twn9izPS5YC8cwgngZ+3kSbpCerKemfF1X86Q3qH5SKAkyKcFJwYKdp9GS/8OvoUHmSFc2vzaZr+Bv2U3xp9jPopvuH5FNatqemH6sckaz6Fb1r/mt5FEqmtY1PTm/pbkjX/0nvwU3h/vcsk0qeUpKl6e+uTVpCqbbLDuTQd9cbVoCRWz/xofMbNBKpQXdQkxaOURa3W5roRL+NVnTf+iKumSTUAyngIaG2+ocdw1JIwqEaDtVR55MHSDJRLa89icGE9+nKeljaoFd3VcLKNLr2B9ajpBQmlejnasfLOQ0HgMQIpQ3sP5GKCFNCutfRkUBZQllLhzDbqVSuYFaBo61RTKC7arj88KNLe0jkcbSwHKMmXaKDY7t6MGiUzdZRt7CV3VK6TwolCz4K0Y8T9o1GybI1G1TCypM9WiV6Nh8oSmi8cOCn6u7yud+XyiCekwVqy7Dop3HkxxpAvY1mww4rjtU3M3Sdg8CtwuK55HakSb0mT1FsSi6Kgu1kgnYOEAAmAmwz0rK4AkjOQEoOh0EzghUCzs7G2VE1IWx832Z/uwZJjKxDY2U0lSlu1eTFskMv/Vg5NPW/aYMH19ZLUkTYBLXFl1ZAANEXgooeymY0q2zGUCfBWge5TgrsdQccBuCzw6qhQp+DahNWV56vvvbwlcZqampqampqampqampo+DL3VqPGjMWCWpxvjhZMi3Ke10ShL2cSXTfv0tAPQwY8CztYupM6SK0rAcmEmRa3MHl5lpD3j9T/s4WaFi9YM5E8J0+c94t426DVlwSXRg8KmyR0gHcC5AIt7wngMZhw5QlikNPQwxIfCACEsVx4cFd3NYumOg/1zOJXxrr6YHKrg2TbZae8KG2RrYlJPOP/d5Wqw1GOmg8f0JEAZcJMzfgxQTCQHjgI3K/xDBJJgeTZAyphWDoTlaM/f31qSBjBgbnevZbzGjBgpJlncG6tFHGF4LVt6iYDx884MmdmMo/5OSuV0qT4vJgFJWScHhPsEnjPCnbUTWVqDEEaryeZZVh7L2gA2MbwH/KSgpFiuA/RJt1a2d9+Zy3T+3QVyb0ZdeBDwaYb4Yqw9YqqQFpMuCfxkxshy6cA7xv5PoyWkDg5uIQyvgdQT5itG2gPLlSL8scN//ep3cA4rtBgEdK8JfkQZTStGzayrmRK+WZAOAQ+/6eAnRbjPcGOEf3lCenpAughIXVgNQiVCGtx6P0CL2WgTclA2aHTaO3T7ARwFu9cZvBRzj2xUqaaNOFoKjZJda3dOVv8+dMiDR9rxWhleR8tU7DC1VSpeOFByxQhsZs271l9z8z+mJMS7+NboU9K7/Naoqanpn+tT+jb1XaglkZp+Lv21e+xjur/a++rH6V0kkT7FdXz76FNhmNSNoR8Lf+MRl8VgvGXmQxQo9dM422Yd5Vt+a7vZTBYlrDwTcdaCRGKMGVrTHbbxfNyYI7Uxhx8ZFY5QmTEp2IZ/rdQuZkJtjAJK4qCkc0C1qUcLX0YAuJKqUDMlKnekgIdXuGtJPeSe19dHuiUaasuSOoJmAvGWtqgpH4oZECnHxQrThb0kGx0DkE/GTeFk/JI60qJUzrPWgpeUEGdARdfEkYBAHmsSg3QbHzNWj25/ly0txUkAEUsAXVoTkVWI69Y+VEaaUEyFN9I5hWFEqlurE5Gxj4rX9c8SH1pG2jxQoypKBo/mTOVal+fNZuQ4sXuNY7n2zpg9HG3N0g7IO12f0y0GC5Zg6SE/mRm2mk4xg8SX9f3ee0LVarfLaNbj8cB6/tv9XtrFlCxoRYB0vvB5SsKsq2Nh2/1UU0Hbc5ZjBqumr/eIFoOHhNbf4TqCV9I4qvjnL6KpqampqampqampqanpvdXbR59gaZnz54zwoNj/4WSb7gLZ1eAKsyODxwReMuKTAbl3CPc24pEO7g2DxJVNvpsEEqw1SoIlUTiaCZF7hoRQ4LqK7tZSHNMThxwMoKreEhEkpdr6TtG9mqDPBiwXfjM8Clekju74s8GEJdhYzcNve7hFcfh6NDhsSTJA3RvVxrJWlSu61xMoZky/voAEazPiZMkH9YzpudWFd/dSqrgdvJak0EOEv5sBthGwfLDf5SygyRqtpLZhZ2ujCg/A/hvBfO0xPmdQAlzc1nR4neHPGf5pQO4sDaQOOP5hAoki7W2saHriLDV0FmRv6Z1wEoSHjDxYk1C4ywb5dYw8eLgxAsDKqvEnWY2rtHOYnzj0txn9i8nq2AmIR4fcM/xoCRXATJuHv78AYEZPmAV+yqCkyJcDpHdwi8KfM8Ldgvlpb/dGR0hktdRultXoGr8Y3qhBl8HGrnJv5tbhT4AEM/P6G4BebiZheDBDSUe7F6//02yjbIO3NMr1APHWmmWLDCzXHZbrDn60tNfSd5agWlNmsRhbxShxbEDt3pXROjM749MBvAi6mxnpELBcd+Bo5mQ8WkKsjhxW1k99/1SIcDXvAGsY41mQDg65Ixy+muBvR0y/vrCf9Vv6q+lfrx/q5r/LlpL3RR/Ta/k51JJITT+HPqVvsJv+dWr3QtNPpR/677uPkTHyMb2Wn0MtifTj9FajRlxtbCr8l8B4A95SpFRTL9Z24x793ZpCqTvskphYR3MYJTmypQjEl4RBbbchAthSFtIB6YDCUSlhgQFwIyEdOwOwlmOuSQfanptSbTviLd3DgAQHYrG00KOUBym28aCS4KiMmVyrke8MLAvAmoeoJFsS1vEp9fToOQDUzXdBwdTXSUntEN0GsLW5ssKTiVi5O9uG3lJOljB5DAh+xEvRyljBej3tZwAvgtw92tATmbFFWBu8OOuW3kmlsckRKJeRH8draqkmiWpqhx7fMnVtakrEEQSPqtKzWsKoJJzE0fa8siVxaiMSV9Oi/A4n48m4WQujR0sVOSBhAwVzUriSeOEpg5MgHWlr4yoGTB3xW38eBe68wO18ue9LuiowhAg8p5KWKhXxZCaN8GPDzxJW6ip3iUryRUsLGNY0z/p6CZCOHrFpHvGBys8AMwORzDjkxfhG2ryapqampqampqampqamD0ZvNWrihQep4vi11Sg//H4PPxqDpY6IyD4gFQgsh9J+MyWkYwd1BDcK3ISV62KNTXWXbn/CWeBLwiaHbUQmDcayEWePTTtC2gHn35gp4h8I6aDof/eA19/tkQ493AT4Ubc0ggPSjtfETh2DOn9m6YnDnyPUE27+zYAwKg5fz5BuA90ysIKJu7sMlwTjr3ZIA2N6aqMvl//vLShl3P/bL4yBcpvWkajaEpQODvN1v06hDC8jfGGPQBTxqgMYCA8GbF4urHVKAkF2jHhghJPg6r/Y+UkwOG81N6RzZeO/JXmmz7p1HIuj4vDnaOM3fqvzDvcJ/n62ETdyyDtGOrjy/MBBADdn9C/jCgH25wj/X7+BuziA50toYMTLYOvUVwh0MZQUCLcLOGaEzkDK6WBA53gIa7qKROFGS8zkfWeNWLD0lHhL/rjFjCg7vpTH5rVNys0GMnaTJVxyb4kSLYBk4xRhTfr40RI9ICAdAsbnvrCNbBxq9zLBjbkAke047rt74PUthpsDtO8Qv7hEPHo8/MaSUftvE/xDRPfHl4BzkC+uDFRdrhdnSyLp0VuV/H3C/CQgDYT+1gyW+draucyYU/hTgnSM5TLALYruNkI6RtpzGS9z6O4j3MMC6Tzy5xfwpwh/ijj9br+OizX97fpbXf1//+t/19ISn7ja9W/6KfRD76uP8Rvspqam90M/9vPlcZqifSZ92mrX/4fpr8CEZQUI544BYqjX0shk40iUda2qllplrFg3yJzMiFjri4G18clSAfYzygCXFIp0xqdRJht92W+/V1uNwJYw0K4c1CniAYACfiwJBEcgV4776DyVN5YHZV15NvoofcKpJCBcYedEtRRNYNSGKTcZC0Yud2a4lMdaC5Kurx2P9smVJyMdI6uHGy2B4adcgMTGIdnaqnQd4eLyGqQ0IdUUhR24JIMc4KU+1pJHubM5sJqSeXw+0vE6fmVpoa3FCWxwXM2W9IEALmXj6nhvveVkKZRqHpnB8IiVsjJ3bFxOApfRrEdJj8JzkfpCCtfITaVaWjdOUL1+VHg+aee2tQYsraRlhE0UbhEb6+JimmUboarwZKhCA5d0EEBkDWP1+BZvopUfA+dAXQc4t/GNdEs51eurfQc4XnlDSmVMKoolakpaLe0d0mDjalYVX0DPxVzjRUtKx8FP7g1ItL1X7LEcHSiF9R62c3+zkaqpqampqampqampqanp/ddbjZrdH++Mo3LsAfVI+5Js2Tu4icBJ4KYENyriVY9YkhJ19AVE6whG/8d7QBUyBEjvkfalgSkQ1DAoCHcR7hQRnwyl0YkQj8D5NxkaFN0LZ+BUIahTpCcJIMV4MwCJsFwLOFl1uHQwIO3JdqrhnOBOEfOzARIY/Y2s4zSkBSi72MadlwyOgnSw1+xPxoBZrgLy0cNNim7K2H+ToES4+YcLKBH2L5KNThWToCYhcm+10P4scIuAo2B8HjA+87j4SuHvZnSvToB3uPuHJzZO9ZDfSFMokQFoVZEHh/nKWRJpFAiw1nHnYoBRAoaXI6RzuP+7AdER5kszgFzUdfwsHgNyCOhvBeFzd2pyAAAgAElEQVSUCsyWQPdbVbiSMYd4yeDTbObMs0vkQ4d4YVXoaaDNlFlH2wpseechvWK58silkr2uOaiagI/MOW9tYP3LGWFwyB2vo1LxyGV8ycbJzs+NX7N7mdd0kTpCvArgWeBmQbywhNDwOhtPKAtQ28oC1hGl7j5vkF6YSZV7B5TEkpmPDHcx4P9n792WJLnOK83v3wf3OOSpCiiAAEFJ7LaRzcXYzLzAPHnfzDzA3LWNjUwtqVsiiWNV5SkO7vvwz8W/3SNBjYoSCYqAuJcZjMiqzAgPD88kfOVa36rRg2tz4bmyfWvPHQ52MafPbi6Ps6w5zZXwNBuseM48//Urnj/zZoY5MzddcmzfFdykhJPxgsJ3T6gT9oct+Wrg/GbEz5YIOl1FTq8daRfxU2D3dSI+2WpVbef1e7Djrn+TfgjH/z8ir6arq+tPo9/350j/DXZXV9cPpT80qfcybdx/LnV1/cv6oFGjImtqwDguljzxZ2N9lE1Y2Shg6ZSQzEyog0OdthtjJV+P9jn6YrGnygsGi1oiJzqm14H5ypGuIV0p3CRCrNTHLVSl3iZcqHivKFCzQ1UsZRMgtzXxhdUiisGOjzPSpsaXSWn7PCUeLGVRR6sQ1SBrusTSIC84N8WYMKUliPzUYjRtcUla6iFfvaD1KGtFp0aHKxAmY/pQQXcjGv33uD3rAlGbz1YP6ToaELdBfVWEum0MnQXI3CpedbDzaTUkAzW/PB5ofJtix1aGtirU1qGkcnndLOfBgxdbK2r8IjcrgYvR4mfFT7qmOdzcklnJjtcnXfkrS9Jkub4sFWSgZ0tuvYRBX96DsjHDZoFTrwteypouAtdSJW1+/MV7vl4DAiW09E2DFZfRX5IoVVf+jZ+rmTf7ePn+WK7p9rhlY99SdTCek08VVfv6Gu1r3eRw7ZjCCepgy2duNpbOsvxk6RtFY0BjIF+P1MHhZ0tV5Tt7ruFJ27XVElKbQN7ZtRQO9fuMoK6urq6urq6urq6urq4ftT5s1Ize2BzNXJivhHiEMdX1Yze3G1zFFnvuz8iUyK/3qBPiVw8QPPf/60cgsHlnXJblptctgNtibI75ynF6I6QbJd1U6qby+af3bELm7x9+Bgp/+fO3jD5zypG5eA7TwFFG9OgtuXEnhAOE4zIZrfinM3L/hPv0qq1M1RVY7FJl+zhTR8/0KlIGR9oJ4ayEU13TDohVcPxUcaVy/HSketh/Ndt60egMQjsZo+f0JhDOyvDYkhpIY644wqkyTBV/SkgpTD+7Im8dZXhhMFUzcsTbUlXeOeYrx+a+sPtqIl1ZmuV86ykjXP86Ew6XVMh8N6C+LQOlC7cl3fjViPGnQjgX0j4Ym2bvqBGGp9pMA6syLWaVXg1tYtuBM0ZMaNDgsm1rT4diC1AtSeKfZ0TNOLKKkD1W2jVjBUvRlPGSxko7h+SwsmjS3jhB8ai4qkw3ZoJt3lulrg72GOu12+bbadPe8djqTmpmER7cZHwbq5opw7cHS9d8vFuNmgVwvaSs0s3AfBOsktSqaFRL39Qg5BtjH7m0QJcLItpSXo7jTUtCHQNuquy/zszXVhsLZzOTcjOhJBXIlXqzJe8jh88G/Kxs3iZObyLPP/fsv6rc/OOZ8+uB+apxa0JkvrGU0N3fPFsKqqurq6urq6urq6urq+snoQ/DhG83xstIVtmJh8arWUyLpOuNbNk6yuBwc8HXZTlJKK/2aLQak6hSveBa0sBPQjzKutwTTpYSKRtLA+S9xWHeP+8YY8bfzjhX2YTELsy82T5TVTiXwP8Ir3h3iCQn5K0wvnVIEYZng9SW2y2yGcgbTw0G0pWqlrhwYlWR6NaUxFINWl7jspJE4+/UKvj5+wtX6xT1NhiUd5Q1zaJLQqcZAJZOcnC7wZVqC0vZkijrIpITM8sEwrmsC0GuJVKMUVPtHGbBTbZaVUd7jVYFal+rND6MI28cflbc3BIbIiu3pUTrL4Wzvfa8tXMyvRqa4ZFt+eh5pu4i8+toaZ2sLYXU+ETucs5cqw9ZDaexcwK4NjHuiiLalqVaosY3I0SDoy7JnALDY7YZ7HZ+/KlYPW+0OXU/WdqkDPYY4VTWdFQZ3ffmqv3gWjrKkjZlP6ChfY5iZqKDvA/r2lXZXODEFVuXoigEY9aEY1ln3a32V6iAircqWDuOdf1sroSzUGqbDw9CmGwZLF8Ndo2KvXdhaqkkb8tWw6NdB9OrSA2WLtLGbpK2ZJ6vBtzw8irt6urq6urq6urq6urq+jHrg0bN+aOAT8r2qzP+pGze22/+095u9MOhrDfj041nvhbCMTZOi1WRTp9t2w0yK0SVIpZmSMZrsYSGGKNmKlS/Q6pjem3Gxun9llOo/NUX33E9TGx84jpM/O/X/8ToEhuZ+b+G/5n/836PD5U4ZM5ybStAXynDY2J6PTbGCN8D/gKUwTG3hIboUoOxitdivixwWkQoW7vZj4/ZoLkLz/iUqNEzvx6YrzxlK9SpTU5Ht1bH7DmFvHHI3oMq8bmlXg51hRWrl7VeZmyTsJoiGpop1lIYNTpbMSqVfBWtOtPMl/j+hA6B6aNNS+UIwxMM93U1f/wp4+ZCGXaIWirGzQX1kbxxHD+xNMz+a4g54d89ovGO02uPT0o4X6pOurVz5CcDTpdq62E1tITNXNs89aU+5JK9/qX24yczCPPuwqiRpAzfHZHjhMzXa4VOB0e69o0RUygbS/bE58z41TP5bst8E5nuPHkr6xrVshK1+WZCFNLdaKmYrWumGdTRka48Lyfb7c0X4wxnq6eVXashvZ+QUlHvzNw5Z/t8Fy2Z5kFHoQbP8JAJkxlwkh3n154ahfHevi+mV/ECZ05qa2Ji16ufKrtvlPnGcfjUMzwp4dTqVbFV2ipMryMQ/+0/Gf7M9cfoTHdWTVdX1++rH+LnRmdCdHV1/SH6IX+G/PZ/E/WfS11d/1wfNGqGRzNi8t7WZBauyFIn8alCsQTI+OhwxbdFI7+yXvy54ifFT0uXxG406+uxLTFpY5VAuo1MceD82jHdCmVTkaESxkwcMr+4es9NmDiUgdFnomQGyWxc4i4e2V+f8aI4VznuCulGOH7sUDeu7BYyK8ekLumJxnxZ1cyaOjimV4FwMHAr1GYONDZJvTyWeqFGjw6uVaBgvK+EsyWQlgRMHazeYxPi1RIrntXAGe5n1DtOnwyWWsoON+l6XjUIpRke8VlxU8EvNS4BvCOcMiU6jp9GXIHrs0GPbV2qsrm3laK884RjaSZNRpLVe1xujBht8OHGnFnSUzU66t0VGj2b+7ImWKTV2Nysl1Wluqw/2d/T6lDLKtfC5AknJT5lytaT9p68M0NwWXtaDEENDsZhvb6W92v79Wz/6q3WNjzan+e7LWVjqaR4rITJzBKA8cHmufP+8m0glfZa7bjdXIlPkHfOTJ5qn5NGUOco42iz4S29VAePVLfWvmQMjddkr394NjOlBmkJJ0+68mutS+rFvMyjtDSVJXvOr0MzEvne8YajvZ/rglr7HFEaDPpD3+VdXV1dXV1dXV1dXV1dPyZ90KgZ303UwXP+2PaSXVaWGWupiszVaii1Eh/NlAGoo7eKiAjDQ0JKNa5Ne6wahTxalWO4z3bzLsJ045luhfm2TXJvCmEoXF+duNlM/PX+G3Zu5u9PbxhdwokSpbB3Ex/FA2+uDlQVVIX7fSbdeM4fOWrw7L8uxKmu5oE2cyVvzQwY39taz2IouFQ4v9lwvnXsJ6uwSHHrrDIYgBfaqk8zEUp0q2mxeVfX2oq0iXAwcyIcM+F5Rt9sVrOIqoT3R3SMpF9uLE2RIYaKn7yBYge3clzCQZA5I8FeA15QwB8zbAKnT8xo2X11gT77ooRjIW/NIAjHgj9MloIqdTW09MWikVMhnGWtZNUgpFdbRJXx7Uy6jZx2Ad/OiUuVcMh2PHJxCUSBsoCE5VKVGoRwhvA0oX6DXl8mq8fHSjjWdb1Io3GTyuhWLkw4VeI/3sMQmT+5ws0Vf8yUbWC+i2viKT4XY8BszbgZ3p6Qohz+6orqhXioDRp8MZgM+Juo40DeGJjZZSXthbyxBSuXYPe24KrBqC8z9PbeL3BqP1f8qZL3ntIWz8rGrfydq98kwnNCvUMHabPqrEtW051rVTa9cIyKEpO+AChfTBrU4Np6aXt1dXV1/WD6fX4D+l/q7/6crq6urq6urq6fon7I5PwHjZrjz7frv6tYwkGqGkOjLQLN+4HamBsoxOeMS4UaBgjNpPBi5s1gN6VgBoTUdiMb7KbcJ2X7VpnvPOm64q8T292Ed0oqnv/69Dlbnxhchhr529On3IYTvxwhqWcbElMJTDkQYmHeFhAzMfLW6iZhahWjhwRemG88OTrS55aMGB4yTqA6vyYgwqHgTpm6DYC7QGiX1adzsYTIYJPNw+NlXkkKuGomiTT4bAiO80eB8lkkHq1eNdyboTV/ek0NwtgeQ7JVhcIxkVykBofLlrKog2P+aGc3/qPNd0tV5ptIDcLmO4PnTq/imvhYtMB307UH9oTnGTdZ/Sk0c2nhCUlRwtHSROnK4bIQnwrUS6rIZTNgShSCE/BC9d9n1UjVteZmvaGWAlKDBz//8ho/V6sEnVxLH5mZsaR1zm9stWupsPlzAy1/ckMdPPNdWM9ZGSwFYzweMztULuDf8yc7XFHiU2l/7izpMghuUob7eZ3g9qfK7ls7zjIK8aAMj41DUyA8F6SyMnDWylzj2UgDLlvapxKfpIGIFfVjgydbjS48nFDvia8DNbZrdBTma6tt1XA572V0lM3lfY0HxSXW17qe464fjXoFquunqh5N/4+hXjXo+o+m/v+nP131ClTXT12//fPnh/wl1ocZNXfGJRmfikFVR8HPBv1FjZOS9575yhHOrR6TK+6UcPtIWWaWmyFTR6tzuAJxtqUo3MJraTe/h4KKp+4quzGxH2dUhVwdv3m+ZQyZv7p6RwIep2umGvgs3gOw8YmqwkTA+4psCuqi1XxGQSKAI2BJIC2W5CmDtEUrJT4LFZA2PR2PFX/OuCmh0Sos7pyRatBeYJ3QXjgl8ZCp3lE2rs1Sm5kgpeKSoFJ4/mzL9Fq4/sdCPCj+eQJVTj/bUL0wPGSrEZVqy09TQXbxksw4mxFRt4752hIZgzPjYL4ys2Dz3t63+doh1QDB0GpHzaxYjAVXGjC3WJ2qRlt1WkwWP5kxNG0cLgnhuVgFzpm54Eqb5/b2nkKb324T51LMqLAZaTuPi5EA9v6kvbB5B7v3MzqZgTffBIMfA4gy7y2hEk4Vny6T2vPdQB1awiXTZrbtvbVZ8sbQaemWGqDceFxRdr85g9JWsoQS29T5OaOjR0ePnyrhWKhxIO2F4UnXBA7V1p1gMb7AzxioevkOW1a8SsUdM+6cV+5N2QUzc6oZa3KcEBHCaU9ysqZ38rYtcCFrvWm+hnSj63OoE8IJysbeC8nfr0p1dXV1dXV1dXV1dXV1/bj1QaNm93Ve/92JNlZGu7kfIe+t5hGPlkTxp0zeB+ZXQ6vyQHhKBgT+2QYV2H+V11nsOghzg8DGg67piM1bRX3gyJ7pJuJEcb7y8c0Bh/KUR/Z+5q/33/DF8I7/Y/v3/N/+5/zN86dUn6hR8H4LKuSdMr22lSeXLCGDwvEzq+7E50I4Ci6ZuzDdhXXSezEz4rNHnaMOnrLxzbxQpjszTuLozaBKlerFEiyZdmNvZkM4FMKhNpaNIx6Xas1SnTIjY6kKSQUE0j5YlWVnrJNwtvPkZnsssrFwWGDHCmNLrpTREhj7L1uty1+iFWlv9aLFTEn7QBk9062lc1xqnJ5oX1Pb1w5PlkjyUwXHZTGqKOnKk3ZWd7IkjMFxh0ebZC8bbwmbNgpmFS6hRvCTwY3D0Raq/CkhuVLGPWWwRIwUxW1A1ea2qTDf2vlxyda9wnMxEPA5k64i0qa0RWm1rmrAX4Xp9diWuASNwvTKjs9PzfgIi4nVWEzVkkWjawtVfkn0VNJNNKOogaaXepw6Y/zE50yNjun1iNTB2DKnbOms9rjL+tjhi08sQXMjq9FVNpD3jYPjzQCqg1Kj/e+iuULZSjPFQMeeqOnq6vr91H+z2dXV9WNUT9B0dXX9qfRDJGj+tfqgUROfUls58lB1rXbUjd2Iq4MwmXHgTxl/mJhfDaQrSyC42VgviKxz0cNjsorMxlOjVTrCua3+tJvheFDKgzDfeoqLlFhx8RILOOfI1ic+Dk98Ht7zF2HLr8sDo89kdQy+IA2oUiPkDbSN5PUx0l6QKuwezUjSYJDjtLXpY/8idVKjg+CsGhMdtS095Y2jRhB1uFnwTwlxxt/xorhSqUOwqeip3cA3eK5vk+TSeDm2krVAbG3KXEVWo0SiJTVc0lYDasybIPjJajfqgAatVWeVGadKeDLQrlW37FwsS0oLILoO0gwbR95CPGBmTfMAjLtjnBc7hgrVDA5XKsxttp3LOdYlYdMSNQuTZjVClrdEbKI7HgpubqZTrshpxqUtUq365MqF82PT5JBGbxPyczOQzlbfcidjvZSNv4CBS8Wlgn86Q8r4fVxBvzU48sZMkTV5tDB2XjBf3FwJJ1k5NAv7p2xsjt1m6KHUlpBp/7uklPLOrUkalbDuMckyTR4dh088ZWvXLoCboQz2sXgApQ5Qts0sczZvvhg6NUA4CxQog64Jp66urq6urq6urq6urq4fvz5o1Cxa5p/nF3yZcCrEp2TJAYfVgabM+G4iHAN5a6s850+3qNiNtajxU+xB7EZY1EyAMnjGRxjmagmEg7L/lVC+ixy/KNSrTK6OrI5zCbyfdvzXwxe8y1d4+W+8LVf8T7tv+NvjJ/z6+dZe3CaRd4FSrK4jCufXDjfD8GzVmRrNiDnf+ZW14ueW2Ggqg+P4xdX68QKjXealVRQNkHYBlypXvzrbzf9g5yucFRrTxs6fAX39LKvxMn+0w5XK1f/znYGVf3FnfJ9iJlZ8trTSdOtBfGOfNMMsOKvfTMVgvY21os7SMccvdus6lZuVeMi4rAzPdV3c8mclnDLhWIw9dG2vcfflhKRC3QYzLRpTBhHj2bw/Um42zHcjeetabagSHqcGszWDTr2sJhTQFqjM/VjMDHsvPHoV8FcRP41oW+Ryc7UE1FHWBSWD9AIIsrPjrT4wPFU2X5bVl3O5GTlTQVIhv9qh0Wp7NUozT2D/dV7NMXXCfNuqUKNb36f4nBkeZtxhgpRJn95YmibIBdqr4BuUORwNYIzIaoq5zDoRrk44fRzJW2dVKm08G7WqkwZLzaBWpyqjMn+WoQiSHBoUYkWeAv4k5KuKXlXcdx6fBX/ucZrfR70r3fXnrH7d//jU2VZdf87q1/2PQ50n0/XnrD/Fdf9ho+bF/DE0Y6VNavup4I4JHT012KoRC7+lLetogOpcW4myx6hjY5bUy3qUVWWwe/j2uS7D8KTUE0yvHXlwpOJIxa/LTu/mHU4q/zR8xKyBnZ8oKhyngVJagkV0OXx7/mhOg8us60YajK9iTBj7RwrQlpoM1uvWyWlVWYMj6/KTWFqEIrgp2wLUuMBasBv1ZlasaZhlslqxlawsxPsnxDtU7i7rWuWyVGUJH5Aqq3FiBkFLflS1mo6/VG/yKP8M6GspFDOYFjNFsuKT1d1sNlxwx4Sbkk09R6t/gQF5mYE5QR0po6zvs0uKpII/2yKVpYUuz48qUqUlZCylYu+DnUOrDbXrpgGYl1TM8r6sb2rzfmq02e0yGJRaWwLqe+9Te4w6esro23R1g/1W8E/GmcmL6TM4W2YalhRUuyamhBzPMM3ws1s7bmmz2O01+slqfLaKRkugvVzAulw3ZWj8mWyppSV1pV6NpbOpSBHjG3nw20KZnTGWnCJeW2oJO8+hosFfGDUvvwG6urq6urq6urq6urq6ftT68OrTJ4MZJo8ZPxW23xQkG1y3Rk+5Gcgbm+JO19H4H/cTMiXOr/fknXD1q4xU5fnzeKlKzRCfCqEqUh3xkBneT5RdIG+MnZI3sPvO5oylBubbyP1uz7SfUQXvK4c08G7acSoD0RWCFP7u4WPuv7pGzh4/CdsnafwTe15oS0xtYae2Ss/1r6zmVaPdDKcr1wwpMzRcLqSdo26c/VlRxge7sV/rSVUpg+Ppl3t8UuJjoXqD+fqk+LOs6z95ZyaAFLfyU1CoX3yynn/XTIp0FXj85bAaXPYa7LiX2k31oC6sSRN1QmgVo2U2XZ2lXfxU0CQGOG5GUNl65ttos9e+naOkEBzVRc5vNvb1jd2TrhzDQ2B3nCm7SNo5Nu8L1/9jQiY7L/7hhC8VvEO9R2Vn5s9c29KXHW98StTBk3cGr5bazJnywmEQLmkXb3Ugycru60TZOA4/s0vZJcij4/TZnjosJohDqic++QsD51zwZ3voGqR9bUVKJT6cKVcDzz8f12qWn8CfCmXjKZs98mbf3nsHFcZ7M7g0CG6qbP/uO3QzcPrLO9QvZhjE50rZCPPeEUVXL1QqHN9YlW6+MwPNTULIEI6eGpV0U8FDPQTwiuwzWszg000ltdchkyfdFNLNv/4HQdf/v/pvjbr+nNSv8x+/erKm689J/Tr/caona7r+nPSnvM4/aNSoF7SlF5bEhZsL7jjDzkwadS3V4YUqLcVQrJpTLXyxJg3WZI4FJl4kOyruOFtaQ16kDppREY+WLKiHyAkQB84XojdD4GHYGHAY5fk8WqplNoCw5PbPC3PGlQt4d01clMbyaKyP5e8W00IaE6V6wTlFqxi3Ry+HvHBiapCWzKkU3Pox6FoVU/dbSZhij1V3sZ2f9vjZnjdvpEFyl8TRAklZODMtsfHiNS3vmz/XtoLk1roN7rIyZC/MvrAGM578rGgF2rT4WvXSC3dmvUbaBDWquFNqCRoHbjnGZiA0k0pKBVwzZb5/HMvHa2JmCXW11NVaMXKCtEUsDS+YMVXX9I19fnvvkWYOOXwyOPAit85ULeeimUL+YsAt13GNZmQt55clRaOs14NP1ZJG3lJBLytjLlVq9GvF6eX3Rtk2xszQuDPpYsgRrAaFA2pL0jhFlzqZUzSCZLueGLDzL/RITVdXV1dXV1dXV1dX109IH4YJH2qDuFoiow4Od0zwzVvcq1vcGBjmy9/V6Jhe2ZKOn9TSDTurDF3/k8VZ8tZTB2G69VY3mdW+dmtgV5ufthvYvHXkTeOeZLj+20AZAtNrJW8rB2c1pGMeeH/e8t3DFbU43HVCZ4ccnN30BnDJbrq3723aOpyK3YwPluA5vhmQAsOhEo6VzXcz821kuvWMD4XwnPE7Rw2WWCkOu+EuyuatLRRpcLiWOvFTIdyfqWFnCZCkDE+J+TqSdw4/V8JpMQCU+GD1oqktZrmkLVFTCEfHeO/xyZa3hodMeJyYX21IN6E93wUy7GarSZUxWCLq7REdAunnW/LWUV8FwrkSnwrzdSDtHbuvEtvfHJCf7UlXjvnKjJTrt0/o4cSwjZRtYHoVCKfK7d/dtyvINVNObKr94x0uW+1nvrOEjp/qWnFyqeKmDCJEbwZGuoprCghVBDOVFjOPVoECm9xWBzy1i9RbMmj/TV4Xs+JzZvj6ifMvbjnfRsbHyvBUyVtH2jl2X822CnVr12o42FS2ekfZek6fbhqnpvGEzmYk5Z1fq1nj+2QrZ7toy16N6TO+zwZr/vwj1AvxOa9m1mp2JiWcHOGUkbmSdxvKIJw/Usptxj17pAh5bw6OVZ4WJ0ohNtMwefvYLyajQvL2+dnMuDrW75mfXb+f+m+Nurq6fkz67Z9FPXnQ1dX1761/KeHX/1upq+uH0YcZNUtiINuNv3pbP5LNBo3hBUOkUMaxwWBlTdlASxu0is73kx6sfJbqhbKPlMHSCi43uOzKLGkHe1DcLNRByNUxnwxMfNgOzDlQi6NWQYtrYFljobxMx9QgyCDU3B70xT3smvp5yT+BBgb2lgBa6kdLAkRfpGGW173wR6JHF9MlKfJbrJU1FQMssNnFIJCqxuLxDUg82WT4snak0RuHRRamjhk7LEwbJ2tNShsnyKULD0gquLkg1a8pFZVmlLTEjlTQGJBxuDBV3CWRQ5ss1zZXvcCDXX5xDtprkiWthMOLGJ9HlbosM6mu56P6l9DiBuBNrMwgVC4pomZChENZAc72+h3STJZwNuOsBll5OepkfS8W6LO2dbLlenO5sYzKi4SOf3Gu1iSQrMkmsJRR2X3/W2tN+mgzPmcs+eLkMkbmzHSp23q5bitoS2oZlwgoL67Ttha2qgpSBLwloqTI967xrq6urq6urq6urq6urh+3fkf1yQwFf5htSWjwzLcDvPpsBbPGR1vAyT/bcXzjiae2YrS3G8TttwmfKnkbVraJS8ru6xl1YpPYV47DZxv8ZItLw1MlnDLn1wN5K9TBbpDHxwqqhLOQt8IpjczXA18CIVSu9mceHnbIuwgO0o0Sny9pGnVw+Jl1jjbvKy7ZOo9Pyu7b0tgobdr6zkyg8bGQ9p7za29Jn6K2QpRtpchumO1r8t6vtaCyccwt7bL7NuNPBTdlpMT1efy5rOyVdB1sgWizVMl8W0JySNWVgQIw3UXS58NqIiwJHkm1mU12PH4yw2r6dIebK+PbibIN8CoSnzLxqwc0vmK+du3Yty0NVRkezFQ6//K1PWk7FpvwFp7/8629jmzmz/hg89guK/6YkVNiUIiDI+3ttU13YeXPoEqJLcHy2jM+VXa/OZGuIukuEJ8r4ZApWzOS4lNCUsHlYT2O0mDA4VQYfvUexoH5kz1555k+uiU+Fu7+36f1vPmDTXbn60jaBTbfngB4+OsrShSGZ3tfh4cM7jKNbteOrEZfDVC2DtG4LlD5szaosYN44d4s58gfLUW0QGlcqZStpww2C14juFkoyfHmL94z+MKvv3wFk4dkppucLjvbspg4wXg22lI1fhJLsgVsje3kevPpB1T/rTAR3x8AACAASURBVFFXV9ePUZ1d09XV9afSv5Tw6/+N1NX1h+mDRs0yIVw3wWoho2sJB8HPFX/MqHfU/Yhoq4jU1saYYVnOwS0rNm1dqVz4NH6q1FFe8EpaCiO4S7IhXRI2qIFdUSUc7ONp3DJ5hWAzxfG5mTvBEjh+bqmWjE0dY8aPFHv+JbkhpaWHBjOQXNYLcLfVtNy83JBfWDbG1mnJmordQHtpNR2x40i2/uOyrpPbi2EBUDZWefJJLwmLhTfT2CbAmiCxyk4hPpVL8ic6qizn+reSFMLKvHFzS4jsRlAIp5ZmWSoyylpfqq22Q3CNa9O4N3P951wYMQaMXEXc4G0NaUkZyYuUTptlpzF1linrpd5UvbR1K3dZSlJdn0eqrn+uoZkjvk2fn63SVjbtNTsHtS0vbTx1cC++1mbNl5RSjS8SU1WtTeTsWKQokiFoXQ2cMrg1CeUWk4zGDFr4NkvaKVdqcJTo27pYXc2fMti1gihShCkFVMUYNM74TC9TXCuXSICgqFckCTJLYzK19ShRY9d0o6arq6urq6urq6urq+snow8aNb7NJp8/NmZH3toNoJ+V+FyJ3zyRPr3h8NmG+Ji5/se0ckm27ywBMt1Z/Wd8rKzQ4WCJk3AqxPdnXBrW1SOwtMJ841ejZngyzsbzZ/YH178uxCOgVpWqX794Gc1IyHtLp8RnMyLi0YwaWOo77bHfGztnvhuslpKqrVjthXiEMFfCqeInYbhP+HPm+S93pK2tHElRplcBqbD5bjZQrkLZBdI+UkabXpYK8d0JtzzeKeNOGXew6aF0/Qopwvi0zGOb8bAAlV1jAQG4bH+3/c0J/w9fUb/4hHw3Mt8EyiCkvb248aHi54pkS8fUwWjAw1OiRMfpF9eEY2H35YmyCa0C1AyGZiTFYgbD9NHQUjp2/OM3R+P7XA24BvWdXw2c7zz6cUCdvW9+1jVdMt7nC5i4VYf8XNm8rWaY1WoG12AVqTrI98HCSwWpmVfqhBItVZM/vsKdE+G7J/x+g7otKjDfDoSWZjp/PDBfO0v/zJV0FRG11FcdHIefGch5XOpjs1I2nroNDI+FeH9Go83Rp9tIurJrVBR2vznjpkzZRjsve1kNLX8u+Mcz+mpHugn2Ws+XGlm6Eubbdk0WePxujwRFQoVNMT+wNsPKKTJUXKyMY0JEcU55/vKKeO9sWaw2A0uFsq0Xvk3XD67f57dG/TfeXV1dfyz132B3dXX9qfX7JPz6z66urn+uDxo1LlVjmojDFyVYU2SdLK43W6vmLEkS1baWA9ISJ76BbRf2h8tqC0jabtZDc0wql9qOLEyOy6KOyvJYF+hsODewb7uZt0UjS+74k004h7M2vok9hsuNeWKDUZSNnYIlAUE7xuG5IhlLmVQD/tpqkL8kXposhWH8EfWuQWeFeKyNK+JaCsQ1aG5L4QCiI1QzKmzVqYAq/pTR6EhXbXb6nKhDoI5WiQqnSh08/vWtJZ5kSaG8XNvSFykefbHeJGgwUDM0w2PjLimiqpRNQL3NVYvanPqymrQye8LCAnKIMxNvfKykvSOPsqZv8tbZWlbyuGSVJgBisMdqSZY6tLnuU12/1k1mVGl0FBfXGtWSFnJ5Ye80bs9+Q9lFS9lg12lRLN3j5WL6iJAaANifa5suX5JFSyJJqKNri1seKWNj5Fgy6SXA2R+tmrWwg+z7pLF0glB3g6V5hPae1HbNVcLJptrrAKijOKs0yVVdUzUoUAQ8hNHOX5oD0r5BRAUN9nqX7xdjSL14zV1dXV1dXV1dXV1dXV0/en04UXOyJR2XHG7KhK/v0c1I/mhP2QaOP9/hZiU+l7WaU6MlImq0G/fN2wTA9NrSCr5BcRdTpWwCGmRleUhVEo1LcrREhiUsIB6szmGTy8JwqGYAZFnhxHnjSHsYnpR4rGtqoYZm4Mx6qRQB852dgurBJ6hnhz8V4v1E3QbSLrT5aMgbDzubEHcLHFnAzfricxzPn0eGg7L/pxNx4wn7gD9X6iY0QLKQrgKiHr8NuFwJTxOSrQolqcC37+Duhul/eYObwD2e4HbH/MrWqcb3mXQdmV+9xs1mppRByKPdsEsFya1iNRWrMqVCHbylZ1pCKm88ot7es2Dnzc8Lf8czPGTcXBi/fkaj5/jFFeohX1lVqwabva7RlpDCl2dOn1/BrW9pHmW6tedS5xkOwvjdqRklkToIaecIUVbDb/NdaitiwvCYcMfE/GZL3jnOt36tArkM2++y1bCAOnrSzWDX4LhMbrP++2Um3a6F00eOMgjx4PDJ2EhSLnUvDcJ85ZlvzKBLe8fwVAiHQjgW0Ex4npE5IwdzMWUIOH9hyeDsa/P2YjC5orhTtppdELbvHOFsKSJLXznKqMg1iCi1JW3c7KixcH114vm4Id0P9hzNnCkbxZ8Fcru+xap/nSb8x1dPyXR1dXV1dXV1XdRTMl1df5g+aNTU0UNR/HG2+en9lrobyLvQILeXpaSy9ahYlMMnVtNlSaosHBA/1ZXx4nCQ6npjXJZUy8Iz0UtFCex5XLUbaqCBd21lqHqrU6kzPo5v89bFu5bkWcCurF/rCgz3+cK/cc10EIeGSBk9ZeNWRo2bK24yxoz6ZgBEIT5bBSpvfVswas+VDBbsGxBYfTN4TmVdbJKiUJSyNXjOkipy+5GytSUsFxWGaK91vqRNRCuaLqtEC+PHzZclKLAaVi2Km4wXJI33YutMl0SQCgyPxabLG1umjG0y/dhWpjxU51ZGz8LbGZ+zvY79sCZX3GS1n+3bQB4x422y1yoK4Vwo6imDog7Slb9wgdrXa7BFsGVNbDjUluiS1RxTL+R9WBe4fFH8+cLQSdeetHPrtLafDbg7PFlaJUxtMvtQLIWkQFZbZlIQ9QZ/no11UzYefy641F7L4HHRDLxyM6ypK1cVN1dqMNA0wmooSqnkq4G89+TR5s3jwaa407UlaurcLv7ZGWPHKRTh4Wlnq2VLpUkFSYI/CzWqAa0xVg3dp+nq6urq6urq6urq6vpJ6YNGTdoFwrngf3NAYyB/fEXeeubbYKmApCvgNO+sSuNnq+W4uaUTRoeK4M/1Ag8eHPNNq4ecrYZTxsuNtLE9vp98oc0guwzjdxMaHNNfjHbDf7IURLoy0LDVnQz+ymCmSjgvvBAzecoQkaKMXz5CLug4UK8Gpo9GdDRzZ0kHoZbY2R4L8Wk2OK1zPP6nPTXC5hsze86fjJQXBoacM64oodW1NDjcVPC5NvPBrfyY+XZo8F0zHtLuMj3tkqPuBlQgHC/rT2YiWB3MTACbI/ez1cuWlNN8E1pdyq0VKDNYdDXaXDLzZvPNEfd0RoeIjp7jL/aoE+Kz1ZRsqctSMD6p8X+eK/HLR/LHV8x3lmiRqoRjxj9P7KtVwpZZ7HRj5354PyFZKWOkDMJ0422Fa1LiwQyjsvGUdm2psySRT5US3TptXYNxefxsi03+nHHP83qa8u6GtBObFAfKZMe3/S7hcl25Ru6crO4UbS5ccsUfhOHered6vjVzxaUKqZlgQRAdUcFqb42BJDO4qaA+kHZ27S7LYTIVytZx+shbVU1gfFBUlOe/EHRQW3yq4M4N4j0YbLi+HdGhIpti7Jpqi1HhWUg3Stko4dgMzEA3arq6urq6urq6urq6un5C+qBRE86F6oXH/+1TRPVFKkbXRImnomo1m3Cu+JPNNJfRoaHxXbDpYEXa41TCUdbEBwCCGTxTJd0E8iiEyRgrftbGrLGKT76OLRmhaxrEJxieWFMUNRqzJUyV+HxhtIRDgqqEK4864fSXd3ZDnqrVW3au3VDXNQ0Uzko4WmrGgLzGabH6k1iKZqkaNbZODZDe7BpThzWN4p3gp9LMHLXUEhBOlr7JO08VcNk4PC7beS+7gMwVf0wtiWE8F9GF/2M35vForJuVd0N7bmcrRS5VYvvzJUUDrAmafDMiu2E14IYHM4bU22s2w01Qtxg1bY1qN6LeUlaLAZR3wapWjWuzVpSi4ATqGNaKky1BmUEXn8zg0mBGjFSr1yFinz8046Qq8Tk3gyuuqaU6epv3cktlLnP9a12vCanNqGomzXwbEVXGb4sZVwJlDOS9R7K274O2QtZMR5eN32PvkzlAIpYYU9eqXp6VVxOPS4pJqYMjf7TFTZXdN3k1KfPGqmt+ApyjRoPNuFmog6LbAknwTx45BXgfLj6mQLo1c9OfrcbGi3RNV1dX1+9Sn1Tt6ur6ManPznd1df2p9ds/h/49/xvpwzDhqVBuBt7/tccl2H9VCWe7aS6jI2/bTWo1c4CkhEPG5UrebaiDEI7GXanBmWHT0gvh2GAhL6aG/akSH87k/d6mmZOuk9muKr6ZHmnfKlazXmpA1VIsNbzg5HhLKQzvzm1CW/BPk4GID5aMeP48GEvnvlhFZeMI50o4qqVxmoE0vJ+og18no9W12o9qM2p0NQCWKtX5dWwslYtJQJtmhgW0a5WY8duzfbzZXtIuFTtPIqRdYMgJOU5wPVpNqNiN+VILCsd6WYkqij9ncw/abPZ8G5AqSKn4UnGTrKmU0qar59uwGjJurgxvz0it5JsNGmz1SaoZK25WwsnqQkvlaalUabU6XPass+pS22qTF4oT3GimS1ngwEpjHiVq9CsQWBQDEFfl/KmllsJZkVnxhxkVIQTXFsUM3qzOqmQqQnyaGb5+pm4jdQjk62jH1IzC6dYhCsN7m+s2uLLn+HFYja8yOsrG4c8GfpbU1rQWw87LmhyrUWDrG3S5GTWHZpq1BFDeRsb7xPD+bEtRo2f+xUDZCv5s54JdOyfZVpziNpE04ifBH23RDGe1v/MbJd8UwoPHzZCvFY2dItzV1dXV1dXV1dXV1fVT0weNmryzmeXdVxcGSolCvTUOi5+tTuTKi2RGXBZ+7Ia+hrae0/63fDzYvPPXR+rGbpqtvmRz0FQY7xN+0pa0WHgsWEpBZE328CINop41PWDJkrLWefLVYKEHJ+Qvrl8cD22228wnq7BYimT88on5kytqMD7K/GpcH88SELLydvLWZq1DSxNt7staEVIHZbR/L4PgskOqXxMs2pgxdfBrNYwZwmF5ba2WUyo1Ouaf31JGv6ZmpNCYOZdz4lvl6fzp1s5Hq5uVsfFZztnSQt5RxkjeXWIXSwIIsTRIerWxGlCyFSyNdv6H+9zqQZYQKXu3vg/hZBUzmxgXCA0cvXVIxs61F05vIn5Wrn4zUYMjbz0a4PDzLX6ya6vGtmQV45qWWlbDEFkXr9Tb5+WNLVeFU20LTcvC1kjex9VwMVMpmmk32fV7fjOuxp+KsLkvBr+e65qG8VNBFnD2aKym9Tpshpi2a11FqdFSTP5UqNFRR7caUiU69HokHBLheWY3OtLRI0Xsmnm285m3VnlKjwOSGidoVBJW59LGvvFPnuHBEjmuGK/GzVbb6+rq6vrXqidrurq6fkz6IZM1y2P9l/7fRl1dXf8G/TGSNb/rZ9qHYcKD3YRu35mJUYZ247hxlqw512YUtESBMyiqOMFlRYuSrzy1VYjUC2UAqYI7Ti0NMDSDwgCrAP6QcKfM9NHGkjhLTahVYfx0SWYsslnwpdaihGMlPCfyLlC2FyLxfOWbmaCIKuFs5oo/F1xbZAqHBG/vCbsB99rSFzV44qGsgNsahfhcoSrlptWXjqw38yU6agxU3153tNdeBsHNDg12zFINEKvRQbY0DKq4uaDeUbZtdWqu1F1YeTNr0ihbPUbLhcEi2YyH+dqgtuP95RjUYatS9WKg5a3xXWSZphYa90ZJ1x4pMNzPVodqVaRlEQzXHmPnVrMuHNSWpoJQ3eIkWJJEBIaHAqNjvg6MjxDentDRI3Vkuouc7xzjo9WKyuCowQxC0RdT4y2dU4MzU6QdRxnbc82Co03MB6G4QN566igtwWOfK9WMJ3XGuQFLM/mkxKe2lpXNdJRUL+tZG2MMqW/1rGUSOzQTEJoR12bhUwEHRRqEO1ebSI8Q78/I84nhYUCKUmKgjNbeKuNynIo7WMVOsb9T0YtRU8BnuwbDSdfzEU50o6arq6urq6urq6urq+snpA9Xn/ICfKm44ADXEi7GQhkebHobVaaPB+YrB3hQ2L4tFxZLSylQLBmAwPkv72yhZ7rcRdqUdEKHAMExvp8seQIgwuatJRTSlc13p63gkzLeF1v6ufBjjRNyFcnbtlrUJrTj0e5043MGgXRlMNjp1WVuOu8i/vUtZRvbElImPifcOUOulpzYeFxjrgxPFVElPhqMNrcJ77DMg3tBiiDVteqWGSMuqRkczt4Kl6odV1UDLG8C549jq4q1utdUKRurnQ2PijsXymAT5+FoxoI2o2D/q/PleAqMT7a6VLdxhRvTqjv+VKzSo3Y+4sEAyXOwCe3j55v1mpCihGjGzJIs2n05kfdhncLW4NqylbD9ZkZKpY6eMjiOn43UYOBnFNLHu/V983NleLZFrjLaY5vZoFB1rUO5Yh+XnV3CkivDWdn9aqJuIuk6Qm2JmqUW1UwaWwCrDI82kV2jpWBccg26bOmX+SbY80tZUzN58ECkDi3Z0pJZw0NuS2dWRcs735I9BRVhvh2ogyPtHPFQiWdFqyWyzp/u0M/2lK1bZ+JdsVl6ycrYDDGQds65rHUVS5DVaBWopQoXn8xUS3vpnJqurq7fS/+evzXq6urq+l36l34W/fbPl54G7Orq+mPpdyX8fvvnz4f+++d3Jfw+aNQssF8pimrFRaEiiFj6wk3ZGCdLqmLTEhsK+o7VpEHsBhYFX3TlzPi5Eg6lpTiW/siFq+HOGWpFx2iGwKki2TPdekqEMoKorFBdqq7Ho2I1HW3T3+r0ArqtlvhAgH0weOxG1tnnMtrK0lJr8VPFP54hZQPIzuMKv6WCPxuE1k+l3fQHqBcYswaH9zavrI1z6+dWsXEXro4skRTMaKrRzCir+rgGCLZ56jI0rkvlklYpVlEqm2DG0fsTOEfZ7tC27IQqNfr1PNmTmTEgS3rEOas6LakVj60mAeFsxkBpppM6M1P887QmqoB1wQoBf0rIOSNXA2ALSOosGbVweuz5LSkUzvVSCyuNCZMvV7B6WdM/pfFvfGPy+O8ekbsrUqvUiSqKrItVtipWcbNdA5Jr21oXqNpMqwwEagyICjpd3pcaLjWrpeq1fr9US0SJymXWPVWIzhhA8fsVvWUKPO/D+r0Dlohx2ZIyqMDB3odlhr5G1u8Zqx/a90JZHl8gTPa9l67oRk1XV1dXV1dXV1dXV9dPSB+uPkVnNRylGR7tnnYQ/CiUXbQb01TYvE3EZ3+B5grkrW9mjzBfW+VjeCiEueKPGR0caWdGCQLpZkv1O6sjTdUMkKpMH43UIGy/mZBc2by1pZ/6rs1Anws1OEqrar00fvy5EurlZjUsSZFXw+WGe/ErvBkjUh1lG9e1ojI6/H6EHJFaKdtA2TgKDirEY7b1oFc20SzZ+CrhOdnq0QZb75kuJtRiIMVDW01qpkfeB1vwubIDHp/MmFn+flm7gtr4K241XOy8e+a70FaerixRs7UEzvETRzwo+y/dCmBejIfzRxF1A7XxZPLOrZUZl2H/VV5rZTXI+rxlEDNars28Mq6MI4+sk9rTx1vcXAnHhD8kbv67Hfd87VtVzFJC00eB8bGw/fpsKZhoc+Yu1VYxuhgmrliyaYEUu7lSo2f+q48poydvHQFwc2X86hl5eCb94mPS7WBmlGKpG1iNPlds5n36bGsVr2IT7/b3ZsqhzrxEBZyuNafqBQbjM9Gqf1ZNq60GJ8SnwvXXR86f7nj+YmgcHm3XMMxXlqjZfZXwqXJ6M7RXa483PF/Mqry5VNb8rMiDmVzpyuDM4+PCaApm7HR1/cTU1z5+PPohfmvU1dXV9cdST9B0/bmoM+R+PPr3SPh90KgxkK0gWtHfiuQsAFdVAdqMcc1kNRjqogXoqs1AWXgz7pypEhpjoxk7bUlqqXRosARIGWWdoF5SCxRw7cZ9vYG/PK3dWNMSPaorJ0VKvcw4x0uKgXbzfWGNNNNHtXFYHOIFxa9snBrNKOCpzWS3P3dLGqXWtfLkUnuSdowLkHgFFDeTaXmdNRoENhwaH2h0LDRdqa3m9eK8LvDf6nRdvJLi1+M0Q8Xez7IxNgvKWs0qgz13bfxfS7OYCeAyhJPVhNSZa1QXDwEzwQzYux7iZZbc2/Opc/jJIbXgjwmX/Hr+RHU1faAlqTaByovXuLy/zvgyy3u8gKbBUjxl9O0ccnlvU0YPR/wpUTf+e8e2XJO065R2HKKX9NXlhZphoxXEiSF7lu+L9rHVvbB1s5fz81ityz0ecR9tjblTWFfBVkA2XNJF1cDJssy0z/WSHlOP+vb+LFDvVC3Npc7SSrkyHOqFmdPV1dXV1dXV1dXV1dX1o9eHV5/ab+yH+4xzstZlwhFQKIPj/DqQ9gYX9rO2G31h9+WEP864o4FjxvdbS73sjGNS32yhqtWZWlIDDNA6PGTi/RmNHvWuVXYg7zyilpZY5pzVC3m0uebh4ZL6kFyRUjl9vmW6CWzeF/zJqi6SKptvz9TRc/zUUjA+KeND4ea/HdHoKRvjkxhHxyaop1cjZesY3yf8sXL6dLxMUs+F7ZezAWKvBoPT3m3MlGoVGymVfD1aAmWuttQzFTMAtqHBae3cD0/FprxTBXWt5qVrukSkGUJFSWGZIzdnYqnRLItSi3kyPNnaUB6F+VqYXgl+Bjc3s0IbpHaZHi9COBroeXh04LHFpFb5cUnX2emlCoSD+Jjxp8Tps50xUkSoEQ6fj3bRnQzevPuHB+pu4PiFMWq2by0Fkq9H6uCMR7S3NMoCfV4YOJLbutOxoEGY7yJSlHjIZtbExaRyTL+4Q//qFeEpEZ5mnn65J+0c1/80GxR5cKvxKEXZfmvspcXMyTu/cpYsMWNpoZdprDErIpZoQWH7nc2Gz3d2fcXnatfEZ3f4U+bV32TSzWDJpQbkjgd7b4+fDK1KVwkvzKIlUQVm+sSv8poeE/2+KZT2DleE8V2ya6ir60+oP+S3CT1Z8+NVf0+6/hzUf4Pd1dX1x9Dv8/+hf4zloa4fVj/ke/I7EzW6JF4Aqlp4oy5JDrksOZVLQkOagYJzDehqCRoGb9Ue11g2RZC5XpIRWQlnq4tIUeoo1NhWcpQVJLskHvx5YbzIOk8tautRLhUkFaT81otyAu2GfFlHWkwfqYpM9gXSbvQdWNqi2sLOmuyBCxfnn523S2LDtY/FCSR7LvWCTODmYktXzVxyVFsFakyfZRJavbZUUDu3XEwEM6uMcyMiLdnDyioRffG+NDh03ljKpWxawinbY4ra49DYMrWBa+09tvWtOly4Nst7pg54scC1gqNbvcr+kHWSvA7gsoM5wRgpQ+PvpGb6DJc1pWVtLJzMPLIDbekhKl4XE6P9fXtfLQ1Du14MFhyeDTps1y3fr8kt10C7Fu3PpJ3rxRVkTUQt3xv2Pi2PtVSx2rl2L/gwxa7fGoRwLvhjbnycFvtxlqxRvfCAXFpWzNr328v0F5frdgFI11YPs/dxSZBd1tS6urq6urq6urq6urq6fvz6MEy42k3q/Np6LjUKki3J4eeKmwrqB9TZDHSN4JLdqD9/MaAysvt2Y4mU2iaDG6DXpJacaHegw8PM9tcT5Wokvdow34b1Jh5gvnYrIycelOv//kDdRfQvdkjFZrjP4HMzCubM5tsz8SkYzHV0JDeYMbLczNphIGppjdMvronHTLg/U7exgXkx7shUiUC69uhNIBwNcqtOKPvIdBdXM0KKEk6VMjrmW/vc+JTIO0/eOYb7mXB/RjdmXPljAif4Y4PVjt7YJc8zki1ts1Rp6uCYr9y6MnS+dZRR2LxvBle06hTNaMkb48wMj0reC+fXiks25RyfYHhS0hXkrbTZcJt6XoyR6uH8kV+NIpfUpsmhQXPNAPFzRbJSNmbISYH4VFZzZ/PWXuN83VhGd3vSzcj5lRAPEB/bAtPo8JMtYKkXXBH2//CIe/9M+ouPyfvAfONRccSjTcQPD9lMFgV/zoRjMsMsOtxzmzyfMqiy+S4RD47pVUBfB1y2hMr41oDI8+1gJou7JJP8pKuRomKVJHWw/82EP2fOH28aR8kWriRXCM5WpQbHdONahQ3CORBOxqgJp8p87SijY/Ou4A6FEiM12vXusrJ5ZwZWGe0aCIdCugmc7yK7bwrbr0/Mr0bSlTffR9VqYF5I12GtwHV1/Xvpj/Ebnp6s6erq+kP1h/z86L/B7urq+kP0Q7JLerLmz0O/06gBSySsf4bdsC6/1XdTJR4MbFqirSuBtBRMSzssPBvXeCRLokGNf4NcboiXVMLln1ZlquCC2MhRaWmONU0hdnPa1qckOmT0qMa1FqIrYHg5pnb8bT1oWYoSD3V2dhxVVyOmxmDHMFVq8GbGtMSIRoPILlWYhbEjRaHxUmoU0lVY2S929t26wLSkHrRNSdsHCyvnsmy1pGj8wjR5wahZzZnFYAiWkMl7xWXBJSFvaHwZxSWrJJXxksBY5p/LaF8vxea77RiW8yXfe06rpknjvFz4P7Qk1AVKrIhW3NbqQWUTqFHwkxlJCzMGLJEieQFKG7QZ3ybBXyBXahTceo3Y8y/1N/WO6h2u2Gy5PfAlpVK9WBJpSdC0v19NGn9h7azmYtU1keWhJaJqq45dkk/L++fnutaVjDVz4Rv5eTlee/3rdd7OcQ1LfEoRZH1cg3yzmkes1zfr9+bC6UH/OSunq6urq6urq6urq6ur68erDxo1fjYQaWoLQPFoqQl/zA0SGxgeZja/PnP8T3cc3wRyA8Te/I+Z+DSvBsr8agSxVEodHGnnCVoJD8WYNVtPuo38f+y9648dyXXlu/aOiMw8j3qQ7FZ3S7IB+w5wgcH8/3/I/TRjXPjaY7ekFskmWXUemRkRe98Pe0eeojVD2WNI6hZiAUI3q6tOnXwUoVy1zw/IdQAAIABJREFU1m/lu4Th04r0cQbpiDoGB6sqhid7rXyIIFHk13uUg809hxUIq9oa045BNfqDux1LMz8ap0YjA2zH2Fg7gHFZaA/wOoJzRThnzN/usbwKOPxmxfDjDC4TZPCECwHrXTRzItBWh2rw1/a91ztbOdr/XrD7YYEmxvpmh7IL0GCJEAC4fGPppf3vVygTljej11uMjyIjI14qxvcF+T6hHAI4AxoU6/1tMloCUHdA2SnydytQCetD3Ko5dSLIqMgPwFyBcLU0lIxAHRTlXqCsGN9GhJkwfrQUTjDkEGQg1OTLQ4taskWB4BwXcViuekXKZswLqCrGqpAhYP56RFgFj/9wQZ0i1oe4gXXDtSA+zYhPZpaUxwn12wPKwUyyeLYJ7/U+gINi+CjbmpMGgwrXfUTZM8YPAj4VYw+9XMlKPmt+sftLIjsM+GYctn9KJPCLeld6ruAqkCFAhmDfW8iTRMbg4bVi+OGKcBxRp/02R5+PxnUyA4gwfiifQYuH5+pAa69AFYWSIsyAjIT5dcDufcXdf/8IHSJ0iBv4eXjKoFVQfz1Z8uw5I8zlP/FXRFfXv19/jt/o9GRNV1fXv1d/ir8n+m+wu7q6/iP6U/6d0ZM1f9368jx347Fsv8m3xR/axY21YmtIVovhrBs3A3AWS1GDELeFnYKtQmO8Et5SIk1WWQkbTHd7UC4veDl0mw9P5/aA3l7gxlYJswF429S2PfzyZ+kN4AbTbQ/MDVobPI3QamCagoNuyf6bmygqLY1CKBOBlJH8vbSH6DDbfDV58MLO0YskSTsvwMaEsfrRv0lEqCc5qKV1rA4mww15ogGok0IjgOVF9YUBic5vqQDEeDsyWF2m7BV1VGgSgIE62oUqe0KYgXTR7T0AZghFUYRrBZhQdrbkRfUFJ0X8z810a3wbN3C2+6UlQNxIq4fhtuiUfCWrvEi/wFIlJIo6RfBaEa4ZBAaxbowbm/o2QLQMvsqk6omU2z0nQ3D2D26JqZbeKrpV5giNL6RANP6NJcZe3FAANLAZKdEByNXuZ87iCSdLDXEVSyN5moezTY9Xr9HV0YxSzgIw+70IyH6w+9HvyQaUDny7XzQxRHr1qaurq6urq6urq6ur6+eiLxo1G7R3UWgA1gMDB4DvbYkpXhV6nyCTGTXjk2xz3DIwchwQz8VaMW58tBli9qnn9SGCs08PexrFeDIBvFTwIlhej14VsYSKDNbzoGqrSXf/eEW5G3H9Om28ETORCPG0Ij4vWN/sUXeMsveHVsFWV2kMEpv+tupOvouQQTaAcTqb2SNpxPIYIRE4/E7AqyUrlAk0BZQDY34TUE+K4SOD1JaJ4qViememjW6QVwUoGPzXK1HxItAI5GNAWBXjj5asqTtj1qB4fSw48yQR8pGQj9j4MpawAfKDna/hbVtAAupOgfsCWRh8DeAFCBfC+qiohwK+zxiGgrxESGHUo0AmggyEeCEMz2SMosXOkwZbcZq+f8L8q3tcv44YzoIwK/LezAP2So+GZHybJ0vWpGdjr6gbX60aFxZBPkbUr4et5pTObnDMFUpWIwOA6d0KSYzr1wnpHLD/OANcwSUAdwl5z+AcQGIMoTIRxk8VYRFM7201aX2IqCMBsLSOvWebRg+rIJyzJW2SV7BUzRDKFfUwAmwpLgl+HzVzKVpqqk2vQ20dLF7az1UFfbbIpEB9YWImW0Fb7y21tP9dRhUgjoyyYzz//XGDGZfJoMtcghlHbvIsjwlcvvhj3tX1n9Zf4jc4PVnT1dX1v9Of4++F/hvsrq6uL+nP+XdET9b8derLjJoXSYc29czllmL4TM5hCc4KkcHAHuFyA9ACMMZHIqwHm/62SWJYhWfVbXIacD6Lto+RJwoIkm7fWwKh7hI02ES3shk54SoYPhrEuO4HN1ns4wbctWQFoTFJAIsJmYESvDYlyfkiVS0NI5aOaWtK9iac3VPN6IkX+xxLiHyeFpJIxqQp6nPbltoIlwKqVgvTDERn0tTRTJZtRYhtgUk8hROyQqIZMC1NQ+LvudgaVr737zFbKqlWM7o0qKeMrDoFBpgVzApVstknaUwgmI+QjFtTR4IE+7gMhPK4h0a7przYpDkXgz/b1Lfa9S23e2fjDFX11Sf7eNmHLWXF7XN9CQxVQQFurNzqQXExIwdeX6oN0rza1zfDjV76Inhxf7t5Zkkaun3Ni/SOEtkilwJ1l0BT2mbEW/osrBW8CsJc/Nwmv29bhandCAoJbGtgsHPbqmF1DBurqM2gN6A2V6tP1YmR93a+zcBkhKxIp4owV8Q9owp9Vv/r6urq6urq6urq6urq+unry0aNL9s0s4IzEGfB9G41BsiON4irJKv8hMWMmby3h/Thg9V04tW4GyRW65nfEMaPwP6HguVVwvUNY3hSDM+eSPC1HCUgXnzG2vkjktJWf5GBke+jrQQ9F+RjxPLAuP9hQfzH36L8/XdY3oy2aMSE8X0G54r1YdgmoA0WTLeH4VUQFkvQ1J3VdbgYN4XXagyWgcHVa0xQQAi8CqIo9l5jsmlxB9tG3kwkibdKVrha9SW+P4GK1YcAIHy4QPYjLn97ADt7RAaGDGZk1IEQF0G8CCQF5Dt3IJRseasSwpVQd8D46xOWawL/fxPAhJrNtNCkkEEhFdCoQBRwEIQgZtIUAq8GIQ6zJZjqRD4T7QmpYmmO868nxFkxPAviKVtyZAog9XukAukp3+aimYxJrAD5LHf0GfB8z+CCjVdDxa7Hdg+QcZNAQDoHcBaMHzLg7Ju6T1gfDP68rVONlm4K6wuzZqtGOaB5kQ2QrIFQ9mYU0oGdOWRmHERR7wJkoM10KpO9RjxlhEsGna5AstoTMSFkqzc1NhJgi1mSaJtij88LeC7Id0f7b76Wlc5yS2KtgvG0Yn01YbkPSFdBvFSkJ1u0ik8zaCkY0j3Krleeuv761ZM1XV1df0n132B3dXX9VNSTNX9d+qJRs96Z0bDVORxE24Cp8WI1lJoYvCqSCngRsDNZNAB1HyFVkY9hY9QoA+lk1SnyFAqvuK0aedpEiG61n8oI12Kf40tOYambYUNVt/pQuip0YOg3r0GqGJ4zSGxhSCNB2JgeylZvAd+WferE9v4vqwOJLbUhwdeC1oKQk7NoAkiBeLaH5DoywLRVelqagaqiRKursM92K5ODjwGqAeE0gV4cj+xH6Bg286gla8LSmD2Nq+KJpYUB57LUEQAp6l6gUTGfRujCvvCkoKlC3YiRSVCYoYN+xuwJQ0VlRWWgZkI8262yvAbCYjPtrXZTk9VuSMTNDoKGBstpiRyrtHFV8GzmXbhmq3DtIiTwltoK2WC98ZwhY4AE9urcbap9+lD9fpJbYiQQ6t4m0sMsny1lKRNECQh+XxIjXitiEegnNyKrsWHY7119sajVrqclZ8wkagYUYCYmAJR9hAZGVPXPs4nwsg/gRexekdu5a0taVAT5YQIeXtQEV6uMxWuxJJEY76nuB9TJa1qJUPbO/qkK0gm0NyeqVQC7urq6urq6urq6urq6fj76olEzv7KEzPEk9mDeFpzuAobnivRxRrkbUXfBZ7rFKjqwFIzBaa2mU3a3VA4pMH0QxKulJLgo4mKE3TbXvFWrGMhTsJrQUrc6FhQI12IP1tVmmDUaD4WfCsoUkH91h/H9jPTuAio7SwE5vLhMlmQIc/VqFqPsAuZXjHgl8KcLeEjgMaE8jqhjtPrNdQUdRgQmLI/JF4jMqJGRQUUxfJztLaZgAFrRbeln+lARzxXrQ0SZGHW0VE88TwjX4sYAoR4HaPTlJALqju1B/1JsqWh0tk1iUAHCDKhzXurBDJpwv0IrAe9GsBgwWHaC3XFBXiPKHIGokOkP+0DjZM5DuBdc5wR8f4QyMH9bEU6M9IRtBUoG2PLW4tPjjC0Z1BJFpFZvowqMq91P/DxD9yPW19PNFBEgzIrh3QX8w4+Qb98gP04oh2grRmcBr4Ld7y4AgHK0lSy4oVZ2AbwK0qnYua/iwF0GRoYq3RJiTwJeCsI52xx2MqMtzq32xJ64aaaKr4qNjLCIpX381EU30PJ9RM1+Dtq8/RgwPwYMJ0I828ITV4EWgIjtHiyCy3cjysQYTr6uNtuxxie7n2SMkDFifUieELMKmIaw1aOq/6zEi1WwNNJn8OWurq6urq6urq6urq6un7a+aNTs3ovVnS5evQgEJTVGycA4/+3RPpEs5SKJkZ6t9sIloG48FXugVzKgLRcD0AJAOSZfkzLeSpi9KkS0VXy4WHJBBgPqxqst7lCuIGbUyOBaQVdF3UWUg32dREJYBpAoLt+OyHvG7l2xh2wHE5djcg6OpxcWRR0J89+/2YC/ZQqQSFhfT+DjsB1vkxKAyJgfg6dBjI8io32dJKuxhFW3+lZbCAqemlA2Jo8lRJzdAgYGBYGgYpwXKmYIlKktDdmncSXQbP9eDwCCoi7BKkyjVXoQFZQEpTDEOSxhrIipoJQAKQxVoFbnuZCiVIYIb0tIGsWrQQxaFekqSFdg/AhwtVpWuAIBAhkJZWSkKsZkiQRqc9eJoa8PkMYhciMk3wWsRwb0gJEtbUNqq0uhrXIRsLyZPG1lYOvhwwrKiqhWZ1peDQ5xzmYGim6cIlvSAtbHBKoJw48zSOHpHTds2gqXKLiSmz8Zkhh1vCViNoNJb4kbibStOOU7hx5/qDax7uBtwK63DITCtqdOavdfOldQUUvKjAyqg5l3/rXpVEA1fL4y5YtjvBqrRxIDyWp8LP8LME9XV1dXV1dXV1dXV1fXT1JfNGqm99WqOmfbMG6/nVcmLK8iLr9gxCsQZ4UEMwvSibbpZVKgDvZgnq7VDIYd39aVGFvihtSqHtFTMs2MyHvC+GRrODKYkREvxQDDuZqBoAouAr6skDGg7BhlJNQBGE4MXiOubxjrPWH3I8CLzThrCrh8twMADE+WdAizouwI19cJ6apIp2ZMAMtDABAwPDu4ltqDuk1Ar3eEsAK7MfixBpQdIR9stccgxHqb4yb4RLQ6JJkRczXgMhvApTFwCH5eq2yJIA0vQbhAspAJZgBgvc1yJ+PPpKlYoqQGqz4BiKng/jDjdB2xagKUUCuDfeJZhKDSvpcCSaHJqkEkZuKFRRDmivU+Id8506cq6mCJobCSL1E5lIYBBaMcg713r4fxKpAYMb9mkEQAuw3gzFmgQhurZX2IqMkB1os6C0nBa4Y8jljvnUlzJXD2Ke2HwZbAsgACLI92foaPZqxUN9bazDsXYw+BbImKTyv4mACE7R7fZuerLW1JILD6f0uWKAuzYno3Q1Kw2mCxeqAGZ+Q0YLVPcMeTpZmW19ESYyVtqapwFYzvF5Amq+QlW/5Sght2vpp15zDlpW4pt66urq6urq6urq6urq6fvr5o1HCbkIavDbkBoWRJkP1b+029+m/zSwTyfYQMVg/RYMaFsiUNAEvSkAL5aEmI9FztgX5iZ3UoEGHWhAAhW1IDCsyvAkgCJrYFKI5WVZGhreTY94xXQbxYVUsS4frtiHRRq7REQjmmbVWn7GjjjCibqUKi2H2o4NUeeqVYBaaBk8NqXJT0VAAmlEOEBmD/zuswWaBD2FI06VK2CfKWxjGGir1XKpYSUQaWV6P/u/N2njPqFLA+BkhKiMEMiPFJbP56soSSMrA+ABIVfCXoGrclJw0KVEI+W1WLgoKiIO5XMCuua0LJAWrjQQCAdY7QytBCQGFodJjtKSCeGPFsZlvjqbR6U7yaCQE1E4eLHSPUVo4Qne1TbzPtXG6JjzArxo+K8UPF+OOC+asJ5cBbtUfIlrmm9xl1YJx+ZZvkMhhUeLsfyYHWPG7GUViq8V78OGV0dk1kEPlS1UobZLhObObJosh3EcvrB4SrYHqXUQ7BZrNnh2mPlgrbvc0gVeR7q2QNH+0eWV6PBqSe63YPULWfozZj3tI7dRfBRfy8mXmjRHYNImH+ZgdezLCpu4iyd4OJDdTd4MicBeG0brDmrq4/lTq0rqur66ekDhnv6ur6S6uDfbv+s/ojq08vZrgZ2wRxA6kOT7KlJiTCl5/YH35vn0eCLTUTFzFmzURI1RgxAJzHYpwa+8LGN/F/inFQACBdeKt92AMsQUHb9DVnf+heKi7fTViPjHQWW94hn3ZWY9q0ahUAf9AlS9I827T3lkZQsnRHlm2yOWarIS2vzQAZPhavaXlyhi0xkz5lcBFQEeOMDG5KCbbEg00yWwJDg01fx1kxvq+QIViChu0BnFSRLoI6EKoa2JcZWB8VMlqKBCtQJ19zAgAhUGab5IaAEzCOBSKEnIPVm9qsNykkByATaGVQvaVMwtUYPnERcIXzW9pykvrilJswWUC+htWMqFZ7Ir6lrto5VbZrkc7GmOHTDP1mh/Vo3BbjwVj1Lj4v4CEAZCaZJALpzXQD7GNrtNfkCkxvK+LzAk02/82LfS0CQWHvg2AJH4wBZW/3JFfFchcwvyIcv1ekpwX5fo8y0TavrmyJmPS0AGT8Ii6K8amgThH5ISBdBPHs3Bg/Xw2u3c4jyKbj0Sbt2z3oM+d1NDNx/ACEp8WPk7fjlcFcqjAb+4mWClrzf+xvha6urq6urq6urq6urq6/mL5o1Gigz9aN2FdkNHi6pKhVZMhrIr7qRKIYzvbEPH+VIBHbg2d6qmZikNU25q+GLUGSj8FgsNkeMtNFEHJLPVi6hqoao6N47cRTBIAZGHUwDolS8PlmweG3eVu/CcttJcjSGT73fGeg292PBexVnlZraomhxiFpL1B30Tk4ZjqkU7YVrF38jIWiiVGGYA/kI6NuRo3i+vVwW5RSuBmjSBebgxb/urCY2dBSQhIJ6aIYTmJQ4sHOZ74D6k4hgyC9ngEllB8nKCt0X5xMTKhLwEVGEAPMAqlWcQpRMKSCOgXUwMDCdhwChJUwfAJ4NdOuXSMlMlCwB2PW+4TqLCJ204bEjCegrRcB6zGAq5k/G3RYFOnkIOrXB3BRTB+qvbbCF5NaGkdw+G11o8bMu0BmCI6fBHU0Iy7OinC1+7Hu08aiCatACVheJWPTOIw6ncRTY1Z7W/bR7j9j+qLu7POVbOErXjLSKXhKJ0ISm4lTCWEf/ZoT4kxWa8PtnpJEGD9WTKLbPdGqT9dvrZYX5mqGkCqUIvRoM+/1YcL6mDA/hu1ct2tg62jA/Kvj/8nfC11dPxv135h3dXX9JdV/S97V1fVTUU/v/HXpi0YN4AmI0VIbcXWjANhSI1B7OLRVqNvX8epJGUpb2gDqCZJq6ZJyN2B9iFtiRiJBByDVljYwyGzZ01YFCtkMI+O4sE14e9rDUjXGxZFoqZThyepDZR+hka1mUxWaeHvvgCV+gk+OUxbwWiHRUjfwFJF/ExNhW5CK12qJmaUCyY2icEvqSCADx0ay9FGyGWoSOEvHKmIkVvOyNSoHOCf7HvTCoJBgXJJhFv/eZlDFa7BU00GAqDjsVuQaUAqBAkDROC9aAlAJIgGUBIhsLBZP1DApOIjxafyY2zVOp1uCBIAZZj7PzZ5+KiOh7IB4BZBv5lNYb6aNeJpJBKBKoEpg0hu/yOG5jRv0v5qZpqoYPmXIwMh3wUy16obcXAEKW2UtLF6LSmzppWDLZASgjD5dngghA2G26wMxE68Odg6aGdlgw6Rq4OxrtmsfyEycweDLAvvcli5T9uU03IDSjSMTrsXuTVXQXIDI2329Ha9XuJqhV8ewmXQkChTczERVr+XZOlhXV1dXV1dXV1dXV1fXz0NfNGriKUPGgOVxuM0QXyqmHy6ou4RyiJ44IbCYsWATx0C+S1vSpi3ktAd1iD2MRiKMbnSE04L8aod8Fw1Ou1QoW0UlnW/sEVKg7IKbGj7tfZWtbhVWtXSBp3J4FZuwFvu+630yEK6bDXEx5sz0+8XmtxW2JrVk0JhQdwmcCcoB4vyP9sCej5biGH9cwFlQD8a+oRdsnzoFzG+Ss1h0Wwiafr8gfrggfXVE3YWNKxJnq0KFudis8y9G1GQGT1NbGlrBqF6JUgLu/sWAzc+/DqhjwPI/X0MDkAZFHe29tPUnVAIyA0uAVEAHAw7Pn0bMGIFi9RtEhRAQL7epcNLbWpWtIJnpotVSNMNZMJyAdK4vuDEEWFPHV5wIYUefmXtKVoFDIks1ZcFyTCg7xvjB1rrWx4jKjLBEM9RytVRVikACJAbES8XwtCLMAfEStsnwOpqRtR4DJAJxZ2mhdLZ797NzP0VcfzGAi2L3tiLfBSz37NwbIJ4Fw0c7NtklhA8XM0ecoTN+bCkvS5IZgFpR9gl1YpSdGXq2iMYgDVh3A5Rvxt/+X87QwFjeTNvPkhIwfqhu2CimHzOm99iMpWbmrffJUlenut2LXV1/avXf5HR1df2U9G//LuoJvK6urj+3/nfMrP7/lbr+mL7MqPFlG2h7iPaPrwWc/u2v+82BIAVUrJoB8uqLV4BI1JIxAEgEWpqZUkHXFXwYQNVeV5luKQo144Nb+mVgqKozPXBbSYIZMFTNfDGz58bVAbCt+jAstWEcGoCXcnugLQKUCqTgqSF7D7f3JNtrWd1LABHIOPj6jlVcuCoqGn/E/1fte/NSQJcZ4Tra8Y22gMSrgKoARUDDbYWorTvh5tdsgGbADIF4toWk4T6hTuTGGWF+Q+AAyByMWRNt9YgqgTKBM6FCoGBQtnSLHyJ0tOOnQlvah7QlpPT23pigYkYCV6tttaloZQKxbpPmVBVEhJAby8a/R7vPyKfHK/ncNbavs3sDkMD2fbLBmEmwpVbscw1kvN2bfDtv29pSuxZXex2ePRmVKzCaSYhiBk45WAXNjveWgrEqoL+4WGXKjkm26wLziW4z7F6zEn+ttnJmAG6Aiy+jzcWg1y+WqNoyVDO4eBXwUj77OWxLVBpaCqfPc3d1dXV1dXV1dXV1df1c9EWjJt8PoKo4/usMSYx8jKgjY/7lnSVZLsU5LcGTHRHT2xVhLjj/eo86EHbvDKQrbWXpEBEigZcC2ScsrxLKPiDc2UpOmAXL64i8Z8RZt/oQFBg/2KJODQwl3h5IjUlzgxe35IFEW5NqvBgSxfDJZrglEmRgLI9mhvDXe8RrQXp3sQfn/bilYzTYAlBT2UeHHZspoZGhKWB5Ff0YGlDYkhrpqgitprSaESBjRP2bNxuDptVpcrRKVjuG9FztwX64mUotwdLEL4wKECFeLVUk6SXklnD8Z0vgLK8UEs144xXglTB8CNu6ltV87PWWRzMb9j8owgyMT2Kz6juCgMDF+TOL1+BeVMPynZ2PxhSqBzOj0qWA14rxnaU9wmXdDAYZI+ouYr2PuH4VjWGztgMF0pOvJkWCICCeVoS14PjPBZIC6s6uTX6c3OQim9YugvGHM+i6gv7uFfIxIJ3q7V5JjOVXk12/RVEHclgwGWRYDA7NWZHOFcPvz+BPJ5TvXqHuE8pXR+PdvDHmEntSKz2tqGPA+jiA14p4LpbMSnZcnAXpXMwk2gUICOPbC2ipWL8+oI7Gu2k/AyBAQkRYFPFa/TxE8Gz1q/WbA8reXB2DDzNEX7hUXV1/Bv05kjX9N+NdXV1/SfXfhnd1df1H9Kdco+uJ5r9OfdGokUCWBKgCxq16ISNDY4Oh2kOgpQJg9Q+xpIylA2wpiQGIMuqeQYW2lR9LSzjzozifhC1tUJPPVAs2w8TAHwC96MxQBQi3PyuRNVCCvy8icJFbAkMUymHj5qgvQVFhxMib8YIXiaLPRO19mUHSZsHbshXJLfFAG4D4xmohUa8MeXrIjYdmqpAFXrxiZABnUjt2S1MwAN7SNiQ3foqGF7UkT9zwaqZAOjlDZiJwBCSpGREFCAvAGVtihz3tkk7kbCFsCZh2zhvcGL5W1M6nLSEpZLBzEgKB9fPrQS2Q1VbFnElEQV6sZrFVoJYbl6UlnGzhy6+1KqgImAiaxc+tVfC2FNSL0EmroZHPiFsdzdg7m/HHnijb6kx+n3mFjrRFWswgrFPYuDPbhW/H5Utd9uGb8diSX+11qCqCHwtgFb86+TS8WjLLpr3be355TxLQkjrRQMlbKuoP8T5dXV1dXV1dXV1dXV1dP1F9efUpEoQtWcNZkD6tkClgeUxYHhjXrwjTe8X+nS05oRLqPgKBML5ftqoTFAinFTRErI8RJJ//ht/SCwEhqyd1BOmseP5VRDkQ9r8TxAys99F4Hx9Xe+3EZtoUqwuRKMrdgOUxuUlkD8NpFUz/+gS6zMjfvYKMVmniLBhO5JBfeyCW8Wg1lIEwfigY3p3Ba0SYXyRYfImqVcHWB+PxhNUevMd3MzQyyjFttaB8IKz3AXEO4EUho5kYjSGyHvkFY8eSP1wU8bRuSRFeq9W5AmEIjPmrAesdIyyKMFfkO5ubHj9YJWe9T4ACh982TpAZM/Hi73UG6qioI4GzpYPKZMdFYtPTj/+vLQ7lg6VAzt8y4hU4/uvqNSibFq8jgVeD9obZEjOXX1mqqu4CpKqZJwDK3kyN5YHBBUjnEWGRbe2I14r0ZK83vZ3BpxnrN3cou3CrfrlJUQ8JCIS8j+Bqs+waP09AUSFQZFx/fUQdGGEV8KooB3OLwiyIc8X+H95Ch4Tr372y9/GjVZnyMfoimN1jMjKWb47gVzuDPTNhebQkz/TOUl8tfYaH0V5rsXnxurObJs52n8e52ucOhN0Pi/FxjiPqFHD5JkISNjNJiRCvvkyWW+3LOD11ipD7ESBLEKXnAqqyQbS7uv4S+lP8hqcnabq6uv5P1X/b3NXV9ZfWnyJZ0/9u++vUl40aBqAEJee5VAEQNl4GF3/gX2RLIdjXERDYoSMtWuLpjuwplBQMHAvn2BRsiQyq6g/dgAbdEhBbg8OnkeGcFGoMDiKfWTajQZkQL1Y3QpXtc0kZwmxg3KKW9vDXroPxQdrkNvj2kNvmk8vudg5uJ+vFP/mWGGp1LGLL/EggUMQteQEHzlZ4KsWTKWwRzRlcAAAgAElEQVQplZd8HQSCDLcUDhd/n6qe5ri9rkFs4ZDcG9uFql0zzvZPS0VZWoZXOwBLBum2dGRrW5YsaYmfrZLmCQ+rofk1orbS5akbhytT1S2NJNGuoQT1ahptxpvxgPy1A9m618AQN4M244JtTaulZoTcRKNbckV9rntLz7SP8S2OElYBvUy2+FR4mKulc6IzYzK26/MyafNyEQoEKPzepBf3U3v97aK3c+dpHfH7Otp9aSkmNY6QeP1uxB+KYEZMeHGfOFOpcX+21FJXV1dXV1dXV1dXV1fXT15/BCZsD6TbFLeDeetAGJ4Fh98Jho8LwocLypsDyjGB/AH++osBysDhNwuoVFtEIsLwMVva49XoM9VAOgmGH2fUfbJJ5mLpg4d/mgEB6s7YJmExMO3yKtlaz6lYxWcIkCFsazpl4u2hNT0XxNMKHSMQg9W4loryYHPOcbYZ8TAbs2a9Cxg/Vuz+6SPkOKI8jKiemgjXDF4K1ocD8p6tYlSB4ZyhRFgfIiQR8tHWn+rks+Zne+BXr6XYHPcL8wLA8FTNYGgT3JEgIbyolsEXg25T3em5YviYsT4k5GMwbg0B5RhAFRg/WQWrnbcymXkS8h/WYYYnxfShOHwZmF/51PeOjcvyVBADgaonn7xiVKaAumPkPUFiAGeGJAbnYImlJ0V6WkFFILsIiYz13pI/cb5VxCQR8iFujKFyCMh7hsQJ4XHE/NqO7/ibjHCtWB8trSSV3SgyUyezzb3Hi5hpN9hUdzytCDNDPYlUBnaTUTH8cAJUsf76NTSSmXdrRXieQfvBZ8KtAhgvFWEuBntWRd0lgMnuscCYfzECBMRThUa2FNVVkJ4tLaTB7qUyGvl4MxOzWCLqPmF8tyB9mvHwYTYTjgj1kHD6m8mXtswICmwrV/rCXCKSzdBrZlv7mezq+kupp2C6urq6urq6um7qKZiuP6Z/V6Lm9jBtlZVbkqYac2Q3oO4iyo6RnisoC+JFNmaHDgFlspnkuFSQmGEBoS2looG3OtK2NgUADIRLsbSMz2O3OWoJBPJ0hPrHuSrS1R7SDeXiKZQxGqR3raAiCKt/TlsiaimNALSJZTsHzjhpaRUihFmhdGOOvEzHKJPzSpyp4ktYnAWotCU+/q3CUv0cMyCWUoIfo0YDItvn+bkR5/9UuQGU/T221Am/SP2Q6M2godtSk0QgBLWUzSoba4WcyRIWqwlxUah48ibrjZNCt0oV51tyRCPfUkfO6WmsolaT4xfsHptZr9vn22vpdn9wgZ1z0c8WnDiL3YPRANFmZBF0fZFwactfMLMlLI3nYykV2Q9Avd1DAKCJUe8mN25kW2+ilsxyFpO6KcKeEOIXHB+onw+1ylM7B7Rxa14ya27MHLuunpIiNuB0ZKSLL0n5aarpRb3LzyupJXS4CuDrWujNp66urq6urq6urq6urp+N/ohRQ24CWCIj3xmHI52sTsSroO4j1tcD5seAsiM8nCy9ED/OAOO2XLM3lsr49gJltuWnotDVjItyl8CrIMx1q2rk+wSNhP0/PQFrxvn//srWpcgqNTLwVu9o08nxYqyTOkUzdgJhfRyQj7audPePZ/AlI5KBkPNd8kqPPeiXkVBHgg4JMkRIsoSIDIQwBpAC4/sZI4DlzbTxbZopIAHIB/Z6ELbETJiNL4MiIBGUxwllClZxqmp8FlWsry01MXz/EYgB+asjcmKsd4zhWTC9ne01RRxizJbyWMUqWUxITxmkwPJ62AC+VI1702RpE7YEzJWQngvCXLA+RqwHdpCxYnq7gJdiVbXA0JOfb68ctYWj8Vqc/SLGXJnYEz6E9ImAWcHXAi0MPkYAltKRxCiHgHipGH7zBB0jdEzgLIgXW90yY0o31kozKLgo4tNiVas42RT5w+3cN1OpTgzStM1vp6cV8co4/XL0xNLejKHFTaZAKPuA5Z6RLorp3WqGWLmZULQWUBGUQ0Q+2nIYieLwmwUQRX4YAFWM7zPKIeL8XUI622u1VS3299deM55tkYyuxrkpD3uUKWB9iAiLYP/9xdhHh7SdtwZuVnGgtidowjmDcoUOscOEu7q6urq6urq6urq6fkb6slETAEFLsNwYM8Fngcshbh8zU8ISIXWf7AWINpbK7u0KKgpNAZICyi5asmURyMCoyaozJGFL1dSdJWjy671VZzxVEmd/eHeWB6/ijBlGWCrCue05WxVJg6ckCPbeWsKCCPFcoMnqOCBg96HaPPPDhDr6A7haRabNOL9c/bH/ZtBZJePP2Mdv60LbuQgEGZOnTSy1ogRf6+GtZgYCyi/ut+tgvB57CC/7BK6yTUZTFeeakHOCLNFDaktWUGC41C2toeyfF+2fLREjIyPzAF4VYxWU3YsYBpGlqXzuGs4Qatfe0jXGB9LRKmVUb4kdcYML8PTMIp50su8RrtXew/1um3GHrznJ4OeqKHixtFY7v1CrErXXgCh2PtPe7jt2wDMVM3rqwJBgNbTGrtm4O+vNqLGUjyemIkFjAMbgxqCi7vZb3a2MhJAtJZOP0RaaktXejHdUkc7GqmlmZ7x4aoY8wMW0IWYQ2XhGboY1+DHaYtbLFTF46sjvx3a/hyWCWposdKemq6urq6urq6urq6vr56IvGjV1sIfVW21EES4F6e0J+esjlq8H46Q8ZcSdpTvqRNAwoA6WMonninguSP/je1AMyH//LcohYnkMSCfC8GmFDAPKrpk1hDgLQrYlpDoQ6jDaNLKbH8OTMWHynS39xEuGBoZURXhawR9PgB7sICiiNoYH24M1HwLCbOmP9P6Mehyx/HrEcBYc/+ET6sOEy7fjZi7Ec0WcK2pi1Cls5sYGfb2Urc6igRDa+WpJEPIFLWUsbwasR8b4ydJDmoyxIlPYOCMyMD79XzuEVXH4fkFYKgbYQ/jy2paveFWk54xwzVbLcvaNREJzi/Le+DLxXLZEigxs6SKHLjeTbb0LkGhrTvF5weXXB9SB7LwOQDnEDfBr94IYLHi1xaG6czMn4FaVCnYPrfcRYeSNpTJ8XKFsSSfOgvHHBXWKmH8x2Ytrq1wJyt5YNfvfr4inDFoLUHUD79b9YEya5wXxSTH9ViBTRD0ONved63Y/58dxW/dqkOdQ/RysYudSDSBN1SDHUJhhlz5nC82vA/LBPgYAhx/smOc3cUt8xVlAuSLkit1SsT4MuH4dMX2oGH9cUadgxlF04ynb+5IpuuFmJtTwsdzm6f2eA7ym50ZlmyqvOzOjqCo4G7fpZTWvq6urq6urq6urq6ur66etL8OEKwBV5DuD05KozW9/fUS+T6gJ4IlRagQJttRHS98AVk8qiEhfv/LUx4sHR+eEaLA0RlwU/Hxbx4mzLe3E2aeNR69JOe8jXCtCtodh9aUh2ScA90CgzUzRYABeq7eoVVgUAMMSLils1af89R51DNuDPC/2VFxHY+yQM0c+O8Yp+Mf8sIolRpQA9tSGRIJMaUsFAQCYUA5WzwqLpT4Q4eDkZnbcTDJyloudVwfGVrWESEuAyAtA8cn5MmvdzKCWNFGBX9PbglNYPQUzJTPIRkK+j5ZGebEopJGwvBlva0d+r3AWZ8jYJ6ezIM6EeBW/FmZmyWDn97PEEeycykCoiRBG3qpUu4slaSQyQiYgEvLjZMfsCRs7F8ZlsQ8AZRcgj8mqYdeywZt19NUpdmB2EWPdMEGGaEBg5+QYzBdbNarBltPZ1rRsVv22KsW+jnW7/y3RUscAGehF1YluxssLJhJUUfZW+asj3yDBtSVw3GQqgng2Q8u+1j7e6m1lH5BfQLW7urq6urq6urq6urq6fh76olETskICsNwFg/ReBHWwJRtLupgBAjJWRpzlBZzXHirLRKAhgL+7MzMk0AaZNa6MJRwk2UrR+O6KcrSlHT7d+C4AIClBApx3Ixh+zOBcQbmCglVk8jECx+gP59kME3+Q5mqvRUU8yWLGTh1t1UcicP522FaVOBvgto6MOjLSqYAXT8HwrbpU9mGbWDbwraVJjKFjlZ06DVjvw21i3LUeGHUEpg/ks9T2CXGWrT5E6kDdLAAYdbRzzyODJGyQ5cZYaamL+FTAq4CuGRh9QYrc7FH97H3E1Y0AtvRMmRh1AJaHAC5AOldALPlRdozra/bUiF33eKoIiyDMBXVv607jj9kMGnagrb19Y/PAkiBcrTYGT+uUkbDeGXQ5rIS7/7lY6ul++qwWtbxOUAJ271bAl7+4EGi5JWjKMeD6OmD/ewLPdYMuNxYR4LWybPwZjcYsevrbgHhV3P1LQZsCD9eK+Lyg3I8ou4DxQzYw9TcT6uhQbJ8+B9n3ANoiGSMfefuZghpnR8KtpmXXzNlMd57gSYTQJsGLGN/IAdgGX87bsYoblcPbM+i6Yv2vX2G9Y59v/9JPeVdXV1dXV1dXV1dXV9dPSV80auK5biwVLgajNVZIgezilmx5maJovYycLL0Rry9mqMnMCyVCOpkxUJ37kc5WPzFuTEY8GxBYnRHTlp6Mf2KGRDlEkEZQHbZUDvnCkCSGhsGYHUSI1+qsElvwEbZ0z/wmgRSYPlSr6ow+98zwlR9LUrQ1ozrFz1IKliSqXsUKoErGsBEgXqt/Pzu2dLl9YUufpKtVjyCWxAjXggAgzsZSkYHta59X1NEXmSptq0HA7UG/MWeUaavHcGJAR2ji7VxosPcNxZZakcG+l02xA7t3BWA7H1AgeCqmpTlIwmZMSbRK2fQ+g5aMUAQh2KR0TcEgylU3cHO8Wn3pdk8ESLD0yHCyFI4ZH8aHya/3ED92vEwYtTsuemKlKjgyZAzIdwFl5BcT8wLOBlVOZwbnZigCy6PNvXOxRanj99UNSGypIXuvzjpiNwQRt2QQVX9PtV1fNWPKDZgwt6UoN17UTCJVYwVJIHBp9TeAodt70kiAsCWjxJk5IP9ZwgbDpqqQKYGCGafpoojn+llqqaurq6urq6urq6urq+unrT9i1BRb2vHqRzxl8GUFfXwGxgHxbmcgWwcEa2x1IwIOlh4Jq9VKWopFBgPNxnOFuhFAaomNVmPhywqsGbjfQcbo60ZWOWnVHQAoh7A9TDfjoYFuDax745G0tIcSWcom2APy9Q0jzsD+N1dIZODB6km1GU+q4EXARVCOaUvJGMzWH7jnCrDxYxABLgxa7fs1E8tWjLDBaAG4gSSbaQAG+FRAYoZV3SWU/QheAT4vAEYH8ypIPu+0KGM71mZYgYzbA6QbRLjBdtkNjIsinjPWOEASW1UrC6YPCyCC+Rd7m0ify5aOYQDxUsw8i4x8F5EPjPEjgeYMgiU96iGhjuy1IzHmCgHDR09BFYEOEfluMDNCLbkyzAYXhpoZJ/t0m81mSx5ZKgjbx6qDiWlk1ImxHvjGc/EkEHkFLF5s7QpuAM6v7T6Ksxkqh+9nA0zfJZtXL7e5+Hb+ys4qT8asaVBi/QNTRAm+oCWfGZZtiQswaHD1WlT7Xs0Ea++RmAARAGGrX6mn05QJ4SoIVSG7CAwOGL4I0lMGF0FXV1dXV1dXV1dXV1fXz0NfXn3yqkkdGcqKckgIBIS8g9xNWF9NzoiRDS5bJ1takugLP55iKQebum6AW16dKTPSxkopuwSJA4bnEeFSDGAbCPFiJs7wbOtOXDxhM1jyIp2KzxgHxKsgzt5XYWO9kAjKISDfRYSrJQyGDwskMiROngrxRMeHFeWYUF5F46XsoyUVRJEP9rHdb2eEa8b1u4OZUc8LwEB8vBkKkgj5mGxN6RAMuvxp3VIZ64OZGJwVYRav3zRIbkTdG1A2zLawdf2be18x8oduN4okEoanDKqC+asJdaLPzYLmNxFQE1n9a7k9uNeJIcNk5zXrZijk++FWyRFY3UvgEGJCOTq3qFhF7PC7jHAt0N1gwN/yooJ0sCUkXp1RExlI4TNAMVUgXqqZLvuIsFTQKrYiNvJmcMUnS+MsXw1QIoT5NtWNtpoFIHkiCgDSpYCuGbq7LW4pucmigv1bq+Q1eK/6/He8VtSJcf06YfxIGJeCeFoRrozkIODLLxLqABx/I9sUeDPFSNQNSULZWV0vna1ORVAsjwnr8fZ+xo+KOFeUKWzg5W3tShQ6JsgYP+MchVkRluI/g2rJo4ERn/O2CCZD+Hf+ddDV1dXV1dXV1dXV1dX1l9YXjZoG+5Vgf7BqTATvBtT9gHwXoZeKVHSbrFZfINqWoopVZmRwtkq6JSPaQz8RwMVWisrOEgsx0VZDij7fHOa6VXtaPYlEjT8ysK/y3B5ilQhhNZMnHweUkTBWM274soIBDDs3C4JVlsJ5hQyWBhJP3cATKnW0P/NcQKcrQAd7/7mYSVAUCF5F8mpVPjCWRwJnBr+tftxWQ6oj3WpV1Rei/L83jktYBHW0alE6V1uYCmbGNFAyz550ejUCcG6QX79/ey1VbvUcwAylsqMNXtxSH+VgnBRe9TPOjAQy82nPZq4sxqdJT6sxewabXQfq9n1ldDMl3ypE4qyj9nFb4aqb0UeFEUj8ezr/p1rah4oY64jbPeBVspZWKrc5c5I2613MqAm8GVCN/ZKuBRoYSxy2e7N9XdnZulOcne+zFPv+awSPEfLLhLL3emAV5GST7nUwvoy9Hpzn5BdEAKiiDoR8aDPhnsrJAmoz4C2l04DJkSFeYdsqUqtYYqnYPSSTXbfhR1vIKq/2llbq6urq6urq6urq6urq+lnoi0aNeLJgePYp6w8z6iHh/Hd3vrJkn2O8Dqt4tHrN+MlTAIkhniLhrNj9WLfFJUsc2INoyIKwBE/jWJUlnis4W5IFR2D4aFPU8+vkdSZLlFy/mzZ4a94RJA5WuVoUYangpWD8QEiJEa4VUMX113f24L3aolSZAgITeA2bqWRGAG9rSg3wev31AZz3vrSkWL+7hzJheYwbLDjOiundCqoRkowZIkPYzITxY0Z6Nu4IiSUh6kTbObfzZfWpcPEE0BiR79NmmvBi563cj9CHyc7JrJDBF6ecmdLqYru3GWUfcP42Ip0F0/sCzkC4mplSR0I8qwGBd40d5HPYZMaaRkaYBffvF0iylJJGRr4fEGYDOGsgUPJby+HDynYf2TqSgosgXuUGlo5kKZ42Mz0x6jiAKjA8VcRLBVWBjAGyjxu4WkZ7P+NvnyFjwvLNfjPw2hKVpAB9fUDdRTMbi4CLWu1uYIS3V7AWxDH4Nb9xcCzJZde5HBIiACorwJac2X2oGM52fM1cI3FoMGBz8FUxfjLjqkzhBQcoY//725ITYIm0l9/fFsqcj0ONt6PbClUdGfluskSRJ54AgJZsZuKrvSWYurq6urq6urq6urq6un4W+nKiBrCUSRbwUsFLhuyTpSl87lqSJUA2RoxzQcJSQcWhvv6cSNXSMY0PY3PGsr0+HAabjxES2yRyxfpgfx5UgYqt+hGvNpdcJjMmGuy2DrAFIPV1o+qpiqLbdHY5GOx49LSCsgFdNfKLtEb7px1Ym6hej754dBWbgd77Ss9A27GGVcG5IqyMsBokVgMbCFlhDBvIjVfjvJdWvwmLQY+pOAB5Lb5gFV8sawGoijrZohOpA2uVPl9lJgIVS17UkVEmICz+GqJgTzw1/gtEtjlw8rSUeqpKyQHL70+g4w75aOaUTOFWuWKGumFHis/4Qp+9rWIsFuMJGWOnLVw1/kq4iqWOLiuoCOpub8daFATdjC06X8HAVqVqaZoGJNZoBpwGGPOnCuoY7ZYVS6Nwli0NpkQg58i0paY2Jd/+Z/Bnm0AH4IwmbD8IGjxJMxvjp9UIQZbeis8rwmkxDhSzTY4n2rg2VG7GFtrLbutidh00WK2K/Vy244bYdVT6w/Pe1dXV1dXV1dXV1dXV9dPVl2HCJ+tuNEBwfnMAABy/N75LHRnLQ8B6zxg/KdLZHqpbDQUM8FqBQKiTmRXhWuzFydIjdQqouMFVOfu6EGh74OR8mxgmUUzv8u1BuVoCJCyCeFq35Ee+H5CPARoG0P2AfDCw8HCqzkOxNMf1qwQuiul9tlTM6xGSCOOTIJ4F6Tn7YhIbDJgIZc+QcKuzpOcCLm7UBOPzSCTMX02gqhh/zNDIWB+Sz4Ybf2czRwAMnzJ4Fax3Vr+ZfrQkSzkO2/WwxScgLjYTXo4J66thqyut9wEagN3vsydAWn3KVqnKMYFXwev/sSAfIi7fJMTFa0fFzqNGRj0OkGjmyfUXIwAgPZdtyYrXCsRg52W8AYrLLgA02gJTusFyGxMnXi1VsryxCfR4rs6nYYSlIp6yQYbXgvWboy1yJYNNQwCabQ0szAYCNqPPDD6dRmhkpKcMBIJEBhczAGUMkMg2ze73C9SZQ4mQX+8ABfLReETjB0sLrQ/JYL2+VJV+vGJ9s8f63Q7jR2PyxIunyu6NK5OeitXkBrb7vxDiqWL4/Qn1OKIO01aNs4uqbmyFW1WNAVQgvT1ZZWsaPIVUoYcJEneQxG5gktekDFhs11KQvz6Cvjra+Z9fdN26urq6urq6urq6urq6ftL6cqJmm3/2paRoCYtwKcAU7WHUV4YA3RIMbSEHcJPnxett6zmePNn4MNWmkdFSAS2d40kZVWPFKHzWWACNMCOnqlWIZjOBCADtk7F1HERbR0vMSCSwGDRXYMs9pHSbik63mlZYBGGpqERAULDCj9NXeNr782RLyAoRbImXOhLibOyXGv39AgZ5DQQZbpPi7VxtU8ue9KnxRYKjpUT8f0pmCIVi56CtOXFpXJNwe10GyhjAq4DPBeQsE/WKTrtuGsiqam6+iCc8QmJwFq+KKTQEaGhRqcblsXuhjjdGCxXnr2hjGJEbXEA84/NjytUqO9cFlPdbQkuCVb3A5CtaL+61tdi1i8HOXfX7LeCWoBqNGxPavelJq5ZMsdf32fIK0FJBzhG6bYADlKsZO3uyie+Z/HV0u+Yhy1ZBUiUwLJGGNYNy+uxnY/uxaCkdfpHmgSVittqT3zfIFWHx+yfxLX0jVn2yupSaERhslr6ltrq6urq6urq6urq6urp++vqiUZMfBmiAL9YoprezPRQXe1CsO8bwLBg/VKTnjDAXrK8nrPuE4WO2tAOwPfTD60QyBly/tiRInGV70JTA0GSfR1VR9gFo3I8KXL8etgdTzorx/QoEQt5H1MeE9b/sMT5VjO9W1J1VTIrxdc0YyILxR3ufEhkcCJOvA7UKTXqut+ljhi1A7QPKdJsIt1qTbhWbOrBxSD5YKmerQiWfjXYwbHoWDO/O4A8nyO5rVK+sALaMBFWkc72xVRweW/aM+ZExPit2v19RdhH1VUKYFcNTsfnlqtgV9YSK1X0k0gbglV3E9U0ANCC8iQirYve+IJ4r4vOC/DBZ5czrWwb+tdl0ZcL6EMCZsT/bxHl5tQMYGD4WZ/r4mldRqwIR7JwxMH4woPN6l6DROSpklbE2aV12EfkQMXxYkeYV4Zoxfgh27veMcj+Cx7glnmwJTBHJDAzKFTJGrI/Ddj/RRcBPV+SHEfPriOQ1JarRkzUV8eoQaADxZIZf+HQGcABgaSL1tBB9fbAJ8wLkBlvOL1JfVZHenoEqwNfHbWGKiqVmSATpVLYqE2WBBjOYlAnrfUQdCMnTXpf/8sbvddkMrXhaMfzjD+BfvcH8+oCQbQmMKm6ppl3A8tjeX9iMwK6urq6urq6urq6urq6fvr48zx0ssSGBwOHF0x7foKZUfNLZkwrqyQQAxjZJ4capUdpqRBJhCZUXqZ1mLrR0ghJZMqIlSJh9gQrbg6sxRtSXdYAyMuIU/HWwLSCRp3TUazFgS41s60nR0xquVtux9+qmh/NBtohQ+7MnSiiLpz58uvrF2VX2yfIUAAfttqUfqCdSiLbZ7bZM1Mwh+HFyFp9LZ2fneHIkVzMGmDYjpB379jFgS6gE+PTzWkGLGWoasbFktvfmZhRnS+2og2m3JSG162zpFXt/PDC00HaeyFNPlbxGNL9YaLLbwnguI0OmAN2Nzj3SLbUkgUDBGDNo54rs/tLAYCL/d7uOJLCFpyltoOnGHGqJLc7V0018OxYi+/6Jb2tXfn+UXbTUjbxIX4m/FXmR1vH7TduxMUGHZO+P24XVbQZcktXI7OfNzoXFmOxekA0yY7DrEAPAtCWC7B62a9wSO41hg9tl6Orq6urq6urq6urq6voZ6I9WnzgrhlIBsUWabTJ4qdh/n5HvR1u22QVQHTxB0Oo2hPUxWaoEZgLMrweAvFq0Wr1IosF968ioycwTrupmELb6R1gEHAjrgTcTgotg+LSCS4KyLebMX6XtEMaPFfFasDwm1IFw/qWlctLF0x/ZK0ReRbJaiy02ycCokXyJCti/LYjPGcubEXUkMy48JcRuaADYzI2wuJG1CNbHiPmBMb+OCOsRw3PF8DEjXDOgivXV9BmzRgZ7eK8jIWTF3fcF8VwQTovVbdSSTmUfcfznFfzpgut3b7AeGeMn8WSLnaRyTFACdu/rrX7mpoT9Wcx4iLSlYoaPGVQFl+92IFXc/z9vgRTx6b+9BlVL9sjAyHcBYdYtUWX1s8nMKjc64tnqSbQPiFfF/r//ABBh/dUryGipmTrYTLjEAfn4uN1/rYpGbmANT5bo4WqrT63i04wjuz8BiGJ5NaD8ckTIivHJYdLVrgcVQXheQKpYvz7YtR6s7lQmS6oMT9XuzZ3NrLe0SzqLJ48IMgBUaaut5a+OZsJEtvNzCCgHS4fJwCg73q5fvBpTpo68rZ01vg2TYve72ZaudvHGhHoz4vLdL+0aPVVf9lLkO0t9xdlSQ8d/ta8t+9Tnubu6urq6urq6urq6un5G+uOrT8BmQEg0NgtnAeS20GOwX/vtva3PeLrGKx2NMwPgNj0sltrgIgBswpudlyIBqIGtOqW6LfFwUQh8dtpXlGwT3P4cZ3WQL8DVqyLXgnApoDZr3ZI17MmFVUFt0UkBdtZxq/PUkW/JHNHbshLckFJ18K6ZBqT/P3tvuiNJkmXpnZjCyMUAACAASURBVHtFRBcz8yWWXKqqu9nFDQQIEPMW88x8C4I/CAIEprtRa2ZkRPhmZqoqIlf4414R9ahpRpM1RXQmRg6QqAyPcDM1VfVE6YlzvoNmPokxfGodyS/KsamvVc8HFdpXfHg3Jkrl9ABfpjUsWUMjm1ngQEN4dW7tuphRU69bkZ13Unhns/zr17y8ei2tFxXWFaL9GlsSijUdUhKD6roTv7r2udi1tJceAuAYMrgdhiv7uc8jNRONI/a57QLA1p5qaqiqLUaZsUdiiR3ilvyiYsfltIdXRqepF95Xw6hAa3E1UeT2JFWdxeZNUNihVM7z6+Owqlv9Gic7T6xmjlvVFGuGnN079c/We62mdorbzbu28jQRXCSQCIqllfRz2zUNmgTjeq92lnBXV1dXV1dXV1dXV9cvRv+vjJr6wJ1GpwkUBtggt7xljJ9sWScwwtMGWjNk8rZSVMB4VcOozQ+2lZpzBNs0dWV1nH8zYr0j+CvBRcHlnUcOhOOfI8Ii7bjS0e+mhRSMH9c2c82bclH46QpaN+C7GRKA6aN+PZ20Q6XmkJo+/low/ZQQT7qIJLbgFK5qshTPSMdgiY4Cf8kgKS0NdP5uwPBScP+/f4IcR5z//gDYg/jwmHD8l8XAzEA+DJq4OE0A6aoSbwXxRoGzfInA5IGi7yeeQIODjF4n088RadaJ8eX9AL4LoFIwnIstMwnc86LXb/DN0JHBWbqDkEaCvzo4tonrWuMyjhBFsQnygvzmCAhw+NOihtaWtJ2zaRpkmQPCCyOwLnzlQdk6hYH59wl8XkDvZ+SR8Pw/v29z3C4WDI8JuOq9kWeHeGS4pej0dRRl0NQFMKuJbW9GFLaUlRTI+KpqZctOVKyClkSrVwYVTrMaaHQfGj+Ic0F4jGrQBTJDTb8uuSCsgiFDU03XiO1+BMhZokpNx0Ja36rnkkSTSQpZZl2JerxCDgPyHCxJw2Z+6QoWld3o2u6Gdj04CsJTRLwNkOAgAYizw/wRCE8RzqbH40HTP3Wy25/1s3d1dXV1dXV1dXV1dXX9MvRvMGpeRQUKFMQq2GGt9jf8cDUtoOBZjMoKKX4H6fKm/JZssNriLMUCaE3EjAHKWi0pxLpQlAVu26s6dZkHQKsdiXc6z31NgGNQEV0XmjxQJtCkVSiO2MGqNcWRBeK09sKxKH+nwWE15UGys1sAmOFU2THUaiuApoHkOCIdA9JICh5OtngUXHsIV4iuIM11yto1hg4IyMeA4rk98LdVqtE306IuTlWeDCVqtSsAyMdRExVWQ6u1NbLEiYvG7DloPU0c4Oy1JLCubFVGi7O0TE2CjF5TNJZQ0YUk0pUlO0dVMnuAJz1fZEkXob2ChcqpIZvDRmPRtPRLYxNpKojafZWVe+RoT6LYtVceTQUcZ/0zvNfm6mdxq7QVrWKvjfqPlC/utzwyihvavV0TM4BeC/+isaA88hcQXyp6XDIH5Mkjz66laep5aO9bfy4aa0g/gzuvAAHDyWDVg9b1av2LEmwJzEw30G6OdnV1dXV1dXV1dXV1df0i9FWjJltKoS75hOdoZgmBooCXhHQ3It54jJ82uJcV27sD8mRrRlYloVwQXiKKY+RBOTZ5IHBkFM/Is8d67zE+JISnDfMfz5hhtQ/PGD8lBQ0bi2SvhahBEGfC+EQID9JYIdubEduNA5XBeDGC8SGpGTCymht1BtsxthtWZs6iCYfxc2oPzvHGaQoDaODiwlZzgaYYlO8CgICXfzggD4T1njB9BsLTBhkc1rejnj8ChocN/nHD8m7AdmTEo57rcNVIRfp+VDNlEatNZeTAiLfeoL17TcpfM9w1IZ00BVRXn5Z3I1CA8XPUdNGazLBxcEngDQ68fDu/YrAkuEUQb9RI4Kz1IxnUKUmn0AyXwtQMgzgTxs8F7rwhHwOSLXehAMs3I0hGTQVJ0ZQOjD9j5lRlBOWwG3l1/h3YU136C9jqkyayZPbI46DcoyUjTw7bWwe32sT6kuCeVxSeASa4qyah4klv//BZk0fROEG1lke5aNUvld0YuXEoDggXgVtKmyvPkwMlwfDPH/S1/uG9gqjr6pcUpNkhvxmQJ5soz1rjcwuaUdTqWUzIk90TLwJ3TaA/fUSYRtycb7C9O+DyfUA8ENabAdNjhr9oJSsPALCfx66urq6urq6urq6urq5fjr5q1HCyVMmmE9oyupZ8EE/g0SFN+uAabwLy6KwGUqz2otUUFIBi3hkvxiOpy0r19YqzNRzHKE5TNvVBsz40F9bZZ8BmsreCySoy+TBoTSaJQXz1Afv10k+dYqasZkG8Udhqndz+IqnhtJri1gLK0tat+NUMNhk0mBOQw57Y4VQwPujvtXQHsJsQs98/N1vaRzS1BAD5deKICXl0athcMiQw8sRtgaguCwH6/ung2sIRZezrSp6V92OrQo0hU3Qm3UVd3MqjfmZn0+mA1sy0VkYtyVQNKxRoNYwJ+WZENihyXSXS99FjB6weVHaeEW+CMjlLW1HjCzUujRSkk9P1sWQJmVqHsspcOItevyQgqUkfOzeOtYpnyRtX9HpStpTLIWjyJoomn+y8p4PTtSebGS/OYMtLXZWCnfPSGEz52ztA0AC+nESXobIAcFqjeikIr9hLdUHKVT6SJWm0dmb1vALQzRFymJoZ6raCNCnQWOznxMWCshD8ovezv2TjQHV1dXV1dXV1dXV1dXX9EvRVo8ZdLc1xVXMgnjyK14fC+uBaV3biW4Z4j8OPuk50/cYjTYT5E+Czpm90OnmyB2qDp7KlKYJVNHLResisKZbiCOFF0xMKKGast5p6mB4yhqeE4fcPkLsDrr86wF0zwkuEWzM4C7bbgDTtZk9NQPASIaPH+bczqADDk7QaC68Z/uECOU2QMMC/xH2qukKPxSozpWAQrQrRkVsqwl8Ew+cNefbY7j14UyOgpYBuHQBLP5AaV/XBGgTk0S6NmTBpJISnjPDhgu27I7Y3vpkWxVFLvADAdut2PlApgBliefIQWzYqpGaAAnsLhksCRcH2ZkA6Mg5/WpWT4wgyerz8/WSG0m6ulcYaKghnrY2t78yocYBbtLKVZ0YhwvC4AQCefnsAFWD+EJWls6S2iMRmsNX1qXq94q1vkGEItCYnaoIBwPRhNfNHlJfkADZwshqIpKaipXooZnDyEA9st8oFGj+tANSYzJPDeq/vGQ+76XR4zhg+bdjuB+SZ4ZZqpgjEEV7+8QQAGB6THv/Vklmppr0A/7TCfT4jvb9BvB2QTk7XzjY9Nhn0uKefNoU42+eI390h3gacvw/wS8HwnJEmhzTt8+t+EXAiDE8Zbs3wD8teR+vq6urq6urq6urq6ur62evrRk1dDRo0WVKnkmuipCS0pAhlwElBcQqE5Qj4UhdvABk8wIBfstVc6mS31m38onyb7d1kyRKBFzUh8qhgWkqaYnBbAWeDr0qB3B2QTgPyQADcFwaSu2a4ldrKEkppqR0QwUVNb/hLtjQFafohJkBEuSSTgYfznpyoE+VUCtKsny28qJlEBQ1wDNiyDwESnCVIKtTEEi8MpIlAA0DiANI6FZWC4pS/MzwkBeRKXXKqqSQYhFmNIAAYUJeSYA/+bq+KeTVp3CZqxFnKKU0OcvQoriapRFeFvAeKVsHKa2YNl1ZFUuOt2HFgT+JYkqdBcplQnC4qAWgwXQlaHfOLTaVb0kR5PmimGApjeErKLromgIEy6y1cF7iK8ZLCVcDV8NkyeMvwnlraRwb7PtF7slhdTk+uvo5fBFS4JWzqJLp8OzYWkJpS+gcK6T3S0luW3NGToPc7b6LnaR6RbgZs976loUDq8lWGTh4dSHhfe5oVAu3XYtPwhPFRMDwLKL+aMhdo7e/oMG8C3tLXfsy7urq6urq6urq6urq6fkb6evXJ4MDp6JURE/bqCexBXAb9urN6hng1A/wqKJtOJhcmyORBWcBLBnllzwBax/GPK9xPj9j+22/w8usR88cE95zgrE7z8ve6FhTOog/W9gDuz8pc2d5OOqVtx4Ija5VnUa4Orwn5GCCeG3emeKtmbVqZCc8bxDPyQSe2aY3tAVkGfW1/kWZeUS5w16jn4BtNm0yf1vZgXo2KQlqJgj1ED+cCt4lNY++m13pLKLa+VIgQjwCg3Js5EcJPFzVpsrT6GWBAZwLgGbREO67aoVEGzXY/NDOgQnrdIhh+OgOs12K7DVjuHYazqNESMygJZFSzZ/zxCjhCvB0boLbBe03iCSUwwiWBNoFMWlfy5wTKAhk10VNnqNNs12NWU8pfBHkkS4hAWS1mXrirHlf4vIDWqJ9t9Hvlp9a7mECpIDyriUfJFqAW4/OIU0iyfR9nAa8Z4hmX9xMKAX4V8GbmXSp7lYrVQMsjMDwV+FUgA6EINR5PTVuhAMhaxSqsrBoqahqBCPk4YLvzWN4w3GKVJa7nVQ3DPDNgRlIeHdY3umLlVoNTO03d+A/P2H59h/VtaGDi9U5TTcOT/3+eYO/q6urq6urq6urq6ur62enriZrzhjJ4xFudiNZ1HLSJ6ZracEtRQGogTJ91fWm7CSg6tmQrSlmNi+CAogZK8aSA3DcT8u2ANDmEi85Bl4FBq1aehqeM4kmnjktBOnqACPE27EyYTTA+VGOFwKuuUAGaZFFOSMF2GwDWWhdgiRSBJmGyaHVmcCi/easJmGwP+9jTEvHkDIxrq1FeUybxbtAk0MuGdAy4fhNeGQL7QpB4skUh/fccCMNzaSwZUEE4q8nltC2E5e9uWk2oeIZvnBRNkJSiwF+S0hao3Kqf0S3SjDaKAK1qlMS3B9QFK3/JOK7S+CjbuxmAJkZqLag4xnanqRtxasYNj8mqa9zmrNPsUQ77fRTvhrbWhFIQXjRVlY6MAjVG6gqXJnq0DpdmBjsCR4UaQ4A8B9BkvBwmNSGkQIJOpG/3fuffGOsmHfQ6iqVf3DUrxPccW32qeMbwmFrVr3hCPHireBHcokaRvzDyyPBXZSGlk0MeSYHApejaUy4YP0c1aUKdRLeq2qpT9nm08/pYGqvHrVo1zJNeA3fV85KNDTU+ZDODRJfSgk6h490Jbkk4/DFpvc0TivP7fdbV1dXV1dXV1dXV1dX1i9FXjRq6qktQ6y5uLfu0dn1YXwS8CtIhIA8Et2a4pw1kZkpNF1RORvGaeHAvK/JhgBw8ZCSkKcBfZV8E8qz1liRtbSp8uli16IA8Omz33mpLmnThNSNPHglOf71p+qTOhwNAOjJyIIx19trMBRjkmKIyTtIhNJAyZzVCKvw4HjT1wdHr+pJNSscjw3mCv2hN5fwrXR4KZ02+uNWqUIFs6rxYAgmYHjXZs91oTcmbKeZWQR4Y1/cOfmGEF01K+KvYtQDUbdHXpUL7QpWtDfGWUYQh3tlxCGRgbHeu1Wzqald8MyPNDuudzUc7rViFZ+W7xCO1Yy7MCE9k8+oEXvV8pVkTSM5YRGl8xcNJQHiIxjziBniuEGetRpU2ha0XhcG28iTGm8mjVYnsmsjASEeHy3uG24BwKS3x02pUtWGUC2gR8BLNbNHEUXiOWpM6r5DThPVNaN/rVk3zODN1NLlSEG+88mVSAbKuObkN4MumxtLNqMbM7FA2M3dmh3hSGHB4zu1a8SatLgZoog1EzWgKT7EZk3mEragxxAeMP17hPj+D70/Ic4AEbjyePs/d1dXV1dXV1dXV1dX1y9FXjRqILSjVClBjYOhkc4hZH9oDa32o1k9GBwn6QO+yQma3d7PWgCYzUZbYKhn+JWP8HBvgtiY04v0IiE57Uy6Ibw9tKae4fVEKBvPNo6Z1aj2prlABQHiJ4CXDXzx40NQNiJDGOiU+6RT1ZumOrImhPHNLJSxvvc6KJ2B8UsODU0F4UaiweOWZxJNWUO7/r2gmlMKPUbklYrybVDA+6zkk47YMz8pL0UUntNUfv6g5488J6eAg086L4U3aJLeQmQbQ1aJ6vVDq++OVYWGLUAWQwMBhACWBvwIyWlVKCFSgU9ak61RulWbCyKCfucKSOQncynb+GWUyho2gwYLDo74vJzWXrt94hHPB9GFV48HSOm7ZjYu6xiT2+/rFOvGtn9lfBXf/rCaPBGqJmsrmcZstMJmplW8mUMzwL5uaP4egqSQzY9xSQCk3YPP67dzSL0I6HS5+P58owPCkF3L59Q0oCZxxg9TQI2z3g9almMBRFNTtqVUBKRvUmCwtU4DhUZM/kKJT9m98g1XLoIaazB7gG2xvJuTZGa8J8K6Cfrq6urq6urq6urq6urp+Cfp6okYKStHEifBeg6Gs9Qt3TcDskSeyB1j9Pp3Xpn2SmgjxpEkI8QCgIN8qtwr80wKZg9aUAu+JCgDD4waKGfH91BI5ZGZKnXAWJl0F2gBeRUMmr6C0lHXpR+tAWl8pDro2xYR0dOCtINTpbdnNqVahmRnxAMyf1BSotSj/vKoBMHvI4BBvPNwqGP98QbofkcahJSGaYWJgYncVsKvHSXCL1bXG/eG6GmO60JTBiZEBg/qiVX2SrS2R1aXyYPPboskKt7zqwcgORkaxlNTAuqa0ZXC0ie9SF6MswWKMovCcDRLNrz4P9DzY8aZZj4Ebv8hqc5a0qiyWeFQWD79aRqoMIglqiKDeW2bS1WMvrGmiQmqc+ecVMgVsd0ENsSj6GkUrYJxE159s8pyZ4D9fFeh8M2hdaOQGhOZN4K4R8XZEOjqtQK3SgMev72MqOmleGMqLyYzxc9p/lhwhT9RW0+rxFee+aCi586bVvpOuY7mnuH92T9huNI3jLvZ1p9PjmQPSyel8fdnf8zVHqKurq6urq6urq6urq+vnra8aNWUaIGP4AtRLWQ2SPDAK6bezVWkKU0tEkChfRVke9aFaEzXhJcH99AQeAniddQVn8PoQX7QmRAQQa7Jke6PJmjypEYGBLMmSW1qEi4CE2sN1sSltZenook+hESBly4RnfYAOnoGi5kMeGNfvBvirYHiIyJNDIWfHbpPkrKtQlArSURMPnAcgF+SDRx4Yy70DJ0aaj9huGNf3jPGhYP6YdTI7Fp3INmZK8cByp5Wnwwc1fygrvybeMvwqGD9GgIFsK0dqCFgCaSTk2SM86SR0TWg4q1eFl4RCCkXmTeDP9oBPwPZ2wnrvEM46D82OwVnTGiDC+mZAqXdJUR4RCGparPrnysBIk1bR4kwYnwT+knH6XQRlQZ69pa64cXiUexPhDg7FebhNa0/+ki1xlcFLAh2CmUH2WZ62HXBdTQgB/FnZPes3B8QTY7lnjE8F4yc1TkBAmh2oMHjVmlnxhMwMPg1qXOUCZwDiPDKWd0ENo6sHR8H0cWtsHAUi6+uDCemg5h9s3UocAEdY3vk9QZV1tj1PjDQS4pGRx2H/eSOt8omtjFEuDZbNm5pQbs3wi9cEVXB2P6vhBU8Izxn+Is0IpFS+qFN1dXV1dXV1dXV1dXV1/bz1VaNGxgCZFB5bGjxYp6DhCAIDyKb68A01XRza3+i3B8ZSUApBsn4NKYMA8NVDBg+Z/b+aUICo+QNgX8XBnqTQP2iVojoTLWr0gNDYMnJwyAM3YKuCkQuKF33INaWJwMm+sdTKjf1+rS5ZhajObufAIG91mpGQJ0AyAcRIMyGP0Af3V7PNIG6sn8JkyR59Ta4P9jWFshF4TVpzGV0zFajo+RCn89ajLRzJSSnOlDQNxVc1McSTnVOtALE9wIu39416bQWMcI66WnS7A5Gr4SCOLClD4CVBOGhVZ9B0TLgazPi8ga4bCh2/THWo7wK36MS225waJ2aC8SpqhtmUeqtsFSiUmsiA0vU+sfQIgDwR0qjJlXwt7dgBoHhASGt6lAUFCiNua2CwezYJMKqZwk4POCRbhwoOZdB7j6WArNqUDsPOb6phKLJEUUZj8LR/RJNBmRU0jQLIgPZ1NQB3phHAO9h620HSlT9TV704CbCWZmC+/vxdXV1dXV1dXV1dXV1dP3991ah5/J9uQAIML7mlQABb5/EGcB31AX04C/xFGpD1/HcHpImwHZXPMjwbN2Yi5HlAvP01wktC+HBGPgYs3476pq8YKv6c4aLo+5IyRuqDLmCLSaPDeuvgl6ILRDNDgm+vpRwZ5Z3odLKaF/7zFWBg/fZoU90w7k1BDoTLrye41cC7Tn/v8CHZA7UCeykXEIB0cppYCWRJCa3yUAbCuWD+qHUZXnWtJ81OExLbXs86GpS4rkkNH67GMRlBSWe288FjvXNwsRiMGA1InMf9gXx9G1AYuPlPZ5AUbG8nAwMr94TM5ChM4E1w+sOmlSdjoMjA2O71ehRbkOLNjCNHEEuDUAGCpWWK1ZXCRc2uPASdab+McJcNWID07WzrUwphducIvib4s06i59mBsp7XePJIB8bwlOGvqaWHoGGgtrzlNk0opVMApMC/ZK2wXdWoyDODV53aXt94pImQZg/KwPEPC9yakY5BP5fXmW2XlXmkNT2C+NLm3FGUY0RJjaQ9LaTMHo4CKnrv6rVWczA8J/15OagpNS5WiSqAW3UGfLvT9JrMej6ruRNesqbEHIFixvRxs8UwvSfSgZuZOP20wS06R58DI956NQm7urq6urq6urq6urq6fhH6qlGTx50vommG0oC/gKY52vJQqfBbS2xgT4jU2eUqcYAcGJQcPLOmc7zVnl4HL6ImRECa6iEDuXK0apM3g8QTitPUjjAbYNYMpZq6qEDd6mcwNP3j2VabaiJBj7Ut+Yimh4Dd9FnHoDUwe806aa2Gjr2+JXo4AeEptUSIkKUcLD1S7IA4FpQEyMESGaWACu2m1OCMbVIXjMoX10Dc/tla8iga5Lh+nx1bwW7qUC7gJVvSxoC9nkBuTzG18wcANlfd3tupgUGWAHGbcohyIAUxA3BXAhW7J4gaGBiOUBx/kbapKREJhBzQrg2h7Ner1dCwp7WsKkfZEl5XnSTPA4FhqS4DOrfPVKD3ql2T4izRVWFL7STttbdap9OL8upmrUkp+7pOfAsK6yw3JWnsJa0PlnZP0CbG5wkGpaZWH2Si/WeCWQHcubTjkvaz8+p463HwvtDV1dXV1dXV1dXV1dXV9cvQVx/hbv9lRSGdQqYCuEtu08iUAFcKpk/5ixnsPHukG63e+KUgnPMX6ze1slQNiPRuBgDMPxoB11afwITxhxfQywX03T3yISAdXDMcOBYMD5tWmIpxXaKAggJJeNP1p9cmgBo5ympZ/7s7NVKM48KprvOoUWAjPJpAKWoG5IEhgXF945BmQrioKeCX0h6U3VZw+EE5LhViDNRKjK5NSSDkwQHQVEir8NgcNwlw+bsjxOsMeP09vxaMD+nVlLW9ZtB6VTzq5Tz8sKkpNOmvwyVpPcoWmsDA8BDhf3hEOc1IpwHilZETbzzySGZqFISz7DUrey9OBcc/6vXKs9P1opcIt+r50fNEiAfGeuPaQhcVwF8zwsOCEhwuvzlobS0BbtPXyJNHOjqMDxHH30fl/owO/kWntJfvZjUQk/KP5h+uQCmQ0e+T7VkTRzWhVI2V+YcVhyzIkzdQNKP4nRETj2xT5JqkGs713tBzHe9Cu//cVZqR6K4J67tRuU1OZ+zHP5/1floHSHCId/o+bi3IE2G7DfCL6LKUOIBJz+HC2E4DJAB+UTMpj9zgxTIwthvWn62XZLBoMxGjsnVkmOCuCWHNatL5Xn/q6urq6urq6urq6ur6pejrq09R1LGwv7CvaY6aNCGxaeiYAc/qVVhqg5POJHPUB31xbNPUBcgFvGXI4JAmq8GsWWsxzJqaIEtSWKKgzki3SWZ6xeWIVociS1SsWm+q5kmhPQVSUwytXnXN7dfFlqLaa7/6/roEVV+jPsBzqifLWCOvVCG21eyBoL32bn68SiSRhndes04qY6QwUOKr5Ant/9Rjqrwbt2SgaF0HvKeF6gpQrfDQGlEOoyVbNH3BtnpV6zJ/aaxV9hBnTVcVlHadNHWlhhdlQpqd8m8G/VCaYLFkjJk+KICP0r6u32usoWRz2nZtNb2jn5nrvWQGW/G7IUEZNtHO8NDXEEdwWUBrBgXXoMCv00WamHll7Ml+D9VU2f6b+mcrh0lnv2tkCiija0tVqKwd+766fqY/T+WLexkEW1XTNJZeM7QLXe8J8Qb0rgkrgVXkCEIADW7nQ0V0dXV1dXV1dXV1dXV1/UL0VaMm3gZ9aDe+yXrvMLwI5j9fAVFORz6N2N5OytmIgvC8ASLIpwFi9Zk8Mi7fBZAUTB8z/DWDXzbkQ8Dy1iNcNBUTTx7xwEhTrWvcYHia2gO4XzQhEI/KP5HvRri1YHiMyl+ZNXkx/umK9OaAaMkeJQrba7xEUNbpZ94y+J/+CBpHxH/8Fml2ut4zEOJMGF4Ew1NGnjQh4pPySeaPWeG9DxEowPXbAYWA8SGheMJy71oCJs6E87cO46Ng+pStqgLMnxL8OeH6qwlxpta2iTODMzA8JtSFKrwyZNKx9ZdancdtShXmpMYCr+oeLd8OzdTiqFPgCHZ8eYB/PEImTYnkSVeLDn+8wj2vWH5zg3TQ9AYJMH1OZsKoiZYmTdK4JUNGh+0u6K83QXja9N6YNRWkhkKFAhPS6fCqalaU5+II212AWwTjpxV59li+PyBcEvw5KkcmMIYn/WzxZJydwJDB4eXXIzgVjI8Z/iXCf760alL89gbrO53rdo6xvgvIAyM8ZzOc0JacqP16r+0JgOGSER5WyKhMmmocFjNsNNECuCWjBMbTf3+jy1aPGe6aMf35jHQzYn1vE+D1GtbXcMB25yGeMH+ILcUjXqftXdb0DomDBDW56qJUNRoVqKw/q89/P6I44PT7DW79Cwexq6urq6urq6urq6ur62err9Mr6l/yZwAo4Kwpj3QMcJcIvmw6VQNN37g1v+LT6J/Vyos9BNtqEAjIh2ArRPZer5IuZHwZhfa6neUhO8OmGAOm8kUUqMug7MFx1NTFcCKsFwAAIABJREFUq+pTq/040rcKaiKxM+ND9hUlFMBF+7WvaRoArK/TgLNW0RKPPXVi5ko1XuiVoVLXolCgqaFB55zr6g8V2HmqqZP9z9Or1E+9NBI0TVFNoZYUMmMqj9xqYhBYiom/OG/F65w68IpDA8Bdc7uO9fy08479Gn2xZGQppsLaHdOkVNGJdoMe1/uJqCCznatSIAZjdqtdC0vt6HtSu/5N9T7wyjhq6aaagklZGUbOAaz1qnb8Rc9RcZY+sXRTnTPXJJLymdqiFBPyIbSfiR2grCCkCoWWEbsRA03yUGCU4NRUqnDm+OrzEFrCpwV8yN6D8Z+p3l9/idJpn49gta89kdXV1dXV1dXV1dXV1dX1y9DXq09JH1Q5ZhQi+HNGOjo8/eOI458Yhx8fwdMANzqEz1fQ0xn5/R3yMSCePAoD44eLglRN7pqQJ4/zbyY1GK4CfxVwFEtk6JJPBcpu9x5uVRPAXzIqJJigvA8UTZmkmbHeMkg0LXL644bxzy9ATEApSN/cIM8e8aB8kvVOeSR35/coSfQzJjUxwkXaZ13vHPxV0yjpyMiBMH1KcJvg/KsBaazMnHrOBOGyw3vdVjB/LPDXYp9RJ5+3W4ft1hnjRhpgdvxpQXGM6/eTwXLVvOHN4LijPbkXaPpoBg4fBOFJV4XywLAcEbYbNRNOf4pwlwT/sAAA+I3VcljTKMqZKfBrthUjB//5ivBjQribUYJDnpSnU+oy0qJsIt4S2KarYTWceKPpF7cKwkuCf1hBIli/OQBMCA8rSnC4fjuqaSIA2MC/I8MtDnxNcC8b8hyQD17rXNeCeKuvXc9BnjxICg5/WtuilhotjHR/wPZ2ANtxUFLDyJ8zOHJbSxofNQ3mX2yp6eCAAoyfU7tvt3uP8/cew7MgvGRst84mygvcUhCPTqfZB2XkTJ/U6JKRIKNDOhyQJ+X2+KtgeJFmNlXDsk7Yp6PxggzGXE24Cm4G1AD1FyDN3Ba/qOy1smrkSGDk+f/7fxi6urq6urq6urq6urq6/n30VaOm8i/qw6fCeWErToRy1CdAtySU4IDbI2TyKJamUOYLa8ok7emIYms0Lha4RZStYdwWt4oBYHWOG6+SKXXtibIeNm8C0A64HR9lX+cBNMUwB02v1Id7BopXA4WTAXdlh9HqN1oKJmkixG1qIvkrwElfu5oFtXrECVaJUWNFvD6Ac66/X6HClnIor9I22Tg1IMjs7RzZ525rVfTFrymrocRRzYJS6ccE5MMAsBpZVLCfe7s2zlg3Mnljoti1CgwJxqCJAyi69rq8ZnAiRGcrXqSmjYxezQGyY2RLqLCZbY4gk1cTwha21neTXgdj+FTVhEhhAmwNqnhLoYzK+eFYwCmrYfUqZZMnPVad/2aUKehCUvUIa5qK9N5qK2UES1NZWisXvE4wVblFMAINivxFosWulzggD3qPtORXXaKKmiyD3R/1mJTjpNeI1wJmYxkxQCO+SFHV6882U8+56CT8ZNPrdv9SVsB1sWvxxTpVV1dXV1dXV1dXV1dX189aXzVqZFRDZbnTlZnjn3RZxi9aG1m/OyE8rXAfXxC/v1NOiVV3wnMEpCDPQY2aXKGvbMkPTc4MjxvEa7KDc4F7SYhHXR4aPm1w5xXpzQxxDPeyAkTwdwEoQHiOKIGxjgHhKWP84QX5OCCdBmXe3E9Y3gfEA2P+mOAWQbbqz/xTBElBvB0gTqekay2mrjz5a4ZfspoBAgTj26xvR6SDJnI4FUwfNU6z3XmF414yGMrm4U0wPGwotoaU7cHaX4vNNuv75ZFRBkIetEpWWCtRvBncN1RYrxpInArGjwm8JazvZ6Sj0wWrUnD5Xl9j+qisE46axlm+mQEC/EWvRbwdWlIpnjzSvNdv0tFZcsa4Mx8uBiY+2GISIY9eF5WqcZHUyHNR4FbRBamZkWc1EMTmss+/Uu7N4QdR04IByA6AViYRt4UuCYx4o27F6V8uoDVi/f6kXBmDUi/vg1aRDMfCeQIAhJcECfoa1bDQyhra+VLTRYG/arxJW4XSi1EwflrhPp2R7w9IpwF+EXA2Q9DXGWxCnugL6LM4wG/A8Hlt5k06BcSjR/EV/pzsHzRDrpqZFSpdGTSUBO4S27R4Hh0Ka7oqj4TwIvDXDLf8K72orq6urq6urq6urq6urp+9vmrU8KZGwsiWZIjaOXIbgTeBWxIkOJQ3R1BWQwKoXJWy/7toIqU4goyavnCbJhjiSZMP4gjhkuDOERDArQpsLcGpkeMJ6WbUA7NnUBldm4LOI0MOgyZx1mzVI4JbtFtTZ8bbuhMRCJZOcDqbzbYWxFFAmwADIw8O7prB0aosfq+fhHPWRaEKOz5nTVf4/fcr56QAAJF9bjFwraUr6qIV8EWKo56/AjQGDtd0RhSUgZHGsaU2AH3AT5MaDJOZTsrn0YSSznNTW+2idp0KqFB7L7cKeFXDhbJoYsqzJldqEsaMo3a/2FpTNT3aZPmqCZB4cuAEDI8FXBNBm34WBwAX2jk3niBkaZ5UUKJ9tlMAjc5MtfIF96Xed8VB0yXVmAmM4qgtkHHWilE1SvLMyIW/ZL7YqlSpDKTRgY4Tiuc95VS5QWZuUQGmT9LWmsSRJb7UFAPvaTIJZOkYvQdrWgys71WYMDwliCOkk9Mk0tuhJb1aYscB4bIbavWcc7bFrHoturq6urq6urq6urq6un4R+qpR4y9qTgzPRSe1kwClwHlS9sjjgvj+gOvbCcffneF+ekIZAhA88s2I4hgUNZFCWwKCQ74blANzFRQmrG8DUPTBfXgq4Icz+OxRnIMcgjJKRjVj0mEEFVsvgi7/5IGQRk1grDLCnxP8ywaZPIQdhueI8kLY7jzSzA3OK4FAheBfohpBQdMv4fNiiz4FyU/IA8NdEvgakQ+DPkQboHX4rOtGy3czUID5zxdIcLh+P8FtguGzGlewefDCQHjJ4CTIzTwwo0SAYnUhYIcIo1ZyDFzrFv1+ihnr+xnbrTF01tJSHfH05XVMs6ZjwnNsDJP28N7munfIL4gQnhLcZQOtGWAgH0fI6BCP3Ng5/ipwl9TMKWXW7AtD9TOEpw0UM/J4AAlw8wdNJlXYM0cBonJuitP6Uh7UhHObQqpJFHq8vgl2HvV70+RalaydR9pZPm3O2gFBDGod1bgTrwtKukqFlshRZpIClfPAkIEQ4SGebTpclIUklS+jr09ScPMvCygL0jEA3qqDIyFNtlQWtOrktoJw1tSWu0bwNWpVzzPyrSWi/vBsyZ4bpCPj+i1b4meHBuua2Ab3tIEvK9Lbo5pKSStP7hob4Lurq6urq6urq6urq6vr56+vV58GfdgVp3/77xd9CHcGtk33M3JQHo0MDnR70OoG1YSHKDeECHKjFSMZlFNSiMBbUQhu4Ja0wRAgc4AMXsG29qDcuDNE+3HZfHK4lpZckcEh3Y0Qp+aO26SxZigrnwawJMXAKLeD8j0mQmGGOwSD9mpqg1PRFEmYwWuGu0Sko4Mwa7ojl5awyMeg0GVbOSqOm9FSDYNC0AWmXCAA8qyJELcJ3KZw2MIEYYANDktSwIs0zksOjHLUmtn0KbUkRl2VCi/2GR0BCZh+uECmgOv3E0gUfluTGc3ICAo/1gSUpnDAA/I7p9fNgLV+kT1NwsD6foC/CPxzVBDvKeypjk0Nj8KEMvj2fRIIqGtERdMvHAW8JpSREA8eMlAz0wpxW1XSdan9Gqr5VjA8ZwUvR6vY2WoSPCEPsKodgZNOkRciZd68Mj2AHd5cryungrJq1S/eOPBa4Da7JhH6Wk7TWJSLTqPngnIKbX2JshqTEggRygjiVCADYRsUhuw8Q0YHqcDgUiBzsCUpNaKmz7vhUmHVmtxh4HZAPgaFPgeGs5/ZMvDO6enq6urq6urq6urq6ur62evrRo09HOeJ2sOxTi5n5NEhn/QhkKNY0mQGJWnJG0rFTBfG8tbbGs2eIHGbYPxwQboZsblBkxmDb0s/yUyMBtatjI+J2mtwMiCx/V4eGclpVQRmtFCxVEYiyKgP6SCt12xHrfKIJ7Ar4KTvu90wwrlgeEpIB4d1Ihz/KHDnDXini0zxpOtA/qqfNx68rQolnfIOWpOhKDbjTeBXU9gMYD065AAcPiRwFKSJrW4DreewnfNranyfNDukmXD4cYN/WJBPo1Z9jGMzPltNyxEcAP79B9B3b3H+X2ZwBKYHZQ3xVgzqq6aIGkZqUuSBkUfG9b1HHmBT68DN77ZWq9nuAi7vHA4FGH+MiPcT4tFbIgkIzwkcs9bFPLdqUgUB64nQa+YvGeM1QpyuMUkgZPs8bi1m1um5bkaNA9JM+pk+aGqHt2znySHPHsk7m24nyKIVu3hQc2V40nSSQnJegZpLhfDC7mUg3jhsR4Z3es541fraeheQB0K4ihpgy74UVazS56MgPGc1dSpcOBWkmZEmAmUP7wh5dm1OnTIhz2oappHBqeDw4wZxel1KrU9lu48PQQ2w6n9Vo8btPz9dXV1dXV1dXV1dXV1dP3991ahxi9hDnlZn/DmhBFZo8KaT0AraLZBJZ57dCoXAGojVv2zgleBnBwloD6LDUwIvWWskRZMu8cbv89Ni3A16BW2xhEke9QHVX7KaLKOCZ6up4a8Z673HdmJ76C062+wI7pqtZqRg4/oQy5ZyKGTH9yJwV60aSWDQQIgnDwlHTf8wIQd9qHcLwKLHDNI/VxedhEgTOZZ+yBMjT4zwrKZCeM7wnhCPDlQY4SWjOMLyZmfBiCewZ53+ftmANxMkeKz3AdvNDnDmVVegqsEGBtLkwL/9HjI6zB8LxAFpJDjWaI+/Cvw5YrsNSAeFHZeRMMYMTgXhLHCrTWcnNVnEThqVgvmTxjWuvzk2s4ekVpE8ODn4cwJfoq6DGYOFUoH/fEUZHbZ3M9yagVzgloThWQ2O4pQjIwNheEzgTZQ3w2jcHb+UtjBGgNZ8cq1yab1qeAbCFY19Ey5qNIVLUjMxsBmSO8OIoHDk4giwe9YvRdNDy16JGp6ywpdnNZfKpCtY6aScmfEpG4cmt2lzTVipKea2apjpMlqdaQfUCNNqlgGeJ5tzv+rqlXgHf8kInxfENxPS0QxKoCWC8sjdqOnq6urq6urq6urq6voF6d+ACWebXNaHSLckJD8gHhlDLnAvG0g0TSLTAXlUhgdDkGzpJ/yUwKXAbSOokC0hFfiHFZRz42dojYVQjmzmgMJsqZS9ulGKVWa8mhaPC2QKWI5qwogncMxwS0ZxAfFIyM8MdxWt0nhCeC5tKUheMWFqHQWweeNLUYjwlkHJgYRtwcjMDNY6TU3yQArIKkt50iSNW2FgW24z3GnSJIS/Cuha2irR5Ttdxxo/RoDRjJpCBLIaT1gS+PkCN3nw0WE7aSJjelRTyW8K/sXsIDYDXgbC9bsJlIHxISEdGNc32nEiIfCTwD0v8GY81OMDdDLaX8TSGTZLPtSOkMKmh8eEeONwfefNHLAFqAJlFGXAP0c9jxXIPHllF/3wEXyc4WarkBW9Nv4ZDby73WtixZ8j3OMV6e3Rlo7UvHCLNGMDFarM+3XkWOC2BBRdssoDa5JmzWoOiYA3ZRTlaWgVOzCBk0BIq1U6Ha/1P3dNSNOIPDKmTxtoE+RxQnFavQNZCiYXDA9Za11JIMlAxmYq+kX+MxhzvZeKI8Qj28y7nk+dfxdNV7FWt9yS4B5eILNXowlmWNZZboMhd3V1dXV1dXV1dXV1df0y9FWjZn0/gKNyZCgrb4ZyQXhRIwWOIGNAcYzt1iMeGWnWmsbwkMBbRnozA8XqQEB7EM4nm6F21AyeEqglG4ojXQtKBSVAq0P2+5rKYeTD0IC8tNp08ZLBl4j5A8Nf/L5UddV0Tk10pNm1VEOTAH7JjW8jgYGiKYbhKSFP+nWtzFhawRG2W4fCakzV2gwnQiGtfw1L0kqWwYzdVpd7Ckop4CwYHzSZUatIflHjaHhW2HE6OpAEDBc9b7wJhhfArwasnblNiddVoWoQjZ+SpT60vrO+JfgzwMlSGqcR4jQxMz6ZK0bVcAIoCkabZM8Tt7Uqkp3j4jZN60ggzD8lhOekiZCBkA++sVJIitbHmJF/+73WlEatJ63vR02IPG2QwbUEitsEefIodADFDJ9FDbOBsd3r9ZlzAV0KEJOeRs8Qgi56eULx+v5uEeRJ62PVdKprXfGkybHxQY2deDu01SdAK366EuXtOsp+Ha0+t70ZtA63ik6vi1al8qRGSpwZw7MgvCSko8N26yz1tfOT3FXNses7Blgh2yRqkuXRYb33du6B5ZsR25tv28/G8JjAa8b2ZlAjUb5c5urq6urq6urq6urq6ur6eeurRk08MNxaMHySZtQANrecRKeH7UE7D8oUEa/w1OmjcmHWtzqpPX5a9/RMcIinYNUWXUSq08j1gbcQQInAjbOhs9N1cQhAq0m15MSawWvSh/nnDbxacsZgvfr6dswDtcnq+nUqmiLR5SPWFabAoKTLRAqnVTOH1wzeHPLIWO6t1mWrQeECc2z02Gp9qjhq89D7LDZQBPDX3I6jMMGtaoDwNaEcNFXiBtaZbBjHpAgokTJd7DxWMG6tZrlIWjkKDAle17MmgCPp5/OkpogtJ7lrBueCePQoXo0N5QBl+7N2zpPodahw5FgaBNmtAv+0IB0VCpwHtuUlAmc1aoojbG8nvc5WCdtu1FgKjzaLXdeoklWdmBAeFyDq9RcHpIN9ljqbLrKvHNk8OVjPTzWX0qi/3o5adarcpDzoa3ESu9/c/jqyV+O0doW2ylWTK+L0Z4azpo24mTjUmD9aDSvwLxvScUaaCB4Ao7T7nletfaWjnt/hUd9LvF7TdCC4hTCcRTk3I1kiTA08d42Qb0bkkeCve1Ksq6urq6urq6urq6ur6+evrxo1hTUhEe8Gq+6U9tAK0sRJhf4e/rTCP6/Ix0HNjU0UImuslPXdpDPcSR9I09GZuaImEOWCwh5pJFuOJk08ELdJZX8BwPownB0jvWP4VTD+pAmM9c0Atzj4s2vVmWKsEwEaN0Y/C2tFRvYUDCU1Y2RgBSgnhxIF0BCLgYL3VEU8eoCA4w9RUy2TMnGGBz2e7c6jsK7wwEC47bw6AtnKj1Z4MgppiqkQIZwz3DXDPVxAcYKfdYVqezc3A6KoV9YSINu9hziP+aeI8BgxGieoBNZpaSkYngV3/0TgpIbK8BARPp4R3x6QTgH+knR9yThDw+OmjJ9j+ALsLDaZngeGWwXjQ9pXrQDEtzPEW2LlmkG54PIPoyWqDso1st+nosbG9DmDY0E+BqTJmTkDNUFEK2DxbgIIWG91WtutChv216T30HFCPo1Y3g/gTe8vAO2+q4YUx4LDj8nWm/ZEDAoa9yc8ay0tG8yX16znEsB265BHgls93CXBXwScqJktxQFChHUKiAfG9T0jPBccfsrK2jEDsS48kQBuKXZu1fT0F32deAQ4E8g4xXVFavwUW42qXo946xFP+mPtqlkk3ajp6ur6t/Uff/0f/qrv+1//+L/9jY+kq6urq6urq+vfX3/t/8f5a/8/1Wv9G0YNQVzRdRkBqK42tWEbbmaIu0bwT4+gdNNmhWsCp7AlZAqQWVM02Won7loM+prBydkyEAwcbLWTTdr0cvGs61CsCYZSExBBUzKUGWV4tez0agWnQB/qgbrwQ22JqKYOavKjMAGuoEh9HZv6lv3z7FWVbA/DXqHE12Tv4XW9yetDNiWtwWhsgtpDNlAnom3pCFDmTRZQ1IQQ5wKxGXGyqlG7CsamER+QB6sXrRllyyiOkWdvaR7AGWtFuSvQOemYNNlDlpSJeTe0kgC5WC2LGohZvJ6nPABus3WkTc+ljE45Mg6WiJG9kuV3Zk+drkYpCmO2io54bsyhJrLEjq0/Kb9HDRhOr6pkg0eeHNLM8GTz4PVlLG1E2Uy3q8Ks4QgCbqmgPBGwQM//qxlxKsZItnu+GT9UU11qwLWfH6fnKY2EeNTVLD3OPTn1ehq8Ko3cfj4AIE8EETWz1FS0j5PkL75V62A1ddZMmu7TdHV1dXV1dXV1dXV1/WL09erTUasg4aoTyBwFeWSs3zD8qqwaSoLxU9Z6yfs75OMAGZyyYQCDzgrmf35ACR6X394iTfrwCgA8OdBFob1uEYSgQF132bB8f0A8MPxlf281CTQRcfu7VU2FLHBSMG+i89WWxsgj6arSkrG8U2bH9EnXg/w560P5yGAB3DVBRoflnaYp3FV0GnneJ3PSQU/X9DHCXzP8VV8j3vjGMckTsN2d4BbB9MMV6WbA8tbDZ61PVfhwTfAMz2rqnP/hiBwI4aznLd56yMBwlyPyccB269RoWaVVaWoSSOtIjOFRkzDrfQDdBAwPG4pnLO88XCyYflwho8N6HxDOguHzijx5xP/mDeKNR5oIHAd4r+eweMLy7QzKBcPjBncucKO38+L0M37Uc15TKLzpnDVvgkKWWiLtCZ3+sLWEE2BLW5vAnxNk0uNyq8AtYiYdNKlia09ggGxW/PY/bYDBhgsR0lGvTTHwMic1ttLJtevnrgrvzaO+lgKvnXJ3StEJ7YFx+daDpwIZJk3lbHovxOAbG2d8yDgset82E6coILguTtUqnb8w3KYm5Hrv4BeGvyoIWgYgb3o+rm8Z6UBY3hf9+mzcomwJqKsZpkJY3jlcvpnhFiBcC8bPCcPnDZdfT9iOjOlBf578omtaXV1dXf+a/hZ/41Nfoydrurq6/hb69/wb7K6urq7X/w36L00b/5f8d+mrRk1d8HmtlqZI+u9cLOniCGX0KMZiKTXGUP9ni7BOk/76L58daeeRUBLQmtvaU2XZgGl/vWKrVCIAV1aN6DoRUZs1DkRArsyTPV1BSUD25yB7PaSmHDgLslV9asqnJTms4sNJANnTFZw0eZIH0pTJJYIHB84Gf61pIewP8vWc5KCz48NLsfey1x1c47PAeCe1eoairyFePzMlrZBpgkYrT7qOpEZJ+4zOzoOoAZFnB/F6rYpnWy6q15objLYlbMANUuuWBJDOqmvKSBM/nAVSWD8eAxCCWzLgCGn27fU4a3II0AROXTOCJUcUzFyMAUSgLOAs4C3pZ84B4LKnU+rc+isuS00uOdh1Za0J8bafDwiZuYSWoCpsnKGkLB99jx0szGtuqa/9vrLrarDfCrMezmSMGYVh1ylzcXq/FAbSkRAPQDoWyCTAlPUyR0bOhMJ63iGWJmPC8KiLZRXSLU5TS5y00oW/+Pnt6urq6urq6urq6urq+nnrq0bN2/9zaekNELVloOlBV4/IDJA8OoDcXjEBsN0GW6LRB+74q3sAmrQIlhDgWCyVAmxvlF9CuSDeDYi3QZkqTxnbjUNxHv6iT52U9YH08ptZ6zuxtHUeZwmNNA/toRiOEF4y/IV0GSkV44IIxo/K+ciHAAAYP8X2GSgXuGhg2E2QJ4figXhyiCcHf5HGOOFNl3wKE/jGIzwn8PMZYYtw14h8GJCOvjFXqBTQVrC9mTQRY/WZNOmsc3jR1463w54Q8YTtlozJIrYWVCCz8lI4G39l0xrQduvBqeDwxwVwhPWdTkrHuRpb+t7iCcOz2GdkxBtvJoyuKxWvC0j0infilmxcIQIvGdM5It0MiCeH8JxBm6AcdKlIVga/cgz8Oen5zwWwc59mhxzIgL2k60/PqRlZVJxW164JlATLtwc174zXQ1KMa0zwq05o6/cVLN9MWN64Zjidv9P00Lv/Y4E/RyzvJ1AB/PMKtzjMswMlnU6nLOAtIx8D5OAxfo46U38M2O6HVn0CKsNIa2R5tCQPWxXtKhhWgbtErO8nXN95xJOCgeOt3s/pWCwtZi7ZTQRxQRat4eEYIUIoiZE3RroyhifG4ceE7dbh+v4ACWosDg8R7nnB5R9ukce/6FZ1dXX9V6//P/7m+T/++j/0VE1XV9dfpb/Ffzv+Fn+D3dXV9V+v/pb/DXmdNv5rX+/riZoommKpKzc1rRD39IlKH7grZ6UQvgDP6tSzNy6K/e3/q2+tK0WVVSKOAEctnaCpnt0kqMkV8QSqjBdXkyWsaYZiHJfy+jjt3z1Am6312CpQXZDiVPaERF32AYzPUoCsKYh2/GYQUC6gmAHP+4JV8ICz6XFHNs+txySOgMBtrYgMDFxf1y0KImkrS7noR3MMZ7CUYtwYwKo3RCCUlgip55ek2CIUtZUlhR9rioWKJmU4qlFTl4lQyBgy2K9/TT7VNS6vpoZeA0ud1DlsqKlWSI+7VHhwnfbOuRlsr6/Rfm8UoP5e0VWjlkyydFM9PtTjqekroN1vHAv8UhrbpR4/lQKIgK0aJJO3xS3Re8PuFxmcLZPp61WodjXc2j0i2FNS9fTXBI4Zm3pNCekA5FHTL+Lt/g1A8QUwLhIRwFSAMYOowPmMnBySEOA1dSOB20JWZf6QwM6rGovlFTenq6urq6urq6urq6ur6+etrxo12/3QDJFqWlQOSZ4c0oHhr9KWdagAadZ6B2d7aLRExHavKY3wnCADcH3HCGcDugrAawZFASdBPAU1EYI+HM9/XsBRUw2FNW0hXvkjYgZIDvreKofjDxm3/3RBnj3ywEgHNSXSQdMp04cVAJBuRuTJ4fpeGTDhIjbhrVPbHHU6OtrEN9sMMgCEpw0cBfFmUFPAjK26vlP8mwY1vr4PuL5nDM8F4SzY7rymOM5Zk0KvzjNvBcMPzyjOYf3+CBY1GuLRI40GAY7Sln78RRDOgnjU+e14Ukjy9FMECRBvNC3klgy3EfxVz9ny1iFcxJJBduoszHF9a4tWf9zgojT47etJdBkY8cg2OY5mWGw3DrhxGJ4z3CUpM2gkXN9positBS4WhGduYF0A7TWKIzMgnBlHwPxThDtHPb+e4S+5nVtAjZc0MJY3Di4ywsg6Vb0Kxg8XzP+0Ir09Is8exx/TXhWagvGPHB7+hyPcVnD63RUNC5HTAAAgAElEQVQyOCzvBzNSCMOLYHiKugI1j+AoCOek9Scpmsiq5oxj5IkB0Sl3Er038uSwfHPAy/cO1+/LbqqY6ZSngjIKKGvtigXgIPgff/UjpBAe1wkP5xnpOahpNmds9x7nXwWEi61mJTWOtjcDyruhpdS6urq6gP43zV1dXT8v9RReV1fXv7d+rmm8rxo1vKnxUFMRyhqx3yTlZIgnULJFpFzgAbC3dR7aExksYlwWZY6EF31Yl7DDel0BkKrpU5o58JerODr5XZMdsFQImoHSJsRfqUJ4YYkSGRzIGC6F0F6LN10jqm9al4t0WQivqkX2HkUXq0AEmZXRUw2LCvyF1LWe0tg0/3d7b9YkyXFlaX5XFzNz94jIBQsJFruWmZ4Smbf+F/2b51+MzMtIj0hL11RzSBDILRZfzHS583DVzAOsYhIkABZA6BFJSUSmh7uZmnkk9Pi531Fha8KyRIviq9qYGaDRWyKipSG0vV6YdUv9bOda9NlY0tpkhaWc0GsldVYr1GrrsCYxEGtiWseg4FlqKbrGA6rgr8kNon2fX9Z2KDaTZ2vOslkk/FypRbbxrZVPtCaXrmmQ9TXF0ikt9SIq25o+N2e+cU+sf/7876TdP85ZskmNncPlyipaDRupdj+6YveGOrHkmMh2D9jjaa1g3sbezhlJFVGlOtfG2xrLJkC6aXyirOS9Zzk48gHy3tZsvX/VK7ovyFjQIohTdoeFMSaqCqU6SnXXN4oAaoaO8Xu4JobW+7n82/dBV1dXV1dXV1dXV1dX149bHzVqxq9PAKhzEBxlb5vQGl3bXBoIFXHEp0y4PyPnBSmV0z9/RjqsVdKV4esjiJBvR8Jj4tVvHsgvd5x+NW21zeMHabBaNngvAvkmIjls4Na8b2NKSbc0QsgQzvZa/mJQ2HQTN0Nj+vqCLJk6BjR6Tr8cUQfDQ0HUmnP8pTK+vaDeKr7TTWC59QwPpSWBzMiIT1aZvRoO4WmhDp7jf9rbcz2VNjLj7PyLEo8FKa7Bc5+llBrIOD7lZlyYuTB/fkC9WCNRtbEYl5XpTTJTpXFrQqrGi0kFbkIb+bLjWk2f2tgvLPa66cbas9zGGHKkvcGXw9kMi/GDJUGWF4FcHYd/PYET5lfGHsqTpUx2v7s0iLNSDpG8C9vYmwa7V4Y3RyRX1N9to1wAZbLjyKPgkzU81UGY7xzjfTHeS/FoMJNlHRMzWLRr5kS7CG3tVoiuPxdL3wyO5cWAu4m42RI+Xs2AyYeIDpY48efCzb+mrfnLz8r05kKZAvlw5dtocNRRSDu7F148JfxxIYvxf06/aM1gH1qD1Gdm3PmklEHIO6zV6dOEFjHI8iExDJmb3czgzW2JvvDPL74iV8//9eZXLNmzpIAqxEMiLx4922uVUVC/gqxtTcd32SrawxWA3NXV9fPVX+tTot4A1dXV9W30Q/6M+C5MiK6urp+P/hpJmuf8vj/3dT5q1Gj0G3NGg6MGt/FEXFLiUfFzbZXMSt0P+FRQ1WfQXHuu9Hq/jUEpUO4mS7UUcA2CIrUxSfw1HbGO20g0M4Pc+C5Cq2AG17itUoDG55B6HYexhh2HT5Z6KaO31AbfTFRsKRQvlOgal2Rt0Clb+1K6jaDBUkRZ8eeE+paEaYkQKRCfMtW3cSG16mbJa4uRa81RutUnPx8VW9kzK1zXnly3FiR1V4ZKGT0uiLFWZqjjylb5Ji/ILbJBi9dIiayNV+vXLY3jUn02lmPrdn28rW/1kG9tdEhSJU++cXha0qalfHQIqFcbWUtKurUL5udqbVleGvOmnXqhjS0VNDpKaNfJO4sWbYDhxi8SqOt6tVTMxkzSa9uWekdxgluaybbycXwza07tes661csbu8cMt+cNSuFiT7o+row27rSOHlmSzODAuAZVHiBPNuIkoSIeVIVpSowx4UQp7Tq46liqrflhWAjeFicXR84erbLd6zWY2eWy2+5jDULVqynW1dXV1dXV1dXV1dXV9dPQR42adDcCz8ZZ1jSEQjgXxq8vuFNCLjPpi5dcPpuYquJO6ZmhY9Xd9/80IAXu/t8FHYVTY9aEs210rRJbDTrrjfNiIyaQdpYqmb66IHNC0shaT63RkeTZaQjU0Rn75ZhYXgbmW098ssecPxvI05Wjg+M6JrJu5idPuguWhFgq/lxw5wSHaKyV154ywPRBW/LCXtqOX1huPON9Yfif78mf3fH06Y7hsRDvE34uyJLRIVCDa9XU9rpWE23nINkgxbRxoXUEyUatWg33ZIZTmTzgGd8nQqrMr0d0gLRrFdCDmTR+tlGicFbqAEWkmSKKH9jGj1xRfKqt1jxSg3B5PWxpFTNw7LmfvoiE1kKVd460E6YPleEh45MZH+nFCArjl4+ocywvX4BCvF8sLVPCBoOWCuFszV3u/oSMt+jOU0aPRN0ao6hmxrilmIm4t/Go+GTruT6XVMVlM5LSbbSEz32yhE8brct711I1GZcK47u6jTpJUcJTuo5RqZlau69n/HGxa+kc80trkpruS2vjAhlsbKqMUHZtzUdFD5kYC84p3lde7s/cDDNfHw8sOSCiBFf5/fmWfVj4p7u3nEvk6/MN7087Tvc7WBySHDgoE6Rq13n8YJwlS505/EX7+FNXV1dXV1dXV1dXV9dPSB81ajaOydrm49g262YWVHQK1H3cILPp5YjcDPbYZJtkMgxPwTbDl0yZAiXaC+j8jFEyg6CU0RkYWNnGkqRYVbXUaIkaGt8jtERE1StLh2vSBMxAKYMDtdNdq8FdeZaS0DUNY6ZQONXNPCg7D0ztOTAI8qV9j2drGQI73jBXM5i+eEkZnSVpiqWS0uhRP9r65WppE/lmygMFPxczopwgxV1hvvtw5dGoblwdUUj7sDF43AK+tTe50vg9LV1Tg5lg1QODUL0jj0KJMDyCP1dqcNCAylv9db0metxSt4an7dyrvY6fbRxLo6NO11RHHQ2C6+e6XVsas0jrs0TRmmyaInXw2+iWSnu9KtdK88FbequtXV2rqBukWB2EIPhLpQ6OMgjpJtjYV0vd+GYWLi+HjW+0GlbrqJ/kamkZ7D1QRo/KQHiosKau8nofycaR8YvdI3nlxmQ7vhAKpTiWxaN7a3d6ubtQquNxHlAV5hIo1XEpkVQ8x2UgV4eLhZpaxf0i+IvdzysnyMYR7fWcW2+qrq6urq6urq6urq6urp+CPj76JNiGeeVcNDhsOGYzFuZC+nTP/CpuIzHnT6x5aHwohHM12KrC7uuWWniYLcUwmZnjFzMgqmfbCKe9sNzZBtQvyv59QlLl+OuJGtiqlm0EiDa6Aj7XZnbYRn5NAK3NTXW0lIVflPhUrDb72fiLjahYW9Dw7kK+GdCDJx08y53f4KzT+4wU5fI6mOHRgMhrw058KuSd5/5/mYinyvTOKMc1CJdPIsutsP+6EB8LZWcjVsMH47zQxrb808xaHV4HgwqX0dqr/LlaW1Yx1kp8TLil8PCfb0g74eZ32eq9G9xXno3s1CAsh2ecmKGlY6Ktg18q8TGxvBiog424iSpuMePCJRt184+XzeQqLybmV5a4CUA4FfwxsXy2I++crXVV6j6iYn9PM2loY07wDCDdKrbLYaRMZq5oq0cvyZJFK99mq82uSo12buu4WhmFvBPikxAHIY/WIFWj35I7knVrc3r4x9GO72LmUTg/e46jY7i3e5kC+eDRW4+/ZNw54ZdngGfBRuecEE6tjr6ZSS5BUWEIheMSyIsnFY8T5R9v3uFE+b/f/4JzChyXwd4PxVGrY04BVSGOmfkSNpMmHhWXzOiqDfi8GmG6PJs/7PrO+mOzpZ3H8ZfpY7O6fU2/H3VOQ1dX149J/Wf7357+2DXt//78ZfrYe6Sv6fejH2vL0x/qo0bNcL9Qo8FYBYPtAuRDIKgSHsyw8Yu/phcuCrPiZt0As1JtrERyBW+tP8OxjdCIpR2GSyXdepbPo/39Q4OvTsLpc9uwnj6z8aD4ZN9La3oKl4pvxk0ZjBXiZ0tAhKdKwJIyxmexsSGf1hEZt6Uo/FyJHy5mjjTzxUZnzFMIT8Xao4IZB+GsaFDSjW9jN1bVvL6Wbfiv7UY02G04W+pBXwRrk6pK2bdL0QwMS9pAHYwTJEW3JEo421hX2QcKWAX5LrQGpsakkbXCGhuRGszEKBMsd2ZYrWNWK5AZgfnOAwNpbyNoLmlLsADJqrUBG90aPHkfqKOjTIK/KPEhI2rXvUbZGEAAy12rCZ8ruGuCxSUz2BTZGqPqPsDe2C7SkkuIcXiMC1SboWOcF7eYeecT20idHs208IuZS3Ft/WrtYyXaOS53lvSJR+PyXGHQdr2Gp3Y/q9oxPhuXK4fYWEu6NYupXw2TlvoSG3mSIrgEFGHJHnGKi5VShadlJEglOIMJe6dUFXJxPDzuqUXQ1BrFquCOHn8RwgnCye4zV3QzaKSsI2pcDaSurq6urq6urq6urq6uH70+Xs/9/gk3DqTb2JIiiTIF5lcBfy5IMqPGzZU62qbXUgp1S3HkvYcKu98+GfMkelBleCzbGI6fK8ObI8uLF5w/dezeVMbHwvHzQJmE885aoS6f6Da+I60Vyl/AvRF8snEVHORJcFmQSzXuyJLJtyN1cIQn45OwVn97Z81LBfw547+6R292lE9vtgSRtBGj+LDgn2byqz1l9ISzncPpF7Y++98t1tj0ydhMq9pSDlc48mqm5J2Q9sY0kQJ5b8macDYjqQ4eDULa25hOOGY0N2bKMeGOczM1HPngrbHpUvFnS5tIgOFD3pg9NTiWF0Lew/yyJZLSH1Raq5k46vw2PjM82lhVbXXcPNjIVR086TZy/vR6Cw0PhfHNmXw7kg+hGTXtLwXSjQMx46QGYX7pcRmG+xXAq9s4VRkbRyjb6NYKRJZqYOd4stTK8rKxhGbj1qwmTXxYzABa8nZ8kgqUiiRz3tKvXpEPoZlTdvzhUggfZuo+cvlswC1KOJdmgOhWJ76OaKX9Ok7XxvNu/ZYQW9NROKiT4maQi0OKkLNHRImxkNtYE1jb0/r7kgNLDpT7iCSHTzToNvjZ7v1wVoZjbVXf1+TMaqouL8IGae768/VtnfY/fFz/xPDj+jbr2tuDfprq1+uvo/4J9ver/gn235b6Nfth9Yfvl2+bNu7X5eP6NimPn0oSpOuq79JC91GjJn92B062yYk62ibUXywRUe/2libQK1y23lhEI5zqln4QhXIzokG4fDJsm3eXzLCRYo1ReWf1xafPHZdXtllfUwk1QL61BAvicElwMzDB+VNHOssGkI1tpAWgTp46+VZbbCYKCuP7BV1Nlgq7N1bNPP+vn7c0guLmglsq6TaQ9g4+m3B3Q2ulMuCx+nUUS8n7aLDeU9mAyCuU1mVbi7JrIzEXG63xzZgpY7iOKgFuKRTxlJ1DThV/tArwEhz5JqK3A65USzQ5kOyuyZRgxzV/MjaYrUF+885ah+q41por4Sz4s1Amayg6fyYsL2RrznLZ4Zd2EspWg12j2+rK18pxWMfQKuHUkjOwtXfBFe5rB3D9nrXBaOUChXMlPrZ2rNAYO4AkW6/5pUGOzSBhu6csdaSUKZDuHGUUxneJ8HCh7ger+PZuq09/flzx0WDPbslodFfmy+hbIorWZGYcpRpka5VaGTolro1k1sR0/lRIt7bWdk8o6hURxTn7FXzBu8opRVwO3I4zVYWvP9xQskcOGU0OfVr5RIJLYmbNDG7WzWzbzkftfouPeWsQ6/r2+q7/AHaT4d/XX7KufS1/OurX6IfTt13bvjH68/Rt1rVvjH466tfoh9Wf+174Yx9i9ev0Tf056/KH/0/U1/LHq+/jGv2J1icbVZFWH12D7Yb9Um1Tuo/oymfxlhypgbZRFYMDN25M3nnK5Dl9agyReGockGM2SO4UDGg7WIuNimxwVpfa8+8LxEoqET9DzEJx1qpTB3M5hidleDCTCNomuyUKVITl1mqxh0dL1MwvbBxl9zWUwdp74rEyvp1xxbgx6S7YqJL3yMFb6qUqeTLDxs+WnCmTa8mjbEaGv0YZrPa5GHRZLPGwQplXreNHAOSKRNfGmLC2q8YJyjurwR4/ZMKcILUa8dYgJXUd6XFbvXYZ2zqNSh0UjQpDpZSAP9l1q7vKIoLktZYcygdYq9OlNlZRaHXUrdVIq+DL6ki5lqhS5FSgQrkbqG3kzbrZzahYDUAzF4zmvI4OuaTEh4V0N1Ck1XJjY1LUStrb2kzvy8b2YTNMjDW03DrmO4eflfAAdQyUyZN3BiheUydg40L+kpFLhlxsRK5eE1zq2UbBpCglmpGIWrrGJWnvEdngy+qEdAd5p1cwt7MXEzHQr3cV72w95iWiwKf7I1WFdI5QhOF2IXuPnj1SWptVxoDRSS2hFN12/2yjWXVNA3VGTVdXV1dXV1dXV1dX109FHx99ypZoOP0i4BNMbw26mvfOTIbkNyPAzcp4KcwvbWzGGDK6AX1XLkg4G0tjeFiTJK21ZzUTdpbs0LD2I0M5VPCK22VEoL5I5CzUwQ5fvRIfHG5pYyHJcdkZ3yaebRxGW9X3mtDJk5ko431rTLrzSIbxQ258G2s+qoMQToX9XDejwV+yjb0cdpQBY4+gm4GzMmxY28xb+kaqI1yMc+MWSxJJsTGscDZDaQXt5hcjosrh/7sY9+Zmag1FmeoFNwiX1wH9LDLc28hO9W4zLABKNLZMOliaZnlhBo16tfWMhbp3JLXEEm2cDA9+FtwCNSgSrYrcJSUfvCU1TplwEeKTa9XV9prpdjCzwItVaLM2IlmVeQ3C6Ytx4+648qxlKSm1mtMgRVHvrPJ77wizMWBkMdZRuCh5gvlla+m66GaExKfK9PUZPw/4FPBzQaM38ywY18bG0Gq7L9u9OgaIHpcCGtw3R57caiLZ7z7ZuUlto2Gt/SqejSOkbdzNzRCwcTKrC7f0U0oeVZCoPJ1HahXmhxGy4/85D+YczWbMLHmye+zi8AuEJyGcbewJbLxwNZNW4PWaYko3YbsPu76dvs9PJ/7rr/5LTxnw/axpT9b8ZfprfOrWr8kPp++6tv1T139ff8m69rX8fvRD/Czv1+SH13cZ31j1/Nr3a/bdfqb0ZM130w+5ft/nc37UqLFUAKQboc4wvrONcHnGHtHWMhOOlXApLI33sW1gV5DpsxEgn9RaiVjZJ81ECYIGtdGc1VAQGF+fibGwLMGKkHyhVkfR1mjjlZwjZbRxkBKFdBDSjaU4Ym3w3lYvThsPQtsG31maxmsl3Fuawk4CNFgLlC/X9IU7JxABdmbItGjIakZtDVmw/fe60XdLsXaqbCM6NIaJS5Wqso1s5b3Hz5Vwf0ajNyhzMT7Lxv+ZDA4czoLOshle63rXYOedDs0A21fUtfSJU8Tb4tSpjWgprZ2ogW9LAyE7a32SaiM/XiuyVJwq/mi8mjJ5WMeJ1uahdhzumDczhiAsN9bcNDzqBr0VvYKbbQ6KzRipQWBua1UUcmmcG8e8d43Z0q7jKMQjuNOCd0KIDsmKhmZiiaWCtEGFXbpe1xodokpdy5tSS9Vou9ytTawMZiS59X6CLfnkmoGT2/211qL7yPV9UEFLM31USEugZIccAy5BYrTrk6QZNGIA4WR13Pa7pWlo/KC17cnpNakEVle+mkhdXV1dXV1dXV1dXV1dP359fPTpxoCwfrYNaT54XFJ2X6etTWYdVVnBt/GxEB8hnjIUpYZojUO3fqtT9slGMsroyQe3NUaBbUDLZIkaKbbZTbPVEr++O+JEefd4oLbWJxz4sVBuHJfPDCJ8+Kog74XxQRgeizUEtc2qZDMqVujrmqgorlVXv4ybqTTcJ4avj9Rd3NqXVCB/urdNfVHiSYmPxUZuvFDbZl4qxp9p0NkVkisXxV0y5TDY45pRkG4sFVEHMxbik0FZll8c7M+biYDamFcZHIffLcSnxMM/7Xn6wnP4qhJOlXjMlNGzvAwsL5T51wnxBoERp4hTNDvKU4QskNcElK2neqiDjTpJaxI6fWbg33g2UHR4uFCnQL4byZNdx3Cu+EsljTZaNL1NuEsxsPDOM7/0WzOYy8pwb/yUGoUa3FblPb6bSbcDy8vIcJ+ZvirbPVn3ESme/f+4R6Pn/KsbXKpMv3tCoye9nHCzPV6jp4x2f0l2+EshXgoqg12LBgdeXgSkwvT7Mzght6YySZU6espo5uPGqWmSYk1gNmYXrtBoLDUWZhjfm1nmkiXG8o0Br3k2+lSLoBdrgVInDF97XBHKYCZWOMmWdvLJ6rjD2cwpl9nSSqhBqfPkGN9Uqw6fw3Y/d31c/dOI7199Tf+21ZM0P6z6+n7/6mv6t6X+b8wPr57Y+P7V1/RvUz/Edf2oUbOyXVxqVb9eIBlrRYNQ1dnIDNgGvzU4udRgvtoSE0Us0dIgq5YqaOmTNpJU/QqwbbM7YptowVIHqjD6gsgf2XV6pewqNdpB+5YA8edqx1uuRo0K6ItA9eDL9nKApRO2DfkjsCSYAurdNkJSRmejTK2pyC+WvKjeGWzX2zlIO0eKQnRUkS3RUaOjjB4nZhisDVii4Kvi5owGRxlCW1uoYqmQtfrZXwr+/Qn9z3vyvjUNtXOUoJQB8g52dxdjoFwGg9j6SqqW0liZJ/aNbImbzTzb1qWtyamN1qSMRL+NeG2jQcL2/VIVt2Q4BNRfQbshXeukVYEGZS6DELxYO1O7Fi5X/DGhsUGAgzPA9dtHRIR4NxkT5+GIxIAfPFKqQYPbOdQgiDOjxmXjF1VHqyeX7R5cVYNYC1htVeHPEimrWWZrZoaTS8YbUrHHqZixIkUJl1bRHRq/qdWia3aUIBTvqMkjybFGecLJ+EyrUekvtqY1Gq/Jz/aeXE0aqQYOdlmtPWw9l5aukWtoqKurq6urq6urq6urq+tHro8aNYd/eaIOnvmTCWgba4GlQYYRCOeypSZKa1cqg8NHM2vGN2fUO9LhgDoYHs3UWF5ZHbGfDQyb9kKZoIw28uHUU18mwi7x+u5EcJWvHm7I2VGL8T38TaIunvr1tAUdymTpj/ikDE+VsnOUneP8OlAGGI5mOpXhep5S142vbukbM2yEerMjvZxYXgT82Uyo4T5BO4caxQyXpRLvL9QhUMaROgjzFDfGybq5P/1yRP201TmvaQ2XFb8o4Vjw50z47TsQIXzYWzJkP1B2gXzwBt2tyvJyIN+8YnisxKPiL7a2KzBXG+snhkLDsOBD5e5w4RwjF6+U+0h4cqSXBXeToApaHHLvcInWcgTT24pfLOnjloruR1Bl+PoIzjEFx/mXe55+PRDOSpgr6SaQd4FwzrisLLetKUnMlDl/Nljz10OGyRI1ee+QT3ZIUaavZtJd5PLJsAGb/Wzw4PR3r5sRWC0h9etPzNjarQ1Nglsq49uFfBPJOwe3kTJ5S77oysapTF/NaHQc/35voOunQo2OdBuaEWPmpJtLG9MTys6eR4paLXg7PmutsjEqWEfrhBohnCxhkw+edPDgRrLArpmXZdTGzjEzZveVfb3cGlfHGEXK7W8SwHaeZoBqq26v+FlIt5F0G1nurjDtrq6un6++z096eiqhq6vru+q7sGp6EqGrq+v70PfBqvkhE1IfZ9TMyTgkrZnIAK9rbXbbPM6t9SYrLNVqsAPUIri6wj0av6XKNnpURrdVVgMb6Hc1BqggXomxEFwluEopjlrd1pojmPngCg1gq5bMiEKUZyNH3tIIdYCyWJ302kJkm9jGSSnGilEVVFqbVXTXRp1vJBWu5suaIpFUcC1NoWIJF1FQtddcx1fKwPZ6a9pBWjLClTYuJbK91mpIGNS2GT/V1r94adydxkrxgo4G4K3RHp+Ls3NaExu+EL0jhULxwdZgrAxTJi2B2p5L2nmAmUhuqbhmlGj0dlzZWpjc2f68hsabKWuSBfRi94ilnK7nXFf4bav33v48CCEb0Hl7XDBgs6V2BB0NVry2GmlLMq3jR5boEUjPUj5BqHKt5NZ2D0m1ZM9a767r0rv12rQWq8ZskoqBkr1sY0zSUmIqslWV094XrlVq+0WJx9Uguo6baWiv1Q5IMg3YXEEMBF0RM3AWM6vM/HHbsa4JHqkKxe5VFdneS11dXV1dXV1dXV1dXV0/DX3UqKnTAMFtoxXh4YJGj9tF5k8ip888w+QYRsf0+xP+/ZH571+TboNtGJ3w9A8HEGzT2dpwahTS3jaew0PFZVqrj+BmId9Uyq7iRMnZ8+5pj4gyDBkRZYqZSwo8vjlAFepNucJ7ncPPxu+w2mLbwG9cjwZg1baZrwEcghRLy7g5o9kAwuqEugu4VImP1xGn5UVjnNR1vKltvmfjyqzpBg/bWJCfK/5cCCe38X0Axnczck6NDeNZPtuR9oHl5Rc2tjNcx25qsPEhn4xJ4hYbuZlfBauKbo95/E9CPij5ztIml3+9tdccK1nUjCNXGYZM/KxQPxE+vzlxExf++5efoefGZHk2DrQxhJJBfJdPRvLOsdw4pg+F3Zdn/KVy+LJsAF4bA4P5lTFfDv96QqoyfzKhwTg7/lIJT4s1LbUmppUxU4NjfDczvlHyjTF9VtPs8sqOcXrniE+Z4Tfv0N2I/vLWjrNULq8HHv5TZHyoxDVdtb82Y/mLR4tjfhlBYHhorztYq9n+y7kZZVB2gfRJ2FqVVkMyETbjb10f1jE7NQMKrUxvrdo7XJThaPdfPFbCOfP465HlVhjfs5k8rijxaNcvjwGpleFoqZ10CM2oke015Gzjcuw96q2pzOXK+K52Rk3XX139084fr76PT426un5q6vfuj1fPfxb94XXq/5Z0/S2ps2l+vPr3En5/eJ3+2L8jP+T1/BNGTWiwV4fTek13VG2f+tuGs4yNH+INsCvNqICWygBLyFRLVCDgWqvQyoa5Jl8slbEmFcASKfY7xlgRxUuDsqJXwKvyjJHCN9IGriV5pNgG2idrM7rW8AsAACAASURBVNoYO9Ie7xpktrb9/Npe1NgyiJknNQjh0pqIWtOTjuGaNGmvaSmPtk473yqplfqs7lmCg1wRsXExcWKjOnI9hzWB41UbvHaFyBZc8RQsTVIi5INS9moV52qcn1XiYAoZEY+q4J0SfGHwV2Dvumbos7VsiZUyejQYo8fGviBPQtnbQrpUtzTQ6g+o55oQWq91u95ry9SVp6JbNbqu61KuiZa6AqzbdVrZSDoNtvawNW+pa2yddlxlct+AAWtwVFqzE9dEj6VmFLeU1jrlqEOrCb8oLrGdv0vF0kpB2vc1zlBrNVNvHKBw0a0225JT4JaKpEqY1fg8s70/qucKd8ZMGyngFm2smjUKBIqAW49fN/iziiVqXL2+F7u6urq6urq6urq6urp+/PqoUbO8HqjBTINwqYRjNONAleHDQnxyLC8Cy43j/MUO/2rEz5X4mGwsBIi/ORmj5oVBYYZ3F9Q7wqm9tBrTIx1gfqWkz/L2+uIUESUEgwhfzvYctTpElJtXJ5YlsBwHSzFk28DmveAXt6VnpEJobUXqbQM7njIqML+04yiDRUZq8gZmbZt0VCiHQLrxhLONbpWhGSxPxi/R1tZ0/vWtmUKpmolyyWbuOOH0y5HjLzz7N5XxQ6YMZnakww5RGN8n3FwY3p2pU2C529s6P5QrtPicCfcX0qd7Lq8H/CkT3h0Zwy0uBc6fBBvv2it1v0YzFD20NS3Cbj/zv734mvfLjq9Ot9wMM3fDhd88vuTN08EeN1ZcDviFZmQJaSfk0XN55a3RKukGL057x/GLkfhkjVPVCxrcdUSrjR2dv9gZc+XgWsMVDEGYvgSkmV9nxT/O1Fc78t5gxS6ZweXnQr0JaLD2qdXISIfA/L+/tsTKqZix0pJU4YIxc87FqsOdXWdRSAeHy8L+N0eocPlib4yYSzEmzpKpNyPLy4H5pWN+6ZjeVqb3xerf94KfBZ8r8521dg1HIZwq+395sFaqv7sx3s7bRLrxzC88flbCpZL3nrKztqxwbukvJ0iDF2sb43Lr5ZvcBt6+VpnTRq/M7PIXq29Pt5asGT7INyrIu/76+i5z+F1X9fX7fvWXfGrU9dPV//Hb/7N/ivsd1dfvh1df45+H/uuv/ktPl3xH9fX7YfRjS/h91KgpY2NgtHSFCpacie6aaig2tmSf9DsbD9JrmsItBZWKvhoA28ADuFxb6kG2ZpprRXRLSlShZI/3FeegqmVDhmA71FQ8zilusFYndY4afDNjaNyOlrBoDUBSFFevG1eftDUDgahQvcNRGwvnWaJGr6mEtfFHGijYzTYmlfcNDFy+mWKwNqtrE5W2jbVUrk1Jq2rdmCgbd+TZqJZGb+yRqtTRU+9sVCrvHHmCMgka6raG4hQXDLxS2khObS/oWpwpV7d9XRaHnLwlpipbgsQSIQYBXq+Xy0o8NbZP0Y05JGL8mLXuW1Soz8a9XF7TVcZtWddXiiVh6hQslTK3dVgbmnh2TVdzooJgx4iyjUZZ85K9hiW13NbutI2/NTNHo7cWsnbNfLIUz3O5DL7Vim9fL2z3iMurWUJLu9i9rg04vHJ4gOv93tJV+uw+U1kTPWzHszFz2j3tysr6uf6+rU9LfbmkaKGlip7NsHV1dXV1dXV1dXV1dXX9qPVRoybtDHgazxU/G3NGB0e6Ca3dSRgeC7vfJ9JtsE/8z2Y8VG+JCjkviHc2LuQFqQMuVfwpI641JmXFX8CfBXfy1JuMGwp19tQqiCg+VLQI4pVf3j5SquNf370C4O72TFVBgafLHfVtS31c6jZaNb/01ACH3y24pbK8iKgTwtEafi6vPDVYQqYWZ+ZGkyVyViisEk61jVG1r9+ewQt5urGvn5KtwRi2kaF4LITTtTVICvhckbaJltQMmlzBtfWGjX9SJk+ZPKk1brlFuXwayb8erDFrFJYXUHaKxooExQ8FcRURKMVBdqTkuU8TpzxQVTilgXOOOFFuppmn9y+YvjbOj2TYf10Jp8r45mxg25toldWDI2bFn1qsQwTZAMDBODiLjcvl/WTmWTFzZ3qbzWBQRVKFSuMAJeroufxyz/BuYfztA/VmokztNm3mkFaD7ZqZUywBNWfKPnL+LNq1n6+jVGV0zK8jpdWAx1PFzZXlZaBE4fzLCbco8SGZeZIaoDi4LaXiL4XpDfYeEBjuC8OjJbHKThg/ZETN3EQhv5iogyfv3FZZv7KL1jGu4X7BP8ykT/eWrhms7l6dGUFrMm1uPB5JrZ1sqe0+svEpM8jsz+rgKKPbziXdxW9wjrq6fkj1T3Z+muoJmq6/VfV7u6ur6z9aPf3y09SP4Xp91KjxyTbG4VRt03cTjeFS2if27YN6bW05fq4bRLZGg2iUFzsA3Ky4xtJQL5YGCWZA5NHZRt6DeoXsqDOIV4gVHyrO1cbkgKdlBGAaEql4jqfROCEAxbgkZYSyc7jFNsfWjMSW4tlqs9dWqsYNubJ0rrEgkYrDteSCbmNda+tO8JbmWZt2yuhtDYLbuDdblXJj76jC8yiNBodWpY4RjWaCbY1Q63GsjJ/tm3iW4GBbQ1rDk/MVETOeANzOTJXfPL4kuEpsXBonyrl45hTwFyGcwaXrNVZvppO1PFliZk0oIbIBk1GhYhXZZXSMb2b8ORGPA640xg8G65XS7iu9spDWtJXVXAt1GqiD30aAtFVRo1YTLlVRb2aK+jWp1ZbGXxM/LrXriaNWtvSJvyjOt1E2J/iLR1Qp+4DLFf+wfCO1YnXqDh3WG/9qBq5Jm/V61NFTo9tSMXnnt1Ypa7pqCakpbPejPYcY8ydCHfy2HsjaStXMxIglyKLFjUQdxcuW3tJg7Wg1GvS4q6urq6urq6urq6ur66ehj27h4mPBpcrw9kLdRx7/YcLPxttwXnDZxkzy3uMvFXesxmsJjjIZhyTv97isjO8WANJNaH9uqZy0t+YlM1cUHSsyO+QckF9cOOxnvLOd9TxHUOGr+xtiLPzq7oGvjwdOv72BVnfsspBuFH8xtsn4WPHn9gszlYprposaF0W9jSW53EZ4UmseWkebvEND3ca9wDbZZbQK6PgUbWQnrgbGsBknklsKxF2ByRsIl7YJVxo/RVBv4Nq8k22chw2y2zgt3qFB2riRbNXWK0BZFkFxxJdmxJzngPPKq5dHjpeB3//mFePLC//46Ts7FxWO88DpaWR6FIb761qUKKjzm5EQjhlRtZTGBpK21JDzgk+V+YVnuXXsvqy494+MXqhTZHlh6Y5043FJiY/JRsbuohk+rc7aXwp1sAQRz9ZbWw22S5Xhtx8srfOLFzaO19YvnCwhVSYhHCvxcdnuZ7e3e08UcML4fkGd8PgPI7mxcGoQ5heO4bFy++ECWawyPVXcUqjDSB2kjYYZq8ktmXIzUBuXR0VINwEUwqVSg3D5JG6GzpqKqYOnjmZEiYI/V5wX5lsb30t3vjVFGb9mOTgbF7tk1AXKrYGKNQh1dJY4avdvmXx7b7qNJdTV9VNU/0S8q6vrP1I/hk9Vu7q6uqCnc35u+qhRo0GozpFeTdQozczQBjg1M0ODbZBda+YhqXFkqnFh1kYda8Vpm8ogGxA1nqw1qAYIZ6F+CNRB0ajUY+Rh9oTRDIfyZGM/cqN4X5lLoFSHekWKIM20sAcZd2ZrTVpTKS35sMJmtW1iw8USNFaz7DYosCxW65z3fkvYlMltzTyiVt2M2jiSVCWcMzU40o1tuEuQDWq8tg6VwZ4jniuSG8x4AMTbsRmEhTJ5pGpLbpgJ4EqF0kyZAmnvbdRqUOqo0M7pfBwQr4Sh4H01bExbkJwCXx8PDKEwhczT+z3hq0g8srF3AEsZqZL3rpkMzo5hUTue4MzYOq213LqxhvIhIi9vKDeDtUU5q6iOD8nOQbmmUdSer0ZHbu1YUq+JEJeMw7IyV+rtDopSo2/G1nWdXC647JBc0Wd8lm+wXlwzU0TwsxlppZlPobFoyn6gjp58MCOSluiRjbGDQbI1bn+3qgax9brUf3NfrvfQdv5LxZdyrSWPO2uUWuw1fDFzR4rVl9fWvLWm2MK5UEa7b0oDEVuKyN4DNfTRp66urq6urq6urq6urp+KPmrU5MlmapZb2zjHU7WRDRHcUvCPs8Fto1VzI7aRpFbkQ0GqMUo0eubPD9TRkVtzDdI27Y8Z1EZl4iO4JJw/h7ov+HuPS4F8W1GnhEdLCdRdJmfPcRnIxYG3Ha9LLS2hLV3SeB8AW2V2a8DJh9UQsRSCP7cq5ugMfOvsnMmVPFlbj8v2PHln5xCPFa224ZdiJoGfC+HdkXoYyfs9ZRDKIPikG3cGMf5PHcAnwWcl76Q1bNkx+cWOPR2sFWh8WLa0jSRjskg2I8O98mZMDUrdlc2R0PuBGit3XzzgnTJnvwGFy+z58OHAtF/Q3Uz8MnL339lGvlajyGWD3S63zoyCi/FQwrm05iY7vvj22OC53mC3Cuk2UIcD6WCGlUuKuyjTv7y1a/D5Harg5rKNm+Vp5PLKMxyNjZN3Qp4c40PBz7oloNKrHaJKnsyoubz0xHNluE9W511shCnt/+AWb6NJtrYBdTA8mkGy3JoZNzwWqJDuImVyLDeOeHJEYYMDu2JjcKdfRMooDI/VAMNzRbBadq0Qzsa7Mbiwpc3yzlvjVDHOUThW/GnBv3mAJXHIn1LHYCmr1ZirMLyvGyNqNUHDqRDfn6mf7an7QBmsDn731tJwJVoTWNef1g/1KcXPIRHSP9np6vr+9bwZ5ft4rp+Tfg4/d7u6/hp63lz5ff0c+bm00PX0S9d31UeNmpX34S7VEgejMV9cAh0c5XbcHrs23NhYj0eixTpqcGbKFEWfjQBBGyvKNmYjeU1LtERHctuGWpJVXJe9mSz6GFl84ENx1GopCOOkgJvFwMSzJVhqFPL+Wsm8cUKq4pY2ntRGh4z/URqXxUwbbgb8UpneQd5Z7fMKqh3vDWSb9y3NMAb87HDzSI2+MXuagTXbuIsGoUaYPpQteSJVmd611NBoj99qs9rvy8vxOpIFliSJ7pqW0DUpArRRMcVBUEp1lAopWcRIRjNztDhODxOn+x27s6BeKaOtp78ofhGG+2TpmF1s/B3BOfcNUHOJDnc32XUVGwuKpzbikyrxaNd8TTGVVwdLzMwFCc7SIKOnjFZXbY1Ytl6uuC2VBeDP7fyHa1JGio0HAVw+HfCXSnzK231WR6FEq/52qW7pruGhQYOdnXM8tvt8sPay8Jhx2W9coLLz2+iav8+4uXD4XbtvxzVp1Jg1yYycbZytjSflybUUUUu9rM1O3pH+7rWN1O3NiHGLpdQkq5lPqVAJxqjx6/idQ+4mW5tLbfXj0uDFleFYKUtP1HR1dXV1dXV1dXV1df1U9CeMGtsw+3OlDo75Zdscn82A0ei2xhkbURFYGSBqKY+1snp4SAan9VfWCLSK4qRWmSxCGTHzom0uNVhSRp1SXtiOOb4NqEBWsRpqAXW6mS7x2Fp/CpQobZzJjKEaWjroWBG1RMzWQJTNqKnBUfbh2qDzlIkfLugv95TBE+aKW5Th/Qy1UqY9dXAsB4cfhHiMUK2RyM7B2TkulSIeERjfL7hTYvlkQoMjvrvg5mQJJeegGV919ORdYH7piU/CeMobeLcG2aqXt7Eqp0hcjRoDMpfqUIWc7Fr4WKlFqLNHjoFwEvxsl6zsWlV5bc1D9zOSK+fPIzVoM5Iq4WztS2CjSOkmbveNrW8xoyFVwlxQJywvB2oU0ssJNxfCh4ulTaZAGT3zS78loIzjUpDikXaN1gYmUbbWLpfq1spVRuHyyhOPYiNCjf2yspD8UnBnJQ+2duObGZcr8+vxWQOYsLwIuCT4Y8ItBZcD6RBslK1xgAbFQMm/f0BK5fKPn1BGZ9XezVixqnHfxrnsXloOQjwpw1Nrq0o29qXBcfpiIk9W9e2yMi6WDJJUzKiZCw7ws4PRU7FE0xKbsXQuW0pMiiJLJT5VQmfUdP0E1T8R7+rq+o9U/xS8q6vrx6Kezvl56uOMGt+SJW2nF851a7eRqpvZsnJApKi120Rhercgi4FU1QnpYByX8UNBxZg1ltTwjUGCQWyTcP5cbIznk4QfCvlhQBbB39tx5EO1dijXmpmq4GZHPArxCOHYUgqy8j0sLSFFqaN8AwS8NgKtPJR025ZEbYxrrZguLVGytUEJXD63JMPKXhmeKn626vEaHWkft/RGGaGGYDXlQfBLwLexK62VcojUKeDPCakVraAhUKJrBlQ7TlUoClWod4HlxurNh0eQLFAFPZtJJkNFfCUlT8me8mgGkqjgTo7p0YDFfobxvR1/Ge34XLKkU9lFMxJam5A1NanxXWgppmoGysorQizJ5C+Y+dYajzS0dT1lW79f327JGW0pouHBxpdqNLPMJWV4rIRTMeOm3XPxmM0IaaNQazPUyn2Rqpb6GoVwqsQnvSZUiuKA5eWwQZqlmsHiyrUlqk6h3f/Gk/Hzs8p2VeoYKL98gXoh3TYGT/E4V3EXBdeMtKoM95kahHh0SG6m3WDQbTObqo3gJTGId1Hq0EbdRmd/d0zUXWB+Fa15bbkmjdKNpwwBvyjh8iypI9cEW9e3088lkvt96vv8H4hu0HR1XfV87KDr2+u7rFv/+d/V9W/1fBSzv0e+nf7w59Bfsm59zX/e+rhR05p21BsY1Z/rdQxFMVjrujlvbJgyGpNFsuIuGT95ymAwXpeV4Z017eS9td3UQRqHw8DCYVaWF44ETDczLw5nfp9eoDUQPljddbkrxqWpDdJbBLcIbgZ/MRhsjcbqkAI+WZ2zmwvL68E4Hm0EyrXUAph5tNzacYZzbdyZbKM5QzM/GhRYRVhujVUzPJmBFY9m7MiSER83EO427hUt4aPeRpykeFy2NS2Tb80/yVImz9Iqtj5cq7mr4tTOMe+EcLHNuStCqW1sDGAs1sxUHGVx+Cdn0OUK8VEY3+lWFz0+VIZHS2SY+XGt0t6AzJUtqZL3a8tWMz6WYocd15G1671TRrc1YhmnJqMtQeOyMr2tDWCMMVe+vCd/fse8H3CpmV+XjEu1Pb/gzi1ZtI827iVck1qKrV9r4hrOhfBkDVM0xoylvWydprcJaddBkuJT4wGNwcbLoo0r+dnSL9v7IzqW27iZW+toHVVobeXNvFH8KeGdoOe12lsNKB1b2quoQYq9Ek8ZirK8HJq5Ze1Pko3Jk/aOcFHiuWzV73kU0o0wvbfHGReHbSSwq6urq6urq6urq6ur66ehj48+pdaQFCxdc3ntt8RBuFTCCfLkKZMBZf1ctlaoMlr6ZR1/cUlb0sI1jg1WJ5zUGqRSJR0Cee8Y3ytSHJdyw5eHPYwVxkoZPVIgfAjGUzlcEw407kcdYH7ljLEyr61FZhjo0GDGXpjeGntlfhXMgGmtPGG2Y/VzRXJt51AsjRMFdW5LXITZzCD1Yp5RS3jU4bAlSyRDSHXblIdZN+6IeqGqQ9zKKbGxIMmV8LTgUrFxlsFgzSrWMLVWRftzZXTCfOfIOwhPguSAy0INyhI9OlT8WBCn1EmRBcJJWnWzML1Tdm8Lae84fR6IRxvHubxyNgJVvI15PVXUs0GVhwe71m62lIt6Y82sbUb+UsmHljLJrbFoNjMkvZ5sfOjBxqPCU8LNBbfYtZj//pW1YAnba+R92MwjUQhHkFKJ7y/o6CnjhBNLfYWzGTvpJpD2Dj8rfnZbvXpto0+7389WuT0G8Gb61ejILwa7fo6t8lrarzJZYiycCv6SGbNxaMrOztXPNtIkuSJAeII6es6/2llVe7IxwjLIlvyxN1lLDSUzLsVbagjYklxSKvGx8XeCUL01h9XoGJ4q8dzuY2fjdqiNqpXYEzV/rr6vTzD6p+DfXn2turr+uP7ShEj/FPbbqa9TV9ef1ndNiPR0yLfT85/zfa1+3vqoUSNrFTdQvBg/o9ieVqoZFtZk01IjsoJ6bfRF1OEuBbemEBpseE1cQGOhpIo/Z8pgiY9wthkW9Y58EZZfGHdFgyIq+LON0dThD8ZdWuFRGWgmzXVcSAWqX4HH4M+2Ca4hWkV3q4kO5xUufB0dkZYectmAyFINFGt8EXs+nIDXLUEiqttzSlYkWLW2FP1GMkMdW0sT2CiYS3aOdg0q4mRj0NTobOJrZfucK/WVo0w2xiSlGQBekOTamFm14/SKILhspoSGds7HQjoYxyWcbb3KwDam5XIbT/LCcnCAGVkuVdwlmYkUfQMlywbJrXszCeK5gYUXM77KziIe/mJwZFkyrprBkw+BdBeaMbHWYNtYWh1lq8ZWZ8kVPye0rbWNMRmEl2ay1UBLCbkt4VNDAyYfE25O1DFsLVcaLO211mi7pGgb81uTVxvAOVdctdpuaI1QazKn3fJmBHmWG4dfIJwNSp1HM+1cur7f3FKQ6tp9J9vY3fr8VhlfcMeZehipd2ODFTdY9alSxqshZXXzbBX0XV1dXV1dXV1dXV1dXT9+fdSoGe6XBvj1SHYMjV0STpU6CpfXgeG+cPjtQt75Ns6EjUDtjK8R2mjG5dOIn5Xb//aecjfx4Z8P+EUZHsr2vS4p4/vMcjNY5fE9DB8EdYEy2aiT1W7bJn760hI+fm7mSoZ4VMaH2lJA0gwaId9YGmdNcfjjAqrc/MbOb3kRqAEurzw+KeEi1nC1+GubVUvCXF7ZY3dvC+FYWnLEmCHqhTKAVLEmIsU22q3Bat3kW8311UhyDbh7+Wwk7wOXT263cSproVqbqATnBe/FkkiPhZvfQnnvePrCkw+Q91C9MrxzSPX4c2wJGmV8L7z4H4U8CcutmTs1WgNSfGrnWOH2f2ZoTV9ldIRi0N7pvdWYXz6NhGNlmjN18OSbiEuV8UMi3QTyweMvdq/kvaO0qmlpIz8uN9aPF8p+QIMjH8I2euWXa/LIJTOFEGfJFsUq0atxYNRJY/iwGWDlxjqphyf7Ot347X4YHq26+vQPB6oXG3OrAHb/1iitAUxbZXrY1mVNW+W9p+x2Dd67vr4S1Eyly+ejpb9OhRod4WzPNd/Z2NLuTdneZ3VwaBibWcTW9JV33gxAzDT1l2wQ6cNIOUTSbXNgxO4rFbcZTBuLJ3N9wq4/W9/1U6Ouj6uvU1fXn6dvm6zpn8J+O/V16ur68/XnJmt6kubbqa9T1x/qT4w+WYrCLViyJrkGKy2kECjR0hvulJDJf+OT++oFaTXX6iyNgwIpW0tUaGMabWQIAWptqQJ7Dr8Yt8MMBEuA2JMbODeeDEIcTtqSI8anGT8ka+k5rI1O7TW84p+KVVwXM0j8cYEacQffWpQABClX/s2WFGkpnRqhDAKquFKR4gzuWpQqmKHQWqSQxmpZUxHCdTPdOCJK46asKR4vpIPgkoFwgc3kWLkjNdh1cdnafsxYsETSKn82I2Z40GYQCfFJmd4tLHeR3Lg42rgtro3xqEC4tLrwwW1GkTVZWWqjDA6XrI5bg0F7JbcUFmZKWaNXhb1r1evXZJC6dv6sBpRBkw0+vSau1MZ4GsjYeDrNnPEW9Vprujc2TXu+svPg2Ebu1NuYGqupkpW0sxEkq4jXLZ3yXOoslUJrkFqTQXVwVG88JnXgFxu9U2ctY3lydrxrKq20xjNvJpCfVwNOtl/r9V/vj3XUS53geAYFdrKlw9bkEc8A3c/rzEUthdbV1dXV1dXV1dXV1dX109BHjZp0NyBFCY+zbS73Hj9XwuMC2MYbVeo+WiXzU7FUTVw31kp4stmOeGc74PnvX+Fy5dV/O1NGT7r1DPeZ+OZEeTGRbiPxVHHFzIoywe73uhk1tnE200JKq5A+aWN1WDJk+PIR+fQG9ZHhPuNPqcGAZdvEltsRsFESaKZCbuND1QyWcMyMb87k25F8CJvZsD4mH6x6eXy/2CZboA6W3AinwvjlE/nFxOXz0RI3xZI0a8W0OmF+FahBmN4IPlXGt4slVMaBMCvj2wsaHOk2NkOhmslUFY2OvI/kvXFTxntleFLSQzMPZm18njbidLE/m19F0s5Ro0FopZhhod4MB6nK5bUxV8bHgmRLGkmB/Ve1PZeZG8al8TZy0wwSyZaUWo2H4UPempFqsPEqlxVJzZETMcPr1ADJo/Fx8uTJk8MvkXAshGPeWDBbwqUlkRja60/GnymDmXh+WXlDupmG6caDeGuxmhtTaXDknVVjjx9sDG9+6awx7FQ3Eyc+ZeL7C8snO/Le4xdFHaSDmVFhct8wjcrktnt1bZ9SJ+SDxy3GQ6pRttTV9j0Vpt+f7T3z6dQYRxF/Ni6PWwp+drYuTwunv9szv/Ds3mTiMZNaOmkDfXd9J/25nxr9XNXXqavrr6M/fI/1T2L/ffX16Or64fTHEn7fR9vR35J6ErLrL9VHjZoaBNfYHGsttaURbOO7jqEYHFhhBfc+a0dagbxSLfVSRmORDB9OwEi69cZ/OV2oN0MzNBQWSAdLGvhF8UkbC0coUa9smtJMFoyV44oil2Vjyril4OYGZfWt/qYlLOT5BlbX9MGVLyIVa3AqsY3UyAZ2teQESDCo7dqAJblu4FmWhOThmqZR3QyGtaWoREvr1GjjQH7JZiitj21mxvqckurGyNHorP7bX80YyjoGYyYFArnBm62G2owu9Y2P82wkq8Z1ZMbqy9fKbKn29+tpUK/3A35NwLTkCUJoDUVr25BVkLfvFUH0mxyXNcWyPqc6qNjrSbtDw/Gb3KB1PdcEiejasmTHUeLVlKO1U22lWS29s173NdFlTWCWAqrBkjFr2ma99ySr3RPtue2YZVvTGvjGfaUOqIKgWxV5HWyczCVbC7uv2vdJS9fIcyPLflUvOMf1Hm3vL1ns/i6xXa+WDtpYOl1dXV1dXV1dXV1dXV0/GYmq/ulHdXV1dXV1dXV1dXV1dXV1dXX94HL/0QfQ1dXV1dXV1dXV1dXV1dXV1WXqRk1XV1dXV1dXV1dXV1dXV1fXj0TddQ6qhQAAAFhJREFUqOnq6urq6urq6urq6urq6ur6kagbNV1dXV1dXV1dXV1dXV1dXV0/EnWjpqurq6urq6urq6urq6urq+tHom7UdHV1dXV1dXV1dXV1dXV1df1I9P8D6B+itoiN2kgAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 1440x360 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sample = 0\n",
+    "plt.figure(figsize=(20,5))\n",
+    "plt.subplot(1,4,1)\n",
+    "plt.imshow(X[sample,...,0])\n",
+    "plt.axis('off')\n",
+    "plt.title('Raw validation image')\n",
+    "plt.subplot(1,4,2)\n",
+    "plt.imshow(Y[sample,...,0], vmin=0, vmax=1, interpolation='nearest')\n",
+    "plt.axis('off')\n",
+    "plt.title('1-hot encoded background')\n",
+    "plt.subplot(1,4,3)\n",
+    "plt.imshow(Y[sample,...,1], vmin=0, vmax=1, interpolation='nearest')\n",
+    "plt.axis('off')\n",
+    "plt.title('1-hot encoded foreground')\n",
+    "plt.subplot(1,4,4)\n",
+    "plt.imshow(Y[sample,...,2], vmin=0, vmax=1, interpolation='nearest')\n",
+    "plt.axis('off')\n",
+    "plt.title('1-hot encoded border');"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Configure network parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_batch_size = 128\n",
+    "train_steps_per_epoch = max(100, min(int(X.shape[0]/train_batch_size), 400))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the next cell, you can choose how much relative importance (weight) to assign to denoising \n",
+    "and segmentation tasks by choosing appropriate value for `denoiseg_alpha` (between `0` and `1`; with `0` being\n",
+    "only segmentation and `1` being only denoising. Here we choose `denoiseg_alpha = 0.5`)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'means': ['13.494209'],\n",
+       " 'stds': ['20.886541'],\n",
+       " 'n_dim': 2,\n",
+       " 'axes': 'YXC',\n",
+       " 'n_channel_in': 1,\n",
+       " 'n_channel_out': 4,\n",
+       " 'train_loss': 'denoiseg',\n",
+       " 'unet_n_depth': 4,\n",
+       " 'relative_weights': [1.0, 1.0, 5.0],\n",
+       " 'unet_kern_size': 3,\n",
+       " 'unet_n_first': 32,\n",
+       " 'unet_last_activation': 'linear',\n",
+       " 'probabilistic': False,\n",
+       " 'unet_residual': False,\n",
+       " 'unet_input_shape': (None, None, 1),\n",
+       " 'train_epochs': 200,\n",
+       " 'train_steps_per_epoch': 237,\n",
+       " 'train_learning_rate': 0.0004,\n",
+       " 'train_batch_size': 128,\n",
+       " 'train_tensorboard': True,\n",
+       " 'train_checkpoint': 'weights_best.h5',\n",
+       " 'train_checkpoint_last': 'weights_last.h5',\n",
+       " 'train_checkpoint_epoch': 'weights_now.h5',\n",
+       " 'train_reduce_lr': {'monitor': 'val_loss', 'factor': 0.5, 'patience': 10},\n",
+       " 'batch_norm': True,\n",
+       " 'n2v_perc_pix': 1.5,\n",
+       " 'n2v_patch_shape': (64, 64),\n",
+       " 'n2v_manipulator': 'uniform_withCP',\n",
+       " 'n2v_neighborhood_radius': 5,\n",
+       " 'denoiseg_alpha': 0.5}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conf = DenoiSegConfig(X, unet_kern_size=3, n_channel_out=4, relative_weights = [1.0,1.0,5.0],\n",
+    "                      train_steps_per_epoch=train_steps_per_epoch, train_epochs=200, \n",
+    "                      batch_norm=True, train_batch_size=128, unet_n_first = 32, \n",
+    "                      unet_n_depth=4, denoiseg_alpha=0.5, train_tensorboard=True)\n",
+    "\n",
+    "vars(conf)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:541: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n",
+      "\n",
+      "WARNING:tensorflow:From /home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:4432: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n",
+      "\n",
+      "WARNING:tensorflow:From /home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:66: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n",
+      "\n",
+      "WARNING:tensorflow:From /home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:190: The name tf.get_default_session is deprecated. Please use tf.compat.v1.get_default_session instead.\n",
+      "\n",
+      "WARNING:tensorflow:From /home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:197: The name tf.ConfigProto is deprecated. Please use tf.compat.v1.ConfigProto instead.\n",
+      "\n",
+      "WARNING:tensorflow:From /home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:203: The name tf.Session is deprecated. Please use tf.compat.v1.Session instead.\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Gitrepos/DenoiSeg/denoiseg/models/denoiseg_standard.py:533: UserWarning: output path for model already exists, files may be overwritten: /home/tbuchhol/Gitrepos/DenoiSeg/examples/DenoiSeg_2D/models/DenoiSeg_DSB18_n10\n",
+      "  'output path for model already exists, files may be overwritten: %s' % str(self.logdir.resolve()))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:207: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n",
+      "\n",
+      "WARNING:tensorflow:From /home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:216: The name tf.is_variable_initialized is deprecated. Please use tf.compat.v1.is_variable_initialized instead.\n",
+      "\n",
+      "WARNING:tensorflow:From /home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:223: The name tf.variables_initializer is deprecated. Please use tf.compat.v1.variables_initializer instead.\n",
+      "\n",
+      "WARNING:tensorflow:From /home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:2041: The name tf.nn.fused_batch_norm is deprecated. Please use tf.compat.v1.nn.fused_batch_norm instead.\n",
+      "\n",
+      "WARNING:tensorflow:From /home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:148: The name tf.placeholder_with_default is deprecated. Please use tf.compat.v1.placeholder_with_default instead.\n",
+      "\n",
+      "WARNING:tensorflow:From /home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:4267: The name tf.nn.max_pool is deprecated. Please use tf.nn.max_pool2d instead.\n",
+      "\n",
+      "WARNING:tensorflow:From /home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:2239: The name tf.image.resize_nearest_neighbor is deprecated. Please use tf.compat.v1.image.resize_nearest_neighbor instead.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "model_name = 'DenoiSeg_DSB18_n10'\n",
+    "basedir = 'models'\n",
+    "model = DenoiSeg(conf, model_name, basedir)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/optimizers.py:793: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Gitrepos/DenoiSeg/denoiseg/models/denoiseg_standard.py:144: UserWarning: small number of validation images (only 2.15642% of all images)\n",
+      "  warnings.warn(\"small number of validation images (only %.05f%% of all images)\" % (100 * frac_val))\n",
+      "Preparing validation data:   0%|          | 0/670 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "61 blind-spots will be generated per training patch of size (64, 64).\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Preparing validation data: 100%|██████████| 670/670 [00:10<00:00, 63.22it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:1033: The name tf.assign_add is deprecated. Please use tf.compat.v1.assign_add instead.\n",
+      "\n",
+      "WARNING:tensorflow:From /home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:1020: The name tf.assign is deprecated. Please use tf.compat.v1.assign instead.\n",
+      "\n",
+      "Epoch 1/200\n",
+      "237/237 [==============================] - 144s 606ms/step - loss: 0.1425 - denoiseg: 0.1425 - seg_loss: 0.0036 - denoise_loss: 0.1389 - val_loss: 0.6639 - val_denoiseg: 0.6639 - val_seg_loss: 0.5376 - val_denoise_loss: 0.1263\n",
+      "WARNING:tensorflow:From /home/tbuchhol/Gitrepos/DenoiSeg/denoiseg/models/denoiseg_standard.py:352: The name tf.Summary is deprecated. Please use tf.compat.v1.Summary instead.\n",
+      "\n",
+      "Epoch 2/200\n",
+      "237/237 [==============================] - 132s 559ms/step - loss: 0.1280 - denoiseg: 0.1280 - seg_loss: 0.0023 - denoise_loss: 0.1257 - val_loss: 0.5660 - val_denoiseg: 0.5660 - val_seg_loss: 0.4311 - val_denoise_loss: 0.1349\n",
+      "Epoch 3/200\n",
+      "237/237 [==============================] - 132s 557ms/step - loss: 0.1254 - denoiseg: 0.1254 - seg_loss: 0.0015 - denoise_loss: 0.1238 - val_loss: 0.4611 - val_denoiseg: 0.4611 - val_seg_loss: 0.3407 - val_denoise_loss: 0.1204\n",
+      "Epoch 4/200\n",
+      "237/237 [==============================] - 132s 557ms/step - loss: 0.1249 - denoiseg: 0.1249 - seg_loss: 0.0012 - denoise_loss: 0.1237 - val_loss: 0.3975 - val_denoiseg: 0.3975 - val_seg_loss: 0.2764 - val_denoise_loss: 0.1211\n",
+      "Epoch 5/200\n",
+      "237/237 [==============================] - 133s 559ms/step - loss: 0.1243 - denoiseg: 0.1243 - seg_loss: 9.6278e-04 - denoise_loss: 0.1233 - val_loss: 0.3448 - val_denoiseg: 0.3448 - val_seg_loss: 0.2250 - val_denoise_loss: 0.1198\n",
+      "Epoch 6/200\n",
+      "237/237 [==============================] - 132s 557ms/step - loss: 0.1236 - denoiseg: 0.1236 - seg_loss: 8.1437e-04 - denoise_loss: 0.1228 - val_loss: 0.3279 - val_denoiseg: 0.3279 - val_seg_loss: 0.2085 - val_denoise_loss: 0.1194\n",
+      "Epoch 7/200\n",
+      "237/237 [==============================] - 136s 573ms/step - loss: 0.1233 - denoiseg: 0.1233 - seg_loss: 7.7107e-04 - denoise_loss: 0.1225 - val_loss: 0.3407 - val_denoiseg: 0.3407 - val_seg_loss: 0.2156 - val_denoise_loss: 0.1251\n",
+      "Epoch 8/200\n",
+      "237/237 [==============================] - 132s 559ms/step - loss: 0.1230 - denoiseg: 0.1230 - seg_loss: 6.9601e-04 - denoise_loss: 0.1223 - val_loss: 0.3101 - val_denoiseg: 0.3101 - val_seg_loss: 0.1898 - val_denoise_loss: 0.1204\n",
+      "Epoch 9/200\n",
+      "237/237 [==============================] - 132s 558ms/step - loss: 0.1224 - denoiseg: 0.1224 - seg_loss: 6.3728e-04 - denoise_loss: 0.1218 - val_loss: 0.2937 - val_denoiseg: 0.2937 - val_seg_loss: 0.1712 - val_denoise_loss: 0.1225\n",
+      "Epoch 10/200\n",
+      "237/237 [==============================] - 130s 548ms/step - loss: 0.1219 - denoiseg: 0.1219 - seg_loss: 6.3748e-04 - denoise_loss: 0.1213 - val_loss: 0.2742 - val_denoiseg: 0.2742 - val_seg_loss: 0.1536 - val_denoise_loss: 0.1206\n",
+      "Epoch 11/200\n",
+      "237/237 [==============================] - 126s 530ms/step - loss: 0.1212 - denoiseg: 0.1212 - seg_loss: 5.6470e-04 - denoise_loss: 0.1206 - val_loss: 0.2673 - val_denoiseg: 0.2673 - val_seg_loss: 0.1478 - val_denoise_loss: 0.1195\n",
+      "Epoch 12/200\n",
+      "237/237 [==============================] - 125s 528ms/step - loss: 0.1216 - denoiseg: 0.1216 - seg_loss: 5.3302e-04 - denoise_loss: 0.1211 - val_loss: 0.2585 - val_denoiseg: 0.2585 - val_seg_loss: 0.1361 - val_denoise_loss: 0.1225\n",
+      "Epoch 13/200\n",
+      "237/237 [==============================] - 128s 542ms/step - loss: 0.1209 - denoiseg: 0.1209 - seg_loss: 5.0804e-04 - denoise_loss: 0.1204 - val_loss: 0.2682 - val_denoiseg: 0.2682 - val_seg_loss: 0.1475 - val_denoise_loss: 0.1207\n",
+      "Epoch 14/200\n",
+      "237/237 [==============================] - 124s 524ms/step - loss: 0.1207 - denoiseg: 0.1207 - seg_loss: 4.9451e-04 - denoise_loss: 0.1202 - val_loss: 0.2628 - val_denoiseg: 0.2628 - val_seg_loss: 0.1429 - val_denoise_loss: 0.1199\n",
+      "Epoch 15/200\n",
+      "237/237 [==============================] - 123s 517ms/step - loss: 0.1205 - denoiseg: 0.1205 - seg_loss: 4.7971e-04 - denoise_loss: 0.1200 - val_loss: 0.2624 - val_denoiseg: 0.2624 - val_seg_loss: 0.1402 - val_denoise_loss: 0.1222\n",
+      "Epoch 16/200\n",
+      "237/237 [==============================] - 123s 521ms/step - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 4.5965e-04 - denoise_loss: 0.1199 - val_loss: 0.2539 - val_denoiseg: 0.2539 - val_seg_loss: 0.1354 - val_denoise_loss: 0.1185\n",
+      "Epoch 17/200\n",
+      "237/237 [==============================] - 119s 502ms/step - loss: 0.1204 - denoiseg: 0.1204 - seg_loss: 4.8634e-04 - denoise_loss: 0.1199 - val_loss: 0.2609 - val_denoiseg: 0.2609 - val_seg_loss: 0.1413 - val_denoise_loss: 0.1197\n",
+      "Epoch 18/200\n",
+      "237/237 [==============================] - 119s 504ms/step - loss: 0.1206 - denoiseg: 0.1206 - seg_loss: 4.4462e-04 - denoise_loss: 0.1202 - val_loss: 0.2528 - val_denoiseg: 0.2528 - val_seg_loss: 0.1330 - val_denoise_loss: 0.1199\n",
+      "Epoch 19/200\n",
+      "237/237 [==============================] - 119s 501ms/step - loss: 0.1204 - denoiseg: 0.1204 - seg_loss: 4.6196e-04 - denoise_loss: 0.1199 - val_loss: 0.2522 - val_denoiseg: 0.2522 - val_seg_loss: 0.1330 - val_denoise_loss: 0.1192\n",
+      "Epoch 20/200\n",
+      " 49/237 [=====>........................] - ETA: 1:32 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.4783e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151839). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 117s 492ms/step - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.7857e-04 - denoise_loss: 0.1196 - val_loss: 0.2489 - val_denoiseg: 0.2489 - val_seg_loss: 0.1278 - val_denoise_loss: 0.1211\n",
+      "Epoch 21/200\n",
+      "237/237 [==============================] - 115s 483ms/step - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.1923e-04 - denoise_loss: 0.1196 - val_loss: 0.2458 - val_denoiseg: 0.2458 - val_seg_loss: 0.1272 - val_denoise_loss: 0.1186\n",
+      "Epoch 22/200\n",
+      " 31/237 [==>...........................] - ETA: 1:40 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.6089e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.131538). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 116s 489ms/step - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.5026e-04 - denoise_loss: 0.1196 - val_loss: 0.2621 - val_denoiseg: 0.2621 - val_seg_loss: 0.1436 - val_denoise_loss: 0.1186\n",
+      "Epoch 23/200\n",
+      "237/237 [==============================] - 115s 485ms/step - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.8389e-04 - denoise_loss: 0.1197 - val_loss: 0.2432 - val_denoiseg: 0.2432 - val_seg_loss: 0.1249 - val_denoise_loss: 0.1184\n",
+      "Epoch 24/200\n",
+      " 51/237 [=====>........................] - ETA: 1:32 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.0715e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145385). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 1:18 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.2861e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.136563). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 76/237 [========>.....................] - ETA: 1:17 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.4535e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161985). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 112s 472ms/step - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.4081e-04 - denoise_loss: 0.1197 - val_loss: 0.2465 - val_denoiseg: 0.2465 - val_seg_loss: 0.1278 - val_denoise_loss: 0.1187\n",
+      "Epoch 25/200\n",
+      "237/237 [==============================] - 107s 450ms/step - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 3.8713e-04 - denoise_loss: 0.1199 - val_loss: 0.2431 - val_denoiseg: 0.2431 - val_seg_loss: 0.1239 - val_denoise_loss: 0.1192\n",
+      "Epoch 26/200\n",
+      " 41/237 [====>.........................] - ETA: 1:26 - loss: 0.1206 - denoiseg: 0.1206 - seg_loss: 6.8268e-04 - denoise_loss: 0.1199"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174429). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 42/237 [====>.........................] - ETA: 1:25 - loss: 0.1205 - denoiseg: 0.1205 - seg_loss: 6.6643e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196012). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 47/237 [====>.........................] - ETA: 1:23 - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 6.0256e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178543). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 1:08 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 5.0008e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164093). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 106s 446ms/step - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.4773e-04 - denoise_loss: 0.1194 - val_loss: 0.2442 - val_denoiseg: 0.2442 - val_seg_loss: 0.1244 - val_denoise_loss: 0.1199\n",
+      "Epoch 27/200\n",
+      " 34/237 [===>..........................] - ETA: 1:27 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.0990e-04 - denoise_loss: 0.1194 ETA: 37s - loss: 0.1206 - denoiseg"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184869). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200248). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 36/237 [===>..........................] - ETA: 1:26 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.1459e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215094). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 37/237 [===>..........................] - ETA: 1:26 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.0608e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234045). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.243446). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 39/237 [===>..........................] - ETA: 1:25 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.3987e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.260917). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 44/237 [====>.........................] - ETA: 1:23 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.4374e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.255343). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 46/237 [====>.........................] - ETA: 1:22 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.3364e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.252772). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236683). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 48/237 [=====>........................] - ETA: 1:21 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.1974e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.249228). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 50/237 [=====>........................] - ETA: 1:20 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.2999e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229451). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199279). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 52/237 [=====>........................] - ETA: 1:21 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2352e-04 - denoise_loss: 0.11 - ETA: 1:19 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.1729e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167469). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 1:10 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.0889e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135314). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 77/237 [========>.....................] - ETA: 1:10 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.1904e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141785). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 78/237 [========>.....................] - ETA: 1:10 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.1366e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187178). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 79/237 [=========>....................] - ETA: 1:09 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.0998e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.247857). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 1:09 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.0486e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.262355). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 84/237 [=========>....................] - ETA: 1:07 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.8953e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.272316). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 88/237 [==========>...................] - ETA: 1:05 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.2011e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.240182). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224868). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 91/237 [==========>...................] - ETA: 1:04 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.1447e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216831). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 92/237 [==========>...................] - ETA: 1:03 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.0997e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222802). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 94/237 [==========>...................] - ETA: 1:02 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.2363e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218882). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 98/237 [===========>..................] - ETA: 1:01 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.3206e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203125). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/237 [===========>..................] - ETA: 1:00 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.2546e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158449). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 110s 466ms/step - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.1299e-04 - denoise_loss: 0.1196 - val_loss: 0.2598 - val_denoiseg: 0.2598 - val_seg_loss: 0.1372 - val_denoise_loss: 0.1226\n",
+      "Epoch 28/200\n",
+      " 37/237 [===>..........................] - ETA: 1:24 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2106e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179720). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 38/237 [===>..........................] - ETA: 1:23 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.5837e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236357). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 39/237 [===>..........................] - ETA: 1:23 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.9688e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185821). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 40/237 [====>.........................] - ETA: 1:23 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.8696e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235244). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 41/237 [====>.........................] - ETA: 1:22 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.7752e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227608). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 43/237 [====>.........................] - ETA: 1:21 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.6691e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220841). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 44/237 [====>.........................] - ETA: 1:21 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.4239e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207133). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 46/237 [====>.........................] - ETA: 1:20 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.2315e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166050). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 50/237 [=====>........................] - ETA: 1:19 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.1577e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147744). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 64/237 [=======>......................] - ETA: 1:13 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.7176e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196782). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 70/237 [=======>......................] - ETA: 1:11 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.4182e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161359). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "124/237 [==============>...............] - ETA: 48s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.1373e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.137043). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 105s 444ms/step - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.9482e-04 - denoise_loss: 0.1194 - val_loss: 0.2511 - val_denoiseg: 0.2511 - val_seg_loss: 0.1308 - val_denoise_loss: 0.1203\n",
+      "Epoch 29/200\n",
+      " 15/237 [>.............................] - ETA: 1:19 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 2.1258e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.133822). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/237 [=>............................] - ETA: 1:20 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 2.5203e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153311). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 32/237 [===>..........................] - ETA: 1:28 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.2547e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138601). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 33/237 [===>..........................] - ETA: 1:27 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.8146e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201378). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 34/237 [===>..........................] - ETA: 1:27 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.8073e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227323). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 36/237 [===>..........................] - ETA: 1:26 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5957e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197114). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 39/237 [===>..........................] - ETA: 1:24 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.3531e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226794). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202069). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 42/237 [====>.........................] - ETA: 1:23 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.4265e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219069). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 45/237 [====>.........................] - ETA: 1:22 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.2303e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198600). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 46/237 [====>.........................] - ETA: 1:21 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.1642e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209977). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 48/237 [=====>........................] - ETA: 1:20 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.0324e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217968). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 52/237 [=====>........................] - ETA: 1:19 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.8937e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212345). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 53/237 [=====>........................] - ETA: 1:18 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.2111e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210772). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 54/237 [=====>........................] - ETA: 1:18 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.1516e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214003). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 55/237 [=====>........................] - ETA: 1:17 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.3879e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218764). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 57/237 [======>.......................] - ETA: 1:16 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.3204e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222101). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220529). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/237 [======>.......................] - ETA: 1:15 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.2079e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232895). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 64/237 [=======>......................] - ETA: 1:13 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.0222e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219873). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 66/237 [=======>......................] - ETA: 1:12 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.0586e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190104). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 67/237 [=======>......................] - ETA: 1:12 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.0130e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201972). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 72/237 [========>.....................] - ETA: 1:10 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.2843e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175871). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 1:09 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.1956e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193789). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 76/237 [========>.....................] - ETA: 1:08 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.1141e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217530). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 1:07 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.0343e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219291). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 1:06 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2910e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199262). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 87/237 [==========>...................] - ETA: 1:03 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.1243e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182668). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 88/237 [==========>...................] - ETA: 1:03 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.0888e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158014). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 90/237 [==========>...................] - ETA: 1:02 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.0201e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138082). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.128977). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 92/237 [==========>...................] - ETA: 1:01 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 2.9545e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148909). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "110/237 [============>.................] - ETA: 54s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.6549e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.133983). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "175/237 [=====================>........] - ETA: 26s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.0293e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143023). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179/237 [=====================>........] - ETA: 24s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.9667e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167316). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 23s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.9229e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135668). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "192/237 [=======================>......] - ETA: 19s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.8077e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201564). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "195/237 [=======================>......] - ETA: 17s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.7503e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226136). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "196/237 [=======================>......] - ETA: 17s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.7312e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.268839). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232501). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "201/237 [========================>.....] - ETA: 15s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.7417e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.129651). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 101s 427ms/step - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.9382e-04 - denoise_loss: 0.1192 - val_loss: 0.2446 - val_denoiseg: 0.2446 - val_seg_loss: 0.1262 - val_denoise_loss: 0.1185\n",
+      "Epoch 30/200\n",
+      " 27/237 [==>...........................] - ETA: 1:19 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 8.6236e-05 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155538). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 30/237 [==>...........................] - ETA: 1:22 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 1.7153e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189554). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 32/237 [===>..........................] - ETA: 1:22 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 1.9388e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217301). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234381). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 34/237 [===>..........................] - ETA: 1:21 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 1.9619e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.259404). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 37/237 [===>..........................] - ETA: 1:21 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 1.8028e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236293). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 38/237 [===>..........................] - ETA: 1:20 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 1.7553e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.262484). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:20 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 1.9435e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.240220). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 42/237 [====>.........................] - ETA: 1:19 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 1.8510e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221922). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 43/237 [====>.........................] - ETA: 1:19 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 1.8079e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213837). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 44/237 [====>.........................] - ETA: 1:18 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 1.7668e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209221). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 47/237 [====>.........................] - ETA: 1:17 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 2.1543e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205528). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 49/237 [=====>........................] - ETA: 1:17 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 2.0680e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199426). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148482). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 52/237 [=====>........................] - ETA: 1:16 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 1.9494e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154584). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 79/237 [=========>....................] - ETA: 1:05 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 2.5377e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148090). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "150/237 [=================>............] - ETA: 36s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.3459e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151326). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "152/237 [==================>...........] - ETA: 35s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.3246e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153199). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "184/237 [======================>.......] - ETA: 22s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.7973e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156430). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 102s 429ms/step - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.6407e-04 - denoise_loss: 0.1193 - val_loss: 0.3029 - val_denoiseg: 0.3029 - val_seg_loss: 0.1828 - val_denoise_loss: 0.1201\n",
+      "Epoch 31/200\n",
+      " 14/237 [>.............................] - ETA: 1:14 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.6541e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184315). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 37/237 [===>..........................] - ETA: 1:23 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 5.4923e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196576). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158676). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 39/237 [===>..........................] - ETA: 1:22 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 5.2106e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179030). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 40/237 [====>.........................] - ETA: 1:22 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 5.6620e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208923). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 42/237 [====>.........................] - ETA: 1:21 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 5.4934e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231246). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.246971). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 44/237 [====>.........................] - ETA: 1:20 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 5.6524e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.241989). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 45/237 [====>.........................] - ETA: 1:20 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 5.9926e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227438). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 47/237 [====>.........................] - ETA: 1:19 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 5.7394e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226487). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 48/237 [=====>........................] - ETA: 1:19 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 6.0841e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.256764). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 51/237 [=====>........................] - ETA: 1:17 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 6.0578e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197132). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 53/237 [=====>........................] - ETA: 1:16 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 5.8292e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195003). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169550). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:15 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 5.9224e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159185). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/237 [======>.......................] - ETA: 1:14 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 5.7682e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189560). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 60/237 [======>.......................] - ETA: 1:13 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 5.6721e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208724). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 62/237 [======>.......................] - ETA: 1:12 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 5.5471e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201749). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 66/237 [=======>......................] - ETA: 1:11 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 5.3492e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235410). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 67/237 [=======>......................] - ETA: 1:10 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 5.2694e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228435). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197126). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 71/237 [=======>......................] - ETA: 1:09 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 5.3189e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220393). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.248075). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/237 [========>.....................] - ETA: 1:08 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 5.1880e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.259704). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 74/237 [========>.....................] - ETA: 1:08 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 5.1929e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.264614). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 76/237 [========>.....................] - ETA: 1:08 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 5.1493e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.263976). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 79/237 [=========>....................] - ETA: 1:07 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.9550e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.243498). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 80/237 [=========>....................] - ETA: 1:07 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.8931e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231433). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 94/237 [==========>...................] - ETA: 1:02 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.5755e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141242). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 95/237 [===========>..................] - ETA: 1:02 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.8317e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157799). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 97/237 [===========>..................] - ETA: 1:01 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.9559e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189897). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 99/237 [===========>..................] - ETA: 1:00 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.8558e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192508). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "100/237 [===========>..................] - ETA: 1:00 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.8077e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196278). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "101/237 [===========>..................] - ETA: 59s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.7601e-04 - denoise_loss: 0.1193 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.244075). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "104/237 [============>.................] - ETA: 58s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.6489e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214163). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "108/237 [============>.................] - ETA: 56s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.5520e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178404). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "109/237 [============>.................] - ETA: 55s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.7207e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167738). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "189/237 [======================>.......] - ETA: 20s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.5084e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144238). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "192/237 [=======================>......] - ETA: 19s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.4848e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172715). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "195/237 [=======================>......] - ETA: 18s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.5222e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218035). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "197/237 [=======================>......] - ETA: 17s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.4766e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153628). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "199/237 [========================>.....] - ETA: 16s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.4316e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163459). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134094). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 106s 447ms/step - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.2313e-04 - denoise_loss: 0.1192 - val_loss: 0.2507 - val_denoiseg: 0.2507 - val_seg_loss: 0.1325 - val_denoise_loss: 0.1182\n",
+      "Epoch 32/200\n",
+      " 40/237 [====>.........................] - ETA: 1:20 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.1872e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200469). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 41/237 [====>.........................] - ETA: 1:19 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.4966e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216353). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 43/237 [====>.........................] - ETA: 1:20 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.4122e-04 - denoise_loss: 0.11 - ETA: 1:19 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.3096e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237588). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 44/237 [====>.........................] - ETA: 1:18 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.5797e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236356). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 48/237 [=====>........................] - ETA: 1:17 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.5505e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212776). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 50/237 [=====>........................] - ETA: 1:16 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.6253e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206490). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 51/237 [=====>........................] - ETA: 1:16 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.5346e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194583). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 53/237 [=====>........................] - ETA: 1:15 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.3634e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216499). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 55/237 [=====>........................] - ETA: 1:14 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.3755e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140847). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 57/237 [======>.......................] - ETA: 1:14 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.2231e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151477). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/237 [======>.......................] - ETA: 1:13 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.1100e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215044). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 63/237 [======>.......................] - ETA: 1:12 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9793e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194803). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 67/237 [=======>......................] - ETA: 1:11 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9204e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197049). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 69/237 [=======>......................] - ETA: 1:10 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.8068e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193173). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 76/237 [========>.....................] - ETA: 1:07 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.8566e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.136591). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "151/237 [==================>...........] - ETA: 35s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.1160e-04 - denoise_loss: 0.1191  ETA: 1:02 - loss: "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156849). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "153/237 [==================>...........] - ETA: 35s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.0991e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210168). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 34s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.0588e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210411). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "157/237 [==================>...........] - ETA: 33s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.1496e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.245647). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "159/237 [===================>..........] - ETA: 32s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.1454e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219641). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184162). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "161/237 [===================>..........] - ETA: 31s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.1679e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182711). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "164/237 [===================>..........] - ETA: 30s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.4036e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185405). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "166/237 [====================>.........] - ETA: 29s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.3505e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155280). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "172/237 [====================>.........] - ETA: 27s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.2182e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144099). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "174/237 [=====================>........] - ETA: 26s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.2418e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141827). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 25s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.1936e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156381). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156565). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "178/237 [=====================>........] - ETA: 24s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.1597e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154293). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 23s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0908e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144225). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "189/237 [======================>.......] - ETA: 20s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.3558e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161992). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "191/237 [=======================>......] - ETA: 19s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.3160e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192468). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "192/237 [=======================>......] - ETA: 18s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.3837e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212485). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236533). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "194/237 [=======================>......] - ETA: 17s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.3386e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203379). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "195/237 [=======================>......] - ETA: 17s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.3422e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177349). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "197/237 [=======================>......] - ETA: 16s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.3034e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159244). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "198/237 [========================>.....] - ETA: 16s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.3610e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143887). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "200/237 [========================>.....] - ETA: 15s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.3436e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147859). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "210/237 [=========================>....] - ETA: 11s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.3758e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158937). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "212/237 [=========================>....] - ETA: 10s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.4063e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185904). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174397). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "213/237 [=========================>....] - ETA: 10s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.3856e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193373). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "218/237 [==========================>...] - ETA: 7s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.2968e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212998). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201491). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "222/237 [===========================>..] - ETA: 6s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.2313e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221700). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "225/237 [===========================>..] - ETA: 5s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.3441e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226151). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "228/237 [===========================>..] - ETA: 3s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.3503e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222666). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "229/237 [===========================>..] - ETA: 3s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.3313e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226533). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "234/237 [============================>.] - ETA: 1s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.3126e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178808). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "235/237 [============================>.] - ETA: 0s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.3038e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230140). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "236/237 [============================>.] - ETA: 0s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.2855e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.250272). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 100s 423ms/step - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.2675e-04 - denoise_loss: 0.1194 - val_loss: 0.2512 - val_denoiseg: 0.2512 - val_seg_loss: 0.1291 - val_denoise_loss: 0.1221\n",
+      "Epoch 33/200\n",
+      "  2/237 [..............................] - ETA: 55s - loss: 0.1219 - denoiseg: 0.1219 - seg_loss: 9.5010e-04 - denoise_loss: 0.1210"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177110). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228772). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  3/237 [..............................] - ETA: 1:09 - loss: 0.1212 - denoiseg: 0.1212 - seg_loss: 7.6227e-04 - denoise_loss: 0.1205"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.280435). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  4/237 [..............................] - ETA: 1:16 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 5.7329e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.278705). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  6/237 [..............................] - ETA: 1:22 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.8219e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.276975). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  7/237 [..............................] - ETA: 1:24 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.2759e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.264670). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  8/237 [>.............................] - ETA: 1:25 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 2.8665e-04 - denoise_loss: 0.1199"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.260277). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.256321). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 10/237 [>.............................] - ETA: 1:18 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 2.2932e-04 - denoise_loss: 0.1200"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.252365). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 11/237 [>.............................] - ETA: 1:18 - loss: 0.1205 - denoiseg: 0.1205 - seg_loss: 2.0847e-04 - denoise_loss: 0.1203"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225869). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 13/237 [>.............................] - ETA: 1:14 - loss: 0.1204 - denoiseg: 0.1204 - seg_loss: 2.0225e-04 - denoise_loss: 0.1202"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182708). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 15/237 [>.............................] - ETA: 1:15 - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 1.9004e-04 - denoise_loss: 0.1201"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180822). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 16/237 [=>............................] - ETA: 1:16 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 1.7817e-04 - denoise_loss: 0.1199"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197486). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 19/237 [=>............................] - ETA: 1:18 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 1.5004e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199546). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 21/237 [=>............................] - ETA: 1:14 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 2.1621e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197659). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 23/237 [=>............................] - ETA: 1:15 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 1.9741e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159239). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 24/237 [==>...........................] - ETA: 1:16 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 2.3043e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153608). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 38/237 [===>..........................] - ETA: 1:20 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.1147e-04 - denoise_loss: 0.1196 ETA: 1:21 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.3817e-04 - denoise_loss: 0. - ETA: 1:21 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.1989e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164960). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134693). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 41/237 [====>.........................] - ETA: 1:19 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.3768e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.181036). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219061). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 43/237 [====>.........................] - ETA: 1:18 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 4.3589e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.238656). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 46/237 [====>.........................] - ETA: 1:17 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 4.0755e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223961). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 47/237 [====>.........................] - ETA: 1:17 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 3.9888e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230830). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 49/237 [=====>........................] - ETA: 1:16 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.8292e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.245278). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 52/237 [=====>........................] - ETA: 1:15 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 4.1141e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214851). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 55/237 [=====>........................] - ETA: 1:14 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.4029e-04 - denoise_loss: 0.1197 ETA: 1:14 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 3.9617e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224986). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220943). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 56/237 [======>.......................] - ETA: 1:13 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.3243e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204252). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 60/237 [======>.......................] - ETA: 1:12 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 4.5773e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195911). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 63/237 [======>.......................] - ETA: 1:10 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.3593e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164068). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 65/237 [=======>......................] - ETA: 1:10 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.5936e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.131363). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "143/237 [=================>............] - ETA: 38s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.2131e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212878). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "145/237 [=================>............] - ETA: 37s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.1688e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.253636). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "148/237 [=================>............] - ETA: 36s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.3167e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150324). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "232/237 [============================>.] - ETA: 2s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.4759e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146999). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "236/237 [============================>.] - ETA: 0s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.4189e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156749). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 97s 411ms/step - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.4170e-04 - denoise_loss: 0.1195 - val_loss: 0.2456 - val_denoiseg: 0.2456 - val_seg_loss: 0.1267 - val_denoise_loss: 0.1188\n",
+      "Epoch 34/200\n",
+      " 59/237 [======>.......................] - ETA: 1:09 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 5.2425e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173735). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 61/237 [======>.......................] - ETA: 1:07 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 5.0706e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.119012). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/237 [===========>..................] - ETA: 54s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.9679e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161432). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176339). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "102/237 [===========>..................] - ETA: 53s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.8705e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.244520). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "104/237 [============>.................] - ETA: 52s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.7955e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.255277). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "107/237 [============>.................] - ETA: 51s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.6814e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214279). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "108/237 [============>.................] - ETA: 51s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.6801e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165416). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "194/237 [=======================>......] - ETA: 17s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.4445e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191560). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "196/237 [=======================>......] - ETA: 16s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.4371e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221864). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177189). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "199/237 [========================>.....] - ETA: 15s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.4457e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151219). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "200/237 [========================>.....] - ETA: 14s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.4235e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168652). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "215/237 [==========================>...] - ETA: 8s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.3264e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182208). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "216/237 [==========================>...] - ETA: 8s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.3437e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.252021). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "218/237 [==========================>...] - ETA: 7s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.3150e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212353). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "219/237 [==========================>...] - ETA: 7s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.2953e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.255901). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211558). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "222/237 [===========================>..] - ETA: 5s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.4191e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208348). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "223/237 [===========================>..] - ETA: 5s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.3993e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197123). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "224/237 [===========================>..] - ETA: 5s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.4316e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193823). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "225/237 [===========================>..] - ETA: 4s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.4119e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157840). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 96s 405ms/step - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.3319e-04 - denoise_loss: 0.1192 - val_loss: 0.2580 - val_denoiseg: 0.2580 - val_seg_loss: 0.1390 - val_denoise_loss: 0.1190\n",
+      "Epoch 35/200\n",
+      " 16/237 [=>............................] - ETA: 1:13 - loss: 0.1207 - denoiseg: 0.1207 - seg_loss: 3.7103e-04 - denoise_loss: 0.1203"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156866). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/237 [=>............................] - ETA: 1:14 - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 3.2981e-04 - denoise_loss: 0.1200"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152327). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 46/237 [====>.........................] - ETA: 1:15 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 2.8275e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173542). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 47/237 [====>.........................] - ETA: 1:15 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.1403e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182435). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 51/237 [=====>........................] - ETA: 1:13 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.1989e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184999). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 52/237 [=====>........................] - ETA: 1:13 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.1374e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189516). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 55/237 [=====>........................] - ETA: 1:11 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.0535e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195641). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201394). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/237 [======>.......................] - ETA: 1:10 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.0902e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196877). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 60/237 [======>.......................] - ETA: 1:09 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.0387e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211786). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 61/237 [======>.......................] - ETA: 1:09 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.0638e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215901). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 62/237 [======>.......................] - ETA: 1:09 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.4613e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208781). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 65/237 [=======>......................] - ETA: 1:07 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.7418e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180225). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 66/237 [=======>......................] - ETA: 1:07 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.6851e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204708). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 70/237 [=======>......................] - ETA: 1:06 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.4745e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201614). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 72/237 [========>.....................] - ETA: 1:05 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.4810e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185133). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/237 [========>.....................] - ETA: 1:04 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.4333e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209617). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 1:04 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.3869e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204230). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 1:02 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.3434e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206383). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 81/237 [=========>....................] - ETA: 1:01 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.3066e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215317). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230620). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 83/237 [=========>....................] - ETA: 1:00 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.3002e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.238385). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 84/237 [=========>....................] - ETA: 1:00 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.2609e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231876). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 87/237 [==========>...................] - ETA: 59s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.3183e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215176). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198077). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 91/237 [==========>...................] - ETA: 57s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.1725e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161338). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 97/237 [===========>..................] - ETA: 55s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.1796e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176229). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 98/237 [===========>..................] - ETA: 54s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.2344e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179747). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/237 [===========>..................] - ETA: 54s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.1836e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180631). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "107/237 [============>.................] - ETA: 51s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.0601e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143939). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "110/237 [============>.................] - ETA: 49s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.1955e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157261). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "112/237 [=============>................] - ETA: 49s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.1384e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173734). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184286). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "114/237 [=============>................] - ETA: 48s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.1148e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193005). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "118/237 [=============>................] - ETA: 46s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.1451e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190430). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 44s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.1791e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180227). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "125/237 [==============>...............] - ETA: 43s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.1282e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182432). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "126/237 [==============>...............] - ETA: 43s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.1034e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193446). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "130/237 [===============>..............] - ETA: 41s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.0163e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179397). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "132/237 [===============>..............] - ETA: 41s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.0235e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195481). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217141). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "136/237 [================>.............] - ETA: 39s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.2967e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175612). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "138/237 [================>.............] - ETA: 38s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.2842e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186458). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "139/237 [================>.............] - ETA: 38s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.2606e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200681). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217865). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "142/237 [================>.............] - ETA: 37s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.1917e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214185). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "144/237 [=================>............] - ETA: 36s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.2317e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233078). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "146/237 [=================>............] - ETA: 35s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.2839e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215894). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "147/237 [=================>............] - ETA: 35s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.2616e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172088). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "154/237 [==================>...........] - ETA: 32s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.1315e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154257). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148501). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "155/237 [==================>...........] - ETA: 32s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.1415e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195118). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "156/237 [==================>...........] - ETA: 32s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.1475e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222234). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "157/237 [==================>...........] - ETA: 31s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.1275e-04 - denoise_loss: 0.119\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.249347). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "159/237 [===================>..........] - ETA: 31s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.2668e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.249810). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "160/237 [===================>..........] - ETA: 30s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.3470e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.248827). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.278774). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "162/237 [===================>..........] - ETA: 29s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.4255e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.266414). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "183/237 [======================>.......] - ETA: 22s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.2791e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145944). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "188/237 [======================>.......] - ETA: 20s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.3694e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204003). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "189/237 [======================>.......] - ETA: 19s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.4836e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212683). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "191/237 [=======================>......] - ETA: 18s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.4472e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182267). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "222/237 [===========================>..] - ETA: 6s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.4796e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151083). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "224/237 [===========================>..] - ETA: 5s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.4588e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153086). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "225/237 [===========================>..] - ETA: 4s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.4434e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.136277). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "228/237 [===========================>..] - ETA: 3s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.5544e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203273). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140806). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "233/237 [============================>.] - ETA: 1s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.6354e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140431). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "234/237 [============================>.] - ETA: 1s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.6199e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156868). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "236/237 [============================>.] - ETA: 0s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.6454e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159324). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156364). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 99s 418ms/step - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.6300e-04 - denoise_loss: 0.1197 - val_loss: 0.2399 - val_denoiseg: 0.2399 - val_seg_loss: 0.1213 - val_denoise_loss: 0.1187\n",
+      "Epoch 36/200\n",
+      "  2/237 [..............................] - ETA: 1:12 - loss: 0.1210 - denoiseg: 0.1210 - seg_loss: 8.0406e-04 - denoise_loss: 0.1202"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.304463). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  3/237 [..............................] - ETA: 1:19 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 5.3604e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223604). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142744). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  6/237 [..............................] - ETA: 1:15 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 8.6098e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159505). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151125). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 10/237 [>.............................] - ETA: 1:10 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 6.0022e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213622). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 12/237 [>.............................] - ETA: 1:10 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 5.3018e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174304). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 14/237 [>.............................] - ETA: 1:13 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 6.2170e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228421). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 15/237 [>.............................] - ETA: 1:14 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 5.8025e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.181787). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183135). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 19/237 [=>............................] - ETA: 1:14 - loss: 0.1207 - denoiseg: 0.1207 - seg_loss: 5.7926e-04 - denoise_loss: 0.1201"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175817). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 22/237 [=>............................] - ETA: 1:12 - loss: 0.1206 - denoiseg: 0.1206 - seg_loss: 5.5721e-04 - denoise_loss: 0.1201"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169296). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 25/237 [==>...........................] - ETA: 1:12 - loss: 0.1206 - denoiseg: 0.1206 - seg_loss: 5.4432e-04 - denoise_loss: 0.1200"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160234). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155034). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 26/237 [==>...........................] - ETA: 1:10 - loss: 0.1206 - denoiseg: 0.1206 - seg_loss: 6.0786e-04 - denoise_loss: 0.1200"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152954). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 27/237 [==>...........................] - ETA: 1:10 - loss: 0.1205 - denoiseg: 0.1205 - seg_loss: 5.8721e-04 - denoise_loss: 0.1199"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149452). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:14 - loss: 0.1205 - denoiseg: 0.1205 - seg_loss: 4.1738e-04 - denoise_loss: 0.12"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196969). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 41/237 [====>.........................] - ETA: 1:13 - loss: 0.1206 - denoiseg: 0.1206 - seg_loss: 4.0720e-04 - denoise_loss: 0.1202"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201616). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 43/237 [====>.........................] - ETA: 1:13 - loss: 0.1206 - denoiseg: 0.1206 - seg_loss: 3.8826e-04 - denoise_loss: 0.1202"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206420). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 49/237 [=====>........................] - ETA: 1:11 - loss: 0.1206 - denoiseg: 0.1206 - seg_loss: 3.9119e-04 - denoise_loss: 0.1202"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180264). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 55/237 [=====>........................] - ETA: 1:09 - loss: 0.1204 - denoiseg: 0.1204 - seg_loss: 3.9037e-04 - denoise_loss: 0.1200"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176062). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 56/237 [======>.......................] - ETA: 1:08 - loss: 0.1204 - denoiseg: 0.1204 - seg_loss: 3.9038e-04 - denoise_loss: 0.1200"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189875). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/237 [======>.......................] - ETA: 1:07 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 3.8355e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176328). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 65/237 [=======>......................] - ETA: 1:05 - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 3.7725e-04 - denoise_loss: 0.1199"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171498). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 66/237 [=======>......................] - ETA: 1:05 - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 3.9834e-04 - denoise_loss: 0.1199"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149508). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 92/237 [==========>...................] - ETA: 56s - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 4.3149e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179836). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 97/237 [===========>..................] - ETA: 54s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.2503e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201332). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 99/237 [===========>..................] - ETA: 53s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.5563e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.239234). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197379). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "100/237 [===========>..................] - ETA: 52s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.7940e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146384). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "104/237 [============>.................] - ETA: 51s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.6096e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.239788). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "105/237 [============>.................] - ETA: 51s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.5657e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232515). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "109/237 [============>.................] - ETA: 49s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.6418e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224561). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "111/237 [=============>................] - ETA: 49s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.5918e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233654). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 47s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.9436e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214319). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "116/237 [=============>................] - ETA: 47s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.9010e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218841). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "118/237 [=============>................] - ETA: 46s - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 4.8189e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182493). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "219/237 [==========================>...] - ETA: 7s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.2543e-04 - denoise_loss: 0.1194 - ETA: 15s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.9952e-04 - denoise - ETA: 10s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.0358e-04 - denoi"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.133641). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "225/237 [===========================>..] - ETA: 4s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.2703e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165573). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "228/237 [===========================>..] - ETA: 3s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.3216e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199455). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134973). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "233/237 [============================>.] - ETA: 1s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.2737e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229268). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "236/237 [============================>.] - ETA: 0s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.2821e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154417). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164786). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 96s 405ms/step - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.2638e-04 - denoise_loss: 0.1194 - val_loss: 0.2437 - val_denoiseg: 0.2437 - val_seg_loss: 0.1234 - val_denoise_loss: 0.1202\n",
+      "Epoch 37/200\n",
+      " 16/237 [=>............................] - ETA: 1:10 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 2.4103e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177472). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 17/237 [=>............................] - ETA: 1:11 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.2685e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225057). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 19/237 [=>............................] - ETA: 1:11 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.0317e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230265). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 21/237 [=>............................] - ETA: 1:12 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 1.8382e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198415). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170071). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 23/237 [=>............................] - ETA: 1:12 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 1.6784e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149127). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 32/237 [===>..........................] - ETA: 1:12 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.5154e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177978). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 34/237 [===>..........................] - ETA: 1:12 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.4051e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183767). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 36/237 [===>..........................] - ETA: 1:11 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.0945e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.136606). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 72/237 [========>.....................] - ETA: 1:04 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 2.9425e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165650). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195213). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 1:03 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 2.8885e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209054). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 79/237 [=========>....................] - ETA: 1:01 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.1960e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177986). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 82/237 [=========>....................] - ETA: 1:00 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2676e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210945). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 83/237 [=========>....................] - ETA: 59s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2283e-04 - denoise_loss: 0.1194 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223482). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157752). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 84/237 [=========>....................] - ETA: 59s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.1898e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208517). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 85/237 [=========>....................] - ETA: 59s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.4104e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226292). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 86/237 [=========>....................] - ETA: 58s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.3708e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225512). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 88/237 [==========>...................] - ETA: 58s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.3320e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237463). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 90/237 [==========>...................] - ETA: 57s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.3498e-04 - denoise_loss: 0.119\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.239252). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 91/237 [==========>...................] - ETA: 56s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.4399e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.238472). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 92/237 [==========>...................] - ETA: 56s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.4025e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228844). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 94/237 [==========>...................] - ETA: 55s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.3301e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236574). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 95/237 [===========>..................] - ETA: 55s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2951e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228735). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/237 [===========>..................] - ETA: 53s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2835e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188648). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "102/237 [===========>..................] - ETA: 52s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2756e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208422). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "103/237 [============>.................] - ETA: 52s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2438e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212905). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176064). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "104/237 [============>.................] - ETA: 51s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2126e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187864). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "108/237 [============>.................] - ETA: 50s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2833e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180256). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "110/237 [============>.................] - ETA: 49s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.4492e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.181571). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "113/237 [=============>................] - ETA: 48s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.9141e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179892). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 47s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.8461e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180258). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "118/237 [=============>................] - ETA: 46s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.7760e-04 - denoise_loss: 0.1192- ETA: 46s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.7974e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195170). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179061). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "120/237 [==============>...............] - ETA: 45s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.7251e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169469). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "121/237 [==============>...............] - ETA: 45s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.6943e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170301). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 44s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.9849e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184268). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 43s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.9336e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148613). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "136/237 [================>.............] - ETA: 39s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.7627e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168055). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "138/237 [================>.............] - ETA: 38s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.7081e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148095). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "141/237 [================>.............] - ETA: 37s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.8588e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.181684). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145105). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "164/237 [===================>..........] - ETA: 28s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.7401e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156816). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "170/237 [====================>.........] - ETA: 26s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.8658e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168660). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 23s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.7871e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199036). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "177/237 [=====================>........] - ETA: 23s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.7657e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213009). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 21s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.7403e-04 - denoise_loss: 0.1191- ETA: 22s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.7611e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177656). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204792). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "185/237 [======================>.......] - ETA: 20s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.8637e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185465). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "189/237 [======================>.......] - ETA: 19s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.8177e-04 - denoise_loss: 0.119 - ETA: 18s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.7975e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184437). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "192/237 [=======================>......] - ETA: 17s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.8467e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178964). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "195/237 [=======================>......] - ETA: 16s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.8304e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138161). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "197/237 [=======================>......] - ETA: 15s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.7915e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154920). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 94s 395ms/step - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.8598e-04 - denoise_loss: 0.1192 - val_loss: 0.2406 - val_denoiseg: 0.2406 - val_seg_loss: 0.1222 - val_denoise_loss: 0.1184\n",
+      "Epoch 38/200\n",
+      "  4/237 [..............................] - ETA: 52s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 6.1817e-05 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139420). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 47/237 [====>.........................] - ETA: 1:12 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.2843e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147310). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 63/237 [======>.......................] - ETA: 1:06 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.8238e-04 - denoise_loss: 0.1190 ETA: 1:07 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.8256e-04 - denoise_loss"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175324). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 67/237 [=======>......................] - ETA: 1:05 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 2.9686e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175766). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 68/237 [=======>......................] - ETA: 1:04 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.9249e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190604). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 71/237 [=======>......................] - ETA: 1:04 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.8821e-04 - denoise_loss: 0.11 - ETA: 1:03 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.8415e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200754). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 1:01 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.8574e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203706). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 81/237 [=========>....................] - ETA: 59s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.7523e-04 - denoise_loss: 0.1189 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189527). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 83/237 [=========>....................] - ETA: 59s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.9902e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179655). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 84/237 [=========>....................] - ETA: 58s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.0156e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185953). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 86/237 [=========>....................] - ETA: 58s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.1455e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200232). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 88/237 [==========>...................] - ETA: 57s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.2517e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178643). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 55s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.2952e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193388). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 94/237 [==========>...................] - ETA: 55s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.2601e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190486). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 95/237 [===========>..................] - ETA: 54s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.3397e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206855). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/237 [===========>..................] - ETA: 52s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.3473e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213333). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226631). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "102/237 [===========>..................] - ETA: 52s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.5784e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237980). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "103/237 [============>.................] - ETA: 51s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.5437e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233396). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105/237 [============>.................] - ETA: 50s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.4791e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236004). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "107/237 [============>.................] - ETA: 50s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.4151e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234715). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "109/237 [============>.................] - ETA: 49s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.3528e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235644). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "111/237 [=============>................] - ETA: 48s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.4206e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233036). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219881). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "113/237 [=============>................] - ETA: 47s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5333e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221199). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201501). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 47s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.4730e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159101). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "119/237 [==============>...............] - ETA: 45s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.9028e-04 - denoise_loss: 0.1191- ETA: 46s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.8153e-04 - denoise_loss: 0.11 - ETA: 45s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.8700e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212718). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "121/237 [==============>...............] - ETA: 44s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.9244e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206174). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226526). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "124/237 [==============>...............] - ETA: 43s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.8451e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236331). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "128/237 [===============>..............] - ETA: 42s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.1388e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165366). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "129/237 [===============>..............] - ETA: 41s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.2016e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212201). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "131/237 [===============>..............] - ETA: 40s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.1379e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170288). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "140/237 [================>.............] - ETA: 37s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.0563e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148923). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "143/237 [=================>............] - ETA: 36s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.9718e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.137717). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182655). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "144/237 [=================>............] - ETA: 35s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.9442e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205361). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "157/237 [==================>...........] - ETA: 30s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.8681e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153667). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "159/237 [===================>..........] - ETA: 30s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.1441e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196970). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "163/237 [===================>..........] - ETA: 28s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.0749e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224141). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "164/237 [===================>..........] - ETA: 28s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.0501e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200355). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "167/237 [====================>.........] - ETA: 27s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.0030e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177466). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "180/237 [=====================>........] - ETA: 21s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.1236e-04 - denoise_loss: 0.1192- ETA: 26s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.0149e-04 - denoise_l"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188653). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "184/237 [======================>.......] - ETA: 20s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.0772e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163532). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169273). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "186/237 [======================>.......] - ETA: 19s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.1972e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214422). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "190/237 [=======================>......] - ETA: 18s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.1088e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214464). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "229/237 [===========================>..] - ETA: 3s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.9792e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208378). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.252937). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "231/237 [============================>.] - ETA: 2s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.0187e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.316033). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "233/237 [============================>.] - ETA: 1s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.9842e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177822). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "235/237 [============================>.] - ETA: 0s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.9503e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216202). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.274746). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 95s 401ms/step - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.9490e-04 - denoise_loss: 0.1192 - val_loss: 0.2429 - val_denoiseg: 0.2429 - val_seg_loss: 0.1246 - val_denoise_loss: 0.1183\n",
+      "Epoch 39/200\n",
+      "  2/237 [..............................] - ETA: 1:11 - loss: 0.1228 - denoiseg: 0.1228 - seg_loss: 0.0000e+00 - denoise_loss: 0.1228"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.326819). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  3/237 [..............................] - ETA: 1:22 - loss: 0.1226 - denoiseg: 0.1226 - seg_loss: 0.0000e+00 - denoise_loss: 0.12"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.320587). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.322807). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  5/237 [..............................] - ETA: 1:32 - loss: 0.1209 - denoiseg: 0.1209 - seg_loss: 0.0000e+00 - denoise_loss: 0.1209"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.318581). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  7/237 [..............................] - ETA: 1:33 - loss: 0.1207 - denoiseg: 0.1207 - seg_loss: 7.3951e-05 - denoise_loss: 0.1207"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.314355). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  9/237 [>.............................] - ETA: 1:32 - loss: 0.1207 - denoiseg: 0.1207 - seg_loss: 1.4606e-04 - denoise_loss: 0.1205"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.292318). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 10/237 [>.............................] - ETA: 1:31 - loss: 0.1207 - denoiseg: 0.1207 - seg_loss: 1.4794e-04 - denoise_loss: 0.1205"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.270280). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.264467). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 12/237 [>.............................] - ETA: 1:30 - loss: 0.1205 - denoiseg: 0.1205 - seg_loss: 1.3514e-04 - denoise_loss: 0.1204"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.256560). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.252703). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 14/237 [>.............................] - ETA: 1:26 - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 1.1584e-04 - denoise_loss: 0.1202"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227352). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190190). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/237 [=>............................] - ETA: 1:21 - loss: 0.1209 - denoiseg: 0.1209 - seg_loss: 2.8412e-04 - denoise_loss: 0.1206"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175014). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 21/237 [=>............................] - ETA: 1:21 - loss: 0.1206 - denoiseg: 0.1206 - seg_loss: 2.5276e-04 - denoise_loss: 0.1203"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188587). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 22/237 [=>............................] - ETA: 1:21 - loss: 0.1206 - denoiseg: 0.1206 - seg_loss: 2.4127e-04 - denoise_loss: 0.1204"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198823). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 23/237 [=>............................] - ETA: 1:20 - loss: 0.1206 - denoiseg: 0.1206 - seg_loss: 2.3078e-04 - denoise_loss: 0.1203"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183646). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 27/237 [==>...........................] - ETA: 1:17 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 1.9659e-04 - denoise_loss: 0.1200"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217010). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179263). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 33/237 [===>..........................] - ETA: 1:14 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 3.3658e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173964). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 34/237 [===>..........................] - ETA: 1:14 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.2668e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237421). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 39/237 [===>..........................] - ETA: 1:19 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 2.8528e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228439). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:19 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 2.7814e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205105). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 41/237 [====>.........................] - ETA: 1:18 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 2.9944e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235456). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 44/237 [====>.........................] - ETA: 1:17 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 2.9543e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217038). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201314). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 51/237 [=====>........................] - ETA: 1:13 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.4117e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207016). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 52/237 [=====>........................] - ETA: 1:13 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.3461e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203807). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 53/237 [=====>........................] - ETA: 1:12 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.2829e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218955). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:11 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.1071e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230964). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233253). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 57/237 [======>.......................] - ETA: 1:11 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.3827e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233259). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/237 [======>.......................] - ETA: 1:10 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.3188e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232985). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 64/237 [=======>......................] - ETA: 1:08 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.3115e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184275). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215017). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 65/237 [=======>......................] - ETA: 1:07 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2605e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190577). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 68/237 [=======>......................] - ETA: 1:06 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.2936e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184181). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/237 [========>.....................] - ETA: 1:04 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.1328e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179843). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 1:03 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.2238e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180750). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 76/237 [========>.....................] - ETA: 1:03 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.1814e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201586). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 81/237 [=========>....................] - ETA: 1:01 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2327e-04 - denoise_loss: 0.1194 ETA: 1:01 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.2278e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227251). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 82/237 [=========>....................] - ETA: 1:00 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.1940e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215497). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 83/237 [=========>....................] - ETA: 1:00 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.1555e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192926). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 84/237 [=========>....................] - ETA: 1:00 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.3328e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186890). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 86/237 [=========>....................] - ETA: 59s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2553e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186992). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 88/237 [==========>...................] - ETA: 58s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2279e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197217). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 89/237 [==========>...................] - ETA: 57s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.1916e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229040). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 92/237 [==========>...................] - ETA: 56s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.1738e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230535). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 95/237 [===========>..................] - ETA: 55s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.0736e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231791). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 97/237 [===========>..................] - ETA: 54s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.0110e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230621). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 98/237 [===========>..................] - ETA: 54s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.1914e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230083). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 99/237 [===========>..................] - ETA: 53s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.2109e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229314). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "101/237 [===========>..................] - ETA: 53s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.1828e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204095). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175809). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105/237 [============>.................] - ETA: 51s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.0780e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204864). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "108/237 [============>.................] - ETA: 50s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 2.9925e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194102). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "109/237 [============>.................] - ETA: 49s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.0644e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220561). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "110/237 [============>.................] - ETA: 49s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.0366e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232121). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "112/237 [=============>................] - ETA: 48s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.0610e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232116). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "113/237 [=============>................] - ETA: 48s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.0512e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220545). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 47s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 2.9981e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199076). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183934). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "118/237 [=============>................] - ETA: 46s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 2.9305e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210635). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "120/237 [==============>...............] - ETA: 45s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 2.9991e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153855). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 44s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 2.9259e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143446). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "125/237 [==============>...............] - ETA: 43s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 2.9257e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178931). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "132/237 [===============>..............] - ETA: 41s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 2.9661e-04 - denoise_loss: 0.1194- ETA: 41s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 2.8931e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205446). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "135/237 [================>.............] - ETA: 40s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.0556e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230619). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "136/237 [================>.............] - ETA: 39s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.0331e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223871). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187611). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "139/237 [================>.............] - ETA: 38s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.0052e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175599). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "144/237 [=================>............] - ETA: 36s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.1425e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211811). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 35s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.0789e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166421). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141922). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179/237 [=====================>........] - ETA: 22s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2428e-04 - denoise_loss: 0.1194- ETA: 34s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.16"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152948). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "180/237 [=====================>........] - ETA: 22s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.2553e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147979). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 94s 395ms/step - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.4394e-04 - denoise_loss: 0.1194 - val_loss: 0.2590 - val_denoiseg: 0.2590 - val_seg_loss: 0.1396 - val_denoise_loss: 0.1194\n",
+      "Epoch 40/200\n",
+      " 24/237 [==>...........................] - ETA: 1:07 - loss: 0.1206 - denoiseg: 0.1206 - seg_loss: 1.5974e-04 - denoise_loss: 0.1204"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184602). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 26/237 [==>...........................] - ETA: 1:07 - loss: 0.1204 - denoiseg: 0.1204 - seg_loss: 1.4784e-04 - denoise_loss: 0.1203"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202467). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 28/237 [==>...........................] - ETA: 1:07 - loss: 0.1204 - denoiseg: 0.1204 - seg_loss: 2.5056e-04 - denoise_loss: 0.1201"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138917). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 51/237 [=====>........................] - ETA: 1:09 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 2.7622e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186983). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 53/237 [=====>........................] - ETA: 1:09 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 2.7125e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214212). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 55/237 [=====>........................] - ETA: 1:08 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.3201e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235503). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 56/237 [======>.......................] - ETA: 1:08 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.2608e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.246575). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 61/237 [======>.......................] - ETA: 1:07 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.4277e-04 - denoise_loss: 0.1194 ETA: 1:08 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.1484e-04 - denoise_loss: "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.273718). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 64/237 [=======>......................] - ETA: 1:07 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.3162e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.270579). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 65/237 [=======>......................] - ETA: 1:06 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2652e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231461). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 68/237 [=======>......................] - ETA: 1:05 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.6420e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224486). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208733). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 71/237 [=======>......................] - ETA: 1:04 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.5894e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.181562). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 1:03 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.5100e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.128637). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 1:01 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.3360e-04 - denoise_loss: 0.1195 ETA: 1:02 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.3788e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164440). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 81/237 [=========>....................] - ETA: 1:00 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.2128e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154832). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 88/237 [==========>...................] - ETA: 57s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.3095e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145433). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 92/237 [==========>...................] - ETA: 56s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.4357e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160088). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 55s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.3623e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174680). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 97/237 [===========>..................] - ETA: 53s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.2689e-04 - denoise_loss: 0.119\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192480). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200373). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/237 [===========>..................] - ETA: 52s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.2768e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225832). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "104/237 [============>.................] - ETA: 51s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.2287e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172024). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "107/237 [============>.................] - ETA: 49s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.3561e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178626). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "110/237 [============>.................] - ETA: 48s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2646e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163245). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "113/237 [=============>................] - ETA: 47s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.1779e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184532). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "114/237 [=============>................] - ETA: 47s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.1617e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208243). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 46s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.1780e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230061). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "118/237 [=============>................] - ETA: 45s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.1245e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210720). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "120/237 [==============>...............] - ETA: 45s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.0724e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231602). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "121/237 [==============>...............]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235750). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "122/237 [==============>...............] - ETA: 44s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.4492e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.238469). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236212). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "124/237 [==============>...............] - ETA: 43s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.3936e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.240808). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215330). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "127/237 [===============>..............] - ETA: 42s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.3136e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204097). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227047). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "129/237 [===============>..............] - ETA: 41s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.2868e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236366). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225785). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "130/237 [===============>..............] - ETA: 41s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.2757e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185228). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "136/237 [================>.............] - ETA: 39s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.4248e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147129). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "139/237 [================>.............] - ETA: 37s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.3726e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144885). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "141/237 [================>.............] - ETA: 37s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.3248e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155348). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "143/237 [=================>............] - ETA: 36s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.2783e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187171). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "145/237 [=================>............] - ETA: 35s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2784e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210290). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184313). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "148/237 [=================>............] - ETA: 34s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.3612e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192530). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "149/237 [=================>............] - ETA: 33s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.3387e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169412). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "151/237 [==================>...........] - ETA: 33s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.3770e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143245). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "153/237 [==================>...........] - ETA: 32s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.4587e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151279). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 31s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.4689e-04 - denoise_loss: 0.119\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199691). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "157/237 [==================>...........] - ETA: 30s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.4484e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228176). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "161/237 [===================>..........] - ETA: 29s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.5819e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234614). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "162/237 [===================>..........] - ETA: 28s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.5598e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218484). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "164/237 [===================>..........] - ETA: 28s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.5628e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223549). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "167/237 [====================>.........] - ETA: 26s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.4988e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213870). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "168/237 [====================>.........] - ETA: 26s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.4779e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222205). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "174/237 [=====================>........] - ETA: 24s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.5622e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205561). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 23s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.5355e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180315). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179/237 [=====================>........] - ETA: 22s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.4763e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.136819). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "190/237 [=======================>......] - ETA: 18s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.6789e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168354). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "191/237 [=======================>......] - ETA: 17s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.6597e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212257). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "196/237 [=======================>......] - ETA: 15s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.6548e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196714). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "200/237 [========================>.....] - ETA: 14s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.7175e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204459). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179313). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "202/237 [========================>.....] - ETA: 13s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.6901e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209609). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "203/237 [========================>.....] - ETA: 13s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.6722e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231280). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "206/237 [=========================>....] - ETA: 11s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.6613e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230009). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "208/237 [=========================>....] - ETA: 11s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.6414e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231468). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "209/237 [=========================>....] - ETA: 10s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.6803e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212578). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "211/237 [=========================>....] - ETA: 9s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.7591e-04 - denoise_loss: 0.1194 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172861). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211207). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "215/237 [==========================>...] - ETA: 8s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.7625e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175643). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "216/237 [==========================>...] - ETA: 8s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.7757e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191248). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "219/237 [==========================>...] - ETA: 6s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.8179e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140169). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "236/237 [============================>.] - ETA: 0s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.7056e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142872). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 92s 390ms/step - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.6998e-04 - denoise_loss: 0.1194 - val_loss: 0.2381 - val_denoiseg: 0.2381 - val_seg_loss: 0.1187 - val_denoise_loss: 0.1194\n",
+      "Epoch 41/200\n",
+      " 16/237 [=>............................] - ETA: 1:04 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.9670e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.133297). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/237 [=>............................] - ETA: 1:05 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5262e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146569). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 21/237 [=>............................] - ETA: 1:07 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.0978e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153087). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 22/237 [=>............................] - ETA: 1:07 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.9570e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190877). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 23/237 [=>............................] - ETA: 1:07 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2689e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145296). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 24/237 [==>...........................] - ETA: 1:07 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.1327e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134025). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 27/237 [==>...........................] - ETA: 1:08 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7846e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.137071). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "122/237 [==============>...............] - ETA: 42s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.8792e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187168). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "123/237 [==============>...............] - ETA: 42s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.8477e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207136). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "124/237 [==============>...............] - ETA: 42s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.8166e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230879). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 41s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.8060e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231809). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "129/237 [===============>..............] - ETA: 40s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.7443e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231225). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "131/237 [===============>..............] - ETA: 39s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.7300e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233173). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "133/237 [===============>..............] - ETA: 38s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6752e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234550). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "135/237 [================>.............] - ETA: 38s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6208e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233218). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "139/237 [================>.............] - ETA: 36s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5793e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233641). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "140/237 [================>.............] - ETA: 36s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5537e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232668). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "141/237 [================>.............] - ETA: 35s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5591e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228498). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "143/237 [=================>............] - ETA: 35s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5327e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226525). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219858). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "148/237 [=================>............] - ETA: 33s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4688e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219671). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144845). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 30s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6046e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148963). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "158/237 [===================>..........] - ETA: 29s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6940e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193712). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "159/237 [===================>..........] - ETA: 29s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6962e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182061). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "161/237 [===================>..........] - ETA: 28s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6503e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191899). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "162/237 [===================>..........] - ETA: 28s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.7945e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185766). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "171/237 [====================>.........] - ETA: 24s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6700e-04 - denoise_loss: 0.1189- ETA: 27s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.7255e-04 - denoise_loss: "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189181). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "172/237 [====================>.........] - ETA: 24s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6487e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185954). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "174/237 [=====================>........] - ETA: 23s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6380e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163131). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "178/237 [=====================>........] - ETA: 22s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5563e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144374). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "183/237 [======================>.......] - ETA: 20s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5158e-04 - denoise_loss: 0.1189- ETA: 20s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5351e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169329). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "184/237 [======================>.......] - ETA: 19s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4967e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198476). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "187/237 [======================>.......] - ETA: 18s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4406e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219785). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "192/237 [=======================>......] - ETA: 16s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4655e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223522). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226130). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "194/237 [=======================>......] - ETA: 16s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4396e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222392). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203362). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "195/237 [=======================>......] - ETA: 15s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4329e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188084). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "196/237 [=======================>......] - ETA: 15s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4415e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182854). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "198/237 [========================>.....] - ETA: 14s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4989e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167790). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "199/237 [========================>.....] - ETA: 14s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4813e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142541). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 382ms/step - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5608e-04 - denoise_loss: 0.1190 - val_loss: 0.2433 - val_denoiseg: 0.2433 - val_seg_loss: 0.1251 - val_denoise_loss: 0.1182\n",
+      "Epoch 42/200\n",
+      "  5/237 [..............................] - ETA: 1:01 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 4.5308e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144248). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  6/237 [..............................] - ETA: 1:03 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 9.1912e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230393). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/237 [=>............................] - ETA: 1:02 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 5.2239e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157853). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 21/237 [=>............................] - ETA: 1:04 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.5662e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.131549). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 22/237 [=>............................] - ETA: 1:04 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 4.3586e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180761). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 28/237 [==>...........................] - ETA: 1:06 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 5.0007e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144408). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 30/237 [==>...........................] - ETA: 1:06 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.8283e-04 - denoise_loss: 0.11 - ETA: 1:06 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.6704e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184166). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 33/237 [===>..........................] - ETA: 1:06 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.6468e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198416). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 35/237 [===>..........................] - ETA: 1:06 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.5555e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215730). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 36/237 [===>..........................] - ETA: 1:06 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.4290e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201480). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 38/237 [===>..........................] - ETA: 1:06 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.1959e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160169). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:05 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.5564e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140526). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 45/237 [====>.........................] - ETA: 1:09 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 5.1574e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160791). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 47/237 [====>.........................] - ETA: 1:08 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 5.3624e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194547). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 49/237 [=====>........................] - ETA: 1:08 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 5.3810e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201507). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215376). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 51/237 [=====>........................] - ETA: 1:07 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 5.2441e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218215). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:05 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.7918e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212592). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/237 [======>.......................] - ETA: 1:04 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.8367e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221611). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221396). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 61/237 [======>.......................] - ETA: 1:04 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 5.9412e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222988). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 67/237 [=======>......................] - ETA: 1:02 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 6.1897e-04 - denoise_loss: 0.1189 ETA: 1:03 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 6.4799e-04 - denoise_loss: "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223633). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172997). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 71/237 [=======>......................] - ETA: 1:00 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 6.3489e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214414). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 72/237 [========>.....................] - ETA: 1:00 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 6.2607e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215536). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 59s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 6.4274e-04 - denoise_loss: 0.1189 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183472). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 77/237 [========>.....................] - ETA: 58s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 6.6538e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184893). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 57s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 6.4373e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186067). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188508). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 81/237 [=========>....................] - ETA: 57s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 6.3578e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163316). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 84/237 [=========>....................] - ETA: 56s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 6.2684e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218678). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 94/237 [==========>...................] - ETA: 52s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 5.5634e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157404). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 95/237 [===========>..................] - ETA: 52s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 5.5048e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161480). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 96/237 [===========>..................] - ETA: 52s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 5.4475e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185528). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 97/237 [===========>..................] - ETA: 51s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 5.3913e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204346). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/237 [===========>..................] - ETA: 50s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 5.2447e-04 - denoise_loss: 0.1190- ETA: 50s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 5.2878e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211023). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208653). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "101/237 [===========>..................] - ETA: 50s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 5.1928e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216378). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "103/237 [============>.................] - ETA: 49s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 5.2723e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215717). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "104/237 [============>.................] - ETA: 49s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 5.3525e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203685). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "106/237 [============>.................] - ETA: 48s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 5.2515e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176294). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "108/237 [============>.................] - ETA: 47s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 5.1628e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168561). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "113/237 [=============>................] - ETA: 45s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 5.0160e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198191). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "119/237 [==============>...............] - ETA: 43s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 5.1359e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228938). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194139). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "122/237 [==============>...............] - ETA: 42s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 5.0100e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152138). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "124/237 [==============>...............] - ETA: 41s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.9735e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.137669). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 41s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 5.0107e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196705). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "127/237 [===============>..............] - ETA: 40s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 5.0065e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173101). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "131/237 [===============>..............] - ETA: 39s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.8776e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227497). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "133/237 [===============>..............] - ETA: 38s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.8043e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194802). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "135/237 [================>.............] - ETA: 37s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.7348e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213251). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "136/237 [================>.............] - ETA: 37s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.7092e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185195). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "141/237 [================>.............] - ETA: 35s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.6257e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145724). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "160/237 [===================>..........] - ETA: 28s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.3846e-04 - denoise_loss: 0.1192- ETA: 29s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.3665e-04 - denoise_loss: 0.119 - ETA: 28s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.3390e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172200). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208884). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "161/237 [===================>..........] - ETA: 28s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.3573e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229568). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "164/237 [===================>..........] - ETA: 27s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.2776e-04 - denoise_loss: 0.1192- ETA: 27s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.3039e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235092). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "165/237 [===================>..........] - ETA: 26s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.2757e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232165). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "167/237 [====================>.........] - ETA: 26s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.3070e-04 - denoise_loss: 0.119\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232419). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "169/237 [====================>.........] - ETA: 25s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.3245e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230518). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220086). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "170/237 [====================>.........] - ETA: 24s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.3221e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159276). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "173/237 [====================>.........] - ETA: 23s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.2630e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199190). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "175/237 [=====================>........] - ETA: 23s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.2207e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208637). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "178/237 [=====================>........] - ETA: 21s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.1498e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195716). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "180/237 [=====================>........] - ETA: 21s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.1455e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203893). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "182/237 [======================>.......] - ETA: 20s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.1293e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212398). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "184/237 [======================>.......] - ETA: 19s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.1918e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200294). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176641). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "185/237 [======================>.......] - ETA: 19s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.1692e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188103). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "187/237 [======================>.......] - ETA: 18s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.1499e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196829). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "189/237 [======================>.......] - ETA: 17s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.1315e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184763). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "193/237 [=======================>......] - ETA: 16s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.0929e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171745). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "195/237 [=======================>......] - ETA: 16s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.0951e-04 - denoise_loss: 0.119 - ETA: 15s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.0741e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201759). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "198/237 [========================>.....] - ETA: 14s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.0667e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210047). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "201/237 [========================>.....] - ETA: 13s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.0754e-04 - denoise_loss: 0.1192- ETA: 13s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.0450e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188742). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177557). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "204/237 [========================>.....] - ETA: 12s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.1574e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179321). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "206/237 [=========================>....] - ETA: 11s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.1907e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169376). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "209/237 [=========================>....] - ETA: 10s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.1306e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154888). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "211/237 [=========================>....] - ETA: 9s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.0914e-04 - denoise_loss: 0.1192 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209281). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "213/237 [=========================>....] - ETA: 8s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.1545e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227097). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "215/237 [==========================>...] - ETA: 8s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.1665e-04 - denoise_loss: 0.11 - ETA: 8s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.1471e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225231). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "217/237 [==========================>...] - ETA: 7s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.1916e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227470). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "219/237 [==========================>...] - ETA: 6s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.3250e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231332). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "220/237 [==========================>...] - ETA: 6s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.3530e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233602). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "222/237 [===========================>..] - ETA: 5s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.3307e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229466). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "224/237 [===========================>..] - ETA: 4s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.2925e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234001). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "225/237 [===========================>..] - ETA: 4s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.2734e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.241854). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.244373). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "227/237 [===========================>..] - ETA: 3s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.2505e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237191). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "229/237 [===========================>..] - ETA: 2s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.3345e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234079). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235265). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "231/237 [============================>.] - ETA: 2s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.3297e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226027). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "233/237 [============================>.] - ETA: 1s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.2926e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204223). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "234/237 [============================>.] - ETA: 1s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.2742e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185723). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 90s 381ms/step - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.2357e-04 - denoise_loss: 0.1193 - val_loss: 0.2377 - val_denoiseg: 0.2377 - val_seg_loss: 0.1195 - val_denoise_loss: 0.1182\n",
+      "Epoch 43/200\n",
+      "  4/237 [..............................] - ETA: 52s - loss: 0.1221 - denoiseg: 0.1221 - seg_loss: 8.4295e-04 - denoise_loss: 0.1212"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157378). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  6/237 [..............................] - ETA: 1:06 - loss: 0.1208 - denoiseg: 0.1208 - seg_loss: 5.6325e-04 - denoise_loss: 0.1203"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.239316). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154176). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 50/237 [=====>........................] - ETA: 1:07 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.7869e-04 - denoise_loss: 0.1193 ETA: 1:05 - loss: 0.1195 - denoiseg: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163219). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 52/237 [=====>........................] - ETA: 1:07 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.3055e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188581). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207887). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 53/237 [=====>........................] - ETA: 1:06 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.2243e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217419). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 55/237 [=====>........................] - ETA: 1:06 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.4045e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213368). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 58/237 [======>.......................] - ETA: 1:05 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.1824e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209656). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/237 [======>.......................] - ETA: 1:05 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.1488e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219188). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 60/237 [======>.......................] - ETA: 1:05 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.0796e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232573). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 62/237 [======>.......................] - ETA: 1:04 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.4852e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220173). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 63/237 [======>.......................] - ETA: 1:04 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.5747e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216122). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 65/237 [=======>......................] - ETA: 1:03 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.4340e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206711). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 67/237 [=======>......................] - ETA: 1:03 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.4413e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182277). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144133). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 72/237 [========>.....................] - ETA: 1:01 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.6154e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172659). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 73/237 [========>.....................] - ETA: 1:00 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.5522e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205413). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 1:00 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.4868e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212817). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232042). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 76/237 [========>.....................] - ETA: 59s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.4278e-04 - denoise_loss: 0.1192 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232138). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 81/237 [=========>....................] - ETA: 58s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.3878e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223786). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204729). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 83/237 [=========>....................] - ETA: 57s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.3006e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186364). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170698). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 85/237 [=========>....................] - ETA: 56s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.3396e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.130741). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "128/237 [===============>..............] - ETA: 40s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9486e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165286). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "130/237 [===============>..............] - ETA: 39s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.8878e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206489). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "131/237 [===============>..............] - ETA: 39s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.8983e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217842). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "135/237 [================>.............] - ETA: 38s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.8954e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190048). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "137/237 [================>.............] - ETA: 37s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.8385e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199800). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "139/237 [================>.............] - ETA: 36s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7999e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186073). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "142/237 [================>.............] - ETA: 35s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.8514e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.181901). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191653). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "143/237 [=================>............] - ETA: 35s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9873e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212236). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "145/237 [=================>............] - ETA: 34s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0694e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213106). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234779). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "146/237 [=================>............] - ETA: 34s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0415e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234641). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "148/237 [=================>............] - ETA: 33s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9873e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224111). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "150/237 [=================>............] - ETA: 32s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9345e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234012). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "153/237 [==================>...........] - ETA: 31s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.8582e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225388). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 30s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9054e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222970). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "156/237 [==================>...........] - ETA: 30s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.8803e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222758). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219722). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "160/237 [===================>..........] - ETA: 28s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9583e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225064). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "161/237 [===================>..........] - ETA: 28s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.1221e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227746). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "163/237 [===================>..........] - ETA: 27s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0716e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233514). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "164/237 [===================>..........] - ETA: 27s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0619e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237819). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "168/237 [====================>.........] - ETA: 25s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9812e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235437). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "169/237 [====================>.........] - ETA: 25s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9758e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233575). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "171/237 [====================>.........] - ETA: 24s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0564e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230510). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "173/237 [====================>.........] - ETA: 24s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0515e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229505). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202665). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 22s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9824e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144792). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 21s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0526e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143595). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "184/237 [======================>.......] - ETA: 19s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0546e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187197). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202789). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "186/237 [======================>.......] - ETA: 19s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0110e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224657). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "190/237 [=======================>......] - ETA: 17s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9347e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223764). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "192/237 [=======================>......] - ETA: 16s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.8940e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197726). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "195/237 [=======================>......] - ETA: 15s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.8341e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192068). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "198/237 [========================>.....] - ETA: 14s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.7968e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210929). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "199/237 [========================>.....] - ETA: 14s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.7932e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189949). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "201/237 [========================>.....] - ETA: 13s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.7554e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198065). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "202/237 [========================>.....] - ETA: 13s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.7369e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177229). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "209/237 [=========================>....] - ETA: 10s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.8151e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.130199). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170537). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "211/237 [=========================>....] - ETA: 9s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.8404e-04 - denoise_loss: 0.1188 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145499). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "214/237 [==========================>...] - ETA: 8s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.8041e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182417). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "220/237 [==========================>...] - ETA: 6s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7339e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157906). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151810). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "221/237 [==========================>...] - ETA: 6s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7318e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143604). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "228/237 [===========================>..] - ETA: 3s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6734e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138158). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "232/237 [============================>.] - ETA: 1s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7307e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200656). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 382ms/step - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.7408e-04 - denoise_loss: 0.1190 - val_loss: 0.2399 - val_denoiseg: 0.2399 - val_seg_loss: 0.1214 - val_denoise_loss: 0.1185\n",
+      "Epoch 44/200\n",
+      "  2/237 [..............................] - ETA: 1:01 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 0.0012 - denoise_loss: 0.1172"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237353). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  5/237 [..............................] - ETA: 59s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 5.7788e-04 - denoise_loss: 0.1187- ETA: 52s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 7.2235e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165415). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 22/237 [=>............................] - ETA: 1:04 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.0797e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146075). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 25/237 [==>...........................] - ETA: 1:05 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.0961e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145349). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 27/237 [==>...........................] - ETA: 1:06 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.0994e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225674). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 28/237 [==>...........................] - ETA: 1:06 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 2.9887e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231257). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 31/237 [==>...........................] - ETA: 1:06 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.8045e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232629). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 34/237 [===>..........................] - ETA: 1:06 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.6105e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230603). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 35/237 [===>..........................] - ETA: 1:06 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.5387e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231515). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 36/237 [===>..........................] - ETA: 1:06 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.4682e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231974). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 38/237 [===>..........................] - ETA: 1:07 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.4015e-04 - denoise_loss: 0.11 - ETA: 1:06 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.4359e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233275). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:06 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.5236e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232528). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 43/237 [====>.........................] - ETA: 1:05 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.9546e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234575). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:06 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 2.7520e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172566). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 58/237 [======>.......................] - ETA: 1:05 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.6721e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218163). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162338). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 59/237 [======>.......................] - ETA: 1:05 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.6268e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177379). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 62/237 [======>.......................] - ETA: 1:04 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.2486e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221866). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 63/237 [======>.......................] - ETA: 1:04 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.1970e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179199). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 65/237 [=======>......................] - ETA: 1:03 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.5551e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187921). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 66/237 [=======>......................] - ETA: 1:03 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.5012e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177981). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 68/237 [=======>......................] - ETA: 1:02 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.3982e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157502). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 72/237 [========>.....................] - ETA: 1:01 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.2666e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201676). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 1:00 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.2907e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214280). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 76/237 [========>.....................] - ETA: 59s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.3419e-04 - denoise_loss: 0.1193 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221826). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 79/237 [=========>....................] - ETA: 58s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.4925e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221160). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 81/237 [=========>....................] - ETA: 58s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.6430e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202793). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173588). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 84/237 [=========>....................] - ETA: 56s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.5341e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161173). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 88/237 [==========>...................] - ETA: 55s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.5889e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171140). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183555). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 90/237 [==========>...................] - ETA: 54s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.5343e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207519). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199102). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 92/237 [==========>...................] - ETA: 54s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.4876e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216007). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 94/237 [==========>...................] - ETA: 53s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.4509e-04 - denoise_loss: 0.119 - ETA: 53s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.4142e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192043). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195227). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 98/237 [===========>..................] - ETA: 51s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.3126e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188340). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166711). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/237 [===========>..................] - ETA: 51s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.2784e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138554). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "103/237 [============>.................] - ETA: 50s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.3121e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153350). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "138/237 [================>.............] - ETA: 37s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.1905e-04 - denoise_loss: 0.1191- ETA: 42s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.9812e-04 - denoi"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159989). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "144/237 [=================>............] - ETA: 34s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.2062e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142569). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 90s 381ms/step - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.7400e-04 - denoise_loss: 0.1191 - val_loss: 0.2440 - val_denoiseg: 0.2440 - val_seg_loss: 0.1239 - val_denoise_loss: 0.1201\n",
+      "Epoch 45/200\n",
+      " 56/237 [======>.......................] - ETA: 1:05 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6738e-04 - denoise_loss: 0.1186 ETA: 1:05 - loss: 0.1189 - denoiseg: 0.1189 - seg_l"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187403). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201218). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 57/237 [======>.......................] - ETA: 1:05 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.7557e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212183). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 60/237 [======>.......................] - ETA: 1:04 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6228e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216174). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 61/237 [======>.......................] - ETA: 1:04 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6200e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220608). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 65/237 [=======>......................] - ETA: 1:02 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7042e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206817). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 67/237 [=======>......................] - ETA: 1:02 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6199e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209008). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210393). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 69/237 [=======>......................] - ETA: 1:01 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.9810e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231289). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/237 [========>.....................] - ETA: 1:00 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.3607e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225488). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 74/237 [========>.....................] - ETA: 59s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.3749e-04 - denoise_loss: 0.1186 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224577). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 76/237 [========>.....................] - ETA: 58s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.2809e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224441). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 77/237 [========>.....................] - ETA: 58s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.2254e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196020). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 57s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0669e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174424). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198238). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 83/237 [=========>....................] - ETA: 56s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9285e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202245). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 85/237 [=========>....................] - ETA: 55s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0123e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201991). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 97/237 [===========>..................] - ETA: 51s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0575e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155018). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173304). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/237 [===========>..................] - ETA: 50s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0502e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189803). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "102/237 [===========>..................] - ETA: 49s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9713e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215063). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224401). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105/237 [============>.................] - ETA: 48s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9043e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225181). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "106/237 [============>.................] - ETA: 48s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.8886e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226143). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "109/237 [============>.................] - ETA: 47s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9829e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228572). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "112/237 [=============>................] - ETA: 46s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.1246e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222190). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 45s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0174e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202406). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "118/237 [=============>................] - ETA: 44s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9468e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189318). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "119/237 [==============>...............] - ETA: 43s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9137e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159442). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "148/237 [=================>............] - ETA: 33s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6107e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155650). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "151/237 [==================>...........] - ETA: 31s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5389e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156392). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "153/237 [==================>...........] - ETA: 31s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5066e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158294). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189491). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "154/237 [==================>...........] - ETA: 30s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4838e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203842). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "156/237 [==================>...........] - ETA: 30s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5510e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223275). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "159/237 [===================>..........] - ETA: 28s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5776e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227483). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "161/237 [===================>..........] - ETA: 28s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5336e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228323). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207973). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "172/237 [====================>.........] - ETA: 24s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5955e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158805). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "174/237 [=====================>........] - ETA: 23s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5704e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185680). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "177/237 [=====================>........] - ETA: 22s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.6036e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193655). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "180/237 [=====================>........] - ETA: 21s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5802e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177481). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169506). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "187/237 [======================>.......] - ETA: 18s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5235e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192557). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190222). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "189/237 [======================>.......] - ETA: 17s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4862e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215127). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "190/237 [=======================>......] - ETA: 17s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4681e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214149). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226379). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "191/237 [=======================>......] - ETA: 17s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4499e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227918). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "193/237 [=======================>......] - ETA: 16s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5900e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226940). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "194/237 [=======================>......] - ETA: 16s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5716e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229685). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "197/237 [=======================>......] - ETA: 14s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6271e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226021). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "198/237 [========================>.....] - ETA: 14s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6806e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223715). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "199/237 [========================>.....] - ETA: 14s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7517e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216437). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "203/237 [========================>.....] - ETA: 12s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7420e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196951). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "206/237 [=========================>....] - ETA: 11s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7407e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211783). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "208/237 [=========================>....] - ETA: 10s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7108e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215495). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "210/237 [=========================>....] - ETA: 10s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7820e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197887). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 90s 380ms/step - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5416e-04 - denoise_loss: 0.1190 - val_loss: 0.2423 - val_denoiseg: 0.2423 - val_seg_loss: 0.1219 - val_denoise_loss: 0.1204\n",
+      "Epoch 46/200\n",
+      " 18/237 [=>............................] - ETA: 1:05 - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 3.3237e-04 - denoise_loss: 0.1200"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166167). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 19/237 [=>............................] - ETA: 1:05 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 3.1487e-04 - denoise_loss: 0.1199"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213148). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 21/237 [=>............................] - ETA: 1:07 - loss: 0.1205 - denoiseg: 0.1205 - seg_loss: 5.8013e-04 - denoise_loss: 0.1200"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230534). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182792). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 23/237 [=>............................] - ETA: 1:07 - loss: 0.1204 - denoiseg: 0.1204 - seg_loss: 5.3165e-04 - denoise_loss: 0.1199"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230523). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 25/237 [==>...........................] - ETA: 1:08 - loss: 0.1205 - denoiseg: 0.1205 - seg_loss: 4.9323e-04 - denoise_loss: 0.1200"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231164). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150249). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 58/237 [======>.......................] - ETA: 1:07 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.4063e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191148). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 60/237 [======>.......................] - ETA: 1:07 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.3369e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237885). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 66/237 [=======>......................] - ETA: 1:06 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.0555e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.248413). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 68/237 [=======>......................] - ETA: 1:05 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 2.9656e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.259440). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227106). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 71/237 [=======>......................] - ETA: 1:05 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 2.9223e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.257896). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/237 [========>.....................] - ETA: 1:04 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.0955e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.258974). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 74/237 [========>.....................] - ETA: 1:04 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.0540e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.260697). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.280500). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 76/237 [========>.....................] - ETA: 1:03 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.2624e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.282818). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 77/237 [========>.....................] - ETA: 1:03 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.2560e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.281095). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 79/237 [=========>....................] - ETA: 1:02 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.4467e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.305733). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 80/237 [=========>....................] - ETA: 1:02 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.4036e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.302500). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 81/237 [=========>....................] - ETA: 1:02 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.3628e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.303931). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 85/237 [=========>....................] - ETA: 1:01 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.4246e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.241410). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 87/237 [==========>...................] - ETA: 1:00 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.4387e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.270163). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 88/237 [==========>...................] - ETA: 1:00 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.4503e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.263142). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 90/237 [==========>...................] - ETA: 59s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.4764e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.281765). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 58s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.9539e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.258712). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 94/237 [==========>...................] - ETA: 58s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0897e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.277799). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 98/237 [===========>..................] - ETA: 56s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0765e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.276583). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/237 [===========>..................] - ETA: 56s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0619e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.263903). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "101/237 [===========>..................] - ETA: 55s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0216e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.277048). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105/237 [============>.................] - ETA: 54s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.1040e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.266656). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "106/237 [============>.................] - ETA: 54s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.1752e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.240437). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "109/237 [============>.................] - ETA: 53s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0979e-04 - denoise_loss: 0.119 - ETA: 52s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0603e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197662). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "113/237 [=============>................] - ETA: 51s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.9379e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183828). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "114/237 [=============>................] - ETA: 50s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.9034e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208303). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 49s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.9696e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.249124). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "119/237 [==============>...............] - ETA: 49s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.9363e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.253347). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.258199). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " - ETA: 49s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.9032e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.261353). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "122/237 [==============>...............] - ETA: 48s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.8390e-04 - denoise_loss: 0.119 - ETA: 47s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.9656e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.253458). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 46s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0367e-04 - denoise_loss: 0.1194- ETA: 46s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0689e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.256086). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.261867). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "128/237 [===============>..............] - ETA: 46s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0049e-04 - denoise_loss: 0.119 - ETA: 45s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.9736e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.257126). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "130/237 [===============>..............] - ETA: 44s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0393e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.252205). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.257986). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "133/237 [===============>..............] - ETA: 43s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0540e-04 - denoise_loss: 0.1194- ETA: 44s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.0847e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.249229). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "134/237 [===============>..............] - ETA: 43s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0238e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.267185). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "136/237 [================>.............] - ETA: 42s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.9801e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.250262). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "140/237 [================>.............] - ETA: 40s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.8772e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.246425). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "141/237 [================>.............] - ETA: 40s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.8500e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.264381). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "142/237 [================>.............] - ETA: 40s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.8229e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.257342). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "144/237 [=================>............] - ETA: 39s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.7913e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.260898). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "145/237 [=================>............] - ETA: 38s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.7651e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.251014). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "148/237 [=================>............] - ETA: 37s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.6888e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228355). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "153/237 [==================>...........] - ETA: 35s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.7533e-04 - denoise_loss: 0.1194- ETA: 36s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.7516e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168499). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 34s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.7903e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213320). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.245838). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "159/237 [===================>..........] - ETA: 33s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.8283e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.261589). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "160/237 [===================>..........] - ETA: 32s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.8044e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.259029). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "161/237 [===================>..........] - ETA: 32s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.7919e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.252460). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "162/237 [===================>..........] - ETA: 31s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.8759e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.247629). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "171/237 [====================>.........] - ETA: 28s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.8293e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.243148). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "174/237 [=====================>........] - ETA: 26s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.9234e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.241933). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.242736). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 26s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.8789e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.240083). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 24s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.9056e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.243821). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "182/237 [======================>.......] - ETA: 23s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.8627e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.270447). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.242384). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "183/237 [======================>.......] - ETA: 23s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.9973e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.239808). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "186/237 [======================>.......] - ETA: 21s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.9338e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.248458). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "190/237 [=======================>......] - ETA: 20s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.8596e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.272784). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.275887). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "192/237 [=======================>......] - ETA: 19s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.8197e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.255711). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "193/237 [=======================>......] - ETA: 18s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.7999e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.277807). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "196/237 [=======================>......] - ETA: 17s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.7824e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.272962). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "198/237 [========================>.....] - ETA: 16s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.7976e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.259297). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.265218). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "202/237 [========================>.....] - ETA: 15s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.8012e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.253797). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.245308). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "205/237 [========================>.....] - ETA: 13s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.7457e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.249478). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "207/237 [=========================>....] - ETA: 12s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.7386e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227602). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207312). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "209/237 [=========================>....] - ETA: 12s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.7142e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206760). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "210/237 [=========================>....] - ETA: 11s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.6966e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213663). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "217/237 [==========================>...] - ETA: 8s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.7223e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186473). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "218/237 [==========================>...] - ETA: 8s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.7052e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221665). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165391). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "226/237 [===========================>..] - ETA: 4s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.7342e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174730). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "230/237 [============================>.] - ETA: 3s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.7081e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231314). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "236/237 [============================>.] - ETA: 0s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.7484e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148348). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 103s 433ms/step - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.7328e-04 - denoise_loss: 0.1193 - val_loss: 0.2367 - val_denoiseg: 0.2367 - val_seg_loss: 0.1184 - val_denoise_loss: 0.1183\n",
+      "Epoch 47/200\n",
+      "  4/237 [..............................] - ETA: 1:16 - loss: 0.1212 - denoiseg: 0.1212 - seg_loss: 2.7457e-04 - denoise_loss: 0.1209"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.241400). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.244206). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  6/237 [..............................] - ETA: 1:20 - loss: 0.1206 - denoiseg: 0.1206 - seg_loss: 2.0837e-04 - denoise_loss: 0.1204"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.246718). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.244059). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  8/237 [>.............................] - ETA: 1:21 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 2.0230e-04 - denoise_loss: 0.1199"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236974). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 12/237 [>.............................] - ETA: 1:21 - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 1.9033e-04 - denoise_loss: 0.1201"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.239633). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 14/237 [>.............................] - ETA: 1:21 - loss: 0.1205 - denoiseg: 0.1205 - seg_loss: 1.6314e-04 - denoise_loss: 0.1203"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231762). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/237 [=>............................] - ETA: 1:20 - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 1.4367e-04 - denoise_loss: 0.1201"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221332). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.238653). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 21/237 [=>............................] - ETA: 1:20 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 1.2339e-04 - denoise_loss: 0.1201"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227482). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200806). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 27/237 [==>...........................] - ETA: 1:11 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 3.0982e-04 - denoise_loss: 0.1199"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143543). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 36/237 [===>..........................] - ETA: 1:07 - loss: 0.1204 - denoiseg: 0.1204 - seg_loss: 4.0926e-04 - denoise_loss: 0.1200"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201672). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 37/237 [===>..........................] - ETA: 1:07 - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 3.9820e-04 - denoise_loss: 0.1199"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218421). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237695). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:07 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.6856e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215545). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 42/237 [====>.........................] - ETA: 1:05 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.5101e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179522). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161640). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 43/237 [====>.........................] - ETA: 1:05 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.8600e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178389). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 45/237 [====>.........................] - ETA: 1:04 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.9588e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178012). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150292). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:04 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.7082e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142916). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 58/237 [======>.......................] - ETA: 1:04 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.5920e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160372). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186599). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196131). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 60/237 [======>.......................] - ETA: 1:03 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.7216e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215130). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 63/237 [======>.......................] - ETA: 1:03 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.8288e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231739). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 64/237 [=======>......................] - ETA: 1:02 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.7469e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233442). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 66/237 [=======>......................] - ETA: 1:01 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.7405e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231086). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 68/237 [=======>......................] - ETA: 1:01 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.6305e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229307). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 70/237 [=======>......................] - ETA: 1:00 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.5268e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208377). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229023). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/237 [========>.....................] - ETA: 59s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.6524e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203139). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 58s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.5550e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173248). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 57s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.5150e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166280). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 81/237 [=========>....................] - ETA: 56s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.4957e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196925). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 88/237 [==========>...................] - ETA: 54s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.2453e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165865). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 91/237 [==========>...................] - ETA: 53s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.1383e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167775). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 92/237 [==========>...................] - ETA: 53s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.1042e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170644). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 95/237 [===========>..................] - ETA: 52s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.2199e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173057). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 97/237 [===========>..................] - ETA: 51s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.3061e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197680). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222368). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 98/237 [===========>..................] - ETA: 50s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.2939e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220761). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105/237 [============>.................] - ETA: 48s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5227e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197988). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "107/237 [============>.................] - ETA: 47s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.4810e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172558). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "109/237 [============>.................] - ETA: 47s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5251e-04 - denoise_loss: 0.119\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198676). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "111/237 [=============>................] - ETA: 46s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.4625e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215951). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226499). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "114/237 [=============>................] - ETA: 45s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.4079e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226847). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 44s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.3362e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201588). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "118/237 [=============>................] - ETA: 43s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.3703e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187232). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "119/237 [==============>...............] - ETA: 43s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.3749e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160466). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "130/237 [===============>..............] - ETA: 40s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5156e-04 - denoise_loss: 0.118 - ETA: 39s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4886e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183579). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "131/237 [===============>..............] - ETA: 39s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4619e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220124). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "135/237 [================>.............] - ETA: 37s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5945e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186568). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "207/237 [=========================>....] - ETA: 11s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.5699e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135047). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "209/237 [=========================>....] - ETA: 10s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.5357e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148887). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "230/237 [============================>.] - ETA: 2s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6370e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169210). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "232/237 [============================>.] - ETA: 1s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.7047e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182658). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "233/237 [============================>.] - ETA: 1s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6888e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135809). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 90s 379ms/step - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7991e-04 - denoise_loss: 0.1189 - val_loss: 0.2326 - val_denoiseg: 0.2326 - val_seg_loss: 0.1145 - val_denoise_loss: 0.1181\n",
+      "Epoch 48/200\n",
+      "  2/237 [..............................] - ETA: 56s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 6.6112e-05 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182598). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  3/237 [..............................] - ETA: 1:07 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.4074e-05 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195554). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  4/237 [..............................] - ETA: 1:12 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3056e-05 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208510). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 16/237 [=>............................] - ETA: 1:11 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.5891e-04 - denoise_loss: 0.1187 ETA: 1:03 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 1.3202e-04 - "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155695). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/237 [=>............................] - ETA: 1:11 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.1631e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168026). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 20/237 [=>............................] - ETA: 1:09 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9641e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225979). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 22/237 [=>............................] - ETA: 1:11 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.2059e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230405). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 23/237 [=>............................] - ETA: 1:12 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.0231e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225705). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 25/237 [==>...........................] - ETA: 1:13 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.7744e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235321). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 31/237 [==>...........................] - ETA: 1:15 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.1484e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163875). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:14 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.5273e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188880). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 60/237 [======>.......................] - ETA: 1:11 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.5110e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208659). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199253). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 64/237 [=======>......................] - ETA: 1:10 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.7862e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204176). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 66/237 [=======>......................] - ETA: 1:09 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.8887e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194444). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 69/237 [=======>......................] - ETA: 1:07 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.6992e-04 - denoise_loss: 0.1189 ETA: 1:08 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.7683e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217008). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 72/237 [========>.....................] - ETA: 1:06 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.5405e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215114). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 73/237 [========>.....................] - ETA: 1:05 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.6625e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205382). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 1:04 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.5382e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142741). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 82/237 [=========>....................] - ETA: 1:01 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.2044e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176614). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 84/237 [=========>....................] - ETA: 1:00 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.1043e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226204). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220903). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 85/237 [=========>....................] - ETA: 1:00 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0611e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225976). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 89/237 [==========>...................] - ETA: 58s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9159e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221270). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205389). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 91/237 [==========>...................] - ETA: 57s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.8298e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220819). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 94/237 [==========>...................] - ETA: 56s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7130e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217657). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206850). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 95/237 [===========>..................] - ETA: 56s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6739e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166851). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 97/237 [===========>..................] - ETA: 55s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.8119e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218210). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 99/237 [===========>..................] - ETA: 54s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7349e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222280). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "102/237 [===========>..................] - ETA: 52s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6620e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178211). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.124759). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105/237 [============>.................] - ETA: 51s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6087e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158234). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171831). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "107/237 [============>.................] - ETA: 50s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.6917e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168603). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "108/237 [============>.................] - ETA: 50s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6905e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138355). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 46s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7128e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147112). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "121/237 [==============>...............] - ETA: 45s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7106e-04 - denoise_loss: 0.119\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197408). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 44s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.8268e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215006). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "127/237 [===============>..............] - ETA: 42s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7507e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190331). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "128/237 [===============>..............] - ETA: 42s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7269e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208164). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "130/237 [===============>..............] - ETA: 41s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7812e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140693). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "132/237 [===============>..............] - ETA: 40s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7239e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147934). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "134/237 [===============>..............] - ETA: 39s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6688e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173848). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "135/237 [================>.............] - ETA: 39s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6423e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197572). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "139/237 [================>.............] - ETA: 37s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5703e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198740). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "140/237 [================>.............] - ETA: 37s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5448e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209155). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "141/237 [================>.............] - ETA: 37s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5411e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220068). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "146/237 [=================>............] - ETA: 35s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4595e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191191). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "170/237 [====================>.........] - ETA: 25s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.7539e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208531). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "172/237 [====================>.........] - ETA: 24s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7106e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230479). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 23s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6323e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230933). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "178/237 [=====================>........] - ETA: 22s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5956e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227239). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "179/237 [=====================>........] - ETA: 22s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5755e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225262). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 21s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5976e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215812). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "182/237 [======================>.......] - ETA: 21s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5778e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217815). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "184/237 [======================>.......] - ETA: 20s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6084e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229805). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "186/237 [======================>.......] - ETA: 19s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6012e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228920). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "187/237 [======================>.......] - ETA: 19s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5885e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217666). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "189/237 [======================>.......] - ETA: 18s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6277e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219322). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "192/237 [=======================>......] - ETA: 17s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6025e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190242). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "196/237 [=======================>......] - ETA: 15s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5418e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219547). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "197/237 [=======================>......] - ETA: 15s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5238e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228210). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "198/237 [========================>.....] - ETA: 14s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5060e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232238). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "203/237 [========================>.....] - ETA: 12s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5442e-04 - denoise_loss: 0.1189- ETA: 13s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5788e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229206). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "204/237 [========================>.....] - ETA: 12s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5268e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226390). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "206/237 [=========================>....] - ETA: 11s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5168e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228675). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "207/237 [=========================>....] - ETA: 11s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5000e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231740). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "208/237 [=========================>....] - ETA: 11s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4831e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231663). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "211/237 [=========================>....] - ETA: 9s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4462e-04 - denoise_loss: 0.1189 - ETA: 10s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4627e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225097). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "213/237 [=========================>....] - ETA: 9s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4392e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211291). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "216/237 [==========================>...] - ETA: 8s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4090e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199473). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191708). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "218/237 [==========================>...] - ETA: 7s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.3781e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187104). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "222/237 [===========================>..] - ETA: 5s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.3622e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194501). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "223/237 [===========================>..] - ETA: 5s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.3471e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201259). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "228/237 [===========================>..] - ETA: 3s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.2742e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202848). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "229/237 [===========================>..] - ETA: 3s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.3406e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185052). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "232/237 [============================>.] - ETA: 1s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.3006e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189696). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "234/237 [============================>.] - ETA: 1s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.2724e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214709). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "236/237 [============================>.] - ETA: 0s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.2446e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207412). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175523). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 92s 387ms/step - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.2856e-04 - denoise_loss: 0.1189 - val_loss: 0.2355 - val_denoiseg: 0.2355 - val_seg_loss: 0.1171 - val_denoise_loss: 0.1184\n",
+      "Epoch 49/200\n",
+      " 25/237 [==>...........................] - ETA: 1:06 - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 3.3829e-04 - denoise_loss: 0.1199"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157282). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 27/237 [==>...........................] - ETA: 1:07 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.2044e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134799). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 29/237 [==>...........................] - ETA: 1:07 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 2.9834e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184925). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 32/237 [===>..........................] - ETA: 1:07 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.3634e-04 - denoise_loss: 0.1196 ETA: 1:07 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.4070e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140819). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 34/237 [===>..........................] - ETA: 1:07 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.9897e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194576). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 37/237 [===>..........................] - ETA: 1:06 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.9893e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208575). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 38/237 [===>..........................] - ETA: 1:06 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.8843e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199978). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:06 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.6901e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221644). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 42/237 [====>.........................] - ETA: 1:06 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.9268e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188059). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 43/237 [====>.........................] - ETA: 1:05 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.8355e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179269). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 46/237 [====>.........................] - ETA: 1:05 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.1327e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173520). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 48/237 [=====>........................] - ETA: 1:04 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.5561e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161471). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 53/237 [=====>........................] - ETA: 1:05 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.1529e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187950). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 55/237 [=====>........................] - ETA: 1:04 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.0019e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212599). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221393). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 57/237 [======>.......................] - ETA: 1:04 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.1224e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226738). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 58/237 [======>.......................] - ETA: 1:04 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.0513e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226925). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228871). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 60/237 [======>.......................] - ETA: 1:03 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.9256e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230182). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 62/237 [======>.......................] - ETA: 1:02 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.4293e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229982). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 63/237 [======>.......................] - ETA: 1:02 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.3590e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227799). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 66/237 [=======>......................] - ETA: 1:01 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.4722e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228978). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 69/237 [=======>......................] - ETA: 1:00 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.5146e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224408). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 70/237 [=======>......................] - ETA: 1:00 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.5973e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198501). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 59s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.4818e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169013). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 75/237 [========>.....................] - ETA: 58s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.4221e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172191). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 57s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.5688e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208676). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 82/237 [=========>....................] - ETA: 56s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.6218e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215974). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 84/237 [=========>....................] - ETA: 55s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.5117e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222159). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 85/237 [=========>....................] - ETA: 55s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.4587e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221928). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 88/237 [==========>...................] - ETA: 54s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.4281e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221115). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215161). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 90/237 [==========>...................] - ETA: 53s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.3528e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213278). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 91/237 [==========>...................] - ETA: 53s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.3998e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206869). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 92/237 [==========>...................] - ETA: 52s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.4925e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211603). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 93/237 [==========>...................] - ETA: 52s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.5567e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201200). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 96/237 [===========>..................] - ETA: 51s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.4368e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190534). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 98/237 [===========>..................] - ETA: 50s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.5487e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194574). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205240). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/237 [===========>..................] - ETA: 50s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.4696e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210281). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208672). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "104/237 [============>.................] - ETA: 48s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.3823e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214396). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205301). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "105/237 [============>.................] - ETA: 48s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.3658e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209703). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215508). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "107/237 [============>.................] - ETA: 47s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.3005e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220745). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "108/237 [============>.................] - ETA: 47s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.2607e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221404). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "110/237 [============>.................] - ETA: 46s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.1832e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221358). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224655). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "113/237 [=============>................] - ETA: 45s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.1171e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224821). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 44s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.2380e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223362). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "118/237 [=============>................] - ETA: 43s - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 4.2043e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201101). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "119/237 [==============>...............] - ETA: 43s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.1690e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177620). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "120/237 [==============>...............] - ETA: 42s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.1415e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167173). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "121/237 [==============>...............] - ETA: 42s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.1073e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144251). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "124/237 [==============>...............] - ETA: 41s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.2587e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169566). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 40s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.2984e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150965). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "132/237 [===============>..............] - ETA: 38s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.1346e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208436). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "134/237 [===============>..............] - ETA: 37s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.1805e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171504). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "135/237 [================>.............] - ETA: 37s - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.1495e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195983). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194942). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "137/237 [================>.............] - ETA: 36s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.1866e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.133211). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "150/237 [=================>............] - ETA: 32s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.1719e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.131064). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166929). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "152/237 [==================>...........] - ETA: 31s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.1179e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188365). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184211). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "157/237 [==================>...........] - ETA: 29s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.1574e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190161). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "158/237 [===================>..........] - ETA: 29s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.1311e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209957). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "160/237 [===================>..........] - ETA: 28s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0794e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211021). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "162/237 [===================>..........] - ETA: 27s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0291e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186008). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165974). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "163/237 [===================>..........] - ETA: 27s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.1003e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141757). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179/237 [=====================>........] - ETA: 21s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.1982e-04 - denoise_loss: 0.1194- ETA: 22s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.1625e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188900). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215354). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 20s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.1520e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215355). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "184/237 [======================>.......] - ETA: 19s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.1092e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213878). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "185/237 [======================>.......] - ETA: 19s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0870e-04 - denoise_loss: 0.119\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203768). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "189/237 [======================>.......] - ETA: 17s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.0005e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188955). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "190/237 [=======================>......] - ETA: 17s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.9794e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147854). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "192/237 [=======================>......] - ETA: 16s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.9380e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196388). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "195/237 [=======================>......] - ETA: 15s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.8848e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170102). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 89s 377ms/step - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.7569e-04 - denoise_loss: 0.1192 - val_loss: 0.2461 - val_denoiseg: 0.2461 - val_seg_loss: 0.1278 - val_denoise_loss: 0.1183\n",
+      "Epoch 50/200\n",
+      "  2/237 [..............................] - ETA: 1:00 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 0.0000e+00 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220248). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222680). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  5/237 [..............................] - ETA: 1:04 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 0.0000e+00 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208396). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196544). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 17/237 [=>............................] - ETA: 1:01 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 1.5113e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173827). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " - ETA: 1:02 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 2.3800e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199490). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 19/237 [=>............................] - ETA: 1:03 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 2.3122e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214968). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 20/237 [=>............................] - ETA: 1:04 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 2.8003e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225406). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 21/237 [=>............................] - ETA: 1:05 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 3.1993e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229171). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 23/237 [=>............................] - ETA: 1:06 - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 3.5571e-04 - denoise_loss: 0.1199"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228793). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 26/237 [==>...........................] - ETA: 1:07 - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 3.2391e-04 - denoise_loss: 0.1200"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230283). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 27/237 [==>...........................] - ETA: 1:07 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 3.8245e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232346). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 29/237 [==>...........................] - ETA: 1:08 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 3.6337e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230259). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 33/237 [===>..........................] - ETA: 1:08 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 3.4345e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235783). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228961). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 37/237 [===>..........................] - ETA: 1:08 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 3.2419e-04 - denoise_loss: 0.1195 ETA: 1:08 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.3346e-04 - denoise_loss: 0."
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.240075). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 38/237 [===>..........................] - ETA: 1:07 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.7366e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235686). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232679). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:07 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.8298e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234467). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 47/237 [====>.........................] - ETA: 1:06 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.6397e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183879). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 48/237 [=====>........................] - ETA: 1:06 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.6042e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185003). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:08 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.4870e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150519). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/237 [======>.......................] - ETA: 1:08 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.2588e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213131). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 62/237 [======>.......................] - ETA: 1:07 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0527e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.266110). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 66/237 [=======>......................] - ETA: 1:06 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 4.0551e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186640). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 70/237 [=======>......................] - ETA: 1:05 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.8237e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193100). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.260555). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 71/237 [=======>......................] - ETA: 1:05 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.9489e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.285724). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 76/237 [========>.....................] - ETA: 1:04 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0148e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227705). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 1:03 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.2094e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227002). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 82/237 [=========>....................] - ETA: 1:02 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.3758e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.266452). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 84/237 [=========>....................] - ETA: 1:01 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.2716e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.288166). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 87/237 [==========>...................] - ETA: 1:00 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.2006e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.286346). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 89/237 [==========>...................] - ETA: 1:00 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.1978e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.287569). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 91/237 [==========>...................] - ETA: 59s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.1060e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.270232). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 58s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0177e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.271428). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 94/237 [==========>...................] - ETA: 58s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0669e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.255911). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 95/237 [===========>..................] - ETA: 58s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0553e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.254935). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 98/237 [===========>..................] - ETA: 56s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.9968e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.256131). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "102/237 [===========>..................] - ETA: 55s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0228e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.247300). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "103/237 [============>.................] - ETA: 55s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.9837e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.244852). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "104/237 [============>.................] - ETA: 54s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 3.9454e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.246022). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "107/237 [============>.................] - ETA: 53s - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 4.0009e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.244590). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "109/237 [============>.................] - ETA: 52s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.9275e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.244523). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 50s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 3.9770e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228884). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224219). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "124/237 [==============>...............] - ETA: 47s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.8329e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148035). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "132/237 [===============>..............] - ETA: 44s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.9220e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134415). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "134/237 [===============>..............] - ETA: 43s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.9120e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.111368). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "189/237 [======================>.......] - ETA: 19s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.6137e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150099). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "191/237 [=======================>......] - ETA: 19s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5952e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168614). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "193/237 [=======================>......] - ETA: 18s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5627e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172774). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "195/237 [=======================>......] - ETA: 17s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5261e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183337). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "198/237 [========================>.....] - ETA: 16s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5980e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201098). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "200/237 [========================>.....] - ETA: 15s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5622e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216336). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "204/237 [========================>.....] - ETA: 13s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5269e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223401). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "207/237 [=========================>....] - ETA: 12s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.4913e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.131110). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "224/237 [===========================>..] - ETA: 5s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5226e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135628). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "225/237 [===========================>..] - ETA: 5s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5256e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208174). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "227/237 [===========================>..] - ETA: 4s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5088e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214744). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "229/237 [===========================>..] - ETA: 3s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5236e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220195). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "231/237 [============================>.] - ETA: 2s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5083e-04 - denoise_loss: 0.11 - ETA: 2s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.4931e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237480). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "233/237 [============================>.] - ETA: 1s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.4631e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230904). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "234/237 [============================>.] - ETA: 1s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.4483e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.248071). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "236/237 [============================>.] - ETA: 0s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.4191e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.254986). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 101s 425ms/step - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.4374e-04 - denoise_loss: 0.1191 - val_loss: 0.2365 - val_denoiseg: 0.2365 - val_seg_loss: 0.1175 - val_denoise_loss: 0.1190\n",
+      "Epoch 51/200\n",
+      "  3/237 [..............................] - ETA: 1:02 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 0.0013 - denoise_loss: 0.1174 ETA: 41s - loss: 0.1181 - denoiseg: 0.1181 - seg_loss: 0.0019 - denoise_loss: 0.116"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190909). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  7/237 [..............................] - ETA: 1:07 - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 0.0014 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195431). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  8/237 [>.............................]0.1199 - seg_loss: 0.0014 - denoise_loss: 0.11 - ETA: 1:15 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 0.0012 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.277642). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.284983). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 10/237 [>.............................] - ETA: 1:20 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 0.0010 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.292324). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 12/237 [>.............................] - ETA: 1:15 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 8.9906e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216060). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 13/237 [>.............................] - ETA: 1:16 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 8.4539e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.256917). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 15/237 [>.............................] - ETA: 1:17 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 7.3267e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212477). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 16/237 [=>............................] - ETA: 1:17 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 6.8688e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207886). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/237 [=>............................] - ETA: 1:17 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 6.1116e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199301). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 23/237 [=>............................] - ETA: 1:17 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 6.7717e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174713). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 26/237 [==>...........................] - ETA: 1:16 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 6.3163e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185252). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 27/237 [==>...........................] - ETA: 1:16 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 6.7735e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188740). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 29/237 [==>...........................] - ETA: 1:16 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 7.3169e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142833). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 31/237 [==>...........................] - ETA: 1:15 - loss: 0.1198 - denoiseg: 0.1198 - seg_loss: 6.8449e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179464). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 32/237 [===>..........................] - ETA: 1:15 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 6.6310e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207539). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 33/237 [===>..........................] - ETA: 1:15 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 6.7532e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210181). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223400). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 36/237 [===>..........................] - ETA: 1:14 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 6.7499e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229985). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216764). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 38/237 [===>..........................] - ETA: 1:13 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 6.4565e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200904). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 41/237 [====>.........................] - ETA: 1:12 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 6.0711e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192074). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 42/237 [====>.........................] - ETA: 1:12 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 5.9266e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179455). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 43/237 [====>.........................] - ETA: 1:12 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 5.9623e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155293). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 64/237 [=======>......................] - ETA: 1:07 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.7572e-04 - denoise_loss: 0.1191 ETA: 1:10 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 5.4817e-04 - de"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210065). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 67/237 [=======>......................] - ETA: 1:06 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.5889e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169425). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 47s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.5195e-04 - denoise_loss: 0.1189- ETA: 54s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9441e-04 - "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145748). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 46s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.4423e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183549). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "120/237 [==============>...............] - ETA: 45s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.3312e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219012). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "121/237 [==============>...............] - ETA: 44s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.4122e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220371). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "122/237 [==============>...............] - ETA: 44s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.3761e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209209). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "127/237 [===============>..............] - ETA: 42s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.5073e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162697). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "156/237 [==================>...........] - ETA: 31s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.1392e-04 - denoise_loss: 0.1189- ETA: 41s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.4401"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148301). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138520). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "159/237 [===================>..........] - ETA: 30s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0868e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188108). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "160/237 [===================>..........] - ETA: 29s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0713e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219341). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "163/237 [===================>..........] - ETA: 28s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9964e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232164). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "168/237 [====================>.........] - ETA: 26s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0081e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192914). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "170/237 [====================>.........] - ETA: 25s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9766e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196208). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "188/237 [======================>.......] - ETA: 18s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9686e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.133531). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "189/237 [======================>.......] - ETA: 18s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9476e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152092). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "199/237 [========================>.....] - ETA: 14s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9824e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145567). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140400). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "219/237 [==========================>...] - ETA: 6s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9661e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149011). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "221/237 [==========================>...] - ETA: 6s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9391e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169146). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "225/237 [===========================>..] - ETA: 4s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9649e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201885). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "228/237 [===========================>..] - ETA: 3s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9691e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232425). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "229/237 [===========================>..] - ETA: 3s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0412e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233298). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "233/237 [============================>.] - ETA: 1s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0177e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232901). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "235/237 [============================>.] - ETA: 0s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0713e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233882). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227531). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 92s 390ms/step - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0421e-04 - denoise_loss: 0.1190 - val_loss: 0.2521 - val_denoiseg: 0.2521 - val_seg_loss: 0.1338 - val_denoise_loss: 0.1183\n",
+      "Epoch 52/200\n",
+      "  2/237 [..............................] - ETA: 1:02 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 7.0807e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203245). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 37/237 [===>..........................] - ETA: 1:06 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.7510e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159027). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 38/237 [===>..........................] - ETA: 1:06 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8826e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202338). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:06 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6885e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222582). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 42/237 [====>.........................] - ETA: 1:06 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.5605e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222973). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 44/237 [====>.........................] - ETA: 1:06 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3987e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210935). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 45/237 [====>.........................] - ETA: 1:05 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3242e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221466). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 48/237 [=====>........................] - ETA: 1:05 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.7580e-04 - denoise_loss: 0.1186 ETA: 1:05 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2821e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223069). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 49/237 [=====>........................] - ETA: 1:05 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6813e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216909). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 50/237 [=====>........................] - ETA: 1:05 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6453e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230550). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 51/237 [=====>........................] - ETA: 1:04 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.5738e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203234). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 53/237 [=====>........................] - ETA: 1:08 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6120e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174777). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:07 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8235e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200654). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 58/237 [======>.......................] - ETA: 1:06 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.6916e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196343). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 59/237 [======>.......................] - ETA: 1:06 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.8315e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144747). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 61/237 [======>.......................] - ETA: 1:05 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.8331e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174699). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 64/237 [=======>......................] - ETA: 1:04 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7478e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187608). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 65/237 [=======>......................] - ETA: 1:04 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.6983e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206951). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 67/237 [=======>......................] - ETA: 1:03 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.6136e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214515). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 70/237 [=======>......................] - ETA: 1:02 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4861e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227982). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214565). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 1:01 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.5130e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199843). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 79/237 [=========>....................] - ETA: 59s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.7647e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200315). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 81/237 [=========>....................] - ETA: 58s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9298e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230315). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 84/237 [=========>....................] - ETA: 58s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.8355e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228724). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 86/237 [=========>....................] - ETA: 57s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.1078e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230062). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 87/237 [==========>...................] - ETA: 56s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0932e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218169). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 90/237 [==========>...................] - ETA: 55s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.3662e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207080). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 91/237 [==========>...................] - ETA: 55s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.3182e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186876). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 94/237 [==========>...................] - ETA: 54s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.4066e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225757). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187663). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 95/237 [===========>..................] - ETA: 54s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.3663e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185705). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 97/237 [===========>..................] - ETA: 53s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.2762e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168111). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "185/237 [======================>.......] - ETA: 19s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9182e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184294). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "187/237 [======================>.......] - ETA: 18s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.8763e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208246). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "188/237 [======================>.......] - ETA: 18s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.8631e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219458). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "228/237 [===========================>..] - ETA: 3s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0399e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184254). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "232/237 [============================>.] - ETA: 1s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0338e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183080). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.132742). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 382ms/step - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0238e-04 - denoise_loss: 0.1190 - val_loss: 0.2445 - val_denoiseg: 0.2445 - val_seg_loss: 0.1261 - val_denoise_loss: 0.1184\n",
+      "Epoch 53/200\n",
+      " 43/237 [====>.........................] - ETA: 1:08 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 1.9308e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147659). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176088). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 45/237 [====>.........................] - ETA: 1:08 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 1.8919e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215550). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 46/237 [====>.........................] - ETA: 1:07 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 1.8508e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235507). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 50/237 [=====>........................] - ETA: 1:06 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 1.8292e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235136). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 51/237 [=====>........................] - ETA: 1:06 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 1.7933e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233968). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 52/237 [=====>........................] - ETA: 1:06 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 1.7588e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194441). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:08 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 2.0969e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142378). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 61/237 [======>.......................] - ETA: 1:07 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 2.1523e-04 - denoise_loss: 0.1193 ETA: 1:08 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 2.2636e-04 - denoise_loss: "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192763). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 63/237 [======>.......................] - ETA: 1:06 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 2.0840e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231945). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 66/237 [=======>......................] - ETA: 1:05 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 2.1377e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219560). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 69/237 [=======>......................] - ETA: 1:04 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 2.4691e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195000). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 1:01 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 2.7234e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171969). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 1:00 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 2.8198e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147617). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 81/237 [=========>....................] - ETA: 58s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 2.7740e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165946). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 85/237 [=========>....................] - ETA: 57s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.0477e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171317). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 87/237 [==========>...................] - ETA: 56s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 2.9776e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174184). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 91/237 [==========>...................] - ETA: 55s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 2.9846e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171941). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 94/237 [==========>...................] - ETA: 54s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 2.9759e-04 - denoise_loss: 0.119 - ETA: 54s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 2.9651e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189079). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 98/237 [===========>..................] - ETA: 52s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.1597e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173023). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "101/237 [===========>..................] - ETA: 51s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.0663e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176201). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "102/237 [===========>..................] - ETA: 51s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.1182e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195413). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "106/237 [============>.................] - ETA: 50s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.0291e-04 - denoise_loss: 0.119 - ETA: 49s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.0005e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184646). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "108/237 [============>.................] - ETA: 48s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.0988e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197692). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 46s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 2.9943e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198418). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "116/237 [=============>................] - ETA: 45s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 2.9971e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215970). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 45s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 2.9715e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207161). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "119/237 [==============>...............] - ETA: 44s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 2.9482e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225008). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "124/237 [==============>...............] - ETA: 42s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.0496e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177764). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143892). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "232/237 [============================>.] - ETA: 1s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.5712e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190965). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "234/237 [============================>.] - ETA: 1s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.5503e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185317). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "236/237 [============================>.] - ETA: 0s - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.5866e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189706). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 385ms/step - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.5714e-04 - denoise_loss: 0.1192 - val_loss: 0.2398 - val_denoiseg: 0.2398 - val_seg_loss: 0.1209 - val_denoise_loss: 0.1189\n",
+      "Epoch 54/200\n",
+      "  3/237 [..............................] - ETA: 52s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 0.0000e+00 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217426). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  5/237 [..............................] - ETA: 1:06 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 1.5488e-06 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222528). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  7/237 [..............................] - ETA: 59s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 6.1858e-05 - denoise_loss: 0.1195 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134506). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 12/237 [>.............................] - ETA: 1:02 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.1379e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135792). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139098). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 21/237 [=>............................] - ETA: 1:06 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.4548e-04 - denoise_loss: 0.11 - ETA: 1:05 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.4026e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142242). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 22/237 [=>............................] - ETA: 1:06 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.0144e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150626). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 24/237 [==>...........................] - ETA: 1:07 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1063e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211592). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 25/237 [==>...........................] - ETA: 1:07 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.9820e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213884). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 26/237 [==>...........................] - ETA: 1:08 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.8673e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188350). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 28/237 [==>...........................] - ETA: 1:07 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.7611e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204153). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 29/237 [==>...........................] - ETA: 1:07 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 2.6562e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224633). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 32/237 [===>..........................] - ETA: 1:08 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 2.4591e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189702). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 33/237 [===>..........................] - ETA: 1:08 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.3846e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182912). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 44/237 [====>.........................] - ETA: 1:06 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 1.9890e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.130463). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 46/237 [====>.........................] - ETA: 1:06 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 1.9646e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170028). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 48/237 [=====>........................] - ETA: 1:05 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 2.0522e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174838). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 50/237 [=====>........................] - ETA: 1:05 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.0541e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215239). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 51/237 [=====>........................] - ETA: 1:05 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.0138e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218704). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 53/237 [=====>........................] - ETA: 1:04 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 2.0067e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186396). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 57/237 [======>.......................] - ETA: 1:06 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 2.7032e-04 - denoise_loss: 0.1192 ETA: 1:07 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.3096e-04 - denoise_loss: 0."
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189676). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 58/237 [======>.......................] - ETA: 1:06 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.6566e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225539). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227039). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 61/237 [======>.......................] - ETA: 1:05 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.6388e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229829). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 63/237 [======>.......................] - ETA: 1:04 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 2.5708e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230589). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 67/237 [=======>......................] - ETA: 1:03 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.4541e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230060). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 69/237 [=======>......................] - ETA: 1:02 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.3830e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229157). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 71/237 [=======>......................] - ETA: 1:01 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.3159e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225971). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221212). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191380). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/237 [========>.....................] - ETA: 1:01 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.2542e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160812). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 1:00 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.1941e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186411). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 59s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.3688e-04 - denoise_loss: 0.118 - ETA: 59s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.3385e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203986). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 58s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.3935e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187886). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 85/237 [=========>....................] - ETA: 56s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.3436e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150101). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139454). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "112/237 [=============>................] - ETA: 46s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.6957e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157461). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "114/237 [=============>................] - ETA: 46s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.6487e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186820). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 45s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.6030e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221514). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "120/237 [==============>...............] - ETA: 43s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.5242e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193534). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "121/237 [==============>...............] - ETA: 43s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.5034e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188076). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 42s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.5739e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166717). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "125/237 [==============>...............] - ETA: 42s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.5327e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191130). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "129/237 [===============>..............] - ETA: 40s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.6282e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199408). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "131/237 [===============>..............] - ETA: 39s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.6964e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189740). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "132/237 [===============>..............] - ETA: 39s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.6760e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194378). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "133/237 [===============>..............] - ETA: 39s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.8787e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.133008). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "164/237 [===================>..........] - ETA: 27s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.7558e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161784). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "166/237 [====================>.........] - ETA: 26s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.7460e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210969). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "168/237 [====================>.........] - ETA: 25s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.7143e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236274). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "169/237 [====================>.........] - ETA: 25s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.7692e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.239901). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "171/237 [====================>.........] - ETA: 24s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.8280e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.239819). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236239). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "172/237 [====================>.........] - ETA: 24s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.8201e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207389). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "174/237 [=====================>........] - ETA: 23s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.7877e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159554). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 90s 380ms/step - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.8965e-04 - denoise_loss: 0.1188 - val_loss: 0.2375 - val_denoiseg: 0.2375 - val_seg_loss: 0.1195 - val_denoise_loss: 0.1180\n",
+      "Epoch 55/200\n",
+      " 22/237 [=>............................] - ETA: 1:11 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 5.8405e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.131566). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 23/237 [=>............................] - ETA: 1:11 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 6.3864e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.137611). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 49/237 [=====>........................] - ETA: 1:06 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.8223e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155373). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 64/237 [=======>......................] - ETA: 1:04 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.6977e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141318). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "113/237 [=============>................] - ETA: 46s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.1328e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166650). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "114/237 [=============>................] - ETA: 46s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0965e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172537). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201981). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 45s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0281e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185500). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "119/237 [==============>...............] - ETA: 44s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0984e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199996). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "121/237 [==============>...............] - ETA: 43s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0307e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216747). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "124/237 [==============>...............] - ETA: 42s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.9334e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165949). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 41s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0313e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170861). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "127/237 [===============>..............] - ETA: 41s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9995e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175431). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "128/237 [===============>..............] - ETA: 41s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9683e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185294). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "130/237 [===============>..............] - ETA: 40s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9072e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141384). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "134/237 [===============>..............] - ETA: 38s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9350e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140610). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151525). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "136/237 [================>.............] - ETA: 38s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0289e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189965). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "139/237 [================>.............] - ETA: 36s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.1811e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178664). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "141/237 [================>.............] - ETA: 36s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.2067e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208671). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "145/237 [=================>............] - ETA: 34s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0906e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219972). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 33s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.1170e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210985). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "149/237 [=================>............] - ETA: 33s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0706e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199545). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "152/237 [==================>...........] - ETA: 32s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9903e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180666). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 30s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9893e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207356). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "157/237 [==================>...........] - ETA: 30s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0279e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188477). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "158/237 [===================>..........] - ETA: 29s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0024e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184808). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "178/237 [=====================>........] - ETA: 22s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0000e-04 - denoise_loss: 0.1189- ETA: 22s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.0226e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143483). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "180/237 [=====================>........] - ETA: 21s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9567e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191159). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "181/237 [=====================>........] - ETA: 21s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0962e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225675). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "185/237 [======================>.......] - ETA: 19s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.1966e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192261). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "187/237 [======================>.......] - ETA: 18s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.1517e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144949). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "194/237 [=======================>......] - ETA: 16s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0432e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155264). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "200/237 [========================>.....] - ETA: 13s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0489e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215833). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211562). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "205/237 [========================>.....] - ETA: 12s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0302e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220942). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "208/237 [=========================>....] - ETA: 10s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9788e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215369). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "209/237 [=========================>....] - ETA: 10s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9597e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219080). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "211/237 [=========================>....] - ETA: 9s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9222e-04 - denoise_loss: 0.1190 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216687). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205707). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "215/237 [==========================>...] - ETA: 8s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.8540e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198388). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 382ms/step - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.6824e-04 - denoise_loss: 0.1190 - val_loss: 0.2371 - val_denoiseg: 0.2371 - val_seg_loss: 0.1186 - val_denoise_loss: 0.1185\n",
+      "Epoch 56/200\n",
+      " 62/237 [======>.......................] - ETA: 1:05 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.0056e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175645). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205504). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 64/237 [=======>......................] - ETA: 1:05 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.0227e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235272). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 67/237 [=======>......................] - ETA: 1:04 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.0819e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.271656). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 68/237 [=======>......................] - ETA: 1:04 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.1883e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.276308). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 70/237 [=======>......................] - ETA: 1:04 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.1421e-04 - denoise_loss: 0.11 - ETA: 1:04 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.0977e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.239924). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 71/237 [=======>......................] - ETA: 1:04 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.0541e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210129). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 72/237 [========>.....................] - ETA: 1:04 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.0117e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224044). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 1:03 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.0873e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221529). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 76/237 [========>.....................] - ETA: 1:03 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.0060e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.240142). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 1:01 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.2892e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232035). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 84/237 [=========>....................] - ETA: 1:00 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.4479e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.248359). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 87/237 [==========>...................] - ETA: 59s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.7871e-04 - denoise_loss: 0.1192 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204890). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 89/237 [==========>...................] - ETA: 58s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.7020e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204415). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 96/237 [===========>..................] - ETA: 55s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5567e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174757). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/237 [===========>..................] - ETA: 54s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.5216e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169606). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "101/237 [===========>..................] - ETA: 53s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.4920e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198269). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "103/237 [============>.................] - ETA: 52s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.4242e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221624). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "106/237 [============>.................] - ETA: 51s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.3273e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217845). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "109/237 [============>.................] - ETA: 50s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.4670e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182449). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "112/237 [=============>................] - ETA: 49s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.6176e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164271). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 47s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9883e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176889). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147607). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 47s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9201e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156195). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "118/237 [=============>................] - ETA: 46s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.8873e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187374). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192934). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "120/237 [==============>...............] - ETA: 45s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9576e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205232). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "121/237 [==============>...............] - ETA: 45s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9249e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221406). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222805). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 44s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9010e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222591). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "127/237 [===============>..............] - ETA: 43s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.8591e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219449). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219871). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "129/237 [===============>..............] - ETA: 42s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.8545e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209857). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "134/237 [===============>..............] - ETA: 40s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7106e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216230). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196351). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "136/237 [================>.............] - ETA: 39s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6933e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220304). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "140/237 [================>.............] - ETA: 37s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.5956e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180725). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "190/237 [=======================>......] - ETA: 18s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5793e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.133151). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "195/237 [=======================>......] - ETA: 16s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5685e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171370). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "197/237 [=======================>......] - ETA: 15s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5430e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170322). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "203/237 [========================>.....] - ETA: 13s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6097e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150128). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "224/237 [===========================>..] - ETA: 4s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4880e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140217). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 92s 390ms/step - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4387e-04 - denoise_loss: 0.1189 - val_loss: 0.2434 - val_denoiseg: 0.2434 - val_seg_loss: 0.1249 - val_denoise_loss: 0.1185\n",
+      "Epoch 57/200\n",
+      " 64/237 [=======>......................] - ETA: 1:02 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.2801e-04 - denoise_loss: 0.1191 ETA: 1:05 - loss: 0.1195 - denoiseg: 0.1195 - seg_l - ETA: 1:02 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.2825e-04 - denoise_loss: 0."
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138415). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 67/237 [=======>......................] - ETA: 1:01 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.6469e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159491). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 70/237 [=======>......................] - ETA: 1:00 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.4477e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194635). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217930). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 71/237 [=======>......................] - ETA: 1:00 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.4600e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227477). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222618). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 72/237 [========>.....................] - ETA: 59s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.4228e-04 - denoise_loss: 0.1191 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221612). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 73/237 [========>.....................] - ETA: 59s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.3622e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229426). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 74/237 [========>.....................] - ETA: 59s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.3033e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228605). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 77/237 [========>.....................] - ETA: 58s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.2101e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226358). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 79/237 [=========>....................] - ETA: 57s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.4288e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228200). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 83/237 [=========>....................] - ETA: 56s - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.3339e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227216). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 86/237 [=========>....................] - ETA: 55s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.1827e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224700). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 87/237 [==========>...................] - ETA: 54s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.2199e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225299). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 52s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.2468e-04 - denoise_loss: 0.1189- ETA: 52s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.2492e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225529). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208462). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 94/237 [==========>...................] - ETA: 52s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.2347e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223409). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 95/237 [===========>..................] - ETA: 52s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.1901e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210456). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 97/237 [===========>..................] - ETA: 51s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.1452e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140300). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "101/237 [===========>..................] - ETA: 49s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.1745e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149862). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "104/237 [============>.................] - ETA: 48s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.1862e-04 - denoise_loss: 0.1190- ETA: 49s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.2268e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166456). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "106/237 [============>.................] - ETA: 48s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.1236e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152657). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "108/237 [============>.................] - ETA: 47s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0477e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173754). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198572). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "109/237 [============>.................] - ETA: 47s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.1429e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220659). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "110/237 [============>.................] - ETA: 46s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.1052e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220662). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "112/237 [=============>................] - ETA: 45s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.2988e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225350). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 44s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.3216e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225234). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 44s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.2846e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228152). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "119/237 [==============>...............] - ETA: 43s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.2126e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201419). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 42s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.2252e-04 - denoise_loss: 0.119"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174407). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "127/237 [===============>..............] - ETA: 40s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0741e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172427). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "129/237 [===============>..............] - ETA: 39s - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.1144e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202128). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "130/237 [===============>..............] - ETA: 39s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.1964e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200543). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "135/237 [================>.............] - ETA: 37s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.1370e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166408). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "139/237 [================>.............] - ETA: 36s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.2369e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167588). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "142/237 [================>.............] - ETA: 35s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.1504e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173213). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "145/237 [=================>............] - ETA: 34s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.1757e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172629). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "152/237 [==================>...........] - ETA: 31s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.1481e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164322). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 30s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.1435e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168534). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "156/237 [==================>...........] - ETA: 30s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.1170e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175701). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173179). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "159/237 [===================>..........] - ETA: 28s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0435e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194513). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "161/237 [===================>..........] - ETA: 28s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0792e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228823). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "163/237 [===================>..........] - ETA: 27s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0546e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159567). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "169/237 [====================>.........] - ETA: 25s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9106e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218731). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "174/237 [=====================>........] - ETA: 23s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.7986e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218828). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 22s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.7555e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169000). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "225/237 [===========================>..] - ETA: 4s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5796e-04 - denoise_loss: 0.1189 ETA: 5s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5957e-04 - denoise_loss: 0."
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190062). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " - ETA: 4s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5707e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209027). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "228/237 [===========================>..] - ETA: 3s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6454e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157159). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 382ms/step - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5904e-04 - denoise_loss: 0.1189 - val_loss: 0.2393 - val_denoiseg: 0.2393 - val_seg_loss: 0.1211 - val_denoise_loss: 0.1182\n",
+      "\n",
+      "Epoch 00057: ReduceLROnPlateau reducing learning rate to 0.00019999999494757503.\n",
+      "Epoch 58/200\n",
+      "  1/237 [..............................] - ETA: 32s - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 9.1846e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139451). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:02 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 5.3690e-04 - denoise_loss: 0.1186- ETA: 57s - loss: 0.1184 - denoiseg: 0.1184 - seg_l"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180350). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 41/237 [====>.........................] - ETA: 1:02 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 5.2381e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205952). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 45/237 [====>.........................] - ETA: 1:02 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.7817e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214791). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 49/237 [=====>........................] - ETA: 1:02 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.5988e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233650). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221974). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 52/237 [=====>........................] - ETA: 1:01 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.5179e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204811). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182589). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:00 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.6217e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.130893). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 57/237 [======>.......................] - ETA: 1:00 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.5765e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173600). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/237 [======>.......................] - ETA: 1:03 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.4213e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166158). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 61/237 [======>.......................] - ETA: 1:02 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.4414e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143712). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 62/237 [======>.......................] - ETA: 1:02 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.3697e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165556). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 65/237 [=======>......................] - ETA: 1:01 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.2003e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166148). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 69/237 [=======>......................] - ETA: 1:00 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.1071e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185709). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171493). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/237 [========>.....................] - ETA: 59s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8820e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170637). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180365). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 81/237 [=========>....................] - ETA: 56s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9979e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134819). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 83/237 [=========>....................] - ETA: 55s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.1586e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203211). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 90/237 [==========>...................] - ETA: 53s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9305e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171454). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105/237 [============>.................] - ETA: 48s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6905e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155472). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "107/237 [============>.................] - ETA: 47s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6737e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164910). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "108/237 [============>.................] - ETA: 47s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.6942e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197813). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "109/237 [============>.................] - ETA: 47s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7970e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134359). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 45s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.8806e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163983). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "135/237 [================>.............] - ETA: 39s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.7263e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202841). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "137/237 [================>.............] - ETA: 38s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6719e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178652). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178403). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "143/237 [=================>............] - ETA: 36s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6308e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158797). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "145/237 [=================>............] - ETA: 35s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.5807e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231075). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 35s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.6860e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.253496). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "149/237 [=================>............] - ETA: 34s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.7747e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.258978). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "150/237 [=================>............] - ETA: 34s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.7497e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.277542). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "152/237 [==================>...........] - ETA: 33s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7283e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.263425). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "153/237 [==================>...........] - ETA: 33s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7176e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.246778). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "154/237 [==================>...........] - ETA: 32s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7580e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.241898). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "155/237 [==================>...........] - ETA: 32s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8917e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.246345). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "158/237 [===================>..........] - ETA: 31s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8540e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.270055). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "159/237 [===================>..........] - ETA: 30s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8297e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.270966). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "164/237 [===================>..........] - ETA: 29s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.9424e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.292757). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "167/237 [====================>.........] - ETA: 27s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.8764e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.263134). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "168/237 [====================>.........] - ETA: 27s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8690e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.269614). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "169/237 [====================>.........] - ETA: 27s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8461e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.281920). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "170/237 [====================>.........] - ETA: 26s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8505e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.253810). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "173/237 [====================>.........] - ETA: 26s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8293e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.289532). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "174/237 [=====================>........] - ETA: 25s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8193e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.294282). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "177/237 [=====================>........] - ETA: 24s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8684e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.296201). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "178/237 [=====================>........] - ETA: 23s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8778e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.296665). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 22s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.9706e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.307824). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "182/237 [======================>.......] - ETA: 22s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.0040e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.309593). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "186/237 [======================>.......] - ETA: 20s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.9614e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.306732). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "188/237 [======================>.......] - ETA: 19s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.9347e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.300480). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "191/237 [=======================>......] - ETA: 18s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8782e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.299620). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "195/237 [=======================>......] - ETA: 17s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.9174e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.302391). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "199/237 [========================>.....] - ETA: 15s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0014e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.305224). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.278941). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "201/237 [========================>.....] - ETA: 14s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.9616e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.303491). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.295032). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "205/237 [========================>.....] - ETA: 13s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9147e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.263967). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "207/237 [=========================>....] - ETA: 12s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.8769e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224241). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231819). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "208/237 [=========================>....] - ETA: 11s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.8738e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201170). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "210/237 [=========================>....] - ETA: 11s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.8369e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182993). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "211/237 [=========================>....] - ETA: 10s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8399e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150871). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "224/237 [===========================>..] - ETA: 5s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8179e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171104). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "225/237 [===========================>..] - ETA: 4s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8010e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183923). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "230/237 [============================>.] - ETA: 2s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8488e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194256). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "232/237 [============================>.] - ETA: 2s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8197e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211660). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "234/237 [============================>.] - ETA: 1s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7870e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171463). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "235/237 [============================>.] - ETA: 0s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7709e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170374). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "236/237 [============================>.] - ETA: 0s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7549e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210571). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 100s 422ms/step - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7388e-04 - denoise_loss: 0.1187 - val_loss: 0.2353 - val_denoiseg: 0.2353 - val_seg_loss: 0.1175 - val_denoise_loss: 0.1179\n",
+      "Epoch 59/200\n",
+      "  2/237 [..............................] - ETA: 38s - loss: 0.1213 - denoiseg: 0.1213 - seg_loss: 8.0181e-04 - denoise_loss: 0.1205"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166150). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  5/237 [..............................] - ETA: 1:17 - loss: 0.1208 - denoiseg: 0.1208 - seg_loss: 5.7284e-04 - denoise_loss: 0.1202"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225806). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  6/237 [..............................] - ETA: 1:22 - loss: 0.1203 - denoiseg: 0.1203 - seg_loss: 4.7777e-04 - denoise_loss: 0.1198"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.263247). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  8/237 [>.............................] - ETA: 1:26 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 5.8838e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.244739). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  9/237 [>.............................] - ETA: 1:28 - loss: 0.1201 - denoiseg: 0.1201 - seg_loss: 5.2338e-04 - denoise_loss: 0.1196"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.272713). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 14/237 [>.............................] - ETA: 1:18 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 4.4095e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191330). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 25/237 [==>...........................] - ETA: 1:26 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.9050e-04 - denoise_loss: 0.1191 ETA: 1:24 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4713e-04 - denoise_lo - ETA: 1:26 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.3104e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185559). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 26/237 [==>...........................] - ETA: 1:26 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0764e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203845). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 28/237 [==>...........................] - ETA: 1:26 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 3.8310e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234911). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 29/237 [==>...........................] - ETA: 1:25 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.0449e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225802). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 30/237 [==>...........................] - ETA: 1:26 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.9100e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.261655). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 31/237 [==>...........................] - ETA: 1:25 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.7839e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.270294). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 33/237 [===>..........................] - ETA: 1:25 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6719e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.254322). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 36/237 [===>..........................] - ETA: 1:24 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5749e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205674). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.243469). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 38/237 [===>..........................] - ETA: 1:24 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.3868e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229751). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 46/237 [====>.........................] - ETA: 1:21 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.6203e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214876). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 48/237 [=====>........................] - ETA: 1:21 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.5396e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203537). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 49/237 [=====>........................] - ETA: 1:21 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4673e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195336). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 50/237 [=====>........................] - ETA: 1:20 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.3980e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190661). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 53/237 [=====>........................] - ETA: 1:19 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.2647e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196716). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 54/237 [=====>........................] - ETA: 1:19 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2042e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199388). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 55/237 [=====>........................] - ETA: 1:19 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1460e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194713). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 56/237 [======>.......................] - ETA: 1:18 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0898e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199096). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 58/237 [======>.......................] - ETA: 1:17 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.9833e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201099). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 60/237 [======>.......................] - ETA: 1:20 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.8838e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203523). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 64/237 [=======>......................] - ETA: 1:17 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.8304e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174846). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 70/237 [=======>......................] - ETA: 1:13 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.6541e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193284). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 72/237 [========>.....................] - ETA: 1:12 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.7019e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198118). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220337). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 1:11 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.6669e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220894). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 76/237 [========>.....................] - ETA: 1:10 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.5967e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222004). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 82/237 [=========>....................] - ETA: 1:07 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.4076e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221273). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202820). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 86/237 [=========>....................] - ETA: 1:04 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.4439e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222281). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175808). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 91/237 [==========>...................] - ETA: 1:02 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.3097e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195033). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 1:01 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.2600e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188089). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 95/237 [===========>..................] - ETA: 1:00 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.4183e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160847). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "146/237 [=================>............] - ETA: 37s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.8761e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164881). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 36s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9387e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225580). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "149/237 [=================>............] - ETA: 35s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.8996e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195095). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "154/237 [==================>...........] - ETA: 33s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9668e-04 - denoise_loss: 0.1186- ETA: 34s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9861e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198641). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228197). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "156/237 [==================>...........] - ETA: 32s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.0307e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227900). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "167/237 [====================>.........] - ETA: 28s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2941e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140895). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "168/237 [====================>.........] - ETA: 27s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3001e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162571). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "170/237 [====================>.........] - ETA: 27s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2863e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155140). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "188/237 [======================>.......] - ETA: 19s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2742e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174176). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "190/237 [=======================>......] - ETA: 19s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2398e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214478). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "192/237 [=======================>......] - ETA: 18s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2060e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225319). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176127). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "193/237 [=======================>......] - ETA: 17s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1902e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185017). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "195/237 [=======================>......] - ETA: 17s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1575e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.242606). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 100s 422ms/step - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4659e-04 - denoise_loss: 0.1186 - val_loss: 0.2317 - val_denoiseg: 0.2317 - val_seg_loss: 0.1138 - val_denoise_loss: 0.1179\n",
+      "Epoch 60/200\n",
+      " 21/237 [=>............................] - ETA: 1:16 - loss: 0.1180 - denoiseg: 0.1180 - seg_loss: 1.4205e-04 - denoise_loss: 0.1178 ETA: 57s - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 8.7379e-05 - denoise_loss: 0.118 - ETA: 55s - loss: 0.1178 - denoiseg: 0.1178 - seg_loss: 1.021"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177804). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135536). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 22/237 [=>............................] - ETA: 1:17 - loss: 0.1180 - denoiseg: 0.1180 - seg_loss: 1.3559e-04 - denoise_loss: 0.1179"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138883). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 29/237 [==>...........................] - ETA: 1:19 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 1.9415e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139353). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 33/237 [===>..........................] - ETA: 1:19 - loss: 0.1181 - denoiseg: 0.1181 - seg_loss: 1.7067e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157975). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 34/237 [===>..........................] - ETA: 1:19 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 1.6565e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178201). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 35/237 [===>..........................] - ETA: 1:19 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 1.8604e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229657). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 38/237 [===>..........................] - ETA: 1:19 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 2.2740e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209767). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:19 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 2.5827e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.276463). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 42/237 [====>.........................] - ETA: 1:19 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.4597e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225007). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.295316). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 43/237 [====>.........................] - ETA: 1:19 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.4382e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.288764). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 44/237 [====>.........................] - ETA: 1:19 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.3828e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231613). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 48/237 [=====>........................] - ETA: 1:18 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5972e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.296593). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 49/237 [=====>........................] - ETA: 1:18 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5442e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.257795). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 50/237 [=====>........................] - ETA: 1:18 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.5494e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.278359). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 51/237 [=====>........................] - ETA: 1:17 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5006e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.272569). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 55/237 [=====>........................] - ETA: 1:16 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.5543e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.260276). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 56/237 [======>.......................] - ETA: 1:16 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.5087e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.259259). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/237 [======>.......................] - ETA: 1:15 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.4526e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.269876). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 61/237 [======>.......................] - ETA: 1:17 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.3894e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215619). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 63/237 [======>.......................] - ETA: 1:16 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.3136e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175798). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 64/237 [=======>......................] - ETA: 1:15 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.2777e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192446). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 70/237 [=======>......................] - ETA: 1:12 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.2087e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190691). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 71/237 [=======>......................] - ETA: 1:11 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.3330e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201557). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/237 [========>.....................] - ETA: 1:11 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.3006e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206887). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " - ETA: 1:10 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.4349e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219223). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 1:09 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.4087e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211133). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219894). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 1:07 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.6386e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228845). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 1:06 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.5944e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216663). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 82/237 [=========>....................] - ETA: 1:05 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.5438e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225993). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 83/237 [=========>....................] - ETA: 1:05 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.5142e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221736). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 87/237 [==========>...................] - ETA: 1:03 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.4547e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226208). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 1:00 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.3645e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226637). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225024). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 95/237 [===========>..................] - ETA: 59s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.3556e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225521). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229182). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 97/237 [===========>..................] - ETA: 58s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.3785e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227812). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227485). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "102/237 [===========>..................] - ETA: 56s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.3722e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229252). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "106/237 [============>.................] - ETA: 54s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.3976e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204302). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "108/237 [============>.................] - ETA: 53s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.3532e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195258). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "110/237 [============>.................] - ETA: 52s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.3104e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218666). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 50s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.3850e-04 - denoise_loss: 0.1187- ETA: 52s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.2950e-04 - denoise_loss: 0."
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194534). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "117/237 [=============>................] - ETA: 50s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.3646e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158876). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "119/237 [==============>...............] - ETA: 49s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.3730e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200991). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "121/237 [==============>...............] - ETA: 48s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.3338e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198688). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "144/237 [=================>............] - ETA: 39s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0930e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145144). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "149/237 [=================>............] - ETA: 37s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.3002e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183333). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "151/237 [==================>...........] - ETA: 36s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2565e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228783). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "153/237 [==================>...........] - ETA: 35s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2139e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199702). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 34s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1925e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150479). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "168/237 [====================>.........] - ETA: 29s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.3091e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172270). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "171/237 [====================>.........] - ETA: 28s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.3250e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135514). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139346). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 103s 433ms/step - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4810e-04 - denoise_loss: 0.1187 - val_loss: 0.2315 - val_denoiseg: 0.2315 - val_seg_loss: 0.1132 - val_denoise_loss: 0.1183\n",
+      "Epoch 61/200\n",
+      " 65/237 [=======>......................] - ETA: 1:04 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.2382e-04 - denoise_loss: 0.11 - ETA: 1:03 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.2038e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178258). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 66/237 [=======>......................] - ETA: 1:03 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.1704e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192153). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 68/237 [=======>......................] - ETA: 1:02 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.1362e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203141). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 71/237 [=======>......................] - ETA: 1:01 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.0459e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206210). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 72/237 [========>.....................] - ETA: 1:01 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.0175e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193760). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 73/237 [========>.....................] - ETA: 1:01 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.0297e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170214). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 74/237 [========>.....................] - ETA: 1:00 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.1616e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.181203). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 75/237 [========>.....................] - ETA: 1:00 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.1327e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161379). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 77/237 [========>.....................] - ETA: 59s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.0773e-04 - denoise_loss: 0.1187 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.129794). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 79/237 [=========>....................] - ETA: 59s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.0587e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149749). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 81/237 [=========>....................] - ETA: 58s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.2371e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164762). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 83/237 [=========>....................] - ETA: 57s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.2661e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197161). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 84/237 [=========>....................] - ETA: 57s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.2391e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229834). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 86/237 [=========>....................] - ETA: 56s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.1870e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231972). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 89/237 [==========>...................] - ETA: 55s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.2423e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230842). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 91/237 [==========>...................] - ETA: 55s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.3472e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232368). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 54s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.4100e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233669). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 94/237 [==========>...................] - ETA: 53s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.3844e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232539). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 96/237 [===========>..................] - ETA: 53s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.3368e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234473). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 98/237 [===========>..................] - ETA: 52s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.3096e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233928). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 99/237 [===========>..................] - ETA: 52s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.2863e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235193). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "102/237 [===========>..................] - ETA: 50s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.2191e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232605). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105/237 [============>.................] - ETA: 49s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.5025e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232241). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "106/237 [============>.................] - ETA: 49s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.4789e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228992). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "108/237 [============>.................] - ETA: 48s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.4699e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227737). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "109/237 [============>.................] - ETA: 48s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.4551e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209722). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 46s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.6704e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226398). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "116/237 [=============>................] - ETA: 45s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.7821e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226841). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "118/237 [=============>................] - ETA: 44s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.7691e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226921). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "119/237 [==============>...............] - ETA: 44s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.8395e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226970). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 43s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.0629e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228130). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "125/237 [==============>...............] - ETA: 42s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.1391e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228109). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "127/237 [===============>..............] - ETA: 41s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0897e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227273). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "128/237 [===============>..............] - ETA: 41s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0655e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217883). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163582). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179/237 [=====================>........] - ETA: 21s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.9255e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173615). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 21s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.0180e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231635). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223637). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "184/237 [======================>.......] - ETA: 20s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0524e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226561). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "186/237 [======================>.......] - ETA: 19s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0492e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215060). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "188/237 [======================>.......] - ETA: 18s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.0323e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222060). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "190/237 [=======================>......] - ETA: 17s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0827e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230058). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "192/237 [=======================>......] - ETA: 17s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2093e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218557). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223869). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "199/237 [========================>.....] - ETA: 14s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2675e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215828). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "201/237 [========================>.....] - ETA: 13s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2515e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226944). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "203/237 [========================>.....] - ETA: 12s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2483e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231806). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "204/237 [========================>.....] - ETA: 12s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2428e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220592). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "205/237 [========================>.....] - ETA: 12s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2270e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219009). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "206/237 [=========================>....] - ETA: 11s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2114e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230223). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "209/237 [=========================>....] - ETA: 10s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.1655e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220590). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "211/237 [=========================>....] - ETA: 9s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.1355e-04 - denoise_loss: 0.1187 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203518). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "215/237 [==========================>...] - ETA: 8s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2106e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222592). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214640). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "220/237 [==========================>...] - ETA: 6s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.1376e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.136381). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "222/237 [===========================>..] - ETA: 5s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.1094e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212679). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "226/237 [===========================>..] - ETA: 4s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.0889e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.136330). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 384ms/step - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9460e-04 - denoise_loss: 0.1186 - val_loss: 0.2308 - val_denoiseg: 0.2308 - val_seg_loss: 0.1129 - val_denoise_loss: 0.1179\n",
+      "Epoch 62/200\n",
+      "  3/237 [..............................] - ETA: 59s - loss: 0.1181 - denoiseg: 0.1181 - seg_loss: 7.4103e-07 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159021). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  4/237 [..............................] - ETA: 1:06 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 5.5577e-07 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237279). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  5/237 [..............................] - ETA: 1:10 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1756e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.241267). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  9/237 [>.............................] - ETA: 1:07 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.9639e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.181120). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 60/237 [======>.......................] - ETA: 1:06 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.9102e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182743). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 63/237 [======>.......................] - ETA: 1:08 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.9542e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203304). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 64/237 [=======>......................] - ETA: 1:07 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.9189e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208875). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 68/237 [=======>......................] - ETA: 1:06 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6884e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207288). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205138). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 69/237 [=======>......................] - ETA: 1:06 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6352e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201275). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 71/237 [=======>......................] - ETA: 1:05 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5328e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209006). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 1:03 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3895e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217215). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 1:01 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2394e-04 - denoise_loss: 0.1184 ETA: 1:02 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2599e-04 - denoise_loss: 0.11 - ETA: 1:02 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2804e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215322). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 81/237 [=========>....................] - ETA: 1:01 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1994e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165295). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 82/237 [=========>....................] - ETA: 1:00 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3877e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230210). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "145/237 [=================>............] - ETA: 35s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6664e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.136394). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 34s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7464e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206073). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "149/237 [=================>............] - ETA: 34s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8614e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225522). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "152/237 [==================>...........] - ETA: 32s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7853e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214748). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 92s 389ms/step - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.5776e-04 - denoise_loss: 0.1186 - val_loss: 0.2321 - val_denoiseg: 0.2321 - val_seg_loss: 0.1136 - val_denoise_loss: 0.1185\n",
+      "Epoch 63/200\n",
+      " 15/237 [>.............................] - ETA: 1:03 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.6214e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.131598). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:07 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 1.8295e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209106). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 42/237 [====>.........................] - ETA: 1:07 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.1241e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210688). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227920). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 44/237 [====>.........................] - ETA: 1:06 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.0504e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226945). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210037). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 45/237 [====>.........................] - ETA: 1:06 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.0049e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221664). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 50/237 [=====>........................] - ETA: 1:05 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0693e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214943). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 53/237 [=====>........................] - ETA: 1:04 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0535e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207015). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 55/237 [=====>........................] - ETA: 1:04 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.9434e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198045). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 57/237 [======>.......................] - ETA: 1:03 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.9058e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171041). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 60/237 [======>.......................] - ETA: 1:02 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.7783e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213684). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 62/237 [======>.......................] - ETA: 1:02 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.2682e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227289). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210550). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 66/237 [=======>......................] - ETA: 1:03 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.0701e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226913). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 1:00 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.0870e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190791). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 77/237 [========>.....................] - ETA: 1:00 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.3536e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206284). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 78/237 [========>.....................] - ETA: 59s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.3106e-04 - denoise_loss: 0.1189 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218608). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 79/237 [=========>....................] - ETA: 59s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4608e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221657). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 81/237 [=========>....................] - ETA: 59s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.3754e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209528). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 83/237 [=========>....................] - ETA: 58s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.2940e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213502). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 86/237 [=========>....................] - ETA: 57s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.2463e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201628). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 87/237 [==========>...................] - ETA: 57s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.3076e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208846). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 90/237 [==========>...................] - ETA: 55s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2062e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194986). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 54s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.1742e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194844). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 94/237 [==========>...................] - ETA: 54s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.3084e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197327). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 95/237 [===========>..................] - ETA: 54s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.2735e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206613). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 99/237 [===========>..................] - ETA: 52s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1413e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201674). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "102/237 [===========>..................] - ETA: 51s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0763e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210819). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218160). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "103/237 [============>.................] - ETA: 51s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0465e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224748). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105/237 [============>.................] - ETA: 50s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.9887e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228570). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224385). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "107/237 [============>.................] - ETA: 49s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.9333e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213221). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "122/237 [==============>...............] - ETA: 44s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0240e-04 - denoise_loss: 0.118 - ETA: 43s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.9992e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145872). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "180/237 [=====================>........] - ETA: 21s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5131e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146271). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150635). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "182/237 [======================>.......] - ETA: 21s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4748e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196357). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "184/237 [======================>.......] - ETA: 20s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5412e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196280). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "188/237 [======================>.......] - ETA: 18s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4659e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203542). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153860). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "190/237 [=======================>......] - ETA: 17s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4558e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201172). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "194/237 [=======================>......] - ETA: 16s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4607e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205209). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208681). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "196/237 [=======================>......] - ETA: 15s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4518e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214506). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "198/237 [========================>.....] - ETA: 14s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4413e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226276). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "201/237 [========================>.....] - ETA: 13s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4743e-04 - denoise_loss: 0.1189- ETA: 14s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4916e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234084). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "202/237 [========================>.....] - ETA: 13s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4571e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233070). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "203/237 [========================>.....] - ETA: 12s - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.4400e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226023). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "204/237 [========================>.....] - ETA: 12s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4418e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198381). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "205/237 [========================>.....] - ETA: 12s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4418e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184739). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "206/237 [=========================>....] - ETA: 11s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4254e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176970). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "212/237 [=========================>....] - ETA: 9s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.3498e-04 - denoise_loss: 0.1189 - ETA: 10s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.3817e-04 - denoise_loss: 0.1"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192140). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "215/237 [==========================>...] - ETA: 8s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.3185e-04 - denoise_loss: 0.11 - ETA: 8s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.3206e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193421). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "217/237 [==========================>...] - ETA: 7s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.2900e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213821). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "219/237 [==========================>...] - ETA: 6s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.2753e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230947). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "224/237 [===========================>..] - ETA: 4s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.3162e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231413). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229225). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "225/237 [===========================>..] - ETA: 4s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.3014e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169073). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 92s 389ms/step - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.2715e-04 - denoise_loss: 0.1188 - val_loss: 0.2348 - val_denoiseg: 0.2348 - val_seg_loss: 0.1169 - val_denoise_loss: 0.1179\n",
+      "Epoch 64/200\n",
+      "  2/237 [..............................] - ETA: 1:00 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 0.0000e+00 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200394). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.132918). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/237 [========>.....................] - ETA: 58s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.3096e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142358). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 74/237 [========>.....................] - ETA: 58s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.2649e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185390). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 75/237 [========>.....................] - ETA: 58s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4009e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210341). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 57s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.5477e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188757). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 56s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4822e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193341). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 82/237 [=========>....................] - ETA: 55s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.3973e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200807). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 83/237 [=========>....................] - ETA: 55s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4243e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205352). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 86/237 [=========>....................] - ETA: 54s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4649e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179223). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 90/237 [==========>...................] - ETA: 53s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3174e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208194). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182805). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 52s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3988e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162578). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 95/237 [===========>..................] - ETA: 51s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4875e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139129). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "108/237 [============>.................] - ETA: 47s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6188e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155939). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "110/237 [============>.................] - ETA: 46s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5961e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140959). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "114/237 [=============>................] - ETA: 45s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5891e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194739). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 44s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5578e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228870). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 44s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5126e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227065). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "119/237 [==============>...............] - ETA: 43s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4535e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231871). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "121/237 [==============>...............] - ETA: 42s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5829e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233950). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "122/237 [==============>...............] - ETA: 42s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5535e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234688). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "123/237 [==============>...............] - ETA: 41s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5246e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235268). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "125/237 [==============>...............] - ETA: 41s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4976e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232451). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 40s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4702e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235621). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "128/237 [===============>..............] - ETA: 40s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4160e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216881). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "133/237 [===============>..............] - ETA: 38s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4008e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179250). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "134/237 [===============>..............] - ETA: 37s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3754e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190094). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "137/237 [================>.............] - ETA: 36s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3015e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204653). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195819). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "139/237 [================>.............] - ETA: 36s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2876e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203283). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "140/237 [================>.............] - ETA: 35s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2642e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219053). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "142/237 [================>.............] - ETA: 35s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2373e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188724). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "145/237 [=================>............] - ETA: 34s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2838e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173633). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 33s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2391e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187814). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "149/237 [=================>............] - ETA: 32s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2947e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200217). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "151/237 [==================>...........] - ETA: 31s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2571e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154620). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "153/237 [==================>...........] - ETA: 31s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3884e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194410). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145223). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "154/237 [==================>...........] - ETA: 30s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3664e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177333). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "156/237 [==================>...........] - ETA: 30s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4045e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233059). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 90s 380ms/step - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.5245e-04 - denoise_loss: 0.1184 - val_loss: 0.2285 - val_denoiseg: 0.2285 - val_seg_loss: 0.1106 - val_denoise_loss: 0.1180\n",
+      "Epoch 65/200\n",
+      "  8/237 [>.............................] - ETA: 1:05 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 4.1317e-05 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.136378). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  9/237 [>.............................] - ETA: 1:07 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.6969e-05 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164088). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 17/237 [=>............................] - ETA: 1:04 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 9.3305e-05 - denoise_loss: 0.1185 ETA: 1:03 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 9.9136e-05 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161532). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 20/237 [=>............................] - ETA: 1:06 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 7.9309e-05 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222856). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 25/237 [==>...........................] - ETA: 1:05 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 1.5404e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231959). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 26/237 [==>...........................] - ETA: 1:06 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 1.4812e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221183). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 29/237 [==>...........................] - ETA: 1:06 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 1.7579e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220534). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 30/237 [==>...........................] - ETA: 1:06 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 1.7011e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223700). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 32/237 [===>..........................] - ETA: 1:06 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 1.8280e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230378). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 35/237 [===>..........................] - ETA: 1:06 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 1.6733e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229729). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 37/237 [===>..........................] - ETA: 1:06 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 1.6850e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212966). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 38/237 [===>..........................] - ETA: 1:06 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 1.7814e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.181137). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 59s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.6816e-04 - denoise_loss: 0.1189 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167207). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 77/237 [========>.....................] - ETA: 58s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.5771e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186484). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205626). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 57s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.7234e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196923). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215339). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 83/237 [=========>....................] - ETA: 56s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.8916e-04 - denoise_loss: 0.1187- ETA: 57s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.9269e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218935). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 85/237 [=========>....................] - ETA: 56s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2137e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205436). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 87/237 [==========>...................] - ETA: 55s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1399e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179554). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 89/237 [==========>...................] - ETA: 54s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2478e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142893). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 92/237 [==========>...................] - ETA: 53s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2729e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172519). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 93/237 [==========>...................] - ETA: 53s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2377e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196881). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 95/237 [===========>..................] - ETA: 52s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1696e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209599). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 96/237 [===========>..................] - ETA: 52s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1618e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201574). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 97/237 [===========>..................] - ETA: 52s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1292e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213429). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "101/237 [===========>..................] - ETA: 50s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0053e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190132). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "209/237 [=========================>....] - ETA: 10s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2137e-04 - denoise_loss: 0.1186- ETA: 31s - loss: 0.1190 - denois"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145977). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "211/237 [=========================>....] - ETA: 9s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2208e-04 - denoise_loss: 0.1186 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190182). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "212/237 [=========================>....] - ETA: 9s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2056e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214591). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "213/237 [=========================>....] - ETA: 9s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2401e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227813). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "217/237 [==========================>...] - ETA: 7s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.1943e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194105). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "220/237 [==========================>...] - ETA: 6s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.1916e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150041). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 383ms/step - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2017e-04 - denoise_loss: 0.1187 - val_loss: 0.2324 - val_denoiseg: 0.2324 - val_seg_loss: 0.1143 - val_denoise_loss: 0.1181\n",
+      "Epoch 66/200\n",
+      "  2/237 [..............................] - ETA: 43s - loss: 0.1228 - denoiseg: 0.1228 - seg_loss: 0.0013 - denoise_loss: 0.1215"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140304). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  5/237 [..............................] - ETA: 1:10 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 5.4752e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165172). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/237 [=>............................] - ETA: 1:04 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.9789e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140075). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217920). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 20/237 [=>............................] - ETA: 1:06 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.9219e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231594). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 21/237 [=>............................] - ETA: 1:06 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.7351e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233582). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 23/237 [=>............................] - ETA: 1:07 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.4507e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234136). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 28/237 [==>...........................] - ETA: 1:07 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1498e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214996). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138807). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 68/237 [=======>......................] - ETA: 1:02 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.6208e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141353). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "139/237 [================>.............] - ETA: 36s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0405e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187993). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "141/237 [================>.............] - ETA: 35s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0162e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209974). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "143/237 [=================>............] - ETA: 35s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1128e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206899). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "145/237 [=================>............] - ETA: 34s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1532e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193237). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 33s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.1103e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199944). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "152/237 [==================>...........] - ETA: 31s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.1503e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212394). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198732). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 30s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.1139e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214206). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "156/237 [==================>...........] - ETA: 30s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.0740e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219808). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "160/237 [===================>..........] - ETA: 28s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.0187e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220262). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217239). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "161/237 [===================>..........] - ETA: 28s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.1200e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226514). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "162/237 [===================>..........] - ETA: 27s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.1007e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230529). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "165/237 [===================>..........] - ETA: 26s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0443e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224242). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "168/237 [====================>.........] - ETA: 25s - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.0798e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225039). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166445). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "169/237 [====================>.........] - ETA: 25s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0616e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.133310). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "172/237 [====================>.........] - ETA: 24s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0635e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157180). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "175/237 [=====================>........] - ETA: 23s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1061e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164332). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179/237 [=====================>........] - ETA: 21s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1414e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169531). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "180/237 [=====================>........] - ETA: 21s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2315e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192998). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "182/237 [======================>.......] - ETA: 20s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2004e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163641). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "185/237 [======================>.......] - ETA: 19s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1846e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173938). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "187/237 [======================>.......] - ETA: 18s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2454e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203295). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "193/237 [=======================>......] - ETA: 16s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2252e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168021). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "194/237 [=======================>......] - ETA: 16s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2115e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185164). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "197/237 [=======================>......] - ETA: 14s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1726e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161939). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "198/237 [========================>.....] - ETA: 14s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1874e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203930). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "201/237 [========================>.....] - ETA: 13s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1484e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230171). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "203/237 [========================>.....] - ETA: 12s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1177e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234101). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235957). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "205/237 [========================>.....] - ETA: 12s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0873e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234654). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "208/237 [=========================>....] - ETA: 10s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0997e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233872). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "212/237 [=========================>....] - ETA: 9s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2339e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223960). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214413). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "215/237 [==========================>...] - ETA: 8s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1961e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146239). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "219/237 [==========================>...] - ETA: 6s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1925e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140530). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "221/237 [==========================>...] - ETA: 6s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1902e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.132545). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "223/237 [===========================>..] - ETA: 5s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1616e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168411). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "226/237 [===========================>..] - ETA: 4s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1578e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153986). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "227/237 [===========================>..] - ETA: 3s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1439e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.132623). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 90s 381ms/step - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0617e-04 - denoise_loss: 0.1188 - val_loss: 0.2339 - val_denoiseg: 0.2339 - val_seg_loss: 0.1158 - val_denoise_loss: 0.1181\n",
+      "Epoch 67/200\n",
+      "  8/237 [>.............................] - ETA: 56s - loss: 0.1168 - denoiseg: 0.1168 - seg_loss: 2.7456e-04 - denoise_loss: 0.1165"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170961). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 39/237 [===>..........................] - ETA: 1:07 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8502e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206695). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " - ETA: 1:07 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7779e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228965). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 42/237 [====>.........................] - ETA: 1:06 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0207e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215450). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 45/237 [====>.........................] - ETA: 1:06 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1625e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149920). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 51/237 [=====>........................] - ETA: 1:05 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.5025e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152544). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 53/237 [=====>........................] - ETA: 1:04 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3704e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162205). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 54/237 [=====>........................] - ETA: 1:04 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.3079e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213440). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:03 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6853e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226484). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 60/237 [======>.......................] - ETA: 1:02 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8050e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173426). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.129878). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/237 [========>.....................] - ETA: 1:00 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.0811e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211710). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 59s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.0157e-04 - denoise_loss: 0.1184 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214544). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 58s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8612e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217608). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 79/237 [=========>....................] - ETA: 58s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8370e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209922). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 80/237 [=========>....................] - ETA: 58s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.7999e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204896). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 82/237 [=========>....................] - ETA: 57s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.9100e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207730). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170989). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "114/237 [=============>................] - ETA: 46s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6890e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144330). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "115/237 [=============>................] - ETA: 45s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6570e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180206). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 44s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6473e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208627). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "118/237 [=============>................] - ETA: 44s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6164e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164752). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "119/237 [==============>...............] - ETA: 44s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.5860e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198225). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "120/237 [==============>...............] - ETA: 43s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.5812e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226876). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 42s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8394e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228090). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "125/237 [==============>...............] - ETA: 41s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7780e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226582). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 41s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7480e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226812). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "128/237 [===============>..............] - ETA: 40s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7816e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228128). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "129/237 [===============>..............] - ETA: 40s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7523e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231025). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "131/237 [===============>..............] - ETA: 39s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.0534e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227833). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "133/237 [===============>..............] - ETA: 39s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.1235e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173492). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153057). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "135/237 [================>.............] - ETA: 38s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.0820e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157813). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "142/237 [================>.............] - ETA: 35s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.9230e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216315). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "144/237 [=================>............] - ETA: 34s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8685e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226681). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "145/237 [=================>............] - ETA: 34s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.9268e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229042). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 34s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8999e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229800). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "148/237 [=================>............] - ETA: 33s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8656e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230102). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "149/237 [=================>............] - ETA: 33s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8397e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229246). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228186). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179/237 [=====================>........] - ETA: 21s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6584e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173857). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 21s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7068e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192939). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "186/237 [======================>.......] - ETA: 19s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8427e-04 - denoise_loss: 0.1186- ETA: 19s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8562e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134033). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "195/237 [=======================>......] - ETA: 15s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8973e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167942). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "198/237 [========================>.....] - ETA: 14s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8542e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194453). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "203/237 [========================>.....] - ETA: 12s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8089e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144021). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "205/237 [========================>.....] - ETA: 12s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7718e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166800). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "206/237 [=========================>....] - ETA: 11s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7534e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225313). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "208/237 [=========================>....] - ETA: 10s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7174e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227762). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "211/237 [=========================>....] - ETA: 9s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7231e-04 - denoise_loss: 0.1185 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231677). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "215/237 [==========================>...] - ETA: 8s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6669e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228540). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "216/237 [==========================>...] - ETA: 7s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6499e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231505). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225541). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "218/237 [==========================>...] - ETA: 7s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6399e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206313). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "220/237 [==========================>...] - ETA: 6s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6068e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218818). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "224/237 [===========================>..] - ETA: 4s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.5424e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182889). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "228/237 [===========================>..] - ETA: 3s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.5032e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168653). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "230/237 [============================>.] - ETA: 2s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.5081e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143043). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "233/237 [============================>.] - ETA: 1s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.4841e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175503). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 90s 381ms/step - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.5241e-04 - denoise_loss: 0.1185 - val_loss: 0.2372 - val_denoiseg: 0.2372 - val_seg_loss: 0.1193 - val_denoise_loss: 0.1179\n",
+      "Epoch 68/200\n",
+      " 19/237 [=>............................] - ETA: 1:08 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.7086e-04 - denoise_loss: 0.1192 ETA: 1:02 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 4.5500e-05 - d - ETA: 1:07 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 2.6290e-04 - denoise_loss: 0."
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142468). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 21/237 [=>............................] - ETA: 1:09 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 3.3554e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202203). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 22/237 [=>............................] - ETA: 1:09 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 3.2029e-04 - denoise_loss: 0.1192"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231204). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 24/237 [==>...........................] - ETA: 1:10 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 2.9360e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232557). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 27/237 [==>...........................] - ETA: 1:10 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 2.6598e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232417). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 30/237 [==>...........................] - ETA: 1:09 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.3945e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229468). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176093). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 1:00 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.0391e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161512). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 59s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.0163e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177928). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 81/237 [=========>....................] - ETA: 58s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.0948e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171757). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 85/237 [=========>....................] - ETA: 57s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.9909e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164861). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 86/237 [=========>....................] - ETA: 56s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.9681e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153843). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 46s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.0645e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.130221). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 45s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0127e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140126). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "118/237 [=============>................] - ETA: 44s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0155e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143729). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "128/237 [===============>..............] - ETA: 41s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.9143e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139846). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "129/237 [===============>..............] - ETA: 40s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.9145e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227680). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "131/237 [===============>..............] - ETA: 40s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.8701e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145981). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "134/237 [===============>..............] - ETA: 38s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.9507e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166049). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "136/237 [================>.............] - ETA: 38s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.9337e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167644). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "208/237 [=========================>....] - ETA: 10s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0568e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154968). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "210/237 [=========================>....] - ETA: 10s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.0277e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171909). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142549). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "212/237 [=========================>....] - ETA: 9s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.9991e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179581). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "213/237 [=========================>....] - ETA: 9s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.9851e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167161). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 384ms/step - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.9949e-04 - denoise_loss: 0.1188 - val_loss: 0.2366 - val_denoiseg: 0.2366 - val_seg_loss: 0.1186 - val_denoise_loss: 0.1180\n",
+      "Epoch 69/200\n",
+      " 18/237 [=>............................] - ETA: 1:06 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.0231e-04 - denoise_loss: 0.1190 ETA: 41s - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 6.4455e-05 - deno\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184184). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 20/237 [=>............................] - ETA: 1:09 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.6473e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215859). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 22/237 [=>............................] - ETA: 1:10 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 2.4066e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.244000). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 23/237 [=>............................] - ETA: 1:11 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.1740e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.273895). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 24/237 [==>...........................] - ETA: 1:12 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.2163e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.285511). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 26/237 [==>...........................] - ETA: 1:13 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.0080e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.295013). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.283088). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 27/237 [==>...........................] - ETA: 1:13 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9617e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.243331). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 29/237 [==>...........................] - ETA: 1:13 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.8559e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223184). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 30/237 [==>...........................] - ETA: 1:13 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9480e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232938). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 31/237 [==>...........................] - ETA: 1:13 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8529e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229342). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 39/237 [===>..........................] - ETA: 1:12 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.3773e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210859). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.137107). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 77/237 [========>.....................] - ETA: 1:04 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.2622e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170113). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 1:02 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.1024e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166219). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "113/237 [=============>................] - ETA: 50s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6612e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159921). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 49s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.5670e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177249). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "119/237 [==============>...............] - ETA: 48s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.5732e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162354). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "162/237 [===================>..........] - ETA: 30s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.5331e-04 - denoise_loss: 0.1187- ETA: 44s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176535). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "163/237 [===================>..........] - ETA: 30s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6183e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.248467). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.273209). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "166/237 [====================>.........] - ETA: 29s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.5529e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.282184). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "170/237 [====================>.........] - ETA: 27s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4914e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.263657). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "172/237 [====================>.........] - ETA: 26s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6677e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.258787). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.246319). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "174/237 [=====================>........] - ETA: 26s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.7143e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.257550). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "175/237 [=====================>........] - ETA: 25s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.7074e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.246767). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "178/237 [=====================>........] - ETA: 24s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7503e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232570). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 23s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7297e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.243801). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "183/237 [======================>.......] - ETA: 22s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6993e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.260991). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.246794). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "187/237 [======================>.......] - ETA: 20s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8021e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.241235). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "189/237 [======================>.......] - ETA: 19s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.7619e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.272356). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.243345). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "192/237 [=======================>......] - ETA: 18s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.7503e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.251716). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "196/237 [=======================>......] - ETA: 17s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6951e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.282228). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.287024). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "197/237 [=======================>......] - ETA: 16s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6764e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.292514). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "199/237 [========================>.....] - ETA: 15s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6394e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.294973). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "202/237 [========================>.....] - ETA: 14s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.7130e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.260551). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "205/237 [========================>.....] - ETA: 13s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6588e-04 - denoise_loss: 0.1186- ETA: 13s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6768e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231407). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206477). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "208/237 [=========================>....] - ETA: 12s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6061e-04 - denoise_loss: 0.1186- ETA: 12s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6235e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186181). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "210/237 [=========================>....] - ETA: 11s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6781e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205159). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "212/237 [=========================>....] - ETA: 10s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6521e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202785). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "213/237 [=========================>....] - ETA: 9s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6350e-04 - denoise_loss: 0.1186 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218048). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "215/237 [==========================>...] - ETA: 9s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6014e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219111). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "220/237 [==========================>...] - ETA: 7s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.5344e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223442). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "221/237 [==========================>...] - ETA: 6s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.5184e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.242808). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "223/237 [===========================>..] - ETA: 5s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.5410e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.266305). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "225/237 [===========================>..] - ETA: 4s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.5095e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.275167). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "229/237 [===========================>..] - ETA: 3s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.4482e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.277378). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "234/237 [============================>.] - ETA: 1s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3746e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.270218). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "235/237 [============================>.] - ETA: 0s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3851e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.272710). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.278573). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "236/237 [============================>.] - ETA: 0s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3708e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.287422). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 100s 421ms/step - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3641e-04 - denoise_loss: 0.1186 - val_loss: 0.2398 - val_denoiseg: 0.2398 - val_seg_loss: 0.1215 - val_denoise_loss: 0.1183\n",
+      "Epoch 70/200\n",
+      " 12/237 [>.............................] - ETA: 1:12 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 8.2659e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204081). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 14/237 [>.............................] - ETA: 1:15 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 7.3849e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.286625). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 17/237 [=>............................] - ETA: 1:18 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 6.0827e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.259901). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235761). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 19/237 [=>............................] - ETA: 1:17 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 5.4424e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184981). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 21/237 [=>............................] - ETA: 1:17 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.9241e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166252). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161411). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 23/237 [=>............................] - ETA: 1:17 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.5400e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190547). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 25/237 [==>...........................] - ETA: 1:16 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.1768e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178077). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 28/237 [==>...........................] - ETA: 1:17 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.3812e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204791). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 29/237 [==>...........................] - ETA: 1:17 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.2302e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218043). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 30/237 [==>...........................] - ETA: 1:17 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.2124e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228564). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 33/237 [===>..........................] - ETA: 1:17 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.8303e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.244754). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 34/237 [===>..........................] - ETA: 1:17 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7176e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.263943). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 35/237 [===>..........................] - ETA: 1:17 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.6142e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.282304). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 37/237 [===>..........................] - ETA: 1:17 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8696e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.280537). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.262176). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 39/237 [===>..........................] - ETA: 1:17 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7551e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.280300). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 42/237 [====>.........................] - ETA: 1:16 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.6645e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.281869). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.271650). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 44/237 [====>.........................] - ETA: 1:16 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.4979e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.266698). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 47/237 [====>.........................] - ETA: 1:15 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.6471e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.251238). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 48/237 [=====>........................] - ETA: 1:15 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.5711e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224331). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 50/237 [=====>........................] - ETA: 1:15 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.8236e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164159). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 55/237 [=====>........................] - ETA: 1:13 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8410e-04 - denoise_loss: 0.1187 ETA: 1:13 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7256e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228712). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190961). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/237 [======>.......................] - ETA: 1:12 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.1237e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210172). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135313). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 60/237 [======>.......................] - ETA: 1:12 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0979e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162620). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 66/237 [=======>......................] - ETA: 1:10 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.8391e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175203). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 68/237 [=======>......................] - ETA: 1:09 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9896e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224152). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 1:07 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0531e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160455). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 1:06 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.9201e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166248). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 1:05 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.9147e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195960). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235293). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 81/237 [=========>....................] - ETA: 1:05 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.8671e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.253337). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 86/237 [=========>....................] - ETA: 1:03 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7221e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.246652). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 87/237 [==========>...................] - ETA: 1:02 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.6793e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.248292). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 88/237 [==========>...................] - ETA: 1:02 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.6375e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.252478). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 90/237 [==========>...................] - ETA: 1:01 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.5567e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.245793). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.244100). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 92/237 [==========>...................] - ETA: 1:01 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7054e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.243967). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 94/237 [==========>...................] - ETA: 1:00 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.6631e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.242503). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.240408). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "142/237 [================>.............] - ETA: 40s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7031e-04 - denoise_loss: 0.1187- ETA: 41s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.7293e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.264231). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "145/237 [=================>............] - ETA: 39s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.6618e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218353). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "148/237 [=================>............] - ETA: 38s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.5877e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.259153). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "152/237 [==================>...........] - ETA: 36s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.5931e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.255192). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.241393). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 35s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.5726e-04 - denoise_loss: 0.118 - ETA: 35s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.5496e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.267154). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "156/237 [==================>...........] - ETA: 35s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.5268e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.260610). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "157/237 [==================>...........] - ETA: 34s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.5044e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.262731). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "160/237 [===================>..........] - ETA: 33s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.4389e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.250769). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "162/237 [===================>..........] - ETA: 32s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.4055e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.246812). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.243149). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "163/237 [===================>..........] - ETA: 32s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.3846e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218928). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "164/237 [===================>..........] - ETA: 31s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.4219e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235782). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "168/237 [====================>.........] - ETA: 29s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.3648e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194271). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "169/237 [====================>.........] - ETA: 29s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.3449e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153490). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "172/237 [====================>.........] - ETA: 28s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.3016e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178427). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 26s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2367e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138710). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.114071). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "180/237 [=====================>........] - ETA: 24s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2803e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158706). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "183/237 [======================>.......] - ETA: 23s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2270e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153545). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167632). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "186/237 [======================>.......] - ETA: 22s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.3060e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224010). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "191/237 [=======================>......] - ETA: 20s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2391e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140547). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "194/237 [=======================>......] - ETA: 18s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2013e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.278867). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "196/237 [=======================>......] - ETA: 17s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1941e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.298330). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209998). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "197/237 [=======================>......] - ETA: 17s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1779e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208539). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "199/237 [========================>.....] - ETA: 16s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2272e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.296356). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "201/237 [========================>.....] - ETA: 15s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2258e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.240048). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "204/237 [========================>.....] - ETA: 14s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2218e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202543). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "205/237 [========================>.....] - ETA: 13s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2061e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.250754). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "207/237 [=========================>....] - ETA: 13s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.3085e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.240611). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "210/237 [=========================>....] - ETA: 11s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.4675e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.239852). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "212/237 [=========================>....] - ETA: 10s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.4348e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.248341). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "213/237 [=========================>....] - ETA: 10s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.4399e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198147). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "214/237 [==========================>...] - ETA: 10s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.4328e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141193). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 105s 444ms/step - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.3469e-04 - denoise_loss: 0.1188 - val_loss: 0.2407 - val_denoiseg: 0.2407 - val_seg_loss: 0.1229 - val_denoise_loss: 0.1178\n",
+      "Epoch 71/200\n",
+      " 17/237 [=>............................] - ETA: 1:24 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 5.3671e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175632). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 19/237 [=>............................] - ETA: 1:25 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 5.3926e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.272845). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 20/237 [=>............................] - ETA: 1:26 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 5.1230e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.276790). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 21/237 [=>............................] - ETA: 1:25 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 4.8791e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.245950). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 23/237 [=>............................] - ETA: 1:25 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 4.4548e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.265621). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 26/237 [==>...........................] - ETA: 1:26 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.4789e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.247187). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 30/237 [==>...........................] - ETA: 1:25 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 5.1720e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.285009). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 33/237 [===>..........................] - ETA: 1:25 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.7836e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.266575). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 35/237 [===>..........................] - ETA: 1:24 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.5102e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.266149). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 36/237 [===>..........................] - ETA: 1:24 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.8818e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.245246). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 37/237 [===>..........................] - ETA: 1:24 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.7959e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236764). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 39/237 [===>..........................] - ETA: 1:23 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 5.1592e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222048). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 42/237 [====>.........................] - ETA: 1:22 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 5.0625e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.247846). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 47/237 [====>.........................] - ETA: 1:21 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 5.2765e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.251295). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 49/237 [=====>........................] - ETA: 1:20 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 5.3647e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233353). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 51/237 [=====>........................] - ETA: 1:19 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 5.2291e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197828). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 60/237 [======>.......................] - ETA: 1:16 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.6981e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143306). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 61/237 [======>.......................] - ETA: 1:16 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.6211e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174969). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 63/237 [======>.......................] - ETA: 1:15 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 4.4744e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.132073). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 65/237 [=======>......................] - ETA: 1:14 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.3367e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194386). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 68/237 [=======>......................] - ETA: 1:13 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.1462e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230207). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 1:13 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.5456e-04 - denoise_loss: 0.11 - ETA: 1:12 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.4850e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.133386). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 1:11 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.4438e-04 - denoise_loss: 0.11 - ETA: 1:10 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.3872e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206940). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 83/237 [=========>....................] - ETA: 1:07 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.1418e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229590). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 86/237 [=========>....................] - ETA: 1:06 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.0268e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230101). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230536). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 88/237 [==========>...................] - ETA: 1:05 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.1915e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231202). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 90/237 [==========>...................] - ETA: 1:04 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.2842e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227368). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 94/237 [==========>...................] - ETA: 1:02 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.1933e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228483). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 96/237 [===========>..................] - ETA: 1:00 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.1837e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226266). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224907). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 98/237 [===========>..................] - ETA: 59s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.0983e-04 - denoise_loss: 0.1184 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221120). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "101/237 [===========>..................] - ETA: 58s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.9768e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135886). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "102/237 [===========>..................] - ETA: 57s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.9659e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218824). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "104/237 [============>.................] - ETA: 56s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.9484e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212948). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105/237 [============>.................] - ETA: 56s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.9108e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190640). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "110/237 [============>.................] - ETA: 53s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.2243e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219303). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "111/237 [=============>................] - ETA: 53s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.2180e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223113). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 51s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.2443e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226414). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 50s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.4451e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225235). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197094). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "118/237 [=============>................] - ETA: 50s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.4074e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170546). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "128/237 [===============>..............] - ETA: 45s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.1992e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157730). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "130/237 [===============>..............] - ETA: 44s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.2434e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215133). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "131/237 [===============>..............] - ETA: 44s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.2110e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217946). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "137/237 [================>.............] - ETA: 41s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.0348e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222011). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "138/237 [================>.............] - ETA: 41s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.0056e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209559). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "141/237 [================>.............] - ETA: 39s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.9523e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210734). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187721). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "144/237 [=================>............] - ETA: 38s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8711e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211779). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "145/237 [=================>............] - ETA: 38s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8444e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210081). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 37s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.9141e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205439). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "148/237 [=================>............] - ETA: 36s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.9009e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177732). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "151/237 [==================>...........] - ETA: 35s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8432e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213218). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "157/237 [==================>...........] - ETA: 33s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.7531e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216492). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "160/237 [===================>..........] - ETA: 31s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.7702e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212146). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "161/237 [===================>..........] - ETA: 31s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.7468e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227055). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "163/237 [===================>..........] - ETA: 30s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.7130e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222256). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203520). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "167/237 [====================>.........] - ETA: 28s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6899e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199140). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "169/237 [====================>.........] - ETA: 27s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6752e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226727). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "173/237 [====================>.........] - ETA: 26s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6785e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231249). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "177/237 [=====================>........] - ETA: 24s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.7028e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203533). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179/237 [=====================>........] - ETA: 23s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6616e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171177). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "188/237 [======================>.......] - ETA: 19s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6818e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143969). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "190/237 [=======================>......] - ETA: 19s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6434e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149343). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "193/237 [=======================>......] - ETA: 17s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6226e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149807). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200961). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "195/237 [=======================>......] - ETA: 17s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6713e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225713). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "201/237 [========================>.....] - ETA: 14s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7310e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158940). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 96s 406ms/step - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8755e-04 - denoise_loss: 0.1185 - val_loss: 0.2315 - val_denoiseg: 0.2315 - val_seg_loss: 0.1134 - val_denoise_loss: 0.1181\n",
+      "Epoch 72/200\n",
+      " 17/237 [=>............................] - ETA: 1:09 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.0450e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160556). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 20/237 [=>............................] - ETA: 1:10 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9845e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145453). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 22/237 [=>............................] - ETA: 1:11 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7132e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184519). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 27/237 [==>...........................] - ETA: 1:11 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.5087e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187572). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 28/237 [==>...........................] - ETA: 1:11 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3834e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210743). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 29/237 [==>...........................] - ETA: 1:11 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2667e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230074). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 32/237 [===>..........................] - ETA: 1:11 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0917e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204562). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223537). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 36/237 [===>..........................] - ETA: 1:10 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.8725e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230316). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 38/237 [===>..........................] - ETA: 1:10 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4544e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224135). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 41/237 [====>.........................] - ETA: 1:09 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.5805e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233667). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 42/237 [====>.........................] - ETA: 1:09 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4953e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236998). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 44/237 [====>.........................] - ETA: 1:08 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6413e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235997). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 47/237 [====>.........................] - ETA: 1:07 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.4465e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235765). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 49/237 [=====>........................] - ETA: 1:07 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7711e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233782). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 53/237 [=====>........................] - ETA: 1:06 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6270e-04 - denoise_loss: 0.1185 ETA: 1:06 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6967e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205141). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205883). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140883). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:05 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.5011e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.137219). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 57/237 [======>.......................] - ETA: 1:05 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4400e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205386). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 58/237 [======>.......................] - ETA: 1:04 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6263e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232975). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 61/237 [======>.......................] - ETA: 1:03 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.5919e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231736). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163568). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 64/237 [=======>......................] - ETA: 1:02 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.5025e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176141). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 66/237 [=======>......................] - ETA: 1:01 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4274e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191116). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 68/237 [=======>......................] - ETA: 1:01 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.3269e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145707). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 72/237 [========>.....................] - ETA: 1:02 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.1835e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173259). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 1:00 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.3520e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178492). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 59s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.4072e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180962). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 81/237 [=========>....................] - ETA: 58s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3652e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207407). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 84/237 [=========>....................] - ETA: 57s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.5677e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228487). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 86/237 [=========>....................] - ETA: 57s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.4848e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202412). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 87/237 [==========>...................] - ETA: 56s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4447e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200611). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 92/237 [==========>...................] - ETA: 54s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3888e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193619). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215679). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 94/237 [==========>...................] - ETA: 54s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3474e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208748). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 99/237 [===========>..................] - ETA: 52s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2507e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212785). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "101/237 [===========>..................] - ETA: 51s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1868e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191807). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "102/237 [===========>..................] - ETA: 51s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1638e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172012). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "103/237 [============>.................] - ETA: 50s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2571e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167745). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "108/237 [============>.................] - ETA: 48s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3142e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178613). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "110/237 [============>.................] - ETA: 47s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4904e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198787). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "112/237 [=============>................] - ETA: 47s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6874e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209378). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 46s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6771e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188719). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "116/237 [=============>................] - ETA: 45s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6454e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191615). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "118/237 [=============>................] - ETA: 44s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6933e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183193). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "121/237 [==============>...............] - ETA: 43s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6139e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198106). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 43s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.5551e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191018). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "144/237 [=================>............] - ETA: 35s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3088e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134485). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "146/237 [=================>............] - ETA: 34s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2835e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162531). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "147/237 [=================>............] - ETA: 34s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2792e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151841). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "149/237 [=================>............] - ETA: 33s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2775e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151655). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "152/237 [==================>...........] - ETA: 32s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2614e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188519). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "153/237 [==================>...........] - ETA: 31s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2401e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216552). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223160). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 31s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1983e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224462). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224291). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "157/237 [==================>...........] - ETA: 30s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.1582e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226270). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "158/237 [===================>..........] - ETA: 29s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1405e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226820). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "161/237 [===================>..........] - ETA: 28s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2351e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227274). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "166/237 [====================>.........] - ETA: 26s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2324e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226954). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "168/237 [====================>.........] - ETA: 26s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3211e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227605). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "173/237 [====================>.........] - ETA: 24s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3235e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226809). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "175/237 [=====================>........] - ETA: 23s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3547e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172236). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "177/237 [=====================>........] - ETA: 22s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3241e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142651). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "183/237 [======================>.......] - ETA: 20s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2836e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.137389). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "184/237 [======================>.......]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197604). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "185/237 [======================>.......] - ETA: 19s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2481e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233329). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "188/237 [======================>.......] - ETA: 18s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2133e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216751). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "191/237 [=======================>......] - ETA: 17s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1709e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178520). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150005). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "207/237 [=========================>....] - ETA: 11s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2531e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134019). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "221/237 [==========================>...] - ETA: 6s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0956e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144228). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 384ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9304e-04 - denoise_loss: 0.1184 - val_loss: 0.2299 - val_denoiseg: 0.2299 - val_seg_loss: 0.1120 - val_denoise_loss: 0.1179\n",
+      "Epoch 73/200\n",
+      " 51/237 [=====>........................] - ETA: 1:21 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.3139e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167958). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 52/237 [=====>........................] - ETA: 1:20 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.4012e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235023). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 54/237 [=====>........................] - ETA: 1:19 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.7778e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.295079). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:19 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.8848e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.355482). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 58/237 [======>.......................] - ETA: 1:19 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.0106e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.262691). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 61/237 [======>.......................] - ETA: 1:18 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.8937e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.262424). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.265332). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 65/237 [=======>......................] - ETA: 1:16 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.5773e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.307248). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 68/237 [=======>......................] - ETA: 1:15 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.0695e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.342773). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 70/237 [=======>......................] - ETA: 1:15 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.9532e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.344016). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.282488). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 72/237 [========>.....................] - ETA: 1:14 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.0926e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.288415). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 1:16 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.1240e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.242496). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 76/237 [========>.....................] - ETA: 1:16 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.1328e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.257590). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 1:14 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.2187e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.246007). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 1:13 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.1136e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236078). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 82/237 [=========>....................] - ETA: 1:12 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.1501e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232218). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 84/237 [=========>....................] - ETA: 1:11 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.1278e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229475). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227880). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 90/237 [==========>...................] - ETA: 1:07 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.2510e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227736). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 1:05 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.1235e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228535). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 94/237 [==========>...................] - ETA: 1:05 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.0796e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228663). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228518). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 96/237 [===========>..................] - ETA: 1:03 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.1499e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227131). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/237 [===========>..................] - ETA: 1:01 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.0483e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225252). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105/237 [============>.................] - ETA: 59s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8911e-04 - denoise_loss: 0.1185  ETA: 1:00 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.9689e-04 - denoise_loss: "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215076). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "110/237 [============>.................] - ETA: 56s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8575e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193830). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "113/237 [=============>................] - ETA: 54s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8743e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227722). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 53s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8503e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206199). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.181805). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "117/237 [=============>................] - ETA: 52s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8174e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185062). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "119/237 [==============>...............] - ETA: 51s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7792e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205612). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 48s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7490e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203982). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "127/237 [===============>..............] - ETA: 47s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7195e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193805). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "130/237 [===============>..............] - ETA: 46s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6876e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198673). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "131/237 [===============>..............] - ETA: 45s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6879e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220109). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "132/237 [===============>..............] - ETA: 45s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6605e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198629). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "134/237 [===============>..............] - ETA: 44s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6059e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223074). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "138/237 [================>.............] - ETA: 42s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6004e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174922). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "139/237 [================>.............] - ETA: 42s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.5903e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171125). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "160/237 [===================>..........] - ETA: 32s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2269e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185857). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "162/237 [===================>..........] - ETA: 31s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.2926e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231171). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "163/237 [===================>..........] - ETA: 31s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2724e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230134). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "166/237 [====================>.........] - ETA: 29s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.3049e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225507). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "168/237 [====================>.........] - ETA: 29s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2656e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222857). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173355). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "175/237 [=====================>........] - ETA: 26s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4243e-04 - denoise_loss: 0.1187- ETA: 27s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4840e-04 - denoise_loss: 0.1"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227265). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "177/237 [=====================>........] - ETA: 25s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.4083e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232096). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "178/237 [=====================>........] - ETA: 24s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.3892e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233656). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 23s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.3331e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199764). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "183/237 [======================>.......] - ETA: 22s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.4047e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229439). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "185/237 [======================>.......] - ETA: 21s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.3678e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229271). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "186/237 [======================>.......] - ETA: 21s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.3497e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230753). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "190/237 [=======================>......] - ETA: 19s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.3366e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162253). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151455). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "193/237 [=======================>......] - ETA: 18s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2884e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150726). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 98s 414ms/step - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4883e-04 - denoise_loss: 0.1187 - val_loss: 0.2367 - val_denoiseg: 0.2367 - val_seg_loss: 0.1188 - val_denoise_loss: 0.1179\n",
+      "Epoch 74/200\n",
+      " 60/237 [======>.......................] - ETA: 1:04 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1732e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200043). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 61/237 [======>.......................] - ETA: 1:03 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1212e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229951). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 62/237 [======>.......................] - ETA: 1:03 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0708e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226516). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 65/237 [=======>......................] - ETA: 1:02 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9979e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201650). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 67/237 [=======>......................] - ETA: 1:02 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9528e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217939). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 69/237 [=======>......................] - ETA: 1:00 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8681e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195007). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/237 [========>.....................] - ETA: 59s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7239e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175911). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 86/237 [=========>....................] - ETA: 57s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9095e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.181813). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194366). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 89/237 [==========>...................] - ETA: 55s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0411e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211877). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 90/237 [==========>...................] - ETA: 55s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0073e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220500). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 92/237 [==========>...................] - ETA: 54s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0811e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212194). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214079). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 93/237 [==========>...................] - ETA: 54s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2809e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225167). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 96/237 [===========>..................] - ETA: 53s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1909e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224481). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 97/237 [===========>..................] - ETA: 52s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1580e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213673). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 99/237 [===========>..................] - ETA: 52s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2591e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182959). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "100/237 [===========>..................] - ETA: 51s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4040e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193659). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "103/237 [============>.................] - ETA: 50s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5047e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162719). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "104/237 [============>.................] - ETA: 50s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4710e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192521). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "105/237 [============>.................] - ETA: 49s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6250e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225342). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "108/237 [============>.................] - ETA: 48s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7448e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228639). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "112/237 [=============>................] - ETA: 47s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6417e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186415). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "113/237 [=============>................] - ETA: 46s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6094e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153574). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "164/237 [===================>..........] - ETA: 27s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.3801e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175998). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "170/237 [====================>.........] - ETA: 25s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2654e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147235). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "173/237 [====================>.........] - ETA: 24s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.2274e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169977). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 22s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.3549e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198544). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179/237 [=====================>........] - ETA: 21s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4922e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221535). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "180/237 [=====================>........] - ETA: 21s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4728e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224353). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "182/237 [======================>.......] - ETA: 20s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4351e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227210). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227714). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228252). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "183/237 [======================>.......] - ETA: 20s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4876e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227956). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "184/237 [======================>.......] - ETA: 19s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4686e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227453). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "186/237 [======================>.......] - ETA: 19s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4348e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224244). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "190/237 [=======================>......] - ETA: 17s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4101e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208325). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "193/237 [=======================>......] - ETA: 16s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.3756e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208754). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "195/237 [=======================>......] - ETA: 15s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4084e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228704). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "196/237 [=======================>......] - ETA: 15s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4941e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229029). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "200/237 [========================>.....] - ETA: 13s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.5029e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228402). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "203/237 [========================>.....] - ETA: 12s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.5321e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200067). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.181458). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "205/237 [========================>.....] - ETA: 12s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4978e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170595). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "208/237 [=========================>....] - ETA: 10s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4672e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201110). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "210/237 [=========================>....] - ETA: 10s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4514e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211825). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "211/237 [=========================>....] - ETA: 9s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4529e-04 - denoise_loss: 0.1183 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213400). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "216/237 [==========================>...] - ETA: 7s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4610e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194430). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "219/237 [==========================>...] - ETA: 6s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4220e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166765). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "226/237 [===========================>..] - ETA: 4s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.3442e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166933). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "231/237 [============================>.] - ETA: 2s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5212e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138268). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "234/237 [============================>.] - ETA: 1s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.5346e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172980). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140749). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 90s 381ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5124e-04 - denoise_loss: 0.1183 - val_loss: 0.2308 - val_denoiseg: 0.2308 - val_seg_loss: 0.1125 - val_denoise_loss: 0.1183\n",
+      "\n",
+      "Epoch 00074: ReduceLROnPlateau reducing learning rate to 9.999999747378752e-05.\n",
+      "Epoch 75/200\n",
+      " 25/237 [==>...........................] - ETA: 1:09 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.3926e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166439). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 28/237 [==>...........................] - ETA: 1:09 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.1928e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224354). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225487). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 29/237 [==>...........................] - ETA: 1:10 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 2.1171e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223192). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 31/237 [==>...........................] - ETA: 1:09 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 2.2230e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226884). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 32/237 [===>..........................] - ETA: 1:09 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 2.1535e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223360). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 36/237 [===>..........................] - ETA: 1:09 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 1.9146e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210422). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:08 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 2.3403e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223956). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222922). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 42/237 [====>.........................] - ETA: 1:07 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 2.2288e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224483). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226836). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 44/237 [====>.........................] - ETA: 1:07 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 2.2458e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228434). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228566). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 45/237 [====>.........................] - ETA: 1:07 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 2.1959e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228287). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 47/237 [====>.........................] - ETA: 1:06 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 2.1025e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227735). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 48/237 [=====>........................] - ETA: 1:06 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 2.0587e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226415). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 52/237 [=====>........................] - ETA: 1:05 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 1.9601e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217772). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 54/237 [=====>........................] - ETA: 1:04 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 1.9285e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191108). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:04 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 1.8596e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191582). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 58/237 [======>.......................] - ETA: 1:03 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 1.8479e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218463). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 66/237 [=======>......................] - ETA: 1:01 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.1330e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203955). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164344). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 58s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.0385e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177569). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 82/237 [=========>....................] - ETA: 56s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.0746e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175477). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 84/237 [=========>....................] - ETA: 56s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.0665e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167471). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 87/237 [==========>...................] - ETA: 54s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.0542e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166461). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 44s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.3137e-04 - denoise_loss: 0.1184- ETA: 52s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.0817e-04 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.132862). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "118/237 [=============>................] - ETA: 43s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.4582e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150870). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "120/237 [==============>...............] - ETA: 43s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.4406e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159273). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "121/237 [==============>...............] - ETA: 42s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.4204e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176461). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "124/237 [==============>...............] - ETA: 41s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.4492e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205903). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 40s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.4959e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163863). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "153/237 [==================>...........] - ETA: 31s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1408e-04 - denoise_loss: 0.1183- ETA: 36s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6994e-04 - denoi"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145972). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 30s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1827e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166551). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "157/237 [==================>...........] - ETA: 29s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1422e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174362). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "160/237 [===================>..........] - ETA: 28s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0880e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184864). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "161/237 [===================>..........] - ETA: 28s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1473e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213259). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198774). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "164/237 [===================>..........] - ETA: 27s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2192e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227886). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "165/237 [===================>..........] - ETA: 26s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1996e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200574). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "167/237 [====================>.........] - ETA: 25s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1613e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201291). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "170/237 [====================>.........] - ETA: 24s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1057e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191789). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139397). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "174/237 [=====================>........] - ETA: 23s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1049e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145021). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 22s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1101e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162831). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179/237 [=====================>........] - ETA: 21s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0580e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166363). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 20s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0499e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217072). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "197/237 [=======================>......] - ETA: 14s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9433e-04 - denoise_loss: 0.1184- ETA: 15s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9582e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162681). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "200/237 [========================>.....] - ETA: 13s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0076e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171769). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "203/237 [========================>.....] - ETA: 12s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9631e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198142). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "204/237 [========================>.....] - ETA: 12s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9486e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229263). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "205/237 [========================>.....] - ETA: 11s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9343e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205238). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "207/237 [=========================>....] - ETA: 11s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9393e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176781). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "209/237 [=========================>....] - ETA: 10s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9820e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200460). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "210/237 [=========================>....] - ETA: 10s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9754e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169685). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "211/237 [=========================>....] - ETA: 9s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9856e-04 - denoise_loss: 0.1184 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151763). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "217/237 [==========================>...] - ETA: 7s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9867e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143781). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "219/237 [==========================>...] - ETA: 6s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9691e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148536). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218410). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "221/237 [==========================>...] - ETA: 5s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9423e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230455). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "226/237 [===========================>..] - ETA: 4s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8777e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222950). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "227/237 [===========================>..] - ETA: 3s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8650e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223825). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210905). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "228/237 [===========================>..] - ETA: 3s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8525e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203770). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "230/237 [============================>.] - ETA: 2s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8277e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206904). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179188). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "235/237 [============================>.] - ETA: 0s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8944e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190361). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 90s 379ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8727e-04 - denoise_loss: 0.1184 - val_loss: 0.2285 - val_denoiseg: 0.2285 - val_seg_loss: 0.1105 - val_denoise_loss: 0.1179\n",
+      "Epoch 76/200\n",
+      "  2/237 [..............................] - ETA: 1:08 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 0.0000e+00 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.275862). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  3/237 [..............................] - ETA: 1:15 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 2.5595e-04 - denoise_loss: 0.1191"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.257358). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.238855). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  5/237 [..............................] - ETA: 1:02 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 3.8739e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174331). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  7/237 [..............................] - ETA: 1:09 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.3307e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218810). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198765). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  9/237 [>.............................] - ETA: 1:03 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.9980e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154286). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147667). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "114/237 [=============>................] - ETA: 45s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.8677e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171820). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "122/237 [==============>...............] - ETA: 42s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.9386e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170427). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "125/237 [==============>...............] - ETA: 41s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8678e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135005). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "157/237 [==================>...........] - ETA: 29s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8711e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187818). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209555). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "160/237 [===================>..........] - ETA: 28s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8080e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188326). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "162/237 [===================>..........] - ETA: 27s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8730e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171561). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "164/237 [===================>..........] - ETA: 27s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8671e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180562). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "169/237 [====================>.........] - ETA: 25s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8377e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.137570). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "171/237 [====================>.........] - ETA: 24s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8054e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163335). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "172/237 [====================>.........] - ETA: 24s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7833e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170914). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193806). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "174/237 [=====================>........] - ETA: 23s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7398e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214261). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 22s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7842e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145193). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "180/237 [=====================>........] - ETA: 21s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7643e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189222). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "181/237 [=====================>........] - ETA: 20s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7689e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138637). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.107965). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "212/237 [=========================>....] - ETA: 9s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6441e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134349). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "214/237 [==========================>...] - ETA: 8s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6544e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180076). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190431). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "215/237 [==========================>...] - ETA: 8s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6964e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223946). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "217/237 [==========================>...] - ETA: 7s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6737e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224846). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "218/237 [==========================>...] - ETA: 7s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8344e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230150). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "220/237 [==========================>...] - ETA: 6s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.8626e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231301). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "223/237 [===========================>..] - ETA: 5s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.8106e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234405). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "226/237 [===========================>..] - ETA: 4s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.8423e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220033). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "229/237 [===========================>..] - ETA: 2s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.7980e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193623). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "232/237 [============================>.] - ETA: 1s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.7490e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159537). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 90s 380ms/step - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7104e-04 - denoise_loss: 0.1186 - val_loss: 0.2237 - val_denoiseg: 0.2237 - val_seg_loss: 0.1060 - val_denoise_loss: 0.1177\n",
+      "Epoch 77/200\n",
+      " 22/237 [=>............................] - ETA: 1:02 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 2.1238e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141551). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 23/237 [=>............................] - ETA: 1:02 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 2.1194e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158441). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 26/237 [==>...........................] - ETA: 1:03 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.2565e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168697). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151806). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 28/237 [==>...........................] - ETA: 1:04 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.0953e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154472). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 29/237 [==>...........................] - ETA: 1:04 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.0230e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.137587). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 30/237 [==>...........................] - ETA: 1:04 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 1.9556e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.130358). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 87/237 [==========>...................] - ETA: 54s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7784e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186878). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 88/237 [==========>...................] - ETA: 54s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7469e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213774). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 90/237 [==========>...................] - ETA: 53s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7156e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196682). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 92/237 [==========>...................] - ETA: 53s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8435e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195417). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 95/237 [===========>..................] - ETA: 52s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9126e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191869). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222318). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 96/237 [===========>..................] - ETA: 51s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8823e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194949). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 99/237 [===========>..................] - ETA: 50s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.7950e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225021). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "101/237 [===========>..................] - ETA: 50s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.7396e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223915). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "106/237 [============>.................] - ETA: 48s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8142e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221007). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "108/237 [============>.................] - ETA: 47s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7620e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219134). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "109/237 [============>.................] - ETA: 47s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7367e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203157). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 45s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6259e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.181674). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "119/237 [==============>...............] - ETA: 43s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6099e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171121). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179927). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 42s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5250e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179820). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 41s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5920e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177930). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "131/237 [===============>..............] - ETA: 39s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.4938e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172916). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "135/237 [================>.............] - ETA: 37s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5585e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177654). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "136/237 [================>.............] - ETA: 37s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6599e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198408). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "138/237 [================>.............] - ETA: 36s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6343e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201500). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "141/237 [================>.............] - ETA: 36s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6298e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226573). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229375). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "144/237 [=================>............] - ETA: 34s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5974e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230137). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230235). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "146/237 [=================>............] - ETA: 33s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6806e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228406). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "147/237 [=================>............] - ETA: 33s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6624e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227526). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "148/237 [=================>............] - ETA: 33s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6446e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225603). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "149/237 [=================>............] - ETA: 32s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6385e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221368). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "151/237 [==================>...........] - ETA: 32s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6036e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202609). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "152/237 [==================>...........] - ETA: 31s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5864e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199883). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "154/237 [==================>...........] - ETA: 30s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5591e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187340). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "161/237 [===================>..........] - ETA: 28s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5582e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165813). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "165/237 [===================>..........] - ETA: 26s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.4964e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.130752). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "166/237 [====================>.........] - ETA: 26s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5463e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139629). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "168/237 [====================>.........] - ETA: 25s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5250e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176993). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "173/237 [====================>.........] - ETA: 23s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5997e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174946). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "175/237 [=====================>........] - ETA: 23s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6758e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167217). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "178/237 [=====================>........] - ETA: 22s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7095e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190281). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178534). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "184/237 [======================>.......] - ETA: 19s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6612e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183701). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "186/237 [======================>.......] - ETA: 19s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6416e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167130). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "187/237 [======================>.......] - ETA: 18s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6276e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161260). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "189/237 [======================>.......] - ETA: 17s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6928e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144618). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "202/237 [========================>.....] - ETA: 13s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7424e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155232). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "204/237 [========================>.....] - ETA: 12s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8048e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190321). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "207/237 [=========================>....] - ETA: 11s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7836e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210778). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222665). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "208/237 [=========================>....] - ETA: 10s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7702e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221044). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "209/237 [=========================>....] - ETA: 10s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7939e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224230). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "210/237 [=========================>....] - ETA: 10s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7880e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213965). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "212/237 [=========================>....] - ETA: 9s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7617e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198284). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "213/237 [=========================>....] - ETA: 8s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7654e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195111). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "214/237 [==========================>...] - ETA: 8s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7524e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218755). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "216/237 [==========================>...] - ETA: 7s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7369e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222105). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "220/237 [==========================>...] - ETA: 6s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7745e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218932). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221639). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "223/237 [===========================>..] - ETA: 5s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8274e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222412). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "224/237 [===========================>..] - ETA: 4s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8148e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223183). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "225/237 [===========================>..] - ETA: 4s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8095e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221769). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "227/237 [===========================>..] - ETA: 3s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7847e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214188). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "229/237 [===========================>..] - ETA: 2s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7983e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199177). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "231/237 [============================>.] - ETA: 2s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7742e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186689). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "233/237 [============================>.] - ETA: 1s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7503e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146703). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 90s 380ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8134e-04 - denoise_loss: 0.1184 - val_loss: 0.2307 - val_denoiseg: 0.2307 - val_seg_loss: 0.1129 - val_denoise_loss: 0.1178\n",
+      "Epoch 78/200\n",
+      "  2/237 [..............................] - ETA: 1:04 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 9.0868e-05 - denoise_loss: 0.1199"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.266956). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170807). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  5/237 [..............................] - ETA: 1:17 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 2.8101e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.250638). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234320). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  7/237 [..............................] - ETA: 1:08 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 2.0072e-04 - denoise_loss: 0.1195"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173302). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  9/237 [>.............................] - ETA: 1:10 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 1.7563e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234923). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 88/237 [==========>...................] - ETA: 56s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3739e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139971). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 55s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2310e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179098). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140570). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 96/237 [===========>..................] - ETA: 54s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1300e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156821). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 98/237 [===========>..................] - ETA: 53s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0977e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190996). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 99/237 [===========>..................] - ETA: 52s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0352e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208608). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "140/237 [================>.............] - ETA: 36s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.3963e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145318). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "143/237 [=================>............] - ETA: 35s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.3251e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161421). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 34s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2396e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211883). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "149/237 [=================>............] - ETA: 33s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2517e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218044). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "151/237 [==================>...........] - ETA: 32s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2211e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221547). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "154/237 [==================>...........] - ETA: 31s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2230e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224661). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "155/237 [==================>...........] - ETA: 31s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2261e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211296). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "158/237 [===================>..........] - ETA: 30s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2244e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192323). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "160/237 [===================>..........] - ETA: 29s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.1938e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186871). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "162/237 [===================>..........] - ETA: 28s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.1545e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192485). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "165/237 [===================>..........] - ETA: 27s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.1720e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197113). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209882). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209058). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "167/237 [====================>.........] - ETA: 26s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2638e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200903). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "168/237 [====================>.........] - ETA: 26s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.3588e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213671). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223739). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "170/237 [====================>.........] - ETA: 25s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4051e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217434). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "172/237 [====================>.........] - ETA: 24s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.3655e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209279). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "174/237 [=====================>........] - ETA: 23s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.3337e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200701). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 23s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.3043e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204464). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "178/237 [=====================>........] - ETA: 22s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2671e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173949). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "180/237 [=====================>........] - ETA: 21s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2886e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182527). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169538). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "182/237 [======================>.......] - ETA: 20s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.3272e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158515). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "184/237 [======================>.......] - ETA: 20s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2910e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195142). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "185/237 [======================>.......] - ETA: 19s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2899e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191983). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "187/237 [======================>.......] - ETA: 19s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2940e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200062). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "190/237 [=======================>......] - ETA: 17s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4770e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171986). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "194/237 [=======================>......] - ETA: 16s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4598e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185873). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171800). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "196/237 [=======================>......] - ETA: 15s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4477e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165678). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "201/237 [========================>.....] - ETA: 13s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.3768e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160287). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "204/237 [========================>.....] - ETA: 12s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.3713e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163365). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "210/237 [=========================>....] - ETA: 10s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4078e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141109). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "212/237 [=========================>....] - ETA: 9s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4817e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177682). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "215/237 [==========================>...] - ETA: 8s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4478e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141804). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189309). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "218/237 [==========================>...] - ETA: 7s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4003e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196561). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "219/237 [==========================>...] - ETA: 6s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.3848e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223729). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "220/237 [==========================>...] - ETA: 6s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.3694e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225989). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "224/237 [===========================>..] - ETA: 4s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.4280e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216811). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206831). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "226/237 [===========================>..] - ETA: 4s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.4080e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155393). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "227/237 [===========================>..] - ETA: 3s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3930e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168388). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 92s 387ms/step - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2907e-04 - denoise_loss: 0.1186 - val_loss: 0.2288 - val_denoiseg: 0.2288 - val_seg_loss: 0.1110 - val_denoise_loss: 0.1178\n",
+      "Epoch 79/200\n",
+      "  2/237 [..............................] - ETA: 31s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 8.8684e-05 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.242081). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  3/237 [..............................] - ETA: 1:10 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 3.1288e-04 - denoise_loss: 0.1179"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.241658). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  5/237 [..............................] - ETA: 1:10 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 7.0752e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233769). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226303). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  7/237 [..............................] - ETA: 1:06 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 5.1412e-04 - denoise_loss: 0.1177"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231517). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 13/237 [>.............................] - ETA: 1:13 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 3.2431e-04 - denoise_loss: 0.1179 ETA: 1:12 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.5379e-04 - denoise_loss: 0."
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231320). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 14/237 [>.............................] - ETA: 1:14 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.7807e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229891). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236534). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 22/237 [=>............................] - ETA: 1:06 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 1.8958e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199869). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164714). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 28/237 [==>...........................] - ETA: 1:04 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.4083e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.133792). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 32/237 [===>..........................] - ETA: 1:03 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.2771e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197169). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 33/237 [===>..........................] - ETA: 1:04 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.2853e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227565). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 35/237 [===>..........................] - ETA: 1:04 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.1557e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222526). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192130). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160058). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 44/237 [====>.........................] - ETA: 1:03 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9832e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218149). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 46/237 [====>.........................] - ETA: 1:02 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9335e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150103). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 51/237 [=====>........................] - ETA: 1:01 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.9919e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154500). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 53/237 [=====>........................] - ETA: 1:01 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.8698e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225500). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 57/237 [======>.......................] - ETA: 1:00 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9247e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228423). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/237 [======>.......................] - ETA: 1:00 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1567e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228692). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 61/237 [======>.......................] - ETA: 59s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2830e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226988). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224736). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 68/237 [=======>......................] - ETA: 57s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.0485e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208886). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 69/237 [=======>......................] - ETA: 57s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.0043e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198513). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/237 [========>.....................] - ETA: 56s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.8398e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179262). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 56s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.7936e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206497). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 79/237 [=========>....................] - ETA: 55s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.7471e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215165). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 83/237 [=========>....................] - ETA: 54s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.7759e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196024). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 88/237 [==========>...................] - ETA: 53s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.8376e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193837). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 91/237 [==========>...................] - ETA: 52s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.7442e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215019). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 52s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.6855e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225197). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 94/237 [==========>...................] - ETA: 52s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.8375e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235551). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 95/237 [===========>..................] - ETA: 51s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.8077e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.251714). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 96/237 [===========>..................] - ETA: 51s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.7784e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.263780). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "113/237 [=============>................] - ETA: 46s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.8071e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191195). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 46s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.8200e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200261). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "120/237 [==============>...............] - ETA: 44s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9752e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204667). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 43s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.0456e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222672). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215500). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "124/237 [==============>...............] - ETA: 43s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.0454e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211287). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "127/237 [===============>..............] - ETA: 42s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9812e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180089). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "130/237 [===============>..............] - ETA: 41s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9547e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174646). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "132/237 [===============>..............] - ETA: 40s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9552e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206011). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "134/237 [===============>..............] - ETA: 39s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9111e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171573). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "136/237 [================>.............] - ETA: 38s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.8751e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186828). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "141/237 [================>.............] - ETA: 36s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.7971e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173277). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "142/237 [================>.............] - ETA: 36s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.7774e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193938). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "143/237 [=================>............] - ETA: 36s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8622e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212008). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "145/237 [=================>............] - ETA: 35s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8228e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187591). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 34s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8842e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166930). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "148/237 [=================>............] - ETA: 34s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8647e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151813). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 384ms/step - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9905e-04 - denoise_loss: 0.1186 - val_loss: 0.2316 - val_denoiseg: 0.2316 - val_seg_loss: 0.1138 - val_denoise_loss: 0.1179\n",
+      "Epoch 80/200\n",
+      "  7/237 [..............................] - ETA: 1:05 - loss: 0.1176 - denoiseg: 0.1176 - seg_loss: 5.4949e-05 - denoise_loss: 0.1175 ETA: 58s - loss: 0.1177 - denoiseg: 0.1177 - seg_loss: 4.7924e-05 - denoise_loss: 0.1"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173915). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 12/237 [>.............................] - ETA: 1:06 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 1.5421e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170164). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 13/237 [>.............................] - ETA: 1:07 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 1.4234e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225320). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 14/237 [>.............................] - ETA: 1:08 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 1.3218e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.132479). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/237 [=>............................] - ETA: 1:14 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7011e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189091). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 19/237 [=>............................] - ETA: 1:15 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9157e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219335). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 25/237 [==>...........................] - ETA: 1:19 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.4136e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194246). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 27/237 [==>...........................] - ETA: 1:20 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.5894e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196947). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 29/237 [==>...........................] - ETA: 1:20 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.4108e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171272). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 36/237 [===>..........................] - ETA: 1:18 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.4979e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135287). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:17 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.1282e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164367). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 51/237 [=====>........................] - ETA: 1:12 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7346e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144027). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153809). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 53/237 [=====>........................] - ETA: 1:11 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.8085e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164596). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:10 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6710e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193249). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 60/237 [======>.......................] - ETA: 1:08 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4263e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147923). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 63/237 [======>.......................] - ETA: 1:07 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4966e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146011). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221121). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 65/237 [=======>......................] - ETA: 1:06 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3891e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233997). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221033). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 69/237 [=======>......................] - ETA: 1:05 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.2304e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233545). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220669). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 71/237 [=======>......................] - ETA: 1:04 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1801e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222580). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/237 [========>.....................] - ETA: 1:03 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.2412e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203815). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147926). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 1:01 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1205e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200334). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 79/237 [=========>....................] - ETA: 1:01 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0810e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155665). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 57s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1207e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220538). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 94/237 [==========>...................] - ETA: 56s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1652e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223706). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 98/237 [===========>..................] - ETA: 54s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0575e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220880). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "101/237 [===========>..................] - ETA: 53s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1655e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220377). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "104/237 [============>.................] - ETA: 52s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2643e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204162). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "106/237 [============>.................] - ETA: 51s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.2027e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193307). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.137797). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "108/237 [============>.................] - ETA: 50s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1434e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193595). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "109/237 [============>.................] - ETA: 50s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1307e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222125). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "111/237 [=============>................] - ETA: 49s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2038e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165779). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 47s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0924e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195657). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 47s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0395e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228925). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227687). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "118/237 [=============>................] - ETA: 46s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0424e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230962). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 45s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0079e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208069). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "125/237 [==============>...............] - ETA: 43s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9995e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200325). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "130/237 [===============>..............] - ETA: 41s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9226e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196724). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "133/237 [===============>..............] - ETA: 40s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9847e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206085). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "136/237 [================>.............] - ETA: 39s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9189e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199044). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182013). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "142/237 [================>.............] - ETA: 37s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8023e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218093). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217388). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "143/237 [=================>............] - ETA: 36s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7827e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211295). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "149/237 [=================>............] - ETA: 34s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8458e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175461). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "152/237 [==================>...........] - ETA: 33s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7896e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180354). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167415). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "157/237 [==================>...........] - ETA: 31s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7178e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196855). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "158/237 [===================>..........] - ETA: 30s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7006e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194462). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "165/237 [===================>..........] - ETA: 28s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.6985e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206990). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "166/237 [====================>.........] - ETA: 27s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6823e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215030). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222123). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "168/237 [====================>.........] - ETA: 26s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6504e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223601). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "170/237 [====================>.........] - ETA: 26s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6192e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220368). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "173/237 [====================>.........] - ETA: 24s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6289e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224879). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "175/237 [=====================>........] - ETA: 24s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5989e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227921). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "180/237 [=====================>........] - ETA: 22s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7043e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215819). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "183/237 [======================>.......] - ETA: 20s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6791e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198376). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193036). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "185/237 [======================>.......] - ETA: 20s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6502e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167299). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "186/237 [======================>.......] - ETA: 19s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6688e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198369). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "187/237 [======================>.......] - ETA: 19s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6624e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155475). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "190/237 [=======================>......] - ETA: 18s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6801e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174345). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "191/237 [=======================>......] - ETA: 17s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7333e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230036). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "194/237 [=======================>......] - ETA: 16s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7975e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212392). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228529). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "195/237 [=======================>......] - ETA: 16s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7896e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211618). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "197/237 [=======================>......] - ETA: 15s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8410e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180812). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "198/237 [========================>.....] - ETA: 15s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8267e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210706). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "200/237 [========================>.....] - ETA: 14s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8354e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161961). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "206/237 [=========================>....] - ETA: 12s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8722e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.137666). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "223/237 [===========================>..] - ETA: 5s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9040e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145554). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "224/237 [===========================>..] - ETA: 5s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8911e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163496). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "227/237 [===========================>..] - ETA: 3s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9296e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189904). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "229/237 [===========================>..] - ETA: 3s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9646e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214408). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196149). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "230/237 [============================>.] - ETA: 2s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9517e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219525). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "233/237 [============================>.] - ETA: 1s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9137e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224592). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "234/237 [============================>.] - ETA: 1s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9013e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232581). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "235/237 [============================>.] - ETA: 0s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8974e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228643). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "236/237 [============================>.] - ETA: 0s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8852e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227515). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 93s 393ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8730e-04 - denoise_loss: 0.1184 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1114 - val_denoise_loss: 0.1179\n",
+      "Epoch 81/200\n",
+      "  4/237 [..............................] - ETA: 1:09 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 1.8252e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232955). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  8/237 [>.............................] - ETA: 1:06 - loss: 0.1202 - denoiseg: 0.1202 - seg_loss: 4.6912e-04 - denoise_loss: 0.1197"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209991). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187027). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 11/237 [>.............................] - ETA: 1:10 - loss: 0.1197 - denoiseg: 0.1197 - seg_loss: 4.4027e-04 - denoise_loss: 0.1193"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234274). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 13/237 [>.............................] - ETA: 1:15 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.4619e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236577). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.241162). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 15/237 [>.............................] - ETA: 1:17 - loss: 0.1194 - denoiseg: 0.1194 - seg_loss: 4.8188e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.275586). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.285045). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 17/237 [=>............................] - ETA: 1:19 - loss: 0.1195 - denoiseg: 0.1195 - seg_loss: 4.4685e-04 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.304067). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 18/237 [=>............................] - ETA: 1:20 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.2203e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.306634). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 23/237 [=>............................] - ETA: 1:19 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 5.0845e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.285081). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.266059). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 25/237 [==>...........................] - ETA: 1:20 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 4.8250e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.262537). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 26/237 [==>...........................] - ETA: 1:20 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 5.0043e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.251856). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 29/237 [==>...........................] - ETA: 1:21 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.6604e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.255786). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.266450). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 31/237 [==>...........................] - ETA: 1:21 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.5945e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.293104). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.301745). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 32/237 [===>..........................] - ETA: 1:21 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.4509e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.303101). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 33/237 [===>..........................] - ETA: 1:21 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.3168e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.304469). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 35/237 [===>..........................] - ETA: 1:21 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.7280e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.299770). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 37/237 [===>..........................] - ETA: 1:21 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.6178e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.306409). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 41/237 [====>.........................] - ETA: 1:20 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.4075e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.298411). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.284131). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 42/237 [====>.........................] - ETA: 1:20 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.3037e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.243579). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 44/237 [====>.........................] - ETA: 1:20 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.5582e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194340). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169738). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 46/237 [====>.........................] - ETA: 1:19 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.4286e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157039). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 87/237 [==========>...................] - ETA: 1:04 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3363e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139579). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 88/237 [==========>...................] - ETA: 1:03 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2984e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154683). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 91/237 [==========>...................] - ETA: 1:02 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1897e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188415). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 1:01 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1358e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229291). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 95/237 [===========>..................] - ETA: 1:01 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0855e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237445). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 97/237 [===========>..................] - ETA: 1:00 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1314e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214888). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 98/237 [===========>..................] - ETA: 59s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0995e-04 - denoise_loss: 0.1184 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235178). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "101/237 [===========>..................] - ETA: 58s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0115e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231308). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "102/237 [===========>..................] - ETA: 57s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9820e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219412). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202992). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "107/237 [============>.................] - ETA: 55s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9360e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230710). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "110/237 [============>.................] - ETA: 53s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8594e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232957). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "114/237 [=============>................] - ETA: 52s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8569e-04 - denoise_loss: 0.1185- ETA: 52s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8638e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233030). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221892). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 50s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8223e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190351). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148609). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "119/237 [==============>...............] - ETA: 49s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8469e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185972). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "120/237 [==============>...............] - ETA: 49s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8232e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182481). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 47s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0629e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134946). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "125/237 [==============>...............] - ETA: 46s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0139e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154231). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "126/237 [==============>...............] - ETA: 46s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9900e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169157). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "134/237 [===============>..............] - ETA: 42s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1586e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173602). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170739). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "135/237 [================>.............] - ETA: 42s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1352e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186263). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "139/237 [================>.............] - ETA: 40s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1932e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142459). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "149/237 [=================>............] - ETA: 36s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0195e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165920). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172375). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "151/237 [==================>...........] - ETA: 35s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2426e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191244). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "154/237 [==================>...........] - ETA: 34s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1795e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163216). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "157/237 [==================>...........] - ETA: 32s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1245e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134375). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "159/237 [===================>..........] - ETA: 31s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1245e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153245). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "162/237 [===================>..........] - ETA: 30s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0918e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185676). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "165/237 [===================>..........] - ETA: 29s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0401e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212082). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203150). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "167/237 [====================>.........] - ETA: 28s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1986e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201439). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "168/237 [====================>.........] - ETA: 28s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2272e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227844). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "180/237 [=====================>........] - ETA: 23s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1572e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.136677). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "183/237 [======================>.......] - ETA: 21s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2080e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147233). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "184/237 [======================>.......] - ETA: 21s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2295e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169880). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "185/237 [======================>.......] - ETA: 21s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2122e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190821). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "187/237 [======================>.......] - ETA: 20s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1779e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216325). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "189/237 [======================>.......] - ETA: 19s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1444e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201779). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180838). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "191/237 [=======================>......] - ETA: 18s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1115e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218582). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "194/237 [=======================>......] - ETA: 17s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1938e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219626). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217936). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "199/237 [========================>.....] - ETA: 15s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2328e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223708). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "200/237 [========================>.....] - ETA: 14s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2166e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231469). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "201/237 [========================>.....] - ETA: 14s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2009e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233200). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231478). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "204/237 [========================>.....] - ETA: 13s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2862e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225438). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "206/237 [=========================>....] - ETA: 12s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2543e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221771). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198149). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "208/237 [=========================>....] - ETA: 11s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2230e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207950). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188432). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "210/237 [=========================>....] - ETA: 10s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1923e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170095). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "213/237 [=========================>....] - ETA: 9s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2137e-04 - denoise_loss: 0.1184 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212054). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "214/237 [==========================>...] - ETA: 9s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1988e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179896). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "215/237 [==========================>...] - ETA: 8s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1839e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155230). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 96s 406ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0218e-04 - denoise_loss: 0.1184 - val_loss: 0.2298 - val_denoiseg: 0.2298 - val_seg_loss: 0.1121 - val_denoise_loss: 0.1178\n",
+      "Epoch 82/200\n",
+      " 11/237 [>.............................] - ETA: 1:00 - loss: 0.1176 - denoiseg: 0.1176 - seg_loss: 2.1158e-04 - denoise_loss: 0.11 - ETA: 1:03 - loss: 0.1180 - denoiseg: 0.1180 - seg_loss: 1.9253e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140891). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 12/237 [>.............................] - ETA: 1:05 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 2.3654e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193157). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 15/237 [>.............................] - ETA: 1:08 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.4666e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236171). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 17/237 [=>............................] - ETA: 1:05 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 3.3539e-04 - denoise_loss: 0.1179"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189247). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 18/237 [=>............................] - ETA: 1:05 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 3.3847e-04 - denoise_loss: 0.1179"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190372). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 20/237 [=>............................] - ETA: 1:07 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.8636e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237296). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 22/237 [=>............................] - ETA: 1:07 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 3.5123e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155673). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 26/237 [==>...........................] - ETA: 1:08 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 4.2877e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180596). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 28/237 [==>...........................] - ETA: 1:08 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 5.2890e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215294). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 29/237 [==>...........................] - ETA: 1:08 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 5.1066e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215743). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 31/237 [==>...........................] - ETA: 1:08 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 4.8612e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161310). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 37/237 [===>..........................] - ETA: 1:08 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 5.6556e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178373). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 39/237 [===>..........................] - ETA: 1:08 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 5.4147e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139241). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 41/237 [====>.........................] - ETA: 1:07 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 5.4492e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196628). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 42/237 [====>.........................] - ETA: 1:07 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 5.3195e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197827). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 45/237 [====>.........................] - ETA: 1:06 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.9649e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165239). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 48/237 [=====>........................] - ETA: 1:06 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.6552e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177941). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/237 [========>.....................] - ETA: 58s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6670e-04 - denoise_loss: 0.1184- ETA: 59s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8058e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151305). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 58s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7000e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155841). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 77/237 [========>.....................] - ETA: 57s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6356e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164864). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 78/237 [========>.....................] - ETA: 57s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7879e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173591). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 56s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6942e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195643). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 81/237 [=========>....................] - ETA: 56s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6486e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168988). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 83/237 [=========>....................] - ETA: 57s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.5606e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186917). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218720). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 88/237 [==========>...................] - ETA: 55s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5667e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203171). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199947). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 89/237 [==========>...................] - ETA: 55s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.5268e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190705). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 95/237 [===========>..................] - ETA: 52s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.5041e-04 - denoise_loss: 0.1185- ETA: 53s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.5413e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177948). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 98/237 [===========>..................] - ETA: 51s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3969e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197883). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "102/237 [===========>..................] - ETA: 50s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3145e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199477). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182929). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "104/237 [============>.................] - ETA: 49s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2941e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207268). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "105/237 [============>.................] - ETA: 49s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2627e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198184). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "110/237 [============>.................] - ETA: 47s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2991e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198729). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "112/237 [=============>................] - ETA: 46s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2402e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211022). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "113/237 [=============>................] - ETA: 46s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2115e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213620). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 45s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1285e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220311). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "118/237 [=============>................] - ETA: 44s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1816e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218781). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "121/237 [==============>...............] - ETA: 43s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2176e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199506). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "122/237 [==============>...............] - ETA: 42s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3883e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190498). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "124/237 [==============>...............] - ETA: 42s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3337e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208134). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 41s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2807e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203623). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "132/237 [===============>..............] - ETA: 39s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2699e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152455). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "142/237 [================>.............] - ETA: 35s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2303e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156178). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 33s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3538e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.129840). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "152/237 [==================>...........] - ETA: 31s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3584e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146786). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "153/237 [==================>...........] - ETA: 31s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3365e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185736). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "156/237 [==================>...........] - ETA: 30s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2916e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163681). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "160/237 [===================>..........] - ETA: 28s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2342e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186371). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168336). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "164/237 [===================>..........] - ETA: 27s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2830e-04 - denoise_loss: 0.1184- ETA: 28s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3235e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196696). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "165/237 [===================>..........] - ETA: 27s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2631e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216768). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "167/237 [====================>.........] - ETA: 26s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2270e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221984). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207582). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "170/237 [====================>.........] - ETA: 25s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2444e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219936). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "172/237 [====================>.........] - ETA: 24s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2624e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223509). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216371). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "174/237 [=====================>........] - ETA: 23s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2249e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194247). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 22s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2065e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.131779). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "177/237 [=====================>........] - ETA: 22s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2724e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197819). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "178/237 [=====================>........] - ETA: 22s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2541e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161364). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "180/237 [=====================>........] - ETA: 21s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2337e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201640). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "183/237 [======================>.......] - ETA: 20s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1807e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202337). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176990). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "188/237 [======================>.......] - ETA: 18s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1260e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174850). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "191/237 [=======================>......] - ETA: 17s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1125e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200197). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "193/237 [=======================>......] - ETA: 16s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1054e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204585). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230782). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "197/237 [=======================>......] - ETA: 15s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0424e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232017). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "200/237 [========================>.....] - ETA: 13s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.0977e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231349). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225481). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "203/237 [========================>.....] - ETA: 12s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.1152e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194993). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "205/237 [========================>.....] - ETA: 12s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.0849e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187925). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182557). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "206/237 [=========================>....] - ETA: 11s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.0699e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193796). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "208/237 [=========================>....] - ETA: 10s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.0718e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177321). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "211/237 [=========================>....] - ETA: 9s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.1103e-04 - denoise_loss: 0.1186 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184187). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 383ms/step - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.0738e-04 - denoise_loss: 0.1187 - val_loss: 0.2304 - val_denoiseg: 0.2304 - val_seg_loss: 0.1126 - val_denoise_loss: 0.1178\n",
+      "Epoch 83/200\n",
+      "  3/237 [..............................] - ETA: 1:00 - loss: 0.1199 - denoiseg: 0.1199 - seg_loss: 5.7112e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155798). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 20/237 [=>............................] - ETA: 1:05 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 3.0437e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152292). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 22/237 [=>............................] - ETA: 1:06 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.7670e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178724). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 23/237 [=>............................] - ETA: 1:07 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.6467e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177012). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 25/237 [==>...........................] - ETA: 1:07 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.9149e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192951). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193196). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 27/237 [==>...........................] - ETA: 1:07 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.6990e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213959). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 30/237 [==>...........................] - ETA: 1:07 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.4291e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191483). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 33/237 [===>..........................] - ETA: 1:07 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.5145e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205738). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 35/237 [===>..........................] - ETA: 1:07 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.7095e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170125). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 36/237 [===>..........................] - ETA: 1:07 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.7024e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176986). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 39/237 [===>..........................] - ETA: 1:07 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1009e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156090). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 43/237 [====>.........................] - ETA: 1:05 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.9752e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.136300). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 52/237 [=====>........................] - ETA: 1:04 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.7802e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.132022). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 53/237 [=====>........................] - ETA: 1:03 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.7278e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156750). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 57/237 [======>.......................] - ETA: 1:03 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.6199e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157281). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 61/237 [======>.......................] - ETA: 1:01 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.8578e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162359). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 65/237 [=======>......................] - ETA: 1:00 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.9449e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153445). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 68/237 [=======>......................] - ETA: 59s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.0014e-04 - denoise_loss: 0.1187 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157386). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 70/237 [=======>......................] - ETA: 59s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.9160e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189915). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150733). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 71/237 [=======>......................] - ETA: 59s - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1848e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.133417). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105/237 [============>.................] - ETA: 49s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9729e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147950). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "106/237 [============>.................] - ETA: 49s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9448e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161109). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "108/237 [============>.................] - ETA: 48s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.8903e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158523). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "112/237 [=============>................] - ETA: 47s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.8019e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155529). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "113/237 [=============>................] - ETA: 46s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.7771e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172140). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 46s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9405e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192407). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 45s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9738e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155987). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "121/237 [==============>...............] - ETA: 43s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.0382e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216339). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 43s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.0232e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202192). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "127/237 [===============>..............] - ETA: 41s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9409e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184390). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "129/237 [===============>..............] - ETA: 40s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.8955e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209911). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229984). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228599). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "131/237 [===============>..............] - ETA: 40s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9689e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208526). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200746). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "133/237 [===============>..............] - ETA: 39s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.0101e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166787). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "135/237 [================>.............] - ETA: 38s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9655e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144952). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "144/237 [=================>............] - ETA: 35s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0075e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.130869). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "146/237 [=================>............] - ETA: 34s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9760e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153526). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195654). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "151/237 [==================>...........] - ETA: 32s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1132e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180352). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "158/237 [===================>..........] - ETA: 29s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0879e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187647). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183467). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "160/237 [===================>..........] - ETA: 29s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.1061e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192930). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "161/237 [===================>..........] - ETA: 28s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.1562e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190396). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "162/237 [===================>..........] - ETA: 28s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1545e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208520). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "164/237 [===================>..........] - ETA: 27s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1161e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217767). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "171/237 [====================>.........] - ETA: 25s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1593e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142436). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "172/237 [====================>.........] - ETA: 24s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1911e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134174). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "175/237 [=====================>........] - ETA: 23s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1367e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201475). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "177/237 [=====================>........] - ETA: 22s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1454e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216172). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218129). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179/237 [=====================>........] - ETA: 21s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1607e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232949). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 21s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1258e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234144). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "183/237 [======================>.......] - ETA: 20s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1012e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233358). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217344). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "184/237 [======================>.......] - ETA: 20s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1034e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226249). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "187/237 [======================>.......] - ETA: 18s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0538e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168301). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "190/237 [=======================>......] - ETA: 17s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0056e-04 - denoise_loss: 0.1185- ETA: 18s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0215e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197863). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "192/237 [=======================>......] - ETA: 17s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0964e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141433). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "193/237 [=======================>......] - ETA: 16s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0966e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187640). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "197/237 [=======================>......] - ETA: 15s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0337e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204218). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "199/237 [========================>.....] - ETA: 14s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0839e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146192). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "202/237 [========================>.....] - ETA: 13s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0381e-04 - denoise_loss: 0.1185- ETA: 13s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0532e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178061). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "204/237 [========================>.....] - ETA: 12s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0196e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210315). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184158). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "206/237 [=========================>....] - ETA: 11s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9902e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216943). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220440). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "207/237 [=========================>....] - ETA: 11s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9850e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211134). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "208/237 [=========================>....] - ETA: 11s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9870e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230434). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "210/237 [=========================>....] - ETA: 10s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9727e-04 - denoise_loss: 0.118 - ETA: 10s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9586e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233293). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "214/237 [==========================>...] - ETA: 8s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9084e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200240). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "216/237 [==========================>...] - ETA: 7s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8815e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190514). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "221/237 [==========================>...] - ETA: 6s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8745e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182506). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134561). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "222/237 [===========================>..] - ETA: 5s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8615e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188217). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "225/237 [===========================>..] - ETA: 4s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8722e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188809). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "229/237 [===========================>..] - ETA: 3s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8486e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192277). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "231/237 [============================>.] - ETA: 2s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8258e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204787). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "233/237 [============================>.] - ETA: 1s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8079e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201476). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "234/237 [============================>.] - ETA: 1s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8042e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167913). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 92s 387ms/step - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8388e-04 - denoise_loss: 0.1185 - val_loss: 0.2289 - val_denoiseg: 0.2289 - val_seg_loss: 0.1112 - val_denoise_loss: 0.1177\n",
+      "Epoch 84/200\n",
+      " 27/237 [==>...........................] - ETA: 1:06 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.9336e-04 - denoise_loss: 0.1187 ETA: 38s - loss: 0.1202 - denoiseg: 0.1202 - seg_loss"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147648). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 28/237 [==>...........................] - ETA: 1:06 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.7574e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160452). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 32/237 [===>..........................] - ETA: 1:06 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.2054e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189364). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143684). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 34/237 [===>..........................] - ETA: 1:06 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.9584e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193060). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 36/237 [===>..........................] - ETA: 1:06 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8208e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166579). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 37/237 [===>..........................] - ETA: 1:06 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.7186e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204722). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 39/237 [===>..........................] - ETA: 1:06 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.5279e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233167). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 41/237 [====>.........................] - ETA: 1:05 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.6969e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229728). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201675). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 46/237 [====>.........................] - ETA: 1:05 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.2264e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230120). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 47/237 [====>.........................] - ETA: 1:04 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.3536e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222509). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 49/237 [=====>........................] - ETA: 1:04 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.4978e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196776). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 52/237 [=====>........................] - ETA: 1:03 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.7303e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192385). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176071). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 54/237 [=====>........................] - ETA: 1:03 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.6307e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170675). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:03 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.6963e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164944). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 57/237 [======>.......................] - ETA: 1:02 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.6139e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146708). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/237 [======>.......................] - ETA: 1:02 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.6187e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165799). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140522). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 60/237 [======>.......................] - ETA: 1:02 - loss: 0.1193 - denoiseg: 0.1193 - seg_loss: 4.5417e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155982). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 61/237 [======>.......................] - ETA: 1:01 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.5205e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158055). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 64/237 [=======>......................] - ETA: 1:00 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.3086e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170049). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 56s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.9965e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174862). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 82/237 [=========>....................] - ETA: 55s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.1104e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206935). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 87/237 [==========>...................] - ETA: 55s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.0056e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208815). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158004). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 88/237 [==========>...................] - ETA: 55s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.1405e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173204). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 92/237 [==========>...................] - ETA: 53s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.2169e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173037). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 94/237 [==========>...................] - ETA: 53s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.2928e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210357). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231639). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 96/237 [===========>..................] - ETA: 52s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.2247e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231176). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 97/237 [===========>..................] - ETA: 52s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.1811e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209894). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232055). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "101/237 [===========>..................] - ETA: 50s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.1236e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232751). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "102/237 [===========>..................] - ETA: 50s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.0831e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213480). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "103/237 [============>.................] - ETA: 50s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.0435e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195732). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105/237 [============>.................] - ETA: 49s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.1754e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164701). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "109/237 [============>.................] - ETA: 48s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.0995e-04 - denoise_loss: 0.1184- ETA: 48s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.0973e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214407). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "113/237 [=============>................] - ETA: 46s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.2589e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207884). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207242). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 45s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.1850e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190263). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 45s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.2953e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184874). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "122/237 [==============>...............] - ETA: 43s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.2059e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191242). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "125/237 [==============>...............] - ETA: 42s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.1738e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198241). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "128/237 [===============>..............] - ETA: 41s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.0760e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200882). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "130/237 [===============>..............] - ETA: 40s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.0134e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205104). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "131/237 [===============>..............] - ETA: 40s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.9828e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206666). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "132/237 [===============>..............] - ETA: 39s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.9526e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220427). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "134/237 [===============>..............] - ETA: 38s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.9116e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221492). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "138/237 [================>.............] - ETA: 37s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.9084e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200566). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "140/237 [================>.............] - ETA: 36s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8591e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179775). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "141/237 [================>.............] - ETA: 36s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8317e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191828). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 34s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.0242e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212203). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "149/237 [=================>............] - ETA: 33s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.9702e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223248). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "151/237 [==================>...........] - ETA: 32s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.9546e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197101). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "153/237 [==================>...........] - ETA: 31s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.9220e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178409). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 31s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8809e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174214). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "157/237 [==================>...........] - ETA: 30s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8463e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158802). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "162/237 [===================>..........] - ETA: 28s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8791e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203206). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199011). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "164/237 [===================>..........] - ETA: 27s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8924e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226851). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231396). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "165/237 [===================>..........] - ETA: 27s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8688e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231682). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "167/237 [====================>.........] - ETA: 26s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8225e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235893). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "169/237 [====================>.........] - ETA: 25s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8043e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232884). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "171/237 [====================>.........] - ETA: 24s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.7983e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234089). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "173/237 [====================>.........] - ETA: 24s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.7544e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235167). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232158). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "174/237 [=====================>........] - ETA: 23s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.7328e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208956). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "175/237 [=====================>........] - ETA: 23s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.7115e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168956). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "216/237 [==========================>...] - ETA: 7s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4901e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146841). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "217/237 [==========================>...] - ETA: 7s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.5436e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190750). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "220/237 [==========================>...] - ETA: 6s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.5113e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203851). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "221/237 [==========================>...]1188 - seg_loss: 3.4954e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231863). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "223/237 [===========================>..] - ETA: 5s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4725e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234862). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "224/237 [===========================>..] - ETA: 4s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4758e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230726). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "226/237 [===========================>..] - ETA: 4s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4450e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228708). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "227/237 [===========================>..] - ETA: 3s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4299e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226069). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "228/237 [===========================>..] - ETA: 3s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4148e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220076). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 384ms/step - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4141e-04 - denoise_loss: 0.1184 - val_loss: 0.2280 - val_denoiseg: 0.2280 - val_seg_loss: 0.1102 - val_denoise_loss: 0.1178\n",
+      "Epoch 85/200\n",
+      " 91/237 [==========>...................] - ETA: 54s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2620e-04 - denoise_loss: 0.1185- ETA: 55s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2696e-04 - denoise_loss: 0.118 - ETA: 55s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3353e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227049). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204275). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 53s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2466e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212200). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213977). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 96/237 [===========>..................] - ETA: 52s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2775e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218478). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 99/237 [===========>..................] - ETA: 51s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1781e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206846). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "102/237 [===========>..................] - ETA: 50s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1194e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218820). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212925). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105/237 [============>.................] - ETA: 49s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0991e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208119). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196146). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "108/237 [============>.................] - ETA: 48s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0705e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202225). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "110/237 [============>.................] - ETA: 47s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0147e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146188). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "112/237 [=============>................] - ETA: 46s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9608e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190457). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 45s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8588e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197039). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "120/237 [==============>...............] - ETA: 43s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7639e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203046). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "121/237 [==============>...............] - ETA: 43s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8316e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231114). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "124/237 [==============>...............] - ETA: 42s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.8692e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156260). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "125/237 [==============>...............] - ETA: 42s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.8462e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204143). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 41s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.8236e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203184). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "131/237 [===============>..............] - ETA: 39s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.8373e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201385). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "133/237 [===============>..............] - ETA: 39s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.8451e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223282). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "135/237 [================>.............] - ETA: 38s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9692e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226096). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "139/237 [================>.............] - ETA: 36s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.8847e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225873). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "141/237 [================>.............] - ETA: 36s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.8733e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191817). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "143/237 [=================>............] - ETA: 35s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.8468e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185545). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "144/237 [=================>............] - ETA: 34s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.8402e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213249). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 33s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.8829e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184555). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "148/237 [=================>............] - ETA: 33s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9046e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151680). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "168/237 [====================>.........] - ETA: 26s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9778e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180696). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "169/237 [====================>.........] - ETA: 25s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0439e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198554). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213478). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "171/237 [====================>.........] - ETA: 24s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0083e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224545). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "173/237 [====================>.........] - ETA: 24s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9736e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221222). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "175/237 [=====================>........] - ETA: 23s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9396e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226575). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "178/237 [=====================>........] - ETA: 22s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0038e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225238). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 21s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9719e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160459). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "186/237 [======================>.......] - ETA: 19s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9291e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147880). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "188/237 [======================>.......] - ETA: 18s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9530e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178603). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "191/237 [=======================>......] - ETA: 17s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0232e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214419). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "193/237 [=======================>......] - ETA: 16s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0129e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186608). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "194/237 [=======================>......] - ETA: 16s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9974e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214571). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "196/237 [=======================>......] - ETA: 15s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9724e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201276). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "199/237 [========================>.....] - ETA: 14s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9276e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230932). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "203/237 [========================>.....] - ETA: 12s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0339e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200975). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160011). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "205/237 [========================>.....] - ETA: 12s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0305e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143661). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "206/237 [=========================>....] - ETA: 11s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0158e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202668). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "209/237 [=========================>....] - ETA: 10s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9960e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173982). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "210/237 [=========================>....] - ETA: 10s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9817e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204575). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190400). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "212/237 [=========================>....] - ETA: 9s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9536e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219278). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "216/237 [==========================>...] - ETA: 7s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9506e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142241). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "234/237 [============================>.] - ETA: 1s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1188e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165507). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " - ETA: 1s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1146e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226746). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "236/237 [============================>.] - ETA: 0s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1014e-04 - denoise_loss: 0.11 - ETA: 0s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0882e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230415). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 383ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0753e-04 - denoise_loss: 0.1184 - val_loss: 0.2338 - val_denoiseg: 0.2338 - val_seg_loss: 0.1160 - val_denoise_loss: 0.1178\n",
+      "Epoch 86/200\n",
+      " 14/237 [>.............................] - ETA: 1:03 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.1397e-04 - denoise_loss: 0.1181 ETA: 1:00 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5697e-04 - denoise_loss: 0.11 - ETA: 1:02 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2951e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190382). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 16/237 [=>............................] - ETA: 1:00 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.6448e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237081). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/237 [=>............................] - ETA: 1:02 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.5593e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231875). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 21/237 [=>............................] - ETA: 1:04 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.0508e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234642). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 23/237 [=>............................] - ETA: 1:06 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.9654e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192835). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 25/237 [==>...........................] - ETA: 1:06 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 4.0632e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206993). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219708). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 29/237 [==>...........................] - ETA: 1:07 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 4.2632e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191047). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 31/237 [==>...........................] - ETA: 1:07 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 4.6907e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141141). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 43/237 [====>.........................] - ETA: 1:06 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.3878e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182220). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 46/237 [====>.........................] - ETA: 1:05 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.8276e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188112). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 49/237 [=====>........................] - ETA: 1:04 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.6433e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195471). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 51/237 [=====>........................] - ETA: 1:04 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.4614e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215194). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 52/237 [=====>........................] - ETA: 1:04 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.3756e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204964). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:03 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.2032e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206123). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176813). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 60/237 [======>.......................] - ETA: 1:02 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.4433e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180851). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 64/237 [=======>......................] - ETA: 1:01 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.4724e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207227). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 65/237 [=======>......................] - ETA: 1:01 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.4036e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232446). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 67/237 [=======>......................] - ETA: 1:00 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.2721e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217379). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192874). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 68/237 [=======>......................] - ETA: 1:00 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.2093e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191669). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 69/237 [=======>......................] - ETA: 59s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.1483e-04 - denoise_loss: 0.1185 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201821). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/237 [========>.....................] - ETA: 58s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.2130e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216723). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 57s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.0818e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215518). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 79/237 [=========>....................] - ETA: 56s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.0301e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224585). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195805). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 80/237 [=========>....................] - ETA: 56s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.9797e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158964). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "101/237 [===========>..................] - ETA: 52s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3672e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175377). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "103/237 [============>.................] - ETA: 51s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.5834e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210616). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236279). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.257918). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "110/237 [============>.................] - ETA: 49s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6396e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.258600). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.279128). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "112/237 [=============>................] - ETA: 49s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6417e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.266571). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.285432). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 48s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.6538e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.264904). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.285323). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "119/237 [==============>...............] - ETA: 46s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.5533e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.301317). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "120/237 [==============>...............] - ETA: 46s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.5237e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.297718). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "122/237 [==============>...............] - ETA: 45s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.5248e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.269328). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 44s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.4130e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.300785). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "127/237 [===============>..............] - ETA: 44s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.4193e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.304485). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "130/237 [===============>..............] - ETA: 42s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3802e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.272449). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "131/237 [===============>..............] - ETA: 42s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3543e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.295516). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "133/237 [===============>..............] - ETA: 41s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3530e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.272193). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "134/237 [===============>..............] - ETA: 41s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3280e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.273235). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "135/237 [================>.............] - ETA: 41s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3033e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.258301). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "136/237 [================>.............] - ETA: 40s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2793e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.256354). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "137/237 [================>.............] - ETA: 40s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2554e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.253305). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "143/237 [=================>............] - ETA: 38s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3048e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.250349). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "144/237 [=================>............] - ETA: 37s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2818e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.249415). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "146/237 [=================>............] - ETA: 37s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2592e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.250226). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " - ETA: 37s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2369e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.251222). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 36s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.2149e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.254212). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "148/237 [=================>............] - ETA: 36s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.1931e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.257431). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "152/237 [==================>...........] - ETA: 34s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3696e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.248106). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "153/237 [==================>...........] - ETA: 34s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3844e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.242204). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 33s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.4036e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221863). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192072). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "156/237 [==================>...........] - ETA: 33s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3818e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176309). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "157/237 [==================>...........] - ETA: 32s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3603e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156713). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "159/237 [===================>..........] - ETA: 32s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3180e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139161). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "161/237 [===================>..........] - ETA: 31s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2769e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135939). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "163/237 [===================>..........] - ETA: 30s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3554e-04 - denoise_loss: 0.118 - ETA: 30s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3348e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143015). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "166/237 [====================>.........] - ETA: 29s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3908e-04 - denoise_loss: 0.1185- ETA: 29s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4113e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148040). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "170/237 [====================>.........] - ETA: 27s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3666e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161355). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "171/237 [====================>.........] - ETA: 27s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3470e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188667). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "173/237 [====================>.........] - ETA: 26s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3083e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198386). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "175/237 [=====================>........] - ETA: 25s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2704e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188972). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175413). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "177/237 [=====================>........] - ETA: 25s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2947e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203415). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 23s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3060e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194346). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "182/237 [======================>.......] - ETA: 23s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3723e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177645). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "186/237 [======================>.......] - ETA: 21s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3587e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209522). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "187/237 [======================>.......] - ETA: 20s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3546e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195729). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "188/237 [======================>.......] - ETA: 20s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3368e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195584). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192676). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "189/237 [======================>.......] - ETA: 20s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3191e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168039). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "193/237 [=======================>......] - ETA: 18s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2664e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.137441). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "206/237 [=========================>....] - ETA: 13s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2537e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174211). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "208/237 [=========================>....] - ETA: 12s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3658e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135696). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "209/237 [=========================>....] - ETA: 11s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3593e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159735). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 102s 432ms/step - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1669e-04 - denoise_loss: 0.1184 - val_loss: 0.2304 - val_denoiseg: 0.2304 - val_seg_loss: 0.1125 - val_denoise_loss: 0.1178\n",
+      "\n",
+      "Epoch 00086: ReduceLROnPlateau reducing learning rate to 4.999999873689376e-05.\n",
+      "Epoch 87/200\n",
+      " 94/237 [==========>...................] - ETA: 55s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.5842e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139927). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 95/237 [===========>..................] - ETA: 54s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.5465e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169595). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 97/237 [===========>..................] - ETA: 53s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.6716e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206315). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 99/237 [===========>..................] - ETA: 53s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.5974e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226963). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229894). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "101/237 [===========>..................] - ETA: 52s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.5262e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231878). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "104/237 [============>.................] - ETA: 51s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.5121e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231416). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "107/237 [============>.................] - ETA: 50s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.5586e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226934). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "109/237 [============>.................] - ETA: 49s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.5813e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234556). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "110/237 [============>.................] - ETA: 49s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.7138e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228091). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 46s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.5334e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146094). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "122/237 [==============>...............] - ETA: 44s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.5028e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151233). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "124/237 [==============>...............] - ETA: 43s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.6798e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156129). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208361). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "129/237 [===============>..............] - ETA: 42s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.7385e-04 - denoise_loss: 0.1182- ETA: 42s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.7310e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210243). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "131/237 [===============>..............] - ETA: 41s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.6817e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210386). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "132/237 [===============>..............] - ETA: 40s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.6539e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.136126). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "136/237 [================>.............] - ETA: 39s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.6138e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185163). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "138/237 [================>.............] - ETA: 38s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.5788e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190139). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "142/237 [================>.............] - ETA: 36s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.5478e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198616). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "144/237 [=================>............] - ETA: 36s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.5230e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206360). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "145/237 [=================>............] - ETA: 35s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4797e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211865). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "146/237 [=================>............] - ETA: 35s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4895e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201817). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "148/237 [=================>............] - ETA: 34s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4462e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208356). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "149/237 [=================>............] - ETA: 34s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.4645e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222729). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "152/237 [==================>...........] - ETA: 33s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.3961e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199149). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "153/237 [==================>...........] - ETA: 32s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.3739e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175634). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "156/237 [==================>...........] - ETA: 31s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.4017e-04 - denoise_loss: 0.1182- ETA: 31s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.3304e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178379). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "161/237 [===================>..........] - ETA: 29s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.3194e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169213). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "163/237 [===================>..........] - ETA: 28s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2788e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187632). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "165/237 [===================>..........] - ETA: 27s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2392e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175697). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "166/237 [====================>.........] - ETA: 27s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2459e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201447). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "168/237 [====================>.........] - ETA: 26s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2073e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191351). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "171/237 [====================>.........] - ETA: 25s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1511e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219848). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "172/237 [====================>.........] - ETA: 25s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1367e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201237). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "173/237 [====================>.........] - ETA: 24s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1186e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221168). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "175/237 [=====================>........] - ETA: 24s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1649e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215179). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "176/237 [=====================>........] - ETA: 23s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2566e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227569). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "178/237 [=====================>........] - ETA: 22s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2201e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215340). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225327). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "182/237 [======================>.......] - ETA: 21s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1705e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224836). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "184/237 [======================>.......] - ETA: 20s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1361e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192680). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "186/237 [======================>.......] - ETA: 19s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2332e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218597). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "187/237 [======================>.......] - ETA: 19s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2332e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219605). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "189/237 [======================>.......] - ETA: 18s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1990e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193689). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "192/237 [=======================>......] - ETA: 17s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2093e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219466). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230684). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "194/237 [=======================>......] - ETA: 16s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1769e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233247). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "196/237 [=======================>......] - ETA: 15s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1445e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230377). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "198/237 [========================>.....] - ETA: 15s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1128e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216267). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "200/237 [========================>.....] - ETA: 14s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.0817e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194553). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183295). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "203/237 [========================>.....] - ETA: 13s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.0893e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160863). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "207/237 [=========================>....] - ETA: 11s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1141e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178699). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172055). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "212/237 [=========================>....] - ETA: 9s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2068e-04 - denoise_loss: 0.1182 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196954). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "216/237 [==========================>...] - ETA: 8s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2388e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190268). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "218/237 [==========================>...] - ETA: 7s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2091e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187683). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "221/237 [==========================>...] - ETA: 6s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.1840e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182914). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "223/237 [===========================>..] - ETA: 5s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.2093e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206851). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207843). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "228/237 [===========================>..] - ETA: 3s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.1593e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220721). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "230/237 [============================>.] - ETA: 2s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.1340e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218690). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "232/237 [============================>.] - ETA: 1s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.1595e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192728). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "234/237 [============================>.] - ETA: 1s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.1583e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196127). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "236/237 [============================>.] - ETA: 0s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.1700e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161376). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 93s 393ms/step - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.1566e-04 - denoise_loss: 0.1181 - val_loss: 0.2340 - val_denoiseg: 0.2340 - val_seg_loss: 0.1163 - val_denoise_loss: 0.1177\n",
+      "Epoch 88/200\n",
+      "  3/237 [..............................] - ETA: 1:13 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 3.8774e-04 - denoise_loss: 0.1178"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213785). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  4/237 [..............................] - ETA: 1:17 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9120e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.248997). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  5/237 [..............................] - ETA: 1:19 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 4.5329e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194201). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168761). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  9/237 [>.............................] - ETA: 1:13 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 4.1567e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154083). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139405). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 19/237 [=>............................] - ETA: 1:05 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.1726e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173993). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 20/237 [=>............................] - ETA: 1:05 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.7780e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.247916). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 22/237 [=>............................] - ETA: 1:06 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.6948e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.247561). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 24/237 [==>...........................] - ETA: 1:04 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 4.3044e-04 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.244172). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 25/237 [==>...........................] - ETA: 1:04 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 4.1322e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188869). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 26/237 [==>...........................] - ETA: 1:05 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.9733e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230674). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 28/237 [==>...........................] - ETA: 1:05 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.6895e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.239019). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228409). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 30/237 [==>...........................] - ETA: 1:05 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.4948e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222479). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178259). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 34/237 [===>..........................] - ETA: 1:06 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.3574e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228768). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 37/237 [===>..........................] - ETA: 1:06 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.3462e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204593). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177974). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:05 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.0207e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208273). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 43/237 [====>.........................] - ETA: 1:04 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.7402e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161607). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 57/237 [======>.......................] - ETA: 1:02 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5239e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170629). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 58/237 [======>.......................] - ETA: 1:01 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4631e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140944). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 71/237 [=======>......................] - ETA: 58s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1366e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141097). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 57s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2538e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167774). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 76/237 [========>.....................] - ETA: 56s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2109e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186174). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 56s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2853e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188275). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 83/237 [=========>....................] - ETA: 54s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2178e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134701). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 96/237 [===========>..................] - ETA: 51s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2095e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161801). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "102/237 [===========>..................] - ETA: 49s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1667e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161626). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "104/237 [============>.................] - ETA: 48s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1789e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152571). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "107/237 [============>.................] - ETA: 47s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1694e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175338). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "113/237 [=============>................] - ETA: 45s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2684e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178575). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 89s 377ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2187e-04 - denoise_loss: 0.1184 - val_loss: 0.2309 - val_denoiseg: 0.2309 - val_seg_loss: 0.1131 - val_denoise_loss: 0.1177\n",
+      "Epoch 89/200\n",
+      "  4/237 [..............................] - ETA: 1:03 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 2.0636e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155380). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.133505). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 66/237 [=======>......................] - ETA: 1:31 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.3677e-04 - denoise_loss: 0.1183 ETA: 1:33 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.4920e-04 - denoise_loss"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193206). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 67/237 [=======>......................] - ETA: 1:30 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.3324e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229955). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215631). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 70/237 [=======>......................] - ETA: 1:29 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6339e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160934). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 76/237 [========>.....................] - ETA: 1:26 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5339e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236743). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 77/237 [========>.....................] - ETA: 1:26 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5010e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185608). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 78/237 [========>.....................] - ETA: 1:25 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5005e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.134707). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 1:24 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6417e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135671). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "111/237 [=============>................] - ETA: 1:09 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.3069e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173080). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 1:07 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.4195e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167095). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "116/237 [=============>................] - ETA: 1:07 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.4055e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190883). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "120/237 [==============>...............] - ETA: 1:04 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.3253e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140667). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 1:01 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.3106e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180853). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152964). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "127/237 [===============>..............] - ETA: 1:01 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.2924e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178517). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "143/237 [=================>............] - ETA: 52s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6283e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.137023). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "148/237 [=================>............] - ETA: 49s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7059e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226124). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "150/237 [=================>............] - ETA: 49s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6877e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.247052). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "152/237 [==================>...........] - ETA: 47s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6449e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236983). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 45s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7010e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236504). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "158/237 [===================>..........] - ETA: 43s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6922e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233557). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234796). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232556). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "160/237 [===================>..........] - ETA: 41s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7684e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232379). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "162/237 [===================>..........] - ETA: 40s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8537e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229869). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "167/237 [====================>.........] - ETA: 37s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7726e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227375). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "170/237 [====================>.........] - ETA: 35s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7404e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190271). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "172/237 [====================>.........] - ETA: 34s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7727e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212757). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164863). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "175/237 [=====================>........] - ETA: 32s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7550e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212856). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 32s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7393e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199499). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179/237 [=====================>........] - ETA: 31s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7745e-04 - denoise_loss: 0.118 - ETA: 31s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7589e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207339). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " - ETA: 30s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8087e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220695). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "180/237 [=====================>........] - ETA: 30s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8100e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221871). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "182/237 [======================>.......] - ETA: 28s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8018e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216039). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "183/237 [======================>.......] - ETA: 28s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7865e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230951). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "184/237 [======================>.......] - ETA: 27s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7714e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226295). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "186/237 [======================>.......] - ETA: 26s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7416e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225447). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "188/237 [======================>.......] - ETA: 25s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7331e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192432). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "191/237 [=======================>......] - ETA: 23s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7676e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199901). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "192/237 [=======================>......] - ETA: 23s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7532e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202268). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169036). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "196/237 [=======================>......] - ETA: 21s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7422e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150808). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "198/237 [========================>.....] - ETA: 20s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7313e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157607). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172896). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "201/237 [========================>.....] - ETA: 18s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7295e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149964). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "204/237 [========================>.....] - ETA: 16s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7600e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145484). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "207/237 [=========================>....] - ETA: 15s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7347e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152615). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.132101). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "210/237 [=========================>....] - ETA: 13s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6986e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187947). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "214/237 [==========================>...] - ETA: 11s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6954e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206776). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "218/237 [==========================>...] - ETA: 9s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7308e-04 - denoise_loss: 0.1183 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165924). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "219/237 [==========================>...] - ETA: 9s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7184e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173191). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "224/237 [===========================>..] - ETA: 6s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7212e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.132375). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 118s 498ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7829e-04 - denoise_loss: 0.1184 - val_loss: 0.2307 - val_denoiseg: 0.2307 - val_seg_loss: 0.1129 - val_denoise_loss: 0.1178\n",
+      "Epoch 90/200\n",
+      " 65/237 [=======>......................] - ETA: 1:01 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 4.2240e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.131365). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 70/237 [=======>......................] - ETA: 59s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 4.2201e-04 - denoise_loss: 0.1182 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220713). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 72/237 [========>.....................] - ETA: 59s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 4.1028e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218727). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 58s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 4.0341e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226137). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 76/237 [========>.....................] - ETA: 58s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.9282e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229125). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 78/237 [========>.....................] - ETA: 57s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.0272e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200943). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 79/237 [=========>....................] - ETA: 57s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.9762e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178348). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 82/237 [=========>....................] - ETA: 56s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.8439e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177722). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 85/237 [=========>....................] - ETA: 55s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7088e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178335). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 87/237 [==========>...................] - ETA: 54s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6376e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180271). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 89/237 [==========>...................] - ETA: 53s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6916e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174224). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 54s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5328e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168997). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 99/237 [===========>..................] - ETA: 51s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3704e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197913). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "103/237 [============>.................] - ETA: 50s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7224e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211626). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "108/237 [============>.................] - ETA: 48s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5910e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213976). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "109/237 [============>.................] - ETA: 48s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5581e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198456). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "113/237 [=============>................] - ETA: 46s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5899e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174212). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 45s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5880e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195771). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 45s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5583e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199770). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215290). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214005). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "121/237 [==============>...............] - ETA: 43s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4407e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226411). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 42s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3855e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213587). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "125/237 [==============>...............] - ETA: 42s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3827e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216545). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "127/237 [===============>..............] - ETA: 41s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5302e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216433). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194172). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "133/237 [===============>..............] - ETA: 39s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5715e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198857). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "137/237 [================>.............] - ETA: 37s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6565e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171874). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "138/237 [================>.............] - ETA: 37s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6300e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184411). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "141/237 [================>.............] - ETA: 36s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6457e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194853). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "144/237 [=================>............] - ETA: 35s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6644e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203891). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 33s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7220e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170397). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "150/237 [=================>............] - ETA: 32s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6714e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170723). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "154/237 [==================>...........] - ETA: 31s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6692e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165646). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 30s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6455e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163208). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "158/237 [===================>..........] - ETA: 29s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6849e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164643). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "159/237 [===================>..........] - ETA: 29s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6649e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168300). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "164/237 [===================>..........] - ETA: 27s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6611e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149588). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "168/237 [====================>.........] - ETA: 25s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7740e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177692). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "169/237 [====================>.........] - ETA: 25s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7608e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184114). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "170/237 [====================>.........] - ETA: 25s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7954e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180235). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "173/237 [====================>.........] - ETA: 24s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.8702e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167719). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145676). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "177/237 [=====================>........] - ETA: 22s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.8693e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182730). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "181/237 [=====================>........] - ETA: 21s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7911e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187371). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170633). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "183/237 [======================>.......] - ETA: 20s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7496e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186915). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "189/237 [======================>.......] - ETA: 18s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7184e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153020). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "203/237 [========================>.....] - ETA: 12s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6458e-04 - denoise_loss: 0.1184- ETA: 13s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6478e-04 - denoise_loss: 0.1"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.145274). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "205/237 [========================>.....] - ETA: 12s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6165e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195062). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 383ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4914e-04 - denoise_loss: 0.1183 - val_loss: 0.2285 - val_denoiseg: 0.2285 - val_seg_loss: 0.1108 - val_denoise_loss: 0.1177\n",
+      "Epoch 91/200\n",
+      "  1/237 [..............................] - ETA: 31s - loss: 0.1132 - denoiseg: 0.1132 - seg_loss: 0.0000e+00 - denoise_loss: 0.113"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.242457). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "  2/237 [..............................] - ETA: 1:04 - loss: 0.1171 - denoiseg: 0.1171 - seg_loss: 7.3913e-04 - denoise_loss: 0.1163"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226478). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  4/237 [..............................] - ETA: 1:15 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.6957e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210500). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  5/237 [..............................] - ETA: 1:18 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9565e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191387). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208694). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  7/237 [..............................] - ETA: 1:18 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 2.2358e-04 - denoise_loss: 0.1179"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190484). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172273). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  9/237 [>.............................] - ETA: 1:09 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.1569e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169156). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166039). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 11/237 [>.............................] - ETA: 1:04 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6055e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156794). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 62/237 [======>.......................] - ETA: 59s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.0646e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197744). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 67/237 [=======>......................] - ETA: 58s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1189e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.181069). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 97/237 [===========>..................] - ETA: 50s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9294e-04 - denoise_loss: 0.1183- ETA: 52s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.7493e-04 - denoise_loss: 0"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195404). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 98/237 [===========>..................] - ETA: 50s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8995e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194708). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/237 [===========>..................] - ETA: 49s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.8644e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183492). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "103/237 [============>.................] - ETA: 48s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.0471e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169840). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "109/237 [============>.................] - ETA: 46s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9311e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165560). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "111/237 [=============>................] - ETA: 45s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9208e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168485). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "112/237 [=============>................] - ETA: 45s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8947e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195548). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "113/237 [=============>................] - ETA: 45s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8691e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197898). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 44s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8356e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227820). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 43s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8135e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221432). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "119/237 [==============>...............] - ETA: 42s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8608e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193463). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 41s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7680e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160701). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "128/237 [===============>..............] - ETA: 39s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9379e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147122). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "129/237 [===============>..............] - ETA: 39s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9151e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171331). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "132/237 [===============>..............] - ETA: 38s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9238e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196246). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "133/237 [===============>..............] - ETA: 37s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9018e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222027). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "137/237 [================>.............] - ETA: 36s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8343e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223445). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "140/237 [================>.............] - ETA: 35s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7992e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223735). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "141/237 [================>.............] - ETA: 35s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7794e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224850). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "144/237 [=================>............] - ETA: 34s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7488e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226098). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225056). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "146/237 [=================>............] - ETA: 33s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7111e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224922). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "148/237 [=================>............] - ETA: 32s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8928e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213793). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "150/237 [=================>............] - ETA: 32s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8734e-04 - denoise_loss: 0.118 - ETA: 31s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8543e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183615). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "151/237 [==================>...........] - ETA: 31s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8354e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204201). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "153/237 [==================>...........] - ETA: 30s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8102e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213948). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "154/237 [==================>...........] - ETA: 30s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7919e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213186). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222777). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "157/237 [==================>...........] - ETA: 29s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7654e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223111). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "163/237 [===================>..........] - ETA: 27s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8281e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210212). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188118). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "164/237 [===================>..........] - ETA: 26s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8108e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166136). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "167/237 [====================>.........] - ETA: 25s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0217e-04 - denoise_loss: 0.1185- ETA: 26s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9494e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211307). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176427). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "170/237 [====================>.........] - ETA: 24s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1114e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139437). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "171/237 [====================>.........] - ETA: 24s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0932e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157864). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "174/237 [=====================>........] - ETA: 23s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0546e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185969). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 22s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0350e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185347). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "178/237 [=====================>........] - ETA: 21s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0762e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216815). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168144). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "191/237 [=======================>......] - ETA: 17s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9847e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147051). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "192/237 [=======================>......] - ETA: 16s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9692e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196234). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "194/237 [=======================>......] - ETA: 15s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0128e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230938). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195317). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "197/237 [=======================>......] - ETA: 14s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9671e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.131112). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "201/237 [========================>.....] - ETA: 13s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9379e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214093). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "202/237 [========================>.....] - ETA: 12s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9234e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199220). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144457). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "209/237 [=========================>....] - ETA: 10s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8975e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165875). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 89s 376ms/step - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9315e-04 - denoise_loss: 0.1185 - val_loss: 0.2288 - val_denoiseg: 0.2288 - val_seg_loss: 0.1111 - val_denoise_loss: 0.1177\n",
+      "Epoch 92/200\n",
+      " 16/237 [=>............................] - ETA: 1:10 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 4.1308e-04 - denoise_loss: 0.1185 ETA: 40s - loss: 0.1171 - denoiseg: 0.1171 - seg_loss: 8.9908e-05 - "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184964). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/237 [=>............................] - ETA: 1:11 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.1020e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150872). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 21/237 [=>............................] - ETA: 1:11 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 4.5228e-04 - denoise_loss: 0.1186 ETA: 1:11 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8178e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161525). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148686). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "103/237 [============>.................] - ETA: 50s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.6450e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159284). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "107/237 [============>.................] - ETA: 48s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6004e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152042). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "111/237 [=============>................] - ETA: 47s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.5068e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164061). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "112/237 [=============>................] - ETA: 46s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.6136e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191272). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115/237 [=============>................] - ETA: 45s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.5691e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218022). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218115). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "116/237 [=============>................] - ETA: 45s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.5472e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221617). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "122/237 [==============>...............] - ETA: 43s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.5099e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216182). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "123/237 [==============>...............] - ETA: 42s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.4895e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207812). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "125/237 [==============>...............] - ETA: 42s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.5667e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186895). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "128/237 [===============>..............] - ETA: 40s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.7119e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216605). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "130/237 [===============>..............] - ETA: 40s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.6922e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209170). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "133/237 [===============>..............] - ETA: 39s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7513e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148430). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "177/237 [=====================>........] - ETA: 22s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1507e-04 - denoise_loss: 0.1184- ETA: 32s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0116e"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147276). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179/237 [=====================>........] - ETA: 21s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1837e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186099). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "199/237 [========================>.....] - ETA: 14s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2185e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141124). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "200/237 [========================>.....] - ETA: 13s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2024e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183661). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "203/237 [========================>.....] - ETA: 12s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2203e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216760). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "204/237 [========================>.....] - ETA: 12s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2096e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226218). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "205/237 [========================>.....] - ETA: 12s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2289e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226459). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "208/237 [=========================>....] - ETA: 10s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1919e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228492). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "211/237 [=========================>....] - ETA: 9s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1466e-04 - denoise_loss: 0.1184 - ETA: 10s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1616e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218182). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "213/237 [=========================>....] - ETA: 9s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1197e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205746). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "215/237 [==========================>...] - ETA: 8s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1410e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151353). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 382ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1198e-04 - denoise_loss: 0.1184 - val_loss: 0.2282 - val_denoiseg: 0.2282 - val_seg_loss: 0.1104 - val_denoise_loss: 0.1178\n",
+      "Epoch 93/200\n",
+      "  3/237 [..............................] - ETA: 54s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 1.6974e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138958). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  7/237 [..............................] - ETA: 1:01 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6781e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167851). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207760). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  9/237 [>.............................] - ETA: 1:04 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 3.1812e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.153556). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 14/237 [>.............................] - ETA: 1:06 - loss: 0.1178 - denoiseg: 0.1178 - seg_loss: 2.8781e-04 - denoise_loss: 0.1175"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144019). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177138). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/237 [=>............................] - ETA: 1:09 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 2.5662e-04 - denoise_loss: 0.1179 ETA: 1:08 - loss: 0.1179 - denoiseg: 0.1179 - seg_loss: 2.7171e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190446). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 21/237 [=>............................] - ETA: 1:05 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 2.8177e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234781). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 22/237 [=>............................] - ETA: 1:06 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 2.5849e-04 - denoise_loss: 0.1180"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236529). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.238163). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 23/237 [=>............................] - ETA: 1:07 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.4725e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237662). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 28/237 [==>...........................] - ETA: 1:08 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.6720e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237952). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 32/237 [===>..........................] - ETA: 1:08 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9424e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237030). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 33/237 [===>..........................] - ETA: 1:08 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.8533e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235413). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233318). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 35/237 [===>..........................] - ETA: 1:08 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.7340e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230861). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224488). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 37/237 [===>..........................] - ETA: 1:07 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.5862e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216607). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:07 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.4760e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202728). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:04 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.1268e-04 - denoise_loss: 0.11 - ETA: 1:03 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.0888e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144088). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/237 [======>.......................] - ETA: 1:02 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 1.9837e-04 - denoise_loss: 0.1183 ETA: 1:03 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.0179e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190521). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 62/237 [======>.......................] - ETA: 1:02 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.3793e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143588). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 66/237 [=======>......................] - ETA: 1:00 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.9469e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146751). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 67/237 [=======>......................] - ETA: 1:00 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.9491e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149225). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 71/237 [=======>......................] - ETA: 59s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.7834e-04 - denoise_loss: 0.1181  ETA: 1:00 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.8641e-04 - denoise_loss: 0.1"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185852). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 72/237 [========>.....................] - ETA: 59s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.7681e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233572). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 74/237 [========>.....................] - ETA: 58s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.6933e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221025). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173386). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 75/237 [========>.....................] - ETA: 58s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.6574e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135737). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/237 [===========>..................] - ETA: 51s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.6022e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161456). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217597). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "101/237 [===========>..................] - ETA: 50s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6699e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220064). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "106/237 [============>.................] - ETA: 49s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7868e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218049). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "107/237 [============>.................] - ETA: 48s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7904e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221881). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "109/237 [============>.................] - ETA: 47s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7392e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216956). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218320). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "111/237 [=============>................] - ETA: 47s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7919e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.131331). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 44s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8202e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165596). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "118/237 [=============>................] - ETA: 44s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7963e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199875). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "119/237 [==============>...............] - ETA: 44s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7965e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200278). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "124/237 [==============>...............] - ETA: 42s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7057e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173403). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "133/237 [===============>..............] - ETA: 39s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7612e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186816). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "136/237 [================>.............] - ETA: 37s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7268e-04 - denoise_loss: 0.1183- ETA: 38s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7470e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192185). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227279). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "137/237 [================>.............] - ETA: 37s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8066e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229397). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "138/237 [================>.............] - ETA: 37s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7865e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228433). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "140/237 [================>.............] - ETA: 36s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7471e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162938). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "146/237 [=================>............] - ETA: 34s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6342e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161820). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "148/237 [=================>............] - ETA: 33s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.6275e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170705). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "150/237 [=================>............] - ETA: 32s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.6172e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197820). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "151/237 [==================>...........] - ETA: 32s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.5999e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.202532). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 30s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5508e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212322). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "160/237 [===================>..........] - ETA: 29s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6287e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216097). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "163/237 [===================>..........] - ETA: 27s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6206e-04 - denoise_loss: 0.1184- ETA: 28s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5962e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227143). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "164/237 [===================>..........] - ETA: 27s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.6047e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224709). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "166/237 [====================>.........] - ETA: 26s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.6616e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138265). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 90s 381ms/step - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.8365e-04 - denoise_loss: 0.1186 - val_loss: 0.2282 - val_denoiseg: 0.2282 - val_seg_loss: 0.1105 - val_denoise_loss: 0.1177\n",
+      "Epoch 94/200\n",
+      " 11/237 [>.............................] - ETA: 1:05 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 7.0990e-05 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155550). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 12/237 [>.............................] - ETA: 1:07 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 6.5075e-05 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178112). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 13/237 [>.............................] - ETA: 1:08 - loss: 0.1181 - denoiseg: 0.1181 - seg_loss: 6.0069e-05 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209049). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 16/237 [=>............................] - ETA: 1:10 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 1.1442e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.187176). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/237 [=>............................] - ETA: 1:11 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 1.3800e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213631). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 19/237 [=>............................] - ETA: 1:11 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 1.3092e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229196). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 21/237 [=>............................] - ETA: 1:12 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 1.3661e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232366). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 24/237 [==>...........................] - ETA: 1:12 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 1.3517e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232105). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233494). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 27/237 [==>...........................] - ETA: 1:12 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 1.7909e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230015). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 28/237 [==>...........................] - ETA: 1:12 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 1.7269e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212698). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 30/237 [==>...........................] - ETA: 1:12 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 1.6622e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212451). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174487). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 37/237 [===>..........................] - ETA: 1:11 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.4754e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.159644). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184404). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 40/237 [====>.........................] - ETA: 1:10 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.2897e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.137881). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 55/237 [=====>........................] - ETA: 1:06 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 1.9250e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156856). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 57/237 [======>.......................] - ETA: 1:05 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 1.8574e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175169). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 60/237 [======>.......................] - ETA: 1:04 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 1.9918e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146551). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 63/237 [======>.......................] - ETA: 1:03 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.0829e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.184560). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 65/237 [=======>......................] - ETA: 1:03 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.0188e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149164). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "103/237 [============>.................] - ETA: 51s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9842e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143196). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156563). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "107/237 [============>.................] - ETA: 49s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8916e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149971). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "168/237 [====================>.........] - ETA: 26s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0116e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.146585). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "171/237 [====================>.........] - ETA: 25s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0311e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161268). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "174/237 [=====================>........] - ETA: 23s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0487e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176536). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 23s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1439e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177537). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179/237 [=====================>........] - ETA: 22s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1040e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.181435). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "182/237 [======================>.......] - ETA: 20s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0674e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178514). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "185/237 [======================>.......] - ETA: 19s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0485e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147742). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "187/237 [======================>.......] - ETA: 18s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0598e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154534). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "216/237 [==========================>...] - ETA: 7s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9188e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.133459). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "218/237 [==========================>...] - ETA: 7s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9051e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161247). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "234/237 [============================>.] - ETA: 1s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9018e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197054). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "235/237 [============================>.] - ETA: 0s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8895e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207222). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 91s 383ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8843e-04 - denoise_loss: 0.1184 - val_loss: 0.2273 - val_denoiseg: 0.2273 - val_seg_loss: 0.1096 - val_denoise_loss: 0.1177\n",
+      "Epoch 95/200\n",
+      "  6/237 [..............................] - ETA: 56s - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 7.6029e-04 - denoise_loss: 0.117 - ETA: 1:00 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 6.3357e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173455). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  8/237 [>.............................] - ETA: 1:06 - loss: 0.1181 - denoiseg: 0.1181 - seg_loss: 4.7518e-04 - denoise_loss: 0.1176"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186294). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199356). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  9/237 [>.............................] - ETA: 1:09 - loss: 0.1180 - denoiseg: 0.1180 - seg_loss: 4.5384e-04 - denoise_loss: 0.1176"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212417). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 10/237 [>.............................] - ETA: 1:10 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 6.2061e-04 - denoise_loss: 0.1178"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219296). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 11/237 [>.............................] - ETA: 1:12 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 5.6419e-04 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235158). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 13/237 [>.............................] - ETA: 1:13 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 7.2192e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.244564). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 15/237 [>.............................] - ETA: 1:14 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 6.2566e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.239932). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 17/237 [=>............................] - ETA: 1:10 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 5.6822e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.242735). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 19/237 [=>............................] - ETA: 1:11 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 5.7250e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.240662). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.237860). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 20/237 [=>............................] - ETA: 1:09 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 5.5007e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209877). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 21/237 [=>............................] - ETA: 1:07 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 5.8397e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.207696). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 23/237 [=>............................] - ETA: 1:08 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 5.3319e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.133916). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 24/237 [==>...........................] - ETA: 1:08 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 5.1098e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.130590). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 26/237 [==>...........................] - ETA: 1:08 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 5.2801e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142520). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 29/237 [==>...........................] - ETA: 1:08 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 5.2483e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141337). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "101/237 [===========>..................] - ETA: 50s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5041e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169783). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "102/237 [===========>..................] - ETA: 49s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4699e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171476). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "103/237 [============>.................] - ETA: 49s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4362e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214546). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "104/237 [============>.................] - ETA: 49s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4184e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216152). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216544). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "106/237 [============>.................] - ETA: 48s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5481e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217177). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "107/237 [============>.................] - ETA: 48s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5544e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218653). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "108/237 [============>.................] - ETA: 47s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5215e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220948). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "111/237 [=============>................] - ETA: 46s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4270e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226717). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.234651). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "112/237 [=============>................] - ETA: 46s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5273e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.239510). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "114/237 [=============>................] - ETA: 45s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5457e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.247408). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.262684). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 45s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6227e-04 - denoise_loss: 0.118 - ETA: 45s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6088e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.279953). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "118/237 [=============>................] - ETA: 44s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6201e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.290481). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "120/237 [==============>...............] - ETA: 44s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7092e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.264678). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "123/237 [==============>...............] - ETA: 43s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6323e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220480). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 42s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5925e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210569). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199902). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "131/237 [===============>..............] - ETA: 40s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6342e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196914). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169363). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "138/237 [================>.............] - ETA: 38s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.6114e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142649). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "139/237 [================>.............] - ETA: 38s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5854e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152280). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "141/237 [================>.............] - ETA: 37s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5606e-04 - denoise_loss: 0.118 - ETA: 37s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5635e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208636). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "142/237 [================>.............] - ETA: 36s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5849e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.174322). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "144/237 [=================>............] - ETA: 36s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5351e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219171). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 35s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5477e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.253485). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.256049). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "149/237 [=================>............] - ETA: 34s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5000e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.246342). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "150/237 [=================>............] - ETA: 34s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4767e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.242954). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "152/237 [==================>...........] - ETA: 33s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4768e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.243527). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "154/237 [==================>...........] - ETA: 32s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4532e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.246091). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "158/237 [===================>..........] - ETA: 31s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.6071e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.242703). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.239830). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "161/237 [===================>..........] - ETA: 30s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.6191e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.230226). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "163/237 [===================>..........] - ETA: 29s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.5747e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.244847). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208320). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "164/237 [===================>..........] - ETA: 28s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.5818e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206803). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "165/237 [===================>..........] - ETA: 28s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.6822e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194451). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "182/237 [======================>.......] - ETA: 21s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.5570e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197212). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "183/237 [======================>.......] - ETA: 21s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.7058e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232913). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "187/237 [======================>.......] - ETA: 20s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.7032e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148349). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "189/237 [======================>.......] - ETA: 19s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.6640e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180809). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "190/237 [=======================>......] - ETA: 18s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.6447e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214209). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "194/237 [=======================>......] - ETA: 17s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.5881e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.151946). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " - ETA: 17s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.5706e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175738). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "236/237 [============================>.] - ETA: 0s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.3317e-04 - denoise_loss: 0.1183 ETA: 5s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.3685e-0"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170926). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 98s 412ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.3253e-04 - denoise_loss: 0.1183 - val_loss: 0.2299 - val_denoiseg: 0.2299 - val_seg_loss: 0.1122 - val_denoise_loss: 0.1178\n",
+      "Epoch 96/200\n",
+      "  1/237 [..............................] - ETA: 59s - loss: 0.1211 - denoiseg: 0.1211 - seg_loss: 0.0012 - denoise_loss: 0.1199"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.288692). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  3/237 [..............................] - ETA: 1:22 - loss: 0.1204 - denoiseg: 0.1204 - seg_loss: 4.1277e-04 - denoise_loss: 0.1200"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.262086). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.235480). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  4/237 [..............................] - ETA: 1:10 - loss: 0.1200 - denoiseg: 0.1200 - seg_loss: 3.0958e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156163). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "104/237 [============>.................] - ETA: 48s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.8107e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160015). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "106/237 [============>.................] - ETA: 48s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.7576e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216092). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "109/237 [============>.................] - ETA: 47s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.7046e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214928). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "112/237 [=============>................] - ETA: 46s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.7775e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215984). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "117/237 [=============>................] - ETA: 44s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.7787e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218972). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218993). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "119/237 [==============>...............] - ETA: 43s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.7397e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221734). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "122/237 [==============>...............] - ETA: 42s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.7413e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218236). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "124/237 [==============>...............] - ETA: 41s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.7222e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218273). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217943). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126/237 [==============>...............] - ETA: 40s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.6856e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222563). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218333). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211807). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "128/237 [===============>..............] - ETA: 39s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.6963e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209775). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "130/237 [===============>..............] - ETA: 39s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.6548e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197158). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211278). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "132/237 [===============>..............] - ETA: 38s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.6146e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215311). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "133/237 [===============>..............] - ETA: 38s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.6869e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211179). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "136/237 [================>.............] - ETA: 36s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9208e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215213). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "137/237 [================>.............] - ETA: 36s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9330e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189249). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "139/237 [================>.............] - ETA: 35s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 3.0066e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191487). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "141/237 [================>.............] - ETA: 35s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9640e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216094). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "143/237 [=================>............] - ETA: 34s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9414e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219498). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "148/237 [=================>............] - ETA: 32s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.9300e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214346). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "149/237 [=================>............] - ETA: 32s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9103e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213949). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "151/237 [==================>...........] - ETA: 31s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1487e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219453). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 30s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2152e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220964). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "156/237 [==================>...........] - ETA: 29s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1947e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.222691). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "161/237 [===================>..........] - ETA: 27s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1804e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220840). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "163/237 [===================>..........] - ETA: 27s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1414e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219398). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218314). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206597). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "164/237 [===================>..........] - ETA: 26s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1222e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190224). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "167/237 [====================>.........] - ETA: 25s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.0844e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156729). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "168/237 [====================>.........] - ETA: 25s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.0661e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172249). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "221/237 [==========================>...] - ETA: 5s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0938e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166660). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "222/237 [===========================>..] - ETA: 5s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1381e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172323). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138569). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "224/237 [===========================>..] - ETA: 4s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1634e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.136721). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "226/237 [===========================>..] - ETA: 4s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1354e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142384). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "234/237 [============================>.] - ETA: 1s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1601e-04 - denoise_loss: 0.1183 ETA: 2s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.2012e-04 - denoise_loss: "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160153). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 88s 373ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1362e-04 - denoise_loss: 0.1183 - val_loss: 0.2302 - val_denoiseg: 0.2302 - val_seg_loss: 0.1125 - val_denoise_loss: 0.1177\n",
+      "\n",
+      "Epoch 00096: ReduceLROnPlateau reducing learning rate to 2.499999936844688e-05.\n",
+      "Epoch 97/200\n",
+      "  2/237 [..............................] - ETA: 59s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 4.9227e-05 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228595). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  3/237 [..............................] - ETA: 1:08 - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 3.2818e-05 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.231868). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  4/237 [..............................] - ETA: 1:00 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.4614e-05 - denoise_loss: 0.1188"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155980). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  6/237 [..............................] - ETA: 1:03 - loss: 0.1196 - denoiseg: 0.1196 - seg_loss: 2.3476e-04 - denoise_loss: 0.1194"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167053). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  8/237 [>.............................] - ETA: 1:07 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.0416e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227382). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166838). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 12/237 [>.............................] - ETA: 1:05 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 1.8841e-04 - denoise_loss: 0.1186 ETA: 1:04 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.0554e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147185). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 15/237 [>.............................] - ETA: 1:08 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 1.7509e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227597). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/237 [=>............................] - ETA: 1:05 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.3251e-04 - denoise_loss: 0.1186 ETA: 1:04 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.2627e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210333). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 20/237 [=>............................] - ETA: 1:02 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.0926e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201338). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 23/237 [=>............................] - ETA: 1:04 - loss: 0.1191 - denoiseg: 0.1191 - seg_loss: 3.1604e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223594). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150254). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 26/237 [==>...........................] - ETA: 1:05 - loss: 0.1192 - denoiseg: 0.1192 - seg_loss: 2.8525e-04 - denoise_loss: 0.1189"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168792). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/237 [========>.....................] - ETA: 57s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.6098e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165714). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 84/237 [=========>....................] - ETA: 54s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.5827e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162690). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172275). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 86/237 [=========>....................] - ETA: 53s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.5550e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208439). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213720). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 93/237 [==========>...................] - ETA: 51s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.5826e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210380). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173378). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "102/237 [===========>..................] - ETA: 49s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.6480e-04 - denoise_loss: 0.1185- ETA: 50s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.6097e-04 - denoise_loss: 0.1"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188063). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143063). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "104/237 [============>.................] - ETA: 48s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.6270e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189942). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "110/237 [============>.................] - ETA: 46s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.4837e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149726). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "112/237 [=============>................] - ETA: 45s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.4394e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161603). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "114/237 [=============>................] - ETA: 45s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.4644e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.181119). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "121/237 [==============>...............] - ETA: 42s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.4759e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141915). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "122/237 [==============>...............] - ETA: 42s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.5488e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150422). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "125/237 [==============>...............] - ETA: 41s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.5719e-04 - denoise_loss: 0.1186- ETA: 41s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.5825e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212406). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "127/237 [===============>..............] - ETA: 40s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.5518e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162682). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196321). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "128/237 [===============>..............] - ETA: 40s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.6337e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213158). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "129/237 [===============>..............] - ETA: 39s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.6135e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208495). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "131/237 [===============>..............] - ETA: 38s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.5943e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214114). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "132/237 [===============>..............] - ETA: 38s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.5746e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196129). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "135/237 [================>.............] - ETA: 37s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.6389e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167360). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "137/237 [================>.............] - ETA: 36s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.6003e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179533). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "140/237 [================>.............] - ETA: 35s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.5686e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167331). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "142/237 [================>.............] - ETA: 34s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.5662e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173338). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 33s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.4789e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160987). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "150/237 [=================>............] - ETA: 32s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.4293e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165519). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "151/237 [==================>...........] - ETA: 31s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.4132e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158012). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "153/237 [==================>...........] - ETA: 30s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.4003e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156617). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "155/237 [==================>...........] - ETA: 30s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.3693e-04 - denoise_loss: 0.118\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147519). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "163/237 [===================>..........] - ETA: 27s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.5549e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.131905). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "166/237 [====================>.........] - ETA: 26s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.5087e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141203). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "177/237 [=====================>........] - ETA: 22s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.5432e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162119). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "192/237 [=======================>......] - ETA: 16s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.5363e-04 - denoise_loss: 0.1186- ETA: 16s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.5288e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183972). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "195/237 [=======================>......] - ETA: 15s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.5061e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192751). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "198/237 [========================>.....] - ETA: 14s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.4684e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172969). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "201/237 [========================>.....] - ETA: 13s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.4453e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140586). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "213/237 [=========================>....] - ETA: 8s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.5079e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148786). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "214/237 [==========================>...] - ETA: 8s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.4961e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171153). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "216/237 [==========================>...] - ETA: 7s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.6158e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167150). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "217/237 [==========================>...] - ETA: 7s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.6038e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162758). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "220/237 [==========================>...] - ETA: 6s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.5970e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189736). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "222/237 [===========================>..] - ETA: 5s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.6687e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194597). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "223/237 [===========================>..] - ETA: 5s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.6568e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141523). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "233/237 [============================>.] - ETA: 1s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.5962e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178933). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "234/237 [============================>.] - ETA: 1s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.6626e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147963). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "235/237 [============================>.] - ETA: 0s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.6513e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149366). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "236/237 [============================>.] - ETA: 0s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.6401e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220404). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 89s 377ms/step - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.6290e-04 - denoise_loss: 0.1186 - val_loss: 0.2296 - val_denoiseg: 0.2296 - val_seg_loss: 0.1119 - val_denoise_loss: 0.1177\n",
+      "Epoch 98/200\n",
+      " 14/237 [>.............................] - ETA: 58s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.6189e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143955). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 19/237 [=>............................] - ETA: 1:03 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.0369e-04 - denoise_loss: 0.1182 ETA: 1:02 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.1567e-04 - denoise_loss: 0."
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195611). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 20/237 [=>............................] - ETA: 1:04 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 1.8332e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214766). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 24/237 [==>...........................] - ETA: 1:05 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.3365e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.169151). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 25/237 [==>...........................] - ETA: 1:06 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.0695e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213290). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 28/237 [==>...........................] - ETA: 1:06 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2584e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180149). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 30/237 [==>...........................] - ETA: 1:06 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8179e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175630). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 33/237 [===>..........................] - ETA: 1:06 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.5769e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209540). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 47/237 [====>.........................] - ETA: 1:04 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.3035e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.168259). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 48/237 [=====>........................] - ETA: 1:04 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.2139e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171807). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 50/237 [=====>........................] - ETA: 1:03 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 4.0453e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190738). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 51/237 [=====>........................] - ETA: 1:03 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.9841e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209846). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 52/237 [=====>........................] - ETA: 1:03 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.9165e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212897). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 53/237 [=====>........................] - ETA: 1:03 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 4.1278e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220274). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 55/237 [=====>........................] - ETA: 1:02 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 4.0641e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219639). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 57/237 [======>.......................] - ETA: 1:02 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.9788e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.213337). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199232). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 58/237 [======>.......................] - ETA: 1:01 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.9102e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180125). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 62/237 [======>.......................] - ETA: 1:00 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6976e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223765). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221056). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 64/237 [=======>......................] - ETA: 1:00 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7125e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203358). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.203167). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 67/237 [=======>......................] - ETA: 59s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5462e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225453). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 69/237 [=======>......................] - ETA: 58s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6082e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206761). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 71/237 [=======>......................] - ETA: 58s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.5893e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206538). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 76/237 [========>.....................] - ETA: 56s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6081e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.186449). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162657). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 79/237 [=========>....................] - ETA: 55s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6368e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182167). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 80/237 [=========>....................] - ETA: 55s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5913e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.142808). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 83/237 [=========>....................] - ETA: 54s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6098e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158688). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 86/237 [=========>....................] - ETA: 53s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8480e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.175003). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 87/237 [==========>...................] - ETA: 53s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8038e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192071). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 90/237 [==========>...................] - ETA: 52s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.8199e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208563). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 95/237 [===========>..................] - ETA: 50s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.8755e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214054). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206053). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 97/237 [===========>..................] - ETA: 49s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.8394e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193353). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 99/237 [===========>..................] - ETA: 50s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7998e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.148726). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "100/237 [===========>..................] - ETA: 50s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.8851e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.140535). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "106/237 [============>.................] - ETA: 48s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.8464e-04 - denoise_loss: 0.1183- ETA: 48s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7766e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139031). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "111/237 [=============>................] - ETA: 46s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6819e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154097). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "118/237 [=============>................] - ETA: 43s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5697e-04 - denoise_loss: 0.1183- ETA: 44s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6158e-04 - denoise_loss: 0.118 - ETA: 44s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.5849e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147771). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "120/237 [==============>...............] - ETA: 43s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5333e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144719). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188226). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "125/237 [==============>...............] - ETA: 41s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3920e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196730). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "129/237 [===============>..............] - ETA: 39s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3430e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.137715). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "132/237 [===============>..............] - ETA: 38s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3737e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205338). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "134/237 [===============>..............] - ETA: 38s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3233e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.205253). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157079). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "136/237 [================>.............] - ETA: 37s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4909e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224702). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170596). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "139/237 [================>.............] - ETA: 36s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4155e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224048). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "143/237 [=================>............] - ETA: 34s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3331e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178197). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "146/237 [=================>............] - ETA: 33s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.2678e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193543). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "149/237 [=================>............] - ETA: 32s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.2258e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161758). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "156/237 [==================>...........] - ETA: 30s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0854e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.158008). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "158/237 [===================>..........] - ETA: 29s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0945e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192778). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "162/237 [===================>..........] - ETA: 27s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0777e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.188151). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "165/237 [===================>..........] - ETA: 26s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1761e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179845). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "167/237 [====================>.........] - ETA: 25s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1383e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.201773). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.162852). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "169/237 [====================>.........] - ETA: 25s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1012e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154490). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163163). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "173/237 [====================>.........] - ETA: 23s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1754e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185105). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "176/237 [=====================>........] - ETA: 22s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1371e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198096). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179/237 [=====================>........] - ETA: 21s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0845e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223972). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "213/237 [=========================>....] - ETA: 8s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0888e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170603). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "215/237 [==========================>...] - ETA: 8s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1252e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212191). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "216/237 [==========================>...] - ETA: 7s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1107e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218766). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "218/237 [==========================>...] - ETA: 7s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0964e-04 - denoise_loss: 0.11 - ETA: 7s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0950e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219140). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "219/237 [==========================>...] - ETA: 6s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0809e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.226466). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225720). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "221/237 [==========================>...] - ETA: 5s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1385e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219042). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "222/237 [===========================>..] - ETA: 5s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1298e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199898). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "224/237 [===========================>..] - ETA: 4s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1019e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.206478). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "226/237 [===========================>..] - ETA: 4s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1007e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227709). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "228/237 [===========================>..] - ETA: 3s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0936e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143473). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "233/237 [============================>.] - ETA: 1s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0983e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152921). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218013). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "235/237 [============================>.] - ETA: 0s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0843e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195520). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 89s 377ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1259e-04 - denoise_loss: 0.1183 - val_loss: 0.2286 - val_denoiseg: 0.2286 - val_seg_loss: 0.1108 - val_denoise_loss: 0.1177\n",
+      "Epoch 99/200\n",
+      "  2/237 [..............................] - ETA: 1:08 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 0.0000e+00 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.304646). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  3/237 [..............................] - ETA: 1:14 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 0.0000e+00 - denoise_loss: 0.1190"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.270672). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  4/237 [..............................] - ETA: 1:18 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 0.0000e+00 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.236697). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.228754). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  5/237 [..............................] - ETA: 1:18 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.5615e-07 - denoise_loss: 0.11\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233586). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  6/237 [..............................] - ETA: 1:19 - loss: 0.1177 - denoiseg: 0.1177 - seg_loss: 2.1346e-07 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227199). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  9/237 [>.............................] - ETA: 1:21 - loss: 0.1178 - denoiseg: 0.1178 - seg_loss: 9.1475e-05 - denoise_loss: 0.1177"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.233043). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 11/237 [>.............................] - ETA: 1:20 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 1.8127e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229599). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 12/237 [>.............................] - ETA: 1:19 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 1.6617e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223754). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 16/237 [=>............................] - ETA: 1:16 - loss: 0.1177 - denoiseg: 0.1177 - seg_loss: 2.1236e-04 - denoise_loss: 0.1175"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223072). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/237 [=>............................] - ETA: 1:14 - loss: 0.1177 - denoiseg: 0.1177 - seg_loss: 2.3763e-04 - denoise_loss: 0.1174"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.214477). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 19/237 [=>............................] - ETA: 1:14 - loss: 0.1178 - denoiseg: 0.1178 - seg_loss: 2.2519e-04 - denoise_loss: 0.1176"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189815). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 22/237 [=>............................] - ETA: 1:14 - loss: 0.1180 - denoiseg: 0.1180 - seg_loss: 2.5151e-04 - denoise_loss: 0.1178"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225095). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 24/237 [==>...........................] - ETA: 1:14 - loss: 0.1180 - denoiseg: 0.1180 - seg_loss: 3.0809e-04 - denoise_loss: 0.1177"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221552). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 25/237 [==>...........................] - ETA: 1:14 - loss: 0.1181 - denoiseg: 0.1181 - seg_loss: 3.4950e-04 - denoise_loss: 0.1177"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.189765). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 26/237 [==>...........................] - ETA: 1:14 - loss: 0.1181 - denoiseg: 0.1181 - seg_loss: 3.3606e-04 - denoise_loss: 0.1177"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227200). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 29/237 [==>...........................] - ETA: 1:10 - loss: 0.1182 - denoiseg: 0.1182 - seg_loss: 3.0890e-04 - denoise_loss: 0.1179"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.227916). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 39/237 [===>..........................] - ETA: 1:05 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.0630e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135751). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 44/237 [====>.........................] - ETA: 1:04 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2858e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163010). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 52/237 [=====>........................] - ETA: 1:02 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6680e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.139125). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 54/237 [=====>........................] - ETA: 1:02 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.5322e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.170254). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 56/237 [======>.......................] - ETA: 1:01 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.5896e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195390). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 58/237 [======>.......................] - ETA: 1:01 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4661e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.216422). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 61/237 [======>.......................] - ETA: 1:00 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4188e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221544). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 62/237 [======>.......................] - ETA: 1:00 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3636e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.224302). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 64/237 [=======>......................] - ETA: 59s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4552e-04 - denoise_loss: 0.1183 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.225452). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 67/237 [=======>......................] - ETA: 58s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.5253e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223455). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 71/237 [=======>......................] - ETA: 57s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.8834e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.200590). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 77/237 [========>.....................] - ETA: 56s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.9750e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212751). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.208448). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 78/237 [========>.....................] - ETA: 55s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.9241e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.209429). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/237 [=========>....................] - ETA: 55s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.8260e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.204783). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 82/237 [=========>....................] - ETA: 54s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.7328e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.190036). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.149346). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "110/237 [============>.................] - ETA: 46s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8705e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.193962). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "111/237 [=============>................] - ETA: 45s - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.8357e-04 - denoise_loss: 0.1185"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.211863). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "116/237 [=============>................] - ETA: 43s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8230e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.194389). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "118/237 [=============>................] - ETA: 43s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8859e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.210473). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "121/237 [==============>...............] - ETA: 42s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.7978e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196433). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.176975). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "125/237 [==============>...............] - ETA: 40s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8326e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.212326). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "126/237 [==============>...............] - ETA: 40s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8611e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.196242). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "129/237 [===============>..............] - ETA: 39s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8951e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.192869). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161595). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "130/237 [===============>..............] - ETA: 38s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.9636e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180862). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "133/237 [===============>..............] - ETA: 37s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.9706e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179622). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "135/237 [================>.............] - ETA: 37s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.9282e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.182032). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "137/237 [================>.............] - ETA: 36s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.0458e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.221876). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "139/237 [================>.............] - ETA: 35s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 4.0162e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160024). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "140/237 [================>.............] - ETA: 35s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.9875e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.165645). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "143/237 [=================>............] - ETA: 34s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.9139e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.229836). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "144/237 [=================>............] - ETA: 33s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8867e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.167282). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "145/237 [=================>............] - ETA: 33s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8814e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.232215). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "147/237 [=================>............] - ETA: 32s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.8608e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.218060). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "150/237 [=================>............] - ETA: 31s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.7837e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.160576). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "184/237 [======================>.......] - ETA: 19s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4908e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143869). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "186/237 [======================>.......] - ETA: 19s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4533e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.161551). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "188/237 [======================>.......] - ETA: 18s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4286e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172189). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "189/237 [======================>.......] - ETA: 17s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4713e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.177347). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "192/237 [=======================>......] - ETA: 16s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.4252e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.147641). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "195/237 [=======================>......] - ETA: 15s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3726e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.156710). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "197/237 [=======================>......] - ETA: 14s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.3408e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163594). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "201/237 [========================>.....] - ETA: 13s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.5100e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.199270). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "203/237 [========================>.....] - ETA: 12s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4756e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.220725). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "205/237 [========================>.....] - ETA: 11s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6037e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.215426). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.217798). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "208/237 [=========================>....] - ETA: 10s - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.7932e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.179776). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 90s 378ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6027e-04 - denoise_loss: 0.1184 - val_loss: 0.2280 - val_denoiseg: 0.2280 - val_seg_loss: 0.1102 - val_denoise_loss: 0.1177\n",
+      "Epoch 100/200\n",
+      "  6/237 [..............................] - ETA: 1:01 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 5.4168e-04 - denoise_loss: 0.1179"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.166601). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 19/237 [=>............................] - ETA: 1:05 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.5243e-04 - denoise_loss: 0.1185 ETA: 1:05 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.6645e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.144496). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 20/237 [=>............................] - ETA: 1:06 - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 2.3981e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198439). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.219350). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 23/237 [=>............................] - ETA: 1:07 - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 2.9647e-04 - denoise_loss: 0.1186"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.223163). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 26/237 [==>...........................] - ETA: 1:07 - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7559e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197937). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 28/237 [==>...........................] - ETA: 1:07 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.6188e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.197814). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178057). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 31/237 [==>...........................] - ETA: 1:07 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.4903e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.164238). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 33/237 [===>..........................] - ETA: 1:07 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.3393e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.141639). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 36/237 [===>..........................] - ETA: 1:07 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.1927e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.195381). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183522). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 39/237 [===>..........................] - ETA: 1:06 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.0240e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.132252). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 41/237 [====>.........................] - ETA: 1:06 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 1.9275e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.157573). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 42/237 [====>.........................] - ETA: 1:06 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 1.8816e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.198103). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 45/237 [====>.........................] - ETA: 1:05 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.1143e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.131896). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 49/237 [=====>........................] - ETA: 1:04 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.3450e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155864). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.178063). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 52/237 [=====>........................] - ETA: 1:04 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.2207e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185660). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 53/237 [=====>........................] - ETA: 1:03 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.1788e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.180128). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 55/237 [=====>........................] - ETA: 1:03 - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.1189e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.191203). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/237 [======>.......................] - ETA: 1:02 - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.1136e-04 - denoise_loss: 0.11"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.154880). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "138/237 [================>.............] - ETA: 36s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.4726e-04 - denoise_loss: 0.1183- ETA: 45s - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.5104e"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143668). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "141/237 [================>.............] - ETA: 35s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.4298e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.183078). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150071). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 105s 441ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7874e-04 - denoise_loss: 0.1184 - val_loss: 0.2303 - val_denoiseg: 0.2303 - val_seg_loss: 0.1126 - val_denoise_loss: 0.1177\n",
+      "Epoch 101/200\n",
+      "237/237 [==============================] - 133s 560ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9831e-04 - denoise_loss: 0.1184 - val_loss: 0.2283 - val_denoiseg: 0.2283 - val_seg_loss: 0.1106 - val_denoise_loss: 0.1177\n",
+      "Epoch 102/200\n",
+      "237/237 [==============================] - 130s 547ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8218e-04 - denoise_loss: 0.1183 - val_loss: 0.2288 - val_denoiseg: 0.2288 - val_seg_loss: 0.1110 - val_denoise_loss: 0.1178\n",
+      "Epoch 103/200\n",
+      "237/237 [==============================] - 129s 544ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.5679e-04 - denoise_loss: 0.1183 - val_loss: 0.2285 - val_denoiseg: 0.2285 - val_seg_loss: 0.1108 - val_denoise_loss: 0.1177\n",
+      "Epoch 104/200\n",
+      "237/237 [==============================] - 128s 538ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.3836e-04 - denoise_loss: 0.1183 - val_loss: 0.2294 - val_denoiseg: 0.2294 - val_seg_loss: 0.1116 - val_denoise_loss: 0.1178\n",
+      "Epoch 105/200\n",
+      "237/237 [==============================] - 130s 550ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.5266e-04 - denoise_loss: 0.1183 - val_loss: 0.2297 - val_denoiseg: 0.2297 - val_seg_loss: 0.1120 - val_denoise_loss: 0.1177\n",
+      "Epoch 106/200\n",
+      "237/237 [==============================] - 131s 551ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7439e-04 - denoise_loss: 0.1184 - val_loss: 0.2294 - val_denoiseg: 0.2294 - val_seg_loss: 0.1117 - val_denoise_loss: 0.1177\n",
+      "\n",
+      "Epoch 00106: ReduceLROnPlateau reducing learning rate to 1.249999968422344e-05.\n",
+      "Epoch 107/200\n",
+      "237/237 [==============================] - 130s 550ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1938e-04 - denoise_loss: 0.1183 - val_loss: 0.2290 - val_denoiseg: 0.2290 - val_seg_loss: 0.1113 - val_denoise_loss: 0.1177\n",
+      "Epoch 108/200\n",
+      "237/237 [==============================] - 133s 562ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8740e-04 - denoise_loss: 0.1183 - val_loss: 0.2292 - val_denoiseg: 0.2292 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 109/200\n",
+      "237/237 [==============================] - 129s 546ms/step - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9362e-04 - denoise_loss: 0.1185 - val_loss: 0.2286 - val_denoiseg: 0.2286 - val_seg_loss: 0.1108 - val_denoise_loss: 0.1177\n",
+      "Epoch 110/200\n",
+      "237/237 [==============================] - 129s 545ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8488e-04 - denoise_loss: 0.1184 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1178\n",
+      "Epoch 111/200\n",
+      "237/237 [==============================] - 131s 551ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1328e-04 - denoise_loss: 0.1183 - val_loss: 0.2297 - val_denoiseg: 0.2297 - val_seg_loss: 0.1119 - val_denoise_loss: 0.1177\n",
+      "Epoch 112/200\n",
+      "237/237 [==============================] - 130s 547ms/step - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1477e-04 - denoise_loss: 0.1185 - val_loss: 0.2291 - val_denoiseg: 0.2291 - val_seg_loss: 0.1114 - val_denoise_loss: 0.1177\n",
+      "Epoch 113/200\n",
+      "237/237 [==============================] - 132s 556ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.4505e-04 - denoise_loss: 0.1184 - val_loss: 0.2297 - val_denoiseg: 0.2297 - val_seg_loss: 0.1119 - val_denoise_loss: 0.1177\n",
+      "Epoch 114/200\n",
+      "237/237 [==============================] - 130s 547ms/step - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8687e-04 - denoise_loss: 0.1186 - val_loss: 0.2289 - val_denoiseg: 0.2289 - val_seg_loss: 0.1112 - val_denoise_loss: 0.1177\n",
+      "Epoch 115/200\n",
+      "237/237 [==============================] - 130s 548ms/step - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.9353e-04 - denoise_loss: 0.1185 - val_loss: 0.2282 - val_denoiseg: 0.2282 - val_seg_loss: 0.1105 - val_denoise_loss: 0.1177\n",
+      "Epoch 116/200\n",
+      "  2/237 [..............................] - ETA: 48s - loss: 0.1204 - denoiseg: 0.1204 - seg_loss: 0.0000e+00 - denoise_loss: 0.1204"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135979). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 126s 531ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9901e-04 - denoise_loss: 0.1182 - val_loss: 0.2284 - val_denoiseg: 0.2284 - val_seg_loss: 0.1107 - val_denoise_loss: 0.1177\n",
+      "\n",
+      "Epoch 00116: ReduceLROnPlateau reducing learning rate to 6.24999984211172e-06.\n",
+      "Epoch 117/200\n",
+      "237/237 [==============================] - 132s 555ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9539e-04 - denoise_loss: 0.1182 - val_loss: 0.2282 - val_denoiseg: 0.2282 - val_seg_loss: 0.1105 - val_denoise_loss: 0.1177\n",
+      "Epoch 118/200\n",
+      "237/237 [==============================] - 131s 551ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.6348e-04 - denoise_loss: 0.1185 - val_loss: 0.2284 - val_denoiseg: 0.2284 - val_seg_loss: 0.1107 - val_denoise_loss: 0.1177\n",
+      "Epoch 119/200\n",
+      "237/237 [==============================] - 129s 544ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9261e-04 - denoise_loss: 0.1182 - val_loss: 0.2287 - val_denoiseg: 0.2287 - val_seg_loss: 0.1110 - val_denoise_loss: 0.1177\n",
+      "Epoch 120/200\n",
+      "237/237 [==============================] - 128s 539ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9701e-04 - denoise_loss: 0.1182 - val_loss: 0.2292 - val_denoiseg: 0.2292 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 121/200\n",
+      "237/237 [==============================] - 128s 539ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7985e-04 - denoise_loss: 0.1183 - val_loss: 0.2302 - val_denoiseg: 0.2302 - val_seg_loss: 0.1124 - val_denoise_loss: 0.1177\n",
+      "Epoch 122/200\n",
+      "237/237 [==============================] - 127s 534ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2301e-04 - denoise_loss: 0.1182 - val_loss: 0.2302 - val_denoiseg: 0.2302 - val_seg_loss: 0.1125 - val_denoise_loss: 0.1177\n",
+      "Epoch 123/200\n",
+      "237/237 [==============================] - 127s 534ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7963e-04 - denoise_loss: 0.1183 - val_loss: 0.2286 - val_denoiseg: 0.2286 - val_seg_loss: 0.1109 - val_denoise_loss: 0.1177\n",
+      "Epoch 124/200\n",
+      "237/237 [==============================] - 124s 522ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8688e-04 - denoise_loss: 0.1183 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 125/200\n",
+      "237/237 [==============================] - 126s 532ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0086e-04 - denoise_loss: 0.1184 - val_loss: 0.2291 - val_denoiseg: 0.2291 - val_seg_loss: 0.1114 - val_denoise_loss: 0.1177\n",
+      "Epoch 126/200\n",
+      "237/237 [==============================] - 124s 522ms/step - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.3372e-04 - denoise_loss: 0.1182 - val_loss: 0.2296 - val_denoiseg: 0.2296 - val_seg_loss: 0.1119 - val_denoise_loss: 0.1177\n",
+      "\n",
+      "Epoch 00126: ReduceLROnPlateau reducing learning rate to 3.12499992105586e-06.\n",
+      "Epoch 127/200\n",
+      "237/237 [==============================] - 129s 542ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.3548e-04 - denoise_loss: 0.1183 - val_loss: 0.2296 - val_denoiseg: 0.2296 - val_seg_loss: 0.1118 - val_denoise_loss: 0.1177\n",
+      "Epoch 128/200\n",
+      "237/237 [==============================] - 129s 543ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.6574e-04 - denoise_loss: 0.1183 - val_loss: 0.2286 - val_denoiseg: 0.2286 - val_seg_loss: 0.1109 - val_denoise_loss: 0.1177\n",
+      "Epoch 129/200\n",
+      "237/237 [==============================] - 126s 530ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.4672e-04 - denoise_loss: 0.1184 - val_loss: 0.2288 - val_denoiseg: 0.2288 - val_seg_loss: 0.1111 - val_denoise_loss: 0.1177\n",
+      "Epoch 130/200\n",
+      "237/237 [==============================] - 126s 533ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7591e-04 - denoise_loss: 0.1183 - val_loss: 0.2290 - val_denoiseg: 0.2290 - val_seg_loss: 0.1113 - val_denoise_loss: 0.1177\n",
+      "Epoch 131/200\n",
+      "237/237 [==============================] - 126s 530ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.2409e-04 - denoise_loss: 0.1183 - val_loss: 0.2289 - val_denoiseg: 0.2289 - val_seg_loss: 0.1111 - val_denoise_loss: 0.1177\n",
+      "Epoch 132/200\n",
+      "237/237 [==============================] - 124s 524ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.7245e-04 - denoise_loss: 0.1182 - val_loss: 0.2290 - val_denoiseg: 0.2290 - val_seg_loss: 0.1112 - val_denoise_loss: 0.1177\n",
+      "Epoch 133/200\n",
+      "237/237 [==============================] - 126s 532ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9102e-04 - denoise_loss: 0.1183 - val_loss: 0.2295 - val_denoiseg: 0.2295 - val_seg_loss: 0.1118 - val_denoise_loss: 0.1177\n",
+      "Epoch 134/200\n",
+      "210/237 [=========================>....] - ETA: 13s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.6561e-04 - denoise_loss: 0.1182"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138385). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 123s 519ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.7292e-04 - denoise_loss: 0.1182 - val_loss: 0.2297 - val_denoiseg: 0.2297 - val_seg_loss: 0.1119 - val_denoise_loss: 0.1177\n",
+      "Epoch 135/200\n",
+      "237/237 [==============================] - 126s 530ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1124e-04 - denoise_loss: 0.1184 - val_loss: 0.2297 - val_denoiseg: 0.2297 - val_seg_loss: 0.1120 - val_denoise_loss: 0.1177\n",
+      "Epoch 136/200\n",
+      "237/237 [==============================] - 123s 521ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.0311e-04 - denoise_loss: 0.1182 - val_loss: 0.2292 - val_denoiseg: 0.2292 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "\n",
+      "Epoch 00136: ReduceLROnPlateau reducing learning rate to 1.56249996052793e-06.\n",
+      "Epoch 137/200\n",
+      "237/237 [==============================] - 123s 517ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1630e-04 - denoise_loss: 0.1184 - val_loss: 0.2292 - val_denoiseg: 0.2292 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 138/200\n",
+      "237/237 [==============================] - 127s 534ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.3295e-04 - denoise_loss: 0.1183 - val_loss: 0.2292 - val_denoiseg: 0.2292 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 139/200\n",
+      "190/237 [=======================>......] - ETA: 24s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4820e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.127587). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "194/237 [=======================>......] - ETA: 22s - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.4141e-04 - denoise_loss: 0.1187"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.135184). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 124s 524ms/step - loss: 0.1190 - denoiseg: 0.1190 - seg_loss: 3.2185e-04 - denoise_loss: 0.1186 - val_loss: 0.2290 - val_denoiseg: 0.2290 - val_seg_loss: 0.1113 - val_denoise_loss: 0.1177\n",
+      "Epoch 140/200\n",
+      "237/237 [==============================] - 125s 529ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.7444e-04 - denoise_loss: 0.1183 - val_loss: 0.2289 - val_denoiseg: 0.2289 - val_seg_loss: 0.1112 - val_denoise_loss: 0.1177\n",
+      "Epoch 141/200\n",
+      "237/237 [==============================] - 126s 531ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.2358e-04 - denoise_loss: 0.1182 - val_loss: 0.2290 - val_denoiseg: 0.2290 - val_seg_loss: 0.1113 - val_denoise_loss: 0.1177\n",
+      "Epoch 142/200\n",
+      "237/237 [==============================] - 126s 531ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7735e-04 - denoise_loss: 0.1183 - val_loss: 0.2295 - val_denoiseg: 0.2295 - val_seg_loss: 0.1118 - val_denoise_loss: 0.1177\n",
+      "Epoch 143/200\n",
+      "237/237 [==============================] - 124s 523ms/step - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.6953e-04 - denoise_loss: 0.1182 - val_loss: 0.2297 - val_denoiseg: 0.2297 - val_seg_loss: 0.1119 - val_denoise_loss: 0.1177\n",
+      "Epoch 144/200\n",
+      "237/237 [==============================] - 126s 532ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9300e-04 - denoise_loss: 0.1184 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1116 - val_denoise_loss: 0.1177\n",
+      "Epoch 145/200\n",
+      "237/237 [==============================] - 125s 526ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9823e-04 - denoise_loss: 0.1182 - val_loss: 0.2292 - val_denoiseg: 0.2292 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 146/200\n",
+      "237/237 [==============================] - 125s 528ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.7950e-04 - denoise_loss: 0.1182 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1116 - val_denoise_loss: 0.1177\n",
+      "\n",
+      "Epoch 00146: ReduceLROnPlateau reducing learning rate to 7.81249980263965e-07.\n",
+      "Epoch 147/200\n",
+      "237/237 [==============================] - 127s 535ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.3485e-04 - denoise_loss: 0.1184 - val_loss: 0.2289 - val_denoiseg: 0.2289 - val_seg_loss: 0.1112 - val_denoise_loss: 0.1177\n",
+      "Epoch 148/200\n",
+      "237/237 [==============================] - 125s 527ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.6139e-04 - denoise_loss: 0.1183 - val_loss: 0.2290 - val_denoiseg: 0.2290 - val_seg_loss: 0.1113 - val_denoise_loss: 0.1177\n",
+      "Epoch 149/200\n",
+      "237/237 [==============================] - 123s 520ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7688e-04 - denoise_loss: 0.1184 - val_loss: 0.2292 - val_denoiseg: 0.2292 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 150/200\n",
+      "237/237 [==============================] - 125s 527ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8273e-04 - denoise_loss: 0.1184 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1116 - val_denoise_loss: 0.1177\n",
+      "Epoch 151/200\n",
+      "237/237 [==============================] - 127s 536ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5912e-04 - denoise_loss: 0.1184 - val_loss: 0.2295 - val_denoiseg: 0.2295 - val_seg_loss: 0.1118 - val_denoise_loss: 0.1177\n",
+      "Epoch 152/200\n",
+      "237/237 [==============================] - 125s 529ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.2592e-04 - denoise_loss: 0.1183 - val_loss: 0.2291 - val_denoiseg: 0.2291 - val_seg_loss: 0.1114 - val_denoise_loss: 0.1177\n",
+      "Epoch 153/200\n",
+      "237/237 [==============================] - 127s 536ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7893e-04 - denoise_loss: 0.1184 - val_loss: 0.2292 - val_denoiseg: 0.2292 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 154/200\n",
+      "237/237 [==============================] - 124s 523ms/step - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.6661e-04 - denoise_loss: 0.1185 - val_loss: 0.2294 - val_denoiseg: 0.2294 - val_seg_loss: 0.1117 - val_denoise_loss: 0.1177\n",
+      "Epoch 155/200\n",
+      "173/237 [====================>.........] - ETA: 33s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2076e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.155263). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "174/237 [=====================>........] - ETA: 33s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2007e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.126934). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "182/237 [======================>.......] - ETA: 29s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1107e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.130410). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "189/237 [======================>.......] - ETA: 25s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1228e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.143242). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 127s 535ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1360e-04 - denoise_loss: 0.1184 - val_loss: 0.2294 - val_denoiseg: 0.2294 - val_seg_loss: 0.1117 - val_denoise_loss: 0.1177\n",
+      "Epoch 156/200\n",
+      "237/237 [==============================] - 125s 526ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.1233e-04 - denoise_loss: 0.1184 - val_loss: 0.2297 - val_denoiseg: 0.2297 - val_seg_loss: 0.1120 - val_denoise_loss: 0.1177\n",
+      "\n",
+      "Epoch 00156: ReduceLROnPlateau reducing learning rate to 3.906249901319825e-07.\n",
+      "Epoch 157/200\n",
+      "237/237 [==============================] - 125s 529ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0088e-04 - denoise_loss: 0.1183 - val_loss: 0.2291 - val_denoiseg: 0.2291 - val_seg_loss: 0.1114 - val_denoise_loss: 0.1177\n",
+      "Epoch 158/200\n",
+      "237/237 [==============================] - 124s 524ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5016e-04 - denoise_loss: 0.1183 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1116 - val_denoise_loss: 0.1177\n",
+      "Epoch 159/200\n",
+      "237/237 [==============================] - 126s 531ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8419e-04 - denoise_loss: 0.1183 - val_loss: 0.2296 - val_denoiseg: 0.2296 - val_seg_loss: 0.1119 - val_denoise_loss: 0.1177\n",
+      "Epoch 160/200\n",
+      "237/237 [==============================] - 125s 528ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0928e-04 - denoise_loss: 0.1183 - val_loss: 0.2298 - val_denoiseg: 0.2298 - val_seg_loss: 0.1121 - val_denoise_loss: 0.1177\n",
+      "Epoch 161/200\n",
+      "237/237 [==============================] - 125s 526ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9160e-04 - denoise_loss: 0.1182 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 162/200\n",
+      "237/237 [==============================] - 124s 523ms/step - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.7925e-04 - denoise_loss: 0.1181 - val_loss: 0.2295 - val_denoiseg: 0.2295 - val_seg_loss: 0.1118 - val_denoise_loss: 0.1177\n",
+      "Epoch 163/200\n",
+      "237/237 [==============================] - 125s 529ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1495e-04 - denoise_loss: 0.1182 - val_loss: 0.2295 - val_denoiseg: 0.2295 - val_seg_loss: 0.1117 - val_denoise_loss: 0.1177\n",
+      "Epoch 164/200\n",
+      "237/237 [==============================] - 124s 522ms/step - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8451e-04 - denoise_loss: 0.1185 - val_loss: 0.2292 - val_denoiseg: 0.2292 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 165/200\n",
+      "237/237 [==============================] - 127s 535ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0726e-04 - denoise_loss: 0.1183 - val_loss: 0.2295 - val_denoiseg: 0.2295 - val_seg_loss: 0.1117 - val_denoise_loss: 0.1177\n",
+      "Epoch 166/200\n",
+      "237/237 [==============================] - 124s 525ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9760e-04 - denoise_loss: 0.1183 - val_loss: 0.2295 - val_denoiseg: 0.2295 - val_seg_loss: 0.1117 - val_denoise_loss: 0.1177\n",
+      "\n",
+      "Epoch 00166: ReduceLROnPlateau reducing learning rate to 1.9531249506599124e-07.\n",
+      "Epoch 167/200\n",
+      "237/237 [==============================] - 126s 533ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8641e-04 - denoise_loss: 0.1184 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1116 - val_denoise_loss: 0.1177\n",
+      "Epoch 168/200\n",
+      "237/237 [==============================] - 128s 541ms/step - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.0779e-04 - denoise_loss: 0.1186 - val_loss: 0.2288 - val_denoiseg: 0.2288 - val_seg_loss: 0.1111 - val_denoise_loss: 0.1177\n",
+      "Epoch 169/200\n",
+      "237/237 [==============================] - 126s 531ms/step - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.6364e-04 - denoise_loss: 0.1181 - val_loss: 0.2292 - val_denoiseg: 0.2292 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 170/200\n",
+      "237/237 [==============================] - 125s 528ms/step - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.8060e-04 - denoise_loss: 0.1181 - val_loss: 0.2291 - val_denoiseg: 0.2291 - val_seg_loss: 0.1114 - val_denoise_loss: 0.1177\n",
+      "Epoch 171/200\n",
+      "237/237 [==============================] - 124s 525ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1619e-04 - denoise_loss: 0.1183 - val_loss: 0.2291 - val_denoiseg: 0.2291 - val_seg_loss: 0.1114 - val_denoise_loss: 0.1177\n",
+      "Epoch 172/200\n",
+      "237/237 [==============================] - 125s 526ms/step - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2066e-04 - denoise_loss: 0.1185 - val_loss: 0.2295 - val_denoiseg: 0.2295 - val_seg_loss: 0.1118 - val_denoise_loss: 0.1177\n",
+      "Epoch 173/200\n",
+      "237/237 [==============================] - 126s 532ms/step - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.1520e-04 - denoise_loss: 0.1185 - val_loss: 0.2292 - val_denoiseg: 0.2292 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 174/200\n",
+      "237/237 [==============================] - 125s 529ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.5515e-04 - denoise_loss: 0.1184 - val_loss: 0.2291 - val_denoiseg: 0.2291 - val_seg_loss: 0.1114 - val_denoise_loss: 0.1177\n",
+      "Epoch 175/200\n",
+      "237/237 [==============================] - 125s 529ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.1487e-04 - denoise_loss: 0.1182 - val_loss: 0.2295 - val_denoiseg: 0.2295 - val_seg_loss: 0.1118 - val_denoise_loss: 0.1177\n",
+      "Epoch 176/200\n",
+      "237/237 [==============================] - 125s 528ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.8561e-04 - denoise_loss: 0.1183 - val_loss: 0.2291 - val_denoiseg: 0.2291 - val_seg_loss: 0.1114 - val_denoise_loss: 0.1177\n",
+      "\n",
+      "Epoch 00176: ReduceLROnPlateau reducing learning rate to 9.765624753299562e-08.\n",
+      "Epoch 177/200\n",
+      "237/237 [==============================] - 127s 537ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.5967e-04 - denoise_loss: 0.1184 - val_loss: 0.2292 - val_denoiseg: 0.2292 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 178/200\n",
+      "237/237 [==============================] - 125s 529ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7216e-04 - denoise_loss: 0.1184 - val_loss: 0.2297 - val_denoiseg: 0.2297 - val_seg_loss: 0.1120 - val_denoise_loss: 0.1177\n",
+      "Epoch 179/200\n",
+      "237/237 [==============================] - 125s 528ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.0736e-04 - denoise_loss: 0.1182 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 180/200\n",
+      "189/237 [======================>.......] - ETA: 24s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0565e-04 - denoise_loss: 0.1183- ETA: 25s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9994e-04 - denoise_loss: 0.118"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.150500). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "191/237 [=======================>......] - ETA: 23s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.0309e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.171123). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "193/237 [=======================>......] - ETA: 22s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 3.1174e-04 - denoise_loss: 0.1183"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.138412). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "196/237 [=======================>......] - ETA: 21s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.0834e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.132193). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 123s 520ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9137e-04 - denoise_loss: 0.1184 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 181/200\n",
+      "237/237 [==============================] - 123s 520ms/step - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.2954e-04 - denoise_loss: 0.1185 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 182/200\n",
+      "237/237 [==============================] - 128s 542ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.6449e-04 - denoise_loss: 0.1182 - val_loss: 0.2294 - val_denoiseg: 0.2294 - val_seg_loss: 0.1117 - val_denoise_loss: 0.1177\n",
+      "Epoch 183/200\n",
+      "  2/237 [..............................] - ETA: 53s - loss: 0.1172 - denoiseg: 0.1172 - seg_loss: 1.2477e-04 - denoise_loss: 0.1171"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.172137). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "191/237 [=======================>......] - ETA: 23s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.6384e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.185183). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "192/237 [=======================>......] - ETA: 23s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.6764e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.238246). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "194/237 [=======================>......] - ETA: 22s - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.6581e-04 - denoise_loss: 0.1181"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.275590). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 124s 524ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.5618e-04 - denoise_loss: 0.1182 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1116 - val_denoise_loss: 0.1177\n",
+      "Epoch 184/200\n",
+      "237/237 [==============================] - 125s 526ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.9490e-04 - denoise_loss: 0.1184 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1116 - val_denoise_loss: 0.1177\n",
+      "Epoch 185/200\n",
+      "237/237 [==============================] - 126s 530ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.8429e-04 - denoise_loss: 0.1182 - val_loss: 0.2292 - val_denoiseg: 0.2292 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 186/200\n",
+      "237/237 [==============================] - 126s 531ms/step - loss: 0.1189 - denoiseg: 0.1189 - seg_loss: 3.1834e-04 - denoise_loss: 0.1186 - val_loss: 0.2295 - val_denoiseg: 0.2295 - val_seg_loss: 0.1118 - val_denoise_loss: 0.1177\n",
+      "\n",
+      "Epoch 00186: ReduceLROnPlateau reducing learning rate to 4.882812376649781e-08.\n",
+      "Epoch 187/200\n",
+      "237/237 [==============================] - 126s 531ms/step - loss: 0.1183 - denoiseg: 0.1183 - seg_loss: 2.8686e-04 - denoise_loss: 0.1180 - val_loss: 0.2295 - val_denoiseg: 0.2295 - val_seg_loss: 0.1117 - val_denoise_loss: 0.1177\n",
+      "Epoch 188/200\n",
+      "237/237 [==============================] - 126s 530ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.6343e-04 - denoise_loss: 0.1183 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1116 - val_denoise_loss: 0.1177\n",
+      "Epoch 189/200\n",
+      "215/237 [==========================>...] - ETA: 11s - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.7402e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.173632). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 125s 526ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6430e-04 - denoise_loss: 0.1183 - val_loss: 0.2294 - val_denoiseg: 0.2294 - val_seg_loss: 0.1117 - val_denoise_loss: 0.1177\n",
+      "Epoch 190/200\n",
+      "237/237 [==============================] - 127s 537ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.9437e-04 - denoise_loss: 0.1182 - val_loss: 0.2292 - val_denoiseg: 0.2292 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "Epoch 191/200\n",
+      "237/237 [==============================] - 124s 522ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6827e-04 - denoise_loss: 0.1183 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1116 - val_denoise_loss: 0.1177\n",
+      "Epoch 192/200\n",
+      "237/237 [==============================] - 126s 530ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.0338e-04 - denoise_loss: 0.1182 - val_loss: 0.2296 - val_denoiseg: 0.2296 - val_seg_loss: 0.1119 - val_denoise_loss: 0.1177\n",
+      "Epoch 193/200\n",
+      "237/237 [==============================] - 126s 530ms/step - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 2.8254e-04 - denoise_loss: 0.1185 - val_loss: 0.2291 - val_denoiseg: 0.2291 - val_seg_loss: 0.1114 - val_denoise_loss: 0.1177\n",
+      "Epoch 194/200\n",
+      "237/237 [==============================] - 125s 529ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.8844e-04 - denoise_loss: 0.1185 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1116 - val_denoise_loss: 0.1177\n",
+      "Epoch 195/200\n",
+      "237/237 [==============================] - 128s 540ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 2.7640e-04 - denoise_loss: 0.1182 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1116 - val_denoise_loss: 0.1177\n",
+      "Epoch 196/200\n",
+      " 26/237 [==>...........................] - ETA: 1:29 - loss: 0.1188 - denoiseg: 0.1188 - seg_loss: 3.6312e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152454). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 29/237 [==>...........................] - ETA: 1:29 - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 3.2578e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.163317). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 126s 533ms/step - loss: 0.1184 - denoiseg: 0.1184 - seg_loss: 2.9519e-04 - denoise_loss: 0.1181 - val_loss: 0.2294 - val_denoiseg: 0.2294 - val_seg_loss: 0.1117 - val_denoise_loss: 0.1177\n",
+      "\n",
+      "Epoch 00196: ReduceLROnPlateau reducing learning rate to 2.4414061883248905e-08.\n",
+      "Epoch 197/200\n",
+      "237/237 [==============================] - 128s 540ms/step - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.7844e-04 - denoise_loss: 0.1184 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1116 - val_denoise_loss: 0.1177\n",
+      "Epoch 198/200\n",
+      "237/237 [==============================] - 126s 531ms/step - loss: 0.1185 - denoiseg: 0.1185 - seg_loss: 3.4091e-04 - denoise_loss: 0.1181 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1116 - val_denoise_loss: 0.1177\n",
+      "Epoch 199/200\n",
+      "237/237 [==============================] - 125s 528ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.9428e-04 - denoise_loss: 0.1183 - val_loss: 0.2293 - val_denoiseg: 0.2293 - val_seg_loss: 0.1116 - val_denoise_loss: 0.1177\n",
+      "Epoch 200/200\n",
+      "217/237 [==========================>...] - ETA: 10s - loss: 0.1187 - denoiseg: 0.1187 - seg_loss: 2.6580e-04 - denoise_loss: 0.1184"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/keras/callbacks.py:95: RuntimeWarning: Method (on_train_batch_end) is slow compared to the batch update (0.152275). Check your callbacks.\n",
+      "  % (hook_name, delta_t_median), RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "237/237 [==============================] - 129s 543ms/step - loss: 0.1186 - denoiseg: 0.1186 - seg_loss: 2.6567e-04 - denoise_loss: 0.1183 - val_loss: 0.2292 - val_denoiseg: 0.2292 - val_seg_loss: 0.1115 - val_denoise_loss: 0.1177\n",
+      "\n",
+      "Loading network weights from 'weights_best.h5'.\n"
+     ]
+    }
+   ],
+   "source": [
+    "history = model.train(X, Y, (X_val, Y_val))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['val_loss', 'val_denoiseg', 'val_seg_loss', 'val_denoise_loss', 'loss', 'denoiseg', 'seg_loss', 'denoise_loss', 'lr'])"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "history.history.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_history(history, ['loss', 'val_loss'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Computing Threshold Value\n",
+    "The network predicts 4 output channels:\n",
+    "1. The denoised input.\n",
+    "2. The background likelihoods.\n",
+    "3. The foreground likelihoods.\n",
+    "4. The border likelihoods.\n",
+    "\n",
+    "We will threshold the foreground prediction image to obtain object segmentations. The optimal threshold is determined on the validation data. Additionally we can optimize the threshold for a given measure. In this case we choose the Average Precision (AP) measure."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Computing best threshold: \n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d887e7e5e0764a8681104f7afe2a9183",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(FloatProgress(value=0.0, max=19.0), HTML(value='')))"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tbuchhol/Gitrepos/DenoiSeg/denoiseg/utils/compute_precision_threshold.py:7: NumbaWarning: \n",
+      "Compilation is falling back to object mode WITH looplifting enabled because Function \"pixel_sharing_bipartite\" failed type inference due to: Invalid use of Function(<built-in function zeros>) with argument(s) of type(s): (UniTuple(int64 x 2), dtype=Function(<class 'int'>))\n",
+      " * parameterized\n",
+      "In definition 0:\n",
+      "    All templates rejected with literals.\n",
+      "In definition 1:\n",
+      "    All templates rejected without literals.\n",
+      "This error is usually caused by passing an argument of a type that is unsupported by the named function.\n",
+      "[1] During: resolving callee type: Function(<built-in function zeros>)\n",
+      "[2] During: typing of call at /home/tbuchhol/Gitrepos/DenoiSeg/denoiseg/utils/compute_precision_threshold.py (10)\n",
+      "\n",
+      "\n",
+      "File \"../../denoiseg/utils/compute_precision_threshold.py\", line 10:\n",
+      "def pixel_sharing_bipartite(lab1, lab2):\n",
+      "    <source elided>\n",
+      "    assert lab1.shape == lab2.shape\n",
+      "    psg = np.zeros((lab1.max() + 1, lab2.max() + 1), dtype=np.int)\n",
+      "    ^\n",
+      "\n",
+      "  @jit\n",
+      "/home/tbuchhol/Gitrepos/DenoiSeg/denoiseg/utils/compute_precision_threshold.py:7: NumbaWarning: \n",
+      "Compilation is falling back to object mode WITHOUT looplifting enabled because Function \"pixel_sharing_bipartite\" failed type inference due to: Unsupported constraint encountered: raise $14load_global.0\n",
+      "\n",
+      "File \"../../denoiseg/utils/compute_precision_threshold.py\", line 9:\n",
+      "def pixel_sharing_bipartite(lab1, lab2):\n",
+      "    assert lab1.shape == lab2.shape\n",
+      "    ^\n",
+      "\n",
+      "  @jit\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/numba/object_mode_passes.py:178: NumbaWarning: Function \"pixel_sharing_bipartite\" was compiled in object mode without forceobj=True, but has lifted loops.\n",
+      "\n",
+      "File \"../../denoiseg/utils/compute_precision_threshold.py\", line 9:\n",
+      "def pixel_sharing_bipartite(lab1, lab2):\n",
+      "    assert lab1.shape == lab2.shape\n",
+      "    ^\n",
+      "\n",
+      "  state.func_ir.loc))\n",
+      "/home/tbuchhol/Programs/miniconda3/envs/DS/lib/python3.7/site-packages/numba/object_mode_passes.py:188: NumbaDeprecationWarning: \n",
+      "Fall-back from the nopython compilation path to the object mode compilation path has been detected, this is deprecated behaviour.\n",
+      "\n",
+      "For more information visit http://numba.pydata.org/numba-doc/latest/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit\n",
+      "\n",
+      "File \"../../denoiseg/utils/compute_precision_threshold.py\", line 9:\n",
+      "def pixel_sharing_bipartite(lab1, lab2):\n",
+      "    assert lab1.shape == lab2.shape\n",
+      "    ^\n",
+      "\n",
+      "  state.func_ir.loc))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Score for threshold = 0.10 is 0.7025\n",
+      "Score for threshold = 0.15 is 0.7220\n",
+      "Score for threshold = 0.20 is 0.7284\n",
+      "Score for threshold = 0.25 is 0.7307\n",
+      "Score for threshold = 0.30 is 0.7268\n",
+      "Score for threshold = 0.35 is 0.7283\n",
+      "Score for threshold = 0.40 is 0.7239\n",
+      "Score for threshold = 0.45 is 0.7134\n",
+      "Score for threshold = 0.50 is 0.7034\n",
+      "Score for threshold = 0.55 is 0.6979\n",
+      "Score for threshold = 0.60 is 0.6846\n",
+      "Score for threshold = 0.65 is 0.6708\n",
+      "Score for threshold = 0.70 is 0.6466\n",
+      "Score for threshold = 0.75 is 0.6153\n",
+      "Score for threshold = 0.80 is 0.5734\n",
+      "Score for threshold = 0.85 is 0.5134\n",
+      "Score for threshold = 0.90 is 0.4337\n",
+      "Score for threshold = 0.95 is 0.3205\n",
+      "Score for threshold = 1.00 is 0.0000\n",
+      "\n",
+      "The higest score of 0.731 is achieved with threshold = 0.25.\n"
+     ]
+    }
+   ],
+   "source": [
+    "threshold, val_score = model.optimize_thresholds(val_images.astype(np.float32), val_masks, measure=measure_precision())\n",
+    "\n",
+    "print(\"The higest score of {} is achieved with threshold = {}.\".format(np.round(val_score, 3), threshold))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test Data\n",
+    "Finally we load the test data and run the prediction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_data =  np.load('data/DSB2018_{}/test/test_data.npz'.format(noise_level), allow_pickle=True)\n",
+    "test_images = test_data['X_test']\n",
+    "test_masks = test_data['Y_test']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Average precision over all test images with threshold = 0.25 is 0.694.\n"
+     ]
+    }
+   ],
+   "source": [
+    "predicted_images, precision_result = model.predict_label_masks(test_images, test_masks, threshold, \n",
+    "                                                                   measure=measure_precision())\n",
+    "print(\"Average precision over all test images with threshold = {} is {}.\".format(threshold, np.round(precision_result, 3)))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "denoiseg",
+   "language": "python",
+   "name": "ds"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/DenoiSeg_2D/FlyWing_DenoiSeg_Example.ipynb b/examples/DenoiSeg_2D/FlyWing_DenoiSeg_Example.ipynb
new file mode 100644
index 0000000..1da8cb7
--- /dev/null
+++ b/examples/DenoiSeg_2D/FlyWing_DenoiSeg_Example.ipynb
@@ -0,0 +1,2034 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# DenoiSeg Example: Fly Wing\n",
+    "This is an example notebook which illustrates how DenoiSeg should be trained. In this notebook we use a membrane labeled developing Fly Wing dataset from our collaborators. We already split the data into train and test images. From the train images we then extracted 1428 training and 252 validation patches of size 128x128. The test set contains 50 images of size 512x512."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using TensorFlow backend.\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:523: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
+      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:524: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
+      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
+      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:526: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
+      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:527: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
+      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:532: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
+      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/numba/npyufunc/parallel.py:300: UserWarning: Could not obtain multiprocessing lock due to OS level error: [Errno 13] Permission denied\n",
+      "A likely cause of this problem is '/dev/shm' is missing orread-only such that necessary semaphores cannot be written.\n",
+      "*** The responsibility of ensuring multiprocessing safe access to this initialization sequence/module import is deferred to the user! ***\n",
+      "\n",
+      "  warnings.warn(msg % str(e))\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Here we are just importing some libraries which are needed to run this notebook.\n",
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "from scipy import ndimage\n",
+    "\n",
+    "from denoiseg.models import DenoiSeg, DenoiSegConfig\n",
+    "from denoiseg.utils.misc_utils import combine_train_test_data, shuffle_train_data, augment_data\n",
+    "from denoiseg.utils.seg_utils import *\n",
+    "from denoiseg.utils.compute_precision_threshold import measure_precision\n",
+    "\n",
+    "from csbdeep.utils import plot_history\n",
+    "\n",
+    "import urllib\n",
+    "import os\n",
+    "import zipfile"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Downloading and  Data Loading\n",
+    "We created three versions of this dataset by adding Gaussian noise with zero mean and standard deviations 10 and 20. The dataset are marked with the suffixes n0, n10 and n20 accordingly.\n",
+    "\n",
+    "In the next cell you can choose which `noise_level` you would like to investigate."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "# Choose the noise level you would like to look at:\n",
+    "# Values: 'n0', 'n10', 'n20'\n",
+    "noise_level = 'n10'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "# create a folder for our data\n",
+    "if not os.path.isdir('./data'):\n",
+    "    os.mkdir('data')\n",
+    "    \n",
+    "if noise_level == 'n0':\n",
+    "    link = 'https://owncloud.mpi-cbg.de/index.php/s/1WXxLSqbK0ZIxF5/download'\n",
+    "elif noise_level == 'n10':\n",
+    "    link = 'https://owncloud.mpi-cbg.de/index.php/s/llTDhwvxgmDdQ3B/download'\n",
+    "elif noise_level == 'n20':\n",
+    "    link = 'https://owncloud.mpi-cbg.de/index.php/s/s1XEtPnKTvR64aG/download'\n",
+    "else:\n",
+    "    print('This noise level does not exist for this dataset.')\n",
+    "\n",
+    "# check if data has been downloaded already\n",
+    "zipPath=\"data/Flywing_{}.zip\".format(noise_level)\n",
+    "if not os.path.exists(zipPath):\n",
+    "    #download and unzip data\n",
+    "    data = urllib.request.urlretrieve(link, zipPath)\n",
+    "    with zipfile.ZipFile(zipPath, 'r') as zip_ref:\n",
+    "        zip_ref.extractall(\"data\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "# Loading of the training images\n",
+    "trainval_data =  np.load('data/Flywing_{}/train/train_data.npz'.format(noise_level))\n",
+    "train_images = trainval_data['X_train'].astype(np.float32)\n",
+    "train_masks = trainval_data['Y_train']\n",
+    "val_images = trainval_data['X_val'].astype(np.float32)\n",
+    "val_masks = trainval_data['Y_val']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape of train_images: (1428, 128, 128)\n",
+      "Shape of train_masks:  (1428, 128, 128)\n",
+      "Shape of val_images:   (252, 128, 128)\n",
+      "Shape of val_masks:    (252, 128, 128)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Shape of train_images: {}\".format(train_images.shape))\n",
+    "print(\"Shape of train_masks:  {}\".format(train_masks.shape))\n",
+    "print(\"Shape of val_images:   {}\".format(val_images.shape))\n",
+    "print(\"Shape of val_masks:    {}\".format(val_masks.shape))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Small Amounts of Annotated Training Data\n",
+    "With DenoiSeg we present a solution to train deep neural networks if only few annotated ground truth segmentations are available. We simulate such a scenario by zeroing out all but a fraction of the available training data. In the next cell you can specify the percentage of training images for which ground truth annotations are available."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "# Set the percentage of annotated training images.\n",
+    "# Values: 0.0 (no annotated images) to 100.0 (all images get annotations)\n",
+    "percentage_of_annotated_training_images = 0.25\n",
+    "assert percentage_of_annotated_training_images >= 0.0 and percentage_of_annotated_training_images <=100.0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Raw image size after augmentation (11424, 128, 128)\n",
+      "Mask size after augmentation (11424, 128, 128)\n",
+      "Shape of X:     (11424, 128, 128, 1)\n",
+      "Shape of Y:     (11424, 128, 128, 3)\n",
+      "Shape of X_val: (252, 128, 128, 1)\n",
+      "Shape of Y_val: (252, 128, 128, 3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Seed to shuffle training data (annotated GT and raw image pairs).\n",
+    "seed = 1 \n",
+    "\n",
+    "# First we shuffle the training images to remove any bias.\n",
+    "X_shuffled, Y_shuffled = shuffle_train_data(train_images, train_masks, random_seed=seed)\n",
+    "# Here we zero out all training images which are not part of the \n",
+    "# selected percentage.\n",
+    "X_frac, Y_frac = zero_out_train_data(X_shuffled, Y_shuffled, fraction = percentage_of_annotated_training_images)\n",
+    "\n",
+    "# Now we apply data augmentation to the training patches:\n",
+    "# Rotate four times by 90 degree and add flipped versions.\n",
+    "X, Y_train_masks = augment_data(X_frac, Y_frac)\n",
+    "X_val, Y_val_masks = val_images, val_masks\n",
+    "\n",
+    "# Here we add the channel dimension to our input images.\n",
+    "# Dimensionality for training has to be 'SYXC' (Sample, Y-Dimension, X-Dimension, Channel)\n",
+    "X = X[...,np.newaxis]\n",
+    "Y = convert_to_oneHot(Y_train_masks)\n",
+    "X_val = X_val[...,np.newaxis]\n",
+    "Y_val = convert_to_oneHot(Y_val_masks)\n",
+    "print(\"Shape of X:     {}\".format(X.shape))\n",
+    "print(\"Shape of Y:     {}\".format(Y.shape))\n",
+    "print(\"Shape of X_val: {}\".format(X_val.shape))\n",
+    "print(\"Shape of Y_val: {}\".format(Y_val.shape))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next we look at a single sample. In the first column we show the input image, in the second column the background segmentation, in the third column the foreground segmentation and in the last column the border segmentation.\n",
+    "\n",
+    "With the parameter `sample` you can choose different training patches. You will notice that not all of them have a segmentation ground truth."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x360 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sample = 0\n",
+    "plt.figure(figsize=(20,5))\n",
+    "plt.subplot(1,4,1)\n",
+    "plt.imshow(X[sample,...,0])\n",
+    "plt.axis('off')\n",
+    "plt.title('Raw validation image')\n",
+    "plt.subplot(1,4,2)\n",
+    "plt.imshow(Y[sample,...,0], vmin=0, vmax=1, interpolation='nearest')\n",
+    "plt.axis('off')\n",
+    "plt.title('1-hot encoded background')\n",
+    "plt.subplot(1,4,3)\n",
+    "plt.imshow(Y[sample,...,1], vmin=0, vmax=1, interpolation='nearest')\n",
+    "plt.axis('off')\n",
+    "plt.title('1-hot encoded foreground')\n",
+    "plt.subplot(1,4,4)\n",
+    "plt.imshow(Y[sample,...,2], vmin=0, vmax=1, interpolation='nearest')\n",
+    "plt.axis('off')\n",
+    "plt.title('1-hot encoded border');"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Configure network parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "train_batch_size = 128\n",
+    "train_steps_per_epoch = max(100, min(int(X.shape[0]/train_batch_size), 400))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "### In the next cell, you can choose how much relative importance (weight) to assign to denoising \n",
+    "### and segmentation tasks by choosing appropriate value for denoiseg_alpha (between 0 and 1; with 0 being\n",
+    "### only segmentation and 1 being only denoising. Here we choose denoiseg_alpha = 0.5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'means': ['44.538273'],\n",
+       " 'stds': ['40.435387'],\n",
+       " 'n_dim': 2,\n",
+       " 'axes': 'YXC',\n",
+       " 'n_channel_in': 1,\n",
+       " 'n_channel_out': 4,\n",
+       " 'train_loss': 'denoiseg',\n",
+       " 'unet_n_depth': 4,\n",
+       " 'relative_weights': [1.0, 1.0, 5.0],\n",
+       " 'unet_kern_size': 3,\n",
+       " 'unet_n_first': 32,\n",
+       " 'unet_last_activation': 'linear',\n",
+       " 'probabilistic': False,\n",
+       " 'unet_residual': False,\n",
+       " 'unet_input_shape': (None, None, 1),\n",
+       " 'train_epochs': 200,\n",
+       " 'train_steps_per_epoch': 100,\n",
+       " 'train_learning_rate': 0.0004,\n",
+       " 'train_batch_size': 128,\n",
+       " 'train_tensorboard': False,\n",
+       " 'train_checkpoint': 'weights_best.h5',\n",
+       " 'train_checkpoint_last': 'weights_last.h5',\n",
+       " 'train_checkpoint_epoch': 'weights_now.h5',\n",
+       " 'train_reduce_lr': {'monitor': 'val_loss', 'factor': 0.5, 'patience': 10},\n",
+       " 'batch_norm': True,\n",
+       " 'n2v_perc_pix': 1.5,\n",
+       " 'n2v_patch_shape': (64, 64),\n",
+       " 'n2v_manipulator': 'uniform_withCP',\n",
+       " 'n2v_neighborhood_radius': 5,\n",
+       " 'denoiseg_alpha': 0.5}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conf = DenoiSegConfig(X, unet_kern_size=3, n_channel_out=4, relative_weights = [1.0,1.0,5.0],\n",
+    "                      train_steps_per_epoch=train_steps_per_epoch, train_epochs=200, \n",
+    "                      batch_norm=True, train_batch_size=128, unet_n_first = 32, \n",
+    "                      unet_n_depth=4, denoiseg_alpha=0.5, train_tensorboard=False)\n",
+    "\n",
+    "vars(conf)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "collapsed": true,
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "model_name = 'DenoiSeg_Flywing_n10'\n",
+    "basedir = 'models'\n",
+    "model = DenoiSeg(conf, model_name, basedir)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/Desktop/GitClones/DenoiSeg/denoiseg/models/denoiseg_standard.py:146: UserWarning: small number of validation images (only 2.15827% of all images)\n",
+      "  warnings.warn(\"small number of validation images (only %.05f%% of all images)\" % (100 * frac_val))\n",
+      "Preparing validation data:   1%|          | 2/252 [00:00<00:14, 17.82it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "61 blind-spots will be generated per training patch of size (64, 64).\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Preparing validation data: 100%|██████████| 252/252 [00:06<00:00, 36.14it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/200\n",
+      "100/100 [==============================] - 104s 1s/step - loss: 0.1003 - denoiseg: 0.1003 - seg_loss: 0.0018 - denoise_loss: 0.0986 - val_loss: 1.1673 - val_denoiseg: 1.1673 - val_seg_loss: 1.0783 - val_denoise_loss: 0.0890\n",
+      "Epoch 2/200\n",
+      "100/100 [==============================] - 94s 936ms/step - loss: 0.0518 - denoiseg: 0.0518 - seg_loss: 0.0014 - denoise_loss: 0.0504 - val_loss: 0.9583 - val_denoiseg: 0.9583 - val_seg_loss: 0.8919 - val_denoise_loss: 0.0664\n",
+      "Epoch 3/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0486 - denoiseg: 0.0486 - seg_loss: 0.0011 - denoise_loss: 0.0475 - val_loss: 0.8418 - val_denoiseg: 0.8418 - val_seg_loss: 0.7866 - val_denoise_loss: 0.0553\n",
+      "Epoch 4/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0474 - denoiseg: 0.0474 - seg_loss: 0.0013 - denoise_loss: 0.0461 - val_loss: 0.7919 - val_denoiseg: 0.7919 - val_seg_loss: 0.7423 - val_denoise_loss: 0.0495\n",
+      "Epoch 5/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0465 - denoiseg: 0.0465 - seg_loss: 0.0012 - denoise_loss: 0.0453 - val_loss: 0.7965 - val_denoiseg: 0.7965 - val_seg_loss: 0.7523 - val_denoise_loss: 0.0442\n",
+      "Epoch 6/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0456 - denoiseg: 0.0456 - seg_loss: 9.4418e-04 - denoise_loss: 0.0447 - val_loss: 0.8407 - val_denoiseg: 0.8407 - val_seg_loss: 0.7959 - val_denoise_loss: 0.0448\n",
+      "Epoch 7/200\n",
+      "100/100 [==============================] - 104s 1s/step - loss: 0.0451 - denoiseg: 0.0451 - seg_loss: 8.3489e-04 - denoise_loss: 0.0443 - val_loss: 0.8992 - val_denoiseg: 0.8992 - val_seg_loss: 0.8554 - val_denoise_loss: 0.0438\n",
+      "Epoch 8/200\n",
+      "100/100 [==============================] - 96s 963ms/step - loss: 0.0447 - denoiseg: 0.0447 - seg_loss: 9.1589e-04 - denoise_loss: 0.0438 - val_loss: 0.9386 - val_denoiseg: 0.9386 - val_seg_loss: 0.8948 - val_denoise_loss: 0.0438\n",
+      "Epoch 9/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0448 - denoiseg: 0.0448 - seg_loss: 8.0901e-04 - denoise_loss: 0.0440 - val_loss: 0.8047 - val_denoiseg: 0.8047 - val_seg_loss: 0.7618 - val_denoise_loss: 0.0428\n",
+      "Epoch 10/200\n",
+      "100/100 [==============================] - 103s 1s/step - loss: 0.0441 - denoiseg: 0.0441 - seg_loss: 7.4717e-04 - denoise_loss: 0.0434 - val_loss: 1.1508 - val_denoiseg: 1.1508 - val_seg_loss: 1.1065 - val_denoise_loss: 0.0443\n",
+      "Epoch 11/200\n",
+      "  2/100 [..............................] - ETA: 24s - loss: 0.0427 - denoiseg: 0.0427 - seg_loss: 0.0000e+00 - denoise_loss: 0.0427"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.299548). Check your callbacks.\n",
+      "  % delta_t_median)\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.154358). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 92s 919ms/step - loss: 0.0442 - denoiseg: 0.0442 - seg_loss: 7.9472e-04 - denoise_loss: 0.0434 - val_loss: 0.9143 - val_denoiseg: 0.9143 - val_seg_loss: 0.8720 - val_denoise_loss: 0.0423\n",
+      "Epoch 12/200\n",
+      "100/100 [==============================] - 94s 943ms/step - loss: 0.0441 - denoiseg: 0.0441 - seg_loss: 7.3416e-04 - denoise_loss: 0.0434 - val_loss: 1.0312 - val_denoiseg: 1.0312 - val_seg_loss: 0.9880 - val_denoise_loss: 0.0431\n",
+      "Epoch 13/200\n",
+      "  1/100 [..............................] - ETA: 12s - loss: 0.0434 - denoiseg: 0.0434 - seg_loss: 0.0000e+00 - denoise_loss: 0.0434"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.134682). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  3/100 [..............................] - ETA: 1:01 - loss: 0.0438 - denoiseg: 0.0438 - seg_loss: 7.1515e-04 - denoise_loss: 0.0430"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.118923). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  4/100 [>.............................] - ETA: 1:07 - loss: 0.0443 - denoiseg: 0.0443 - seg_loss: 5.3636e-04 - denoise_loss: 0.0437"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.111990). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  7/100 [=>............................] - ETA: 1:14 - loss: 0.0436 - denoiseg: 0.0436 - seg_loss: 5.2091e-04 - denoise_loss: 0.0431"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.105056). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 10/100 [==>...........................] - ETA: 1:15 - loss: 0.0442 - denoiseg: 0.0442 - seg_loss: 0.0011 - denoise_loss: 0.0431    "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.101566). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 91s 914ms/step - loss: 0.0440 - denoiseg: 0.0440 - seg_loss: 7.2186e-04 - denoise_loss: 0.0433 - val_loss: 0.8318 - val_denoiseg: 0.8318 - val_seg_loss: 0.7885 - val_denoise_loss: 0.0432\n",
+      "Epoch 14/200\n",
+      "100/100 [==============================] - 92s 923ms/step - loss: 0.0437 - denoiseg: 0.0437 - seg_loss: 7.3955e-04 - denoise_loss: 0.0429 - val_loss: 0.7221 - val_denoiseg: 0.7221 - val_seg_loss: 0.6797 - val_denoise_loss: 0.0424\n",
+      "Epoch 15/200\n",
+      "100/100 [==============================] - 90s 897ms/step - loss: 0.0438 - denoiseg: 0.0438 - seg_loss: 7.8077e-04 - denoise_loss: 0.0430 - val_loss: 1.1496 - val_denoiseg: 1.1496 - val_seg_loss: 1.1066 - val_denoise_loss: 0.0430\n",
+      "Epoch 16/200\n",
+      "100/100 [==============================] - 105s 1s/step - loss: 0.0435 - denoiseg: 0.0435 - seg_loss: 6.0947e-04 - denoise_loss: 0.0429 - val_loss: 0.6705 - val_denoiseg: 0.6705 - val_seg_loss: 0.6269 - val_denoise_loss: 0.0436\n",
+      "Epoch 17/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0435 - denoiseg: 0.0435 - seg_loss: 6.2796e-04 - denoise_loss: 0.0428 - val_loss: 0.8018 - val_denoiseg: 0.8018 - val_seg_loss: 0.7561 - val_denoise_loss: 0.0458\n",
+      "Epoch 18/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0434 - denoiseg: 0.0434 - seg_loss: 7.0183e-04 - denoise_loss: 0.0426 - val_loss: 1.0387 - val_denoiseg: 1.0387 - val_seg_loss: 0.9930 - val_denoise_loss: 0.0457\n",
+      "Epoch 19/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0433 - denoiseg: 0.0433 - seg_loss: 7.0440e-04 - denoise_loss: 0.0426 - val_loss: 0.9525 - val_denoiseg: 0.9525 - val_seg_loss: 0.9105 - val_denoise_loss: 0.0420\n",
+      "Epoch 20/200\n",
+      "100/100 [==============================] - 100s 1s/step - loss: 0.0433 - denoiseg: 0.0433 - seg_loss: 6.7662e-04 - denoise_loss: 0.0426 - val_loss: 0.8212 - val_denoiseg: 0.8212 - val_seg_loss: 0.7790 - val_denoise_loss: 0.0422\n",
+      "Epoch 21/200\n",
+      "  2/100 [..............................] - ETA: 42s - loss: 0.0409 - denoiseg: 0.0409 - seg_loss: 0.0000e+00 - denoise_loss: 0.0409"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.102763). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 102s 1s/step - loss: 0.0431 - denoiseg: 0.0431 - seg_loss: 6.2475e-04 - denoise_loss: 0.0425 - val_loss: 1.0547 - val_denoiseg: 1.0547 - val_seg_loss: 1.0121 - val_denoise_loss: 0.0426\n",
+      "Epoch 22/200\n",
+      " 35/100 [=========>....................] - ETA: 55s - loss: 0.0431 - denoiseg: 0.0431 - seg_loss: 6.1401e-04 - denoise_loss: 0.0424"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.112054). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 97s 974ms/step - loss: 0.0431 - denoiseg: 0.0431 - seg_loss: 5.7185e-04 - denoise_loss: 0.0425 - val_loss: 0.7593 - val_denoiseg: 0.7593 - val_seg_loss: 0.7173 - val_denoise_loss: 0.0421\n",
+      "Epoch 23/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0431 - denoiseg: 0.0431 - seg_loss: 6.8035e-04 - denoise_loss: 0.0424 - val_loss: 0.7517 - val_denoiseg: 0.7517 - val_seg_loss: 0.7099 - val_denoise_loss: 0.0418\n",
+      "Epoch 24/200\n",
+      "  1/100 [..............................] - ETA: 10s - loss: 0.0430 - denoiseg: 0.0430 - seg_loss: 0.0000e+00 - denoise_loss: 0.0430"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.140786). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 95s 954ms/step - loss: 0.0430 - denoiseg: 0.0430 - seg_loss: 6.2463e-04 - denoise_loss: 0.0424 - val_loss: 0.8388 - val_denoiseg: 0.8388 - val_seg_loss: 0.7970 - val_denoise_loss: 0.0417\n",
+      "Epoch 25/200\n",
+      "100/100 [==============================] - 103s 1s/step - loss: 0.0428 - denoiseg: 0.0428 - seg_loss: 5.5037e-04 - denoise_loss: 0.0423 - val_loss: 0.7456 - val_denoiseg: 0.7456 - val_seg_loss: 0.7044 - val_denoise_loss: 0.0413\n",
+      "Epoch 26/200\n",
+      "100/100 [==============================] - 105s 1s/step - loss: 0.0430 - denoiseg: 0.0430 - seg_loss: 7.0232e-04 - denoise_loss: 0.0423 - val_loss: 0.8398 - val_denoiseg: 0.8398 - val_seg_loss: 0.7971 - val_denoise_loss: 0.0427\n",
+      "\n",
+      "Epoch 00026: ReduceLROnPlateau reducing learning rate to 0.00019999999494757503.\n",
+      "Epoch 27/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0427 - denoiseg: 0.0427 - seg_loss: 5.9521e-04 - denoise_loss: 0.0421 - val_loss: 0.7023 - val_denoiseg: 0.7023 - val_seg_loss: 0.6609 - val_denoise_loss: 0.0414\n",
+      "Epoch 28/200\n",
+      "100/100 [==============================] - 102s 1s/step - loss: 0.0428 - denoiseg: 0.0428 - seg_loss: 6.3818e-04 - denoise_loss: 0.0421 - val_loss: 0.7312 - val_denoiseg: 0.7312 - val_seg_loss: 0.6900 - val_denoise_loss: 0.0412\n",
+      "Epoch 29/200\n",
+      "  1/100 [..............................] - ETA: 10s - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 0.0000e+00 - denoise_loss: 0.0419"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.138301). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 93s 933ms/step - loss: 0.0424 - denoiseg: 0.0424 - seg_loss: 5.1803e-04 - denoise_loss: 0.0419 - val_loss: 0.7380 - val_denoiseg: 0.7380 - val_seg_loss: 0.6967 - val_denoise_loss: 0.0414\n",
+      "Epoch 30/200\n",
+      "100/100 [==============================] - 99s 985ms/step - loss: 0.0425 - denoiseg: 0.0425 - seg_loss: 6.7378e-04 - denoise_loss: 0.0418 - val_loss: 0.9233 - val_denoiseg: 0.9233 - val_seg_loss: 0.8821 - val_denoise_loss: 0.0412\n",
+      "Epoch 31/200\n",
+      "100/100 [==============================] - 94s 940ms/step - loss: 0.0426 - denoiseg: 0.0426 - seg_loss: 6.1240e-04 - denoise_loss: 0.0420 - val_loss: 0.7038 - val_denoiseg: 0.7038 - val_seg_loss: 0.6626 - val_denoise_loss: 0.0411\n",
+      "Epoch 32/200\n",
+      "100/100 [==============================] - 92s 923ms/step - loss: 0.0428 - denoiseg: 0.0428 - seg_loss: 7.2133e-04 - denoise_loss: 0.0421 - val_loss: 0.6131 - val_denoiseg: 0.6131 - val_seg_loss: 0.5716 - val_denoise_loss: 0.0415\n",
+      "Epoch 33/200\n",
+      "100/100 [==============================] - 98s 981ms/step - loss: 0.0424 - denoiseg: 0.0424 - seg_loss: 5.6276e-04 - denoise_loss: 0.0418 - val_loss: 0.6641 - val_denoiseg: 0.6641 - val_seg_loss: 0.6230 - val_denoise_loss: 0.0411\n",
+      "Epoch 34/200\n",
+      "100/100 [==============================] - 91s 910ms/step - loss: 0.0423 - denoiseg: 0.0423 - seg_loss: 4.8784e-04 - denoise_loss: 0.0418 - val_loss: 0.5770 - val_denoiseg: 0.5770 - val_seg_loss: 0.5357 - val_denoise_loss: 0.0413\n",
+      "Epoch 35/200\n",
+      "100/100 [==============================] - 104s 1s/step - loss: 0.0424 - denoiseg: 0.0424 - seg_loss: 6.0850e-04 - denoise_loss: 0.0418 - val_loss: 0.8331 - val_denoiseg: 0.8331 - val_seg_loss: 0.7919 - val_denoise_loss: 0.0412\n",
+      "Epoch 36/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0427 - denoiseg: 0.0427 - seg_loss: 6.2147e-04 - denoise_loss: 0.0420 - val_loss: 0.8732 - val_denoiseg: 0.8732 - val_seg_loss: 0.8318 - val_denoise_loss: 0.0414\n",
+      "Epoch 37/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0426 - denoiseg: 0.0426 - seg_loss: 5.8434e-04 - denoise_loss: 0.0420 - val_loss: 0.8244 - val_denoiseg: 0.8244 - val_seg_loss: 0.7832 - val_denoise_loss: 0.0412\n",
+      "Epoch 38/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0424 - denoiseg: 0.0424 - seg_loss: 5.4182e-04 - denoise_loss: 0.0419 - val_loss: 0.6241 - val_denoiseg: 0.6241 - val_seg_loss: 0.5830 - val_denoise_loss: 0.0411\n",
+      "Epoch 39/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0426 - denoiseg: 0.0426 - seg_loss: 5.5605e-04 - denoise_loss: 0.0420 - val_loss: 0.6091 - val_denoiseg: 0.6091 - val_seg_loss: 0.5679 - val_denoise_loss: 0.0412\n",
+      "Epoch 40/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0426 - denoiseg: 0.0426 - seg_loss: 6.9443e-04 - denoise_loss: 0.0419 - val_loss: 0.6797 - val_denoiseg: 0.6797 - val_seg_loss: 0.6385 - val_denoise_loss: 0.0411\n",
+      "Epoch 41/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0425 - denoiseg: 0.0425 - seg_loss: 4.8277e-04 - denoise_loss: 0.0420 - val_loss: 0.4732 - val_denoiseg: 0.4732 - val_seg_loss: 0.4317 - val_denoise_loss: 0.0415\n",
+      "Epoch 42/200\n",
+      "100/100 [==============================] - 115s 1s/step - loss: 0.0425 - denoiseg: 0.0425 - seg_loss: 5.5525e-04 - denoise_loss: 0.0420 - val_loss: 0.4988 - val_denoiseg: 0.4988 - val_seg_loss: 0.4577 - val_denoise_loss: 0.0411\n",
+      "Epoch 43/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0425 - denoiseg: 0.0425 - seg_loss: 6.2452e-04 - denoise_loss: 0.0418 - val_loss: 0.7849 - val_denoiseg: 0.7849 - val_seg_loss: 0.7437 - val_denoise_loss: 0.0412\n",
+      "Epoch 44/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0425 - denoiseg: 0.0425 - seg_loss: 6.0815e-04 - denoise_loss: 0.0418 - val_loss: 0.8116 - val_denoiseg: 0.8116 - val_seg_loss: 0.7703 - val_denoise_loss: 0.0413\n",
+      "Epoch 45/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0424 - denoiseg: 0.0424 - seg_loss: 5.1277e-04 - denoise_loss: 0.0419 - val_loss: 0.3919 - val_denoiseg: 0.3919 - val_seg_loss: 0.3507 - val_denoise_loss: 0.0412\n",
+      "Epoch 46/200\n",
+      "100/100 [==============================] - 101s 1s/step - loss: 0.0424 - denoiseg: 0.0424 - seg_loss: 5.5271e-04 - denoise_loss: 0.0418 - val_loss: 0.5057 - val_denoiseg: 0.5057 - val_seg_loss: 0.4647 - val_denoise_loss: 0.0410\n",
+      "Epoch 47/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0422 - denoiseg: 0.0422 - seg_loss: 6.6191e-04 - denoise_loss: 0.0416 - val_loss: 0.4047 - val_denoiseg: 0.4047 - val_seg_loss: 0.3637 - val_denoise_loss: 0.0411\n",
+      "Epoch 48/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0423 - denoiseg: 0.0423 - seg_loss: 4.8466e-04 - denoise_loss: 0.0418 - val_loss: 0.3920 - val_denoiseg: 0.3920 - val_seg_loss: 0.3510 - val_denoise_loss: 0.0410\n",
+      "Epoch 49/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0422 - denoiseg: 0.0422 - seg_loss: 5.5191e-04 - denoise_loss: 0.0416 - val_loss: 0.7074 - val_denoiseg: 0.7074 - val_seg_loss: 0.6662 - val_denoise_loss: 0.0411\n",
+      "Epoch 50/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0422 - denoiseg: 0.0422 - seg_loss: 6.1575e-04 - denoise_loss: 0.0415 - val_loss: 0.7831 - val_denoiseg: 0.7831 - val_seg_loss: 0.7415 - val_denoise_loss: 0.0416\n",
+      "Epoch 51/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0421 - denoiseg: 0.0421 - seg_loss: 5.7182e-04 - denoise_loss: 0.0416 - val_loss: 0.6224 - val_denoiseg: 0.6224 - val_seg_loss: 0.5814 - val_denoise_loss: 0.0410\n",
+      "Epoch 52/200\n",
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0425 - denoiseg: 0.0425 - seg_loss: 5.4846e-04 - denoise_loss: 0.0420 - val_loss: 0.7817 - val_denoiseg: 0.7817 - val_seg_loss: 0.7405 - val_denoise_loss: 0.0412\n",
+      "Epoch 53/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0422 - denoiseg: 0.0422 - seg_loss: 5.4009e-04 - denoise_loss: 0.0416 - val_loss: 0.5835 - val_denoiseg: 0.5835 - val_seg_loss: 0.5422 - val_denoise_loss: 0.0413\n",
+      "Epoch 54/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0422 - denoiseg: 0.0422 - seg_loss: 5.6794e-04 - denoise_loss: 0.0416 - val_loss: 0.5521 - val_denoiseg: 0.5521 - val_seg_loss: 0.5109 - val_denoise_loss: 0.0412\n",
+      "Epoch 55/200\n",
+      "100/100 [==============================] - 105s 1s/step - loss: 0.0421 - denoiseg: 0.0421 - seg_loss: 5.3068e-04 - denoise_loss: 0.0416 - val_loss: 0.8641 - val_denoiseg: 0.8641 - val_seg_loss: 0.8230 - val_denoise_loss: 0.0411\n",
+      "\n",
+      "Epoch 00055: ReduceLROnPlateau reducing learning rate to 9.999999747378752e-05.\n",
+      "Epoch 56/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0420 - denoiseg: 0.0420 - seg_loss: 5.2934e-04 - denoise_loss: 0.0415 - val_loss: 0.5760 - val_denoiseg: 0.5760 - val_seg_loss: 0.5343 - val_denoise_loss: 0.0417\n",
+      "Epoch 57/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0420 - denoiseg: 0.0420 - seg_loss: 5.8676e-04 - denoise_loss: 0.0414 - val_loss: 0.5314 - val_denoiseg: 0.5314 - val_seg_loss: 0.4905 - val_denoise_loss: 0.0409\n",
+      "Epoch 58/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0420 - denoiseg: 0.0420 - seg_loss: 5.0410e-04 - denoise_loss: 0.0415 - val_loss: 0.4803 - val_denoiseg: 0.4803 - val_seg_loss: 0.4394 - val_denoise_loss: 0.0408\n",
+      "Epoch 59/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0422 - denoiseg: 0.0422 - seg_loss: 5.8487e-04 - denoise_loss: 0.0416 - val_loss: 0.6014 - val_denoiseg: 0.6014 - val_seg_loss: 0.5604 - val_denoise_loss: 0.0410\n",
+      "Epoch 60/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0421 - denoiseg: 0.0421 - seg_loss: 5.0795e-04 - denoise_loss: 0.0416 - val_loss: 0.4078 - val_denoiseg: 0.4078 - val_seg_loss: 0.3669 - val_denoise_loss: 0.0409\n",
+      "Epoch 61/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0421 - denoiseg: 0.0421 - seg_loss: 5.6618e-04 - denoise_loss: 0.0415 - val_loss: 0.5650 - val_denoiseg: 0.5650 - val_seg_loss: 0.5241 - val_denoise_loss: 0.0409\n",
+      "Epoch 62/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0420 - denoiseg: 0.0420 - seg_loss: 5.4097e-04 - denoise_loss: 0.0415 - val_loss: 0.6561 - val_denoiseg: 0.6561 - val_seg_loss: 0.6152 - val_denoise_loss: 0.0409\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 63/200\n",
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0421 - denoiseg: 0.0421 - seg_loss: 5.7326e-04 - denoise_loss: 0.0415 - val_loss: 0.6118 - val_denoiseg: 0.6118 - val_seg_loss: 0.5707 - val_denoise_loss: 0.0411\n",
+      "Epoch 64/200\n",
+      "100/100 [==============================] - 99s 985ms/step - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 5.3746e-04 - denoise_loss: 0.0414 - val_loss: 0.8229 - val_denoiseg: 0.8229 - val_seg_loss: 0.7819 - val_denoise_loss: 0.0410\n",
+      "Epoch 65/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0421 - denoiseg: 0.0421 - seg_loss: 4.8575e-04 - denoise_loss: 0.0416 - val_loss: 0.5853 - val_denoiseg: 0.5853 - val_seg_loss: 0.5445 - val_denoise_loss: 0.0408\n",
+      "\n",
+      "Epoch 00065: ReduceLROnPlateau reducing learning rate to 4.999999873689376e-05.\n",
+      "Epoch 66/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 5.7406e-04 - denoise_loss: 0.0414 - val_loss: 0.3544 - val_denoiseg: 0.3544 - val_seg_loss: 0.3136 - val_denoise_loss: 0.0408\n",
+      "Epoch 67/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0420 - denoiseg: 0.0420 - seg_loss: 6.4474e-04 - denoise_loss: 0.0414 - val_loss: 0.3468 - val_denoiseg: 0.3468 - val_seg_loss: 0.3060 - val_denoise_loss: 0.0408\n",
+      "Epoch 68/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.2329e-04 - denoise_loss: 0.0413 - val_loss: 0.6570 - val_denoiseg: 0.6570 - val_seg_loss: 0.6161 - val_denoise_loss: 0.0408\n",
+      "Epoch 69/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.7336e-04 - denoise_loss: 0.0412 - val_loss: 0.7841 - val_denoiseg: 0.7841 - val_seg_loss: 0.7433 - val_denoise_loss: 0.0408\n",
+      "Epoch 70/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.5528e-04 - denoise_loss: 0.0413 - val_loss: 0.3830 - val_denoiseg: 0.3830 - val_seg_loss: 0.3422 - val_denoise_loss: 0.0408\n",
+      "Epoch 71/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.7224e-04 - denoise_loss: 0.0412 - val_loss: 0.7199 - val_denoiseg: 0.7199 - val_seg_loss: 0.6791 - val_denoise_loss: 0.0408\n",
+      "Epoch 72/200\n",
+      "100/100 [==============================] - 116s 1s/step - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 5.4431e-04 - denoise_loss: 0.0414 - val_loss: 0.8450 - val_denoiseg: 0.8450 - val_seg_loss: 0.8040 - val_denoise_loss: 0.0410\n",
+      "Epoch 73/200\n",
+      "100/100 [==============================] - 101s 1s/step - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 5.1383e-04 - denoise_loss: 0.0414 - val_loss: 0.6071 - val_denoiseg: 0.6071 - val_seg_loss: 0.5663 - val_denoise_loss: 0.0408\n",
+      "Epoch 74/200\n",
+      "100/100 [==============================] - 91s 912ms/step - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 5.0148e-04 - denoise_loss: 0.0414 - val_loss: 0.5978 - val_denoiseg: 0.5978 - val_seg_loss: 0.5570 - val_denoise_loss: 0.0408\n",
+      "Epoch 75/200\n",
+      " 17/100 [====>.........................] - ETA: 1:10 - loss: 0.0425 - denoiseg: 0.0425 - seg_loss: 6.7390e-04 - denoise_loss: 0.0418"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.107762). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/100 [====================>.........] - ETA: 24s - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 5.6769e-04 - denoise_loss: 0.0413"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.101680). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 94s 943ms/step - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 5.5255e-04 - denoise_loss: 0.0414 - val_loss: 0.5153 - val_denoiseg: 0.5153 - val_seg_loss: 0.4744 - val_denoise_loss: 0.0408\n",
+      "Epoch 76/200\n",
+      "100/100 [==============================] - 92s 924ms/step - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 5.3262e-04 - denoise_loss: 0.0414 - val_loss: 0.5826 - val_denoiseg: 0.5826 - val_seg_loss: 0.5416 - val_denoise_loss: 0.0410\n",
+      "Epoch 77/200\n",
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 5.5221e-04 - denoise_loss: 0.0414 - val_loss: 0.5439 - val_denoiseg: 0.5439 - val_seg_loss: 0.5032 - val_denoise_loss: 0.0408\n",
+      "\n",
+      "Epoch 00077: ReduceLROnPlateau reducing learning rate to 2.499999936844688e-05.\n",
+      "Epoch 78/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.4054e-04 - denoise_loss: 0.0411 - val_loss: 0.5476 - val_denoiseg: 0.5476 - val_seg_loss: 0.5068 - val_denoise_loss: 0.0408\n",
+      "Epoch 79/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 4.9218e-04 - denoise_loss: 0.0413 - val_loss: 0.4246 - val_denoiseg: 0.4246 - val_seg_loss: 0.3838 - val_denoise_loss: 0.0408\n",
+      "Epoch 80/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.8484e-04 - denoise_loss: 0.0412 - val_loss: 0.3994 - val_denoiseg: 0.3994 - val_seg_loss: 0.3587 - val_denoise_loss: 0.0408\n",
+      "Epoch 81/200\n",
+      " 97/100 [============================>.] - ETA: 2s - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 5.6253e-04 - denoise_loss: 0.0414"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.108232). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 94s 938ms/step - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 5.5690e-04 - denoise_loss: 0.0413 - val_loss: 0.4674 - val_denoiseg: 0.4674 - val_seg_loss: 0.4266 - val_denoise_loss: 0.0408\n",
+      "Epoch 82/200\n",
+      "100/100 [==============================] - 98s 984ms/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 4.8890e-04 - denoise_loss: 0.0413 - val_loss: 0.5626 - val_denoiseg: 0.5626 - val_seg_loss: 0.5219 - val_denoise_loss: 0.0408\n",
+      "Epoch 83/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.0779e-04 - denoise_loss: 0.0411 - val_loss: 0.5077 - val_denoiseg: 0.5077 - val_seg_loss: 0.4668 - val_denoise_loss: 0.0409\n",
+      "Epoch 84/200\n",
+      "100/100 [==============================] - 118s 1s/step - loss: 0.0420 - denoiseg: 0.0420 - seg_loss: 6.1219e-04 - denoise_loss: 0.0414 - val_loss: 0.7434 - val_denoiseg: 0.7434 - val_seg_loss: 0.7026 - val_denoise_loss: 0.0408\n",
+      "Epoch 85/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 4.0966e-04 - denoise_loss: 0.0412 - val_loss: 0.5117 - val_denoiseg: 0.5117 - val_seg_loss: 0.4709 - val_denoise_loss: 0.0408\n",
+      "Epoch 86/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.8373e-04 - denoise_loss: 0.0412 - val_loss: 0.6592 - val_denoiseg: 0.6592 - val_seg_loss: 0.6185 - val_denoise_loss: 0.0407\n",
+      "Epoch 87/200\n",
+      "100/100 [==============================] - 100s 999ms/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.2830e-04 - denoise_loss: 0.0411 - val_loss: 0.3505 - val_denoiseg: 0.3505 - val_seg_loss: 0.3098 - val_denoise_loss: 0.0408\n",
+      "\n",
+      "Epoch 00087: ReduceLROnPlateau reducing learning rate to 1.249999968422344e-05.\n",
+      "Epoch 88/200\n",
+      " 52/100 [==============>...............] - ETA: 45s - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.0315e-04 - denoise_loss: 0.0411"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.113526). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 92/100 [==========================>...] - ETA: 7s - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.9636e-04 - denoise_loss: 0.0412"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.124876). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 92s 924ms/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.7782e-04 - denoise_loss: 0.0412 - val_loss: 0.5450 - val_denoiseg: 0.5450 - val_seg_loss: 0.5043 - val_denoise_loss: 0.0408\n",
+      "Epoch 89/200\n",
+      " 58/100 [================>.............] - ETA: 38s - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 3.3216e-04 - denoise_loss: 0.0413"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.126291). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 60/100 [=================>............] - ETA: 36s - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 3.8151e-04 - denoise_loss: 0.0414"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.104532). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 61/100 [=================>............] - ETA: 35s - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 3.7526e-04 - denoise_loss: 0.0414"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.109219). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 80/100 [=======================>......] - ETA: 18s - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 4.9865e-04 - denoise_loss: 0.0413"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.100085). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 81/100 [=======================>......] - ETA: 17s - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 4.9249e-04 - denoise_loss: 0.0413"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.118098). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 93s 932ms/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 4.9107e-04 - denoise_loss: 0.0413 - val_loss: 0.5278 - val_denoiseg: 0.5278 - val_seg_loss: 0.4870 - val_denoise_loss: 0.0408\n",
+      "Epoch 90/200\n",
+      " 39/100 [==========>...................] - ETA: 54s - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 4.8583e-04 - denoise_loss: 0.0413"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.101036). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 41/100 [===========>..................] - ETA: 53s - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.6213e-04 - denoise_loss: 0.0413"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.117213). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 43/100 [===========>..................] - ETA: 51s - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.3988e-04 - denoise_loss: 0.0413"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.143200). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 57/100 [================>.............] - ETA: 38s - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.5781e-04 - denoise_loss: 0.0412"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.100702). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 59/100 [================>.............] - ETA: 36s - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.6682e-04 - denoise_loss: 0.0412"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.106715). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 91s 908ms/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.8155e-04 - denoise_loss: 0.0413 - val_loss: 0.5881 - val_denoiseg: 0.5881 - val_seg_loss: 0.5473 - val_denoise_loss: 0.0408\n",
+      "Epoch 91/200\n",
+      "  3/100 [..............................] - ETA: 1:02 - loss: 0.0415 - denoiseg: 0.0415 - seg_loss: 0.0000e+00 - denoise_loss: 0.0415"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.123806). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  6/100 [>.............................] - ETA: 1:12 - loss: 0.0414 - denoiseg: 0.0414 - seg_loss: 0.0000e+00 - denoise_loss: 0.0414"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.128777). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  7/100 [=>............................] - ETA: 1:13 - loss: 0.0415 - denoiseg: 0.0415 - seg_loss: 0.0000e+00 - denoise_loss: 0.0415"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.133749). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  8/100 [=>............................] - ETA: 1:13 - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 2.0786e-04 - denoise_loss: 0.0416"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.153093). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 10/100 [==>...........................] - ETA: 1:14 - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 1.6628e-04 - denoise_loss: 0.0417"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.128802). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 12/100 [==>...........................] - ETA: 1:14 - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 3.7629e-04 - denoise_loss: 0.0415"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.148147). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 14/100 [===>..........................] - ETA: 1:13 - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 4.2499e-04 - denoise_loss: 0.0414"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.152282). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 16/100 [===>..........................] - ETA: 1:12 - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.5097e-04 - denoise_loss: 0.0412"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.127991). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/100 [====>.........................] - ETA: 1:11 - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.8975e-04 - denoise_loss: 0.0412"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.114810). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 21/100 [=====>........................] - ETA: 1:06 - loss: 0.0430 - denoiseg: 0.0430 - seg_loss: 4.1978e-04 - denoise_loss: 0.0426"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.107656). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 93s 932ms/step - loss: 0.0421 - denoiseg: 0.0421 - seg_loss: 5.2911e-04 - denoise_loss: 0.0415 - val_loss: 0.8715 - val_denoiseg: 0.8715 - val_seg_loss: 0.8307 - val_denoise_loss: 0.0408\n",
+      "Epoch 92/200\n",
+      "100/100 [==============================] - 104s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.5605e-04 - denoise_loss: 0.0413 - val_loss: 0.6730 - val_denoiseg: 0.6730 - val_seg_loss: 0.6322 - val_denoise_loss: 0.0408\n",
+      "Epoch 93/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 4.2495e-04 - denoise_loss: 0.0412 - val_loss: 0.5991 - val_denoiseg: 0.5991 - val_seg_loss: 0.5583 - val_denoise_loss: 0.0408\n",
+      "Epoch 94/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.0350e-04 - denoise_loss: 0.0412 - val_loss: 0.5950 - val_denoiseg: 0.5950 - val_seg_loss: 0.5543 - val_denoise_loss: 0.0408\n",
+      "Epoch 95/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.8691e-04 - denoise_loss: 0.0412 - val_loss: 0.5598 - val_denoiseg: 0.5598 - val_seg_loss: 0.5190 - val_denoise_loss: 0.0407\n",
+      "Epoch 96/200\n",
+      "100/100 [==============================] - 94s 940ms/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.8807e-04 - denoise_loss: 0.0412 - val_loss: 0.5124 - val_denoiseg: 0.5124 - val_seg_loss: 0.4717 - val_denoise_loss: 0.0408\n",
+      "Epoch 97/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 4.8515e-04 - denoise_loss: 0.0411 - val_loss: 0.5369 - val_denoiseg: 0.5369 - val_seg_loss: 0.4961 - val_denoise_loss: 0.0408\n",
+      "\n",
+      "Epoch 00097: ReduceLROnPlateau reducing learning rate to 6.24999984211172e-06.\n",
+      "Epoch 98/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.5370e-04 - denoise_loss: 0.0412 - val_loss: 0.5626 - val_denoiseg: 0.5626 - val_seg_loss: 0.5218 - val_denoise_loss: 0.0407\n",
+      "Epoch 99/200\n",
+      "100/100 [==============================] - 104s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 4.8742e-04 - denoise_loss: 0.0411 - val_loss: 0.5880 - val_denoiseg: 0.5880 - val_seg_loss: 0.5473 - val_denoise_loss: 0.0408\n",
+      "Epoch 100/200\n",
+      "100/100 [==============================] - 105s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.2452e-04 - denoise_loss: 0.0411 - val_loss: 0.5579 - val_denoiseg: 0.5579 - val_seg_loss: 0.5171 - val_denoise_loss: 0.0408\n",
+      "Epoch 101/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.3269e-04 - denoise_loss: 0.0411 - val_loss: 0.5549 - val_denoiseg: 0.5549 - val_seg_loss: 0.5142 - val_denoise_loss: 0.0408\n",
+      "Epoch 102/200\n",
+      "100/100 [==============================] - 104s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 4.4125e-04 - denoise_loss: 0.0412 - val_loss: 0.4910 - val_denoiseg: 0.4910 - val_seg_loss: 0.4502 - val_denoise_loss: 0.0408\n",
+      "Epoch 103/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.6135e-04 - denoise_loss: 0.0412 - val_loss: 0.5305 - val_denoiseg: 0.5305 - val_seg_loss: 0.4897 - val_denoise_loss: 0.0408\n",
+      "Epoch 104/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.9272e-04 - denoise_loss: 0.0412 - val_loss: 0.5509 - val_denoiseg: 0.5509 - val_seg_loss: 0.5101 - val_denoise_loss: 0.0408\n",
+      "Epoch 105/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.2346e-04 - denoise_loss: 0.0411 - val_loss: 0.5538 - val_denoiseg: 0.5538 - val_seg_loss: 0.5130 - val_denoise_loss: 0.0408\n",
+      "Epoch 106/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.3025e-04 - denoise_loss: 0.0411 - val_loss: 0.5294 - val_denoiseg: 0.5294 - val_seg_loss: 0.4886 - val_denoise_loss: 0.0408\n",
+      "Epoch 107/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.1116e-04 - denoise_loss: 0.0412 - val_loss: 0.5477 - val_denoiseg: 0.5477 - val_seg_loss: 0.5070 - val_denoise_loss: 0.0408\n",
+      "\n",
+      "Epoch 00107: ReduceLROnPlateau reducing learning rate to 3.12499992105586e-06.\n",
+      "Epoch 108/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.2606e-04 - denoise_loss: 0.0412 - val_loss: 0.5336 - val_denoiseg: 0.5336 - val_seg_loss: 0.4929 - val_denoise_loss: 0.0407\n",
+      "Epoch 109/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 4.5036e-04 - denoise_loss: 0.0411 - val_loss: 0.5308 - val_denoiseg: 0.5308 - val_seg_loss: 0.4900 - val_denoise_loss: 0.0408\n",
+      "Epoch 110/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.7513e-04 - denoise_loss: 0.0411 - val_loss: 0.5463 - val_denoiseg: 0.5463 - val_seg_loss: 0.5055 - val_denoise_loss: 0.0408\n",
+      "Epoch 111/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.1943e-04 - denoise_loss: 0.0411 - val_loss: 0.5452 - val_denoiseg: 0.5452 - val_seg_loss: 0.5044 - val_denoise_loss: 0.0408\n",
+      "Epoch 112/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.9553e-04 - denoise_loss: 0.0412 - val_loss: 0.5520 - val_denoiseg: 0.5520 - val_seg_loss: 0.5112 - val_denoise_loss: 0.0408\n",
+      "Epoch 113/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.2468e-04 - denoise_loss: 0.0413 - val_loss: 0.5339 - val_denoiseg: 0.5339 - val_seg_loss: 0.4932 - val_denoise_loss: 0.0407\n",
+      "Epoch 114/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0415 - denoiseg: 0.0415 - seg_loss: 5.2377e-04 - denoise_loss: 0.0410 - val_loss: 0.5732 - val_denoiseg: 0.5732 - val_seg_loss: 0.5324 - val_denoise_loss: 0.0407\n",
+      "Epoch 115/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0415 - denoiseg: 0.0415 - seg_loss: 5.3218e-04 - denoise_loss: 0.0410 - val_loss: 0.5820 - val_denoiseg: 0.5820 - val_seg_loss: 0.5413 - val_denoise_loss: 0.0407\n",
+      "Epoch 116/200\n",
+      "100/100 [==============================] - 101s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 4.8138e-04 - denoise_loss: 0.0414 - val_loss: 0.5680 - val_denoiseg: 0.5680 - val_seg_loss: 0.5272 - val_denoise_loss: 0.0408\n",
+      "Epoch 117/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.1186e-04 - denoise_loss: 0.0411 - val_loss: 0.5462 - val_denoiseg: 0.5462 - val_seg_loss: 0.5054 - val_denoise_loss: 0.0408\n",
+      "\n",
+      "Epoch 00117: ReduceLROnPlateau reducing learning rate to 1.56249996052793e-06.\n",
+      "Epoch 118/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 4.8565e-04 - denoise_loss: 0.0413 - val_loss: 0.5647 - val_denoiseg: 0.5647 - val_seg_loss: 0.5240 - val_denoise_loss: 0.0408\n",
+      "Epoch 119/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.2470e-04 - denoise_loss: 0.0412 - val_loss: 0.5650 - val_denoiseg: 0.5650 - val_seg_loss: 0.5242 - val_denoise_loss: 0.0408\n",
+      "Epoch 120/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.0937e-04 - denoise_loss: 0.0411 - val_loss: 0.5769 - val_denoiseg: 0.5769 - val_seg_loss: 0.5361 - val_denoise_loss: 0.0408\n",
+      "Epoch 121/200\n",
+      "100/100 [==============================] - 98s 984ms/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.7797e-04 - denoise_loss: 0.0412 - val_loss: 0.5788 - val_denoiseg: 0.5788 - val_seg_loss: 0.5381 - val_denoise_loss: 0.0408\n",
+      "Epoch 122/200\n",
+      "100/100 [==============================] - 95s 947ms/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 4.4748e-04 - denoise_loss: 0.0412 - val_loss: 0.5778 - val_denoiseg: 0.5778 - val_seg_loss: 0.5370 - val_denoise_loss: 0.0408\n",
+      "Epoch 123/200\n",
+      "100/100 [==============================] - 90s 901ms/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.6189e-04 - denoise_loss: 0.0411 - val_loss: 0.5774 - val_denoiseg: 0.5774 - val_seg_loss: 0.5366 - val_denoise_loss: 0.0408\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 124/200\n",
+      "  3/100 [..............................] - ETA: 1:05 - loss: 0.0420 - denoiseg: 0.0420 - seg_loss: 3.4332e-04 - denoise_loss: 0.0417"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.125451). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 100s 998ms/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.0529e-04 - denoise_loss: 0.0413 - val_loss: 0.5577 - val_denoiseg: 0.5577 - val_seg_loss: 0.5169 - val_denoise_loss: 0.0408\n",
+      "Epoch 125/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.4418e-04 - denoise_loss: 0.0411 - val_loss: 0.5542 - val_denoiseg: 0.5542 - val_seg_loss: 0.5135 - val_denoise_loss: 0.0408\n",
+      "Epoch 126/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.5426e-04 - denoise_loss: 0.0411 - val_loss: 0.5738 - val_denoiseg: 0.5738 - val_seg_loss: 0.5331 - val_denoise_loss: 0.0408\n",
+      "Epoch 127/200\n",
+      "100/100 [==============================] - 115s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.1676e-04 - denoise_loss: 0.0412 - val_loss: 0.5488 - val_denoiseg: 0.5488 - val_seg_loss: 0.5081 - val_denoise_loss: 0.0408\n",
+      "\n",
+      "Epoch 00127: ReduceLROnPlateau reducing learning rate to 7.81249980263965e-07.\n",
+      "Epoch 128/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 5.3920e-04 - denoise_loss: 0.0413 - val_loss: 0.5654 - val_denoiseg: 0.5654 - val_seg_loss: 0.5247 - val_denoise_loss: 0.0408\n",
+      "Epoch 129/200\n",
+      "100/100 [==============================] - 116s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.1373e-04 - denoise_loss: 0.0411 - val_loss: 0.5624 - val_denoiseg: 0.5624 - val_seg_loss: 0.5216 - val_denoise_loss: 0.0407\n",
+      "Epoch 130/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0415 - denoiseg: 0.0415 - seg_loss: 5.1054e-04 - denoise_loss: 0.0410 - val_loss: 0.5735 - val_denoiseg: 0.5735 - val_seg_loss: 0.5328 - val_denoise_loss: 0.0407\n",
+      "Epoch 131/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.8756e-04 - denoise_loss: 0.0412 - val_loss: 0.5759 - val_denoiseg: 0.5759 - val_seg_loss: 0.5351 - val_denoise_loss: 0.0408\n",
+      "Epoch 132/200\n",
+      " 99/100 [============================>.] - ETA: 1s - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 4.4688e-04 - denoise_loss: 0.0414"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.100208). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 115s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 4.4241e-04 - denoise_loss: 0.0414 - val_loss: 0.5718 - val_denoiseg: 0.5718 - val_seg_loss: 0.5310 - val_denoise_loss: 0.0407\n",
+      "Epoch 133/200\n",
+      "  4/100 [>.............................] - ETA: 57s - loss: 0.0425 - denoiseg: 0.0425 - seg_loss: 8.0774e-04 - denoise_loss: 0.0417"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.100712). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 6.1585e-04 - denoise_loss: 0.0412 - val_loss: 0.5658 - val_denoiseg: 0.5658 - val_seg_loss: 0.5251 - val_denoise_loss: 0.0408\n",
+      "Epoch 134/200\n",
+      "100/100 [==============================] - 117s 1s/step - loss: 0.0414 - denoiseg: 0.0414 - seg_loss: 4.6582e-04 - denoise_loss: 0.0410 - val_loss: 0.5644 - val_denoiseg: 0.5644 - val_seg_loss: 0.5237 - val_denoise_loss: 0.0408\n",
+      "Epoch 135/200\n",
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0415 - denoiseg: 0.0415 - seg_loss: 5.2568e-04 - denoise_loss: 0.0410 - val_loss: 0.5744 - val_denoiseg: 0.5744 - val_seg_loss: 0.5336 - val_denoise_loss: 0.0407\n",
+      "Epoch 136/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.4124e-04 - denoise_loss: 0.0412 - val_loss: 0.5699 - val_denoiseg: 0.5699 - val_seg_loss: 0.5291 - val_denoise_loss: 0.0408\n",
+      "Epoch 137/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 6.1421e-04 - denoise_loss: 0.0411 - val_loss: 0.5569 - val_denoiseg: 0.5569 - val_seg_loss: 0.5162 - val_denoise_loss: 0.0407\n",
+      "\n",
+      "Epoch 00137: ReduceLROnPlateau reducing learning rate to 3.906249901319825e-07.\n",
+      "Epoch 138/200\n",
+      "100/100 [==============================] - 103s 1s/step - loss: 0.0415 - denoiseg: 0.0415 - seg_loss: 4.3165e-04 - denoise_loss: 0.0410 - val_loss: 0.5633 - val_denoiseg: 0.5633 - val_seg_loss: 0.5226 - val_denoise_loss: 0.0408\n",
+      "Epoch 139/200\n",
+      "  2/100 [..............................] - ETA: 18s - loss: 0.0412 - denoiseg: 0.0412 - seg_loss: 4.1531e-04 - denoise_loss: 0.0408"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.145885). Check your callbacks.\n",
+      "  % delta_t_median)\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.108012). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 98s 980ms/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.4933e-04 - denoise_loss: 0.0411 - val_loss: 0.5615 - val_denoiseg: 0.5615 - val_seg_loss: 0.5207 - val_denoise_loss: 0.0407\n",
+      "Epoch 140/200\n",
+      " 26/100 [======>.......................] - ETA: 1:03 - loss: 0.0415 - denoiseg: 0.0415 - seg_loss: 3.7627e-04 - denoise_loss: 0.0411"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.114539). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 31/100 [========>.....................] - ETA: 59s - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 4.2153e-04 - denoise_loss: 0.0411 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.108005). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 90s 905ms/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.1560e-04 - denoise_loss: 0.0412 - val_loss: 0.5658 - val_denoiseg: 0.5658 - val_seg_loss: 0.5251 - val_denoise_loss: 0.0408\n",
+      "Epoch 141/200\n",
+      "100/100 [==============================] - 92s 922ms/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.1849e-04 - denoise_loss: 0.0412 - val_loss: 0.5555 - val_denoiseg: 0.5555 - val_seg_loss: 0.5147 - val_denoise_loss: 0.0407\n",
+      "Epoch 142/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.5074e-04 - denoise_loss: 0.0412 - val_loss: 0.5527 - val_denoiseg: 0.5527 - val_seg_loss: 0.5119 - val_denoise_loss: 0.0407\n",
+      "Epoch 143/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.5798e-04 - denoise_loss: 0.0411 - val_loss: 0.5592 - val_denoiseg: 0.5592 - val_seg_loss: 0.5184 - val_denoise_loss: 0.0408\n",
+      "Epoch 144/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 4.9521e-04 - denoise_loss: 0.0413 - val_loss: 0.5566 - val_denoiseg: 0.5566 - val_seg_loss: 0.5159 - val_denoise_loss: 0.0408\n",
+      "Epoch 145/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.1635e-04 - denoise_loss: 0.0411 - val_loss: 0.5648 - val_denoiseg: 0.5648 - val_seg_loss: 0.5241 - val_denoise_loss: 0.0408\n",
+      "Epoch 146/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 5.9163e-04 - denoise_loss: 0.0413 - val_loss: 0.5647 - val_denoiseg: 0.5647 - val_seg_loss: 0.5240 - val_denoise_loss: 0.0408\n",
+      "Epoch 147/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.8339e-04 - denoise_loss: 0.0412 - val_loss: 0.5736 - val_denoiseg: 0.5736 - val_seg_loss: 0.5329 - val_denoise_loss: 0.0408\n",
+      "\n",
+      "Epoch 00147: ReduceLROnPlateau reducing learning rate to 1.9531249506599124e-07.\n",
+      "Epoch 148/200\n",
+      "100/100 [==============================] - 115s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.3099e-04 - denoise_loss: 0.0412 - val_loss: 0.5642 - val_denoiseg: 0.5642 - val_seg_loss: 0.5234 - val_denoise_loss: 0.0408\n",
+      "Epoch 149/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.9747e-04 - denoise_loss: 0.0412 - val_loss: 0.5612 - val_denoiseg: 0.5612 - val_seg_loss: 0.5204 - val_denoise_loss: 0.0408\n",
+      "Epoch 150/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.8143e-04 - denoise_loss: 0.0411 - val_loss: 0.5587 - val_denoiseg: 0.5587 - val_seg_loss: 0.5180 - val_denoise_loss: 0.0408\n",
+      "Epoch 151/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.0348e-04 - denoise_loss: 0.0411 - val_loss: 0.5605 - val_denoiseg: 0.5605 - val_seg_loss: 0.5197 - val_denoise_loss: 0.0408\n",
+      "Epoch 152/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.1253e-04 - denoise_loss: 0.0413 - val_loss: 0.5612 - val_denoiseg: 0.5612 - val_seg_loss: 0.5204 - val_denoise_loss: 0.0408\n",
+      "Epoch 153/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 5.4669e-04 - denoise_loss: 0.0413 - val_loss: 0.5614 - val_denoiseg: 0.5614 - val_seg_loss: 0.5207 - val_denoise_loss: 0.0408\n",
+      "Epoch 154/200\n",
+      "100/100 [==============================] - 115s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.8881e-04 - denoise_loss: 0.0412 - val_loss: 0.5675 - val_denoiseg: 0.5675 - val_seg_loss: 0.5267 - val_denoise_loss: 0.0408\n",
+      "Epoch 155/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.4562e-04 - denoise_loss: 0.0410 - val_loss: 0.5803 - val_denoiseg: 0.5803 - val_seg_loss: 0.5395 - val_denoise_loss: 0.0408\n",
+      "Epoch 156/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.0513e-04 - denoise_loss: 0.0411 - val_loss: 0.5683 - val_denoiseg: 0.5683 - val_seg_loss: 0.5276 - val_denoise_loss: 0.0408\n",
+      "Epoch 157/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0414 - denoiseg: 0.0414 - seg_loss: 4.4620e-04 - denoise_loss: 0.0410 - val_loss: 0.5706 - val_denoiseg: 0.5706 - val_seg_loss: 0.5298 - val_denoise_loss: 0.0408\n",
+      "\n",
+      "Epoch 00157: ReduceLROnPlateau reducing learning rate to 9.765624753299562e-08.\n",
+      "Epoch 158/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 6.1713e-04 - denoise_loss: 0.0411 - val_loss: 0.5605 - val_denoiseg: 0.5605 - val_seg_loss: 0.5198 - val_denoise_loss: 0.0408\n",
+      "Epoch 159/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 3.8201e-04 - denoise_loss: 0.0412 - val_loss: 0.5569 - val_denoiseg: 0.5569 - val_seg_loss: 0.5161 - val_denoise_loss: 0.0407\n",
+      "Epoch 160/200\n",
+      " 85/100 [========================>.....] - ETA: 16s - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 6.4713e-04 - denoise_loss: 0.0412"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.100867). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 88/100 [=========================>....] - ETA: 13s - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 6.2507e-04 - denoise_loss: 0.0412"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.120523). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 6.1988e-04 - denoise_loss: 0.0412 - val_loss: 0.5531 - val_denoiseg: 0.5531 - val_seg_loss: 0.5124 - val_denoise_loss: 0.0408\n",
+      "Epoch 161/200\n",
+      "  2/100 [..............................] - ETA: 21s - loss: 0.0399 - denoiseg: 0.0399 - seg_loss: 0.0000e+00 - denoise_loss: 0.039 - ETA: 23s - loss: 0.0401 - denoiseg: 0.0401 - seg_loss: 0.0000e+00 - denoise_loss: 0.0401"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.101279). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 94s 943ms/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.9303e-04 - denoise_loss: 0.0412 - val_loss: 0.5587 - val_denoiseg: 0.5587 - val_seg_loss: 0.5180 - val_denoise_loss: 0.0407\n",
+      "Epoch 162/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.1616e-04 - denoise_loss: 0.0413 - val_loss: 0.5645 - val_denoiseg: 0.5645 - val_seg_loss: 0.5237 - val_denoise_loss: 0.0408\n",
+      "Epoch 163/200\n",
+      "  5/100 [>.............................] - ETA: 52s - loss: 0.0414 - denoiseg: 0.0414 - seg_loss: 2.9898e-04 - denoise_loss: 0.0411"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.101491). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 41/100 [===========>..................] - ETA: 52s - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.1955e-04 - denoise_loss: 0.0412"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.103347). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 44/100 [============>.................] - ETA: 49s - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.8413e-04 - denoise_loss: 0.0412"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.120276). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 46/100 [============>.................] - ETA: 48s - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.6308e-04 - denoise_loss: 0.0412"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.134032). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 48/100 [=============>................] - ETA: 46s - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.6591e-04 - denoise_loss: 0.0412"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.123012). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 93s 927ms/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.4268e-04 - denoise_loss: 0.0413 - val_loss: 0.5581 - val_denoiseg: 0.5581 - val_seg_loss: 0.5173 - val_denoise_loss: 0.0408\n",
+      "Epoch 164/200\n",
+      "  5/100 [>.............................] - ETA: 55s - loss: 0.0411 - denoiseg: 0.0411 - seg_loss: 0.0000e+00 - denoise_loss: 0.0411"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.132168). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 11/100 [==>...........................] - ETA: 1:07 - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 3.3937e-04 - denoise_loss: 0.0414"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.107955). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 63/100 [=================>............] - ETA: 33s - loss: 0.0415 - denoiseg: 0.0415 - seg_loss: 4.5473e-04 - denoise_loss: 0.0410"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.104199). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 91s 908ms/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.0811e-04 - denoise_loss: 0.0411 - val_loss: 0.5671 - val_denoiseg: 0.5671 - val_seg_loss: 0.5264 - val_denoise_loss: 0.0408\n",
+      "Epoch 165/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 4.5519e-04 - denoise_loss: 0.0412 - val_loss: 0.5639 - val_denoiseg: 0.5639 - val_seg_loss: 0.5231 - val_denoise_loss: 0.0408\n",
+      "Epoch 166/200\n",
+      "  1/100 [..............................] - ETA: 12s - loss: 0.0426 - denoiseg: 0.0426 - seg_loss: 0.0016 - denoise_loss: 0.0410"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.170322). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.6912e-04 - denoise_loss: 0.0412 - val_loss: 0.5621 - val_denoiseg: 0.5621 - val_seg_loss: 0.5213 - val_denoise_loss: 0.0408\n",
+      "Epoch 167/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 4.8754e-04 - denoise_loss: 0.0411 - val_loss: 0.5637 - val_denoiseg: 0.5637 - val_seg_loss: 0.5230 - val_denoise_loss: 0.0408\n",
+      "\n",
+      "Epoch 00167: ReduceLROnPlateau reducing learning rate to 4.882812376649781e-08.\n",
+      "Epoch 168/200\n",
+      "  5/100 [>.............................] - ETA: 1:10 - loss: 0.0411 - denoiseg: 0.0411 - seg_loss: 5.4463e-04 - denoise_loss: 0.0406"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.104036). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 50/100 [==============>...............] - ETA: 44s - loss: 0.0415 - denoiseg: 0.0415 - seg_loss: 4.3916e-04 - denoise_loss: 0.0411"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.107293). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 94s 941ms/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 4.5960e-04 - denoise_loss: 0.0412 - val_loss: 0.5691 - val_denoiseg: 0.5691 - val_seg_loss: 0.5284 - val_denoise_loss: 0.0408\n",
+      "Epoch 169/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 6.2503e-04 - denoise_loss: 0.0413 - val_loss: 0.5721 - val_denoiseg: 0.5721 - val_seg_loss: 0.5313 - val_denoise_loss: 0.0408\n",
+      "Epoch 170/200\n",
+      "  2/100 [..............................] - ETA: 53s - loss: 0.0410 - denoiseg: 0.0410 - seg_loss: 5.8544e-04 - denoise_loss: 0.0404"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.120751). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  3/100 [..............................] - ETA: 1:05 - loss: 0.0408 - denoiseg: 0.0408 - seg_loss: 3.9029e-04 - denoise_loss: 0.0405"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.152241). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  4/100 [>.............................] - ETA: 1:15 - loss: 0.0406 - denoiseg: 0.0406 - seg_loss: 2.9272e-04 - denoise_loss: 0.0403"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.107557). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 117s 1s/step - loss: 0.0415 - denoiseg: 0.0415 - seg_loss: 4.7548e-04 - denoise_loss: 0.0411 - val_loss: 0.5711 - val_denoiseg: 0.5711 - val_seg_loss: 0.5303 - val_denoise_loss: 0.0408\n",
+      "Epoch 171/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 4.8534e-04 - denoise_loss: 0.0411 - val_loss: 0.5674 - val_denoiseg: 0.5674 - val_seg_loss: 0.5266 - val_denoise_loss: 0.0408\n",
+      "Epoch 172/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.1227e-04 - denoise_loss: 0.0411 - val_loss: 0.5649 - val_denoiseg: 0.5649 - val_seg_loss: 0.5241 - val_denoise_loss: 0.0408\n",
+      "Epoch 173/200\n",
+      "100/100 [==============================] - 116s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 4.7040e-04 - denoise_loss: 0.0412 - val_loss: 0.5664 - val_denoiseg: 0.5664 - val_seg_loss: 0.5256 - val_denoise_loss: 0.0408\n",
+      "Epoch 174/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.8635e-04 - denoise_loss: 0.0411 - val_loss: 0.5605 - val_denoiseg: 0.5605 - val_seg_loss: 0.5198 - val_denoise_loss: 0.0407\n",
+      "Epoch 175/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.4464e-04 - denoise_loss: 0.0412 - val_loss: 0.5587 - val_denoiseg: 0.5587 - val_seg_loss: 0.5180 - val_denoise_loss: 0.0408\n",
+      "Epoch 176/200\n",
+      "  2/100 [..............................] - ETA: 57s - loss: 0.0404 - denoiseg: 0.0404 - seg_loss: 0.0000e+00 - denoise_loss: 0.0404"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.120732). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 117s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.2202e-04 - denoise_loss: 0.0413 - val_loss: 0.5528 - val_denoiseg: 0.5528 - val_seg_loss: 0.5121 - val_denoise_loss: 0.0407\n",
+      "Epoch 177/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 4.4467e-04 - denoise_loss: 0.0414 - val_loss: 0.5562 - val_denoiseg: 0.5562 - val_seg_loss: 0.5155 - val_denoise_loss: 0.0408\n",
+      "\n",
+      "Epoch 00177: ReduceLROnPlateau reducing learning rate to 2.4414061883248905e-08.\n",
+      "Epoch 178/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.3824e-04 - denoise_loss: 0.0410 - val_loss: 0.5637 - val_denoiseg: 0.5637 - val_seg_loss: 0.5230 - val_denoise_loss: 0.0408\n",
+      "Epoch 179/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 4.5497e-04 - denoise_loss: 0.0411 - val_loss: 0.5639 - val_denoiseg: 0.5639 - val_seg_loss: 0.5232 - val_denoise_loss: 0.0408\n",
+      "Epoch 180/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.6038e-04 - denoise_loss: 0.0411 - val_loss: 0.5666 - val_denoiseg: 0.5666 - val_seg_loss: 0.5259 - val_denoise_loss: 0.0408\n",
+      "Epoch 181/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.3792e-04 - denoise_loss: 0.0411 - val_loss: 0.5660 - val_denoiseg: 0.5660 - val_seg_loss: 0.5252 - val_denoise_loss: 0.0408\n",
+      "Epoch 182/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.9808e-04 - denoise_loss: 0.0412 - val_loss: 0.5649 - val_denoiseg: 0.5649 - val_seg_loss: 0.5241 - val_denoise_loss: 0.0408\n",
+      "Epoch 183/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.1953e-04 - denoise_loss: 0.0411 - val_loss: 0.5662 - val_denoiseg: 0.5662 - val_seg_loss: 0.5255 - val_denoise_loss: 0.0408\n",
+      "Epoch 184/200\n",
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 4.5228e-04 - denoise_loss: 0.0414 - val_loss: 0.5689 - val_denoiseg: 0.5689 - val_seg_loss: 0.5281 - val_denoise_loss: 0.0408\n",
+      "Epoch 185/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 5.6904e-04 - denoise_loss: 0.0413 - val_loss: 0.5627 - val_denoiseg: 0.5627 - val_seg_loss: 0.5219 - val_denoise_loss: 0.0408\n",
+      "Epoch 186/200\n",
+      " 88/100 [=========================>....] - ETA: 11s - loss: 0.0415 - denoiseg: 0.0415 - seg_loss: 4.8400e-04 - denoise_loss: 0.0411"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.100401). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 99s 987ms/step - loss: 0.0415 - denoiseg: 0.0415 - seg_loss: 4.8166e-04 - denoise_loss: 0.0410 - val_loss: 0.5616 - val_denoiseg: 0.5616 - val_seg_loss: 0.5209 - val_denoise_loss: 0.0408\n",
+      "Epoch 187/200\n",
+      " 22/100 [=====>........................] - ETA: 1:07 - loss: 0.0420 - denoiseg: 0.0420 - seg_loss: 5.3553e-04 - denoise_loss: 0.0414"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.113939). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 93s 926ms/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.1720e-04 - denoise_loss: 0.0412 - val_loss: 0.5657 - val_denoiseg: 0.5657 - val_seg_loss: 0.5249 - val_denoise_loss: 0.0408\n",
+      "\n",
+      "Epoch 00187: ReduceLROnPlateau reducing learning rate to 1.2207030941624453e-08.\n",
+      "Epoch 188/200\n",
+      "100/100 [==============================] - 103s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.4409e-04 - denoise_loss: 0.0412 - val_loss: 0.5580 - val_denoiseg: 0.5580 - val_seg_loss: 0.5173 - val_denoise_loss: 0.0408\n",
+      "Epoch 189/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.1751e-04 - denoise_loss: 0.0412 - val_loss: 0.5631 - val_denoiseg: 0.5631 - val_seg_loss: 0.5223 - val_denoise_loss: 0.0408\n",
+      "Epoch 190/200\n",
+      "100/100 [==============================] - 115s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.7916e-04 - denoise_loss: 0.0412 - val_loss: 0.5637 - val_denoiseg: 0.5637 - val_seg_loss: 0.5230 - val_denoise_loss: 0.0408\n",
+      "Epoch 191/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.1630e-04 - denoise_loss: 0.0412 - val_loss: 0.5645 - val_denoiseg: 0.5645 - val_seg_loss: 0.5237 - val_denoise_loss: 0.0408\n",
+      "Epoch 192/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.5087e-04 - denoise_loss: 0.0411 - val_loss: 0.5559 - val_denoiseg: 0.5559 - val_seg_loss: 0.5151 - val_denoise_loss: 0.0407\n",
+      "Epoch 193/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 5.1526e-04 - denoise_loss: 0.0410 - val_loss: 0.5635 - val_denoiseg: 0.5635 - val_seg_loss: 0.5228 - val_denoise_loss: 0.0408\n",
+      "Epoch 194/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0419 - denoiseg: 0.0419 - seg_loss: 5.4398e-04 - denoise_loss: 0.0413 - val_loss: 0.5646 - val_denoiseg: 0.5646 - val_seg_loss: 0.5239 - val_denoise_loss: 0.0408\n",
+      "Epoch 195/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.4860e-04 - denoise_loss: 0.0412 - val_loss: 0.5581 - val_denoiseg: 0.5581 - val_seg_loss: 0.5173 - val_denoise_loss: 0.0407\n",
+      "Epoch 196/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.2056e-04 - denoise_loss: 0.0411 - val_loss: 0.5669 - val_denoiseg: 0.5669 - val_seg_loss: 0.5261 - val_denoise_loss: 0.0408\n",
+      "Epoch 197/200\n",
+      "  1/100 [..............................] - ETA: 10s - loss: 0.0414 - denoiseg: 0.0414 - seg_loss: 0.0000e+00 - denoise_loss: 0.0414"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.105164). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0416 - denoiseg: 0.0416 - seg_loss: 4.5182e-04 - denoise_loss: 0.0412 - val_loss: 0.5671 - val_denoiseg: 0.5671 - val_seg_loss: 0.5263 - val_denoise_loss: 0.0408\n",
+      "\n",
+      "Epoch 00197: ReduceLROnPlateau reducing learning rate to 6.103515470812226e-09.\n",
+      "Epoch 198/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 5.3291e-04 - denoise_loss: 0.0413 - val_loss: 0.5592 - val_denoiseg: 0.5592 - val_seg_loss: 0.5184 - val_denoise_loss: 0.0408\n",
+      "Epoch 199/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 5.7343e-04 - denoise_loss: 0.0411 - val_loss: 0.5632 - val_denoiseg: 0.5632 - val_seg_loss: 0.5225 - val_denoise_loss: 0.0408\n",
+      "Epoch 200/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 4.6245e-04 - denoise_loss: 0.0413 - val_loss: 0.5693 - val_denoiseg: 0.5693 - val_seg_loss: 0.5285 - val_denoise_loss: 0.0408\n",
+      "\n",
+      "Loading network weights from 'weights_best.h5'.\n"
+     ]
+    }
+   ],
+   "source": [
+    "history = model.train(X, Y, (X_val, Y_val))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['val_loss', 'val_denoiseg', 'val_seg_loss', 'val_denoise_loss', 'loss', 'denoiseg', 'seg_loss', 'denoise_loss', 'lr'])"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "history.history.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_history(history, ['loss', 'val_loss'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Computing Threshold Value\n",
+    "The network predicts 4 output channels:\n",
+    "1. The denoised input.\n",
+    "2. The foreground likelihoods.\n",
+    "3. The background likelihoods.\n",
+    "4. The border likelihoods.\n",
+    "\n",
+    "We will threshold the foreground prediction image to obtain object segmentations. The optimal threshold is determined on the validation data. Additionally we can optimize the threshold for a given measure. In this case we choose the Average Precision (AP) measure."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Computing best threshold: \n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "HBox(children=(FloatProgress(value=0.0, max=19.0), HTML(value='')))"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/Desktop/GitClones/DenoiSeg/denoiseg/utils/compute_precision_threshold.py:7: NumbaWarning: \n",
+      "Compilation is falling back to object mode WITH looplifting enabled because Function \"pixel_sharing_bipartite\" failed type inference due to: Invalid use of Function(<built-in function zeros>) with argument(s) of type(s): (UniTuple(int64 x 2), dtype=Function(<class 'int'>))\n",
+      " * parameterized\n",
+      "In definition 0:\n",
+      "    All templates rejected with literals.\n",
+      "In definition 1:\n",
+      "    All templates rejected without literals.\n",
+      "This error is usually caused by passing an argument of a type that is unsupported by the named function.\n",
+      "[1] During: resolving callee type: Function(<built-in function zeros>)\n",
+      "[2] During: typing of call at /home/prakash/Desktop/GitClones/DenoiSeg/denoiseg/utils/compute_precision_threshold.py (10)\n",
+      "\n",
+      "\n",
+      "File \"../../denoiseg/utils/compute_precision_threshold.py\", line 10:\n",
+      "def pixel_sharing_bipartite(lab1, lab2):\n",
+      "    <source elided>\n",
+      "    assert lab1.shape == lab2.shape\n",
+      "    psg = np.zeros((lab1.max() + 1, lab2.max() + 1), dtype=np.int)\n",
+      "    ^\n",
+      "\n",
+      "  @jit\n",
+      "/home/prakash/Desktop/GitClones/DenoiSeg/denoiseg/utils/compute_precision_threshold.py:7: NumbaWarning: \n",
+      "Compilation is falling back to object mode WITHOUT looplifting enabled because Function \"pixel_sharing_bipartite\" failed type inference due to: Unsupported constraint encountered: raise $14.1\n",
+      "\n",
+      "File \"../../denoiseg/utils/compute_precision_threshold.py\", line 9:\n",
+      "def pixel_sharing_bipartite(lab1, lab2):\n",
+      "    assert lab1.shape == lab2.shape\n",
+      "    ^\n",
+      "\n",
+      "  @jit\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/numba/object_mode_passes.py:178: NumbaWarning: Function \"pixel_sharing_bipartite\" was compiled in object mode without forceobj=True, but has lifted loops.\n",
+      "\n",
+      "File \"../../denoiseg/utils/compute_precision_threshold.py\", line 9:\n",
+      "def pixel_sharing_bipartite(lab1, lab2):\n",
+      "    assert lab1.shape == lab2.shape\n",
+      "    ^\n",
+      "\n",
+      "  state.func_ir.loc))\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/numba/object_mode_passes.py:188: NumbaDeprecationWarning: \n",
+      "Fall-back from the nopython compilation path to the object mode compilation path has been detected, this is deprecated behaviour.\n",
+      "\n",
+      "For more information visit http://numba.pydata.org/numba-doc/latest/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit\n",
+      "\n",
+      "File \"../../denoiseg/utils/compute_precision_threshold.py\", line 9:\n",
+      "def pixel_sharing_bipartite(lab1, lab2):\n",
+      "    assert lab1.shape == lab2.shape\n",
+      "    ^\n",
+      "\n",
+      "  state.func_ir.loc))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Score for threshold = 0.10 is 0.0081\n",
+      "Score for threshold = 0.15 is 0.1588\n",
+      "Score for threshold = 0.20 is 0.4768\n",
+      "Score for threshold = 0.25 is 0.6597\n",
+      "Score for threshold = 0.30 is 0.7228\n",
+      "Score for threshold = 0.35 is 0.7457\n",
+      "Score for threshold = 0.40 is 0.7548\n",
+      "Score for threshold = 0.45 is 0.7555\n",
+      "Score for threshold = 0.50 is 0.7525\n",
+      "Score for threshold = 0.55 is 0.7496\n",
+      "Score for threshold = 0.60 is 0.7438\n",
+      "Score for threshold = 0.65 is 0.7391\n",
+      "Score for threshold = 0.70 is 0.7265\n",
+      "Score for threshold = 0.75 is 0.7124\n",
+      "Score for threshold = 0.80 is 0.6925\n",
+      "Score for threshold = 0.85 is 0.6614\n",
+      "Score for threshold = 0.90 is 0.6146\n",
+      "Score for threshold = 0.95 is 0.4960\n",
+      "Score for threshold = 1.00 is 0.0000\n",
+      "\n",
+      "The higest score of 0.755 is achieved with threshold = 0.45000000000000007.\n"
+     ]
+    }
+   ],
+   "source": [
+    "threshold, val_score = model.optimize_thresholds(val_images.astype(np.float32), val_masks, measure=measure_precision())\n",
+    "\n",
+    "print(\"The higest score of {} is achieved with threshold = {}.\".format(np.round(val_score, 3), threshold))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test Data\n",
+    "Finally we load the test data and run the prediction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "test_data =  np.load('data/Flywing_{}/test/test_data.npz'.format(noise_level), allow_pickle=True)\n",
+    "test_images = test_data['X_test']\n",
+    "test_masks = test_data['Y_test']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Average precision over all test images with threshold = 0.45000000000000007 is 0.814.\n"
+     ]
+    }
+   ],
+   "source": [
+    "predicted_images, precision_result = model.predict_label_masks(test_images, test_masks, threshold, \n",
+    "                                                                   measure=measure_precision())\n",
+    "print(\"Average precision over all test images with threshold = {} is {}.\".format(threshold, np.round(precision_result, 3)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "DenoiSeg_figures",
+   "language": "python",
+   "name": "denoiseg_figures"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/DenoiSeg_2D/MouseNuclei_DenoiSeg_Example.ipynb b/examples/DenoiSeg_2D/MouseNuclei_DenoiSeg_Example.ipynb
new file mode 100644
index 0000000..daeef42
--- /dev/null
+++ b/examples/DenoiSeg_2D/MouseNuclei_DenoiSeg_Example.ipynb
@@ -0,0 +1,2033 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# DenoiSeg Example: Mouse Nuclei\n",
+    "This is an example notebook which illustrates how DenoiSeg should be trained. In this notebook we use nuclei dataset from a mouse skull from our collaborators. We already split the data into train and test images. From the train images we then extracted 908 training and 160 validation patches of size 128x128. The test set contains 67 images of size 256x256."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using TensorFlow backend.\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:523: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
+      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:524: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
+      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
+      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:526: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
+      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:527: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
+      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:532: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
+      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/numba/npyufunc/parallel.py:300: UserWarning: Could not obtain multiprocessing lock due to OS level error: [Errno 13] Permission denied\n",
+      "A likely cause of this problem is '/dev/shm' is missing orread-only such that necessary semaphores cannot be written.\n",
+      "*** The responsibility of ensuring multiprocessing safe access to this initialization sequence/module import is deferred to the user! ***\n",
+      "\n",
+      "  warnings.warn(msg % str(e))\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Here we are just importing some libraries which are needed to run this notebook.\n",
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "from scipy import ndimage\n",
+    "\n",
+    "from denoiseg.models import DenoiSeg, DenoiSegConfig\n",
+    "from denoiseg.utils.misc_utils import combine_train_test_data, shuffle_train_data, augment_data\n",
+    "from denoiseg.utils.seg_utils import *\n",
+    "from denoiseg.utils.compute_precision_threshold import measure_precision\n",
+    "\n",
+    "from csbdeep.utils import plot_history\n",
+    "\n",
+    "import urllib\n",
+    "import os\n",
+    "import zipfile"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Downloading and  Data Loading\n",
+    "We created three versions of this dataset by adding Gaussian noise with zero mean and standard deviations 10 and 20. The dataset are marked with the suffixes n0, n10 and n20 accordingly.\n",
+    "\n",
+    "In the next cell you can choose which `noise_level` you would like to investigate."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Choose the noise level you would like to look at:\n",
+    "# Values: 'n0', 'n10', 'n20'\n",
+    "noise_level = 'n10'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# create a folder for our data\n",
+    "if not os.path.isdir('./data'):\n",
+    "    os.mkdir('data')\n",
+    "    \n",
+    "if noise_level == 'n0':\n",
+    "    link = 'https://owncloud.mpi-cbg.de/index.php/s/nU9apzMYnEw7quC/download'\n",
+    "elif noise_level == 'n10':\n",
+    "    link = 'https://owncloud.mpi-cbg.de/index.php/s/hKf1AgVgD2RnPMN/download'\n",
+    "elif noise_level == 'n20':\n",
+    "    link = 'https://owncloud.mpi-cbg.de/index.php/s/7of6cBqyiecFBTj/download'\n",
+    "else:\n",
+    "    print('This noise level does not exist for this dataset.')\n",
+    "\n",
+    "# check if data has been downloaded already\n",
+    "zipPath=\"data/Mouse_{}.zip\".format(noise_level)\n",
+    "if not os.path.exists(zipPath):\n",
+    "    #download and unzip data\n",
+    "    data = urllib.request.urlretrieve(link, zipPath)\n",
+    "    with zipfile.ZipFile(zipPath, 'r') as zip_ref:\n",
+    "        zip_ref.extractall(\"data\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Loading of the training images\n",
+    "trainval_data =  np.load('data/Mouse_{}/train/train_data.npz'.format(noise_level))\n",
+    "train_images = trainval_data['X_train'].astype(np.float32)\n",
+    "train_masks = trainval_data['Y_train']\n",
+    "val_images = trainval_data['X_val'].astype(np.float32)\n",
+    "val_masks = trainval_data['Y_val']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f2132319fd0>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "test_data =  np.load('data/Mouse_{}/test/test_data.npz'.format(noise_level))\n",
+    "test_images = test_data['X_test'].astype(np.float32)\n",
+    "test_masks = test_data['Y_test']\n",
+    "plt.imshow(test_images[1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape of train_images: (908, 128, 128)\n",
+      "Shape of train_masks:  (908, 128, 128)\n",
+      "Shape of val_images:   (160, 128, 128)\n",
+      "Shape of val_masks:    (160, 128, 128)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Shape of train_images: {}\".format(train_images.shape))\n",
+    "print(\"Shape of train_masks:  {}\".format(train_masks.shape))\n",
+    "print(\"Shape of val_images:   {}\".format(val_images.shape))\n",
+    "print(\"Shape of val_masks:    {}\".format(val_masks.shape))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Small Amounts of Annotated Training Data\n",
+    "With DenoiSeg we present a solution to train deep neural networks if only few annotated ground truth segmentations are available. We simulate such a scenario by zeroing out all but a fraction of the available training data. In the next cell you can specify the percentage of training images for which ground truth annotations are available."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set the percentage of annotated training images.\n",
+    "# Values: 0.0 (no annotated images) to 100.0 (all images get annotations)\n",
+    "percentage_of_annotated_training_images = 0.5\n",
+    "assert percentage_of_annotated_training_images >= 0.0 and percentage_of_annotated_training_images <=100.0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Raw image size after augmentation (7264, 128, 128)\n",
+      "Mask size after augmentation (7264, 128, 128)\n",
+      "Shape of X:     (7264, 128, 128, 1)\n",
+      "Shape of Y:     (7264, 128, 128, 3)\n",
+      "Shape of X_val: (160, 128, 128, 1)\n",
+      "Shape of Y_val: (160, 128, 128, 3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Seed to shuffle training data (annotated GT and raw image pairs).\n",
+    "seed = 1 \n",
+    "\n",
+    "# First we shuffle the training images to remove any bias.\n",
+    "X_shuffled, Y_shuffled = shuffle_train_data(train_images, train_masks, random_seed=seed)\n",
+    "# Here we zero out all training images which are not part of the \n",
+    "# selected percentage.\n",
+    "X_frac, Y_frac = zero_out_train_data(X_shuffled, Y_shuffled, fraction = percentage_of_annotated_training_images)\n",
+    "\n",
+    "# Now we apply data augmentation to the training patches:\n",
+    "# Rotate four times by 90 degree and add flipped versions.\n",
+    "X, Y_train_masks = augment_data(X_frac, Y_frac)\n",
+    "X_val, Y_val_masks = val_images, val_masks\n",
+    "\n",
+    "# Here we add the channel dimension to our input images.\n",
+    "# Dimensionality for training has to be 'SYXC' (Sample, Y-Dimension, X-Dimension, Channel)\n",
+    "X = X[...,np.newaxis]\n",
+    "Y = convert_to_oneHot(Y_train_masks)\n",
+    "X_val = X_val[...,np.newaxis]\n",
+    "Y_val = convert_to_oneHot(Y_val_masks)\n",
+    "print(\"Shape of X:     {}\".format(X.shape))\n",
+    "print(\"Shape of Y:     {}\".format(Y.shape))\n",
+    "print(\"Shape of X_val: {}\".format(X_val.shape))\n",
+    "print(\"Shape of Y_val: {}\".format(Y_val.shape))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next we look at a single sample. In the first column we show the input image, in the second column the background segmentation, in the third column the foreground segmentation and in the last column the border segmentation.\n",
+    "\n",
+    "With the parameter `sample` you can choose different training patches. You will notice that not all of them have a segmentation ground truth."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x360 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sample = 0\n",
+    "plt.figure(figsize=(20,5))\n",
+    "plt.subplot(1,4,1)\n",
+    "plt.imshow(X[sample,...,0])\n",
+    "plt.axis('off')\n",
+    "plt.title('Raw validation image')\n",
+    "plt.subplot(1,4,2)\n",
+    "plt.imshow(Y[sample,...,0], vmin=0, vmax=1, interpolation='nearest')\n",
+    "plt.axis('off')\n",
+    "plt.title('1-hot encoded background')\n",
+    "plt.subplot(1,4,3)\n",
+    "plt.imshow(Y[sample,...,1], vmin=0, vmax=1, interpolation='nearest')\n",
+    "plt.axis('off')\n",
+    "plt.title('1-hot encoded foreground')\n",
+    "plt.subplot(1,4,4)\n",
+    "plt.imshow(Y[sample,...,2], vmin=0, vmax=1, interpolation='nearest')\n",
+    "plt.axis('off')\n",
+    "plt.title('1-hot encoded border');"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Configure network parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_batch_size = 128\n",
+    "train_steps_per_epoch = max(100, min(int(X.shape[0]/train_batch_size), 400))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### In the next cell, you can choose how much relative importance (weight) to assign to denoising \n",
+    "### and segmentation tasks by choosing appropriate value for denoiseg_alpha (between 0 and 1; with 0 being\n",
+    "### only segmentation and 1 being only denoising. Here we choose denoiseg_alpha = 0.5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'means': ['23.04147'],\n",
+       " 'stds': ['38.51743'],\n",
+       " 'n_dim': 2,\n",
+       " 'axes': 'YXC',\n",
+       " 'n_channel_in': 1,\n",
+       " 'n_channel_out': 4,\n",
+       " 'train_loss': 'denoiseg',\n",
+       " 'unet_n_depth': 4,\n",
+       " 'relative_weights': [1.0, 1.0, 5.0],\n",
+       " 'unet_kern_size': 3,\n",
+       " 'unet_n_first': 32,\n",
+       " 'unet_last_activation': 'linear',\n",
+       " 'probabilistic': False,\n",
+       " 'unet_residual': False,\n",
+       " 'unet_input_shape': (None, None, 1),\n",
+       " 'train_epochs': 200,\n",
+       " 'train_steps_per_epoch': 100,\n",
+       " 'train_learning_rate': 0.0004,\n",
+       " 'train_batch_size': 128,\n",
+       " 'train_tensorboard': False,\n",
+       " 'train_checkpoint': 'weights_best.h5',\n",
+       " 'train_checkpoint_last': 'weights_last.h5',\n",
+       " 'train_checkpoint_epoch': 'weights_now.h5',\n",
+       " 'train_reduce_lr': {'monitor': 'val_loss', 'factor': 0.5, 'patience': 10},\n",
+       " 'batch_norm': True,\n",
+       " 'n2v_perc_pix': 1.5,\n",
+       " 'n2v_patch_shape': (64, 64),\n",
+       " 'n2v_manipulator': 'uniform_withCP',\n",
+       " 'n2v_neighborhood_radius': 5,\n",
+       " 'denoiseg_alpha': 0.5}"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conf = DenoiSegConfig(X, unet_kern_size=3, n_channel_out=4, relative_weights = [1.0,1.0,5.0],\n",
+    "                      train_steps_per_epoch=train_steps_per_epoch, train_epochs=200, \n",
+    "                      batch_norm=True, train_batch_size=128, unet_n_first = 32, \n",
+    "                      unet_n_depth=4, denoiseg_alpha=0.5, train_tensorboard=False)\n",
+    "\n",
+    "vars(conf)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/Desktop/GitClones/DenoiSeg/denoiseg/models/denoiseg_standard.py:463: UserWarning: output path for model already exists, files may be overwritten: /home/prakash/Desktop/GitClones/DenoiSeg/examples/DenoiSeg_2D/models/DenoiSeg_Mouse_n10\n",
+      "  'output path for model already exists, files may be overwritten: %s' % str(self.logdir.resolve()))\n"
+     ]
+    }
+   ],
+   "source": [
+    "model_name = 'DenoiSeg_Mouse_n10'\n",
+    "basedir = 'models'\n",
+    "model = DenoiSeg(conf, model_name, basedir)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/Desktop/GitClones/DenoiSeg/denoiseg/models/denoiseg_standard.py:146: UserWarning: small number of validation images (only 2.15517% of all images)\n",
+      "  warnings.warn(\"small number of validation images (only %.05f%% of all images)\" % (100 * frac_val))\n",
+      "Preparing validation data:   2%|▎         | 4/160 [00:00<00:04, 34.62it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "61 blind-spots will be generated per training patch of size (64, 64).\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Preparing validation data: 100%|██████████| 160/160 [00:04<00:00, 33.49it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/200\n",
+      "100/100 [==============================] - 105s 1s/step - loss: 0.0842 - denoiseg: 0.0842 - seg_loss: 0.0031 - denoise_loss: 0.0812 - val_loss: 0.5333 - val_denoiseg: 0.5333 - val_seg_loss: 0.4701 - val_denoise_loss: 0.0632\n",
+      "Epoch 2/200\n",
+      "100/100 [==============================] - 104s 1s/step - loss: 0.0462 - denoiseg: 0.0462 - seg_loss: 0.0024 - denoise_loss: 0.0438 - val_loss: 0.4255 - val_denoiseg: 0.4255 - val_seg_loss: 0.3798 - val_denoise_loss: 0.0457\n",
+      "Epoch 3/200\n",
+      "100/100 [==============================] - 115s 1s/step - loss: 0.0440 - denoiseg: 0.0440 - seg_loss: 0.0019 - denoise_loss: 0.0420 - val_loss: 0.3798 - val_denoiseg: 0.3798 - val_seg_loss: 0.3372 - val_denoise_loss: 0.0426\n",
+      "Epoch 4/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0432 - denoiseg: 0.0432 - seg_loss: 0.0018 - denoise_loss: 0.0415 - val_loss: 0.3341 - val_denoiseg: 0.3341 - val_seg_loss: 0.2931 - val_denoise_loss: 0.0410\n",
+      "Epoch 5/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0426 - denoiseg: 0.0426 - seg_loss: 0.0017 - denoise_loss: 0.0409 - val_loss: 0.3099 - val_denoiseg: 0.3099 - val_seg_loss: 0.2669 - val_denoise_loss: 0.0430\n",
+      "Epoch 6/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0424 - denoiseg: 0.0424 - seg_loss: 0.0015 - denoise_loss: 0.0409 - val_loss: 0.2884 - val_denoiseg: 0.2884 - val_seg_loss: 0.2485 - val_denoise_loss: 0.0399\n",
+      "Epoch 7/200\n",
+      " 70/100 [====================>.........] - ETA: 29s - loss: 0.0418 - denoiseg: 0.0418 - seg_loss: 0.0016 - denoise_loss: 0.0402"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.128686). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 98s 983ms/step - loss: 0.0417 - denoiseg: 0.0417 - seg_loss: 0.0015 - denoise_loss: 0.0403 - val_loss: 0.2713 - val_denoiseg: 0.2713 - val_seg_loss: 0.2315 - val_denoise_loss: 0.0398\n",
+      "Epoch 8/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0411 - denoiseg: 0.0411 - seg_loss: 0.0014 - denoise_loss: 0.0397 - val_loss: 0.2632 - val_denoiseg: 0.2632 - val_seg_loss: 0.2235 - val_denoise_loss: 0.0397\n",
+      "Epoch 9/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0413 - denoiseg: 0.0413 - seg_loss: 0.0013 - denoise_loss: 0.0401 - val_loss: 0.2578 - val_denoiseg: 0.2578 - val_seg_loss: 0.2187 - val_denoise_loss: 0.0392\n",
+      "Epoch 10/200\n",
+      "  2/100 [..............................] - ETA: 17s - loss: 0.0437 - denoiseg: 0.0437 - seg_loss: 0.0046 - denoise_loss: 0.0391"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.121754). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  6/100 [>.............................] - ETA: 1:00 - loss: 0.0431 - denoiseg: 0.0431 - seg_loss: 0.0027 - denoise_loss: 0.0404"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.109068). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0413 - denoiseg: 0.0413 - seg_loss: 0.0013 - denoise_loss: 0.0400 - val_loss: 0.2427 - val_denoiseg: 0.2427 - val_seg_loss: 0.2023 - val_denoise_loss: 0.0405\n",
+      "Epoch 11/200\n",
+      "100/100 [==============================] - 115s 1s/step - loss: 0.0412 - denoiseg: 0.0412 - seg_loss: 0.0013 - denoise_loss: 0.0399 - val_loss: 0.2420 - val_denoiseg: 0.2420 - val_seg_loss: 0.2013 - val_denoise_loss: 0.0407\n",
+      "Epoch 12/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0408 - denoiseg: 0.0408 - seg_loss: 0.0011 - denoise_loss: 0.0397 - val_loss: 0.2468 - val_denoiseg: 0.2468 - val_seg_loss: 0.2082 - val_denoise_loss: 0.0386\n",
+      "Epoch 13/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0405 - denoiseg: 0.0405 - seg_loss: 0.0010 - denoise_loss: 0.0395 - val_loss: 0.2367 - val_denoiseg: 0.2367 - val_seg_loss: 0.1973 - val_denoise_loss: 0.0394\n",
+      "Epoch 14/200\n",
+      "  5/100 [>.............................] - ETA: 55s - loss: 0.0397 - denoiseg: 0.0397 - seg_loss: 0.0010 - denoise_loss: 0.0387    "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.127963). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0406 - denoiseg: 0.0406 - seg_loss: 0.0011 - denoise_loss: 0.0395 - val_loss: 0.2178 - val_denoiseg: 0.2178 - val_seg_loss: 0.1785 - val_denoise_loss: 0.0393\n",
+      "Epoch 15/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0405 - denoiseg: 0.0405 - seg_loss: 0.0010 - denoise_loss: 0.0394 - val_loss: 0.2065 - val_denoiseg: 0.2065 - val_seg_loss: 0.1684 - val_denoise_loss: 0.0381\n",
+      "Epoch 16/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0403 - denoiseg: 0.0403 - seg_loss: 9.1701e-04 - denoise_loss: 0.0394 - val_loss: 0.2004 - val_denoiseg: 0.2004 - val_seg_loss: 0.1619 - val_denoise_loss: 0.0385\n",
+      "Epoch 17/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0399 - denoiseg: 0.0399 - seg_loss: 9.7481e-04 - denoise_loss: 0.0389 - val_loss: 0.1924 - val_denoiseg: 0.1924 - val_seg_loss: 0.1543 - val_denoise_loss: 0.0381\n",
+      "Epoch 18/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0407 - denoiseg: 0.0407 - seg_loss: 0.0010 - denoise_loss: 0.0397 - val_loss: 0.1927 - val_denoiseg: 0.1927 - val_seg_loss: 0.1527 - val_denoise_loss: 0.0400\n",
+      "Epoch 19/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0400 - denoiseg: 0.0400 - seg_loss: 8.4304e-04 - denoise_loss: 0.0392 - val_loss: 0.1859 - val_denoiseg: 0.1859 - val_seg_loss: 0.1477 - val_denoise_loss: 0.0381\n",
+      "Epoch 20/200\n",
+      "  2/100 [..............................] - ETA: 39s - loss: 0.0391 - denoiseg: 0.0391 - seg_loss: 0.0015 - denoise_loss: 0.0376"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.186782). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0398 - denoiseg: 0.0398 - seg_loss: 8.1002e-04 - denoise_loss: 0.0390 - val_loss: 0.1899 - val_denoiseg: 0.1899 - val_seg_loss: 0.1519 - val_denoise_loss: 0.0380\n",
+      "Epoch 21/200\n",
+      " 35/100 [=========>....................] - ETA: 1:10 - loss: 0.0400 - denoiseg: 0.0400 - seg_loss: 9.8046e-04 - denoise_loss: 0.0390"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.111689). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0400 - denoiseg: 0.0400 - seg_loss: 8.8576e-04 - denoise_loss: 0.0391 - val_loss: 0.1854 - val_denoiseg: 0.1854 - val_seg_loss: 0.1476 - val_denoise_loss: 0.0378\n",
+      "Epoch 22/200\n",
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0398 - denoiseg: 0.0398 - seg_loss: 8.2183e-04 - denoise_loss: 0.0390 - val_loss: 0.1886 - val_denoiseg: 0.1886 - val_seg_loss: 0.1489 - val_denoise_loss: 0.0397\n",
+      "Epoch 23/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0401 - denoiseg: 0.0401 - seg_loss: 7.9662e-04 - denoise_loss: 0.0393 - val_loss: 0.1798 - val_denoiseg: 0.1798 - val_seg_loss: 0.1418 - val_denoise_loss: 0.0380\n",
+      "Epoch 24/200\n",
+      "  1/100 [..............................] - ETA: 9s - loss: 0.0420 - denoiseg: 0.0420 - seg_loss: 0.0027 - denoise_loss: 0.0393"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.195886). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  2/100 [..............................] - ETA: 51s - loss: 0.0403 - denoiseg: 0.0403 - seg_loss: 0.0014 - denoise_loss: 0.0390"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.145029). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0406 - denoiseg: 0.0406 - seg_loss: 8.6420e-04 - denoise_loss: 0.0397 - val_loss: 0.1912 - val_denoiseg: 0.1912 - val_seg_loss: 0.1517 - val_denoise_loss: 0.0395\n",
+      "Epoch 25/200\n",
+      " 80/100 [=======================>......] - ETA: 21s - loss: 0.0402 - denoiseg: 0.0402 - seg_loss: 8.1434e-04 - denoise_loss: 0.0394"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.103940). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 104s 1s/step - loss: 0.0402 - denoiseg: 0.0402 - seg_loss: 8.0322e-04 - denoise_loss: 0.0394 - val_loss: 0.1856 - val_denoiseg: 0.1856 - val_seg_loss: 0.1471 - val_denoise_loss: 0.0386\n",
+      "Epoch 26/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0397 - denoiseg: 0.0397 - seg_loss: 9.0862e-04 - denoise_loss: 0.0388 - val_loss: 0.1853 - val_denoiseg: 0.1853 - val_seg_loss: 0.1467 - val_denoise_loss: 0.0387\n",
+      "Epoch 27/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0395 - denoiseg: 0.0395 - seg_loss: 7.3724e-04 - denoise_loss: 0.0388 - val_loss: 0.1798 - val_denoiseg: 0.1798 - val_seg_loss: 0.1420 - val_denoise_loss: 0.0378\n",
+      "Epoch 28/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0396 - denoiseg: 0.0396 - seg_loss: 7.2604e-04 - denoise_loss: 0.0389 - val_loss: 0.2032 - val_denoiseg: 0.2032 - val_seg_loss: 0.1646 - val_denoise_loss: 0.0386\n",
+      "Epoch 29/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0398 - denoiseg: 0.0398 - seg_loss: 8.1202e-04 - denoise_loss: 0.0390 - val_loss: 0.1812 - val_denoiseg: 0.1812 - val_seg_loss: 0.1433 - val_denoise_loss: 0.0379\n",
+      "Epoch 30/200\n",
+      "100/100 [==============================] - 116s 1s/step - loss: 0.0398 - denoiseg: 0.0398 - seg_loss: 7.2810e-04 - denoise_loss: 0.0390 - val_loss: 0.1811 - val_denoiseg: 0.1811 - val_seg_loss: 0.1434 - val_denoise_loss: 0.0377\n",
+      "Epoch 31/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0397 - denoiseg: 0.0397 - seg_loss: 7.7227e-04 - denoise_loss: 0.0389 - val_loss: 0.1992 - val_denoiseg: 0.1992 - val_seg_loss: 0.1609 - val_denoise_loss: 0.0383\n",
+      "Epoch 32/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0400 - denoiseg: 0.0400 - seg_loss: 7.4919e-04 - denoise_loss: 0.0392 - val_loss: 0.1826 - val_denoiseg: 0.1826 - val_seg_loss: 0.1443 - val_denoise_loss: 0.0382\n",
+      "Epoch 33/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0394 - denoiseg: 0.0394 - seg_loss: 7.2008e-04 - denoise_loss: 0.0387 - val_loss: 0.1728 - val_denoiseg: 0.1728 - val_seg_loss: 0.1351 - val_denoise_loss: 0.0377\n",
+      "Epoch 34/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0394 - denoiseg: 0.0394 - seg_loss: 7.7360e-04 - denoise_loss: 0.0387 - val_loss: 0.1844 - val_denoiseg: 0.1844 - val_seg_loss: 0.1458 - val_denoise_loss: 0.0386\n",
+      "Epoch 35/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0401 - denoiseg: 0.0401 - seg_loss: 7.5204e-04 - denoise_loss: 0.0393 - val_loss: 0.1747 - val_denoiseg: 0.1747 - val_seg_loss: 0.1370 - val_denoise_loss: 0.0377\n",
+      "Epoch 36/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0394 - denoiseg: 0.0394 - seg_loss: 7.3053e-04 - denoise_loss: 0.0387 - val_loss: 0.1771 - val_denoiseg: 0.1771 - val_seg_loss: 0.1392 - val_denoise_loss: 0.0380\n",
+      "Epoch 37/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0395 - denoiseg: 0.0395 - seg_loss: 6.6494e-04 - denoise_loss: 0.0389 - val_loss: 0.1931 - val_denoiseg: 0.1931 - val_seg_loss: 0.1549 - val_denoise_loss: 0.0382\n",
+      "Epoch 38/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0392 - denoiseg: 0.0392 - seg_loss: 6.7771e-04 - denoise_loss: 0.0385 - val_loss: 0.1903 - val_denoiseg: 0.1903 - val_seg_loss: 0.1513 - val_denoise_loss: 0.0390\n",
+      "Epoch 39/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0394 - denoiseg: 0.0394 - seg_loss: 6.5484e-04 - denoise_loss: 0.0388 - val_loss: 0.1781 - val_denoiseg: 0.1781 - val_seg_loss: 0.1400 - val_denoise_loss: 0.0381\n",
+      "Epoch 40/200\n",
+      "100/100 [==============================] - 116s 1s/step - loss: 0.0393 - denoiseg: 0.0393 - seg_loss: 7.9597e-04 - denoise_loss: 0.0385 - val_loss: 0.1788 - val_denoiseg: 0.1788 - val_seg_loss: 0.1404 - val_denoise_loss: 0.0383\n",
+      "Epoch 41/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0396 - denoiseg: 0.0396 - seg_loss: 6.4702e-04 - denoise_loss: 0.0390 - val_loss: 0.2148 - val_denoiseg: 0.2148 - val_seg_loss: 0.1765 - val_denoise_loss: 0.0383\n",
+      "Epoch 42/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0396 - denoiseg: 0.0396 - seg_loss: 7.8996e-04 - denoise_loss: 0.0388 - val_loss: 0.1862 - val_denoiseg: 0.1862 - val_seg_loss: 0.1473 - val_denoise_loss: 0.0389\n",
+      "Epoch 43/200\n",
+      "  2/100 [..............................] - ETA: 22s - loss: 0.0409 - denoiseg: 0.0409 - seg_loss: 0.0000e+00 - denoise_loss: 0.0409"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.237822). Check your callbacks.\n",
+      "  % delta_t_median)\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.136202). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 20/100 [=====>........................] - ETA: 1:06 - loss: 0.0399 - denoiseg: 0.0399 - seg_loss: 5.5793e-04 - denoise_loss: 0.0393 ETA: 1:07 - loss: 0.0399 - denoiseg: 0.0399 - seg_loss: 6.5468e-04 - de"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.118374). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 103s 1s/step - loss: 0.0396 - denoiseg: 0.0396 - seg_loss: 6.3881e-04 - denoise_loss: 0.0389 - val_loss: 0.1695 - val_denoiseg: 0.1695 - val_seg_loss: 0.1318 - val_denoise_loss: 0.0377\n",
+      "Epoch 44/200\n",
+      "100/100 [==============================] - 105s 1s/step - loss: 0.0392 - denoiseg: 0.0392 - seg_loss: 6.9324e-04 - denoise_loss: 0.0385 - val_loss: 0.2007 - val_denoiseg: 0.2007 - val_seg_loss: 0.1625 - val_denoise_loss: 0.0382\n",
+      "Epoch 45/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0394 - denoiseg: 0.0394 - seg_loss: 6.5976e-04 - denoise_loss: 0.0387 - val_loss: 0.1941 - val_denoiseg: 0.1941 - val_seg_loss: 0.1564 - val_denoise_loss: 0.0378\n",
+      "Epoch 46/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0391 - denoiseg: 0.0391 - seg_loss: 6.2250e-04 - denoise_loss: 0.0385 - val_loss: 0.1838 - val_denoiseg: 0.1838 - val_seg_loss: 0.1458 - val_denoise_loss: 0.0380\n",
+      "Epoch 47/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0395 - denoiseg: 0.0395 - seg_loss: 7.1112e-04 - denoise_loss: 0.0388 - val_loss: 0.1792 - val_denoiseg: 0.1792 - val_seg_loss: 0.1416 - val_denoise_loss: 0.0376\n",
+      "Epoch 48/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0394 - denoiseg: 0.0394 - seg_loss: 6.6107e-04 - denoise_loss: 0.0387 - val_loss: 0.1852 - val_denoiseg: 0.1852 - val_seg_loss: 0.1475 - val_denoise_loss: 0.0376\n",
+      "Epoch 49/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0392 - denoiseg: 0.0392 - seg_loss: 6.4462e-04 - denoise_loss: 0.0386 - val_loss: 0.2006 - val_denoiseg: 0.2006 - val_seg_loss: 0.1618 - val_denoise_loss: 0.0388\n",
+      "Epoch 50/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0393 - denoiseg: 0.0393 - seg_loss: 7.1023e-04 - denoise_loss: 0.0386 - val_loss: 0.1851 - val_denoiseg: 0.1851 - val_seg_loss: 0.1468 - val_denoise_loss: 0.0383\n",
+      "Epoch 51/200\n",
+      "100/100 [==============================] - 117s 1s/step - loss: 0.0394 - denoiseg: 0.0394 - seg_loss: 6.0496e-04 - denoise_loss: 0.0388 - val_loss: 0.1835 - val_denoiseg: 0.1835 - val_seg_loss: 0.1445 - val_denoise_loss: 0.0390\n",
+      "Epoch 52/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0395 - denoiseg: 0.0395 - seg_loss: 7.1535e-04 - denoise_loss: 0.0388 - val_loss: 0.1885 - val_denoiseg: 0.1885 - val_seg_loss: 0.1506 - val_denoise_loss: 0.0379\n",
+      "Epoch 53/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0393 - denoiseg: 0.0393 - seg_loss: 6.0738e-04 - denoise_loss: 0.0387 - val_loss: 0.1755 - val_denoiseg: 0.1755 - val_seg_loss: 0.1381 - val_denoise_loss: 0.0374\n",
+      "\n",
+      "Epoch 00053: ReduceLROnPlateau reducing learning rate to 0.00019999999494757503.\n",
+      "Epoch 54/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0392 - denoiseg: 0.0392 - seg_loss: 5.9973e-04 - denoise_loss: 0.0386 - val_loss: 0.1825 - val_denoiseg: 0.1825 - val_seg_loss: 0.1449 - val_denoise_loss: 0.0375\n",
+      "Epoch 55/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0386 - denoiseg: 0.0386 - seg_loss: 6.3541e-04 - denoise_loss: 0.0379 - val_loss: 0.1686 - val_denoiseg: 0.1686 - val_seg_loss: 0.1312 - val_denoise_loss: 0.0374\n",
+      "Epoch 56/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0390 - denoiseg: 0.0390 - seg_loss: 6.3211e-04 - denoise_loss: 0.0384 - val_loss: 0.1728 - val_denoiseg: 0.1728 - val_seg_loss: 0.1351 - val_denoise_loss: 0.0376\n",
+      "Epoch 57/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0388 - denoiseg: 0.0388 - seg_loss: 6.1722e-04 - denoise_loss: 0.0382 - val_loss: 0.1818 - val_denoiseg: 0.1818 - val_seg_loss: 0.1443 - val_denoise_loss: 0.0375\n",
+      "Epoch 58/200\n",
+      " 61/100 [=================>............] - ETA: 39s - loss: 0.0389 - denoiseg: 0.0389 - seg_loss: 6.5753e-04 - denoise_loss: 0.0383"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.103743). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 101s 1s/step - loss: 0.0388 - denoiseg: 0.0388 - seg_loss: 5.9910e-04 - denoise_loss: 0.0382 - val_loss: 0.1767 - val_denoiseg: 0.1767 - val_seg_loss: 0.1389 - val_denoise_loss: 0.0378\n",
+      "Epoch 59/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0388 - denoiseg: 0.0388 - seg_loss: 5.9916e-04 - denoise_loss: 0.0382 - val_loss: 0.1935 - val_denoiseg: 0.1935 - val_seg_loss: 0.1557 - val_denoise_loss: 0.0378\n",
+      "Epoch 60/200\n",
+      "100/100 [==============================] - 115s 1s/step - loss: 0.0389 - denoiseg: 0.0389 - seg_loss: 5.6787e-04 - denoise_loss: 0.0384 - val_loss: 0.1758 - val_denoiseg: 0.1758 - val_seg_loss: 0.1378 - val_denoise_loss: 0.0380\n",
+      "Epoch 61/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0391 - denoiseg: 0.0391 - seg_loss: 6.9757e-04 - denoise_loss: 0.0384 - val_loss: 0.1775 - val_denoiseg: 0.1775 - val_seg_loss: 0.1400 - val_denoise_loss: 0.0375\n",
+      "Epoch 62/200\n",
+      " 44/100 [============>.................] - ETA: 51s - loss: 0.0390 - denoiseg: 0.0390 - seg_loss: 6.1584e-04 - denoise_loss: 0.0383"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.112769). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 46/100 [============>.................] - ETA: 49s - loss: 0.0390 - denoiseg: 0.0390 - seg_loss: 6.1027e-04 - denoise_loss: 0.0384"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.119924). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 47/100 [=============>................] - ETA: 49s - loss: 0.0390 - denoiseg: 0.0390 - seg_loss: 6.1745e-04 - denoise_loss: 0.0384"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.125192). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 50/100 [==============>...............] - ETA: 46s - loss: 0.0390 - denoiseg: 0.0390 - seg_loss: 6.0583e-04 - denoise_loss: 0.0384"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.115045). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 51/100 [==============>...............] - ETA: 45s - loss: 0.0389 - denoiseg: 0.0389 - seg_loss: 5.9395e-04 - denoise_loss: 0.0383"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.112193). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 73/100 [====================>.........] - ETA: 25s - loss: 0.0388 - denoiseg: 0.0388 - seg_loss: 6.0066e-04 - denoise_loss: 0.0382"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.120199). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/100 [=====================>........] - ETA: 23s - loss: 0.0388 - denoiseg: 0.0388 - seg_loss: 5.8464e-04 - denoise_loss: 0.0382"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.109594). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 81/100 [=======================>......] - ETA: 17s - loss: 0.0388 - denoiseg: 0.0388 - seg_loss: 5.7986e-04 - denoise_loss: 0.0382"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.124296). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 82/100 [=======================>......] - ETA: 16s - loss: 0.0388 - denoiseg: 0.0388 - seg_loss: 5.7646e-04 - denoise_loss: 0.0382"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.127130). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 92s 924ms/step - loss: 0.0388 - denoiseg: 0.0388 - seg_loss: 5.7500e-04 - denoise_loss: 0.0382 - val_loss: 0.1776 - val_denoiseg: 0.1776 - val_seg_loss: 0.1402 - val_denoise_loss: 0.0373\n",
+      "Epoch 63/200\n",
+      "  3/100 [..............................] - ETA: 1:01 - loss: 0.0373 - denoiseg: 0.0373 - seg_loss: 7.1678e-04 - denoise_loss: 0.0366"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.138898). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/100 [====>.........................] - ETA: 1:10 - loss: 0.0387 - denoiseg: 0.0387 - seg_loss: 6.7186e-04 - denoise_loss: 0.0380"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.105315). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 22/100 [=====>........................] - ETA: 1:07 - loss: 0.0388 - denoiseg: 0.0388 - seg_loss: 6.2141e-04 - denoise_loss: 0.0382"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.118810). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 25/100 [======>.......................] - ETA: 1:05 - loss: 0.0390 - denoiseg: 0.0390 - seg_loss: 6.0356e-04 - denoise_loss: 0.0383"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.123946). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 28/100 [=======>......................] - ETA: 1:02 - loss: 0.0389 - denoiseg: 0.0389 - seg_loss: 5.8073e-04 - denoise_loss: 0.0383"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.110996). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 29/100 [=======>......................] - ETA: 1:02 - loss: 0.0389 - denoiseg: 0.0389 - seg_loss: 6.1075e-04 - denoise_loss: 0.0383"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.149863). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 45/100 [============>.................] - ETA: 48s - loss: 0.0389 - denoiseg: 0.0389 - seg_loss: 6.2123e-04 - denoise_loss: 0.0383"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.116760). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 48/100 [=============>................] - ETA: 45s - loss: 0.0389 - denoiseg: 0.0389 - seg_loss: 6.3179e-04 - denoise_loss: 0.0382"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.126241). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 50/100 [==============>...............] - ETA: 44s - loss: 0.0388 - denoiseg: 0.0388 - seg_loss: 6.2790e-04 - denoise_loss: 0.0382"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.123053). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 53/100 [==============>...............] - ETA: 41s - loss: 0.0388 - denoiseg: 0.0388 - seg_loss: 6.1084e-04 - denoise_loss: 0.0382"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.112514). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 94s 942ms/step - loss: 0.0388 - denoiseg: 0.0388 - seg_loss: 5.5248e-04 - denoise_loss: 0.0382 - val_loss: 0.1902 - val_denoiseg: 0.1902 - val_seg_loss: 0.1520 - val_denoise_loss: 0.0382\n",
+      "Epoch 64/200\n",
+      "100/100 [==============================] - 99s 991ms/step - loss: 0.0388 - denoiseg: 0.0388 - seg_loss: 6.5684e-04 - denoise_loss: 0.0381 - val_loss: 0.1792 - val_denoiseg: 0.1792 - val_seg_loss: 0.1417 - val_denoise_loss: 0.0374\n",
+      "Epoch 65/200\n",
+      "100/100 [==============================] - 103s 1s/step - loss: 0.0391 - denoiseg: 0.0391 - seg_loss: 5.9275e-04 - denoise_loss: 0.0385 - val_loss: 0.1796 - val_denoiseg: 0.1796 - val_seg_loss: 0.1416 - val_denoise_loss: 0.0380\n",
+      "\n",
+      "Epoch 00065: ReduceLROnPlateau reducing learning rate to 9.999999747378752e-05.\n",
+      "Epoch 66/200\n",
+      "100/100 [==============================] - 99s 985ms/step - loss: 0.0388 - denoiseg: 0.0388 - seg_loss: 6.6950e-04 - denoise_loss: 0.0381 - val_loss: 0.1797 - val_denoiseg: 0.1797 - val_seg_loss: 0.1423 - val_denoise_loss: 0.0374\n",
+      "Epoch 67/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0389 - denoiseg: 0.0389 - seg_loss: 5.9473e-04 - denoise_loss: 0.0383 - val_loss: 0.1811 - val_denoiseg: 0.1811 - val_seg_loss: 0.1437 - val_denoise_loss: 0.0374\n",
+      "Epoch 68/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0384 - denoiseg: 0.0384 - seg_loss: 6.0331e-04 - denoise_loss: 0.0378 - val_loss: 0.1721 - val_denoiseg: 0.1721 - val_seg_loss: 0.1349 - val_denoise_loss: 0.0373\n",
+      "Epoch 69/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0389 - denoiseg: 0.0389 - seg_loss: 5.5657e-04 - denoise_loss: 0.0383 - val_loss: 0.1834 - val_denoiseg: 0.1834 - val_seg_loss: 0.1461 - val_denoise_loss: 0.0373\n",
+      "Epoch 70/200\n",
+      "100/100 [==============================] - 104s 1s/step - loss: 0.0385 - denoiseg: 0.0385 - seg_loss: 6.0142e-04 - denoise_loss: 0.0379 - val_loss: 0.1754 - val_denoiseg: 0.1754 - val_seg_loss: 0.1380 - val_denoise_loss: 0.0374\n",
+      "Epoch 71/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0387 - denoiseg: 0.0387 - seg_loss: 5.7698e-04 - denoise_loss: 0.0381 - val_loss: 0.1768 - val_denoiseg: 0.1768 - val_seg_loss: 0.1392 - val_denoise_loss: 0.0377\n",
+      "Epoch 72/200\n",
+      "100/100 [==============================] - 115s 1s/step - loss: 0.0385 - denoiseg: 0.0385 - seg_loss: 5.5280e-04 - denoise_loss: 0.0379 - val_loss: 0.1786 - val_denoiseg: 0.1786 - val_seg_loss: 0.1412 - val_denoise_loss: 0.0374\n",
+      "Epoch 73/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0387 - denoiseg: 0.0387 - seg_loss: 5.8047e-04 - denoise_loss: 0.0381 - val_loss: 0.1786 - val_denoiseg: 0.1786 - val_seg_loss: 0.1412 - val_denoise_loss: 0.0375\n",
+      "Epoch 74/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0388 - denoiseg: 0.0388 - seg_loss: 5.9944e-04 - denoise_loss: 0.0382 - val_loss: 0.1850 - val_denoiseg: 0.1850 - val_seg_loss: 0.1476 - val_denoise_loss: 0.0375\n",
+      "Epoch 75/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0384 - denoiseg: 0.0384 - seg_loss: 6.0142e-04 - denoise_loss: 0.0378 - val_loss: 0.1729 - val_denoiseg: 0.1729 - val_seg_loss: 0.1357 - val_denoise_loss: 0.0373\n",
+      "\n",
+      "Epoch 00075: ReduceLROnPlateau reducing learning rate to 4.999999873689376e-05.\n",
+      "Epoch 76/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0384 - denoiseg: 0.0384 - seg_loss: 5.2643e-04 - denoise_loss: 0.0379 - val_loss: 0.1754 - val_denoiseg: 0.1754 - val_seg_loss: 0.1382 - val_denoise_loss: 0.0373\n",
+      "Epoch 77/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0386 - denoiseg: 0.0386 - seg_loss: 4.8746e-04 - denoise_loss: 0.0381 - val_loss: 0.1812 - val_denoiseg: 0.1812 - val_seg_loss: 0.1439 - val_denoise_loss: 0.0373\n",
+      "Epoch 78/200\n",
+      "100/100 [==============================] - 116s 1s/step - loss: 0.0385 - denoiseg: 0.0385 - seg_loss: 5.3100e-04 - denoise_loss: 0.0380 - val_loss: 0.1789 - val_denoiseg: 0.1789 - val_seg_loss: 0.1416 - val_denoise_loss: 0.0373\n",
+      "Epoch 79/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0383 - denoiseg: 0.0383 - seg_loss: 5.5087e-04 - denoise_loss: 0.0377 - val_loss: 0.1819 - val_denoiseg: 0.1819 - val_seg_loss: 0.1446 - val_denoise_loss: 0.0373\n",
+      "Epoch 80/200\n",
+      "100/100 [==============================] - 105s 1s/step - loss: 0.0384 - denoiseg: 0.0384 - seg_loss: 5.1797e-04 - denoise_loss: 0.0378 - val_loss: 0.1779 - val_denoiseg: 0.1779 - val_seg_loss: 0.1407 - val_denoise_loss: 0.0372\n",
+      "Epoch 81/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0384 - denoiseg: 0.0384 - seg_loss: 5.6744e-04 - denoise_loss: 0.0378 - val_loss: 0.1776 - val_denoiseg: 0.1776 - val_seg_loss: 0.1404 - val_denoise_loss: 0.0372\n",
+      "Epoch 82/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0384 - denoiseg: 0.0384 - seg_loss: 5.2352e-04 - denoise_loss: 0.0379 - val_loss: 0.1795 - val_denoiseg: 0.1795 - val_seg_loss: 0.1421 - val_denoise_loss: 0.0375\n",
+      "Epoch 83/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0383 - denoiseg: 0.0383 - seg_loss: 5.1883e-04 - denoise_loss: 0.0378 - val_loss: 0.1869 - val_denoiseg: 0.1869 - val_seg_loss: 0.1495 - val_denoise_loss: 0.0373\n",
+      "Epoch 84/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0384 - denoiseg: 0.0384 - seg_loss: 5.4813e-04 - denoise_loss: 0.0378 - val_loss: 0.1814 - val_denoiseg: 0.1814 - val_seg_loss: 0.1441 - val_denoise_loss: 0.0373\n",
+      "Epoch 85/200\n",
+      "100/100 [==============================] - 105s 1s/step - loss: 0.0384 - denoiseg: 0.0384 - seg_loss: 5.2097e-04 - denoise_loss: 0.0379 - val_loss: 0.1804 - val_denoiseg: 0.1804 - val_seg_loss: 0.1431 - val_denoise_loss: 0.0373\n",
+      "\n",
+      "Epoch 00085: ReduceLROnPlateau reducing learning rate to 2.499999936844688e-05.\n",
+      "Epoch 86/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0383 - denoiseg: 0.0383 - seg_loss: 5.4160e-04 - denoise_loss: 0.0378 - val_loss: 0.1770 - val_denoiseg: 0.1770 - val_seg_loss: 0.1397 - val_denoise_loss: 0.0373\n",
+      "Epoch 87/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0383 - denoiseg: 0.0383 - seg_loss: 4.7604e-04 - denoise_loss: 0.0378 - val_loss: 0.1807 - val_denoiseg: 0.1807 - val_seg_loss: 0.1434 - val_denoise_loss: 0.0373\n",
+      "Epoch 88/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0382 - denoiseg: 0.0382 - seg_loss: 5.4728e-04 - denoise_loss: 0.0377 - val_loss: 0.1846 - val_denoiseg: 0.1846 - val_seg_loss: 0.1473 - val_denoise_loss: 0.0373\n",
+      "Epoch 89/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0384 - denoiseg: 0.0384 - seg_loss: 5.4666e-04 - denoise_loss: 0.0378 - val_loss: 0.1844 - val_denoiseg: 0.1844 - val_seg_loss: 0.1471 - val_denoise_loss: 0.0373\n",
+      "Epoch 90/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0384 - denoiseg: 0.0384 - seg_loss: 5.6204e-04 - denoise_loss: 0.0378 - val_loss: 0.1854 - val_denoiseg: 0.1854 - val_seg_loss: 0.1481 - val_denoise_loss: 0.0373\n",
+      "Epoch 91/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0385 - denoiseg: 0.0385 - seg_loss: 5.0177e-04 - denoise_loss: 0.0380 - val_loss: 0.1840 - val_denoiseg: 0.1840 - val_seg_loss: 0.1466 - val_denoise_loss: 0.0374\n",
+      "Epoch 92/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0383 - denoiseg: 0.0383 - seg_loss: 5.4829e-04 - denoise_loss: 0.0377 - val_loss: 0.1895 - val_denoiseg: 0.1895 - val_seg_loss: 0.1521 - val_denoise_loss: 0.0373\n",
+      "Epoch 93/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0385 - denoiseg: 0.0385 - seg_loss: 5.8097e-04 - denoise_loss: 0.0379 - val_loss: 0.1877 - val_denoiseg: 0.1877 - val_seg_loss: 0.1503 - val_denoise_loss: 0.0374\n",
+      "Epoch 94/200\n",
+      " 76/100 [=====================>........] - ETA: 25s - loss: 0.0381 - denoiseg: 0.0381 - seg_loss: 5.2138e-04 - denoise_loss: 0.0376"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.143358). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 101s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 4.9159e-04 - denoise_loss: 0.0375 - val_loss: 0.1848 - val_denoiseg: 0.1848 - val_seg_loss: 0.1476 - val_denoise_loss: 0.0373\n",
+      "Epoch 95/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0381 - denoiseg: 0.0381 - seg_loss: 4.8101e-04 - denoise_loss: 0.0376 - val_loss: 0.1885 - val_denoiseg: 0.1885 - val_seg_loss: 0.1511 - val_denoise_loss: 0.0373\n",
+      "\n",
+      "Epoch 00095: ReduceLROnPlateau reducing learning rate to 1.249999968422344e-05.\n",
+      "Epoch 96/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0383 - denoiseg: 0.0383 - seg_loss: 5.5325e-04 - denoise_loss: 0.0378 - val_loss: 0.1830 - val_denoiseg: 0.1830 - val_seg_loss: 0.1457 - val_denoise_loss: 0.0373\n",
+      "Epoch 97/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 4.9240e-04 - denoise_loss: 0.0375 - val_loss: 0.1857 - val_denoiseg: 0.1857 - val_seg_loss: 0.1484 - val_denoise_loss: 0.0373\n",
+      "Epoch 98/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.6211e-04 - denoise_loss: 0.0374 - val_loss: 0.1861 - val_denoiseg: 0.1861 - val_seg_loss: 0.1488 - val_denoise_loss: 0.0373\n",
+      "Epoch 99/200\n",
+      "  1/100 [..............................] - ETA: 20s - loss: 0.0378 - denoiseg: 0.0378 - seg_loss: 0.0000e+00 - denoise_loss: 0.0378"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.137108). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0383 - denoiseg: 0.0383 - seg_loss: 5.4146e-04 - denoise_loss: 0.0378 - val_loss: 0.1842 - val_denoiseg: 0.1842 - val_seg_loss: 0.1469 - val_denoise_loss: 0.0373\n",
+      "Epoch 100/200\n",
+      "  1/100 [..............................] - ETA: 10s - loss: 0.0388 - denoiseg: 0.0388 - seg_loss: 6.0514e-04 - denoise_loss: 0.0382"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.147025). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0381 - denoiseg: 0.0381 - seg_loss: 5.2206e-04 - denoise_loss: 0.0376 - val_loss: 0.1870 - val_denoiseg: 0.1870 - val_seg_loss: 0.1497 - val_denoise_loss: 0.0373\n",
+      "Epoch 101/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0381 - denoiseg: 0.0381 - seg_loss: 5.0998e-04 - denoise_loss: 0.0376 - val_loss: 0.1881 - val_denoiseg: 0.1881 - val_seg_loss: 0.1508 - val_denoise_loss: 0.0373\n",
+      "Epoch 102/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0381 - denoiseg: 0.0381 - seg_loss: 5.4236e-04 - denoise_loss: 0.0376 - val_loss: 0.1893 - val_denoiseg: 0.1893 - val_seg_loss: 0.1520 - val_denoise_loss: 0.0373\n",
+      "Epoch 103/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 4.8812e-04 - denoise_loss: 0.0375 - val_loss: 0.1871 - val_denoiseg: 0.1871 - val_seg_loss: 0.1499 - val_denoise_loss: 0.0373\n",
+      "Epoch 104/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0381 - denoiseg: 0.0381 - seg_loss: 5.2696e-04 - denoise_loss: 0.0376 - val_loss: 0.1896 - val_denoiseg: 0.1896 - val_seg_loss: 0.1523 - val_denoise_loss: 0.0373\n",
+      "Epoch 105/200\n",
+      "100/100 [==============================] - 102s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.8690e-04 - denoise_loss: 0.0374 - val_loss: 0.1867 - val_denoiseg: 0.1867 - val_seg_loss: 0.1494 - val_denoise_loss: 0.0373\n",
+      "\n",
+      "Epoch 00105: ReduceLROnPlateau reducing learning rate to 6.24999984211172e-06.\n",
+      "Epoch 106/200\n",
+      "  1/100 [..............................] - ETA: 10s - loss: 0.0376 - denoiseg: 0.0376 - seg_loss: 0.0000e+00 - denoise_loss: 0.0376"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.293894). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  2/100 [..............................] - ETA: 49s - loss: 0.0383 - denoiseg: 0.0383 - seg_loss: 5.5408e-04 - denoise_loss: 0.0377"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.249197). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  3/100 [..............................] - ETA: 1:05 - loss: 0.0384 - denoiseg: 0.0384 - seg_loss: 3.6939e-04 - denoise_loss: 0.0380"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.204500). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  4/100 [>.............................] - ETA: 1:13 - loss: 0.0382 - denoiseg: 0.0382 - seg_loss: 3.7886e-04 - denoise_loss: 0.0378"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.135007). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.4753e-04 - denoise_loss: 0.0375 - val_loss: 0.1851 - val_denoiseg: 0.1851 - val_seg_loss: 0.1478 - val_denoise_loss: 0.0373\n",
+      "Epoch 107/200\n",
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0381 - denoiseg: 0.0381 - seg_loss: 5.1498e-04 - denoise_loss: 0.0376 - val_loss: 0.1907 - val_denoiseg: 0.1907 - val_seg_loss: 0.1535 - val_denoise_loss: 0.0373\n",
+      "Epoch 108/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.1486e-04 - denoise_loss: 0.0374 - val_loss: 0.1899 - val_denoiseg: 0.1899 - val_seg_loss: 0.1526 - val_denoise_loss: 0.0373\n",
+      "Epoch 109/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0381 - denoiseg: 0.0381 - seg_loss: 5.1527e-04 - denoise_loss: 0.0376 - val_loss: 0.1888 - val_denoiseg: 0.1888 - val_seg_loss: 0.1515 - val_denoise_loss: 0.0373\n",
+      "Epoch 110/200\n",
+      "100/100 [==============================] - 103s 1s/step - loss: 0.0381 - denoiseg: 0.0381 - seg_loss: 5.3775e-04 - denoise_loss: 0.0375 - val_loss: 0.1872 - val_denoiseg: 0.1872 - val_seg_loss: 0.1499 - val_denoise_loss: 0.0373\n",
+      "Epoch 111/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.2558e-04 - denoise_loss: 0.0375 - val_loss: 0.1919 - val_denoiseg: 0.1919 - val_seg_loss: 0.1546 - val_denoise_loss: 0.0373\n",
+      "Epoch 112/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0378 - denoiseg: 0.0378 - seg_loss: 4.4254e-04 - denoise_loss: 0.0373 - val_loss: 0.1895 - val_denoiseg: 0.1895 - val_seg_loss: 0.1522 - val_denoise_loss: 0.0373\n",
+      "Epoch 113/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0381 - denoiseg: 0.0381 - seg_loss: 5.4240e-04 - denoise_loss: 0.0376 - val_loss: 0.1917 - val_denoiseg: 0.1917 - val_seg_loss: 0.1544 - val_denoise_loss: 0.0373\n",
+      "Epoch 114/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.9212e-04 - denoise_loss: 0.0374 - val_loss: 0.1915 - val_denoiseg: 0.1915 - val_seg_loss: 0.1542 - val_denoise_loss: 0.0373\n",
+      "Epoch 115/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.3405e-04 - denoise_loss: 0.0374 - val_loss: 0.1890 - val_denoiseg: 0.1890 - val_seg_loss: 0.1517 - val_denoise_loss: 0.0373\n",
+      "\n",
+      "Epoch 00115: ReduceLROnPlateau reducing learning rate to 3.12499992105586e-06.\n",
+      "Epoch 116/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0381 - denoiseg: 0.0381 - seg_loss: 4.6706e-04 - denoise_loss: 0.0376 - val_loss: 0.1887 - val_denoiseg: 0.1887 - val_seg_loss: 0.1514 - val_denoise_loss: 0.0373\n",
+      "Epoch 117/200\n",
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.6857e-04 - denoise_loss: 0.0374 - val_loss: 0.1898 - val_denoiseg: 0.1898 - val_seg_loss: 0.1525 - val_denoise_loss: 0.0373\n",
+      "Epoch 118/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.9644e-04 - denoise_loss: 0.0374 - val_loss: 0.1905 - val_denoiseg: 0.1905 - val_seg_loss: 0.1533 - val_denoise_loss: 0.0373\n",
+      "Epoch 119/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.0439e-04 - denoise_loss: 0.0375 - val_loss: 0.1906 - val_denoiseg: 0.1906 - val_seg_loss: 0.1533 - val_denoise_loss: 0.0373\n",
+      "Epoch 120/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.6829e-04 - denoise_loss: 0.0375 - val_loss: 0.1897 - val_denoiseg: 0.1897 - val_seg_loss: 0.1524 - val_denoise_loss: 0.0373\n",
+      "Epoch 121/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.3584e-04 - denoise_loss: 0.0374 - val_loss: 0.1915 - val_denoiseg: 0.1915 - val_seg_loss: 0.1542 - val_denoise_loss: 0.0373\n",
+      "Epoch 122/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.7915e-04 - denoise_loss: 0.0374 - val_loss: 0.1923 - val_denoiseg: 0.1923 - val_seg_loss: 0.1550 - val_denoise_loss: 0.0373\n",
+      "Epoch 123/200\n",
+      " 60/100 [=================>............] - ETA: 45s - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.0835e-04 - denoise_loss: 0.0374"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.105372). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.8924e-04 - denoise_loss: 0.0375 - val_loss: 0.1929 - val_denoiseg: 0.1929 - val_seg_loss: 0.1556 - val_denoise_loss: 0.0373\n",
+      "Epoch 124/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.3957e-04 - denoise_loss: 0.0375 - val_loss: 0.1924 - val_denoiseg: 0.1924 - val_seg_loss: 0.1551 - val_denoise_loss: 0.0373\n",
+      "Epoch 125/200\n",
+      "100/100 [==============================] - 105s 1s/step - loss: 0.0378 - denoiseg: 0.0378 - seg_loss: 4.8364e-04 - denoise_loss: 0.0373 - val_loss: 0.1910 - val_denoiseg: 0.1910 - val_seg_loss: 0.1538 - val_denoise_loss: 0.0373\n",
+      "\n",
+      "Epoch 00125: ReduceLROnPlateau reducing learning rate to 1.56249996052793e-06.\n",
+      "Epoch 126/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.2127e-04 - denoise_loss: 0.0374 - val_loss: 0.1912 - val_denoiseg: 0.1912 - val_seg_loss: 0.1539 - val_denoise_loss: 0.0373\n",
+      "Epoch 127/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.1359e-04 - denoise_loss: 0.0374 - val_loss: 0.1912 - val_denoiseg: 0.1912 - val_seg_loss: 0.1539 - val_denoise_loss: 0.0373\n",
+      "Epoch 128/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.5577e-04 - denoise_loss: 0.0374 - val_loss: 0.1913 - val_denoiseg: 0.1913 - val_seg_loss: 0.1541 - val_denoise_loss: 0.0373\n",
+      "Epoch 129/200\n",
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.5621e-04 - denoise_loss: 0.0374 - val_loss: 0.1916 - val_denoiseg: 0.1916 - val_seg_loss: 0.1543 - val_denoise_loss: 0.0373\n",
+      "Epoch 130/200\n",
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.4963e-04 - denoise_loss: 0.0374 - val_loss: 0.1906 - val_denoiseg: 0.1906 - val_seg_loss: 0.1534 - val_denoise_loss: 0.0373\n",
+      "Epoch 131/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.2168e-04 - denoise_loss: 0.0374 - val_loss: 0.1897 - val_denoiseg: 0.1897 - val_seg_loss: 0.1525 - val_denoise_loss: 0.0373\n",
+      "Epoch 132/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0378 - denoiseg: 0.0378 - seg_loss: 4.5768e-04 - denoise_loss: 0.0374 - val_loss: 0.1902 - val_denoiseg: 0.1902 - val_seg_loss: 0.1529 - val_denoise_loss: 0.0373\n",
+      "Epoch 133/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.2806e-04 - denoise_loss: 0.0374 - val_loss: 0.1908 - val_denoiseg: 0.1908 - val_seg_loss: 0.1536 - val_denoise_loss: 0.0373\n",
+      "Epoch 134/200\n",
+      "100/100 [==============================] - 104s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.2671e-04 - denoise_loss: 0.0375 - val_loss: 0.1900 - val_denoiseg: 0.1900 - val_seg_loss: 0.1527 - val_denoise_loss: 0.0373\n",
+      "Epoch 135/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.4901e-04 - denoise_loss: 0.0374 - val_loss: 0.1900 - val_denoiseg: 0.1900 - val_seg_loss: 0.1528 - val_denoise_loss: 0.0373\n",
+      "\n",
+      "Epoch 00135: ReduceLROnPlateau reducing learning rate to 7.81249980263965e-07.\n",
+      "Epoch 136/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0378 - denoiseg: 0.0378 - seg_loss: 4.9176e-04 - denoise_loss: 0.0373 - val_loss: 0.1905 - val_denoiseg: 0.1905 - val_seg_loss: 0.1533 - val_denoise_loss: 0.0373\n",
+      "Epoch 137/200\n",
+      " 90/100 [==========================>...] - ETA: 10s - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.8335e-04 - denoise_loss: 0.0374"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.115260). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 91/100 [==========================>...] - ETA: 9s - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.8793e-04 - denoise_loss: 0.0374 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.139320). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 92/100 [==========================>...] - ETA: 8s - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.9367e-04 - denoise_loss: 0.0374"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.163382). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 93/100 [==========================>...] - ETA: 7s - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.8836e-04 - denoise_loss: 0.0374"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.122173). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 94/100 [===========================>..] - ETA: 6s - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.8316e-04 - denoise_loss: 0.0374"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.135087). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 96/100 [===========================>..] - ETA: 4s - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.8093e-04 - denoise_loss: 0.0374"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.116552). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 98/100 [============================>.] - ETA: 2s - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.7632e-04 - denoise_loss: 0.0374"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.103637). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 104s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.8451e-04 - denoise_loss: 0.0374 - val_loss: 0.1903 - val_denoiseg: 0.1903 - val_seg_loss: 0.1530 - val_denoise_loss: 0.0373\n",
+      "Epoch 138/200\n",
+      " 11/100 [==>...........................] - ETA: 1:18 - loss: 0.0384 - denoiseg: 0.0384 - seg_loss: 5.7724e-04 - denoise_loss: 0.0378"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.143762). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 15/100 [===>..........................] - ETA: 1:15 - loss: 0.0382 - denoiseg: 0.0382 - seg_loss: 4.9710e-04 - denoise_loss: 0.0377"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.154792). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      " 16/100 [===>..........................] - ETA: 1:14 - loss: 0.0382 - denoiseg: 0.0382 - seg_loss: 5.1313e-04 - denoise_loss: 0.0377"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.173854). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 18/100 [====>.........................] - ETA: 1:13 - loss: 0.0381 - denoiseg: 0.0381 - seg_loss: 4.5611e-04 - denoise_loss: 0.0377"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.120135). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 62/100 [=================>............] - ETA: 35s - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 4.7538e-04 - denoise_loss: 0.0375"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.113729). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 70/100 [====================>.........] - ETA: 28s - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.5835e-04 - denoise_loss: 0.0374"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.125665). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 75/100 [=====================>........] - ETA: 23s - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.6924e-04 - denoise_loss: 0.0374"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.149957). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 94s 943ms/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.2001e-04 - denoise_loss: 0.0374 - val_loss: 0.1908 - val_denoiseg: 0.1908 - val_seg_loss: 0.1536 - val_denoise_loss: 0.0373\n",
+      "Epoch 139/200\n",
+      " 19/100 [====>.........................] - ETA: 1:06 - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.3515e-04 - denoise_loss: 0.0375"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.106808). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 99s 986ms/step - loss: 0.0378 - denoiseg: 0.0378 - seg_loss: 4.2333e-04 - denoise_loss: 0.0374 - val_loss: 0.1909 - val_denoiseg: 0.1909 - val_seg_loss: 0.1536 - val_denoise_loss: 0.0373\n",
+      "Epoch 140/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.0181e-04 - denoise_loss: 0.0375 - val_loss: 0.1907 - val_denoiseg: 0.1907 - val_seg_loss: 0.1534 - val_denoise_loss: 0.0373\n",
+      "Epoch 141/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.0229e-04 - denoise_loss: 0.0375 - val_loss: 0.1914 - val_denoiseg: 0.1914 - val_seg_loss: 0.1541 - val_denoise_loss: 0.0373\n",
+      "Epoch 142/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.9249e-04 - denoise_loss: 0.0374 - val_loss: 0.1913 - val_denoiseg: 0.1913 - val_seg_loss: 0.1540 - val_denoise_loss: 0.0373\n",
+      "Epoch 143/200\n",
+      "100/100 [==============================] - 117s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.2953e-04 - denoise_loss: 0.0374 - val_loss: 0.1914 - val_denoiseg: 0.1914 - val_seg_loss: 0.1542 - val_denoise_loss: 0.0373\n",
+      "Epoch 144/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.7696e-04 - denoise_loss: 0.0374 - val_loss: 0.1905 - val_denoiseg: 0.1905 - val_seg_loss: 0.1532 - val_denoise_loss: 0.0373\n",
+      "Epoch 145/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.6141e-04 - denoise_loss: 0.0374 - val_loss: 0.1903 - val_denoiseg: 0.1903 - val_seg_loss: 0.1531 - val_denoise_loss: 0.0373\n",
+      "\n",
+      "Epoch 00145: ReduceLROnPlateau reducing learning rate to 3.906249901319825e-07.\n",
+      "Epoch 146/200\n",
+      "100/100 [==============================] - 100s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.0617e-04 - denoise_loss: 0.0375 - val_loss: 0.1903 - val_denoiseg: 0.1903 - val_seg_loss: 0.1531 - val_denoise_loss: 0.0373\n",
+      "Epoch 147/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.2996e-04 - denoise_loss: 0.0375 - val_loss: 0.1905 - val_denoiseg: 0.1905 - val_seg_loss: 0.1532 - val_denoise_loss: 0.0373\n",
+      "Epoch 148/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.0078e-04 - denoise_loss: 0.0374 - val_loss: 0.1905 - val_denoiseg: 0.1905 - val_seg_loss: 0.1533 - val_denoise_loss: 0.0373\n",
+      "Epoch 149/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.2218e-04 - denoise_loss: 0.0375 - val_loss: 0.1904 - val_denoiseg: 0.1904 - val_seg_loss: 0.1531 - val_denoise_loss: 0.0373\n",
+      "Epoch 150/200\n",
+      "100/100 [==============================] - 115s 1s/step - loss: 0.0378 - denoiseg: 0.0378 - seg_loss: 4.2518e-04 - denoise_loss: 0.0374 - val_loss: 0.1907 - val_denoiseg: 0.1907 - val_seg_loss: 0.1534 - val_denoise_loss: 0.0373\n",
+      "Epoch 151/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0381 - denoiseg: 0.0381 - seg_loss: 5.7014e-04 - denoise_loss: 0.0375 - val_loss: 0.1904 - val_denoiseg: 0.1904 - val_seg_loss: 0.1531 - val_denoise_loss: 0.0373\n",
+      "Epoch 152/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.8443e-04 - denoise_loss: 0.0374 - val_loss: 0.1907 - val_denoiseg: 0.1907 - val_seg_loss: 0.1534 - val_denoise_loss: 0.0373\n",
+      "Epoch 153/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.5829e-04 - denoise_loss: 0.0374 - val_loss: 0.1911 - val_denoiseg: 0.1911 - val_seg_loss: 0.1538 - val_denoise_loss: 0.0373\n",
+      "Epoch 154/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.1701e-04 - denoise_loss: 0.0373 - val_loss: 0.1906 - val_denoiseg: 0.1906 - val_seg_loss: 0.1533 - val_denoise_loss: 0.0373\n",
+      "Epoch 155/200\n",
+      "  1/100 [..............................] - ETA: 14s - loss: 0.0384 - denoiseg: 0.0384 - seg_loss: 0.0000e+00 - denoise_loss: 0.0384"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.319589). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  3/100 [..............................] - ETA: 33s - loss: 0.0384 - denoiseg: 0.0384 - seg_loss: 3.1268e-04 - denoise_loss: 0.0381"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.299211). Check your callbacks.\n",
+      "  % delta_t_median)\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.278833). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r",
+      "  4/100 [>.............................] - ETA: 49s - loss: 0.0392 - denoiseg: 0.0392 - seg_loss: 5.8939e-04 - denoise_loss: 0.0386"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.145893). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 20/100 [=====>........................] - ETA: 1:13 - loss: 0.0381 - denoiseg: 0.0381 - seg_loss: 5.5192e-04 - denoise_loss: 0.0376"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.120636). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 23/100 [=====>........................] - ETA: 1:10 - loss: 0.0381 - denoiseg: 0.0381 - seg_loss: 5.0616e-04 - denoise_loss: 0.0376"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.106429). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 95s 949ms/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.9132e-04 - denoise_loss: 0.0374 - val_loss: 0.1913 - val_denoiseg: 0.1913 - val_seg_loss: 0.1540 - val_denoise_loss: 0.0373\n",
+      "\n",
+      "Epoch 00155: ReduceLROnPlateau reducing learning rate to 1.9531249506599124e-07.\n",
+      "Epoch 156/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0378 - denoiseg: 0.0378 - seg_loss: 4.8571e-04 - denoise_loss: 0.0373 - val_loss: 0.1912 - val_denoiseg: 0.1912 - val_seg_loss: 0.1539 - val_denoise_loss: 0.0373\n",
+      "Epoch 157/200\n",
+      "100/100 [==============================] - 115s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.3115e-04 - denoise_loss: 0.0374 - val_loss: 0.1915 - val_denoiseg: 0.1915 - val_seg_loss: 0.1542 - val_denoise_loss: 0.0373\n",
+      "Epoch 158/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.8735e-04 - denoise_loss: 0.0374 - val_loss: 0.1913 - val_denoiseg: 0.1913 - val_seg_loss: 0.1540 - val_denoise_loss: 0.0373\n",
+      "Epoch 159/200\n",
+      "100/100 [==============================] - 106s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.8894e-04 - denoise_loss: 0.0374 - val_loss: 0.1911 - val_denoiseg: 0.1911 - val_seg_loss: 0.1538 - val_denoise_loss: 0.0373\n",
+      "Epoch 160/200\n",
+      "  1/100 [..............................] - ETA: 12s - loss: 0.0371 - denoiseg: 0.0371 - seg_loss: 0.0000e+00 - denoise_loss: 0.0371"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/keras/callbacks.py:122: UserWarning: Method on_batch_end() is slow compared to the batch update (0.125721). Check your callbacks.\n",
+      "  % delta_t_median)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.8849e-04 - denoise_loss: 0.0374 - val_loss: 0.1913 - val_denoiseg: 0.1913 - val_seg_loss: 0.1540 - val_denoise_loss: 0.0373\n",
+      "Epoch 161/200\n",
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.1700e-04 - denoise_loss: 0.0374 - val_loss: 0.1908 - val_denoiseg: 0.1908 - val_seg_loss: 0.1536 - val_denoise_loss: 0.0373\n",
+      "Epoch 162/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.0621e-04 - denoise_loss: 0.0374 - val_loss: 0.1913 - val_denoiseg: 0.1913 - val_seg_loss: 0.1541 - val_denoise_loss: 0.0373\n",
+      "Epoch 163/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.2792e-04 - denoise_loss: 0.0375 - val_loss: 0.1913 - val_denoiseg: 0.1913 - val_seg_loss: 0.1540 - val_denoise_loss: 0.0373\n",
+      "Epoch 164/200\n",
+      "100/100 [==============================] - 115s 1s/step - loss: 0.0378 - denoiseg: 0.0378 - seg_loss: 5.1001e-04 - denoise_loss: 0.0373 - val_loss: 0.1912 - val_denoiseg: 0.1912 - val_seg_loss: 0.1539 - val_denoise_loss: 0.0373\n",
+      "Epoch 165/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0378 - denoiseg: 0.0378 - seg_loss: 4.8728e-04 - denoise_loss: 0.0373 - val_loss: 0.1912 - val_denoiseg: 0.1912 - val_seg_loss: 0.1540 - val_denoise_loss: 0.0373\n",
+      "\n",
+      "Epoch 00165: ReduceLROnPlateau reducing learning rate to 9.765624753299562e-08.\n",
+      "Epoch 166/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.0517e-04 - denoise_loss: 0.0375 - val_loss: 0.1912 - val_denoiseg: 0.1912 - val_seg_loss: 0.1540 - val_denoise_loss: 0.0373\n",
+      "Epoch 167/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.8457e-04 - denoise_loss: 0.0375 - val_loss: 0.1913 - val_denoiseg: 0.1913 - val_seg_loss: 0.1541 - val_denoise_loss: 0.0373\n",
+      "Epoch 168/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.2474e-04 - denoise_loss: 0.0374 - val_loss: 0.1910 - val_denoiseg: 0.1910 - val_seg_loss: 0.1537 - val_denoise_loss: 0.0373\n",
+      "Epoch 169/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 4.4900e-04 - denoise_loss: 0.0375 - val_loss: 0.1912 - val_denoiseg: 0.1912 - val_seg_loss: 0.1539 - val_denoise_loss: 0.0373\n",
+      "Epoch 170/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0378 - denoiseg: 0.0378 - seg_loss: 5.2768e-04 - denoise_loss: 0.0373 - val_loss: 0.1910 - val_denoiseg: 0.1910 - val_seg_loss: 0.1537 - val_denoise_loss: 0.0373\n",
+      "Epoch 171/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.1519e-04 - denoise_loss: 0.0373 - val_loss: 0.1913 - val_denoiseg: 0.1913 - val_seg_loss: 0.1540 - val_denoise_loss: 0.0373\n",
+      "Epoch 172/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.9689e-04 - denoise_loss: 0.0374 - val_loss: 0.1913 - val_denoiseg: 0.1913 - val_seg_loss: 0.1540 - val_denoise_loss: 0.0373\n",
+      "Epoch 173/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.5337e-04 - denoise_loss: 0.0374 - val_loss: 0.1912 - val_denoiseg: 0.1912 - val_seg_loss: 0.1539 - val_denoise_loss: 0.0373\n",
+      "Epoch 174/200\n",
+      "100/100 [==============================] - 95s 946ms/step - loss: 0.0381 - denoiseg: 0.0381 - seg_loss: 5.2776e-04 - denoise_loss: 0.0376 - val_loss: 0.1916 - val_denoiseg: 0.1916 - val_seg_loss: 0.1543 - val_denoise_loss: 0.0373\n",
+      "Epoch 175/200\n",
+      "100/100 [==============================] - 116s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.8108e-04 - denoise_loss: 0.0374 - val_loss: 0.1913 - val_denoiseg: 0.1913 - val_seg_loss: 0.1540 - val_denoise_loss: 0.0373\n",
+      "\n",
+      "Epoch 00175: ReduceLROnPlateau reducing learning rate to 4.882812376649781e-08.\n",
+      "Epoch 176/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 4.8658e-04 - denoise_loss: 0.0375 - val_loss: 0.1915 - val_denoiseg: 0.1915 - val_seg_loss: 0.1543 - val_denoise_loss: 0.0373\n",
+      "Epoch 177/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.8946e-04 - denoise_loss: 0.0374 - val_loss: 0.1912 - val_denoiseg: 0.1912 - val_seg_loss: 0.1539 - val_denoise_loss: 0.0373\n",
+      "Epoch 178/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.2077e-04 - denoise_loss: 0.0374 - val_loss: 0.1913 - val_denoiseg: 0.1913 - val_seg_loss: 0.1540 - val_denoise_loss: 0.0373\n",
+      "Epoch 179/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0378 - denoiseg: 0.0378 - seg_loss: 4.8782e-04 - denoise_loss: 0.0373 - val_loss: 0.1914 - val_denoiseg: 0.1914 - val_seg_loss: 0.1541 - val_denoise_loss: 0.0373\n",
+      "Epoch 180/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.8123e-04 - denoise_loss: 0.0375 - val_loss: 0.1914 - val_denoiseg: 0.1914 - val_seg_loss: 0.1541 - val_denoise_loss: 0.0373\n",
+      "Epoch 181/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.4437e-04 - denoise_loss: 0.0373 - val_loss: 0.1912 - val_denoiseg: 0.1912 - val_seg_loss: 0.1540 - val_denoise_loss: 0.0373\n",
+      "Epoch 182/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.2514e-04 - denoise_loss: 0.0373 - val_loss: 0.1918 - val_denoiseg: 0.1918 - val_seg_loss: 0.1545 - val_denoise_loss: 0.0373\n",
+      "Epoch 183/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.6407e-04 - denoise_loss: 0.0374 - val_loss: 0.1917 - val_denoiseg: 0.1917 - val_seg_loss: 0.1544 - val_denoise_loss: 0.0373\n",
+      "Epoch 184/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.5904e-04 - denoise_loss: 0.0375 - val_loss: 0.1917 - val_denoiseg: 0.1917 - val_seg_loss: 0.1545 - val_denoise_loss: 0.0373\n",
+      "Epoch 185/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.7609e-04 - denoise_loss: 0.0375 - val_loss: 0.1910 - val_denoiseg: 0.1910 - val_seg_loss: 0.1538 - val_denoise_loss: 0.0373\n",
+      "\n",
+      "Epoch 00185: ReduceLROnPlateau reducing learning rate to 2.4414061883248905e-08.\n",
+      "Epoch 186/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.6701e-04 - denoise_loss: 0.0374 - val_loss: 0.1913 - val_denoiseg: 0.1913 - val_seg_loss: 0.1540 - val_denoise_loss: 0.0373\n",
+      "Epoch 187/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.3691e-04 - denoise_loss: 0.0374 - val_loss: 0.1909 - val_denoiseg: 0.1909 - val_seg_loss: 0.1537 - val_denoise_loss: 0.0373\n",
+      "Epoch 188/200\n",
+      "100/100 [==============================] - 112s 1s/step - loss: 0.0378 - denoiseg: 0.0378 - seg_loss: 4.7010e-04 - denoise_loss: 0.0373 - val_loss: 0.1909 - val_denoiseg: 0.1909 - val_seg_loss: 0.1536 - val_denoise_loss: 0.0373\n",
+      "Epoch 189/200\n",
+      "100/100 [==============================] - 108s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.9933e-04 - denoise_loss: 0.0374 - val_loss: 0.1911 - val_denoiseg: 0.1911 - val_seg_loss: 0.1538 - val_denoise_loss: 0.0373\n",
+      "Epoch 190/200\n",
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.4200e-04 - denoise_loss: 0.0375 - val_loss: 0.1913 - val_denoiseg: 0.1913 - val_seg_loss: 0.1540 - val_denoise_loss: 0.0373\n",
+      "Epoch 191/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.9189e-04 - denoise_loss: 0.0374 - val_loss: 0.1912 - val_denoiseg: 0.1912 - val_seg_loss: 0.1539 - val_denoise_loss: 0.0373\n",
+      "Epoch 192/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0378 - denoiseg: 0.0378 - seg_loss: 4.6096e-04 - denoise_loss: 0.0373 - val_loss: 0.1908 - val_denoiseg: 0.1908 - val_seg_loss: 0.1535 - val_denoise_loss: 0.0373\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 193/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.8224e-04 - denoise_loss: 0.0374 - val_loss: 0.1911 - val_denoiseg: 0.1911 - val_seg_loss: 0.1538 - val_denoise_loss: 0.0373\n",
+      "Epoch 194/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.1077e-04 - denoise_loss: 0.0375 - val_loss: 0.1911 - val_denoiseg: 0.1911 - val_seg_loss: 0.1539 - val_denoise_loss: 0.0373\n",
+      "Epoch 195/200\n",
+      "100/100 [==============================] - 114s 1s/step - loss: 0.0380 - denoiseg: 0.0380 - seg_loss: 5.1885e-04 - denoise_loss: 0.0375 - val_loss: 0.1914 - val_denoiseg: 0.1914 - val_seg_loss: 0.1541 - val_denoise_loss: 0.0373\n",
+      "\n",
+      "Epoch 00195: ReduceLROnPlateau reducing learning rate to 1.2207030941624453e-08.\n",
+      "Epoch 196/200\n",
+      "100/100 [==============================] - 113s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.2266e-04 - denoise_loss: 0.0374 - val_loss: 0.1913 - val_denoiseg: 0.1913 - val_seg_loss: 0.1541 - val_denoise_loss: 0.0373\n",
+      "Epoch 197/200\n",
+      "100/100 [==============================] - 111s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.0128e-04 - denoise_loss: 0.0374 - val_loss: 0.1911 - val_denoiseg: 0.1911 - val_seg_loss: 0.1538 - val_denoise_loss: 0.0373\n",
+      "Epoch 198/200\n",
+      "100/100 [==============================] - 107s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.9152e-04 - denoise_loss: 0.0374 - val_loss: 0.1914 - val_denoiseg: 0.1914 - val_seg_loss: 0.1542 - val_denoise_loss: 0.0373\n",
+      "Epoch 199/200\n",
+      "100/100 [==============================] - 110s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 5.2471e-04 - denoise_loss: 0.0374 - val_loss: 0.1910 - val_denoiseg: 0.1910 - val_seg_loss: 0.1538 - val_denoise_loss: 0.0373\n",
+      "Epoch 200/200\n",
+      "100/100 [==============================] - 109s 1s/step - loss: 0.0379 - denoiseg: 0.0379 - seg_loss: 4.9595e-04 - denoise_loss: 0.0375 - val_loss: 0.1912 - val_denoiseg: 0.1912 - val_seg_loss: 0.1539 - val_denoise_loss: 0.0373\n",
+      "\n",
+      "Loading network weights from 'weights_best.h5'.\n"
+     ]
+    }
+   ],
+   "source": [
+    "history = model.train(X, Y, (X_val, Y_val))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['val_loss', 'val_denoiseg', 'val_seg_loss', 'val_denoise_loss', 'loss', 'denoiseg', 'seg_loss', 'denoise_loss', 'lr'])"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "history.history.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_history(history, ['loss', 'val_loss'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Computing Threshold Value\n",
+    "The network predicts 4 output channels:\n",
+    "1. The denoised input.\n",
+    "2. The foreground likelihoods.\n",
+    "3. The background likelihoods.\n",
+    "4. The border likelihoods.\n",
+    "\n",
+    "We will threshold the foreground prediction image to obtain object segmentations. The optimal threshold is determined on the validation data. Additionally we can optimize the threshold for a given measure. In this case we choose the Average Precision (AP) measure."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Computing best threshold: \n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0cc4114c01fc4fd6a5e8fe76e2cad204",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(FloatProgress(value=0.0, max=19.0), HTML(value='')))"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prakash/Desktop/GitClones/DenoiSeg/denoiseg/utils/compute_precision_threshold.py:7: NumbaWarning: \n",
+      "Compilation is falling back to object mode WITH looplifting enabled because Function \"pixel_sharing_bipartite\" failed type inference due to: Invalid use of Function(<built-in function zeros>) with argument(s) of type(s): (UniTuple(int64 x 2), dtype=Function(<class 'int'>))\n",
+      " * parameterized\n",
+      "In definition 0:\n",
+      "    All templates rejected with literals.\n",
+      "In definition 1:\n",
+      "    All templates rejected without literals.\n",
+      "This error is usually caused by passing an argument of a type that is unsupported by the named function.\n",
+      "[1] During: resolving callee type: Function(<built-in function zeros>)\n",
+      "[2] During: typing of call at /home/prakash/Desktop/GitClones/DenoiSeg/denoiseg/utils/compute_precision_threshold.py (10)\n",
+      "\n",
+      "\n",
+      "File \"../../denoiseg/utils/compute_precision_threshold.py\", line 10:\n",
+      "def pixel_sharing_bipartite(lab1, lab2):\n",
+      "    <source elided>\n",
+      "    assert lab1.shape == lab2.shape\n",
+      "    psg = np.zeros((lab1.max() + 1, lab2.max() + 1), dtype=np.int)\n",
+      "    ^\n",
+      "\n",
+      "  @jit\n",
+      "/home/prakash/Desktop/GitClones/DenoiSeg/denoiseg/utils/compute_precision_threshold.py:7: NumbaWarning: \n",
+      "Compilation is falling back to object mode WITHOUT looplifting enabled because Function \"pixel_sharing_bipartite\" failed type inference due to: Unsupported constraint encountered: raise $14.1\n",
+      "\n",
+      "File \"../../denoiseg/utils/compute_precision_threshold.py\", line 9:\n",
+      "def pixel_sharing_bipartite(lab1, lab2):\n",
+      "    assert lab1.shape == lab2.shape\n",
+      "    ^\n",
+      "\n",
+      "  @jit\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/numba/object_mode_passes.py:178: NumbaWarning: Function \"pixel_sharing_bipartite\" was compiled in object mode without forceobj=True, but has lifted loops.\n",
+      "\n",
+      "File \"../../denoiseg/utils/compute_precision_threshold.py\", line 9:\n",
+      "def pixel_sharing_bipartite(lab1, lab2):\n",
+      "    assert lab1.shape == lab2.shape\n",
+      "    ^\n",
+      "\n",
+      "  state.func_ir.loc))\n",
+      "/home/prakash/miniconda3/envs/DenoiSeg/lib/python3.6/site-packages/numba/object_mode_passes.py:188: NumbaDeprecationWarning: \n",
+      "Fall-back from the nopython compilation path to the object mode compilation path has been detected, this is deprecated behaviour.\n",
+      "\n",
+      "For more information visit http://numba.pydata.org/numba-doc/latest/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit\n",
+      "\n",
+      "File \"../../denoiseg/utils/compute_precision_threshold.py\", line 9:\n",
+      "def pixel_sharing_bipartite(lab1, lab2):\n",
+      "    assert lab1.shape == lab2.shape\n",
+      "    ^\n",
+      "\n",
+      "  state.func_ir.loc))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Score for threshold = 0.10 is 0.6457\n",
+      "Score for threshold = 0.15 is 0.6789\n",
+      "Score for threshold = 0.20 is 0.7022\n",
+      "Score for threshold = 0.25 is 0.7056\n",
+      "Score for threshold = 0.30 is 0.7194\n",
+      "Score for threshold = 0.35 is 0.7284\n",
+      "Score for threshold = 0.40 is 0.7359\n",
+      "Score for threshold = 0.45 is 0.7379\n",
+      "Score for threshold = 0.50 is 0.7450\n",
+      "Score for threshold = 0.55 is 0.7459\n",
+      "Score for threshold = 0.60 is 0.7341\n",
+      "Score for threshold = 0.65 is 0.7297\n",
+      "Score for threshold = 0.70 is 0.7141\n",
+      "Score for threshold = 0.75 is 0.6942\n",
+      "Score for threshold = 0.80 is 0.6817\n",
+      "Score for threshold = 0.85 is 0.6496\n",
+      "Score for threshold = 0.90 is 0.5778\n",
+      "Score for threshold = 0.95 is 0.3954\n",
+      "Score for threshold = 1.00 is 0.0000\n",
+      "\n",
+      "The higest score of 0.746 is achieved with threshold = 0.55.\n"
+     ]
+    }
+   ],
+   "source": [
+    "threshold, val_score = model.optimize_thresholds(val_images.astype(np.float32), val_masks, measure=measure_precision())\n",
+    "\n",
+    "print(\"The higest score of {} is achieved with threshold = {}.\".format(np.round(val_score, 3), threshold))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test Data\n",
+    "Finally we load the test data and run the prediction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_data =  np.load('data/Mouse_{}/test/test_data.npz'.format(noise_level), allow_pickle=True)\n",
+    "test_images = test_data['X_test']\n",
+    "test_masks = test_data['Y_test']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Average precision over all test images with threshold = 0.55 is 0.522.\n"
+     ]
+    }
+   ],
+   "source": [
+    "predicted_images, precision_result = model.predict_label_masks(test_images, test_masks, threshold, \n",
+    "                                                                   measure=measure_precision())\n",
+    "print(\"Average precision over all test images with threshold = {} is {}.\".format(threshold, np.round(precision_result, 3)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "DenoiSeg",
+   "language": "python",
+   "name": "denoiseg"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/Noise2Seg_2D/DSB2018_Noise2Seg_Example.ipynb b/examples/Noise2Seg_2D/DSB2018_Noise2Seg_Example.ipynb
deleted file mode 100644
index fb774a3..0000000
--- a/examples/Noise2Seg_2D/DSB2018_Noise2Seg_Example.ipynb
+++ /dev/null
@@ -1,552 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Using TensorFlow backend.\n"
-     ]
-    }
-   ],
-   "source": [
-    "%load_ext autoreload\n",
-    "%autoreload 2\n",
-    "import warnings\n",
-    "warnings.filterwarnings('ignore')\n",
-    "import sys\n",
-    "sys.path.append('../../')\n",
-    "from noise2seg.models import Noise2Seg, Noise2SegConfig\n",
-    "import numpy as np\n",
-    "from csbdeep.utils import plot_history\n",
-    "from noise2seg.utils.misc_utils import combine_train_test_data, shuffle_train_data, augment_data\n",
-    "from noise2seg.utils.seg_utils import *\n",
-    "from noise2seg.utils.compute_precision_threshold import measure_precision\n",
-    "from keras.optimizers import Adam\n",
-    "from matplotlib import pyplot as plt\n",
-    "from scipy import ndimage\n",
-    "import tensorflow as tf\n",
-    "import keras.backend as K\n",
-    "import urllib\n",
-    "import os\n",
-    "import zipfile"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# create a folder for our data\n",
-    "if not os.path.isdir('./data'):\n",
-    "    os.mkdir('data')\n",
-    "\n",
-    "# check if data has been downloaded already\n",
-    "zipPath=\"data/DSB.zip\"\n",
-    "if not os.path.exists(zipPath):\n",
-    "    #download and unzip data\n",
-    "    data = urllib.request.urlretrieve('https://owncloud.mpi-cbg.de/index.php/s/LIN4L4R9b2gebDX/download', zipPath)\n",
-    "    with zipfile.ZipFile(zipPath, 'r') as zip_ref:\n",
-    "        zip_ref.extractall(\"data\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "trainval_data =  np.load('data/DSB/train_data/dsb2018_TrainVal40.npz')\n",
-    "test_data =  np.load('data/DSB/test_data/dsb2018_Test40.npz', allow_pickle=True)\n",
-    "train_images = trainval_data['X_train'].astype(np.float32)\n",
-    "val_images = trainval_data['X_val'].astype(np.float32)\n",
-    "test_images = test_data['X_test']\n",
-    "\n",
-    "train_masks = trainval_data['Y_train']\n",
-    "val_masks = trainval_data['Y_val']\n",
-    "test_masks = test_data['Y_test']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Shape of train_images:  (3800, 128, 128) , Shape of train_masks:  (3800, 128, 128)\n",
-      "Shape of val_images:  (670, 128, 128) , Shape of val_masks:  (670, 128, 128)\n",
-      "Shape of test_images:  (50,) , Shape of test_masks:  (50,)\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"Shape of train_images: \", train_images.shape, \", Shape of train_masks: \", train_masks.shape)\n",
-    "print(\"Shape of val_images: \", val_images.shape, \", Shape of val_masks: \", val_masks.shape)\n",
-    "print(\"Shape of test_images: \", test_images.shape, \", Shape of test_masks: \", test_masks.shape)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Training Data \n",
-      "..................\n",
-      "Raw image size after augmentation (30400, 128, 128)\n",
-      "Mask size after augmentation (30400, 128, 128)\n",
-      "\n",
-      "\n",
-      "Validation Data \n",
-      "..................\n"
-     ]
-    }
-   ],
-   "source": [
-    "fraction = 5 # Fraction of annotated GT and raw image pairs to use during training. \n",
-    "random_seed = 1 # Seed to shuffle training data (annotated GT and raw image pairs).\n",
-    "\n",
-    "\n",
-    "assert 0 <fraction<= 100, \"Fraction should be between 0 and 100\"\n",
-    "\n",
-    "X_shuffled, Y_shuffled = shuffle_train_data(train_images, train_masks, random_seed = random_seed)\n",
-    "X_frac, Y_frac = zero_out_train_data(X_shuffled, Y_shuffled, fraction = fraction)\n",
-    "print(\"Training Data \\n..................\")\n",
-    "X, Y_train_masks = augment_data(X_frac, Y_frac)\n",
-    "print(\"\\n\")\n",
-    "print(\"Validation Data \\n..................\")\n",
-    "X_val, Y_val_masks = val_images, val_masks"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Shape of train images:  (30400, 128, 128, 1) , Shape of train masks:  (30400, 128, 128, 3)\n",
-      "Shape of validation images:  (670, 128, 128, 1) , Shape of validation masks:  (670, 128, 128, 3)\n"
-     ]
-    }
-   ],
-   "source": [
-    "X = X[...,np.newaxis]\n",
-    "Y = convert_to_oneHot(Y_train_masks)\n",
-    "X_val = X_val[...,np.newaxis]\n",
-    "Y_val = convert_to_oneHot(Y_val_masks)\n",
-    "print(\"Shape of train images: \", X.shape, \", Shape of train masks: \", Y.shape)\n",
-    "print(\"Shape of validation images: \", X_val.shape, \", Shape of validation masks: \", Y_val.shape)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1440x360 with 4 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "sl = 1\n",
-    "plt.figure(figsize=(20,5))\n",
-    "plt.subplot(1,4,1)\n",
-    "plt.imshow(X[sl,...,0])\n",
-    "plt.title('Raw validation image')\n",
-    "plt.subplot(1,4,2)\n",
-    "plt.imshow(Y[sl,...,0], vmin=0, vmax=1)\n",
-    "plt.title('1-hot encoded background')\n",
-    "plt.subplot(1,4,3)\n",
-    "plt.imshow(Y[sl,...,1], vmin=0, vmax=1)\n",
-    "plt.title('1-hot encoded foreground')\n",
-    "plt.subplot(1,4,4)\n",
-    "plt.imshow(Y[sl,...,2], vmin=0, vmax=1)\n",
-    "plt.title('1-hot encoded border');"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1440x360 with 4 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "sl = -1\n",
-    "plt.figure(figsize=(20,5))\n",
-    "plt.subplot(1,4,1)\n",
-    "plt.imshow(X[sl,...,0])\n",
-    "plt.title('Raw validation image')\n",
-    "plt.subplot(1,4,2)\n",
-    "plt.imshow(Y[sl,...,0], vmin=0, vmax=1)\n",
-    "plt.title('1-hot encoded background')\n",
-    "plt.subplot(1,4,3)\n",
-    "plt.imshow(Y[sl,...,1], vmin=0, vmax=1)\n",
-    "plt.title('1-hot encoded foreground')\n",
-    "plt.subplot(1,4,4)\n",
-    "plt.imshow(Y[sl,...,2], vmin=0, vmax=1)\n",
-    "plt.title('1-hot encoded border');"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "train_batch_size = 128\n",
-    "train_steps_per_epoch = int(X.shape[0]/train_batch_size)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'means': ['13.486088'],\n",
-       " 'stds': ['44.00652'],\n",
-       " 'n_dim': 2,\n",
-       " 'axes': 'YXC',\n",
-       " 'n_channel_in': 1,\n",
-       " 'n_channel_out': 4,\n",
-       " 'train_loss': 'noise2seg',\n",
-       " 'unet_n_depth': 4,\n",
-       " 'relative_weights': [1.0, 1.0, 5.0],\n",
-       " 'unet_kern_size': 3,\n",
-       " 'unet_n_first': 32,\n",
-       " 'unet_last_activation': 'linear',\n",
-       " 'probabilistic': False,\n",
-       " 'unet_residual': False,\n",
-       " 'unet_input_shape': (None, None, 1),\n",
-       " 'train_epochs': 6,\n",
-       " 'train_steps_per_epoch': 20,\n",
-       " 'train_learning_rate': 0.0004,\n",
-       " 'train_batch_size': 128,\n",
-       " 'train_tensorboard': False,\n",
-       " 'train_checkpoint': 'weights_best.h5',\n",
-       " 'train_checkpoint_last': 'weights_last.h5',\n",
-       " 'train_checkpoint_epoch': 'weights_now.h5',\n",
-       " 'train_reduce_lr': {'monitor': 'val_seg_loss', 'factor': 0.5, 'patience': 10},\n",
-       " 'batch_norm': True,\n",
-       " 'n2v_perc_pix': 1.5,\n",
-       " 'n2v_patch_shape': (64, 64),\n",
-       " 'n2v_manipulator': 'uniform_withCP',\n",
-       " 'n2v_neighborhood_radius': 5,\n",
-       " 'n2s_alpha': 0.5}"
-      ]
-     },
-     "execution_count": 38,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "n2s_conf = Noise2SegConfig(X, unet_kern_size=3, n_channel_out=4, relative_weights = [1.0,1.0,5.0],\n",
-    "                   train_steps_per_epoch=20, train_epochs=6, train_loss='noise2seg', batch_norm=True, \n",
-    "                   train_batch_size=train_batch_size, unet_n_first = 32, unet_n_depth=4, \n",
-    "                   n2s_alpha=0.5,\n",
-    "                          train_tensorboard=False)\n",
-    "\n",
-    "vars(n2s_conf)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# <div style='color:red'>Tensorboard is not working!</div>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [],
-   "source": [
-    "model_name = 'n2s_monitor_numSegImgs'\n",
-    "basedir = 'models'\n",
-    "n2s_model = Noise2Seg(n2s_conf, model_name, basedir)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Preparing validation data:   2%|▏         | 13/670 [00:00<00:05, 121.43it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "61 blind-spots will be generated per training patch of size (64, 64).\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Preparing validation data: 100%|██████████| 670/670 [00:05<00:00, 121.03it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Epoch 1/6\n",
-      "20/20 [==============================] - 11s 536ms/step - loss: 0.5604 - noise2seg: 0.5604 - seg_loss: 0.0442 - denoise_loss: 0.5162 - seg_denoise_ratio: 0.0555 - val_loss: 25.2948 - val_noise2seg: 25.2948 - val_seg_loss: 19.6404 - val_denoise_loss: 5.6544 - val_seg_denoise_ratio: 0.9716\n",
-      "Epoch 2/6\n",
-      "20/20 [==============================] - 4s 223ms/step - loss: 0.4559 - noise2seg: 0.4559 - seg_loss: 0.0236 - denoise_loss: 0.4324 - seg_denoise_ratio: 0.0379 - val_loss: 4.6346 - val_noise2seg: 4.6346 - val_seg_loss: 4.1422 - val_denoise_loss: 0.4924 - val_seg_denoise_ratio: 0.9716\n",
-      "Epoch 3/6\n",
-      "20/20 [==============================] - 5s 257ms/step - loss: 0.4592 - noise2seg: 0.4592 - seg_loss: 0.0322 - denoise_loss: 0.4269 - seg_denoise_ratio: 0.0531 - val_loss: 1.3413 - val_noise2seg: 1.3413 - val_seg_loss: 0.8952 - val_denoise_loss: 0.4461 - val_seg_denoise_ratio: 0.9716\n",
-      "Epoch 4/6\n",
-      "20/20 [==============================] - 5s 257ms/step - loss: 0.4473 - noise2seg: 0.4473 - seg_loss: 0.0237 - denoise_loss: 0.4236 - seg_denoise_ratio: 0.0426 - val_loss: 0.9860 - val_noise2seg: 0.9860 - val_seg_loss: 0.5496 - val_denoise_loss: 0.4364 - val_seg_denoise_ratio: 0.9716\n",
-      "Epoch 5/6\n",
-      "20/20 [==============================] - 5s 268ms/step - loss: 0.4491 - noise2seg: 0.4491 - seg_loss: 0.0250 - denoise_loss: 0.4241 - seg_denoise_ratio: 0.0453 - val_loss: 0.9197 - val_noise2seg: 0.9197 - val_seg_loss: 0.4891 - val_denoise_loss: 0.4306 - val_seg_denoise_ratio: 0.9716\n",
-      "Epoch 6/6\n",
-      "20/20 [==============================] - 6s 281ms/step - loss: 0.4503 - noise2seg: 0.4503 - seg_loss: 0.0272 - denoise_loss: 0.4231 - seg_denoise_ratio: 0.0508 - val_loss: 0.8808 - val_noise2seg: 0.8808 - val_seg_loss: 0.4570 - val_denoise_loss: 0.4238 - val_seg_denoise_ratio: 0.9716\n",
-      "\n",
-      "Loading network weights from 'weights_best.h5'.\n"
-     ]
-    }
-   ],
-   "source": [
-    "history = n2s_model.train(X, Y, (X_val, Y_val))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['val_loss', 'val_noise2seg', 'val_seg_loss', 'val_denoise_loss', 'val_seg_denoise_ratio', 'loss', 'noise2seg', 'seg_loss', 'denoise_loss', 'seg_denoise_ratio', 'lr'])"
-      ]
-     },
-     "execution_count": 41,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "history.history.keys()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plot_history(history, ['val_noise2seg', 'val_seg_loss', 'val_denoise_loss'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plot_history(history, ['seg_denoise_ratio'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plot_history(history, ['lr'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Computing best threshold: \n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "17e6eec6d1344f63b1966fc1f192b34e",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "HBox(children=(FloatProgress(value=0.0, max=19.0), HTML(value='')))"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Score for threshold = 0.10 is 0.0008\n",
-      "Score for threshold = 0.15 is 0.0014\n",
-      "Score for threshold = 0.20 is 0.0021\n",
-      "Score for threshold = 0.25 is 0.0031\n",
-      "Score for threshold = 0.30 is 0.0038\n",
-      "Score for threshold = 0.35 is 0.0071\n",
-      "Score for threshold = 0.40 is 0.0873\n",
-      "Score for threshold = 0.45 is 0.1991\n",
-      "Score for threshold = 0.50 is 0.2174\n",
-      "Score for threshold = 0.55 is 0.2022\n",
-      "Score for threshold = 0.60 is 0.1754\n",
-      "Score for threshold = 0.65 is 0.1444\n",
-      "Score for threshold = 0.70 is 0.1100\n",
-      "Score for threshold = 0.75 is 0.0759\n",
-      "Score for threshold = 0.80 is 0.0547\n",
-      "Score for threshold = 0.85 is 0.0321\n",
-      "Score for threshold = 0.90 is 0.0195\n",
-      "Score for threshold = 0.95 is 0.0042\n",
-      "Score for threshold = 1.00 is 0.0000\n",
-      "\n",
-      "0.5 0.21736018065654708\n"
-     ]
-    }
-   ],
-   "source": [
-    "threshold, val_score = n2s_model.optimize_thresholds(val_images.astype(np.float32), val_masks, measure=measure_precision())\n",
-    "print(threshold, val_score)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Average precision over all test images at IOU = 0.5, threhold = 0.5:  0.15461710878090293\n"
-     ]
-    }
-   ],
-   "source": [
-    "predicted_images, precision_result = n2s_model.predict_label_masks(test_images, test_masks, threshold, \n",
-    "                                                                   measure=measure_precision())\n",
-    "print(\"Average precision over all test images at IOU = 0.5, threhold = {}: \".format(round(threshold, 3)), \n",
-    "      precision_result)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.6.8"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/noise2seg/internals/AlphaScheduling.py b/noise2seg/internals/AlphaScheduling.py
deleted file mode 100644
index 13bd74d..0000000
--- a/noise2seg/internals/AlphaScheduling.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from keras.callbacks import Callback
-from keras import backend as K
-
-class AlphaScheduling(Callback):
-    def __init__(self, alpha, scheduling):
-        self.alpha = alpha
-        self.scheduling = scheduling
-
-    def on_epoch_begin(self, epoch, logs=None):
-        K.set_value(self.alpha, self.scheduling(epoch))
diff --git a/noise2seg/models/__init__.py b/noise2seg/models/__init__.py
deleted file mode 100755
index 8ba3a20..0000000
--- a/noise2seg/models/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-# imports
-
-from .n2s_config import Noise2SegConfig
-from .n2s_standard import Noise2Seg
diff --git a/noise2seg/version.py b/noise2seg/version.py
deleted file mode 100755
index b794fd4..0000000
--- a/noise2seg/version.py
+++ /dev/null
@@ -1 +0,0 @@
-__version__ = '0.1.0'
diff --git a/resources/qualitative_results.png b/resources/qualitative_results.png
new file mode 100644
index 0000000..ac223e1
Binary files /dev/null and b/resources/qualitative_results.png differ
diff --git a/resources/teaser.png b/resources/teaser.png
new file mode 100644
index 0000000..573203f
Binary files /dev/null and b/resources/teaser.png differ
diff --git a/scripts/reproducibility/README.md b/scripts/reproducibility/README.md
new file mode 100644
index 0000000..7292e70
--- /dev/null
+++ b/scripts/reproducibility/README.md
@@ -0,0 +1,50 @@
+# Reproducibility
+In this sub-directory you can find all scripts and jupyter notebook 
+which we used to produce the results reported in the manuscript. If
+you want to run the exact code we used, you have to use release 
+[v0.1.7](https://github.com/juglab/DenoiSeg/releases/tag/v0.1.7).
+You will see the name `noise2seg`, the original name of the project, 
+in these files. We only renamed the project to `DenoiSeg` once we 
+started writing it up :)
+
+__Note:__ These files are here for completeness and not expected to 
+run out of the box on any given setup. 
+
+## ./cluster_execution
+The scripts in this sub-directory were used to run all our experiments
+on the MPI-CBG cluster. All experiments were run via singularity. The 
+singularity image was built with `./cluster_exectuion/singularity/noise2seg.Singularity`. 
+
+### Build Singularity Container
+1. Install Singularity
+2. `sudo singularity build denoiseg.sim singularity/noise2seg.Singularity`
+
+### Run Singularity Container
+Now you can run a jupyter-server with this container:
+`singularity run --nv -B singularity/user:/run/user -B ./:/notebooks singularity/noise2seg.simg`
+
+### Run Singularity Headless
+1. Install PyInquirer
+2. `python3 run_noise2seg.py`
+
+For the headless to work you have to set following parameters in the file `run_noise2seg.py`:
+```
+singularity_path = "/projects/Noise2Seg/singularity/"
+base_dir = "/projects/Noise2Seg"
+gitrepo_path = join(base_dir, 'Noise2Seg')
+base_path_data = join(base_dir, "data")
+base_path_exp = join(base_dir, "experiments")
+```
+
+## ./dataprep
+This sub-directory contains all the jupyter notebooks which we used to
+prepare the training datasets. 
+
+## ./figures
+This sub-directory contains all the jupyter notebooks which we used to 
+create the figures. These notebooks use TeX to render the fonts. If you
+want to run them, make sure that you have TeX installed. 
+
+## ./tables
+This sub-directory contains all the jupyter notebooks which we used to
+create the tables.
\ No newline at end of file
diff --git a/compute_validationscores.py b/scripts/reproducibility/cluster_execution/compute_validationscores.py
similarity index 97%
rename from compute_validationscores.py
rename to scripts/reproducibility/cluster_execution/compute_validationscores.py
index 073580a..e82c91d 100644
--- a/compute_validationscores.py
+++ b/scripts/reproducibility/cluster_execution/compute_validationscores.py
@@ -98,7 +98,7 @@ def create_configs(config, run_name, seed, train_fraction):
 def start_score_evaluation_on_validation_experiment(temp_conf, exp_path, data_path):
     os.makedirs(exp_path, exist_ok=True)
 
-    copytree(join(gitrepo_path, 'noise2seg'), join(exp_path, 'noise2seg'))
+    copytree(join(gitrepo_path, 'denoiseg'), join(exp_path, 'denoiseg'))
     cp(join(gitrepo_path, 'validation_evaluation.py'), exp_path)
 
     with open(join(exp_path, 'temp.json'), 'w') as f:
@@ -130,7 +130,7 @@ def create_slurm_script(exp_path, data_path):
         "#SBATCH --export=ALL\n",
         "\n",
         "cd {}\n".format(singularity_path),
-        "srun -J N2S -o {}/validation_evaluation.log singularity exec --nv -B user/:/run/user -B {}:/notebooks -B {}:/data {} python3 /notebooks/validation_evaluation.py --temp_conf /notebooks/temp.json\n".format(exp_path, exp_path, data_path, singularity_path+"noise2seg.simg")
+        "srun -J N2S -o {}/validation_evaluation.log singularity exec --nv -B user/:/run/user -B {}:/notebooks -B {}:/data {} python3 /notebooks/validation_evaluation.py --temp_conf /notebooks/temp.json\n".format(exp_path, exp_path, data_path, singularity_path+"denoiseg.simg")
     ]
 
     return script
diff --git a/noise2seg.py b/scripts/reproducibility/cluster_execution/noise2seg.py
similarity index 84%
rename from noise2seg.py
rename to scripts/reproducibility/cluster_execution/noise2seg.py
index 47aa48e..ea5ed36 100644
--- a/noise2seg.py
+++ b/scripts/reproducibility/cluster_execution/noise2seg.py
@@ -1,4 +1,4 @@
-from noise2seg.models import Noise2Seg, Noise2SegConfig
+from denoiseg.models import DenoiSeg, DenoiSegConfig
 from skimage import io
 import csv
 import numpy as np
@@ -6,9 +6,9 @@
 import os
 from os.path import join, exists
 from os import makedirs as mkdir
-from noise2seg.utils.misc_utils import shuffle_train_data, augment_data
-from noise2seg.utils.seg_utils import *
-from noise2seg.utils.compute_precision_threshold import measure_precision, measure_seg
+from denoiseg.utils.misc_utils import shuffle_train_data, augment_data
+from denoiseg.utils.seg_utils import *
+from denoiseg.utils.compute_precision_threshold import measure_precision, measure_seg
 import argparse
 import json
 
@@ -61,21 +61,21 @@ def main():
     # create model
     train_steps_per_epoch = max(100, min(int(X.shape[0]/conf['train_batch_size']), 400))
     print("train_steps_per_epoch =", train_steps_per_epoch)
-    n2s_conf = Noise2SegConfig(X, unet_kern_size=3, n_channel_out=4, relative_weights = [1.0,1.0,5.0],
-                               train_steps_per_epoch=train_steps_per_epoch, train_epochs=conf['train_epochs'], train_loss='noise2seg', batch_norm=True,
-                               train_batch_size=conf['train_batch_size'], unet_n_first = 32, unet_n_depth=conf['unet_n_depth'],
-                               n2s_alpha=conf['n2s_alpha'],
-                               train_tensorboard=False,
-                               train_reduce_lr={"monitor" : conf['n2s_monitor'],
+    n2s_conf = DenoiSegConfig(X, unet_kern_size=3, n_channel_out=4, relative_weights = [1.0, 1.0, 5.0],
+                              train_steps_per_epoch=train_steps_per_epoch, train_epochs=conf['train_epochs'], train_loss='denoiseg', batch_norm=True,
+                              train_batch_size=conf['train_batch_size'], unet_n_first = 32, unet_n_depth=conf['unet_n_depth'],
+                              n2s_alpha=conf['n2s_alpha'],
+                              train_tensorboard=False,
+                              train_reduce_lr={"monitor" : conf['n2s_monitor'],
                                                 "patience" : 10,
                                                 "min_delta" : 0.00001,
                                                 "factor" : 0.75,
                                                 "min_lr" : 0.0000125
                                                   }
-                               )
+                              )
 
     vars(n2s_conf)
-    n2s_model = Noise2Seg(n2s_conf, conf['model_name'], conf['basedir'])
+    n2s_model = DenoiSeg(n2s_conf, conf['model_name'], conf['basedir'])
 
     # train
     history = n2s_model.train(X, Y, (X_val, Y_val))
@@ -83,7 +83,7 @@ def main():
         pickle.dump(history, p)
 
     # load model
-    n2s_model = Noise2Seg(None, conf['model_name'], conf['basedir'])
+    n2s_model = DenoiSeg(None, conf['model_name'], conf['basedir'])
 
     # compute AP results
     ap_threshold, validation_ap_score = n2s_model.optimize_thresholds(val_images, Y_val_masks, measure=measure_precision())
diff --git a/run_noise2seg.py b/scripts/reproducibility/cluster_execution/run_noise2seg.py
similarity index 94%
rename from run_noise2seg.py
rename to scripts/reproducibility/cluster_execution/run_noise2seg.py
index 3264901..3bd229f 100644
--- a/run_noise2seg.py
+++ b/scripts/reproducibility/cluster_execution/run_noise2seg.py
@@ -157,8 +157,8 @@ def create_configs(config, run_name, seed, train_fraction):
 def start_n2s_experiment(exp_conf, exp_path, data_path):
     os.makedirs(exp_path, exist_ok=True)
 
-    copytree(join(gitrepo_path, 'noise2seg'), join(exp_path, 'noise2seg'))
-    cp(join(gitrepo_path, 'noise2seg.py'), exp_path)
+    copytree(join(gitrepo_path, 'denoiseg'), join(exp_path, 'denoiseg'))
+    cp(join(gitrepo_path, 'denoiseg.py'), exp_path)
 
     with open(join(exp_path, 'experiment.json'), 'w') as f:
         json.dump(exp_conf, f)
@@ -188,7 +188,7 @@ def create_slurm_script(exp_path, data_path):
         "#SBATCH --export=ALL\n",
         "\n",
         "cd {}\n".format(singularity_path),
-        "srun -J N2S -o {}/noise2seg.log singularity exec --nv -B user/:/run/user -B {}:/notebooks -B {}:/data {} python3 /notebooks/noise2seg.py --exp_conf /notebooks/experiment.json\n".format(exp_path, exp_path, data_path, singularity_path+"noise2seg.simg")
+        "srun -J N2S -o {}/denoiseg.log singularity exec --nv -B user/:/run/user -B {}:/notebooks -B {}:/data {} python3 /notebooks/denoiseg.py --exp_conf /notebooks/experiment.json\n".format(exp_path, exp_path, data_path, singularity_path+"denoiseg.simg")
     ]
 
     return script
diff --git a/singularity/noise2seg.Singularity b/scripts/reproducibility/cluster_execution/singularity/noise2seg.Singularity
similarity index 100%
rename from singularity/noise2seg.Singularity
rename to scripts/reproducibility/cluster_execution/singularity/noise2seg.Singularity
diff --git a/validation_evaluation.py b/scripts/reproducibility/cluster_execution/validation_evaluation.py
similarity index 90%
rename from validation_evaluation.py
rename to scripts/reproducibility/cluster_execution/validation_evaluation.py
index 545fcf3..0c6db01 100644
--- a/validation_evaluation.py
+++ b/scripts/reproducibility/cluster_execution/validation_evaluation.py
@@ -1,4 +1,4 @@
-from noise2seg.models import Noise2Seg, Noise2SegConfig
+from denoiseg.models import DenoiSeg, DenoiSegConfig
 from skimage import io
 import csv
 import numpy as np
@@ -6,8 +6,8 @@
 import os
 from os.path import join, exists
 from os import makedirs as mkdir
-from noise2seg.utils.seg_utils import *
-from noise2seg.utils.compute_precision_threshold import measure_precision, measure_seg
+from denoiseg.utils.seg_utils import *
+from denoiseg.utils.compute_precision_threshold import measure_precision, measure_seg
 import argparse
 import json
 
@@ -40,7 +40,7 @@ def main():
 
     # load model
 
-    n2s_model = Noise2Seg(None, conf['model_name'], conf['basedir'])
+    n2s_model = DenoiSeg(None, conf['model_name'], conf['basedir'])
 
     # compute AP results
     ap_threshold, validation_ap_score = n2s_model.optimize_thresholds(val_images, Y_val_masks, measure=measure_precision())
diff --git a/DataPrep/DataPrep_flywing.ipynb b/scripts/reproducibility/dataprep/DataPrep_flywing.ipynb
similarity index 100%
rename from DataPrep/DataPrep_flywing.ipynb
rename to scripts/reproducibility/dataprep/DataPrep_flywing.ipynb
diff --git a/DataPrep/DataPrep_liver.ipynb b/scripts/reproducibility/dataprep/DataPrep_liver.ipynb
similarity index 100%
rename from DataPrep/DataPrep_liver.ipynb
rename to scripts/reproducibility/dataprep/DataPrep_liver.ipynb
diff --git a/figures/AP_n0_area.pdf b/scripts/reproducibility/figures/AP_n0_area.pdf
similarity index 100%
rename from figures/AP_n0_area.pdf
rename to scripts/reproducibility/figures/AP_n0_area.pdf
diff --git a/figures/AP_n0_area.svg b/scripts/reproducibility/figures/AP_n0_area.svg
similarity index 100%
rename from figures/AP_n0_area.svg
rename to scripts/reproducibility/figures/AP_n0_area.svg
diff --git a/figures/AP_n10_area.pdf b/scripts/reproducibility/figures/AP_n10_area.pdf
similarity index 100%
rename from figures/AP_n10_area.pdf
rename to scripts/reproducibility/figures/AP_n10_area.pdf
diff --git a/figures/AP_n10_area.svg b/scripts/reproducibility/figures/AP_n10_area.svg
similarity index 100%
rename from figures/AP_n10_area.svg
rename to scripts/reproducibility/figures/AP_n10_area.svg
diff --git a/figures/AP_n20_area.pdf b/scripts/reproducibility/figures/AP_n20_area.pdf
similarity index 100%
rename from figures/AP_n20_area.pdf
rename to scripts/reproducibility/figures/AP_n20_area.pdf
diff --git a/figures/AP_n20_area.svg b/scripts/reproducibility/figures/AP_n20_area.svg
similarity index 100%
rename from figures/AP_n20_area.svg
rename to scripts/reproducibility/figures/AP_n20_area.svg
diff --git a/figures/DSB_baseline_vs_vanillabaseline.pdf b/scripts/reproducibility/figures/DSB_baseline_vs_vanillabaseline.pdf
similarity index 100%
rename from figures/DSB_baseline_vs_vanillabaseline.pdf
rename to scripts/reproducibility/figures/DSB_baseline_vs_vanillabaseline.pdf
diff --git a/figures/DSB_baseline_vs_vanillabaseline.svg b/scripts/reproducibility/figures/DSB_baseline_vs_vanillabaseline.svg
similarity index 100%
rename from figures/DSB_baseline_vs_vanillabaseline.svg
rename to scripts/reproducibility/figures/DSB_baseline_vs_vanillabaseline.svg
diff --git a/figures/Flywing_AP_n0_area.pdf b/scripts/reproducibility/figures/Flywing_AP_n0_area.pdf
similarity index 100%
rename from figures/Flywing_AP_n0_area.pdf
rename to scripts/reproducibility/figures/Flywing_AP_n0_area.pdf
diff --git a/figures/Flywing_AP_n0_area.svg b/scripts/reproducibility/figures/Flywing_AP_n0_area.svg
similarity index 100%
rename from figures/Flywing_AP_n0_area.svg
rename to scripts/reproducibility/figures/Flywing_AP_n0_area.svg
diff --git a/figures/Flywing_AP_n10_area.pdf b/scripts/reproducibility/figures/Flywing_AP_n10_area.pdf
similarity index 100%
rename from figures/Flywing_AP_n10_area.pdf
rename to scripts/reproducibility/figures/Flywing_AP_n10_area.pdf
diff --git a/figures/Flywing_AP_n10_area.svg b/scripts/reproducibility/figures/Flywing_AP_n10_area.svg
similarity index 100%
rename from figures/Flywing_AP_n10_area.svg
rename to scripts/reproducibility/figures/Flywing_AP_n10_area.svg
diff --git a/figures/Flywing_AP_n20_area.pdf b/scripts/reproducibility/figures/Flywing_AP_n20_area.pdf
similarity index 100%
rename from figures/Flywing_AP_n20_area.pdf
rename to scripts/reproducibility/figures/Flywing_AP_n20_area.pdf
diff --git a/figures/Flywing_AP_n20_area.svg b/scripts/reproducibility/figures/Flywing_AP_n20_area.svg
similarity index 100%
rename from figures/Flywing_AP_n20_area.svg
rename to scripts/reproducibility/figures/Flywing_AP_n20_area.svg
diff --git a/figures/Flywing_Mouse_alpha_delta.pdf b/scripts/reproducibility/figures/Flywing_Mouse_alpha_delta.pdf
similarity index 100%
rename from figures/Flywing_Mouse_alpha_delta.pdf
rename to scripts/reproducibility/figures/Flywing_Mouse_alpha_delta.pdf
diff --git a/figures/Flywing_Mouse_alpha_delta.svg b/scripts/reproducibility/figures/Flywing_Mouse_alpha_delta.svg
similarity index 100%
rename from figures/Flywing_Mouse_alpha_delta.svg
rename to scripts/reproducibility/figures/Flywing_Mouse_alpha_delta.svg
diff --git a/figures/Flywing_SEG_n0_area.pdf b/scripts/reproducibility/figures/Flywing_SEG_n0_area.pdf
similarity index 100%
rename from figures/Flywing_SEG_n0_area.pdf
rename to scripts/reproducibility/figures/Flywing_SEG_n0_area.pdf
diff --git a/figures/Flywing_SEG_n0_area.svg b/scripts/reproducibility/figures/Flywing_SEG_n0_area.svg
similarity index 100%
rename from figures/Flywing_SEG_n0_area.svg
rename to scripts/reproducibility/figures/Flywing_SEG_n0_area.svg
diff --git a/figures/Flywing_SEG_n10_area.pdf b/scripts/reproducibility/figures/Flywing_SEG_n10_area.pdf
similarity index 100%
rename from figures/Flywing_SEG_n10_area.pdf
rename to scripts/reproducibility/figures/Flywing_SEG_n10_area.pdf
diff --git a/figures/Flywing_SEG_n10_area.svg b/scripts/reproducibility/figures/Flywing_SEG_n10_area.svg
similarity index 100%
rename from figures/Flywing_SEG_n10_area.svg
rename to scripts/reproducibility/figures/Flywing_SEG_n10_area.svg
diff --git a/figures/Flywing_SEG_n20_area.pdf b/scripts/reproducibility/figures/Flywing_SEG_n20_area.pdf
similarity index 100%
rename from figures/Flywing_SEG_n20_area.pdf
rename to scripts/reproducibility/figures/Flywing_SEG_n20_area.pdf
diff --git a/figures/Flywing_SEG_n20_area.svg b/scripts/reproducibility/figures/Flywing_SEG_n20_area.svg
similarity index 100%
rename from figures/Flywing_SEG_n20_area.svg
rename to scripts/reproducibility/figures/Flywing_SEG_n20_area.svg
diff --git a/figures/Manuscript-Figure AP n0.ipynb b/scripts/reproducibility/figures/Manuscript-Figure AP n0.ipynb
similarity index 100%
rename from figures/Manuscript-Figure AP n0.ipynb
rename to scripts/reproducibility/figures/Manuscript-Figure AP n0.ipynb
diff --git a/figures/Manuscript-Figure AP n10.ipynb b/scripts/reproducibility/figures/Manuscript-Figure AP n10.ipynb
similarity index 100%
rename from figures/Manuscript-Figure AP n10.ipynb
rename to scripts/reproducibility/figures/Manuscript-Figure AP n10.ipynb
diff --git a/figures/Manuscript-Figure AP n20.ipynb b/scripts/reproducibility/figures/Manuscript-Figure AP n20.ipynb
similarity index 100%
rename from figures/Manuscript-Figure AP n20.ipynb
rename to scripts/reproducibility/figures/Manuscript-Figure AP n20.ipynb
diff --git a/figures/Manuscript-Figure SEG n0.ipynb b/scripts/reproducibility/figures/Manuscript-Figure SEG n0.ipynb
similarity index 100%
rename from figures/Manuscript-Figure SEG n0.ipynb
rename to scripts/reproducibility/figures/Manuscript-Figure SEG n0.ipynb
diff --git a/figures/Manuscript-Figure SEG n10.ipynb b/scripts/reproducibility/figures/Manuscript-Figure SEG n10.ipynb
similarity index 100%
rename from figures/Manuscript-Figure SEG n10.ipynb
rename to scripts/reproducibility/figures/Manuscript-Figure SEG n10.ipynb
diff --git a/figures/Manuscript-Figure SEG n20.ipynb b/scripts/reproducibility/figures/Manuscript-Figure SEG n20.ipynb
similarity index 100%
rename from figures/Manuscript-Figure SEG n20.ipynb
rename to scripts/reproducibility/figures/Manuscript-Figure SEG n20.ipynb
diff --git a/figures/Manuscript-Figure_alphaDelta_noiseHelps.ipynb b/scripts/reproducibility/figures/Manuscript-Figure_alphaDelta_noiseHelps.ipynb
similarity index 100%
rename from figures/Manuscript-Figure_alphaDelta_noiseHelps.ipynb
rename to scripts/reproducibility/figures/Manuscript-Figure_alphaDelta_noiseHelps.ipynb
diff --git a/figures/Manuscript_Figure_Qualitative.ipynb b/scripts/reproducibility/figures/Manuscript_Figure_Qualitative.ipynb
similarity index 100%
rename from figures/Manuscript_Figure_Qualitative.ipynb
rename to scripts/reproducibility/figures/Manuscript_Figure_Qualitative.ipynb
diff --git a/figures/Mouse_AP_n0_area.pdf b/scripts/reproducibility/figures/Mouse_AP_n0_area.pdf
similarity index 100%
rename from figures/Mouse_AP_n0_area.pdf
rename to scripts/reproducibility/figures/Mouse_AP_n0_area.pdf
diff --git a/figures/Mouse_AP_n0_area.svg b/scripts/reproducibility/figures/Mouse_AP_n0_area.svg
similarity index 100%
rename from figures/Mouse_AP_n0_area.svg
rename to scripts/reproducibility/figures/Mouse_AP_n0_area.svg
diff --git a/figures/Mouse_AP_n10_area.pdf b/scripts/reproducibility/figures/Mouse_AP_n10_area.pdf
similarity index 100%
rename from figures/Mouse_AP_n10_area.pdf
rename to scripts/reproducibility/figures/Mouse_AP_n10_area.pdf
diff --git a/figures/Mouse_AP_n10_area.svg b/scripts/reproducibility/figures/Mouse_AP_n10_area.svg
similarity index 100%
rename from figures/Mouse_AP_n10_area.svg
rename to scripts/reproducibility/figures/Mouse_AP_n10_area.svg
diff --git a/figures/Mouse_AP_n20_area.pdf b/scripts/reproducibility/figures/Mouse_AP_n20_area.pdf
similarity index 100%
rename from figures/Mouse_AP_n20_area.pdf
rename to scripts/reproducibility/figures/Mouse_AP_n20_area.pdf
diff --git a/figures/Mouse_AP_n20_area.svg b/scripts/reproducibility/figures/Mouse_AP_n20_area.svg
similarity index 100%
rename from figures/Mouse_AP_n20_area.svg
rename to scripts/reproducibility/figures/Mouse_AP_n20_area.svg
diff --git a/figures/Mouse_SEG_n0_area.pdf b/scripts/reproducibility/figures/Mouse_SEG_n0_area.pdf
similarity index 100%
rename from figures/Mouse_SEG_n0_area.pdf
rename to scripts/reproducibility/figures/Mouse_SEG_n0_area.pdf
diff --git a/figures/Mouse_SEG_n0_area.svg b/scripts/reproducibility/figures/Mouse_SEG_n0_area.svg
similarity index 100%
rename from figures/Mouse_SEG_n0_area.svg
rename to scripts/reproducibility/figures/Mouse_SEG_n0_area.svg
diff --git a/figures/Mouse_SEG_n10_area.pdf b/scripts/reproducibility/figures/Mouse_SEG_n10_area.pdf
similarity index 100%
rename from figures/Mouse_SEG_n10_area.pdf
rename to scripts/reproducibility/figures/Mouse_SEG_n10_area.pdf
diff --git a/figures/Mouse_SEG_n10_area.svg b/scripts/reproducibility/figures/Mouse_SEG_n10_area.svg
similarity index 100%
rename from figures/Mouse_SEG_n10_area.svg
rename to scripts/reproducibility/figures/Mouse_SEG_n10_area.svg
diff --git a/figures/Mouse_SEG_n20_area.pdf b/scripts/reproducibility/figures/Mouse_SEG_n20_area.pdf
similarity index 100%
rename from figures/Mouse_SEG_n20_area.pdf
rename to scripts/reproducibility/figures/Mouse_SEG_n20_area.pdf
diff --git a/figures/Mouse_SEG_n20_area.svg b/scripts/reproducibility/figures/Mouse_SEG_n20_area.svg
similarity index 100%
rename from figures/Mouse_SEG_n20_area.svg
rename to scripts/reproducibility/figures/Mouse_SEG_n20_area.svg
diff --git a/figures/SEG_n0_area.pdf b/scripts/reproducibility/figures/SEG_n0_area.pdf
similarity index 100%
rename from figures/SEG_n0_area.pdf
rename to scripts/reproducibility/figures/SEG_n0_area.pdf
diff --git a/figures/SEG_n0_area.svg b/scripts/reproducibility/figures/SEG_n0_area.svg
similarity index 100%
rename from figures/SEG_n0_area.svg
rename to scripts/reproducibility/figures/SEG_n0_area.svg
diff --git a/figures/SEG_n10_area.pdf b/scripts/reproducibility/figures/SEG_n10_area.pdf
similarity index 100%
rename from figures/SEG_n10_area.pdf
rename to scripts/reproducibility/figures/SEG_n10_area.pdf
diff --git a/figures/SEG_n10_area.svg b/scripts/reproducibility/figures/SEG_n10_area.svg
similarity index 100%
rename from figures/SEG_n10_area.svg
rename to scripts/reproducibility/figures/SEG_n10_area.svg
diff --git a/figures/SEG_n20_area.pdf b/scripts/reproducibility/figures/SEG_n20_area.pdf
similarity index 100%
rename from figures/SEG_n20_area.pdf
rename to scripts/reproducibility/figures/SEG_n20_area.pdf
diff --git a/figures/SEG_n20_area.svg b/scripts/reproducibility/figures/SEG_n20_area.svg
similarity index 100%
rename from figures/SEG_n20_area.svg
rename to scripts/reproducibility/figures/SEG_n20_area.svg
diff --git a/figures/Supplement-Figure Flywing AP n0.ipynb b/scripts/reproducibility/figures/Supplement-Figure Flywing AP n0.ipynb
similarity index 100%
rename from figures/Supplement-Figure Flywing AP n0.ipynb
rename to scripts/reproducibility/figures/Supplement-Figure Flywing AP n0.ipynb
diff --git a/figures/Supplement-Figure Flywing AP n10.ipynb b/scripts/reproducibility/figures/Supplement-Figure Flywing AP n10.ipynb
similarity index 100%
rename from figures/Supplement-Figure Flywing AP n10.ipynb
rename to scripts/reproducibility/figures/Supplement-Figure Flywing AP n10.ipynb
diff --git a/figures/Supplement-Figure Flywing AP n20.ipynb b/scripts/reproducibility/figures/Supplement-Figure Flywing AP n20.ipynb
similarity index 100%
rename from figures/Supplement-Figure Flywing AP n20.ipynb
rename to scripts/reproducibility/figures/Supplement-Figure Flywing AP n20.ipynb
diff --git a/figures/Supplement-Figure Flywing SEG n0.ipynb b/scripts/reproducibility/figures/Supplement-Figure Flywing SEG n0.ipynb
similarity index 100%
rename from figures/Supplement-Figure Flywing SEG n0.ipynb
rename to scripts/reproducibility/figures/Supplement-Figure Flywing SEG n0.ipynb
diff --git a/figures/Supplement-Figure Flywing SEG n10.ipynb b/scripts/reproducibility/figures/Supplement-Figure Flywing SEG n10.ipynb
similarity index 100%
rename from figures/Supplement-Figure Flywing SEG n10.ipynb
rename to scripts/reproducibility/figures/Supplement-Figure Flywing SEG n10.ipynb
diff --git a/figures/Supplement-Figure Flywing SEG n20.ipynb b/scripts/reproducibility/figures/Supplement-Figure Flywing SEG n20.ipynb
similarity index 100%
rename from figures/Supplement-Figure Flywing SEG n20.ipynb
rename to scripts/reproducibility/figures/Supplement-Figure Flywing SEG n20.ipynb
diff --git a/figures/Supplement-Figure Mouse AP n0.ipynb b/scripts/reproducibility/figures/Supplement-Figure Mouse AP n0.ipynb
similarity index 100%
rename from figures/Supplement-Figure Mouse AP n0.ipynb
rename to scripts/reproducibility/figures/Supplement-Figure Mouse AP n0.ipynb
diff --git a/figures/Supplement-Figure Mouse AP n10.ipynb b/scripts/reproducibility/figures/Supplement-Figure Mouse AP n10.ipynb
similarity index 100%
rename from figures/Supplement-Figure Mouse AP n10.ipynb
rename to scripts/reproducibility/figures/Supplement-Figure Mouse AP n10.ipynb
diff --git a/figures/Supplement-Figure Mouse AP n20.ipynb b/scripts/reproducibility/figures/Supplement-Figure Mouse AP n20.ipynb
similarity index 100%
rename from figures/Supplement-Figure Mouse AP n20.ipynb
rename to scripts/reproducibility/figures/Supplement-Figure Mouse AP n20.ipynb
diff --git a/figures/Supplement-Figure Mouse SEG n0.ipynb b/scripts/reproducibility/figures/Supplement-Figure Mouse SEG n0.ipynb
similarity index 100%
rename from figures/Supplement-Figure Mouse SEG n0.ipynb
rename to scripts/reproducibility/figures/Supplement-Figure Mouse SEG n0.ipynb
diff --git a/figures/Supplement-Figure Mouse SEG n10.ipynb b/scripts/reproducibility/figures/Supplement-Figure Mouse SEG n10.ipynb
similarity index 100%
rename from figures/Supplement-Figure Mouse SEG n10.ipynb
rename to scripts/reproducibility/figures/Supplement-Figure Mouse SEG n10.ipynb
diff --git a/figures/Supplement-Figure Mouse SEG n20.ipynb b/scripts/reproducibility/figures/Supplement-Figure Mouse SEG n20.ipynb
similarity index 100%
rename from figures/Supplement-Figure Mouse SEG n20.ipynb
rename to scripts/reproducibility/figures/Supplement-Figure Mouse SEG n20.ipynb
diff --git a/figures/Supplement-Figure_DSB_Baseline_vs_VanillaBaseline.ipynb b/scripts/reproducibility/figures/Supplement-Figure_DSB_Baseline_vs_VanillaBaseline.ipynb
similarity index 100%
rename from figures/Supplement-Figure_DSB_Baseline_vs_VanillaBaseline.ipynb
rename to scripts/reproducibility/figures/Supplement-Figure_DSB_Baseline_vs_VanillaBaseline.ipynb
diff --git a/figures/Supplement-Figure_alphaDelta_Flywing_Mouse.ipynb b/scripts/reproducibility/figures/Supplement-Figure_alphaDelta_Flywing_Mouse.ipynb
similarity index 100%
rename from figures/Supplement-Figure_alphaDelta_Flywing_Mouse.ipynb
rename to scripts/reproducibility/figures/Supplement-Figure_alphaDelta_Flywing_Mouse.ipynb
diff --git a/figures/alpha_delta_and_additional_noise.pdf b/scripts/reproducibility/figures/alpha_delta_and_additional_noise.pdf
similarity index 100%
rename from figures/alpha_delta_and_additional_noise.pdf
rename to scripts/reproducibility/figures/alpha_delta_and_additional_noise.pdf
diff --git a/figures/alpha_delta_and_additional_noise.svg b/scripts/reproducibility/figures/alpha_delta_and_additional_noise.svg
similarity index 100%
rename from figures/alpha_delta_and_additional_noise.svg
rename to scripts/reproducibility/figures/alpha_delta_and_additional_noise.svg
diff --git a/figures/plot_utils.py b/scripts/reproducibility/figures/plot_utils.py
similarity index 100%
rename from figures/plot_utils.py
rename to scripts/reproducibility/figures/plot_utils.py
diff --git a/tables/Table_DSB.ipynb b/scripts/reproducibility/tables/Table_DSB.ipynb
similarity index 100%
rename from tables/Table_DSB.ipynb
rename to scripts/reproducibility/tables/Table_DSB.ipynb
diff --git a/tables/Table_Flywing.ipynb b/scripts/reproducibility/tables/Table_Flywing.ipynb
similarity index 100%
rename from tables/Table_Flywing.ipynb
rename to scripts/reproducibility/tables/Table_Flywing.ipynb
diff --git a/tables/Table_Mouse.ipynb b/scripts/reproducibility/tables/Table_Mouse.ipynb
similarity index 100%
rename from tables/Table_Mouse.ipynb
rename to scripts/reproducibility/tables/Table_Mouse.ipynb
diff --git a/tables/Table_denoising.ipynb b/scripts/reproducibility/tables/Table_denoising.ipynb
similarity index 100%
rename from tables/Table_denoising.ipynb
rename to scripts/reproducibility/tables/Table_denoising.ipynb
diff --git a/tables/Wiki_Table_denoising.ipynb b/scripts/reproducibility/tables/Wiki_Table_denoising.ipynb
similarity index 100%
rename from tables/Wiki_Table_denoising.ipynb
rename to scripts/reproducibility/tables/Wiki_Table_denoising.ipynb
diff --git a/setup.py b/setup.py
index 458dc4a..3379a23 100755
--- a/setup.py
+++ b/setup.py
@@ -4,26 +4,26 @@
 
 _dir = path.abspath(path.dirname(__file__))
 
-with open(path.join(_dir,'noise2seg','version.py')) as f:
+with open(path.join(_dir,'denoiseg','version.py')) as f:
     exec(f.read())
 
 with open(path.join(_dir,'README.md')) as f:
     long_description = f.read()
 
 
-setup(name='noise2seg',
+setup(name='denoiseg',
       version=__version__,
-      description='Noise2Seg',
+      description='DenoiSeg',
       long_description=long_description,
       long_description_content_type='text/markdown',
-      url='https://github.com/juglab/Noise2Seg/',
-      author='Mangal Prakash, Tim-Oliver Buchholz',
-      author_email='prakash@mpi-cbg.de, tibuch@mpi-cbg.de',
+      url='https://github.com/juglab/DenoiSeg/',
+      author='Tim-Oliver Buchholz, Mangal Prakash, Alexander Krull, Florian Jug',
+      author_email='tibuch@mpi-cbg.de, prakash@mpi-cbg.de, krull@mpi-cbg.de, jug@mpi-cbg.de',
       license='BSD 3-Clause License',
       packages=find_packages(),
 
       project_urls={
-          'Repository': 'https://github.com/juglab/Noise2Seg/',
+          'Repository': 'https://github.com/juglab/DenoiSeg/',
       },
 
       classifiers=[