From 9849cf446a210531755b7c265ebe4a4e9e22300b Mon Sep 17 00:00:00 2001
From: Natalia Shepeleva <natalia.shepeleva@scch.at>
Date: Tue, 26 Feb 2019 15:57:05 +0100
Subject: [PATCH] First code commit

---
 README.md                                     |  38 +-
 configs/config.py                             | 102 +++
 configs/config_ConvNet.py                     |  63 ++
 data_standardization/README.md                |  20 +
 .../json/json_standardization.md              | 113 ++++
 .../txt/txt_standardization.md                |  41 ++
 main.py                                       |  47 ++
 network/InferenceRunner.py                    | 274 ++++++++
 network/NetRunner.py                          | 354 +++++++++++
 network/TrainRunner.py                        | 307 +++++++++
 network/__init__.py                           |  15 +
 network/wrappers/ConvNet.py                   |  90 +++
 network/wrappers/NetworkBase.py               | 366 +++++++++++
 network/wrappers/UNet.py                      | 129 ++++
 network/wrappers/__init__.py                  |  15 +
 requirments.txt                               |  10 +
 utils/BatchIterator.py                        | 257 ++++++++
 utils/DataParser.py                           | 588 ++++++++++++++++++
 utils/__init__.py                             |  15 +
 utils/gradcam/GradCAM.py                      | 169 +++++
 utils/gradcam/__init__.py                     |   0
 utils/gradcam/readme.md                       |  19 +
 utils/utils.py                                | 111 ++++
 23 files changed, 3142 insertions(+), 1 deletion(-)
 create mode 100644 configs/config.py
 create mode 100644 configs/config_ConvNet.py
 create mode 100644 data_standardization/README.md
 create mode 100644 data_standardization/json/json_standardization.md
 create mode 100644 data_standardization/txt/txt_standardization.md
 create mode 100644 main.py
 create mode 100644 network/InferenceRunner.py
 create mode 100644 network/NetRunner.py
 create mode 100644 network/TrainRunner.py
 create mode 100644 network/__init__.py
 create mode 100644 network/wrappers/ConvNet.py
 create mode 100644 network/wrappers/NetworkBase.py
 create mode 100644 network/wrappers/UNet.py
 create mode 100644 network/wrappers/__init__.py
 create mode 100644 requirments.txt
 create mode 100644 utils/BatchIterator.py
 create mode 100644 utils/DataParser.py
 create mode 100644 utils/__init__.py
 create mode 100644 utils/gradcam/GradCAM.py
 create mode 100644 utils/gradcam/__init__.py
 create mode 100644 utils/gradcam/readme.md
 create mode 100644 utils/utils.py

diff --git a/README.md b/README.md
index e442c9e..930f475 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,37 @@
-# training-engine
\ No newline at end of file
+# ALOHA Training Engine
+
+This is stand-alone Training Engine module  ALOHA.eu project. http://aloha-h2020.eu
+
+## Setup
+Training Engine was developed using Python 3.6, TensorFlow 1.12, PyTorch 1.0 and was tested under Windows 10
+
+``pip install -r requirements.txt``
+
+## Data Standardization
+Data standardization description described in [data_standardization](data_standardization)
+
+## Architecture deployment
+to be added
+
+## Training Configuration
+to be added
+
+
+## Supported Features
+- [x] training/inference TensorFlow support
+- [x] classification task support
+- [x] segmentation task support
+
+## In development:
+- [ ] training/inference PyTorch support
+- [ ] detection task support
+- [ ] tracking task support
+- [ ] GAN architecture support
+- [ ] hyperparameter optimization
+- [ ] fast/full training mode
+- [ ] accuracy prediction metric
+- [ ] transfer leraning support
+
+
+# Acknowledgements
+This work was carried out by the European Union\`s Horizon H2020 Research and Innovation programme under grant agreement No. 780788
diff --git a/configs/config.py b/configs/config.py
new file mode 100644
index 0000000..e5de37c
--- /dev/null
+++ b/configs/config.py
@@ -0,0 +1,102 @@
+#!/usr/bin/env python
+# -----------------------------------------------------------------------------
+# Copyright (C) Software Competence Center Hagenberg GmbH (SCCH)
+# All rights reserved.
+# -----------------------------------------------------------------------------
+# This document contains proprietary information belonging to SCCH.
+# Passing on and copying of this document, use and communication of its
+# contents is not permitted without prior written authorization.
+# -----------------------------------------------------------------------------
+# Created on : 11/16/2017 11:07 $
+# by : shepeleva $
+# SVN : $
+#
+
+# --- imports -----------------------------------------------------------------
+
+import argparse
+
+
+class ConfigFlags:
+    def __init__(self):
+        """
+
+        """
+        parser = argparse.ArgumentParser(description='Tensorflow DL training pipeline')
+        # mandatory variables
+        parser.add_argument('--net', help='Network',
+                            type=str, default='ConvNet')
+        parser.add_argument('--mode', help='training / test',
+                            type=str, default='training')
+        parser.add_argument('--data_set', help='Name/ID of the used data set',
+                            type=str, default='MNIST')
+        parser.add_argument('--data_dir', help='Learning data directory',
+                            type=str, default='')
+        parser.add_argument('--data_file', help='Data file',
+                            type=str)
+        parser.add_argument('--checkpoint_dir', help='Checkpoint directory',
+                            type=str, default='ckpnt_dir')
+        parser.add_argument('--trainlog_dir', help='Train records directory',
+                            type=str, default='tr_log')
+        parser.add_argument('--lr', help='Learning rate',
+                            type=float, default=0.001)
+        parser.add_argument('--lr_decay', help='Learning rate decay rate',
+                            type=float, default=0.0005)
+        parser.add_argument('--ref_steps', help='Refinement Steps',
+                            type=int, default=5)
+        parser.add_argument('--ref_patience', help='Refinement Patience',
+                            type=int, default=200)
+        parser.add_argument('--batch_size', help='Batch size',
+                            type=int, default=32)
+        parser.add_argument('--num_epochs', help='Number of epochs',
+                            type=int, default=100)
+        parser.add_argument('--loss', help='Loss function',
+                            type=str, default='mse')
+        parser.add_argument('--optimizer', help='Optimizers: \n\t adam - adam optimizer '
+                                                '\n\t gradient - gradient descent '
+                                                '\n\t proximalgrad - proximal gradient descent ',
+                            default='adam')
+        parser.add_argument('--dropout', help='Dropout Rate to use',
+                            type=float, default=0.25)
+        parser.add_argument('--tb_record', help='Tensorboard records on/off',
+                            type=bool, default=True)
+        parser.add_argument('--darkon_record', help='Darkon tool',
+                            type=bool, default=False)
+        parser.add_argument('--gradcam_record', help='GradCam tool',
+                            type=bool, default=False)
+        parser.add_argument('--gradcam_layers', help='Number of inspected convolution layers',
+                            type=int, default=1)
+        parser.add_argument('--gradcam_layers_max', help='Number of convolution layers',
+                            type=int, default=3)
+        parser.add_argument('--mi_record', help='MI tool',
+                            type=bool, default=False)
+        parser.add_argument('--gpu_load', help='GPU load percentage [0.1 : 1]',
+                            type=int, default=0.8)
+        # optional variables
+        parser.add_argument('--image_size', help='Image size',
+                            type=list, default=[128, 128, 1])
+        parser.add_argument('--num_classes', help='Number of labels',
+                            type=int, default=2)
+        parser.add_argument('--num_filters', help='Number of filters',
+                            type=int)
+        # todo actually implement following parameters in NetRunner
+        parser.add_argument('--filter_size', help='Filter size',
+                            type=int)
+        parser.add_argument('--pool_size', help='Pool size',
+                            type=int)
+        parser.add_argument('--stride_size', help='stride size',
+                            type=int)
+        parser.add_argument('--nonlin', help='Nonlinearity',
+                            type=str)
+        parser.add_argument('--upconv', help='Up convolution type: upconv or upsampling',
+                            type=str)
+        parser.add_argument('--multi_task', help="multiple task, i.e. different loss functions",
+                            type=bool)
+        self.args = parser.parse_args()
+
+    def return_flags(self):
+        """
+
+        :return:
+        """
+        return self.args
diff --git a/configs/config_ConvNet.py b/configs/config_ConvNet.py
new file mode 100644
index 0000000..a298b6c
--- /dev/null
+++ b/configs/config_ConvNet.py
@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+# -----------------------------------------------------------------------------
+# Copyright (C) Software Competence Center Hagenberg GmbH (SCCH)
+# All rights reserved.
+# -----------------------------------------------------------------------------
+# This document contains proprietary information belonging to SCCH.
+# Passing on and copying of this document, use and communication of its
+# contents is not permitted without prior written authorization.
+# -----------------------------------------------------------------------------
+# Created on : 01/08/2018 16:29 $
+# by : shepeleva $
+# SVN : $
+#
+
+# --- imports -----------------------------------------------------------------
+
+from configs.config import ConfigFlags
+
+
+def load_config():
+    config = ConfigFlags().return_flags()
+
+    config.net = 'ConvNet'
+    config.training_mode = False
+    config.data_set = 'MNIST'
+    config.image_size = [28, 28, 1]
+
+    config.lr = 0.001
+    config.lr_decay = 0.1
+    config.ref_steps = 10
+    config.ref_patience = 1
+    config.batch_size = 32
+    config.num_epochs = 1000
+    config.loss = 'mse'
+    config.optimizer = 'adam'
+    config.gradcam_record = True
+    config.gradcam_layers = 6
+    config.gradcam_layers_max = 6
+    config.mi_record = False
+    config.gpu_load = 0.8
+    config.num_classes = 10
+    config.class_labels = [i for i in range(9)]
+    config.num_filters = 16
+    config.upconv = 'upconv'
+    config.nonlin = 'relu'
+    config.task_type = 'classification'
+    config.accuracy = 'mse'
+    config.augmentation = {'flip_hor': False,
+                           'flip_vert': False}
+    config.data_split = 0.7
+    config.long_summary = True
+    config.trainable_layers = 'all'
+    config.normalize = True
+    config.zero_center = True
+    config.dropout = 0.4
+    config.chpnt2load = ''
+    config.multi_task = False
+    config.cross_val = 1
+    config.framework = 'tensorflow'
+    config.experiment_path = None
+
+
+    return config
\ No newline at end of file
diff --git a/data_standardization/README.md b/data_standardization/README.md
new file mode 100644
index 0000000..e52af3c
--- /dev/null
+++ b/data_standardization/README.md
@@ -0,0 +1,20 @@
+# data_standardization
+
+Description of custom dataset representation accepted by ALOHA tool
+
+Current support of data input into ALOHA tool is following:
+- by picking `dataset`
+    >allowed entries: MNIST, CIFAR10, CIFAR100, <custom>
+
+    if `<custom>` is picked, user have two options:
+    - from `data_file`
+
+        > supported file formats: JSON, TXT
+
+    - from `data_folder`
+
+        > multiple file loading for classification and segmentation case
+
+For more detailed description check corresponding folder
+
+##### Important. Description provided in standardization files are not yet final. Changes my apply during development phase.
diff --git a/data_standardization/json/json_standardization.md b/data_standardization/json/json_standardization.md
new file mode 100644
index 0000000..e817fcc
--- /dev/null
+++ b/data_standardization/json/json_standardization.md
@@ -0,0 +1,113 @@
+# JSON format standardization
+
+## General information
+Rules on dataset description on JSON format.
+This representation supports 3 task scenarios:
+- Classification
+- Segmentation
+- Detection
+- *In development: Traking, Multi-task*
+
+This standardization describes following input cases:
+- IC1: single folder with images
+- IC2: multiple folders with images
+- IC3: single video
+- IC4: multiple videos
+
+## Data loading to ALOHA toolflow
+By using JSON format standardization, please, use parameter `data_file` in the configuration and pick JSON file, which describes your dataset.
+
+Please, be aware that all source locations in the JSON format standardization should contain ABSOLUTE path.
+
+
+## Detailed standardization description
+The standardization should be described as a dictionary of `<key>: <value>` pairs.
+
+Allowed list of `key` values:
+
+- `name` - dataset name
+    >str value, describes dataset name, Ex.: 'random_set'
+- `width` - width of the frame/image
+    >set value only if all frames/images of the same size, otherwise put 0
+- `height` - height of the frame/image
+    >set value only if all frames/images of the same size, otherwise put 0
+- `source` - source of the information (`video` or `image`)
+    >describes which source will be used, avaliable values:  `video` or `image`
+- `source_path` - absolute path to the source
+    >absolute or relative to the .json file path to the data source
+- `mask_path` - absolute path to masks if presented
+    >absolute or relative to the .json file path to the masks (only for Segmentation task)
+- `data_size` - number of frames per video / number of images in dataset
+    >depending on IC representaiton this value coud difer use following example: <br>
+    for IC1 or IC3: 2340 - means that dataset represented by one folder with 2340 images in total OR by one video with 2340 frames in total<br>
+    for IC2 or IC4: [345, 654, 123] - means that dataset represented by 3 folders with 345, 654 and 123 images accordingly OR by 3 videos with 345, 654 and 123 frames accordingly
+- `meta`- detailed information for specific task
+    >in this section every frame/image should get detailed description accordingly to the task
+
+###  `meta` for Classification
+List of following dictionaries:
+- `frame` - frame/image id
+    >for IC1: image_name<br>
+    for IC2: [image_folder, image]<br>
+    for IC3: frame_id<br>
+    for IC4: [video_file_name, frame_id]
+- `width`
+    >width of particular frame, if global width is not setted up
+- `height`
+    >height of particular frame, if global height is not setted up
+- `mask` - mask presence
+    >for this task should be equal to null
+- `objects` - list of the descriptions of objects which should be classified in current frame
+    - `object_class` - object class indentification
+      >integer or one-hot labeling
+    - `bb` - bounding box
+      >for this task should be equal to null
+    - `polygon` - polygon area
+      >for this task should be equal to null
+
+###  `meta` for Segmentation
+List of following dictionaries:
+- `frame` - frame/image id
+    >for IC1: image_name<br>
+    for IC2: [image_folder, image]<br>
+    for IC3: frame_id<br>
+    for IC4: [video_file_name, frame_id]
+- `width`
+    >width of particular frame, if global width is not setted up
+- `height`
+    >height of particular frame, if global height is not setted up
+- `mask`- mask presence, video/image representation might be independent from frame representaiton
+    >for IC1: image_name<br>
+    for IC2: [image_folder, image]<br>
+    for IC3: frame_id<br>
+    for IC4: [video_file_name, frame_id]
+- `objects` - list of the descriptions of objects which should be classified in current frame
+    - `object_class` - object class indentification
+      >integer or one-hot labeling
+    - `bb` - bounding box
+      >for this task should be equal to null
+    - `polygon` - polygon area
+      >list of points describing polygon
+
+### `meta` for Detection
+List of following dictionaries:
+- `frame` - frame/image id
+    >for IC1: image_name<br>
+    for IC2: [image_folder, image]<br>
+    for IC3: frame_id<br>
+    for IC4: [video_file_name, frame_id]
+- `width`
+    >width of particular frame, if global width is not setted up
+- `height`
+    >height of particular frame, if global height is not setted up
+- `mask` - mask presence
+    >for this task should be equal to null
+- `objects` - list of the descriptions of objects which should be classified in current frame
+    - `object_class` - object class indentification
+      >integer or one-hot labeling
+    - `bb` - object boundaries
+      >should be described as [Xmin, Ymin, Xmax, Ymax], where<br>
+      (Xmin, Ymin) pair specifying the lower-left corner<br>
+      (Xmax, Ymax) pair specifying the upper-right corner
+    - `polygon` - polygon area
+      >list of points describing polygon
diff --git a/data_standardization/txt/txt_standardization.md b/data_standardization/txt/txt_standardization.md
new file mode 100644
index 0000000..3c1dc51
--- /dev/null
+++ b/data_standardization/txt/txt_standardization.md
@@ -0,0 +1,41 @@
+# TXT format standardization
+
+## General information
+Rules on dataset description on TXT format.
+This representation supports 2 task scenarios:
+- Classification
+- Segmentation
+- Detection
+- *In development: Traking, Multi-task*
+
+This standardization describes following input cases:
+- IC1: single TXT file
+
+## Data loading to ALOHA toolflow
+- IC1 case: please, use parameter `data_file` in the configuration and pick TXT file, which describes your dataset.
+
+Please, be aware that all source locations in the TXT format standardization should contain ABSOLUTE path.
+
+## Detailed standardization description
+The standardization should be described as a list of paticular fileds separated by space depending on the task.
+
+### Classification
+File structure: `<image_file> <label>`
+- `image_file` - absolute path to the image
+- `label` - label description, integer or one-hot encoded
+  >for integer description the count start from 0
+
+### Segmentaiton
+File structure: `<image_file> <mask_file>`
+- `image_file` - absolute path to the image
+- `mask_file` -  absolute path to the corresponding mask
+  >segmentation areas should be setted to the integer values starting from 1 (0 - backgound) for a required number of classes in dataset
+
+### Detection
+File structure: `<image_file> <bounding_box>`
+- `image_file` - absolute path to the image
+- `bounding_box` - object boundaries
+  >should be described as [Xmin, Ymin, Xmax, Ymax], where
+  (Xmin, Ymin) pair specifying the lower-left corner<br>
+  (Xmax, Ymax) pair specifying the upper-right corner<br>
+  for more than one object should be represented as list if lists
diff --git a/main.py b/main.py
new file mode 100644
index 0000000..1111911
--- /dev/null
+++ b/main.py
@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+# -----------------------------------------------------------------------------
+# Copyright (C) Software Competence Center Hagenberg GmbH (SCCH)
+# All rights reserved.
+# -----------------------------------------------------------------------------
+# This document contains proprietary information belonging to SCCH.
+# Passing on and copying of this document, use and communication of its
+# contents is not permitted without prior written authorization.
+# -----------------------------------------------------------------------------
+# Created on : 2/20/2019 1:02 PM $ 
+# by : shepeleva $ 
+# SVN  $
+#
+
+# --- imports -----------------------------------------------------------------
+
+import sys
+import importlib
+
+from network.TrainRunner import TrainRunner
+from network.InferenceRunner import InferenceRunner
+
+EXPERIMENT_ID = 'ToyNet'
+
+
+def run(experiment_id):
+    config = importlib.import_module('configs.config_' + experiment_id)
+    args = config.load_config()
+    if args.training_mode:
+        training = TrainRunner(experiment_id=experiment_id)
+        training.start_training()
+    else:
+        inference = InferenceRunner(experiment_id=experiment_id)
+        inference.start_inference()
+        raise ValueError('Inference not implemented yet')
+
+
+if __name__ == '__main__':
+    print(len(sys.argv))
+    print(sys.argv)
+    if len(sys.argv) != 3:
+        print('You are doing something wrong! We will show you ToyNet')
+        experiment = EXPERIMENT_ID
+    else:
+        experiment = sys.argv[2]
+        print('Running {}'.format(experiment))
+    run(experiment)
diff --git a/network/InferenceRunner.py b/network/InferenceRunner.py
new file mode 100644
index 0000000..1e54d7f
--- /dev/null
+++ b/network/InferenceRunner.py
@@ -0,0 +1,274 @@
+#!/usr/bin/env python
+# -----------------------------------------------------------------------------
+# Copyright (C) Software Competence Center Hagenberg GmbH (SCCH)
+# All rights reserved.
+# -----------------------------------------------------------------------------
+# This document contains proprietary information belonging to SCCH.
+# Passing on and copying of this document, use and communication of its
+# contents is not permitted without prior written authorization.
+# -----------------------------------------------------------------------------
+# Created on : 2/25/2019 3:41 PM $ 
+# by : shepeleva $ 
+# SVN  $
+#
+
+# --- imports -----------------------------------------------------------------
+
+import os
+import time
+from tqdm import tqdm
+
+import h5py
+import numpy as np
+import tensorflow as tf
+import matplotlib.pyplot as plt
+
+import itertools
+from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
+
+from network.NetRunner import NetRunner
+from utils.BatchIterator import BatchIterator
+from utils.gradcam.GradCAM import grad_cam_plus_plus as gradcam
+from utils.gradcam.GradCAM import save_gradcam_data as save_gradcam
+
+class InferenceRunner(NetRunner):
+    def __init__(self, args=None, experiment_id=None):
+        super().__init__(args, experiment_id)
+
+    def start_inference(self):
+        self._initialize_inference()
+
+    def _initialize_inference(self):
+        if self.framework is 'tensorflow':
+            self._run_tensorflow_pipeline()
+        elif self.framework is 'pytorch':
+            self._run_pytorch_pipeline()
+        else:
+            raise ValueError('Framework is not supported')
+
+    def _run_tensorflow_pipeline(self):
+        tf.reset_default_graph()
+        if self.chpnt2load:
+            try:
+                latest_ckpt = tf.train.latest_checkpoint(self.chpnt2load)
+            except:
+                raise ValueError('Mo such checkpoint is found ' + self.chpnt2load)
+        else:
+            raise ValueError("No checkpoint provided")
+            # model_file_path = os.path.join('experiments', 'ckpnt_logs', self.data_set, self.timestamp,
+            #                                self.timestamp + '_split_' + str(split))
+
+        saver = tf.train.import_meta_graph(latest_ckpt + '.meta')
+        graph = tf.get_default_graph()
+        if self.gpu_load != 0:
+            gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=self.gpu_load)
+            config = tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False)
+            config.gpu_options.allow_growth = True
+        else:
+            os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
+            config = tf.ConfigProto(device_count={'CPU': 1})
+
+        # h5_file = h5py.File(self.h5_data_file, 'r')
+
+        with tf.Session(graph=graph, config=config) as sess:
+            saver.restore(sess, latest_ckpt)
+
+            X = tf.get_collection("inputs_train")[0]
+            pred = tf.get_collection("outputs_train")[0]
+            mode = tf.get_collection_ref("mode_train")[0]
+            y_true = tf.get_collection("y_true")
+            if self.gradcam_record:
+                y_true = tf.get_collection("y_true")[0]
+                gradcam_in_data = tf.get_collection("gradcam_in_data")[0]
+                gradcam_gb_grads = tf.get_collection("gradcam_gb_grads")[0]
+                gradcam_conv_outs = []
+                gradcam_first_derivatives = []
+                gradcam_second_derivatives = []
+                gradcam_third_derivatives = []
+                for i in range(self.gradcam_layers):
+                    gradcam_conv_outs.append(tf.get_collection("gradcam_conv_outs_{}".format(i))[0])
+                    gradcam_first_derivatives.append(tf.get_collection("gradcam_first_derivatives_{}".format(i))[0])
+                    gradcam_second_derivatives.append(tf.get_collection("gradcam_second_derivatives_{}".format(i))[0])
+                    gradcam_third_derivatives.append(tf.get_collection("gradcam_third_derivatives_{}".format(i))[0])
+                gradcam_op = [gradcam_in_data, gradcam_gb_grads, gradcam_conv_outs, gradcam_first_derivatives,
+                              gradcam_second_derivatives, gradcam_third_derivatives]
+            pred_result = []
+            gradcam_results = []
+
+            # test_generator = BatchIterator(h5_file, 'test', self.img_size, self.num_classes, 1, self.task_type)
+            # test_lim = test_generator.get_max_lim()
+
+            count = 0
+            for i in tqdm(len(self.inference_X), total=len(self.inference_X), unit=' steps', desc='Inference'):
+                start_time = time.time()
+                ff = list(i)
+                if self.task_type == 'classification':
+                    pred_result_ = sess.run(pred, feed_dict={
+                        X: [np.reshape(f[0], [self.img_size[0], self.img_size[1], self.img_size[2]]) for f
+                            in ff], mode: False})
+                    pred_result.extend(pred_result_)
+                    # Calculate Grad-CAM parameters
+                    if self.gradcam_record:
+                        gradcam_params = sess.run(gradcam_op, feed_dict={
+                            X: [np.reshape(f[0], [self.img_size[0], self.img_size[1], self.img_size[2]]) for f
+                                in ff], mode: False, y_true: pred_result_})
+                        pred_result.extend(pred_result_)
+                        gradcam_results_ = []
+                        # Run Grad-CAM
+                        for cl in range(self.gradcam_layers):
+                            gradcam_results_.append((gradcam(gradcam_params, cl), gradcam_params[0]))
+                        count = count + 1
+                        # Save Grad-CAM results
+                        save_gradcam(gradcam_results_, self.data_dir, count, self.gradcam_layers_max)
+                    #     pred_result = sess.run(pred, feed_dict={X: [np.reshape(f[0], [self.img_size[0], self.img_size[1], self.img_size[2]]) for f
+                    #                         in ff], mode: False})
+                elif self.task_type == 'segmentation':
+                    # if self.y:
+                    for fr in ff:
+                        # <<<<<<< .mine
+                        # mask_pred = sess.run(pred, feed_dict={X: np.reshape(fr[0], [1, self.img_size[0], self.img_size[1], self.img_size[2]]), mode: False})
+                        # mask = tf.nn.sigmoid(mask_pred).eval()
+                        # m_r = np.argmax(mask, axis=3)
+                        # f, (ax1, ax2) = plt.subplots(1, 2)
+                        # # f_r = np.argmax(fr[1], axis=2)
+                        # ax2.imshow(fr[0])
+                        # ax1.imshow(np.reshape(m_r, [self.img_size[0], self.img_size[1]]))
+                        # # ax1.imshow(np.reshape(f_r, [self.img_size[0], self.img_size[1]]))
+                        # f.savefig(os.path.join(self.data_dir, 'results', str(count) + '_.png'))  # save the figure to file
+                        # plt.close(f)
+                        # plt.show()
+
+                        #                         mask_pred = sess.run(pred, feed_dict={X: np.reshape(fr[0], [1, self.img_size[0], self.img_size[1], self.img_size[2]]), mode: False})
+                        # ||||||| .r165
+                        mask_pred = sess.run(pred, feed_dict={
+                            X: np.reshape(fr[0], [1, self.img_size[0], self.img_size[1], self.img_size[2]]),
+                            mode: False})
+                        # =======
+                        #                         mask_pred, gradcam_params_ = sess.run([pred, gradcam_op], feed_dict={X: np.reshape(fr[0], [1, self.img_size[0], self.img_size[1], self.img_size[2]]), mode: False})
+                        # >>>>>>> .r281
+                        #                         mask = tf.nn.sigmoid(mask_pred).eval()
+                        #                         m_r = np.argmax(mask, axis=3)
+                        #                         f, (ax1, ax2, ax3) = plt.subplots(1, 3)
+                        #                         f_r = np.argmax(fr[1], axis=2)
+                        #                         ax3.imshow(fr[0])
+                        #                         ax3.set(xlabel='original mask')
+                        #                         ax2.imshow(np.reshape(m_r, [self.img_size[0], self.img_size[1]]))
+                        #                         ax2.set(xlabel='generated segmentation')
+                        #                         ax1.imshow(np.reshape(f_r, [self.img_size[0], self.img_size[1]]))
+                        #                         ax1.set(xlabel='original image')
+                        #                         f.savefig(os.path.join(self.data_dir, 'results', str(count) + '_.png'))  # save the figure to file
+                        #                         plt.close(f)
+
+                        # mask = tf.nn.sigmoid(mask_pred).eval()
+                        # m_r = np.argmax(mask, axis=3)
+                        # f, (ax1, ax2, ax3) = plt.subplots(1, 3)
+                        # # f_r = np.argmax(fr[1], axis=2)
+                        # ax3.imshow(fr[0])
+                        # ax3.set(xlabel='original mask')
+                        # ax2.imshow(np.reshape(m_r, [self.img_size[0], self.img_size[1]]))
+                        # # ax2.set(xlabel='generated segmentation')
+                        # # ax1.imshow(np.reshape(f_r, [self.img_size[0], self.img_size[1]]))
+                        # ax1.set(xlabel='original image')
+                        # f.savefig(os.path.join(self.data_dir, 'results', str(count) + '_.png'))  # save the figure to file
+                        # plt.close(f)
+
+                        mask = tf.nn.sigmoid(mask_pred).eval()
+                        m_r = np.argmax(mask, axis=3)
+                        f, (ax1, ax2) = plt.subplots(1, 2)
+                        # f_r = np.argmax(fr[1], axis=2)
+
+                        ax2.imshow(np.reshape(m_r, [self.img_size[0], self.img_size[1]]))
+                        ax2.set(xlabel='generated segmentation')
+                        ax1.imshow(np.reshape(fr[0], [self.img_size[0], self.img_size[1]]))
+                        ax1.set(xlabel='original image')
+                        f.savefig(os.path.join(self.data_dir, 'results', str(count) + '_.png'), figsize=(24, 18),
+                                  dpi=600)  # save the figure to file
+                        plt.close(f)
+
+                        count = count + 1
+
+            if self.task_type == 'classification':
+
+                if self.loss_type == 'mse':
+                    m = 0
+                    y_pred = np.array(pred_result)
+                    y_true = np.array(h5_file['lbl_test'][:])
+                    for i in range(0, len(y_pred)):
+                        mse_test = np.sqrt(np.sum(((y_true[i] - y_pred[i]) ** 2) / 2))
+                        # mse_test = sess.run(mse_loss(y_true[i], y_pred[i]))
+                        m += mse_test
+                        print("Prediction: {} GT: {} Score {}%".format(str(y_pred[i]), str(y_true[i]),
+                                                                       int(mse_test * 100)))
+
+                    # mse_test = np.mean(np.sqrt(np.sum(((y_true - y_pred) ** 2)/2)))
+                    print("Overall: {}%".format(int(m / len(y_pred) * 100)))
+                else:
+                    y_pred = np.argmax(np.array(pred_result).squeeze(), axis=1)
+                    # one hot to label encoding - 1 = FRAUD, 0 = OK
+                    # y_train = [1 if np.all(yt == np.array([0, 1])) else 0 for yt in y_train]
+                    y_true = np.array(h5_file['lbl_test'][:])
+                    if len(y_true.shape) != 1:
+                        y_true = np.array([np.argmax(yt) for yt in y_true])
+
+                    self.plot_confusion_matrix(y_true, y_pred, self.class_labels,
+                                               self.data_dir + '/CNN_confusion_matrix_{}.png'.format(self.data_set))
+                    class_report = classification_report(y_true, y_pred, labels=[i for i in range(0, self.num_classes)],
+                                                         target_names=self.class_labels)
+                    with open(self.data_dir + "/classification_report_{}.txt".format(self.data_set), 'w') as f:
+                        f.write('RF accuracy score on test set is {:.2f}\n\n'.format(
+                            accuracy_score(y_true, y_pred) * 100))
+                        f.write(class_report)
+                    print(class_report)
+
+
+
+    def _run_pytorch_pipeline(self):
+        return NotImplementedError
+
+    def plot_confusion_matrix(self, y_true, y_pred, classes, save_path, normalize=False, cmap=plt.cm.Blues):
+        """
+        This function prints and plots the confusion matrix.
+        Normalization can be applied by setting `normalize=True`.
+        :param y_true:      groundtruth labels
+        :param y_pred:      predicted labels
+        :param classes:     class names (strings) for plotting as tick labels
+        :param normalize:   normalize confusion matrix True/False
+        :param cmap:        colormat to use
+        :return:
+        """
+
+        cm = confusion_matrix(y_true, y_pred)
+
+        if normalize:
+            cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
+            print("Normalized confusion matrix")
+            cm_title = 'Normalized confusion matrix'
+        else:
+            print('Confusion matrix, without normalization')
+            cm_title = 'Confusion matrix'
+
+        title = cm_title + ", Accuracy: {0: 0.1f} % ".format(accuracy_score(y_true, y_pred) * 100)
+
+        print(cm)
+        plt.figure()
+        plt.imshow(cm, interpolation='nearest', cmap=cmap)
+        plt.title(title)
+        plt.colorbar()
+        tick_marks = np.arange(len(classes))
+        plt.xticks(tick_marks, classes, rotation=45)
+        plt.yticks(tick_marks, classes)
+
+        fmt = '.2f' if normalize else 'd'
+        thresh = cm.max() / 2.
+        for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
+            plt.text(j, i, format(cm[i, j], fmt), horizontalalignment="center",
+                     color="white" if cm[i, j] > thresh else "black")
+
+        plt.tight_layout()
+        plt.ylabel('True label')
+        plt.xlabel('Predicted label')
+        fig = plt.gcf()
+        fig.savefig(save_path)
+        plt.close(fig)
+
+        return cm
\ No newline at end of file
diff --git a/network/NetRunner.py b/network/NetRunner.py
new file mode 100644
index 0000000..5c0ead4
--- /dev/null
+++ b/network/NetRunner.py
@@ -0,0 +1,354 @@
+#!/usr/bin/env python
+# -----------------------------------------------------------------------------
+# Copyright (C) Software Competence Center Hagenberg GmbH (SCCH)
+# All rights reserved.
+# -----------------------------------------------------------------------------
+# This document contains proprietary information belonging to SCCH.
+# Passing on and copying of this document, use and communication of its
+# contents is not permitted without prior written authorization.
+# -----------------------------------------------------------------------------
+# Created on : 2/20/2019 1:07 PM $ 
+# by : shepeleva $ 
+# SVN  $
+#
+
+# --- imports -----------------------------------------------------------------
+import importlib
+import tensorflow as tf
+
+from utils.DataParser import DataParser
+from network.wrappers import ConvNet, UNet, VGG16
+
+
+class NetRunner:
+    """
+
+    """
+    def __init__(self, args=None, experiment_id=None):
+        self.X = None
+        self.y = None
+        self.X_valid = None
+        self.y_valid = None
+        self.num_classes = None
+        self._parse_config(args, experiment_id)
+
+    def _parse_config(self, args, experiment_id):
+        """
+        Read parameters from config files
+        :param args:
+        :param experiment_id:
+        :return:
+        """
+
+        if not args:
+            if experiment_id:
+                config = importlib.import_module('configs.config_' + experiment_id)
+                args = config.load_config()
+            else:
+                config = importlib.import_module('configs.config')
+                args = config.ConfigFlags().return_flags()
+        # Mandatory parameters for all architectures
+        self.network_type = args.net
+        self.is_training = args.training_mode
+        self.data_dir = args.data_dir
+        self.checkpoint_dir = args.checkpoint_dir
+        self.trainlog_dir = args.trainlog_dir
+        self.lr = args.lr
+        self.lr_decay = args.lr_decay
+        self.ref_steps = args.ref_steps
+        self.ref_patience = args.ref_patience
+        self.batch_size = args.batch_size
+        self.num_epochs = args.num_epochs
+        self.loss_type = args.loss
+        self.accuracy_type = args.accuracy
+        self.optimizer = args.optimizer
+        self.dropout = args.dropout
+        self.gradcam_record = args.gradcam_record
+        self.gradcam_layers = args.gradcam_layers
+        self.gradcam_layers_max = args.gradcam_layers_max
+        self.gpu_load = args.gpu_load
+        self.num_filters = args.num_filters
+        self.upconv = args.upconv
+        self.nonlin = args.nonlin
+        self.loss_type = args.loss
+        self.task_type = args.task_type
+        self.long_summary = args.long_summary
+        self.multi_task = args.multi_task
+        self.framework = args.framework
+        self.cross_val = args.cross_val
+        self.experiment_path = args.experiment_path
+        self.chpnt2load = args.chpnt2load
+
+        if not self.is_training:
+            self.class_labels = args.class_labels
+        if args.data_set:
+            self.data_set = args.data_set
+        else:
+            self.data_set = None
+        if args.data_split:
+            self.data_split = args.data_split
+        else:
+            self.data_split = None
+        if args.data_file:
+            self.data_file = args.data_file
+        else:
+            self.data_file = None
+        if args.image_size:
+            self.img_size = args.image_size
+        else:
+            self.img_size = None
+        if args.num_classes:
+            self.num_classes = args.num_classes
+        else:
+            self.num_classes = None
+        if args.augmentation:
+            self.augmentation_dict = args.augmentation
+        else:
+            self.augmentation_dict = None
+        if args.trainable_layers:
+            self.trainable_layers = args.trainable_layers
+        else:
+            self.trainable_layers = None
+        if args.normalize:
+            self.normalize = args.normalize
+        else:
+            self.normalize = None
+        if args.zero_center:
+            self.zero_center = args.zero_center
+        else:
+            self.zero_center = None
+
+
+        self._initialize_data()
+
+    def _initialize_data(self):
+        data_parser = DataParser(self.data_set, self.data_file, self.data_dir, self.num_classes, self.img_size,
+                                 self.normalize, self.zero_center, self.data_split, self.cross_val, self.task_type,
+                                 self.is_training, self.multi_task, self.experiment_path, self.framework)
+        if self.is_training:
+            self.h5_data_file = data_parser.get_file_name()
+            self.json_log = data_parser.get_log_name()
+            self.data_size = data_parser.get_data_size()
+            self.timestamp = data_parser.get_timestamp()
+            self.ckpnt_path = data_parser.get_ckpnt_path()
+            self.tr_path = data_parser.get_tr_path()
+        else:
+            self.inference_X, self.inference_y = data_parser.get_inference_data()
+
+    def build_tensorflow_pipeline(self):
+        self.graph = tf.Graph()
+        with self.graph.as_default():
+            if self.task_type is 'classification':
+                in_shape = [None, self.img_size[0], self.img_size[1], self.img_size[2]]
+                gt_shape = [None, self.num_classes]
+                self._in_data = tf.placeholder(tf.float32, shape=in_shape, name='Input_train')
+                self._gt_data = tf.placeholder(tf.float32, shape=gt_shape, name='GT_train')
+            elif self.task_type is 'segmentation':
+                in_shape = [None, self.img_size[0], self.img_size[1], self.img_size[2]]
+                gt_shape = [None, self.img_size[0], self.img_size[1], self.num_classes]
+                self._in_data = tf.placeholder(tf.float32, shape=in_shape, name='Input_train')
+                self._gt_data = tf.placeholder(tf.float32, shape=gt_shape, name='GT_train')
+            elif self.task_type is 'gan':
+                in_shape = NotImplementedError
+                gt_shape = NotImplementedError
+            elif self.task_type is 'detection':
+                in_shape = NotImplementedError
+                gt_shape = NotImplementedError
+            else:
+                raise ValueError('Task not supported')
+
+
+
+
+            queue = tf.FIFOQueue(self.data_size * self.num_epochs, [tf.float32, tf.float32], name='queue')
+            self.enqueue_op = queue.enqueue([self._in_data, self._gt_data])
+            self.in_data, self.gt_data = queue.dequeue()
+            self.in_data.set_shape(in_shape)
+            self.gt_data.set_shape(gt_shape)
+
+            self.learning_rate = tf.placeholder(tf.float32, name='Learning_rate')
+            self.training_mode = tf.placeholder(tf.bool, name='Mode_train')
+
+            self.epoch_loss = tf.placeholder(tf.float32, name='Epoch_loss')
+            self.epoch_accuracy = tf.placeholder(tf.float32, name='Epoch_accuracy')
+            self.loss_plot = tf.placeholder(tf.float32, name='Epoch_loss')
+            self.learning_rate_plot = tf.placeholder(tf.float32, name='Epoch_learn')
+
+            self.update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
+
+            self.network = self._pick_model()
+            self.pred_output = self.network.build_net_tf(self.in_data)
+            self.global_step = tf.train.get_or_create_global_step()
+
+            with tf.control_dependencies(self.update_ops):
+                self.loss = self.network.return_loss(y_pred=self.pred_output, y_true=self.gt_data)
+                self.train_op = self.network.return_optimizer(self.global_step)
+                self.accuracy = self.network.return_accuracy(y_pred=self.pred_output, y_true=self.gt_data,
+                                                             b_s=self.batch_size, net_type=self.task_type,
+                                                             loss_type=self.loss_type)
+
+            self.accuracy_plot = tf.placeholder(tf.float32, name='Epoch_accuracy')
+
+            if self.gradcam_record:
+                if self.gradcam_layers > len(self.network.nets) or self.gradcam_layers < 1:
+                    self.gradcam_record = False
+                    print('Wrong layer number, Grad-CAM disabled')
+                else:
+                    gradcam_size = None
+                    self.gradcam_img = tf.placeholder(tf.uint8, shape=gradcam_size, name='GradCAM_merged_images')
+                    self.gradcam_g_img = tf.placeholder(tf.uint8, shape=gradcam_size,
+                                                        name='GuidedGradCAM_merged_images')
+                    self.gb_img = tf.placeholder(tf.uint8, shape=gradcam_size, name='GuidedGradCAM_merged_images')
+                    self.gb_grads = tf.gradients(self.loss, self.in_data)[0]
+                    self.conv_outs = []
+                    self.first_derivatives = []
+                    self.second_derivatives = []
+                    self.third_derivatives = []
+
+                    for cl in range(self.gradcam_layers):
+                        cli = len(self.network.nets) - cl - 1
+                        self.conv_outs.append(self.network.nets[cli])
+                        gs = tf.gradients(self.loss, self.network.nets[cli])[0]
+                        self.first_derivatives.append(tf.exp(self.loss) * gs)
+                        self.second_derivatives.append(tf.exp(self.loss) * gs * gs)
+                        self.third_derivatives.append(tf.exp(self.loss) * gs * gs * gs)
+
+            tf.add_to_collection('mode_train', self.training_mode)
+            tf.add_to_collection('inputs_train', self.in_data)
+            tf.add_to_collection('outputs_train', self.pred_output)
+            tf.add_to_collection('learn_rate', self.learning_rate)
+            # collections for Grad-CAM
+            if self.gradcam_record:
+                tf.add_to_collection('y_true', self.gt_data)
+                tf.add_to_collection('gradcam_in_data', self.in_data)
+                tf.add_to_collection('gradcam_gb_grads', self.gb_grads)
+                for i in range(len(self.conv_outs)):
+                    tf.add_to_collection('gradcam_conv_outs_{}'.format(i), self.conv_outs[i])
+                    tf.add_to_collection('gradcam_first_derivatives_{}'.format(i), self.first_derivatives[i])
+                    tf.add_to_collection('gradcam_second_derivatives_{}'.format(i), self.second_derivatives[i])
+                    tf.add_to_collection('gradcam_third_derivatives_{}'.format(i), self.third_derivatives[i])
+            self.net_params = [self.training_mode, self.train_op, self.loss, self.accuracy,
+                               self.learning_rate, self.pred_output]
+            # Extend net_params with Grad-CAM things
+            if self.gradcam_record:
+                # net_params + [6][[0]input image + [1]grads + [2]conv_layers + [3,4,5]derivatives]
+                self.net_params.append(
+                    [self.in_data, self.gb_grads, self.conv_outs, self.first_derivatives, self.second_derivatives,
+                     self.third_derivatives])
+            self.summ_params = [self.learning_rate_plot, self.loss_plot, self.accuracy_plot]
+
+            self.graph_op = tf.global_variables_initializer()
+
+    def build_pytorch_pipeline(self):
+        return NotImplementedError
+
+
+    def _pick_model(self):
+        """
+        Pick a deep model specified by self.network_type string
+        :return:
+        """
+        if self.network_type == 'ConvNet':
+            return ConvNet.ConvNet(self.network_type, self.loss_type, self.accuracy_type, self.learning_rate,
+                                   training=self.training_mode, framework=self.framework, num_classes=self.num_classes, trainable_layers=self.trainable_layers)
+        elif self.network_type == 'UNet':
+            return UNet.UNet(self.network_type, self.loss_type, self.accuracy_type, self.learning_rate, training=self.training_mode, framework=self.framework,
+                             trainable_layers=self.trainable_layers, num_classes=self.num_classes)
+        elif self.network_type == 'VGG16':
+            return VGG16.VGG16(self.network_type, self.loss_type, self.accuracy_type, self.learning_rate,
+                               training=self.training_mode, framework=self.framework, num_classes=self.num_classes, trainable_layers=self.trainable_layers)
+        else:
+            return ValueError('Architecture does not exist')
+
+    def _initialize_short_summary(self):
+        """
+        Tensorboard scope initialization
+        :return:
+        """
+        loss_sum = tf.summary.scalar('Loss_function', self.loss_plot)
+        lr_summ = tf.summary.scalar("Learning_rate", self.learning_rate_plot)
+        # more then one accuracy specified
+        if isinstance(self.accuracy_type, list) and (len(self.accuracy_type) >= 2):
+            acc_summ = tf.stack([tf.summary.scalar('{:s}_Accuracy_label_{:d}'.format(self.accuracy_type[k], i),
+                                                   self.accuracy_plot[k][i]) for k in range(len(self.accuracy_type))
+                                 for
+                                 i in range(self.num_classes)])
+        # only one accuracy specified
+        else:
+            if isinstance(self.accuracy_type, list):
+                self.accuracy_type = self.accuracy_type[0]
+            if self.task_type == 'classification':
+                acc_summ = tf.summary.scalar('{:s}_accuracy'.format(self.accuracy_type), self.accuracy_plot)
+            elif self.task_type == 'segmentation':
+                acc_summ = tf.summary.scalar('{:s}_accuracy'.format(self.accuracy_type), self.accuracy_plot)
+                # acc_summ = tf.stack([tf.summary.scalar('{:s}_accuracy_label_{:d}'.format(self.accuracy_type, i),
+                #                                        self.accuracy_plot[i]) for i in range(self.num_classes)])
+        summary_op = tf.summary.merge([loss_sum, lr_summ, acc_summ])
+        return summary_op
+
+    def _initialize_long_summary(self):
+        img_summ = tf.summary.image("Original_Image", self.in_data, self.batch_size)
+        if self.task_type == 'segmentation':
+            gt_summ = tf.summary.image("GT_Mask",
+                                       self._convert_mask_data(self.batch_size, self.gt_data, self.num_classes),
+                                       max_outputs=1)
+            if self.loss_type == 'softmax':
+                pred_summ = tf.summary.image("Predicted_Mask",
+                                             self._convert_mask_data(self.batch_size,
+                                                                     tf.nn.softmax(self.pred_output),
+                                                                     self.num_classes), max_outputs=1)
+            elif self.loss_type == 'sigmoid':
+                pred_summ = tf.summary.image("Predicted_Mask",
+                                             self._convert_mask_data(self.batch_size,
+                                                                     tf.nn.sigmoid(self.pred_output),
+                                                                     self.num_classes), max_outputs=1)
+        elif self.task_type == 'classification':
+            gt_summ = tf.summary.text('Input_labels',
+                                      tf.as_string(
+                                          tf.reshape(tf.argmax(self.gt_data, axis=1), [-1, self.batch_size])))
+            pred_summ = tf.summary.text('Predicted_labels', tf.as_string(
+                tf.reshape(tf.argmax(self.pred_output, axis=1), [-1, self.batch_size])))
+        # Setup Grad-CAM summaries
+        if self.gradcam_record:
+            gradcam_summs = []
+            g_gradcam_summs = []
+            for cl in range(self.gradcam_layers):
+                l_idx = self.gradcam_layers_max - cl
+                gradcam_summs.append(
+                    tf.summary.image("GradCAM-{}".format(l_idx), tf.reverse(self.gradcam_img[cl], [-1]),
+                                     self.batch_size))
+                g_gradcam_summs.append(
+                    tf.summary.image("GuidedGradCAM-{}".format(l_idx), tf.reverse(self.gradcam_g_img[cl], [-1]),
+                                     self.batch_size))
+                if cl == 0:
+                    gb_summ = tf.summary.image("GuidedBackpropagation", tf.reverse(self.gb_img, [-1]),
+                                               self.batch_size)
+
+        #         # add weights and biases to summary
+        # <<<<<<< .mine
+        #         # hist_summ = tf.stack(
+        #         #     [tf.summary.histogram(tf.trainable_variables()[i].name[:-2] + '_train', tf.trainable_variables()[i]) for i
+        #         #      in range(len(tf.trainable_variables()))])
+        #         summary_op = tf.summary.merge([img_summ, gt_summ, pred_summ])
+        #
+        #         # summary_op = tf.summary.merge([img_summ, gt_summ, pred_summ, hist_summ])
+        #         # summary_op = tf.summary.merge([img_summ, pred_summ, hist_summ])
+        # ||||||| .r168
+        #         hist_summ = tf.stack(
+        #             [tf.summary.histogram(tf.trainable_variables()[i].name[:-2] + '_train', tf.trainable_variables()[i]) for i
+        #              in range(len(tf.trainable_variables()))])
+        #         summary_op = tf.summary.merge([img_summ, gt_summ, pred_summ, hist_summ])
+        #         # summary_op = tf.summary.merge([img_summ, pred_summ, hist_summ])
+        # =======
+        hist_summ = tf.stack(
+            [tf.summary.histogram(tf.trainable_variables()[i].name[:-2] + '_train', tf.trainable_variables()[i]) for
+             i
+             in range(len(tf.trainable_variables()))])
+        m_summs = [img_summ, gt_summ, pred_summ, hist_summ]
+        summary_op = tf.summary.merge(m_summs)
+        # >>>>>>> .r281
+
+        if self.gradcam_record:
+            return summary_op, tf.summary.merge([gb_summ, gradcam_summs, g_gradcam_summs])
+        else:
+            return summary_op, None
\ No newline at end of file
diff --git a/network/TrainRunner.py b/network/TrainRunner.py
new file mode 100644
index 0000000..9c454ee
--- /dev/null
+++ b/network/TrainRunner.py
@@ -0,0 +1,307 @@
+#!/usr/bin/env python
+# -----------------------------------------------------------------------------
+# Copyright (C) Software Competence Center Hagenberg GmbH (SCCH)
+# All rights reserved.
+# -----------------------------------------------------------------------------
+# This document contains proprietary information belonging to SCCH.
+# Passing on and copying of this document, use and communication of its
+# contents is not permitted without prior written authorization.
+# -----------------------------------------------------------------------------
+# Created on : 2/20/2019 4:01 PM $ 
+# by : shepeleva $ 
+# SVN  $
+#
+
+# --- imports -----------------------------------------------------------------
+
+import gc
+import os
+import time
+import h5py
+import json
+import numpy as np
+import tensorflow as tf
+from tqdm import tqdm
+# import tensorflow.contrib.slim as slim
+
+from network.NetRunner import NetRunner
+from utils.BatchIterator import BatchIterator
+from utils.utils import log_loss_accuracy
+from utils.gradcam.GradCAM import grad_cam_plus_plus as gradcam
+
+
+class TrainRunner(NetRunner):
+    def __init__(self, args=None, experiment_id=None):
+        super().__init__(args, experiment_id)
+
+    def start_training(self):
+        """
+        Start Neural Network training
+        :return:
+        """
+        # os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+        # training initialisation
+        # with tf.device('/cpu:0'):
+        # self._initialize_data()
+        self._initialize_training()
+
+    def _initialize_training(self):
+        if self.framework is 'tensorflow':
+            self.build_tensorflow_pipeline()
+            self._run_tensorflow_pipeline()
+        elif self.framework is 'pytorch':
+            self.build_pytorch_pipeline()
+        else:
+            raise ValueError('Framework is not supported')
+
+    def _run_tensorflow_pipeline(self):
+        tf.reset_default_graph()
+
+        if self.gpu_load != 0:
+            gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=self.gpu_load)
+            # config = tf.ConfigProto(gpu_options=gpu_options, log_device_placement=True,
+            #                         device_count={"CPU": 4},
+            #                         inter_op_parallelism_threads=4,
+            #                         intra_op_parallelism_threads=5,)
+            config = tf.ConfigProto(gpu_options=gpu_options, log_device_placement=True)
+            config.gpu_options.allow_growth = True
+        else:
+            os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
+            config = tf.ConfigProto(device_count={'CPU': 1})
+
+        h5_file = h5py.File(self.h5_data_file, 'r')
+
+        with open(self.json_log, 'r') as f:
+            json_log = json.load(f)
+
+        train_split = []
+        valid_split = []
+        cross_val_split = json_log['data_log']['cross_val_split']
+        if len(cross_val_split) == 2:
+            train_split.append(cross_val_split[0])
+            valid_split.append(cross_val_split[1])
+        else:
+            for i in range(len(cross_val_split)):
+                valid_split.append(cross_val_split[i])
+                train_split.append([].extend(cross_val_split[j]) for j in range(len(cross_val_split)) if j != i)
+
+        for split in range(len(cross_val_split)-1):
+            print("Cross validation split % of %".format(str(split+1), str(len(cross_val_split)-1)))
+
+            with tf.Session(graph=self.graph, config=config) as sess:
+                event_time = time.time()
+                global_step = tf.train.get_global_step(sess.graph)
+                self.net_params.append(global_step)
+                if self.long_summary:
+                    long_summ, self.gradcam_summ = self._initialize_long_summary()
+                    self.net_params.append(long_summ)
+                short_summ = self._initialize_short_summary()
+                self.summ_params.append(short_summ)
+                if not os.path.isdir(os.path.join(self.tr_path, self.data_set, self.timestamp)):
+                    os.mkdir(os.path.join(self.tr_path, self.data_set, self.timestamp))
+
+                summary_log_file_train = os.path.join(self.tr_path, self.data_set, self.timestamp, 'train', self.timestamp + '_split_' + str(split))
+                train_summary_writer = tf.summary.FileWriter(summary_log_file_train, sess.graph)
+
+                summary_log_file_valid = os.path.join(self.tr_path, self.data_set, self.timestamp, 'valid', self.timestamp + '_split_' + str(split))
+                valid_summary_writer = tf.summary.FileWriter(summary_log_file_valid, sess.graph)
+
+                saver = tf.train.Saver(save_relative_paths=True)
+                with tf.device('/cpu:0'):
+                    self.graph_op.run()
+                    learn_rate = self.lr
+                    prev_loss = np.inf
+                    ref_counter = 0
+                    ref_iter_count = 0
+                    total_recall_counter_train = 0
+                    total_recall_counter_valid = 0
+                    coord = tf.train.Coordinator()
+                    enqueue_threads = tf.train.start_queue_runners(sess=sess, coord=coord)
+
+                for epoch in range(1, self.num_epochs + 1):
+                    # print('\nEPOCH {:d}'.format(epoch))
+                    with tf.device('/cpu:0'):
+                        train_generator = BatchIterator(h5_file, train_split[split], self.img_size, self.num_classes, self.batch_size,
+                                                        self.task_type, self.is_training)
+                        train_lim = train_generator.get_max_lim()
+                        # <<<<<<< .mine
+                        #                     valid_generator = BatchIterator(h5_file, 'valid', self.img_size, self.num_classes, self.batch_size,
+                        # ||||||| .r180
+                        #                     valid_generator = BatchIterator(h5_file, 'valid', self.img_size, self.num_classes, 1,
+                        # =======
+                        #                     # TODO calidation self.batch_size -> 1 fix is required with long_summary
+                        valid_generator = BatchIterator(h5_file, valid_split[split], self.img_size, self.num_classes, self.batch_size,
+                                                        self.task_type, self.is_training)
+                        valid_lim = valid_generator.get_max_lim()
+                        epoch_loss_train = 0
+                        epoch_loss_valid = 0
+                        if self.task_type == 'classification':
+                            epoch_accur_train = 0
+                            epoch_accur_valid = 0
+                        else:
+                            epoch_accur_train = 0
+                            epoch_accur_valid = 0
+                        epoch_duration_train = 0
+                        epoch_duration_valid = 0
+
+                    # step_cout_train = 1
+                    for i in tqdm(train_generator, total=train_lim, unit=' steps', desc='Epoch {:d} train'.format(epoch)):
+                        with tf.device('/cpu:0'):
+                            total_recall_counter_train += 1
+                            start_time = time.time()
+                            ff = list(i)
+                            sess.run(self.enqueue_op, feed_dict={
+                                self._in_data: [np.reshape(f[0], [self.img_size[0], self.img_size[1], self.img_size[2]]) for f
+                                                in ff],
+                                self._gt_data: [f[1] for f in ff]})
+                            return_session_params = sess.run(self.net_params,
+                                                             feed_dict={self.training_mode: True,
+                                                                        self.learning_rate: learn_rate})
+                        # Calculate Grad-CAM parameters
+                        if self.gradcam_record and total_recall_counter_train % train_generator.get_max_lim() == 1:
+                            gradcam_params = return_session_params[6]
+                            merged_heatmaps = []
+                            merged_gbs = []
+                            for cl in range(self.gradcam_layers):
+                                merged_heatmap, heatmap, merged_gb, gb = gradcam(gradcam_params, cl)
+                                merged_heatmaps.append(merged_heatmap)
+                                merged_gbs.append(merged_gb)
+                            self.return_gradcam_summs = sess.run(self.gradcam_summ,
+                                                                 feed_dict={self.gradcam_img: merged_heatmaps,
+                                                                            self.gradcam_g_img: merged_gbs,
+                                                                            self.gb_img: gb})
+                        with tf.device('/cpu:0'):
+                            if self.long_summary and total_recall_counter_train % train_generator.get_max_lim() == 1:
+                                train_summary_writer.add_summary(return_session_params[-1], epoch)
+                                # add Grad-CAM to the summary
+                                if self.gradcam_record:
+                                    train_summary_writer.add_summary(self.return_gradcam_summs, epoch)
+                            train_step_loss = return_session_params[2]
+                            train_step_accuracy = return_session_params[3]
+                            train_step_duration = time.time() - start_time
+                            epoch_loss_train += train_step_loss
+                        # print(return_session_params[-1])
+                        if self.task_type == 'classification':
+                            epoch_accur_train += train_step_accuracy
+                        else:
+                            epoch_accur_train += train_step_accuracy
+                        epoch_duration_train += train_step_duration
+                        # print('Training current step: {:d}'.format(step_cout_train))
+                        # step_cout_train += 1
+
+                    # step_cout_valid = 1
+                    for i in tqdm(valid_generator, total=valid_lim, unit=' steps', desc='Epoch {:d} valid'.format(epoch)):
+                        with tf.device('/cpu:0'):
+                            total_recall_counter_valid += 1
+
+                            start_time = time.time()
+                            ff = list(i)
+
+                            sess.run(self.enqueue_op, feed_dict={
+                                self._in_data: [np.reshape(f[0], [self.img_size[0], self.img_size[1], self.img_size[2]]) for f
+                                                in ff],
+                                self._gt_data: [f[1] for f in ff]})
+                            return_session_params_valid = sess.run(self.net_params,
+                                                                   feed_dict={self.training_mode: False,
+                                                                              self.learning_rate: learn_rate})
+                        # Calculate Grad-CAM parameters
+                        if self.gradcam_record and total_recall_counter_valid % valid_generator.get_max_lim() == 1:
+                            gradcam_params = return_session_params_valid[6]
+                            merged_heatmaps = []
+                            merged_gbs = []
+                            for cl in range(self.gradcam_layers):
+                                merged_heatmap, heatmap, merged_gb, gb = gradcam(gradcam_params, cl)
+                                merged_heatmaps.append(merged_heatmap)
+                                merged_gbs.append(merged_gb)
+                            return_gradcam_summs = sess.run(self.gradcam_summ, feed_dict={self.gradcam_img: merged_heatmaps,
+                                                                                          self.gradcam_g_img: merged_gbs,
+                                                                                          self.gb_img: gb})
+                        with tf.device('/cpu:0'):
+                            if self.long_summary and total_recall_counter_valid % valid_generator.get_max_lim() == 1:
+                                valid_summary_writer.add_summary(return_session_params_valid[-1], epoch)
+                                # add Grad-CAM to the summary
+                                if self.gradcam_record:
+                                    valid_summary_writer.add_summary(return_gradcam_summs, epoch)
+
+                        valid_step_loss = return_session_params_valid[2]
+                        valid_step_accuracy = return_session_params_valid[3]
+                        valid_step_duration = time.time() - start_time
+                        epoch_loss_valid += valid_step_loss
+                        if self.task_type == 'classification':
+                            epoch_accur_valid += valid_step_accuracy
+                        else:
+                            epoch_accur_valid += valid_step_accuracy
+                        epoch_duration_valid += valid_step_duration
+                        # print('Validation current step: {:d}'.format(step_cout_valid))
+                        # step_cout_valid += 1
+
+                    # with tf.device('/cpu:0'):
+                    train_aver_loss = epoch_loss_train / train_lim
+                    valid_aver_loss = epoch_loss_valid / valid_lim
+
+                    if self.task_type == 'classification':
+
+                        epoch_accur_train = epoch_accur_train / train_lim
+                        epoch_accur_valid = epoch_accur_valid / valid_lim
+
+                        epoch_acc_str_tr = log_loss_accuracy(epoch_accur_train, self.accuracy_type, self.task_type,
+                                                             self.num_classes, self.multi_task)
+                        epoch_acc_str_val = log_loss_accuracy(epoch_accur_valid, self.accuracy_type, self.task_type,
+                                                              self.num_classes, self.multi_task)
+                    elif self.task_type == 'segmentation':
+                        epoch_accur_train = epoch_accur_train / train_lim
+                        epoch_accur_valid = epoch_accur_valid / valid_lim
+                        epoch_acc_str_tr = log_loss_accuracy(epoch_accur_train, self.accuracy_type, self.task_type,
+                                                             self.num_classes, self.multi_task)
+                        epoch_acc_str_val = log_loss_accuracy(epoch_accur_valid, self.accuracy_type, self.task_type,
+                                                              self.num_classes, self.multi_task)
+                        # epoch_acc_str = 'Not implemented yet'
+
+                    ret_train_epoch = sess.run(self.summ_params, feed_dict={self.learning_rate_plot: learn_rate,
+                                                                            self.loss_plot: train_aver_loss,
+                                                                            self.accuracy_plot: epoch_accur_train})
+                    ret_valid_epoch = sess.run(self.summ_params, feed_dict={self.learning_rate_plot: learn_rate,
+                                                                                self.loss_plot: valid_aver_loss,
+                                                                                self.accuracy_plot: epoch_accur_valid})
+                    train_summary_writer.add_summary(ret_train_epoch[-1], epoch)
+                    valid_summary_writer.add_summary(ret_valid_epoch[-1], epoch)
+
+                    with tf.device('/cpu:0'):
+                        print(
+                            '\nRESULTS: epoch {:d} train loss = {:.3f}, train accuracy : {:s} ({:.2f} sec) || valid loss = {:.3f}, valid accuracy : {:s} ({:.2f} sec)'
+                            .format(epoch, train_aver_loss, epoch_acc_str_tr, epoch_duration_train, valid_aver_loss,
+                                    epoch_acc_str_val, epoch_duration_valid))
+                        if prev_loss > valid_aver_loss:
+                            if not os.path.isdir(os.path.join(self.ckpnt_path, self.data_set, self.timestamp)):
+                                os.mkdir(os.path.join(self.ckpnt_path, self.data_set, self.timestamp))
+
+                            model_file_path = os.path.join('experiments', 'ckpnt_logs', self.data_set, self.timestamp, self.timestamp + '_split_' + str(split))
+                            saver.save(sess, "{}/model.ckpt".format(model_file_path), global_step=epoch)
+
+                            # onnx_graph = tf2onnx.tfonnx.process_tf_graph(sess.graph, output_names=["output:0"])
+                            # model_proto = onnx_graph.make_model("test")
+                            # with open("{}/model.onnx".format(model_file_path), "wb") as f:
+                            #     f.write(model_proto.SerializeToString())
+
+                            print('[SESSION SAVE] Epoch {:d}, loss: {:2f}'.format(epoch, valid_aver_loss))
+                            prev_loss = valid_aver_loss
+                            ref_counter = 0
+                        else:
+                            ref_counter += 1
+                            if ref_counter == self.ref_patience:
+                                learn_rate *= self.lr_decay
+                                print('\nDecreasing learning rate', learn_rate)
+                                latest_ckpt = tf.train.latest_checkpoint(model_file_path)
+                                saver.restore(sess, latest_ckpt)
+                                print('\n[SESSION RESTORED]')
+                                ref_counter = 0
+                                ref_iter_count += 1
+                                if ref_iter_count == self.ref_steps:
+                                    print('\nEarly stopping')
+                                    # sess.close()
+                                    break
+                    gc.collect()
+            coord.request_stop()
+            coord.join(enqueue_threads)
+
+        h5_file.close()
\ No newline at end of file
diff --git a/network/__init__.py b/network/__init__.py
new file mode 100644
index 0000000..bee6569
--- /dev/null
+++ b/network/__init__.py
@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+# -----------------------------------------------------------------------------
+# Copyright (C) Software Competence Center Hagenberg GmbH (SCCH)
+# All rights reserved.
+# -----------------------------------------------------------------------------
+# This document contains proprietary information belonging to SCCH.
+# Passing on and copying of this document, use and communication of its
+# contents is not permitted without prior written authorization.
+# -----------------------------------------------------------------------------
+# Created on : 12/07/2017 14:20 $
+# by : shepeleva $
+# SVN : $
+#
+
+# --- imports -----------------------------------------------------------------
diff --git a/network/wrappers/ConvNet.py b/network/wrappers/ConvNet.py
new file mode 100644
index 0000000..9bd231d
--- /dev/null
+++ b/network/wrappers/ConvNet.py
@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+# -----------------------------------------------------------------------------
+# Copyright (C) Software Competence Center Hagenberg GmbH (SCCH)
+# All rights reserved.
+# -----------------------------------------------------------------------------
+# This document contains proprietary information belonging to SCCH.
+# Passing on and copying of this document, use and communication of its
+# contents is not permitted without prior written authorization.
+# -----------------------------------------------------------------------------
+# Created on : 12/07/2017 11:02 $
+# by : shepeleva $
+# SVN : $
+#
+
+# --- imports -----------------------------------------------------------------
+
+import tensorflow as tf
+
+from network.wrappers.NetworkBase import NetworkBase
+
+
+class ConvNet(NetworkBase):
+    def __init__(self, network_type, loss, accuracy, lr, training, framework, trainable_layers=None, num_filters=16,
+                 optimizer='adam', nonlin='elu', num_classes=2, dropout=0.25):
+        """
+        Convolutional Neural Network constructor
+        :param loss:        used loss function
+        :param lr:          learning rate
+        :param training:    is training True/False
+        :param num_filters: number of filters
+        :param optimizer:   used optimizer
+        :param nonlin:      used nonliniearity
+        :param num_classes: number of classes/labels
+        :param dropout:     dropout ratio
+        """
+        super().__init__(network_type, loss, accuracy, lr, training, framework, trainable_layers=trainable_layers,
+                         optimizer=optimizer, nonlin=nonlin, num_filters=num_filters,
+                         num_classes=num_classes, dropout=dropout)
+        self.weights, self.biases, self.nets = [], [], []
+
+    def build_net_tf(self, X):
+        """
+        Build the Convolutional Neural Network
+        :param X:   input tensor
+        :return:    network
+        """
+
+        with tf.name_scope('s_conv_1'):
+            conv_1_1, batch_1_1, activ_1_1 = self._conv_bn_layer(X, n_filters=self.num_filters, filter_size=3,
+                                                                 is_training=self.is_training, nonlin_f=self.nonlin_f,
+                                                                 name_postfix='1_1')
+            conv_1_2, batch_1_2, activ_1_2 = self._conv_bn_layer(activ_1_1, n_filters=self.num_filters,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, name_postfix='1_2')
+            pooling_1 = tf.layers.max_pooling2d(activ_1_2, pool_size=2, strides=2, padding='same', name='pooling_1')
+            drop_1 = tf.layers.dropout(pooling_1, rate=self.dropout, name='drop_1')
+            self.nets.extend([conv_1_1, conv_1_2])
+
+        with tf.name_scope('s_conv_2'):
+            conv_2_1, batch_2_1, activ_2_1 = self._conv_bn_layer(drop_1, n_filters=self.num_filters, filter_scale=2,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, name_postfix='2_1')
+            conv_2_2, batch_2_2, activ_2_2 = self._conv_bn_layer(activ_2_1, n_filters=self.num_filters, filter_scale=2,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, name_postfix='2_2')
+            pooling_2 = tf.layers.max_pooling2d(activ_2_2, pool_size=2, strides=2, padding='same', name='pooling_2')
+            drop_2 = tf.layers.dropout(pooling_2, rate=self.dropout, name='drop_2')
+            self.nets.extend([conv_2_1, conv_2_2])
+
+        with tf.name_scope('s_conv_3'):
+            conv_3_1, batch_3_1, activ_3_1 = self._conv_bn_layer(drop_2, n_filters=self.num_filters, filter_scale=4,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, name_postfix='3_1')
+            conv_3_2, batch_3_2, activ_3_2 = self._conv_bn_layer(activ_3_1, n_filters=self.num_filters, filter_scale=4,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, name_postfix='3_2')
+            pooling_3 = tf.layers.max_pooling2d(activ_3_2, pool_size=3, strides=2, padding='same', name='pooling_3')
+            drop_3 = tf.layers.dropout(pooling_3, rate=self.dropout, name='drop_3')
+            self.nets.extend([conv_3_1, conv_3_2])
+
+
+
+        with tf.name_scope('s_outputs'):
+            flat = tf.layers.flatten(drop_3, name='flatten')
+            fc_1 = tf.layers.dense(flat, units=1024, activation=None, name='fc_1')
+            drop_5 = tf.layers.dropout(fc_1, rate=self.dropout, name='drop_5')
+            fc_2 = tf.layers.dense(drop_5, units=512, activation=None, name='fc_2')
+            drop_6 = tf.layers.dropout(fc_2, rate=self.dropout, name='drop_6')
+            output_p = tf.layers.dense(drop_6, units=self.num_classes, activation=None, name='output')
+        return output_p
diff --git a/network/wrappers/NetworkBase.py b/network/wrappers/NetworkBase.py
new file mode 100644
index 0000000..3a16619
--- /dev/null
+++ b/network/wrappers/NetworkBase.py
@@ -0,0 +1,366 @@
+#!/usr/bin/env python
+# -----------------------------------------------------------------------------
+# Copyright (C) Software Competence Center Hagenberg GmbH (SCCH)
+# All rights reserved.
+# -----------------------------------------------------------------------------
+# This document contains proprietary information belonging to SCCH.
+# Passing on and copying of this document, use and communication of its
+# contents is not permitted without prior written authorization.
+# -----------------------------------------------------------------------------
+# Created on : 12/07/2017 13:57 $
+# by : shepeleva $
+# SVN : $
+#
+
+# --- imports -----------------------------------------------------------------
+
+from utils.metric_v03 import *
+import numpy as np
+
+
+class NetworkBase:
+    """
+
+    """
+
+    def __init__(self, network_type, loss, accuracy, lr, training, framework, optimizer=None, nonlin=None, upconv=None, num_filters=None, num_classes=None,
+                 dropout=None, num_steps=None, trainable_layers=None):
+        """
+        Construtcor of NetworkBase Class
+        :param loss:        loss function
+        :param lr:          learning rate
+        :param training:    is training True/False
+        :param optimizer:   optimizer
+        :param nonlin:      nonliniearity
+        :param upconv:      upconvolution method
+        :param num_filters: number of filters
+        :param num_classes: number of classes/labels
+        :param dropout:     dropout ratio
+        """
+        self.loss_f = self._pick_loss_func(loss)
+        # self.accuracy_f_list = self._pick_accuracy_function(accuracy)
+        self.is_training = training
+        self.learning_rate = lr
+        self.optimizer = optimizer
+        self.framework = framework
+        self.network_type = network_type
+        if optimizer:
+            self.optimizer_f = self._pick_optimizer_func(optimizer)
+        if nonlin:
+            self.nonlin_f = self._pick_nonlin_func(nonlin)
+        if upconv:
+            self.upconv_f = self._pick_upconv_func(upconv)
+        if num_filters:
+            self.num_filters = num_filters
+        if num_classes:
+            self.num_classes = num_classes
+        if dropout:
+            self.dropout = dropout
+        if num_steps:
+            self.num_steps = num_steps
+
+        if trainable_layers:
+            self.trainable_layers = trainable_layers
+        else:
+            self.trainable_layers = 'all'
+
+        if isinstance(accuracy, list):
+            self.accuracy_f_list = [self._pick_accuracy_function(acc) for acc in accuracy]
+        else:
+            self.accuracy_f_list = self._pick_accuracy_function(accuracy)
+
+    def _loss_function(self, y_pred, y_true):
+        """
+        Returns the loss
+        :param y_pred:  prediction
+        :param y_true:  ground truth
+        :return:        loss
+        """
+        self.loss = self.loss_f(y_pred=y_pred, y_true=y_true)
+        return self.loss
+
+    def _accuracy_function(self, y_pred, y_true, b_s, net_type, loss_type):
+        """
+        Returns the accuracy
+        :param y_pred:
+        :param y_true:
+        :return:
+        """
+
+        if loss_type == 'sigmoid':
+            y_pred = tf.nn.sigmoid(y_pred)
+        if loss_type == 'softmax':
+            y_pred = tf.nn.softmax(y_pred)
+
+        if net_type == 'classification':
+            if isinstance(self.accuracy_f_list, list) and (len(self.accuracy_f_list) >= 2):
+                return [acc_fun(y_pred=y_pred, y_true=y_true, b_s=b_s) for acc_fun in self.accuracy_f_list]
+            else:
+                return self.accuracy_f_list(y_pred=y_pred, y_true=y_true)
+        elif net_type == 'segmentation':
+            if isinstance(self.accuracy_f_list, list) and (len(self.accuracy_f_list) >= 2):
+                return [acc_fun(y_pred=y_pred, y_true=y_true, b_s=b_s) for acc_fun in self.accuracy_f_list]
+            else:
+                return self.accuracy_f_list(y_pred=y_pred, y_true=y_true)
+        else:
+            raise ValueError('Unexpected network task %s' % net_type)
+
+    def _optimizer_function(self, global_step):
+        """
+        Return the optimizer function
+        :param global_step: current global step
+        :return:            optimizer
+        """
+        if self.trainable_layers == 'all':
+            return self.optimizer_f(self.learning_rate).minimize(self.loss, global_step=global_step)
+        else:
+            first_train_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
+                                                 self.trainable_layers)
+            return self.optimizer_f(self.learning_rate).minimize(self.loss, var_list=first_train_vars,
+                                                                 global_step=global_step)
+
+    @staticmethod
+    def _pick_nonlin_func(key):
+        """
+        Select a nonlinearity/activation function
+        :param key: nonliniearity identifier
+        :return:    nonliniearity/activation function
+        """
+        if key == 'elu':
+            return tf.nn.elu
+        elif key == 'relu':
+            return tf.nn.relu
+        elif key == 'lrelu':
+            return tf.nn.leaky_relu
+        elif key == 'tanh':
+            return tf.nn.tanh
+        else:
+            raise ValueError('Unexpected nonlinearity function %s' % key)
+
+    @staticmethod
+    def _pick_upconv_func(key):
+        """
+        Select either deconvolution or upsampling
+        :param key: identifier
+        :return:    upconv or upsampling
+        """
+        if key == 'upconv':
+            return tf.layers.conv2d_transpose
+        if key == 'upsampling':
+
+            def upconv2d(input_, output_shape, filters, kernel_size=4, strides=(1, 1), name="upconv2d"):
+                """
+                Pure tensorflow 2d upconvolution/upsampling layer using tf.image.resize_images
+                :param input_:
+                :param output_shape:
+                :param filters:
+                :param kernel_size:
+                :param strides:
+                :param name:
+                :return:
+                """
+                with tf.variable_scope(name):
+                    resized = tf.image.resize_images(input_, output_shape[1:3])
+                    upconv = tf.layers.conv2d(resized, filters=filters, kernel_size=kernel_size, strides=strides,
+                                              padding='same', name='conv')
+                    # upconv = tf.nn.conv2d(resize, w, strides=[1, d_h, d_w, 1], padding='SAME')
+
+                    return upconv
+
+            return upconv2d
+        else:
+            raise ValueError('Unexpected upconvolution function %s' % key)
+
+    @staticmethod
+    def _pick_loss_func(key):
+        """
+        Select loss function
+        :param key: loss function identifier
+        :return:    loss function
+        """
+        if key == 'softmax':
+            return softmax
+        if key == 'sigmoid':
+            return sigmoid
+        if key == 'margin':
+            return margin
+        if key == 'mse':
+            return mse
+        if key == 'mse_loss':
+            return mse_loss
+        else:
+            raise ValueError('Unexpected metric function %s' % key)
+
+    @staticmethod
+    def _pick_accuracy_function(key):
+        if key == 'IoU':
+            return IoU
+        elif key == 'dice_sorensen':
+            return dice_sorensen
+        elif key == 'dice_jaccard':
+            return dice_jaccard
+        elif key == 'mse':
+            return mse
+        elif key == 'hinge':
+            return hinge
+        elif key == 'percent':
+            return percentage
+        else:
+            raise ValueError('Unexpected metric function %s' % key)
+
+
+    @staticmethod
+    def _pick_optimizer_func(key):
+        if key == 'adam':
+            return tf.train.AdamOptimizer
+        if key == 'amsgrad':
+            from network.third_parties.amsgrad.amsgrad import AMSGrad
+            return AMSGrad
+        if key == 'momentum':
+            return tf.train.MomentumOptimizer
+        if key == 'gradient':
+            return tf.train.GradientDescentOptimizer
+        if key == 'proximalgrad':
+            return tf.train.ProximalGradientDescentOptimizer
+        else:
+            raise ValueError('Unexpected optimizer function %s' % key)
+
+    @staticmethod
+    def _conv_bn_layer(input_layer, n_filters, filter_scale=1, filter_size=3, is_training=True, nonlin_f=None,
+                       padding='same', name='s_conv_bn', name_postfix='1_1'):
+        """
+        Convolution layer with batch normalization
+        :param input_layer:     input layer
+        :param n_filters:       number of filters
+        :param filter_scale:    filter scale -> n_filters = n_filters * filter_scale
+        :param filter_size:     filter size
+        :param is_training:     training True/False
+        :param nonlin_f:        nonlinearity/activation function, if None linear/no activation is used
+        :param padding:         padding: valid or same
+        :param name:            layer name
+        :param name_postfix:    layer name postfix
+        :return: conv, batch_norm, nonlin - convolution, batch normalization and nonlinearity/activation layer
+        """
+        with tf.name_scope(name + name_postfix):
+            conv = tf.layers.conv2d(input_layer, filters=filter_scale * n_filters, kernel_size=filter_size,
+                                    activation=None, padding=padding, kernel_regularizer=tf.contrib.layers.l2_regularizer(scale=0.1),
+                                    name='conv_' + name_postfix)
+            batch_norm = tf.layers.batch_normalization(conv, training=is_training, fused=False, name='batch_' + name_postfix)
+            if nonlin_f:
+                # weights, biases = NetworkBase.weights_and_biases(tf.shape(batch_norm), tf.shape(batch_norm)[-1])
+                # nonlin = nonlin_f(tf.matmul(batch_norm, weights) + biases, name='activation_' + name_postfix)
+                nonlin = nonlin_f(batch_norm, name='activation_' + name_postfix)
+            else:
+                nonlin = None
+        return conv, batch_norm, nonlin
+
+    @staticmethod
+    def _sep_conv_bn_layer(input_layer, n_filters, filter_scale=1, filter_size=3, is_training=True, nonlin_f=None,
+                       padding='same', name='s_conv_bn', name_postfix='1_1'):
+        """
+        Convolution layer with batch normalization
+        :param input_layer:     input layer
+        :param n_filters:       number of filters
+        :param filter_scale:    filter scale -> n_filters = n_filters * filter_scale
+        :param filter_size:     filter size
+        :param is_training:     training True/False
+        :param nonlin_f:        nonlinearity/activation function, if None linear/no activation is used
+        :param padding:         padding: valid or same
+        :param name:            layer name
+        :param name_postfix:    layer name postfix
+        :return: conv, batch_norm, nonlin - convolution, batch normalization and nonlinearity/activation layer
+        """
+        with tf.name_scope(name + name_postfix):
+            conv = tf.layers.separable_conv2d(input_layer, filters=filter_scale * n_filters, kernel_size=filter_size,
+                                    activation=None, padding=padding, depth_multiplier=3, name='conv_' + name_postfix)
+            batch_norm = tf.layers.batch_normalization(conv, training=is_training, fused=False, name='batch_' + name_postfix)
+            if nonlin_f:
+                nonlin = nonlin_f(batch_norm, name='activation_' + name_postfix)
+            else:
+                nonlin = None
+        return conv, batch_norm, nonlin
+
+    @staticmethod
+    def _conv_nonlin_layer(input_layer, n_filters, filter_scale=1, filter_size=3, is_training=True, nonlin_f=None,
+                       padding='same', name='s_conv_nonlin', name_postfix='1_1'):
+        """
+        Convolution layer with batch normalization
+        :param input_layer:     input layer
+        :param n_filters:       number of filters
+        :param filter_scale:    filter scale -> n_filters = n_filters * filter_scale
+        :param filter_size:     filter size
+        :param is_training:     training True/False
+        :param nonlin_f:        nonlinearity/activation function, if None linear/no activation is used
+        :param padding:         padding: valid or same
+        :param name:            layer name
+        :param name_postfix:    layer name postfix
+        :return: conv, batch_norm, nonlin - convolution, batch normalization and nonlinearity/activation layer
+        """
+        with tf.name_scope(name + name_postfix):
+            conv = tf.layers.conv2d(input_layer, filters=filter_scale * n_filters, kernel_size=filter_size,
+                                    activation=None, padding=padding, name='conv_' + name_postfix)
+            if nonlin_f:
+                nonlin = nonlin_f(conv, name='activation_' + name_postfix)
+            else:
+                nonlin = None
+        return conv, nonlin
+
+    @staticmethod
+    def _pool_layer(net, pool_size, stride_size, type='max', padding='same', name='pooling'):
+        """
+        Pooling layer
+        :param net:             network layer
+        :param pool_size:       pooling size
+        :param stride_size:     stride size
+        :param type:            pooling type: max, average
+        :param padding:         padding: valid or same
+        :param name:            layer name
+        :return:
+        """
+        pre_pool = net
+        if type == 'max':
+            net = tf.layers.max_pooling2d(net, pool_size, stride_size, padding=padding, name=name)
+        elif type == 'avg':
+            net = tf.layers.average_pooling2d(net, pool_size, stride_size, padding=padding, name=name)
+        return pre_pool, net
+
+    def return_accuracy(self, y_pred, y_true, b_s=None, net_type=None, loss_type=None):
+        """
+        Returns the prediction accuracy
+        :param y_pred:  prediction
+        :param y_true:  ground truth
+        :return:        accuracy
+        """
+        return self._accuracy_function(y_pred=y_pred, y_true=y_true, b_s=b_s, net_type=net_type, loss_type=loss_type)
+
+    def return_loss(self, y_pred, y_true):
+        """
+        Returns the loss
+        :param y_pred:  prediction
+        :param y_true:  ground truth
+        :return:        loss
+        """
+        return self._loss_function(y_pred=y_pred, y_true=y_true)
+
+    def return_optimizer(self, global_step):
+        """
+        Returns the optimizer function
+        :param global_step: current global step
+        :return:            optimizer
+        """
+        return self._optimizer_function(global_step)
+
+    def return_nets(self):
+        """
+        Returns the network (only the convolutional layers)
+        :return:    network
+        """
+        return self.nets
+
+    @staticmethod
+    def weights_and_biases(a, b):
+        w = tf.Variable(tf.truncated_normal(shape=[a, b], stddev=np.sqrt(2 / a)))
+        b = tf.Variable(tf.zeros([b]))
+
+        return w, b
+
diff --git a/network/wrappers/UNet.py b/network/wrappers/UNet.py
new file mode 100644
index 0000000..b99d50a
--- /dev/null
+++ b/network/wrappers/UNet.py
@@ -0,0 +1,129 @@
+#!/usr/bin/env python
+# -----------------------------------------------------------------------------
+# Copyright (C) Software Competence Center Hagenberg GmbH (SCCH)
+# All rights reserved.
+# -----------------------------------------------------------------------------
+# This document contains proprietary information belonging to SCCH.
+# Passing on and copying of this document, use and communication of its
+# contents is not permitted without prior written authorization.
+# -----------------------------------------------------------------------------
+# Created on : 12/07/2017 11:02 $
+# by : shepeleva $
+# SVN : $
+#
+
+# --- imports -----------------------------------------------------------------
+
+import tensorflow as tf
+from network.wrappers.NetworkBase import NetworkBase
+
+
+class UNet(NetworkBase):
+    def __init__(self, network_type, loss, accuracy, lr, training, framework, trainable_layers=None, num_filters=16,
+                 optimizer='adam', nonlin='elu', upconv='upconv', num_classes=None):
+        """
+
+        :param is_training:
+        """
+        super().__init__(network_type, loss, accuracy, lr, training, framework, optimizer, nonlin, upconv, num_filters,
+                         trainable_layers=trainable_layers, num_classes=num_classes)
+        self.weights, self.biases, self.nets = [], [], []
+
+    def build_net_tf(self, X):
+        """
+
+        :param X:        input tensor
+        :return:
+        """
+
+        with tf.name_scope('encoder'):
+            e_conv_1, e_batch_1, e_activ_1 = self._conv_bn_layer(X, n_filters=self.num_filters, filter_scale=1,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, padding='same',
+                                                                 name='e_conv_bn', name_postfix='_1')
+            e_conv_2, e_batch_2, e_activ_2 = self._conv_bn_layer(e_activ_1, n_filters=self.num_filters, filter_scale=1,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f ,padding='same',
+                                                                 name='e_conv_bn', name_postfix='_2')
+            p1 = e_activ_2
+            pool_1 = tf.layers.max_pooling2d(e_activ_2, pool_size=2, strides=2, padding='same', name='pooling_1')
+
+            e_conv_3, e_batch_3, e_activ_3 = self._conv_bn_layer(pool_1, n_filters=self.num_filters, filter_scale=2,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, padding='same',
+                                                                 name='e_conv_bn', name_postfix='_3')
+            e_conv_4, e_batch_4, e_activ_4 = self._conv_bn_layer(e_activ_3, n_filters=self.num_filters, filter_scale=2,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, padding='same',
+                                                                 name='e_conv_bn', name_postfix='_4')
+            p2 = e_activ_4
+            pool_2 = tf.layers.max_pooling2d(e_activ_4, pool_size=2, strides=2, padding='same', name='pooling_2')
+
+            e_conv_5, e_batch_5, e_activ_5 = self._conv_bn_layer(pool_2, n_filters=self.num_filters, filter_scale=4,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, padding='same',
+                                                                 name='e_conv_bn', name_postfix='_5')
+            e_conv_6, e_batch_6, e_activ_6 = self._conv_bn_layer(e_activ_5, n_filters=self.num_filters, filter_scale=4,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, padding='same',
+                                                                 name='e_conv_bn', name_postfix='_6')
+            p3 = e_activ_6
+            pool_3 = tf.layers.max_pooling2d(e_activ_6, pool_size=2, strides=2, padding='same', name='pooling_3')
+
+            e_conv_7, e_batch_7, e_activ_7 = self._conv_bn_layer(pool_3, n_filters=self.num_filters, filter_scale=8,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, padding='same',
+                                                                 name='e_conv_bn', name_postfix='_7')
+            e_conv_8, e_batch_8, e_activ_8 = self._conv_bn_layer(e_activ_7, n_filters=self.num_filters, filter_scale=8,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, padding='same',
+                                                                 name='e_conv_bn', name_postfix='_8')
+
+            self.nets.extend([e_conv_1, e_conv_2, pool_1, e_conv_3, e_conv_4, pool_2, e_conv_5, e_conv_6, pool_3,
+                              e_conv_7, e_conv_8])
+
+        with tf.name_scope('decoder'):
+            up_conv_1 = self.upconv_f(e_activ_8, filters=4 * self.num_filters, kernel_size=2, strides=2,
+                                      name='upconv_1')
+            concat_1 = tf.concat([p3, up_conv_1], axis=-1, name='concat_1')
+            d_conv_1, d_batch_1, d_activ_1 = self._conv_bn_layer(concat_1, n_filters=self.num_filters, filter_scale=4,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, padding='same',
+                                                                 name='d_conv_bn', name_postfix='_9')
+            d_conv_2, d_batch_2, d_activ_2 = self._conv_bn_layer(d_activ_1, n_filters=self.num_filters, filter_scale=4,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, padding='same',
+                                                                 name='d_conv_bn', name_postfix='_10')
+
+            up_conv_2 = self.upconv_f(d_activ_2, filters=2 * self.num_filters, kernel_size=2, strides=2,
+                                      name='upconv_2')
+            concat_2 = tf.concat([p2, up_conv_2], axis=-1, name='concat_2')
+            d_conv_3, d_batch_3, d_activ_3 = self._conv_bn_layer(concat_2, n_filters=self.num_filters, filter_scale=2,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, padding='same',
+                                                                 name='d_conv_bn', name_postfix='_11')
+            d_conv_4, d_batch_4, d_activ_4 = self._conv_bn_layer(d_activ_3, n_filters=self.num_filters, filter_scale=2,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, padding='same',
+                                                                 name='d_conv_bn', name_postfix='_12')
+
+            up_conv_3 = self.upconv_f(d_activ_4, filters=self.num_filters, kernel_size=2, strides=2, name='upconv_3')
+            concat_3 = tf.concat([p1, up_conv_3], axis=-1, name='concat_3')
+            d_conv_5, d_batch_5, d_activ_5 = self._conv_bn_layer(concat_3, n_filters=self.num_filters, filter_scale=1,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, padding='same',
+                                                                 name='d_conv_bn', name_postfix='_13')
+            d_conv_6, d_batch_6, d_activ_6 = self._conv_bn_layer(d_activ_5, n_filters=self.num_filters, filter_scale=1,
+                                                                 filter_size=3, is_training=self.is_training,
+                                                                 nonlin_f=self.nonlin_f, padding='same',
+                                                                 name='d_conv_bn', name_postfix='_14')
+
+            self.nets.extend([up_conv_1, concat_1, d_conv_1, d_conv_2, up_conv_2, concat_2, d_conv_3, d_conv_4,
+                              up_conv_3, concat_3, d_conv_5, d_conv_6])
+
+        with tf.name_scope('output'):
+            output = tf.layers.conv2d(d_activ_6, filters=self.num_classes, kernel_size=3, activation=None, padding='same',
+                                      name='output')
+            self.nets.append(output)
+
+        return output
diff --git a/network/wrappers/__init__.py b/network/wrappers/__init__.py
new file mode 100644
index 0000000..2e789cd
--- /dev/null
+++ b/network/wrappers/__init__.py
@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+# -----------------------------------------------------------------------------
+# Copyright (C) Software Competence Center Hagenberg GmbH (SCCH)
+# All rights reserved.
+# -----------------------------------------------------------------------------
+# This document contains proprietary information belonging to SCCH.
+# Passing on and copying of this document, use and communication of its
+# contents is not permitted without prior written authorization.
+# -----------------------------------------------------------------------------
+# Created on : 12/07/2017 13:59 $
+# by : shepeleva $
+# SVN : $
+#
+
+# --- imports -----------------------------------------------------------------
diff --git a/requirments.txt b/requirments.txt
new file mode 100644
index 0000000..5dc92b2
--- /dev/null
+++ b/requirments.txt
@@ -0,0 +1,10 @@
+sklearn
+numpy
+h5py
+tensorflow-gpu
+https://download.pytorch.org/whl/cu90/torch-1.0.1-cp36-cp36m-win_amd64.whl
+torchvision
+matplotlib
+seaborn
+tqdm
+numba
diff --git a/utils/BatchIterator.py b/utils/BatchIterator.py
new file mode 100644
index 0000000..1b85edb
--- /dev/null
+++ b/utils/BatchIterator.py
@@ -0,0 +1,257 @@
+#!/usr/bin/env python
+# -----------------------------------------------------------------------------
+# Copyright (C) Software Competence Center Hagenberg GmbH (SCCH)
+# All rights reserved.
+# -----------------------------------------------------------------------------
+# This document contains proprietary information belonging to SCCH.
+# Passing on and copying of this document, use and communication of its
+# contents is not permitted without prior written authorization.
+# -----------------------------------------------------------------------------
+# Created on : 02/21/2018 16:55 $
+# by : shepeleva $
+# SVN : $
+#
+
+# --- imports -----------------------------------------------------------------
+
+import numpy as np
+from utils.utils import *
+
+
+class BatchIterator:
+
+    def __init__(self, file_name, data_split, img_size, num_lbls, batch_size, task_type, is_training, augment_dict=None,
+                 shuffle_key=False, colormap=None):
+        self.file_name = file_name
+        self.data_split = data_split
+        self.task_type = task_type
+        self.is_training = is_training
+        self.augment_dict = augment_dict
+        self._preprocess_data(img_size, num_lbls, batch_size, colormap)
+
+
+        if shuffle_key and not self.is_training:
+            self._shuffle()
+        else:
+            self.permutation_list = self.data_split
+
+        if (self.task_type == 'classification') or (self.task_type == 'segmentation'):
+            self.iterator = iter(self.permutation_list[0:self.max_lim])
+        elif self.task_type == 'prediction':
+
+            frames_max = [int(self.max_num_frames[i] / self.batch_size)*self.batch_size for i in self.permutation_list]
+            scenes_list_g = sum([self.permutation_list[i] * frames_max[i] for i in range(len(frames_max))], [])
+            frames_list_g = [k for i in frames_max for k in range(i)]
+
+            scenes_list_x = scenes_list_g[self.batch_size-1::self.batch_size]
+            frames_list_x = frames_list_g[self.batch_size-1::self.batch_size]
+            scenes_list_y = scenes_list_g[::self.batch_size]
+            frames_list_y = frames_list_g[::self.batch_size]
+
+            self.iterator = iter(zip(scenes_list_x, frames_list_x, scenes_list_y, frames_list_y))
+        elif self.task_type == 'detection':
+            raise ValueError("Not implemented")
+
+        try:
+            self.current = next(self.iterator)
+        except StopIteration:
+            self.on_going = False
+        else:
+            self.on_going = True
+
+    def _preprocess_data(self, img_size, num_lbls, batch_size, colormap):
+        self.X_key = 'X_data'
+        self.y_key = 'y_data'
+        self.size = len(self.data_split)
+        self.img_size = img_size
+        self.num_lbls = num_lbls
+        self.batch_size = batch_size
+        if self.is_training:
+            self.max_lim = int(self.size / self.batch_size) * self.batch_size
+        else:
+            self.max_lim = self.size
+        if self.task_type is 'segmentation':
+            self.colormap = colormap
+
+
+
+    def get_max_lim(self):
+        return int(self.max_lim / self.batch_size)
+
+    def _shuffle(self):
+        import random
+        self.permutation_list = random.sample(self.data_split, len(self.data_split))
+
+    def __iter__(self):
+        if self.task_type == 'classification':
+            while self.on_going:
+                yield self._next_batch_classification()
+        elif self.task_type == 'segmentation':
+            while self.on_going:
+                yield self._next_batch_segmentation()
+        elif self.task_type == 'prediction':
+            while self.on_going:
+                yield self._next_batch_prediction()
+
+
+    # @jit(nopython=True)
+    def _next_batch_segmentation(self):
+        imgs = self.file_name[self.X_key][self.current]
+        if self.file_name[self.y_key][:].size != 0:
+            msks = self.file_name[self.y_key][self.current]
+            if not list(self.img_size) == imgs[0].shape:
+                imgs, msks = self._resize_data(imgs, msks)
+            if self.augment_dict:
+                imgs, msks = self._augment_data(imgs, msks)
+            msks = self._recode_masks(msks)
+            yield imgs, msks
+        else:
+            if not list(self.img_size) == imgs[0].shape:
+                imgs = self._resize_data(imgs)
+            if self.augment_dict:
+                imgs = self._augment_data(imgs)
+            yield imgs, None
+        # start enumerate at 1 because we already yielded the last saved item
+        for num, item in enumerate(self.iterator, 1):
+            imgs = self.file_name[self.X_key][item]
+            if self.file_name[self.y_key][:].size != 0:
+                msks = self.file_name[self.y_key][item]
+                if not list(self.img_size) == imgs[0].shape:
+                    imgs, msks = self._resize_data(imgs, msks)
+                if self.augment_dict:
+                    imgs, msks = self._augment_data(imgs, msks)
+                self.current = item
+                if num == self.batch_size:
+                    break
+                msks = self._recode_masks(msks)
+                yield imgs, msks
+            else:
+                if not list(self.img_size) == imgs[0].shape:
+                    imgs = self._resize_data(imgs)
+                if self.augment_dict:
+                    imgs = self._augment_data(imgs)
+                self.current = item
+                if num == self.batch_size:
+                    break
+                yield imgs, None
+        else:
+            self.on_going = False
+
+    # @jit(nopython=True)
+    def _next_batch_classification(self):
+        imgs = self.file_name[self.X_key][self.current]
+        lbls = self.file_name[self.y_key][self.current]
+        if not list(self.img_size) == imgs[0].shape:
+            imgs = self._resize_data(imgs)
+        if self.augment_dict:
+            imgs = self._augment_data(imgs)
+        yield imgs, lbls
+        for num, item in enumerate(self.iterator, 1):
+            imgs = self.file_name[self.X_key][item]
+            lbls = self.file_name[self.y_key][item]
+            if not list(self.img_size) == imgs[0].shape:
+                imgs = self._resize_data(imgs)
+            if self.augment_dict:
+                imgs = self._augment_data(imgs)
+            self.current = item
+            if num == self.batch_size:
+                break
+            yield imgs, lbls
+        else:
+            self.on_going = False
+
+    # @jit(nopython=True)
+    def _next_batch_prediction(self):
+        x_ped_id = np.where(self.file_name[self.X_key][self.current[0]][0] == self.current[1])[0]
+        y_ped_id = np.where(self.file_name[self.X_key][self.current[2]][0] == self.current[3])[0]
+        x = self.file_name[self.X_key][self.current[0]][2::, x_ped_id[0]:x_ped_id[-1]]
+        y = self.file_name[self.X_key][self.current[2]][2::, y_ped_id[0]:y_ped_id[-1]]
+        yield x, y
+        # start enumerate at 1 because we already yielded the last saved item
+        for num, item in enumerate(self.iterator, 1):
+            x_ped_id = np.where(self.file_name[self.X_key][item[0]][0] == item[1])[0]
+            y_ped_id = np.where(self.file_name[self.X_key][item[2]][0] == item[3])[0]
+            x = self.file_name[self.X_key][item[0]][2::, x_ped_id[0]:x_ped_id[-1]]
+            y = self.file_name[self.X_key][item[2]][2::, y_ped_id[0]:y_ped_id[-1]]
+            self.current = item
+            if num == self.batch_size:
+                break
+            yield x, y
+        else:
+            self.on_going = False
+
+    # @jit(nopython=True)
+    def _resize_data(self, imgs, msks=None):
+        """
+
+        :param imgs:
+        :param msks:
+        :return:
+        """
+        if msks is None:
+            imgs = resize_images_cpu(imgs, self.img_size)
+            # imgs = cv2.resize(imgs, (self.img_size[1], self.img_size[0]), interpolation=cv2.INTER_LINEAR)
+            return imgs
+        else:
+            imgs = resize_images_cpu(imgs, self.img_size)
+            msks = resize_images_cpu(msks, self.img_size)
+            # imgs = cv2.resize(imgs, (self.img_size[1], self.img_size[0]), interpolation=cv2.INTER_LINEAR)
+            # msks = cv2.resize(msks, (self.img_size[1], self.img_size[0]), interpolation=cv2.INTER_LINEAR)
+            return imgs, msks
+
+    # @jit(nopython=True)
+    def _augment_data(self, imgs, msks=None):
+        """
+
+        :param n:
+        :param imgs:
+        :param msks:
+        :return:
+        """
+        if msks is None:
+            if self.augment_dict['flip_hor']:
+                if np.random.randint(2) == 1:
+                    imgs = np.flip(imgs, axis=0)
+            if self.augment_dict['flip_vert']:
+                if np.random.randint(2) == 1:
+                    imgs = np.flip(imgs, axis=1)
+            return imgs
+        else:
+            if self.augment_dict['flip_hor']:
+                if np.random.randint(2) == 1:
+                    imgs = np.flip(imgs, axis=0)
+                    msks = np.flip(msks, axis=0)
+            if self.augment_dict['flip_vert']:
+                if np.random.randint(2) == 1:
+                    imgs = np.flip(imgs, axis=1)
+                    msks = np.flip(msks, axis=1)
+            return imgs, msks
+
+    # @jit(nopython=True)
+    def _recode_masks(self, msks):
+        # only if segmentation colors are encoded as class labels or binary
+        if ((len(msks.shape) == 3) and (np.array_equal(msks[:, :, 0], msks[:, :, 1]))) or (len(msks.shape) != 3):
+            new_img = np.zeros([msks.shape[0], msks.shape[1], self.num_lbls])
+            img = msks[:, :, 0]
+            # binary segmentation - known bag: binary segmentation only
+            if self.num_lbls == 2:
+                img = img//255
+                new_img[:, :, 0] = img
+                new_img[:, :, 1] = 1 - img
+            else:
+                for j in range(0, self.num_lbls):
+                    x_ind, y_ind = np.where(img == j)
+                    for ind in range(0, len(x_ind)):
+                        new_img[x_ind[[ind]], y_ind[ind], j] = 1
+            return new_img
+        else:  # if segmentation colors are encoded as rgb
+            if self.colormap and isinstance(self.colormap, dict) and (len(self.colormap) == self.num_lbls):
+                new_img = np.zeros([msks.shape[0], msks.shape[1], self.num_lbls])
+                for k, v in self.colormap:
+                    x_ind, y_ind = np.where(
+                        (msks[:, :, 0] == v[0]) & (msks[:, :, 1] == v[1]) & (msks[:, :, 2] == v[2]))
+                    for ind in range(0, len(x_ind)):
+                        new_img[x_ind[[ind]], y_ind[ind], k] = 1
+                return new_img
+            else:
+                raise ValueError("Colormap is required in a dictionary format {label: (R, G, B}")
\ No newline at end of file
diff --git a/utils/DataParser.py b/utils/DataParser.py
new file mode 100644
index 0000000..d576a60
--- /dev/null
+++ b/utils/DataParser.py
@@ -0,0 +1,588 @@
+#!/usr/bin/env python
+# -----------------------------------------------------------------------------
+# Copyright (C) Software Competence Center Hagenberg GmbH (SCCH)
+# All rights reserved.
+# -----------------------------------------------------------------------------
+# This document contains proprietary information belonging to SCCH.
+# Passing on and copying of this document, use and communication of its
+# contents is not permitted without prior written authorization.
+# -----------------------------------------------------------------------------
+# Created on : 2/20/2019 1:10 PM $ 
+# by : shepeleva $ 
+# SVN  $
+#
+
+# --- imports -----------------------------------------------------------------
+
+import ast
+import json
+import h5py
+import numpy as np
+from sklearn.model_selection import train_test_split
+import time
+from utils.utils import *
+
+
+class DataParser:
+
+    def __init__(self, data_set, data_file, data_folder, num_classes, img_size, normalize, zero_center, data_split, cross_val,
+                 task_type, training_mode, multi_task, experiment_path, framework):
+        self.data_set = data_set
+        self.data_file = data_file
+        self.data_folder = data_folder
+        self.num_classes = num_classes
+        self.img_size = img_size
+        self.normalize = normalize
+        self.zero_center = zero_center
+        self.data_split = data_split
+        self.cross_val = cross_val
+        self.task_key = task_type
+        self.is_training = training_mode
+        self.multi_task = multi_task
+        self.timestamp = str(time.time())
+        self.experiment_path = experiment_path
+        self.framework = framework
+
+        if self.is_training:
+            self._check_data_split()
+
+        self._parse_data()
+
+
+
+    def get_data_size(self):
+        return self.data_size
+
+    def get_file_name(self):
+        return self.dict_data_path
+
+    def get_log_name(self):
+        return self.log_info_path
+
+    def get_inference_data(self):
+        return self.X_data, self.y_data
+
+    def get_timestamp(self):
+        return self.timestamp
+
+    def get_ckpnt_path(self):
+        return self.ckpnt_path
+
+    def get_tr_path(self):
+        return self.tr_path
+
+    def _parse_data(self):
+        self._path_preparation()
+
+        file_name = self.data_set
+        if self.img_size:
+            file_name += '_resized({:d}x{:d})'.format(self.img_size[0], self.img_size[1])
+        if self.normalize:
+            file_name += '_norm'
+        if self.zero_center:
+            file_name += '_cent'
+        file_name += '.hdf5'
+
+        if not os.path.exists(os.path.join(self.data_path, self.data_set)):
+            os.makedirs(os.path.join(self.data_path, self.data_set))
+
+        if not os.path.exists(os.path.join(self.info_path, self.data_set)):
+            os.makedirs(os.path.join(self.info_path, self.data_set))
+
+        if not os.path.exists(os.path.join(self.tr_path, self.data_set)):
+            os.makedirs(os.path.join(self.tr_path, self.data_set))
+
+        if not os.path.exists(os.path.join(self.ckpnt_path, self.data_set)):
+            os.makedirs(os.path.join(self.ckpnt_path, self.data_set))
+
+        h5py_file_name = os.path.join(self.data_path, self.data_set, file_name)
+        log_file_name = os.path.join(self.info_path, self.data_set, self.timestamp + ".json")
+
+
+        if self.data_set is "MNIST":
+            self._load_mnist(h5py_file_name, log_file_name)
+        elif self.data_set is "CIFAR10":
+            self._load_cifar10(h5py_file_name, log_file_name)
+        elif self.data_set is "CIFAR100":
+            self._load_cifar100(h5py_file_name, log_file_name)
+        elif self.data_set in ["", " ", None]:
+            raise ValueError('Dataset name should be defined')
+        else:
+            if self.data_file:
+                self._data_file_parse(h5py_file_name, log_file_name)
+            elif self.data_folder:
+                self._data_folder_parse(h5py_file_name, log_file_name)
+            else:
+                raise ValueError('No data presented')
+
+    def _data_file_parse(self, h5py_file_name, log_file_name):
+        if os.path.splitext(self.data_file)[1] is '.txt':
+            x_list, y_list = self._process_txt()
+        elif os.path.splitext(self.data_file)[1] is '.json':
+            x_list, y_list = self._process_json()
+        else:
+            raise ValueError('Data format is not supported. Check documentation for data type support.')
+        if self.is_training:
+            if not os.path.isfile(h5py_file_name):
+                # TODO: add normalization and zero-centering
+                try:
+                    self.slice_split = self._cross_val_split(len(x_list))
+                    self.data_size = len(x_list)
+                    self._dump_h5py(h5py_file_name, x_list, one_hot_encode(y_list))
+                    self._dump_json_logs(h5py_file_name, log_file_name)
+                    self.dict_data_path = h5py_file_name
+                    self.log_info_path = log_file_name
+                except KeyError:
+                    raise ValueError("Unable to dump file")
+            else:
+                h5_file = h5py.File(h5py_file_name, 'r')
+                self.data_size = len(h5_file['X_data'])
+                self.slice_split = self._cross_val_split(len(h5_file['y_data']))
+                h5_file.close()
+                self._dump_json_logs(h5py_file_name, log_file_name)
+                self.dict_data_path = h5py_file_name
+                self.log_info_path = log_file_name
+        else:
+            self.X_data = x_list
+            self.y_data = y_list
+
+    def _process_txt(self):
+        with open(self.data_file, 'r') as f:
+            file_lines = f.readlines()
+        line = file_lines[0].rstrip()
+        if len(line.split()) == 1:
+            if self.is_training:
+                raise ValueError("not sufficient data for given task")
+            else:
+                if (os.path.splitext(line)[1].lower() in ['.jpg', '.jpeg', '.png']):
+                    X_data_ = [line.rstrip().split()[0] for line in file_lines]
+                    y_data_ = []
+        else:
+            if self.task_key is "classification":
+                if (os.path.splitext(line.split()[0])[1].lower() in ['.jpg', '.jpeg', '.png']) and isinstance(ast.literal_eval(line.rstrip().split()[1]), int):
+                    print("Classificaiton data detected. Integer encoded")
+                    X_data_ = [line.rstrip().split()[0] for line in file_lines]
+                    y_data_ = [int(line.rstrip().split()[1]) for line in file_lines]
+                elif (os.path.splitext(line.split()[0])[1].lower() in ['.jpg', '.jpeg', '.png']) and isinstance(ast.literal_eval(''.join(line.rstrip().split()[1:])), list) and (sum(ast.literal_eval(''.join(line.rstrip().split()[1:]))) == 1):
+                    print("Classificaiton data detected. One hot encoded")
+                    X_data_ = [line.rstrip().split()[0] for line in file_lines]
+                    y_data_ = [ast.literal_eval(''.join(line.rstrip().split()[1:])) for line in file_lines]
+                else:
+                    raise ValueError("Incorrect data representation")
+            elif (self.task_key is "segmentation") or (self.task_key is "gan"):
+                if (os.path.splitext(line.split()[0])[1].lower() in ['.jpg', '.jpeg', '.png']) and (
+                        os.path.splitext(line.rstrip().split()[1])[1].lower() in ['.jpg', '.jpeg', '.png']):
+                    X_data_ = [line.rstrip().split()[0] for line in file_lines]
+                    y_data_ = [line.rstrip().split()[1] for line in file_lines]
+                else:
+                    raise ValueError("Incorrect data representation")
+            elif self.task_key is "detection":
+                if (os.path.splitext(line.split()[0])[1].lower() in ['.jpg', '.jpeg', '.png']) and isinstance(ast.literal_eval(''.join(line.rstrip().split()[1:])), list):
+                    X_data_ = [line.rstrip().split()[0] for line in file_lines]
+                    y_data_ = [ast.literal_eval(''.join(line.rstrip().split()[1:])) for line in file_lines]
+                else:
+                    raise ValueError("Incorrect data representation")
+            else:
+                raise ValueError('Such task not supported')
+
+        return X_data_, y_data_
+
+    def _process_json(self):
+        with open(self.data_file, 'r') as f:
+            file_lines = json.load(f)
+
+        if file_lines['source_path'] is [None, 'null', '']:
+            raise ValueError("Source path is not specified")
+        else:
+            if file_lines['mask_path'] is [None, 'null', '']:
+                if self.task_key is "classification":
+                    X_data_ = [d['frame'] for d in file_lines['meta']]
+                    y_data_ = [o['object_class'] for d in file_lines['meta'] for o in d['frame']]
+                elif self.task_key is "detection":
+                    X_data_ = [d['frame'] for d in file_lines['meta']]
+                    y_data_ = [o['bb'] for d in file_lines['meta'] for o in d['frame']]
+                else:
+                    raise ValueError('Such task not supported')
+            else:
+                if (self.task_key is "segmentation") or (self.task_key is "gan"):
+                    X_data_ = [d['frame'] for d in file_lines['meta']]
+                    y_data_ = [d['mask'] for d in file_lines['meta']]
+                else:
+                    raise ValueError('Such task not supported')
+
+        return X_data_, y_data_
+
+    def _data_folder_parse(self, h5py_file_name, log_file_name):
+        path_list = [i for i in os.listdir(self.data_folder) if os.path.isdir(i)]
+        if len(path_list) < 2:
+            if self.is_training:
+                raise ValueError("not sufficient data for given task")
+            else:
+                x_list = path_walk(os.path.join(self.data_folder, path_list[0]))
+                y_list = []
+            # raise ValueError('Not sufficient number of folders')
+        else:
+            if self.task_key is "classification":
+                x_list = []
+                y_list = []
+                for i in range(len(path_list)):
+                    for dirpath, _, filenames in os.walk(path_list[i]):
+                        for f in filenames:
+                            if f.lower().endswith(tuple(['.jpg', '.jpeg', '.png'])):
+                                x_list.append(os.path.abspath(os.path.join(dirpath, f)))
+                                y_list.append(i)
+            elif self.task_key is "segmentation":
+                if "images" in path_list and "masks" in path_list:
+                    x_list = path_walk(os.path.join(self.data_folder, 'images'))
+                    y_list = path_walk(os.path.join(self.data_folder, 'masks'))
+                else:
+                    raise ValueError('Incorrect folder names for segmentation task')
+            elif self.task_key is "gan":
+                if "A" in path_list and "B" in path_list:
+                    x_list = path_walk(os.path.join(self.data_folder, 'A'))
+                    y_list = path_walk(os.path.join(self.data_folder, 'B'))
+                else:
+                    raise ValueError('Incorrect folder names for GAN task')
+            else:
+                raise ValueError('Such task not supported')
+
+            # TODO: add normalization and zero-centering
+        if self.is_training:
+            if not os.path.isfile(h5py_file_name):
+                try:
+                    self.slice_split = self._cross_val_split(len(x_list))
+                    self.data_size = len(x_list)
+                    self._dump_h5py(h5py_file_name, x_list, one_hot_encode(y_list))
+                    self._dump_json_logs(h5py_file_name, log_file_name)
+                    self.dict_data_path = h5py_file_name
+                    self.log_info_path = log_file_name
+                except KeyError:
+                    raise ValueError("Unable to dump file")
+            else:
+                h5_file = h5py.File(h5py_file_name, 'r')
+                self.data_size = len(h5_file['X_data'])
+                self.slice_split = self._cross_val_split(len(h5_file['y_data']))
+                h5_file.close()
+                self._dump_json_logs(h5py_file_name, log_file_name)
+                self.dict_data_path = h5py_file_name
+                self.log_info_path = log_file_name
+        else:
+            self.X_data = x_list
+            self.y_data = y_list
+
+    def _load_mnist(self, h5py_file_name, log_file_name):
+
+        print('Creating h5py file for MNIST')
+        if self.framework is 'tensorflow':
+            import tensorflow as tf
+            mnist = tf.keras.datasets.mnist
+            if self.is_training:
+                (X_data, y_data), _ = mnist.load_data()
+            else:
+                _, (self.X_data, self.y_data) = mnist.load_data()
+            # y_data = one_hot_encode(y_data)
+        elif self.framework is 'pytorch':
+            import torchvision.datasets as datasets
+            mnist_trainset = datasets.MNIST(root=os.path.join(self.info_path, self.data_set), train=True, download=True, transform=None)
+            import struct
+            if self.is_training:
+                with open(os.path.join(self.info_path, self.data_set + r'/raw/train-labels-idx1-ubyte'), 'rb') as lbpath:
+                    magic, n = struct.unpack('>II', lbpath.read(8))
+                    y_data = np.fromfile(lbpath, dtype=np.uint8).tolist()
+
+                with open(os.path.join(self.info_path, self.data_set + r'/raw/train-images-idx3-ubyte'), 'rb') as imgpath:
+                    magic, num, rows, cols = struct.unpack(">IIII", imgpath.read(16))
+                    X_data = np.fromfile(imgpath, dtype=np.uint8).reshape((-1, 28, 28, 1))
+            else:
+                with open(os.path.join(self.info_path, self.data_set + r'/raw/test-labels-idx1-ubyte'),
+                          'rb') as lbpath:
+                    magic, n = struct.unpack('>II', lbpath.read(8))
+                    self.y_data = np.fromfile(lbpath, dtype=np.uint8).tolist()
+
+                with open(os.path.join(self.info_path, self.data_set + r'/raw/test-images-idx3-ubyte'),
+                          'rb') as imgpath:
+                    magic, num, rows, cols = struct.unpack(">IIII", imgpath.read(16))
+                    self.X_data = np.fromfile(imgpath, dtype=np.uint8).reshape((-1, 28, 28, 1))
+
+        else:
+            raise ValueError('Framework does not exist')
+
+        if self.is_training:
+            if not os.path.isfile(h5py_file_name):
+                # TODO: add normalization and zero-centering
+                try:
+                    self.data_size = len(X_data)
+                    self.slice_split = self._cross_val_split(len(y_data))
+                    # self._dump_h5py(h5py_file_name, X_data, one_hot_encode(y_data))
+                    with h5py.File(h5py_file_name, 'a') as f:
+                        f.create_dataset('X_data', data=X_data)
+                        f.create_dataset('y_data', data=one_hot_encode(y_data))
+                    self._dump_json_logs(h5py_file_name, log_file_name)
+                    self.dict_data_path = h5py_file_name
+                    self.log_info_path = log_file_name
+                except KeyError:
+                    raise ValueError("Unable to dump file")
+            else:
+                h5_file = h5py.File(h5py_file_name, 'r')
+                self.data_size = len(h5_file['X_data'])
+                self.slice_split = self._cross_val_split(len(h5_file['y_data']))
+                h5_file.close()
+                self._dump_json_logs(h5py_file_name, log_file_name)
+                self.dict_data_path = h5py_file_name
+                self.log_info_path = log_file_name
+
+    def _load_cifar10(self, h5py_file_name, log_file_name):
+        print('Creating h5py file for CIFAR10')
+        if self.framework is 'tensorflow':
+            import tensorflow as tf
+            cifar10 = tf.keras.datasets.cifar10
+            if self.is_training:
+                (X_data, y_data), _ = cifar10.load_data()
+            else:
+                _, (X_data, y_data) = cifar10.load_data()
+
+        elif self.framework is "pytorch":
+            import torchvision.datasets as datasets
+            if self.is_training:
+                cifar_trainset = datasets.CIFAR10(root=os.path.join(self.info_path, self.data_set), train=True, download=True, transform=None)
+                X_data = cifar_trainset.train_data
+                y_data = cifar_trainset.train_labels
+            else:
+                cifar_trainset = datasets.CIFAR10(root=os.path.join(self.info_path, self.data_set), train=False, download=True, transform=None)
+                self.X_data = cifar_trainset.test_data
+                self.y_data = cifar_trainset.test_labels
+
+        else:
+            raise ValueError('Framework does not exist')
+
+        if self.is_training:
+            if not os.path.isfile(h5py_file_name):
+            # TODO: add normalization and zero-centering
+                try:
+                    self.data_size = len(X_data)
+                    self.slice_split = self._cross_val_split(len(y_data))
+                    self._dump_h5py(h5py_file_name, X_data, one_hot_encode(y_data))
+                    self._dump_json_logs(h5py_file_name, log_file_name)
+                    self.dict_data_path = h5py_file_name
+                    self.log_info_path = log_file_name
+                except KeyError:
+                    raise ValueError("Unable to dump file")
+            else:
+                h5_file = h5py.File(h5py_file_name, 'r')
+                self.data_size = len(h5_file['X_data'])
+                self.slice_split = self._cross_val_split(len(h5_file['y_data']))
+                h5_file.close()
+                self._dump_json_logs(h5py_file_name, log_file_name)
+                self.dict_data_path = h5py_file_name
+                self.log_info_path = log_file_name
+
+    def _load_cifar100(self, h5py_file_name, log_file_name):
+        if not os.path.isfile(h5py_file_name):
+            print('Creating h5py file for CIFAR100')
+            if self.framework is 'tensorflow':
+                import tensorflow as tf
+                if self.is_training:
+                    cifar100 = tf.keras.datasets.cifar100
+                    (X_data, y_data), _ = cifar100.load_data()
+                else:
+                    cifar100 = tf.keras.datasets.cifar100
+                    _, (X_data, y_data) = cifar100.load_data()
+
+            elif self.framework is "pytorch":
+                import torchvision.datasets as datasets
+                if self.is_training:
+                    cifar_trainset = datasets.CIFAR100(root=os.path.join(self.info_path, self.data_set), train=True, download=True, transform=None)
+                    X_data = cifar_trainset.train_data
+                    y_data = cifar_trainset.train_labels
+                else:
+                    cifar_trainset = datasets.CIFAR100(root=os.path.join(self.info_path, self.data_set), train=True, download=True, transform=None)
+                    self.X_data = cifar_trainset.test_data
+                    self.y_data = cifar_trainset.test_labels
+
+            else:
+                raise ValueError('Framework does not exist')
+        if self.is_training:
+            if not os.path.isfile(h5py_file_name):
+            # TODO: add normalization and zero-centering
+                try:
+                    self.data_size = len(X_data)
+                    self.slice_split = self._cross_val_split(len(y_data))
+                    self._dump_h5py(h5py_file_name, X_data, one_hot_encode(y_data))
+                    self._dump_json_logs(h5py_file_name, log_file_name)
+                    self.dict_data_path = h5py_file_name
+                    self.log_info_path = log_file_name
+                    print("Dataset preparation finished")
+                except KeyError:
+                    raise ValueError("Unable to dump file")
+            else:
+                h5_file = h5py.File(h5py_file_name, 'r')
+                self.data_size = len(h5_file['X_data'])
+                self.slice_split = self._cross_val_split(len(h5_file['y_data']))
+                h5_file.close()
+                self._dump_json_logs(h5py_file_name, log_file_name)
+                self.dict_data_path = h5py_file_name
+                self.log_info_path = log_file_name
+
+    def _dump_json_logs(self, h5py_file_name, log_file_name):
+        log_dict = {'general_log': {'framework': self.framework,
+                                    'task': self.task_key
+                                    },
+                    'data_log': {'data_path': h5py_file_name,
+                                 'num_classes': self.num_classes,
+                                 'img_size': self.img_size,
+                                 'cross_val_split': self.slice_split,
+                                 'normalization': self.normalize,
+                                 'zero_center': self.zero_center
+                                 },
+                    'hyper_in_log': {},
+                    'hyper_out_log': {}}
+        try:
+            with open(log_file_name, 'w') as f:
+                json.dump(log_dict, f)
+        except KeyError:
+            raise ValueError("Unable to save logs")
+
+    def _dump_h5py(self, h5py_file_name, x_list, y_list):
+        if (self.task_key is 'segmentation') or (self.task_key is 'gan'):
+            with h5py.File(h5py_file_name, 'a') as f:
+                dset_x = f.create_dataset('X_data', (1, self.img_size[0], self.img_size[1], self.img_size[2]),
+                                          maxshape=(None, self.img_size[0], self.img_size[1], self.img_size[2]),
+                                          chunks=True)
+                dset_y = f.create_dataset('y_data', (1, self.img_size[0], self.img_size[1], self.num_classes),
+                                          maxshape=(None, self.img_size[0], self.img_size[1], self.num_classes),
+                                          chunks=True)
+                if isinstance(x_list[0], str):
+                    for i in range(0, len(x_list)):
+                        dset_x.resize(dset_x.shape[0] + 1, axis=0)
+                        dset_x[-dset_x.shape[0]:] = expand_dims(x_list[i], self.img_size)
+                        dset_y.resize(dset_y.shape[0] + 1, axis=0)
+                        dset_y[-dset_y.shape[0]:] = expand_dims(y_list[i], self.img_size)
+                else:
+                    for i in range(0, len(x_list)):
+                        dset_x.resize(dset_x.shape[0] + 1, axis=0)
+                        dset_x[-dset_x.shape[0]:] = expand_dims(x_list[i], self.img_size)
+                        dset_y.resize(dset_y.shape[0] + 1, axis=0)
+                        dset_y[-dset_y.shape[0]:] = expand_dims(y_list[i], self.img_size)
+        else:
+            with h5py.File(h5py_file_name, 'a') as f:
+                dset_x = f.create_dataset('X_data', (1, self.img_size[0], self.img_size[1], self.img_size[2]),
+                                          maxshape=(None, self.img_size[0], self.img_size[1], self.img_size[2]),
+                                          chunks=True)
+                if isinstance(x_list[0], str):
+                    for i in range(0, len(x_list)):
+                        dset_x.resize(dset_x.shape[0] + 1, axis=0)
+                        dset_x[-dset_x.shape[0]:] = expand_dims(x_list[i], self.img_size)
+                    f.create_dataset('y_data', data=y_list)
+                else:
+                    for i in range(0, len(x_list)):
+                        dset_x.resize(dset_x.shape[0] + 1, axis=0)
+                        dset_x[-dset_x.shape[0]:] = expand_dims(x_list[i], self.img_size)
+                    f.create_dataset('y_data', data=y_list)
+
+    def _check_data_split(self):
+        """
+
+        :return:
+        """
+        if self.data_split:
+            if (self.data_split > 1) or (self.data_split < 0.1):
+                raise ValueError('Incorrect data_split value')
+        else:
+            if not self.cross_val:
+                self.data_split = 0.7
+
+    def _cross_val_split(self, data_dim):
+        import random
+        ind = random.sample([i for i in range(data_dim)], data_dim)
+        if self.cross_val > 2 and self.cross_val < 10:
+            cross_val_patch_size = int(data_dim/self.cross_val)
+            slices = [ind[i:i+cross_val_patch_size] for i in range(0, data_dim, cross_val_patch_size)]
+        else:
+            print("Cross-validation is disabled. Will use data split instead")
+            if not self.data_split and self.data_split > 1 and self.data_split < 0.1:
+                print("Data split set up to 0.3")
+                self.data_split = 0.3
+                ind_train, ind_val = train_test_split(ind, test_size=self.data_split)
+            else:
+                ind_train, ind_val = train_test_split(ind, test_size=self.data_split)
+            slices = [ind_train, ind_val]
+
+        return slices
+
+    def _path_preparation(self):
+        if self.experiment_path is None:
+            self.experiment_path = os.path.join(os.path.dirname(os.path.abspath('utils')), "experiments")
+        if not os.path.isdir(self.experiment_path):
+            os.mkdir(self.experiment_path)
+        self.data_path = os.path.join(self.experiment_path, "datasets")
+        if not os.path.isdir(self.data_path):
+            os.mkdir(self.data_path)
+        self.info_path = os.path.join(self.experiment_path, "info_logs")
+        if not os.path.isdir(self.info_path):
+            os.mkdir(self.info_path)
+        self.tr_path = os.path.join(self.experiment_path, "train_logs")
+        if not os.path.isdir(self.tr_path):
+            os.mkdir(self.tr_path)
+        self.ckpnt_path = os.path.join(self.experiment_path, "ckpnt_logs")
+        if not os.path.isdir(self.ckpnt_path):
+            os.mkdir(self.ckpnt_path)
+
+
+    @staticmethod
+    def _preprocess_data_scope(img, msk=None, lbl=None, img_size=None, normalize=False, zero_center=False):
+        """
+        Preprocess data: zero-center, normalize, convert to one-hot
+        :param img:
+        :param msk:
+        :param data_mean:
+        :param data_std:
+        :param normalize:
+        :return:
+        """
+        # resize all images to same size
+        if img_size:
+            img_shapes = [x.shape for x in img]
+            # check if all images are equal to img_size
+            if not np.all(np.array(img_shapes) == img_size):
+                X_resized = []
+                for x in img:
+                    # resize data to given image size
+                    if np.any(np.array(img_size) != x.shape):
+                        X_resized.append(resize_images_gpu(x, img_size))
+                img = X_resized
+                if msk:
+                    y_resized = []
+                    for y_ in msk:
+                        # resize data to given image size
+                        if np.any(np.array(img_size) != y_.shape):
+                            y_resized.append(resize_images_gpu(y_, img_size))
+                    msk = y_resized
+        else:
+            img_shapes = [x.shape for x in img]
+            if not np.all(np.array(img_shapes) == img_shapes[0]):
+                raise ValueError(
+                    "All images and masks should be same size! Add image_size to config to reshape all images")
+
+        # check data range and convert to 0-1 range
+        if zero_center:
+            if np.max(img) > 1:
+                print('Data range [{:.2f}, {:.2f}]'.format(np.min(img), np.max(img)))
+                print('[PREPROCESS]\tConverting to [0, 1]')
+                img = [x / 255 for x in img]
+                assert (np.min(img) >= 0)
+                assert (np.max(img) <= 1)
+            # zero-center data
+            data_mean = np.mean(img)
+            img -= data_mean
+            print('[PREPROCESS]\tZero-centered data with data mean {:.2f} to min: {:.2f}, max: {:.2f}'
+                  .format(data_mean, img.min(), img.max()))
+
+        if normalize:
+            img /= np.std(img)
+            print('[PREPROCESS]\tNormalizing data by dividing by train STD! (std: {:.2f} - min: {:.2f}, max: {:.2f}'
+                  .format(np.std(img), img.min(), img.max()))
+        # convert labels to one-hot if not already
+        if lbl:
+            if isinstance(lbl[0], int):
+                lbl = one_hot_encode(lbl)
+        return img, msk, lbl
diff --git a/utils/__init__.py b/utils/__init__.py
new file mode 100644
index 0000000..2e789cd
--- /dev/null
+++ b/utils/__init__.py
@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+# -----------------------------------------------------------------------------
+# Copyright (C) Software Competence Center Hagenberg GmbH (SCCH)
+# All rights reserved.
+# -----------------------------------------------------------------------------
+# This document contains proprietary information belonging to SCCH.
+# Passing on and copying of this document, use and communication of its
+# contents is not permitted without prior written authorization.
+# -----------------------------------------------------------------------------
+# Created on : 12/07/2017 13:59 $
+# by : shepeleva $
+# SVN : $
+#
+
+# --- imports -----------------------------------------------------------------
diff --git a/utils/gradcam/GradCAM.py b/utils/gradcam/GradCAM.py
new file mode 100644
index 0000000..9bc4ee3
--- /dev/null
+++ b/utils/gradcam/GradCAM.py
@@ -0,0 +1,169 @@
+# Copyright (C) Software Competence Center Hagenberg GmbH (SCCH)
+# All rights reserved.
+# -----------------------------------------------------------------------------
+# This document contains proprietary information belonging to SCCH.
+# Passing on and copying of this document, use and communication of its
+# contents is not permitted without prior written authorization.
+# -----------------------------------------------------------------------------
+# Created on : 30/08/2018 11:06 $
+# by : szanto $
+# SVN : $
+#
+
+# --- imports -----------------------------------------------------------------
+
+import os
+import numpy as np
+import cv2
+
+np.seterr(divide='ignore', invalid='ignore')
+
+def single_chan_to_three(img):
+    """
+    Convert a single channel image to 3 channels
+    :param img: single channel image
+    :return:
+    """
+    im = img.reshape((img.shape[0], img.shape[1]))
+    im3 = np.full((img.shape[0], img.shape[1], 3), 0.0, dtype=np.float32)
+    im3[..., 0] = im
+    im3[..., 1] = im
+    im3[..., 2] = im
+    return im3
+
+
+def grad_cam_plus_plus(params, cl):
+    """
+    Grad-CAM++ implementation, sources in the readme
+    :param params: required inputs for the algorithm
+    :param cl: number of the inspected layer
+    :return:
+    """
+
+    # restructure the given parameters
+    images = params[0]
+    outputs = params[2][cl]
+    gb_vals_ = params[1]
+    first_derivatives_ = params[3][cl]
+    second_derivatives_ = params[4][cl]
+    third_derivatives_ = params[5][cl]
+
+    # return values
+    merged_imgs = []
+    cams = []
+    merged_gb_imgs = []
+    gb_grads_vals = []
+
+    # go through the batch of the images
+    for i in range(images.shape[0]):
+        # get the relevant data for the image
+        image = images[i]
+        output = outputs[i]
+        gb_vals = gb_vals_[i]
+        first_derivatives = first_derivatives_[i]
+        second_derivatives = second_derivatives_[i]
+        third_derivatives = third_derivatives_[i]
+
+        # image parameters width, height channels
+        img_w = image.shape[0]
+        img_h = image.shape[1]
+        img_c = image.shape[2]
+
+        # calculate the sensitivity based on the Grad-CAM++ algorithm
+        # magic
+        global_sum = np.sum(output.reshape((-1, first_derivatives.shape[2])), axis=0)
+        alpha_num = second_derivatives
+        alpha_denom = second_derivatives * 2.0 + third_derivatives * global_sum.reshape(
+            (1, 1, first_derivatives.shape[2]))
+        alpha_denom = np.where(alpha_denom != 0.0, alpha_denom, np.ones(alpha_denom.shape))
+        alphas = alpha_num / alpha_denom
+        weights = np.maximum(first_derivatives, 0.0)
+        alphas_threshold = np.where(weights, alphas, 0.0)
+        alpha_normalization_constant = np.sum(np.sum(alphas_threshold, axis=0), axis=0)
+        alpha_normalization_constant_processed = np.where(alpha_normalization_constant != 0.0,
+                                                          alpha_normalization_constant,
+                                                          np.ones(alpha_normalization_constant.shape))
+        alphas /= alpha_normalization_constant_processed.reshape((1, 1, first_derivatives.shape[2]))
+        deep_linearization_weights = np.sum((weights * alphas).reshape((-1, first_derivatives.shape[2])), axis=0)
+        grad_CAM_map = np.sum(deep_linearization_weights * output, axis=2)
+
+        # normalisation and upscaling
+        eps = 1e-5
+        cam = np.maximum(grad_CAM_map, eps)
+        cam = cam / np.max(cam)
+        cam = cv2.resize(cam, (img_w, img_h))
+
+        # guided backpropagation
+        gb_grads_val = gb_vals
+        gb_grads_val -= np.min(gb_grads_val)
+        gb_grads_val /= gb_grads_val.max()
+        gb_grads_val = gb_grads_val.reshape((img_w, img_h, img_c))
+
+        # convert image to 3chan format if needed
+        if img_c == 1:
+            gb_grads_val = single_chan_to_three(gb_grads_val)
+            image = single_chan_to_three(image)
+
+        # generating the Grad-CAM heatmap
+        merged_gb_img = np.dstack((
+            gb_grads_val[:, :, 0] * cam,
+            gb_grads_val[:, :, 1] * cam,
+            gb_grads_val[:, :, 2] * cam,
+        ))
+
+        merged_gb_img *= 255
+        merged_gb_img = np.clip(merged_gb_img, 0, 255).astype('uint8')
+
+        gb_grads_val *= 255
+        gb_grads_val = np.clip(gb_grads_val, 0, 255).astype('uint8')
+
+        cam = cv2.applyColorMap(np.uint8(255 * cam), cv2.COLORMAP_JET)
+
+        # merging the heatmap and the image
+        im = np.uint8(image * 255).reshape(img_w, img_h, 3)
+        img = im
+        img -= np.min(img)
+        img = np.minimum(img, 255)
+        merged_img = np.float32(cam) + np.float32(img)
+        merged_img = 255 * merged_img / np.max(merged_img)
+        merged_img = np.uint8(merged_img)
+
+        merged_imgs.append(merged_img)
+        cams.append(cam)
+        gb_grads_vals.append(gb_grads_val)
+        merged_gb_imgs.append(merged_gb_img)
+
+    return merged_imgs, cams, merged_gb_imgs, gb_grads_vals
+
+
+def create_folder(path):
+    """
+    Create a folder if it is not exist
+    :param path: path of the folder
+    :return:
+    """
+    if not os.path.exists(path):
+        os.makedirs(path)
+
+
+def save_gradcam_data(data, data_dir, img_num, layers):
+    """
+    Save data generated with Grad-CAM to files
+    :param data: Grad-CAM data in a format: [captured layers: ([[Grad-CAM], [heatmap], [Guided Grad-CAM], [Guided Backprogation]], original image)]
+    :param data_dir: path, wehere the files should be saved
+    :param img_num: number or id of the image
+    :param layers: number of the convolutinal layers in the network
+    :return:
+    """
+    for i in range(len(data)):
+        l_idx = layers - i
+
+        [merged_imgs, cams, merged_gb_imgs, gb_grads_vals], original_img = data[i]
+        create_folder('{}/gradcam/img_{}'.format(data_dir, img_num))
+
+        cv2.imwrite('{}/gradcam/img_{}/heatmap_{}.jpg'.format(data_dir, img_num, l_idx), cams[0])
+        cv2.imwrite('{}/gradcam/img_{}/gradcam_{}.jpg'.format(data_dir, img_num, l_idx), merged_imgs[0])
+        cv2.imwrite('{}/gradcam/img_{}/guided_gradcam_{}.jpg'.format(data_dir, img_num, l_idx), merged_gb_imgs[0])
+        if i == 0:
+            cv2.imwrite('{}/gradcam/img_{}/original.jpg'.format(data_dir, img_num), original_img[0] * 255)
+            cv2.imwrite('{}/gradcam/img_{}/guided_backpropagation.jpg'.format(data_dir, img_num), gb_grads_vals[0])
diff --git a/utils/gradcam/__init__.py b/utils/gradcam/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/utils/gradcam/readme.md b/utils/gradcam/readme.md
new file mode 100644
index 0000000..d06184a
--- /dev/null
+++ b/utils/gradcam/readme.md
@@ -0,0 +1,19 @@
+# Grad-CAM integration
+
+### Sources
+* Original paper: [https://arxiv.org/abs/1610.02391](https://arxiv.org/abs/1610.02391)
+* Grad-CAM++ paper: [https://arxiv.org/pdf/1710.11063.pdf](https://arxiv.org/pdf/1710.11063.pdf)
+* Grad-CAM++ original implementation: [https://github.com/adityac94/Grad_CAM_plus_plus](https://github.com/adityac94/Grad_CAM_plus_plus)
+
+## Usage
+### Preparing the network
+* The 'nets' parameter of the network should contain the convolutional layers that can be relevant for Grad-CAM
+### Configuration
+* gradcam_record: True / False
+* gradcam_layers: number of the relevant layers, in backward order (1 means only the last convolutional layer will be inspected)
+* gradcam_layers_max: the number of the convolutional layers in the network (used only for naming)
+* long_summary should be enabled at training
+
+## Example
+* network: ConvNet_mnist
+* configuration: config_ConvNet_mnist
\ No newline at end of file
diff --git a/utils/utils.py b/utils/utils.py
new file mode 100644
index 0000000..7f4317b
--- /dev/null
+++ b/utils/utils.py
@@ -0,0 +1,111 @@
+#!/usr/bin/env python
+# -----------------------------------------------------------------------------
+# Copyright (C) Software Competence Center Hagenberg GmbH (SCCH)
+# All rights reserved.
+# -----------------------------------------------------------------------------
+# This document contains proprietary information belonging to SCCH.
+# Passing on and copying of this document, use and communication of its
+# contents is not permitted without prior written authorization.
+# -----------------------------------------------------------------------------
+# Created on : 2/20/2019 1:12 PM $ 
+# by : shepeleva $ 
+# SVN  $
+#
+
+# --- imports -----------------------------------------------------------------
+
+import os
+import cv2
+import time
+import cython
+from scipy.misc import imresize
+# from skimage.transform import resize
+import numpy as np
+from numba import jit, vectorize, cuda
+
+
+def one_hot_encode(labels):
+    """
+    Convert labels to one-hot
+    :param labels:
+    :return:
+    """
+    if not isinstance(labels[0], list):
+        mx = max(labels)
+        y = []
+        for i in range(len(labels)):
+            f = [0] * (mx + 1)
+            f[labels[i]] = 1
+            y.append(f)
+        return y
+    else:
+        return labels
+
+
+@jit
+def resize_images_gpu(x, img_size):
+    # return cv2.resize(x, (img_size[1], img_size[0]), interpolation=cv2.INTER_LINEAR)
+    if x.shape == img_size:
+        return x
+    else:
+        return imresize(x, (img_size[0], img_size[1]), interp='nearest')
+
+@jit
+def expand_dims(x, img_size):
+    # return np.expand_dims(np.expand_dims(resize_images_gpu(x, img_size), axis=0), axis=-1)
+
+    return np.expand_dims(np.expand_dims(x, axis=0), axis=-1)
+
+@jit
+def resize_images_cpu(x, img_size):
+    return cv2.resize(x, (img_size[1], img_size[0]), interpolation=cv2.INTER_LINEAR)
+
+
+@cuda.jit
+def preprocess_image(im_file, img_size):
+    if img_size[2] == 3:
+        img = cv2.imread(im_file, cv2.IMREAD_COLOR)
+    else:
+        img = cv2.imread(im_file, cv2.IMREAD_GRAYSCALE)
+    image = resize_images_gpu(img, img_size)
+    return image
+
+def path_walk(path):
+    path_list = []
+    for dirpath, _, filenames in os.walk(path):
+        for f in filenames:
+            if f.lower().endswith(tuple(['.jpg', '.jpeg', '.png'])):
+                path_list.append(os.path.abspath(os.path.join(dirpath, f)))
+    return path_list
+
+
+def log_loss_accuracy(accuracy, accuracy_type, task_type, num_classes, multi_task):
+    if isinstance(accuracy_type, list) and (len(accuracy_type) >= 2):
+        acc_str = ''
+        for k in range(len(accuracy_type)):
+            acc_str += '{:s} '.format(accuracy_type[k])
+            for i in range(num_classes):
+                acc_str += 'lbl_{:d}: {:.3f} '.format(i, accuracy[k][i])
+    else:
+        if isinstance(accuracy_type, list):
+            accuracy_type = accuracy_type[0]
+        acc_str = '{:s}'.format(accuracy_type)
+        if task_type == 'classification':
+            if multi_task:
+                acc_str += 'task_1: {:.3f} task_2: {:.3f} '.format(accuracy[0], accuracy[1])
+            else:
+                acc_str += 'lbl: {:.3f} '.format(accuracy)
+        elif task_type == 'segmentation':
+            acc_str += 'lbl: {:.3f} '.format(accuracy)
+            # for i in range(num_classes):
+            #     acc_str += 'lbl_{:d}: {:.3f} '.format(i, accuracy[i])
+
+    return acc_str
+
+
+# def create_ckpt_data(file_path):
+#     if not os.path.exists(file_path):
+#         # create directory
+#         os.makedirs(file_path)
+#
+#     return "{}/model.ckpt".format(file_path)
\ No newline at end of file